Le compilateur C18 prend en charge la famille number-to-ascii des fonctions C standard dans stdlib.h : itoa () , ltoa () , ultoa () et cetera.

Selon le compilateur / stdlib.h que vous avez, le prototype de fonction pertinent serait:

  extern char * itoa (char * buf, int val, int base); // entier signé char * utoa (char * buf, unsigned val, int base); // unsigned int  

ou

  extern char * itoa (char * buf, int val); // entier signé entier char * utoa (char * buf, unsigned val); // unsigned int  

Si vous recherchiez une méthode C " standard " intégrée relativement robuste pour convertir vos nombres en chaînes ASCII, ces Les fonctions xtoa () seraient celles à utiliser.

Si, d'un autre côté, vous êtes obligé de faire sortir quelques cycles ou octets de mémoire supplémentaires du code final, alors plusieurs des autres réponses à votre question sont la voie à suivre.

J'ai moi-même créé une fonction:

  void writeInteger (unsigned long input) {unsigned long start = 1; compteur long non signé; while (start * 10 < = entrée) start * = 10; pour (compteur = début; compteur > = 1; compteur / = 10) Write1USART (((entrée / compteur)% 10) + 0x30);}  

Vous pouvez essayer une fonction qui utilise la méthode de force brute pour convertir en chaîne. La fonction ci-dessous n'utilise pas d'opérateur de module ni de multiplication. Il renvoie une chaîne.

  / * * Créez une fonction qui renverra une chaîne. * Il accepte 'inputValue' qui est jusqu'à 255, mais vous pouvez en faire un int ou longint ... * ... après avoir fait quelques modifications dans la fonction. * inputValue: 5 7 6 * Chiffres: 1er 2ème 3ème * / unsigned char * returnString (unsigned char inputValue) {static unsigned char traitéesString [4]; // Renvoie une chaîne de 3 chiffres. unsigned char firstDigitCounter = 0; // Compteur de force brute pour le premier chiffre. unsigned char secondDigitCounter = 0; // Compteur de force brute pour le deuxième chiffre. if (inputValue > 99) // Si nous avons un nombre à 3 chiffres, {while (inputValue > 99) // Jusqu'à ce que notre nombre soit à 3 chiffres, soit plus grand que 99, {inputValue - = 100; // Soustraire 100 et .. firstDigitCounter ++; // .. incrémenter le premier chiffre. } while (inputValue > 9) // Jusqu'à ce que notre nombre soit à 3 chiffres, c'est-à-dire plus grand que 9, {inputValue - = 10; // Soustraire 10 et .. secondDigitCounter ++; // .. incrémente le deuxième chiffre. } // Maintenant, nous avons laissé 'inputValue' comme un seul chiffre. traitéesString [0] = firstDigitCounter + 0x30; // Premier chiffre traitéString [1] = secondDigitCounter + 0x30; // Deuxième chiffre traitéString [2] = inputValue + 0x30; // Troisième chiffre traitéString [3] = '\ 0'; // Terminateur de chaîne. } else // Si nous avons un nombre à 2 chiffres, {while (inputValue > 9) // Jusqu'à ce que notre nombre soit à 3 chiffres, c'est-à-dire plus grand que 99, {inputValue - = 10; // Soustraire 10 et .. secondDigitCounter ++; // .. incrémente le deuxième chiffre. } traitéesString [0] = secondDigitCounter + 0x30; // Deuxième chiffre traitéString [1] = inputValue + 0x30; // Troisième chiffre
traitéesString [2] = '\ 0'; // Terminateur de chaîne. } return traitéesString; // Renvoie la chaîne traitée.}  

Pastebin du code ci-dessus.

J'ai déjà utilisé sprintf (); . En plus d'être pratique avec le formatage, je ne suis pas tout à fait sûr qu'il soit rapide et qu'il ait un faible encombrement. Il est livré avec.

  #include <stdio.h>const uint8_t stringLength = 16; char string [stringLength] = {0}; volatile uint32_t Measurement = 12345; sprintf (string, "Mesuré:% lu millisecondes \ n ", mesure); uint8_t charCounter = 0; while ((charCounter < stringLength) et (string [charCounter]! = 0x00)) {serialByteOut (string [charCounter]); // Envoie un seul caractère charCounter ++;}  

Où mesure est un entier 32 bits mis à jour dans un ISR, que je veux imprimer et chaîne est le tampon de sortie. % lu indique qu'un long entier non signé doit être imprimé et \ n est une nouvelle ligne.

L'utilisation est en grande partie la même que pour printf (); La documentation est complète et peut être facilement trouvée sur Internet sur différents sites Web: http://linux.die.net/man/3/sprintf

Vous pouvez essayer ceci:

  void writeInteger (unsigned i) {if (i > 9) writeInteger (i / 10); write1USART (i% 10 + '0');}