Arduino पर int से स्ट्रिंग को कैसे परिवर्तित करें?

Question

मैं एक int, n, एक स्ट्रिंग में कैसे परिवर्तित करूं ताकि जब मैं इसे धारावाहिक पर भेजूं, तो इसे स्ट्रिंग के रूप में भेजा जाता है?

इस तरह

int ledPin=13; 
int testerPin=8; 
int n=1; 

char buf[10]; 

void setup() 
{ 
    pinMode(ledPin, OUTPUT); 
    pinMode(testerPin, OUTPUT); 
    Serial.begin(115200); 
} 

void loop() 
{ 
    digitalWrite(ledPin, HIGH); 
    sprintf(buf, "Hello!%d", n); 
    Serial.println(buf); 
    delay(500); 
    digitalWrite(ledPin, LOW); 
    delay(500); 

    n++; 
} 

Answer 1

उपयोग::

String myString = String(n); 

आप अधिक उदाहरण here पा सकते हैं

यह वही है मैं अब तक है।

Answer 2

आप बस कर सकते हैं:

Serial.println(n); 

जो स्वचालित रूप से एक ASCII स्ट्रिंग के लिए n परिवर्तित कर देंगे। the documentation for Serial.println() देखें।

Answer 3

पहले उदाहरण में, शास्त्रीय सी स्ट्रिंग का उपयोग किया जा रहा है: यह शून्य (एनयूएल चरित्र) द्वारा समाप्त वर्णों की एक सरणी है। अन्य उदाहरण स्ट्रिंग क्लास, एक सी ++ वर्ग का उपयोग करते हैं जो मैं खिलौना उदाहरणों और छोटे डेमो को छोड़कर दूर तक चलाऊंगा। यह उन तरीकों से स्मृति को रिसाव करता है जो भविष्यवाणी करने में इतना आसान नहीं हैं, और बोर्ड के रहस्यमय लॉकअप की ओर जाता है।

Answer 4

यह स्ट्रिंग में int (हस्ताक्षरित 16-बिट पूर्णांक) को परिवर्तित करने के लिए गति-अनुकूलित समाधान है।

यह कार्यान्वयन डिवीजन का उपयोग करने से बचाता है क्योंकि 8-बिट एवीआर के लिए उपयोग किया जाता है क्योंकि Arduino के पास कोई हार्डवेयर डीआईवी निर्देश नहीं है, संकलक समय-उपभोग करने वाले पुनरावर्तक घटाव में विभाजन का अनुवाद करता है। इस प्रकार सबसे तेज़ समाधान स्ट्रिंग बनाने के लिए सशर्त शाखाओं का उपयोग कर रहा है।

गतिशील आवंटन से बचने के लिए रैम में शुरुआत से तैयार एक निश्चित 7 बाइट बफर तैयार किया गया। चूंकि यह केवल 7 बाइट्स है, इसलिए निश्चित RAM उपयोग की लागत को न्यूनतम माना जाता है। कंपाइलर की सहायता के लिए, हम स्पीड-अप निष्पादन के लिए परिवर्तनीय घोषणा में रजिस्टर संशोधक जोड़ते हैं।

char _int2str[7]; 
char* int2str(register int i) { 
    register unsigned char L = 1; 
    register char c; 
    register boolean m = false; 
    register char b; // lower-byte of i 
    // negative 
    if (i < 0) { 
    _int2str[ 0 ] = '-'; 
    i = -i; 
    } 
    else L = 0; 
    // ten-thousands 
    if(i > 9999) { 
    c = i < 20000 ? 1 
     : i < 30000 ? 2 
     : 3; 
    _int2str[ L++ ] = c + 48; 
    i -= c * 10000; 
    m = true; 
    } 
    // thousands 
    if(i > 999) { 
    c = i < 5000 
     ? (i < 3000 
      ? (i < 2000 ? 1 : 2) 
      : i < 4000 ? 3 : 4 
     ) 
     : i < 8000 
     ? (i < 6000 
      ? 5 
      : i < 7000 ? 6 : 7 
     ) 
     : i < 9000 ? 8 : 9; 
    _int2str[ L++ ] = c + 48; 
    i -= c * 1000; 
    m = true; 
    } 
    else if(m) _int2str[ L++ ] = '0'; 
    // hundreds 
    if(i > 99) { 
    c = i < 500 
     ? (i < 300 
      ? (i < 200 ? 1 : 2) 
      : i < 400 ? 3 : 4 
     ) 
     : i < 800 
     ? (i < 600 
      ? 5 
      : i < 700 ? 6 : 7 
     ) 
     : i < 900 ? 8 : 9; 
    _int2str[ L++ ] = c + 48; 
    i -= c * 100; 
    m = true; 
    } 
    else if(m) _int2str[ L++ ] = '0'; 
    // decades (check on lower byte to optimize code) 
    b = char(i); 
    if(b > 9) { 
    c = b < 50 
     ? (b < 30 
      ? (b < 20 ? 1 : 2) 
      : b < 40 ? 3 : 4 
     ) 
     : b < 80 
     ? (i < 60 
      ? 5 
      : i < 70 ? 6 : 7 
     ) 
     : i < 90 ? 8 : 9; 
    _int2str[ L++ ] = c + 48; 
    b -= c * 10; 
    m = true; 
    } 
    else if(m) _int2str[ L++ ] = '0'; 
    // last digit 
    _int2str[ L++ ] = b + 48; 
    // null terminator 
    _int2str[ L ] = 0; 
    return _int2str; 
} 

// Usage example: 
int i = -12345; 
char* s; 
void setup() { 
    s = int2str(i); 
} 
void loop() {} 

यह स्केच AVR-जीसीसी जो Arduino v1.0.5 के साथ बंडल (int2str समारोह के आकार में ही 594 बाइट्स) का उपयोग कर कोड के 1,082 बाइट्स संकलित किया गया है। 2,398 बाइट्स में संकलित स्ट्रिंग ऑब्जेक्ट का उपयोग करके समाधान के मुकाबले, यह कार्यान्वयन आपके कोड आकार को 1.2 Kb तक कम कर सकता है (माना जाता है कि आपको किसी अन्य स्ट्रिंग की ऑब्जेक्ट विधि की आवश्यकता नहीं है, और आपका नंबर हस्ताक्षरित int प्रकार पर सख्त है)।

यह फ़ंक्शन इसे उचित असेंबलर कोड में लिखकर अनुकूलित किया जा सकता है।

Answer 5

समाधान बहुत बड़ा है। इस सरल कोशिश करो। कृपया 7+ वर्ण बफर प्रदान करें, कोई चेक नहीं बनाया गया।

char *i2str(int i, char *buf){ 
    byte l=0; 
    if(i<0) buf[l++]='-'; 
    boolean leadingZ=true; 
    for(int div=10000, mod=0; div>0; div/=10){ 
    mod=i%div; 
    i/=div; 
    if(!leadingZ || i!=0){ 
     leadingZ=false; 
     buf[l++]=i+'0'; 
    } 
    i=mod; 
    } 
    buf[l]=0; 
    return buf; 
} 

आसानी से अगर आप सूचकांक 'l' त्यागने और सीधे बफर को बढ़ा देते है, वापस बफर के अंत देने के लिए संशोधित किया जा सकता है।

Answer 6

stdlib.h

char buffer[7];   //the ASCII of the integer will be stored in this char array 
itoa(-31596,buffer,10); //(integer, yourBuffer, base) 

Answer 7

में itoa() समारोह शामिल का उपयोग आप सिर्फ इस तरह एक स्ट्रिंग वस्तु के आसपास लपेट की जरूरत है:

String numberString = String(n); 

तुम भी कर सकते हैं:

String stringOne = "Hello String";      // using a constant String 
String stringOne = String('a');      // converting a constant char into a String 
String stringTwo = String("This is a string");  // converting a constant string into a String object 
String stringOne = String(stringTwo + " with more"); // concatenating two strings 
String stringOne = String(13);      // using a constant integer 
String stringOne = String(analogRead(0), DEC);  // using an int and a base 
String stringOne = String(45, HEX);     // using an int and a base (hexadecimal) 
String stringOne = String(255, BIN);     // using an int and a base (binary) 
String stringOne = String(millis(), DEC);    // using a long and a base