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




arduino uno pin diagram (7)

मैं एक 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++;
}

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

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

गतिशील आवंटन से बचने के लिए रैम में शुरुआत से तैयार एक निश्चित 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() {}

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

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


समाधान बहुत बड़ा है। इस सरल कोशिश करो। कृपया 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;
}

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


stdlib.h में शामिल itoa() फ़ंक्शन का उपयोग करें

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

आपको बस इसे स्ट्रिंग ऑब्जेक्ट के चारों ओर लपेटने की आवश्यकता है:

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

इस तरह प्रयोग करें:

String myString = String(n);

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


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

Serial.println(n);

जो n को एएससीआईआई स्ट्रिंग में स्वचालित रूप से परिवर्तित करेगा। Serial.println() लिए प्रलेखन देखें।


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