Comment convertir int en chaîne sur Arduino?

Comment puis-je convertir un int`` nen une chaîne de sorte que lorsque je l'envoie via le numéro de série, il soit envoyé sous forme de chaîne?

Voici ce que j'ai jusqu'à présent:

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++;
}

Utilisez comme ceci:

String myString = String(n);

Vous pouvez trouver plus d'exemples ici .

utiliser la itoa()fonction incluse dansstdlib.h

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

Vous pouvez simplement faire:

Serial.println(n);

qui se convertira nautomatiquement en chaîne ASCII. Consultez la documentation pourSerial.println() .

Il vous suffit de l'enrouler autour d'un objet String comme celui-ci:

String numberString = String(n);

Vous pouvez également faire:

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

Il s'agit d'une solution à vitesse optimisée pour convertir un entier (entier 16 bits signé) en chaîne.

Cette implémentation évite d'utiliser la division car l'AVR 8 bits utilisé pour Arduino n'a pas d'instruction DIV matérielle, le compilateur traduit la division en soustractions répétitives chronophages. Ainsi, la solution la plus rapide consiste à utiliser des branches conditionnelles pour créer la chaîne.

Un tampon fixe de 7 octets préparé depuis le début dans la RAM pour éviter une allocation dynamique. Comme il ne fait que 7 octets, le coût d'utilisation fixe de la RAM est considéré comme minimum. Pour aider le compilateur, nous ajoutons un modificateur de registre dans la déclaration de variable pour accélérer l'exécution.

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() {}

Cette esquisse est compilée à 1082 octets de code en utilisant avr-gcc qui est fourni avec Arduino v1.0.5 (la taille de la fonction int2str elle-même est de 594 octets). Par rapport à la solution utilisant un objet String compilé en 2398 octets, cette implémentation peut réduire la taille de votre code de 1,2 Ko (en supposant que vous n'avez besoin d'aucune autre méthode d'objet String et que votre nombre est strict au type int signé).

Cette fonction peut être optimisée davantage en l'écrivant dans le code assembleur approprié.

La solution est beaucoup trop grande. Essayez ce simple. Veuillez fournir un tampon de plus de 7 caractères, aucune vérification effectuée.

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;
}

Peut être facilement modifié pour donner l'arrière-plan du tampon, si vous supprimez l'index 'l' et incrémentez le tampon directement.

Voici ci-dessous un myitoa () auto composé qui est de loin plus petit dans le code, et réserve un tableau FIXED de 7 (y compris la terminaison 0) dans char * mystring, ce qui est souvent souhaitable. Il est évident que l'on peut construire le code avec un décalage de caractère à la place, si l'on a besoin d'une chaîne de sortie de longueur variable.

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;
}

Serial.println(val) 
Serial.println(val, format)

pour plus, vous pouvez visiter le site d'arduino https://www.arduino.cc/en/Serial/Println

souhaite que cela vous aide. Merci!

Cela fonctionne simplement pour moi:

int bpm = 60;
char text[256];
sprintf(text, "Pulso: %d     ", bpm);
//now use text as string