Comment convertir un int en string sur un Arduino?

Comment puis-je convertir un int, n, à une chaîne de sorte que lorsque je l'envoyer au cours de la série, il est envoyé comme une chaîne de caractères?

C'est ce que j'ai à ce jour:

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

?tous les commentaires ici sont partis....ce qui s'est passé?
rend votre objet exécutable ~1000 octets plus grande, de sorte que vous pouvez ne pas l'utiliser si la taille est un problème." playground.arduino.cc/Main/Printf

InformationsquelleAutor user947659 | 2011-10-26

arduino

119

Utiliser comme ceci:
```
String myString = String(n);
```
Vous pouvez trouver plus d'exemples ici.
- Vous n'avez pas besoin d'utiliser un objet de type String, le numéro de Série.imprimer ou println déjà les convertir !
- Je suis à la recherche de la façon de convertir 97 dans 'un' caractère ou 65 ans dans 'Un' caractère. Je veux dire ASCII nombre de caractères. J'ai trouvé cette façon ne fonctionne pas.
- Vous pouvez utiliser le caractère - bar = 97; il va travailler.
InformationsquelleAutor Cassio

utiliser le itoa() fonction incluse dans stdlib.h

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

InformationsquelleAutor

20

Vous pouvez tout simplement faire:
```
Serial.println(n);
```
qui va le transformer en n à une chaîne de caractères ASCII automatiquement. Voir la documentation de numéro de Série.println().

InformationsquelleAutor Matthew Murdoch

Vous suffit de l'enrouler autour d'un objet de type String comme ceci:

String numberString = String(n);

Vous pouvez également le 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

InformationsquelleAutor PedroD

C'est la vitesse de solution optimisée pour la conversion de int (entier signé de 16 bits) dans la chaîne.

Cette mise en œuvre permet d'éviter d'utiliser de la division depuis 8 bits AVR utilisé pour Arduino n'a pas de matériel DIV instruction, le compilateur traduire division en temps répétitif soustractions. Ainsi, la solution la plus rapide est conditionnelle à l'aide de branches pour construire la chaîne.

Fixe de 7 octets de la mémoire tampon, préparé à partir de début dans la RAM pour éviter l'allocation dynamique. Puisque c'est seulement 7 octets, le coût fixe de l'utilisation de la RAM est considéré comme minimum. Pour aider le compilateur, nous ajoutons inscrire le modificateur dans la déclaration de la variable de la vitesse d'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é à 1,082 octets de code à l'aide de avr-gcc qui livré avec Arduino v1.0.5 (taille de int2str fonction elle-même est 594 octets). Par rapport à une solution à l'aide de la Chaîne de l'objet qui les a rassemblées dans 2,398 octets, cette mise en œuvre peut réduire votre taille de code de 1,2 Kb (supposé que vous avez besoin d'aucun autre de la Chaîne de méthode d'objet, et votre numéro est stricte signés type int).

Cette fonction peut être optimisé en outre par écrit, dans un code en langage assembleur.

Une approche alternative pour éviter la DIV est de multiplier par (2^N/10) et de passer ensuite à droite par N bits. Ainsi pour N=16, x/10 ~= (x*6554)>>16. Assez près pour que la plupart des chiffres, de toute façon.

InformationsquelleAutor vcc2gnd

1

La solution est beaucoup trop grand. Essayez ce simple. Veuillez fournir une 7+ tampon de caractère, pas de chèque.
```
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 en retour à la fin de tampon, si vous jetez un "indice de l' et l'incrément de la mémoire tampon directement.

InformationsquelleAutor Enkryptikon
0

Voici ci-dessous un auto composé myitoa() qui est de loin plus petit dans le code, et se réserve un tableau FIXE de 7 (y compris la résiliation 0) char *machaine, qui est souvent souhaitable. Il est évident que l'on peut construire le code de caractère-maj au lieu de cela, si on besoin d'une longueur variable de sortie de chaîne.
```
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;
}
```
InformationsquelleAutor David Svarrer
0
```
Serial.println(val) 
Serial.println(val, format)
```
de plus, vous pouvez visiter le site de l'arduino
https://www.arduino.cc/en/Serial/Println

voulez que cela va vous aider.
merci!

InformationsquelleAutor shubham kumar
-1

dans le premier exemple, un classique de la chaîne C est utilisé: il s'agit simplement d'un tableau de caractères terminée par un zéro (NUL personnage).
d'autres exemples d'utilisation de la classe String, une classe C++ que j'allais diriger loin de l'exception de toy exemples et des petites démos. Il ya des fuites de mémoire dans les moyens qui ne sont pas si faciles à prévoir, et conduit à de mystérieux problèmes de blocage du conseil d'administration.
- Alors, quelle est votre solution?
InformationsquelleAutor Walter Aprile

Vous devez vous connecter pour publier un commentaire.