conversion __int64 (long long) vers binaire (128 bit format)

**Aliveli** · 02/04/2009, 19h24

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** · 02/04/2009, 20h38

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** · 02/04/2009, 22h39

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** · 02/04/2009, 23h03

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** · 03/04/2009, 01h10

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** · 03/04/2009, 14h27

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.

**magma²** · 03/04/2009, 15h52

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
  char bin[64 + 1];
 
  printf("%s\n", _i64toa(987654321234567890LL, bin, 2));
  return 0;
}

**Aliveli** · 03/04/2009, 17h52

Ok,

par contre pour l'affichage j'ai un souci :

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
 
 
memset(allmsg.card_number,'\0',16);
 printf("TRACE: vgt_sendto_S3100 before binary !\n");
for(int i=0,j=0;i<120;i++)
{
 allmsg.card_number[j]|=(unsigned char)(badgeid >> 8-(i%8) );
 allmsg.card_number[j]= allmsg.card_number[j] * mul;
 
 //on test pour aller au prochain blob
 if(i%8==0 && i!=0) 
 {j++;
  printf("allmsg.card_number[%d]= %c\n",j, allmsg.card_number[j]); //affich
 }	
}

la ligne printf que j'ai ajouté m'affiche (null) comme sortie que le %c soit du %x ou %d ?? comment dois je etres sur que c'est en format binaire et voir ça ?

Merci

**rilou** · 03/04/2009, 23h09

Code :

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

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

Pour l'affichage, le truc c'est qu'en fait tu essai d'afficher la prochaine case de ton tableau !!!! or cette case n'est pas encore initialisée :s

Fais plutot ceci :

Code :

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

1
2
3
4
5
 if(i%8==0 && i!=0) 
 {
  printf("allmsg.card_number[%d]= %d\n",j, allmsg.card_number[j]); //affich
  j++;
 }

Mais encore un problème auquel je viens de penser... 8 bits en format binaire sera représenté par 8 chiffres !!!

Donc un UNSIGNED char (qui va contenir maximum 255) ne pourra pas contenir 1 octet entier représenté en binaire :s

Au maximun tu auras 11 111 111 écrit en décimal un LONG serait plutot bienvenu pour stocker tout ca

Je te conseil de modifier tes variables en conséquence, et lors de l'ffichage mais un %u pas un %c ni %x !!

**Aliveli** · 05/04/2009, 15h24

Rebonjour,

Merci magma², merci rilou mais justement mon soucis c'est de pouvoir envoyé avec un tableau (allmsg.card_number[]) unsigned char de 16 bytes les 128 bits

Merci de m'aider.

**Aliveli** · 06/04/2009, 00h47

EN ayant testé la partie du programme, on voit :

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
 
 
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
   int mul=10;
 
 	__int64 badgeid=0;
	//unsigned int highWord = 0, lowWord = 0;
	char binary[80];
 
  		struct frame_message { 
		//typedef struct {  
		unsigned int sender_id;
		unsigned char card_number[16];//crcin
		}allmsg; 
 
  					allmsg.card_number[0]='1';//? //crcin 5
					allmsg.card_number[1]='1';//?
					allmsg.card_number[2]='1';//?
					allmsg.card_number[3]='1';//?
					allmsg.card_number[4]='1';//?
					allmsg.card_number[5]='1';//?
					allmsg.card_number[6]='1';//?
					allmsg.card_number[7]='1';//?
					allmsg.card_number[8]='1';//?
					allmsg.card_number[9]='1';//?
					allmsg.card_number[10]='1';//?
					allmsg.card_number[11]='1';//?
					allmsg.card_number[12]='1';//?
					allmsg.card_number[13]='1';//?
					allmsg.card_number[14]='1';//?
					allmsg.card_number[15]='1';//?
 
				printf("    Give the badge id (e.g. 1): ");
				//scanf("%Lu",&badge_id);
				//scanf("%d",&badge_id);
				scanf("%Lu",&badgeid);//////ici
				printf("\n");
 
for(int i=0,j=0;i<120;i++)
{
 allmsg.card_number[j]|=(unsigned char)(badgeid >> 8-(i%8) );
 allmsg.card_number[j]= allmsg.card_number[j] * mul;
 
 //on test pour aller au prochain tab
 if(i%8==0 && i!=0) 
 {
  printf("allmsg.card_number[%d]= %s,  %c, %x, %u\n",j, allmsg.card_number, allmsg.card_number[j],allmsg.card_number[j],allmsg.card_number[j]); //affich
 j++;}	
}
  system("PAUSE");
 
   return 0;
}

L'idée sera de pouvoir présenter donc avec les 16 x 8 bits un nombre encodé en __int64 .

Merci

**rilou** · 06/04/2009, 10h29

Code :

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

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

Ceci va découper ton entier 64bits en 16*8bits.
Tu ne le verra pas sous forme 01010101... puisque les seul format d'affichage sont l'hexa, le decimal, le caractère, etc... il n'y a pas de format défini pour l'affichage en binaire mais tu peux être sur que ton tableau blob contiendra ton entier 64bits découpé en 16 parties.

**Aliveli** · 06/04/2009, 19h06

Ok rilou,

mais concretement avec l'ensemble de mon code ou et comment pourrais je implementer cela (voir //CONVERSION) ?
Pour les struct est il mieux de passer par un pointeur ou bien directement affecter à la variable allmsg.cardnumber par exemple?

fichier.h

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
29
30
31
32
33
34
35
 
 
		struct frame_message { 
		//typedef struct {  
		unsigned int sender_id;
		unsigned int encrypt_key_id;
		unsigned int encrypt_size;
		unsigned int crc;
		unsigned int data_length; //crcin
		unsigned int sequence_number;//crcin
		unsigned int packet_type;//crcin
		unsigned int read_number;//crcin
		unsigned char card_number[MAX_CARD_NUMBER];//crcin
		unsigned int pin_code;//crcin
		unsigned char padding_bytes[MAX_PADDING];
		}allmsg; 
 
 
		unsigned char *psender_id ;
		unsigned char *pencrypt_key_id;		
                          unsigned char *pencrypt_size;
		unsigned char *pcrc; 
		unsigned char *pdata_length;
		unsigned char *psequence_number;
		unsigned char *ppacket_type;
		unsigned char *ps_read_number; 
		unsigned char *ps_card_number;//		
                           unsigned char *ps_pin_code; 
                         unsigned char *ppadding_bytes;
 
#define ERROR_S3100_INTERFACE_INIT	 	    	-101
 
#define ERROR_S3100_INTERFACE_SEND_TO	 	        -102
 
#define ERROR_S3100_INTERFACE_DEST			-103

Fichier.cpp

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
 
 
void init_structptr()
{
 
	memset(allmsg.card_number,0,16
	memset(allmsg.padding_bytes,0,16);
 
	memset(message,0,256);
	message_length=0;
	memset(msg_crc,0,36);//crc
 
	memset(response,0,256); //090406
 
	psender_id = (unsigned char*)&(allmsg.sender_id);
	pencrypt_key_id = (unsigned char*)&allmsg.encrypt_key_id;
	pencrypt_size = (unsigned char*)&allmsg.encrypt_size;
	pcrc = (unsigned char*)&allmsg.crc;
	pdata_length = (unsigned char*)&allmsg.data_length;//crcin
	psequence_number = (unsigned char*)&allmsg.sequence_number;//crcin
	ppacket_type = (unsigned char*)&allmsg.packet_type;//crcin
	ps_read_number = (unsigned char*)&allmsg.read_number;//crcin
	ps_card_number = (unsigned char*)&allmsg.card_number; //crcin
	ps_pin_code = (unsigned char*)&allmsg.pin_code; //crcin
	ppadding_bytes = (unsigned char*)&allmsg.padding_bytes;
 
	allmsg.sender_id=0x0a0b0c0d;  //hexadecimal sur 4 bytes rmq: nous sommes en little endian
	//allmsg.sender_id=3;
	allmsg.encrypt_key_id=0;
	allmsg.encrypt_size=0;
	allmsg.crc=0; //090406
	allmsg.data_length=24; //crcin 1
	allmsg.sequence_number=12345; //crcin 2
	allmsg.packet_type=1; //crcin 3
	allmsg.read_number=2; //crcin 4 //090401
	allmsg.pin_code=0; //crcin 6 //090404
 
	alreadyinit =true;
 
}
 
 
 
void write_struct(bool a)
{
 
	if (a)
	{
#ifdef _LITTLE_ENDIAN
		message[0]= psender_id[0];
		message[1]= psender_id[1]; 
		message[2]= psender_id[2]; 
		message[3]= psender_id[3];	
 
		message[4]= pencrypt_key_id[0];
		message[5]= pencrypt_key_id[1]; 
		message[6]= pencrypt_key_id[2]; 
		message[7]= pencrypt_key_id[3];
 
		message[8]= pencrypt_size[0];
		message[9]= pencrypt_size[1]; 
		message[10]= pencrypt_size[2]; 
		message[11]= pencrypt_size[3];
		///             
		message[12]= pcrc[0];
		message[13]= pcrc[1]; 
		message[14]= pcrc[2]; 
		message[15]= pcrc[3];
		///
		message[16]= pdata_length[0];
		message[17]= pdata_length[1]; 
		message[18]= pdata_length[2]; 
		message[19]= pdata_length[3];
		msg_crc[0]=pdata_length[0];///////crc 1
		msg_crc[1]=pdata_length[1];
		msg_crc[2]=pdata_length[2];
		msg_crc[3]=pdata_length[3];
 
		message[20]= psequence_number[0];
		message[21]= psequence_number[1]; 
		message[22]= psequence_number[2]; 
		message[23]= psequence_number[3];
		msg_crc[4]=psequence_number[0];///////crc 2
		msg_crc[5]=psequence_number[1];
		msg_crc[6]=psequence_number[2];
		msg_crc[7]=psequence_number[3];
 
		message[24]= ppacket_type[0];
		message[25]= ppacket_type[1]; 
		message[26]= ppacket_type[2]; 
		message[27]= ppacket_type[3];
		msg_crc[8]=ppacket_type[0];///////crc 3
		msg_crc[9]=ppacket_type[1];
		msg_crc[10]=ppacket_type[2];
		msg_crc[11]=ppacket_type[3];
 
		message[28]= ps_read_number[0];
		message[29]= ps_read_number[1]; 
		message[30]= ps_read_number[2]; 
		message[31]= ps_read_number[3];
		msg_crc[12]=ps_read_number[0]; ///////crc 4
		msg_crc[13]=ps_read_number[1];
		msg_crc[14]=ps_read_number[2];
		msg_crc[15]=ps_read_number[3];
 
		msg_crc[16]=message[32]= ps_card_number[0]; //crc 5
		msg_crc[17]=message[33]= ps_card_number[1]; 
		msg_crc[18]=message[34]= ps_card_number[2]; 
		msg_crc[19]=message[35]= ps_card_number[3];
		msg_crc[20]=message[36]= ps_card_number[4];
		msg_crc[21]=message[37]= ps_card_number[5]; 
		msg_crc[22]=message[38]= ps_card_number[6]; 
		msg_crc[23]=message[39]= ps_card_number[7];
		msg_crc[24]=message[40]= ps_card_number[8];
		msg_crc[25]=message[41]= ps_card_number[9]; 
		msg_crc[26]=message[42]= ps_card_number[10]; 
		msg_crc[27]=message[43]= ps_card_number[11];
		msg_crc[28]=message[44]= ps_card_number[12];
		msg_crc[29]=message[45]= ps_card_number[13]; 
		msg_crc[30]=message[46]= ps_card_number[14]; 
		msg_crc[31]=message[47]= ps_card_number[15];
 
		msg_crc[32]=message[48]= ps_pin_code[0]; //crc 6
		msg_crc[33]=message[49]= ps_pin_code[1];
		msg_crc[34]=message[50]= ps_pin_code[2];
		msg_crc[35]=message[51]= ps_pin_code[3]; 
 
		message[52]= ppadding_bytes[0];
		message[53]= ppadding_bytes[1]; 
		message[54]= ppadding_bytes[2]; 
		message[55]= ppadding_bytes[3];
		message[56]= ppadding_bytes[4];
		message[57]= ppadding_bytes[5]; 
		message[58]= ppadding_bytes[6]; 
		message[59]= ppadding_bytes[7];
		message[60]= ppadding_bytes[8];
		message[61]= ppadding_bytes[9]; 
		message[62]= ppadding_bytes[10]; 
		message[63]= ppadding_bytes[11];
		message[64]= ppadding_bytes[12];
		message[65]= ppadding_bytes[13]; 
		message[66]= ppadding_bytes[14]; 
		message[67]= ppadding_bytes[15];
 
#else
		message[0]= psender_id[3];
		message[1]= psender_id[2]; 
		message[2]= psender_id[1]; 
		message[3]= psender_id[0];	
 
		message[4]= pencrypt_key_id[3];
		message[5]= pencrypt_key_id[2]; 
		message[6]= pencrypt_key_id[1]; 
		message[7]= pencrypt_key_id[0];
 
		message[8]= pencrypt_size[3];
		message[9]= pencrypt_size[2]; 
		message[10]= pencrypt_size[1]; 
		message[11]= pencrypt_size[0];
		///             
		message[12]= pcrc[3];
		message[13]= pcrc[2]; 
		message[14]= pcrc[1]; 
		message[15]= pcrc[0];
		///
		message[16]= pdata_length[3];
		message[17]= pdata_length[2]; 
		message[18]= pdata_length[1]; 
		message[19]= pdata_length[0];
		msg_crc[0]=pdata_length[3];///////crc 1
		msg_crc[1]=pdata_length[2];
		msg_crc[2]=pdata_length[1];
		msg_crc[3]=pdata_length[0];
 
		//printf("\nblabla Big_endian\n");
 
		message[20]= psequence_number[3];
		message[21]= psequence_number[2]; 
		message[22]= psequence_number[1]; 
		message[23]= psequence_number[0];
		msg_crc[4]=psequence_number[3];///////crc 2
		msg_crc[5]=psequence_number[2];
		msg_crc[6]=psequence_number[1];
		msg_crc[7]=psequence_number[0];
 
		message[24]= ppacket_type[3];
		message[25]= ppacket_type[2]; 
		message[26]= ppacket_type[1]; 
		message[27]= ppacket_type[0];
		msg_crc[8]=ppacket_type[3];///////crc 3
		msg_crc[9]=ppacket_type[2];
		msg_crc[10]=ppacket_type[1];
		msg_crc[11]=ppacket_type[0];
 
		message[28]= ps_read_number[3];
		message[29]= ps_read_number[2]; 
		message[30]= ps_read_number[1]; 
		message[31]= ps_read_number[0];
		msg_crc[12]=ps_read_number[3]; ///////crc 4
		msg_crc[13]=ps_read_number[2];
		msg_crc[14]=ps_read_number[1];
		msg_crc[15]=ps_read_number[0];
 
		message[32]= ps_card_number[15];
		message[33]= ps_card_number[14]; 
		message[34]= ps_card_number[13]; 
		message[35]= ps_card_number[12];
		message[36]= ps_card_number[11];
		message[37]= ps_card_number[10]; 
		message[38]= ps_card_number[9]; 
		message[39]= ps_card_number[8];
		message[40]= ps_card_number[7];
		message[41]= ps_card_number[6]; 
		message[42]= ps_card_number[5]; 
		message[43]= ps_card_number[4];
		message[44]= ps_card_number[3];
		message[45]= ps_card_number[2]; 
		message[46]= ps_card_number[1]; 
		message[47]= ps_card_number[0];
		msg_crc[16]= ps_card_number[15]; //crc 5
		msg_crc[17]= ps_card_number[14]; 
		msg_crc[18]= ps_card_number[13]; 
		msg_crc[19]= ps_card_number[12];
		msg_crc[20]= ps_card_number[11];
		msg_crc[21]= ps_card_number[10]; 
		msg_crc[22]= ps_card_number[9]; 
		msg_crc[23]= ps_card_number[8];
		msg_crc[24]= ps_card_number[7];
		msg_crc[25]= ps_card_number[6]; 
		msg_crc[26]= ps_card_number[5]; 
		msg_crc[27]= ps_card_number[4];
		msg_crc[28]= ps_card_number[3];
		msg_crc[29]= ps_card_number[2]; 
		msg_crc[30]= ps_card_number[1]; 
		msg_crc[31]= ps_card_number[0];
 
		message[48]= ps_pin_code[3]; 
		message[49]= ps_pin_code[2];
		message[50]= ps_pin_code[1];
		message[51]= ps_pin_code[0]; 				
		msg_crc[32]=ps_pin_code[3]; //crc 6
		msg_crc[33]=ps_pin_code[2];
		msg_crc[34]=ps_pin_code[1];
		msg_crc[35]=ps_pin_code[0]; 
 
		message[52]= ppadding_bytes[15];
		message[53]= ppadding_bytes[14]; 
		message[54]= ppadding_bytes[13]; 
		message[55]= ppadding_bytes[12];
		message[56]= ppadding_bytes[11];
		message[57]= ppadding_bytes[10]; 
		message[58]= ppadding_bytes[9]; 
		message[59]= ppadding_bytes[8];
		message[60]= ppadding_bytes[7];
		message[61]= ppadding_bytes[6]; 
		message[62]= ppadding_bytes[5]; 
		message[63]= ppadding_bytes[4];
		message[64]= ppadding_bytes[3];
		message[65]= ppadding_bytes[2]; 
		message[66]= ppadding_bytes[1]; 
		message[67]= ppadding_bytes[0];
#endif
	} // if(a)
	else
	{
#ifdef _LITTLE_ENDIAN
 
		message[12]= pcrc[0];
		message[13]= pcrc[1]; 
		message[14]= pcrc[2]; 
		message[15]= pcrc[3];
 
		message[32]= ps_card_number[0];
		message[33]= ps_card_number[1]; 
		message[34]= ps_card_number[2]; 
		message[35]= ps_card_number[3];
		message[36]= ps_card_number[4];
		message[37]= ps_card_number[5]; 
		message[38]= ps_card_number[6]; 
		message[39]= ps_card_number[7];
		message[40]= ps_card_number[8];
		message[41]= ps_card_number[9]; 
		message[42]= ps_card_number[10]; 
		message[43]= ps_card_number[11];
		message[44]= ps_card_number[12];
		message[45]= ps_card_number[13]; 
		message[46]= ps_card_number[14]; 
		message[47]= ps_card_number[15];
 
	#else
 
		message[32]= ps_card_number[15];
		message[33]= ps_card_number[14]; 
		message[34]= ps_card_number[13]; 
		message[35]= ps_card_number[12];
		message[36]= ps_card_number[11];
		message[37]= ps_card_number[10]; 
		message[38]= ps_card_number[9]; 
		message[39]= ps_card_number[8];
		message[40]= ps_card_number[7];
		message[41]= ps_card_number[6]; 
		message[42]= ps_card_number[5]; 
		message[43]= ps_card_number[4];
		message[44]= ps_card_number[3];
		message[45]= ps_card_number[2]; 
		message[46]= ps_card_number[1]; 
		message[47]= ps_card_number[0];
 
		message[12]= pcrc[3]; //GOOD
		message[13]= pcrc[2]; 
		message[14]= pcrc[1]; 
		message[15]= pcrc[0];
 
		/*
		message[15]= (char)(rescrc32 & 0x000000FF); //
		message[14]= (char)((rescrc32>>8) & 0x0000FF);
		message[13]= (char)((rescrc32>>16) & 0x00FF);
		message[12]= (char)(rescrc32>>24);
		*/
	#endif
 
	}
}
 
 
 
 
main (int argc, char* argv[]) 
 
{
	char remote_ip[16];
	int remote_port=0;
	unsigned int act_doors=1;
            __int64 badge_id=0;
 
	if(argc<5)  
	{	
 
		return 0;
	}
	else 
	{
		strcpy(remote_ip,argv[1]);
		remote_port = atoi(argv[2]);
		act_doors  = atoi(argv[3]);
		badge_id = atoi(argv[4]);
 
	printf("                     REMOTE_IP = %s\n",remote_ip);
	printf("                     REMOTE_PORT = %d\n",remote_port);
	printf("                     S3100_DOORS = %d\n",act_doors);
	printf("                     BADGE_ID = %Lu",badge_id); //card_number
 
 
init_structptr();
write_struct(1);
 
__int64 badgeid =badge_id;
 
ps_card_number=(unsigned char*)&badgeid; 
 
 
for(int i=0; i < 66; ++i)
{
          printf("%2d[%2.2X], ", i, (unsigned char)message[i]);
          if (i==15||i==30||i==45||i==60) printf("\n");
}
 
printf("\nAFFICHAGE CARD NUMBER\n"); //taille 16 bytes de 32 à 48
 
for(int i=0; i < 16; ++i)
{
	printf("%2d[%2.2X], ", i, (unsigned char)message[32+i]);
 }
 
//CONVERSION 
for(i=0,j=1;i<=120;i+=8,j++)
{
 allmsg.card_number[j]=(unsigned char)(badgeid>> i);     
}
printf("\nAFFICHAGE CARD NUMBER APRES CONVERSION bin \n");
 
for(int i=0; i < 16; ++i)
{
	printf("%2d[%2.2X], ", i, (unsigned char)message[32+i]);
 
}
//CONVERSION
 
}

quand je saisi au console par exemple : programme.run 127.0.0.1 5000 1 154547

j'ai l'affichage de mon card_number est comme ci

AFFICHAGE CARD NUMBER
0[B7], 1[DC], 2[5F], 3[F4], 4[00], 5[00], 6[00], 7[0A], 8[00], 9[00], 10[00], 11[00], 12[00], 13[02], 14[5B], 15[B3],

il s'agit donc de big endian.

Et apres conversion j'ai toujours le même resultat est ce correct?

Merci

**rilou** · 06/04/2009, 19h47

154547 (decimal) = 0x25BB3

Ceci a l'air de correspondre avec ce que tu as dans les dernière case de ton tableau.

Deuxièmement :

pour l'affichage tu fais deux fois la même chose :

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
{
	printf("%2d[%2.2X], ", i, (unsigned char)message[32+i]);
 }
 
//CONVERSION 
for(i=0,j=1;i<=120;i+=8,j++)
{
 allmsg.card_number[j]=(unsigned char)(badgeid>> i);     
}
printf("\nAFFICHAGE CARD NUMBER APRES CONVERSION bin \n");
 
for(int i=0; i < 16; ++i)
{
	printf("%2d[%2.2X], ", i, (unsigned char)message[32+i]);
 
}

Il est donc normal que tu obtienne le même résultat VISIBLE.

**Aliveli** · 06/04/2009, 20h51

Oui exact rilou

mais entre les 2 affichages la phase de conversion n'a til pas une utilité ?

Quel algortihme, code dois je mettre pour intégrer la conversion décimal binaire et stocker le resultat dans mon tableau de 16 bytes allmsg.card_number[j] ?

Merci

**rilou** · 06/04/2009, 22h14

Et bien vu que tu ne re-écrit jamais dans ta structure, il est normal que ton affichage ne bouge pas.

Pourquoi ne pas faire :

Code :

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

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

Puisque tu ne modifie pas message avant le second affichage.

De toute façon une fois que tu auras trouvé ta réponse, espérons que l'affichage sera le même puisque tu veux tout de même voir la même valeur
mais dans une variable différente :p

**Aliveli** · 08/04/2009, 15h21

Voila une erreur !

badge_id = atoi(argv[4]);

atoll a résoud le gros du problème

en effet un __int64 va mieux avec la fonction atoll (long long).

**Aliveli** · 09/04/2009, 10h20

Le problème est maintenant lié à un transtypage:

fichier .h

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
 
 
		struct frame_message { 
		//typedef struct {  
		unsigned int sender_id;
		unsigned int encrypt_key_id;
		unsigned int encrypt_size;
		unsigned int crc;
		unsigned int data_length; 
		unsigned int sequence_number;
		unsigned int packet_type;
			unsigned int read_number;
			unsigned char card_number[16];/////
			unsigned int pin_code;
		unsigned char padding_bytes[MAX_PADDING];
		}allmsg;

fichier .cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
 
fonction pass(_int64 badgeid)
{
 
allmsg.card_number=(unsigned char*)&badgeid; //erreur incompatible signes assignement of (unsigned char* to unsigned char [16]
 
...
 
 
}

Comment dois je passer la variable __int64 dans la variable de mon struct ou dois je déclarer (variables globales, ppointeur ?)

Merci

**Aliveli** · 10/04/2009, 10h27

Bon je reviens avec des pistes plus sures,
en effet le problème viendrait du passage du long long int vers le byte apparement non supporté

Sachant que : ptemp_badge_id = (char*)&temp_badge_id; //

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
29
30
31
32
33
34
35
36
37
 
..
temp_badge_id = badgeid;
..
 
     	printf("\nallmsg.card_number[] before :\n");
	for(int i=0; i < 16; ++i)
	{
	printf("%2d[0x%2.2X], ", i, (unsigned char)allmsg.card_number[i]);
	if (i==14)printf("\n");
	}
 
		allmsg.card_number[15]=ptemp_badge_id[15];  
		allmsg.card_number[14]=ptemp_badge_id[14];
		allmsg.card_number[13]=ptemp_badge_id[13]; 
		allmsg.card_number[12]=ptemp_badge_id[12];
		allmsg.card_number[11]=ptemp_badge_id[11];
		allmsg.card_number[10]=ptemp_badge_id[10]; 
		allmsg.card_number[9]=ptemp_badge_id[9]; 
		allmsg.card_number[8]=ptemp_badge_id[8];
		allmsg.card_number[7]=ptemp_badge_id[7];
		allmsg.card_number[6]=ptemp_badge_id[6]; 
		allmsg.card_number[5]=ptemp_badge_id[5]; 
		allmsg.card_number[4]=ptemp_badge_id[4];
		allmsg.card_number[3]=ptemp_badge_id[3];
		allmsg.card_number[2]=ptemp_badge_id[2]; 
		allmsg.card_number[1]=ptemp_badge_id[1]; 
		allmsg.card_number[0]=ptemp_badge_id[0];
 
 printf("\nallmsg.card_number[] after :\n");
for(int i=0; i < 16; ++i)
	{
	printf("%2d[0x%2.2X], ", i, (unsigned char)allmsg.card_number[i]);
	if (i==14)printf("\n");
	}
 
printf("\nvaleur de temp_badge_id (Lu)= %Lu\n", temp_badge_id);

La capture donne ceci :

Code :

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

1
2
3
4
5
6
7
8
 
allmsg.card_number[] before :
 0[0x00],  1[0x00],  2[0x00],  3[0x00],  4[0x00],  5[0x00],  6[0x00],  7[0x00],  8[0x00],  9[0x00], 10[0x00], 11[0x00], 12[0x00], 13[0x00], 14[0x00],
15[0x00],
allmsg.card_number[] after :
 0[0x15],  1[0xCD],  2[0x5B],  3[0x07],  4[0x00],  5[0x00],  6[0x00],  7[0x00],  8[0xC8],  9[0x1A], 10[0xFD], 11[0xB7], 12[0x00], 13[0x00], 14[0x00],
15[0x00],
valeur de temp_badge_id (Lu)= 123456789

Donc les 3 premiers bytes c'est bon mais à quoi correspondent les bytes 8 à 11 qui faussent le calcul ?

Merci

conversion __int64 (long long) vers binaire (128 bit format)

C

Discussions similaires

Partager

Partager