Discussion :

[Pete_Rebeat]

Bonjour à tous et merci d'avance pour votre aide.

Voilà, pour commencer, je travaille en C sur microcontroleur (STM32F4), j'essaie donc dans la mesure du possible de limiter mon utilisation des bibliothèques du C.

Je voudrais trouver un moyen de calculer le nombre d'éléments d'un chiffre Hexa (exemple 0x02CFF300). J'ai essayé un truc comme ça qui me paraissait pas mal:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
uint32_t hexatest = 0x02CFF300;
char chaine[20]={'0'};
int longueur = sprintf(chaine,"%x",hexatest);

chaine[0] 2
chaine[0] C
chaine[0] F
chaine[0] F
chaine[0] 3
chaine[0] 0
chaine[0] 0

longueur 7


Le problème est que le premier zéro saute systématiquement dans le tableau et que j'ai donc dans longueur '7', ce qui est faux. Ce premier zéro est tres important dans mon application puisque c'est un quartet passé ensuite à un écran, qui doit savoir que 4 pixels sont vides. Je ne trouve pas d'autre solution pour mesurer le nombre de quartet de mon chiffre Hexa, je bloque, si l'un de vous a une idée ce serait génial.

Merci encore,

[Obsidian]

Bonjour,

Un chiffre hexadécimal représente exactement 4 bits. C'est d'ailleurs pour cela qu'on s'en sert : ça permet de passer immédiatement du binaire à l'hexa et vice-versa sans avoir à faire de calcul et le nombre de bits que l'on obtient reste compatible avec le format des mots binaires utilisées par toutes les machines encore en état de fonctionner.

Pour compter le nombre de chiffres hexa, il te suffit de supprimer des blocs de quatre bits par la droite jusqu'à ce que ton nombre devienne nul :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
    uint32_t hexatest = 0x02CFF300;
    int      count    = 0;
 
    while (hexatest) { count++; hexatest >>=4; }

Maintenant, si tu veux tenir compte des zéros non significatifs, alors c'est le format de « uint32_t » qu'il faut connaître, parce qu'il est fixe. En l'occurrence, uint32_t signifie « entier non signé de 32 bits ». Il est donc toujours formé de 8 chiffres hexadécimaux exactement.

[Bktero]

@Obsidian : tu comptes le nombre de digits utiles, non ? 0x00000000 te donnera 0. 0x0000001 te donnera 1. Ton exemple donnera 7. Or, je pense que Pete_Rebeat voudrait obtenir 8. (EDIT: en fait, c'est ce qu'il y après ton bloc CODE )

Est-ce que sizeof(hexatest) * 8 / 4 ne fait pas l'affaire ?

[ram-0000]

Est-ce que sizeof(hexatest) * 8 / 4 ne fait pas l'affaire ?

voire même sizeof(uint32_t) * 8 / 4 (comme cela, pas de variable locale à déclarer)

[Pete_Rebeat]

Merci pour ces réponses. Ces solutions sont bonnes, sauf qu'elles ne fonctionneront pas pour un nombre avec moins de 8 quartets.

En l'occurence si j'ai une variable du style hexatest=0x02FF3, je voudrais retourner longueur=5, en tenant compte du premier zéro non significatif donc. D'autres idées?

[ram-0000]

une solution bourrin :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
if(nombre <= 0x0000000f) len = 2;
else if(nombre <= 0x000000ff) len = 3;
else if(nombre <= 0x00000fff) len = 4;
...

Si tu n'exécute pas trop souvent ce code, c'est très rapide

C'est bourrin, je vous avais prévenu

[Médinoc]

@Pete_Rebeat: Impossible sans stocker l'information quelque part, car toi seul sais que le nombre est censé être affiché sur 5 chiffres même s'ils ne sont pas significatifs.
Il n'existe pas de type "nombre de 20 bits".

Par contre, tu peux faire une struct hexNumber { int value, int nbBits } pour stocker explicitement le nombre de bits du nombre...

----------------------------------------------------------------

Au passage, cette demande est vraiment bizarre. Pourquoi as-tu besoin d'un tel comportement? Que cherches-tu à faire, au juste?

[Obsidian]

(EDIT: en fait, c'est ce qu'il y après ton bloc CODE )

C'est ma faute, désolé : j'ai posté trop vite et ai édité mon message juste après pour y ajouter le complément. Tu devais donc déjà être en train de lire la première partie. :-)

voire même sizeof(uint32_t) * 8 / 4 (comme cela, pas de variable locale à déclarer)

Ou encore, tant qu'à faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

    (sizeof hexatest) * CHAR_BIT / 4

… comme ça, ça fonctionnera partout ! :-)

Merci pour ces réponses. Ces solutions sont bonnes, sauf qu'elles ne fonctionneront pas pour un nombre avec moins de 8 quartets.

En l'occurence si j'ai une variable du style hexatest=0x02FF3, je voudrais retourner longueur=5, en tenant compte du premier zéro non significatif donc. D'autres idées?

Je ne suis pas sûr de comprendre où tu veux en venir mais, si c'est bien ce à quoi je pense, sache qu'un nombre entier a un format fixe et qu'il ne s'agit pas du tout d'une chaîne de caractères. En l'occurrence :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
    uint32_t hexatest = 0x14f;
    uint32_t hexatest = 0x0014f;
    uint32_t hexatest = 0x000014f;
    uint32_t hexatest = 0x0000014f;

… sont des expressions strictement équivalentes. Elles codent toutes la même valeur et seront toutes représentées sur 32 bits dans un uint32_t, quoi qu'il se passe. Et parce que uint32_t comporte exactement 32 bits, tu ne pourras jamais y stocker plus de 8 chiffres hexadécimaux.

Si c'est une suite de chiffres hexadécimaux de taille arbitraire que tu veux stocker puis traiter, et que cette chaîne peut éventuellement s'allonger jusqu'à plusieurs dizaines de chiffres, alors soit tu utilises un chaîne de caractères pour faire simple, soit tu déclares un tableau d'octets et tu y stockes tes chiffres par paire. Dans les deux cas, tu itères sur les élements, du premier au dernier.