Discussion :

[Marley_T]

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 :

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

1
2
3
4
5
6
7
8
9
 
 
struct  ma_structure_s
{
 
unsigned int buf;
byte ligne[16];
 
}ma_structure_t;

Code :

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

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 :

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

1
2
 
#define NB_ELEMENTS 1

Code :

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

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 .

[D[r]eadLock]

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 :

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

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'

[Marley_T]

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 :

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

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

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

Code :

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

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];

[D[r]eadLock]

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

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 :

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

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

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 buff[0] vaudra alors 0x11 et buff[1] 0x22 (quelque soit l'endianness de ta machine)

[Marley_T]

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 :

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

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 .

[D[r]eadLock]

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

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).

[Marley_T]

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 .