comment faire pour convertir un entier en chaîne de caractères?

J'ai une fonction c avec le prototype suivant

extern void lcd_puts(const char *s);

dans mon autre fonction que j'ai quelque chose comme ce

send_to_lcd() {
  uint8_t count = 10
  lcd_puts(count);
}

ma question est comment puis-je convertir compter un pointeur de chaîne pour être en mesure de l'envoyer à lcd_puts
qui doit imprimer le comte sur un écran lcd

grâce

Savez-vous que les bibliothèques-vous? Avez-vous des itoa ou sprintf?

OriginalL'auteur w_hoami | 2011-09-05

c microcontroller

1

sprintf permet de formater une chaîne de caractères

Exemple rapide:
```
char buf[50];
uint8_t count = 10;
sprintf(buf,'%d',count);

lcd_puts(buf);
```
Je suis juste obtenir mes mains mouillées à cette uC chose, de sorte que les performances pour moi n'est pas un problème dès maintenant. Je l'ai essayé et il a travaillé hors de la boîte. Merci à tous les autres pour leurs commentaires et de me mettre au courant des problèmes de performances.

OriginalL'auteur jyore
6

Sur un microcontrôleur, vous devez être au moins un peu inquiet au sujet de la performance (ce qui exclut sprintf), voire la division est une opération très coûteuse sur ces puces. Donc, vous voulez un code optimisé pour un microcontrôleur.

J'ai écrit quelques-uns ici: http://ideone.com/SsEUW (aurez besoin d'un peu de changements pour une utilisation avec C-style de chaînes au lieu de C++, mais la méthode doit être clair)

Vous n'avez pas nécessairement besoin d'être inquiet. Cela dépend si le temps est critique. Préférez standard-routines de la bibliothèque de plus de roulement de votre propre jusqu'à ce que vous savez que vous devez.
comme suggéré par Owen pourrait être faisable, mais sprintf est un horrible choix sur un microcontrôleur.
Jusqu'à ce que l'OP ajoute les mots "j'ai besoin d'elle pour être rapide" à sa question, je m'en tiens à ma réponse que sprintf est le meilleur choix; il est largement pris en charge de la bibliothèque standard de la fonction (on ne peut pas dire la même chose pour itoa).
Oui, probablement sprint serait parfait, s'il est écrit à un écran LCD, c'est pas comme si tu vas voir les 1 ms (1000 cycles sur 1MHz proc) ou si le retard. Soyez prudent avec ce que parce que beaucoup de bibliothèques intégrées utiliser un stripped-down, non-standard sprintf qui ne pourrait pas faire ce que vous attendez (comme toujours d'impression au format Hexadécimal (PIC de %ld)), ou rien du tout
Il est à la recherche d'un C les réponses.

OriginalL'auteur Ben Voigt
5

Cela dépend de ce que lcd_puts fait avec son argument. Une possibilité est comme suit:
```
void send_to_lcd(uint8_t count)
{
    char str[SOME_CONSERVATIVE_MAX_LENGTH];
    sprintf(str, "%d", count);  //You might also snprintf() if it's available
    lcd_puts(str);
}
```
Mais n'oubliez pas que str est hors de portée dès que send_to_lcd() retourne. Donc, si lcd_puts se "souvient" de son argument d'entrée, ce qui aura un comportement indéterminé.

Si c'est le cas, vous devrez malloc un tampon de chaîne à la place. Mais ensuite, vous aurez besoin de se rappeler à free() à un certain point, et ça fait plutôt désordre.

Ou, si vous n'avez pas malloc(), vous pouvez utiliser un static tampon (mais je ne pense pas que lcd_puts enregistre l'argument -- il est probablement juste de réglage de broches numériques).
Ouais, probablement pas. J'étais justement en train de préparer pour le pire des cas, où l'écran LCD n'est pas mis à jour jusqu'à plus tard ou quelque chose.
En tant que comte est essentiellement un petit entier non signé, %s comme un format à sprintf est susceptible d'accéder à violer.
Bonne prise, merci!
Pour microcontrôleur projets que j'ai éviter de malloc.

OriginalL'auteur Oliver Charlesworth

Cela semble être une approche raisonnable.

#include <stdint.h>
#include <stdio.h>

const char *u82s(uint8_t count)
{
    static char aString[4];

    aString[3] = '#include <stdint.h>
#include <stdio.h>
const char *u82s(uint8_t count)
{
static char aString[4];
aString[3] = '\0';
aString[2] = (count % 10) + '0';  count /= 10;
aString[1] = (count % 10) + '0';  count /= 10;
aString[0] = (count % 10) + '0';
return aString;
}
int main(void)
{
uint8_t z = UINT8_MAX;
do
{
z++;
printf("%s\n", u8ts(z));
}
while (z != UINT8_MAX);
return 0;
}
';
    aString[2] = (count % 10) + '0';  count /= 10;
    aString[1] = (count % 10) + '0';  count /= 10;
    aString[0] = (count % 10) + '0';

    return aString;
}

int main(void)
{
    uint8_t z = UINT8_MAX;

    do
    {
        z++;
        printf("%s\n", u8ts(z));
    }
    while (z != UINT8_MAX);

    return 0;
}

Vous avez écrit un joli court (très lent) de la version, qui s'appelait alors printf de toute façon?
Le printf se produit dans l'unité de test, pas la fonction. La question a été soulevée pour une méthode pour transformer un u_int8_t dans un char *. La fonction n'est que, sans les dépenses de frais généraux qui seraient associés à la famille printf.
renommé fonction pour indiquer son intention.
La fonction u82s() comme l'écrit n'est pas réentrant, car il utilise une chaîne statique. Peut-être une meilleure conception serait de fournir la chaîne comme argument. De cette façon, la fonction peut format le numéro dans n'importe quel endroit d'une longue chaîne. (Mais alors, il ne faut pas écrire '\0' à la fin). Je ne suis pas d'accord avec le précédent commentaire que cette fonction est lente. En fait, c'est peut-être un ordre de grandeur plus rapide que snprintf() ou des fonctions similaires. Il est également ordres de grandeur plus petite de la taille du code.
désolé pour mon inexpertise avec le c, mais demande quand exactement l'u82s() la fonction est appelée?

OriginalL'auteur EvilTeach

De prendre votre api.

/* One assumes this is a function that somehow displays a c string on the lcd. */
extern void lcd_puts(const char *s);


send_to_lcd() 
{
  uint8_t count = 10;     /* This is the variable to send to the screen         */ 

  lcd_puts(u82s(count));  /* This creates a string representation of count,     */
}                         /* which is then passed to the lcd_puts function      */
                          /* giving you the result you are after.  You question */
                          /* was how to make a c string out of a uint8.         */
                          /* this is a way to do it.                            */

C'est essentiellement la même que la réponse que vous avez choisi. Convertir la valeur de comptage dans une chaîne c, de sorte que lcd_puts pouvez l'utiliser.

OriginalL'auteur EvilTeach

Pour supprimer les parasites et rangé:

void UART_SendInt( uint16_t num )
{
    #define MAX_LEN         6   //32767 is 6 characters with NULL terminator
    #define BASE_10         10  //Print decimal format

    uint8_t index = MAX_LEN - 1;
    char str[ MAX_LEN ];

    str[ index ] = 'void UART_SendInt( uint16_t num )
{
#define MAX_LEN         6   //32767 is 6 characters with NULL terminator
#define BASE_10         10  //Print decimal format
uint8_t index = MAX_LEN - 1;
char str[ MAX_LEN ];
str[ index ] = '\0';
while( index-- )
{
str[ index ] = ( num % BASE_10 ) + '0'; 
num /= BASE_10;
if( 0 == num )
{
UART_SendStr( &str[ index ] );
break;
}
}
UART_SendStr( "\r\n" );
return;
}
';
    while( index-- )
    {
        str[ index ] = ( num % BASE_10 ) + '0'; 
        num /= BASE_10;

        if( 0 == num )
        {
            UART_SendStr( &str[ index ] );
            break;
        }
    }

    UART_SendStr( "\r\n" );

    return;
}

Je ne peux pas imprimer au-dessus de 32767 mais je pense que c'est quelque chose à faire avec mes options du compilateur.

OriginalL'auteur user1675013

Vous devez vous connecter pour publier un commentaire.