Diviser un entier sous forme de chaîne (pas bien expliqué mais…)

En C, un caractère[] est en fait une chaîne : ajoutez une valeur nulle ‘\0’ à la fin et c’est une chaîne à toutes fins pratiques – celles-ci sont appelées “chaînes terminées par une valeur nulle”.

Pour afficher la chaîne, vous devrez attribuer à readOut[a] plutôt que de le lire et divisez votre valeur en caractères – ce qui n’est pas difficile mais dépendra de ce dans quoi l’entrée est réellement stockée.

Google pour “C convertir un entier en chaîne” et “C convertir un entier en chaîne hexadécimale” pour quelques idées.

Selon les types de données présentés, le capteur stocke le résultat sous forme de nombre binaire dans un entier de 16 bits. La première étape serait de découvrir quelles sont les valeurs maximale et minimale de z_gyro. S’il s’avère qu’il s’agit de valeurs à 4 chiffres avec un signe, au moins 6 caractères seront nécessaires pour la conversion en chaîne de caractères. Si le buffer readOut est déclaré avec 8 octets, il n’y a aucun mal à utiliser la longueur de la chaîne pour la sortie.
Je suggère de convertir d’abord la valeur entière en chaîne. Si vous pouvez utiliser la commande C sprintf(), c’est simple :

sprintf(readOut, "%d", sensor.value.z_gyro);

Utilisez ensuite une boucle for pour transmettre tous les caractères individuellement à la fin de la chaîne à la fonction print().

for (int i = 0; i < strlen(readOut); i++)
    lcd.print(readOut[i]);

Si la fonction sprintf() n’est pas disponible, itoa() serait toujours possible ou vous pourriez programmer vous-même la conversion en boucle.

Avec l’information supplémentaire “sprintf, en fait toutes les fonctions f (impression, scan) n’existent pas !” il serait possible d’écrire vous-même une fonction générique simple. Cela pourrait ressembler à ceci :

void intToCString(int num, char* str) {
    if (num < 0) {
        *str++ = '-';
        num = -num;
    }

    int divisor = 1;
    while (num / divisor > 9) {
        divisor *= 10;
    }

    while (divisor > 0) {
        *str++ = '0' + (num / divisor);
        num %= divisor;
        divisor /= 10;
    }

    *str = '\0';
}

Si vous n’avez pas itoa, vous pouvez utiliser sprintf(), mais c’est assez lourd pour une tâche aussi légère. Ce qui suit devrait fonctionner pour vous

int magnitude(int x)
{
    int i;
    x = abs(x);
    for(i = 0; x > 0; x /= 10, ++i);
    return i;
}

char *i2cstr(int i, char *buff) 
{
    int n = magnitude(i);

    /*  The following is only needed if i may be negative */ 
    int last = 0;
    if(i < 0) {
        i *= -1;
        buff[0] = '-';
        n += 1;
        last = 1;
    }
    /* end of dealing with negative numbers */
    
    buff[n] = 0;
    for(--n; n >= last; --n ) {
        buff[n] = i%10 + '0';
        i/= 10;
    }
    return buff;
}

Attention : paramètre buff car i2cstr() doit être de taille appropriée. Pour uint16_t, cela fait 6 caractères, y compris le nul de fin.

Si vous avez juste besoin d’afficher la valeur, vous n’avez pas besoin de la convertir d’abord en chaîne.

void putaschar(int16_t n)
{
    if( n == 0 ) {
        /* special case for n == 0 */
        putchar('0');
    } else {
        if(n < 0) {
            /* oputput sign, and make n +ve */
            putchar('-');
            n *= -1;
        }

        /* determine largest power of 10 smaller than n */
        int16_t divisor = 10000;  /* maximum power of 10 that will fit in int16 */
 
        while( n / divisor == 0) {
            divisor /= 10;
        }

        /* send chars to the output device */
        do {
            putchar(n/divisor + '0');
            n %= divisor;
            divisor /= 10;
        } while(divisor > 0);
    }
}

dans ce qui précède, supposons que putchar() représente toute la magie que vous devez faire pour envoyer un caractère à l’écran.