मैं एक इंट को, 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++;
}
जवाबों:
itoa()में शामिल फ़ंक्शन का उपयोग करेंstdlib.h
char buffer[7]; //the ASCII of the integer will be stored in this char array
itoa(-31596,buffer,10); //(integer, yourBuffer, base)
आप बस कर सकते हैं:
Serial.println(n);
जो nस्वचालित रूप से एक ASCII स्ट्रिंग में बदल जाएगा । के लिए प्रलेखनSerial.println() देखें ।
आपको बस इसे इस तरह से एक स्ट्रिंग ऑब्जेक्ट के चारों ओर लपेटने की आवश्यकता है:
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
यह int (स्ट्रिंग में हस्ताक्षरित 16-बिट पूर्णांक) को परिवर्तित करने के लिए गति-अनुकूलित समाधान है।
यह कार्यान्वयन विभाजन का उपयोग करने से बचता है क्योंकि Arduino के लिए 8-बिट AVR का उपयोग कोई हार्डवेयर DIV निर्देश नहीं है, संकलक समय विभाजन को दोहराए जाने वाले घटाव में अनुवाद करता है। इस प्रकार सबसे तेज़ समाधान स्ट्रिंग बनाने के लिए सशर्त शाखाओं का उपयोग कर रहा है।
डायनामिक आवंटन से बचने के लिए रैम में शुरुआत से तैयार एक 7 बाइट्स बफर। चूंकि यह केवल 7 बाइट्स है, इसलिए फिक्स्ड रैम उपयोग की लागत न्यूनतम मानी जाती है। संकलक की सहायता करने के लिए, हम गति संशोधन के लिए चर घोषणा में रजिस्टर संशोधक जोड़ते हैं।
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 तक कम कर सकता है (यह मानकर कि आपको किसी अन्य स्ट्रिंग की ऑब्जेक्ट विधि की आवश्यकता नहीं है, और आपका नंबर हस्ताक्षरित इंट प्रकार के लिए सख्त है)।
इस फ़ंक्शन को आगे उचित कोडांतरक कोड में लिखकर अनुकूलित किया जा सकता है।
समाधान बहुत बड़ा है। इस सरल कोशिश करो। कृपया 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;
}
यदि आप सूचकांक 'एल' को त्यागते हैं और बफर को सीधे बढ़ाते हैं, तो बफर के अंतिम छोर को आसानी से संशोधित किया जा सकता है।
Serial.println(val)
Serial.println(val, format)
अधिक के लिए आप arduino की साइट पर जा सकते हैं https://www.arduino.cc/en/Serial/Println
काश यह आपकी मदद करेगा। धन्यवाद!
यहाँ नीचे एक स्वयंभू myitoa () है जो कोड में बहुत छोटा है, और char * मिस्ट्रींग में 7 की FIXED सरणी (0 समाप्त करने सहित) रखता है, जो अक्सर वांछनीय होता है। यह स्पष्ट है कि कोई व्यक्ति चर-लंबाई वाले आउटपुट-स्ट्रिंग की आवश्यकता के बजाय, चरित्र-शिफ्ट के साथ कोड का निर्माण कर सकता है।
void myitoa(int number, char *mystring) {
boolean negative = number>0;
mystring[0] = number<0? '-' : '+';
number = number<0 ? -number : number;
for (int n=5; n>0; n--) {
mystring[n] = ' ';
if(number > 0) mystring[n] = number%10 + 48;
number /= 10;
}
mystring[6]=0;
}
यह मेरे लिए बस काम:
int bpm = 60;
char text[256];
sprintf(text, "Pulso: %d ", bpm);
//now use text as string