Discussion :

[Aliveli]

Bonjour,

Voila Est-il possible de convertir un type __int64 (8 bytes) en binaire.
Je dois entrer un grand nombre decimal que je dois par la suite passé à un membre struct variable unsigned char blob [16]. L'ideal je pense c'est d'utiliser les masques et les operateurs >>, << .

Je n'obtient pour le moment pas ce que je veux car j'arive à obtenir un tableau de char qui contient qu'un seul bit '1' ou '0' alors je n'aurais pas assez pour mettre mes 128 bits (donc 16 * 8 bytes )

Mon objectif c'est par exemple :
on entre une valeur decimal : 15451254
j evoudrais le format binaire en 128 bits : 111010111100010001110110


pourriez vous me dire la marche à suivre sachant que j'utilise des pointeurs sur mes variables struct .

mes variables :

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
26
27
28
 
 
__int64 badge_id=0; //
 
...
 
	struct frame_message {  
		unsigned int sender_id;
		unsigned int packet_type;//crcin
		unsigned char blob[16];//
		unsigned int pin_code;//crcin
		unsigned char padding_bytes[8];
		}allmsg;
....
 
unsigned char *ps_card_number = (unsigned char*)malloc(16*sizeof(char));
ps_card_number = (unsigned char*)&allmsg.card_number; //crcin
 
...
 
 printf("   Give the blob :");
	//scanf("%Lu",&badge_id);
	//scanf("%d",&badge_id);
	scanf("%d",&badge_id);//////ici
...
 
 
ps_card_number=(unsigned char*)&badge_id;

de cette manière je ne convertit rien en format binair ça reste des tableaux de char

pourrais utiliser directement une ecriture sur la variable struct comme ceci ?

Code :

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

1
2
3
4
5
6
7
8
9
 
 
allmsg.card_number[1]=(unsigned char) ((badge_id >> 8) & 0x0000000000000000000000000000FF);
 
allmsg.card_number[2]=(unsigned char) ((badge_id >> 16) & 0x00000000000000000000000000FF);
 
...
 
allmsg.blob[15]=(unsigned char) ((badge_id >> 120) & 0xFF);

Est ce que la demarche est bonne ?

Je triche en mettant 16 bytes de masque (sachant que c'est du __int64 donc 8 bytes simplement), bien sur le resultat n'est pas correct .

Merci

[rilou]

Et ta conversion n'est pas correcte ??

Tu pourrais simplement faire :

Code :

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

1
2
3
4
5
6
7
8
for(i=0,j=1;i<120;i+=8,j++)
{
     allmsg.card_number[j]=(unsigned char)(badge_id >> i);
}
//tu est sur que c'est .BLOB ?? pas card_number ??
//de toute façon si ce n'est pas le cas modifie simplement "I<120"
//en I<=120
allmsg.blob[j]=(unsigned char) (badge_id >> i);

Vu que de toute façon un char ne contient que 8 BITS (sauf peut-être exception je ne sais pas trop...) je suppose que le masque avec 0x0...0FF est inutile.

Dans tout les cas ceci ne t'affichera pas : 111010111100010001110110

[Aliveli]

Oui en effet c'est .BLOB et pas card_number.

dans le code :

Code :

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

1
2
3
4
5
6
 
 
for(i=0,j=1;i<120;i+=8,j++)
{
     allmsg.blob[j]=(unsigned char)(badge_id >> i);
}

en fesant apres un :

Code :

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

1
2
3
4
5
6
 
 
for(int i=0;i<16;i++)
{
printf("\n contenu de blolb : %s \n", allmsg.blob[j]; // ou %x ??
}

on ne pourras pas afficher le format binaire ?
C'est justement le but cherché , comment faire s'il vous plait?

merci

[rilou]

Beh en fait le %s ne doit pas être utilisé pour 1 seul 'char'. Et le %x te donnera la représentation HEXADECIMALE de celui ci :s

En passant :

Code :

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

for(i=0,j=0;i<=120;i+=8,j++)

Tu devrais faire une conversion "à la main" de truc :s

En fait si tu décale de seulement 1 bit alors tu te retrouvera avec le bon resultat petit a petit :p

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
int mul=10;
 
memset(allmsg.blob,'\0',16);
 
for(i=0,j=0;i<120;i++)
{
 
     allmsg.blob[j]|=(unsigned char)(badge_id >> 8-(i%8) );
     allmsg.blob[j]= allmsg.blob[j] * mul;
 
     //on test pour aller au prochain blob
     if(i%8==0 && i!=0) j++;
}

Et donc en faite ça enchainera :

1
10
101
1011
10110

etc... c'est juste a titre d'exemple

[Aliveli]

Merci rilou

mais maintenant cela veut dire que j'aurais par exemple pour :

allmsg.blob[1] 1
allmsg.blob[2] 10
allmsg.blob[3] 101


et ce jusqu'à:

allmsg.blob[16] maximum ? n'est ce pas ?

[rilou]

Non puisque tu incrémente ton compteur J en fonction de I
avec la ligne :

Code :

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

1
2
3
4
5
 
//Si i!=0 et i%8=0
//alors incrémenter j
 
if(i%8==0 && i!=0) j++;

Donc tu ne passe que lorsque tu as traité 8 bits.