Représentation de valeurs Hexadecimal en langage C

salut à tous et a toutes ,


J'ai un programme en C qui doit afficher 2 octets à partir d'un tableau de données , j'ai utiliser & 0xFF mais j'ai le que le prmeiere octet qui est afficher seulement .

& 0xFF c'est %255 en décimal ou 11111111 en langage binaire ,donc les premiers 8bits à 1 .


le code :

Code:

---

1 2 3 4 5 6 7 8 9

struct ma_structure_s {   unsigned int buf; byte ligne[16];   }ma_structure_t;

---

Code:

---

1 2 3 4 5 6 7 8

byte Mes_Donnees[]={   0x11,0x22,0x00,0x00, 0x19,0x77,0x38,0x15,0x35,0x11,0x22,0x97,0x19,0x77,0x38,0x15,0x35,0x11,0x22,0x97,     };

---

Code:

---

1 2	#define NB_ELEMENTS 1

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

int ma fonction ( void)   {   int i;   ma_structure_t *p; p = (ma_structure_t *) Mes_Donnees;       for(i=0; i<NB_ELEMENTS i++) { if((p->buff & 0xFF) p++;   printf (" Buff : %02X %02X",p->buff & 0xFF); }         }

---

Le but du code c'est d'afficher 11 22 à l'ecran , j'ai changer la valeur de buff de unsigned int à byte [0x02] mais j'ai pas les données souhaitées qui sont affichées .
Par contre pour afficher la ligne 16 Octets qui commence par 19 77 38 la j'ai aucun soucis à le faire .
Je n'ai jamais travailler avec ET " &" et "0xFF" pour la représentation de données en C .
La ligne est déclarée au tant que byte array et buff est déclarer au tant que unsigned int , je ne sais pas si c'est d'ici que se pose le probléme principale .



Merci pour vos différents conseils et suggéstions .

Oula oula. Super bizarre tout ça:
- buf dans ton struct et p->buff ! Ça ne risque pas de compiler
- 2 trucs à afficher et un seul paramètre à printf, ça ne risque pas de compiler sans warnings
- p++ ! Tu te décale de sizeof(int) + 16*sizeof(byte) ! Ça ne risque pas de marcher !

Et pourquoi ne pas faire simple (en supposant byte==char)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

#include <stdio.h> typedef char byte; int main(void) {   byte Mes_Donnees[]={ 0x11,0x22,0x00,0x00, 0x19,0x77,0x38,0x15,0x35,0x11,0x22,0x97,0x19,0x77,0x38,0x15,0x35,0x11,0x22,0x97, }; printf("%02hhX %02hhX\n",Mes_Donnees[0],Mes_Donnees[1]); return 0; }

---

Rq: hh c'est pour 'char'

Salut D[r]eadLock ;

buff est déclarer tant que unsigned int .
Le contenu de buff est : 0x11,0x22,0x00,0x00,
On souhaite afficher 2 OCTETS qui sont 11 22 à l'ecran.

La Question qui se pose :

Pourquoi lorsque on souhaite afficher la ligne 16 OCTETS celle ci s'affiche normalement avec un pointeur sur la structure .

Code:

---

printf(" Ligne 16 Octets :" , p->ligne , 0x10);

---

Contrairement au 2 OCTETS qui ne sont pas affichés avec ce code .

Code:

---

printf("Afficher 2 Octets :", p->buf & 0xFF);

---

Doit t'on changer la déclaration de buf et le déclarer tant que byte array par exemple : byte buff [0x04];

Tes printf(s) ne sont pas valides: il n'y a pas de "%" !

Citation:

---

Envoyé par Marley_T

Le contenu de buff est : 0x11,0x22,0x00,0x00,

---

Non, sur une architecture Little-Endian buff vaudra 0x00002211 et sur une architecture Big-Endian buff vaudra 0x11220000. (http://fr.wikipedia.org/wiki/Endian)

Chez moi (x86->little-endian)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#include <stdio.h> #include <stdint.h> typedef char byte; typedef struct ma_structure_s { uint32_t buf; byte ligne[16]; }ma_structure_t;   int main(void) { byte Mes_Donnees[]={ 0x11,0x22,0x00,0x00, 0x19,0x77,0x38,0x15,0x35,0x11,0x22,0x97,0x19,0x77,0x38,0x15,0x35,0x11,0x22,0x97, }; ma_structure_t *p = (ma_structure_t *)Mes_Donnees; printf("%02hhX %02hhX\n",p->buf & 0xFF, (p->buf>>8) & 0xFF); printf("%08X\n",p->buf); return 0; }

---

Donne :
11 22
00002211

Citation:

---

Envoyé par Marley_T

Doit t'on changer la déclaration de buf et le déclarer tant que byte array par exemple : byte buff [0x04];

---

Essaies et tu verras que oui :wink: buff[0] vaudra alors 0x11 et buff[1] 0x22 (quelque soit l'endianness de ta machine)

RE : D[r]eadLock


Ton code fonctionne trés bien et sans aucune erreur ;)

Le Résultat qu'on a voulu est affiché corréctement :

Code:

---

1 2 3

Buf : 11 22 Ligne : 19 77 38 15 35 11 22 97 19 77 38 15 35 11 22 97

---

J'ai juste 2 Quéstions par rapport au code , j'ai pas compris pourquoi tu as
dans le code mis (p->buf>>8) tu décale vers la droite et tu divises X 2 et tu mets un BitWise " & "

La Quéstion :


Pourquoi tu décales vers la DROITE >> 8 et pas sur la GAUCHE << 8
Pourquoi le premier pointeur vers buff(p->buf) et sans PARENTHéSE :
p->buf & 0xFF quant au second il est entre parenthése (p->buf>>8)& 0xFF

Quel différence entre : p->buf & 0xFF ET entre (p->buf>>8) & 0xFF .

Citation:

---

Envoyé par Marley_T

Pourquoi tu décales vers la DROITE >> 8 et pas sur la GAUCHE << 8
Pourquoi le premier pointeur vers buff(p->buf) et sans PARENTHéSE :
p->buf & 0xFF quant au second il est entre parenthése (p->buf>>8)& 0xFF

Quel différence entre : p->buf & 0xFF ET entre (p->buf>>8) & 0xFF .

---

Sur ma machine p->buf (abrégeons il est tard :wink), buf vaut 0x00001122.
Pour la première valeur à afficher, buf & 0xFF vaut donc
0x00001122 & 0xFF, soit 0x000001122 & 0x000000FF donc 0x22.

Pour le deuxième caractère, il faut décaler vers la droite de 8 bits (donc division par 256 et non 2) et buf>>8 vaut 0x00000011 (remarque la propagation de signe (bit le plus fort, ici 0 ne se voit pas)), en y appliquant le même masque on obtient 0x11.
Les parenthèses ne sont pas nécessaires mais aident à la compréhension: on décale d'abord et on masque ensuite.
Si on décale vers la gauche, on obtient 0x00112200, et le masque avec 0xff donne... 0x00

Pour en revenir à ton problème initial (i.e. pas de second caractère), c'est surement dû à ton printf auquel il manque un argument; le fameux p->buf >> 8 & 0xff ou en parenthésant à fond: ((p->buf)>>8) & 0xff

Citation:

---

Quel différence entre : p->buf & 0xFF ET entre (p->buf>>8) & 0xFF .

---

buf & 0xFF donne les huit bits de poid faible (7..0)
(buf>>8) & 0xFF donne les huit bits (15..8) mais mis dans un octet (7..0).

Citation:

---

Envoyé par D[r]eadLock

Sur ma machine p->buf (abrégeons il est tard :wink), buf vaut 0x00001122.
Pour la première valeur à afficher, buf & 0xFF vaut donc
0x00001122 & 0xFF, soit 0x000001122 & 0x000000FF donc 0x22.

Pour le deuxième caractère, il faut décaler vers la droite de 8 bits (donc division par 256 et non 2) et buf>>8 vaut 0x00000011 (remarque la propagation de signe (bit le plus fort, ici 0 ne se voit pas)), en y appliquant le même masque on obtient 0x11.
Les parenthèses ne sont pas nécessaires mais aident à la compréhension: on décale d'abord et on masque ensuite.
Si on décale vers la gauche, on obtient 0x00112200, et le masque avec 0xff donne... 0x00

Pour en revenir à ton problème initial (i.e. pas de second caractère), c'est surement dû à ton printf auquel il manque un argument; le fameux p->buf >> 8 & 0xff ou en parenthésant à fond: ((p->buf)>>8) & 0xff


buf & 0xFF donne les huit bits de poid faible (7..0)
(buf>>8) & 0xFF donne les huit bits (15..8) mais mis dans un octet (7..0).

---

RE D[r]eadLock


Tout ce que j'ai a te dire c'est je te REMERCIE du fond du coeur pour ton aide , tes conseils et toute les infos que tu as pu me donner pour mieux comprendre les choses car grace à toi j'ai assimiler bien le fonctionnement du code et la representation des données sur une machine .



Encore une fois , merci du fond du coeur D[r]eadLock pour ton intervention dans ce sujet , je te souhaite pleins de belles choses .



Probléme résolu .