passage de variable type 128 bits conversion vers 2 _int64

**Aliveli** · 27/04/2009, 12h01

Bonjour,

Il me faut une fonction dans laquelle il faut pouvoir remplir un tableau d'entiers de 16 bytes (128 bits) à partir d'un passage de parametre dans une fonction call. Comme malheurerusement il n'existe
pas de type de variable superiaur à _int64 (64bits), ici sans doute qu'il faut faire un genre de strtol(,,) afin de spliter l'entrée saisie vers 2 _int64 je pense. J'ai déjà commencé par exemple cette fonction asciitobinary(x,x).

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
 
    ascii2binary (char* sourceAscii, char* destBin)
    {
 
        int64 lowPart = 0;
        int highPart = 0;
 
        for(int i=0; i<20; ++i)
        {
            lowPart += (sourceAscii[i]-48)*exp(10,i); //exemple= 10 exp 0                               //correspond au premiere chiffre
                                  //de 654342, càd à 2.
 
                                  // 48 pour enlever le 0 du ascii
 
        }
        for(int i=20; i<38; ++i)
        {
            highPart += (sourceAscii[i]-48)*exp(10,i);
 
        }
 
 
        // ici conversion des 2 _int64 vers les destBin[] avec des decalages et   des   //masquages
 
    }

Pourriez vous m'aider à faire la conversion des 2 _int64 vers les destBin[] ?

Merci .

**Aliveli** · 12/05/2009, 11h37

bonjour,

voila j'ai fait mon programme il reste toutefois un petit soucis.

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
 
 
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
 
void ascii2binary (char* sourceAscii, char* destbin, int size)
{
 
__int64 lowPart = 0; 
__int64 highPart = 0;
 
for(int i=0; i<20; ++i)
{
           lowPart += (sourceAscii[i]-48)*exp(i); //exemple= 10 exp 0 
                                   //correspond au premier chiffre dans
                                   //654342 c'est le 2.
                                   //48 pour enlever le 0 du ascii
}
 
for(int j=20; j<38; ++j)
{
        highPart += (sourceAscii[j]-48)*exp(j);
 
}
 
printf("value of lowPart: %ld\n",lowPart);
printf("value of highPart: %ld\n",highPart);
printf("sizeof lowpart & higpart is : %d\n", sizeof(lowPart));
 
destbin[0] =(char)(lowPart & 0x00000000000000FF);
destbin[1] =(char)((lowPart>>8) & 0x000000000000FF);
destbin[2] =(char)((lowPart>>16) & 0x0000000000FF);
destbin[3] =(char)((lowPart>>24) & 0x00000000FF);
destbin[4] =(char)((lowPart>>32) & 0x000000FF);
destbin[5] =(char)((lowPart>>40) & 0x0000FF);
destbin[6] =(char)((lowPart>>48) & 0x00FF);
destbin[7] =(char)((lowPart>>56) & 0xFF);
 
destbin[8] =(char)(highPart & 0x00000000000000FF);
destbin[9] =(char)((highPart>>8) & 0x000000000000FF);
destbin[10]=(char)((highPart>>16) & 0x0000000000FF);
destbin[11]=(char)((highPart>>24) & 0x00000000FF);
destbin[12]=(char)((highPart>>32) & 0x000000FF);
destbin[13]=(char)((highPart>>40) & 0x0000FF);
destbin[14]=(char)((highPart>>48) & 0x00FF);
destbin[15]=(char)((highPart>>56) & 0xFF);
 
 
for( int k =0; k<size ; ++k)
{
printf("string destbin is: %c\n", destbin[k]); //bug
}
 
}
 
 
void main (int args, char * argv[])
{
 
int indice;
 
char *tab[20];
char* ptabdest;
 
// char* ptab;
// ptab = (char*)malloc(16); //
// memset (ptab,0,16);
 
if(args != 2){
printf("erreur\n");
printf("usage: call program + <numbers>");
exit(1);
}
 
indice = 0;
while(argv[1][indice] != '\0'){
indice++;
}
 
ptabdest = (char*)malloc(indice);
printf("le string %s contient %d lettres\n", argv[1], indice);
 
tab[0]=argv[1];
printf("passage a la variable char *tab[] contient:%s\n", argv[1]);
 
ascii2binary( tab[0], ptabdest, indice);
 
system("PAUSE");
 
}

Si je passe en parametre par exemple : 123456789123456789 ,
je ne retrouve pas dans destbin[] ces données là ?
Qu'est ce qui ne va pas ?

Merci

**diogene** · 12/05/2009, 14h54

Code :

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

1
2
3
           lowPart += (sourceAscii[i]-48)*exp(i); //exemple= 10 exp 0 
...
        highPart += (sourceAscii[j]-48)*exp(j);

Que vient faire dans ce code la fonction exponentielle ???

**Aliveli** · 12/05/2009, 15h29

Je pensais agir sur les digits un peu comme j'ai mis dans mon commentaire l'équivalent aux masques des operations binaires mais pour des decimaux
apparement c'est pas la bonne méthode. Que pourrais je faire?

Les paramètres que je passe est ce que c'est bon?

Merci

**diogene** · 12/05/2009, 18h39

Si je comprend ton problème, la solution de passer par des entiers 64 bits pour former ton tableau d'octets n'est pas bonne : tu ne peux pas calculer de cette façon la partie de forts poids et celle des faibles poids.

Je te propose plutôt l'approche suivante :
- l'octet de poids faible est le reste de la division du nombre par 256.
- l'octet suivant est obtenu en prenant le quotient de la division précédente et en en prenant le reste de la division par 256
- et ainsi de suite.

Ton problème est que le nombre à diviser est codé en décimal et non pas en binaire (sinon tu n'aurais pas de problèmes évidemment)
Il te faut donc coder la division d'un nombre décimal par 256.
Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
unsigned int div256(unsigned char tab[], unsigned int nbtab)
{
 unsigned int A, R ,i;
 A = tab[0];
 R = 0;
 for(i = 0; i<nbtab;i++)
 {
   A = 10*R +tab[i];
   tab[i] = A/256;
   R = A%256;
 }
 return R;
}

Ici tab contient la suite des chiffres décimaux, un chiffre par élément du tableau, le poids fort en position 0. nbtab est le nombre d'éléments de ce tableau. La fonction renvoie le reste sous forme binaire et place le quotient dans tab sous forme décimale (tab est donc modifié).

Il ne reste plus qu'à placer les restes obtenus dans le tableau de destination.
Par exemple :

Code :

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

1
2
3
4
5
6
7
8
void ascii2binary (unsigned char tab[], unsigned int nbtab, unsigned char dest[],
   unsigned int nbdest)
{
  unsigned int i;
  // Si les données de départ sont en caractères :
  for(i=0 ; i<nbtab ;i++ ) tab[i] = tab[i]-'0';
  for(i=0 ; i<nbdest;i++ ) dest[i] = div256(tab,nbtab);
}

tab a le même format que précédemment. Le résultat est placé dans dest, tableau de nbdest éléments, avec dans dest[0] les poids faibles.
On peut utiliser tout ça de la façon suivante

Code :

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

1
2
3
4
5
6
  unsigned char dest[15];
  unsigned char tab[] = {'1','2','3','4','5','6','7','8','9'};
...
  int lentab = sizeof tab /sizeof *tab;
  int lendest = sizeof dest /sizeof *dest;
  Convert(tab,lentab,dest,lendest);

**Aliveli** · 13/05/2009, 13h03

Merci diogene,

voila j'ai adapter mon programme mais
je n'ai pas encore le résultat attendu dans la vérification?

Deplus je ne comprend pas le type de retour de la fonction div256 est un entier ?

Voici mon code :

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
 
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
 
unsigned int div256(unsigned char tab[], unsigned int nbtab)
{
 unsigned int A, R ,i;
 A = tab[0];
 R = 0;
 for(i = 0; i<nbtab;i++)
 {
   A = 10*R +tab[i];
   tab[i] = A/256;
   R = A%256;
 }
 return R;
}
 
void ascii2binary (unsigned char tab[], unsigned int nbtab, unsigned char dest[],
   unsigned int nbdest)
{
  unsigned int i;
  // Si les données de départ sont en caractères :
  for(i=0 ; i<nbtab ;i++ ) tab[i] = tab[i]-'0';
  for(i=0 ; i<nbdest;i++ ) dest[i] = div256(tab,nbtab);
}
 
 
void main (int args, char * argv[])
{
 
  int indice;
  unsigned char tab[40];
  unsigned char dest[40];
 
 
  if(args != 2)
  {
	  printf("erreur\n");
	  printf("usage: call program with string in params");
      exit(1);
  }
 
  indice = 0;
  while(argv[1][indice] != '\0')
  {
      indice++;
  }
 
  printf("le parametre %s contient %d lettres\n", argv[1], indice);
 
  for(int c=0; c<indice;++c)
  {
	  tab[c]=(char)argv[1+c];
  }
 
  printf("tab[] contient:%s\n", argv[1]);
 
 
  int lentab = sizeof tab /sizeof *tab;
  int lendest = sizeof dest /sizeof *dest;
 
  ascii2binary(tab,lentab,dest,lendest);
 
  printf(" verification : \n");
 
  for (int i=0; i<lentab;++i)
	  printf("apres conversion tab[] contient:%c\n", tab[i]);
 
  for (int j=0; j<lendest;++j)
      printf("apres conversion dest[] contient:%c\n", dest[j]);
 
 
  system("PAUSE");
 
}

la capture donne :

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
 
 
le parametre 123456789123456789123456789123456789 contient 36 lettres
tab[] contient:123456789123456789123456789123456789
 verification :
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion tab[] contient:
apres conversion dest[] contient:4
apres conversion dest[] contient:X
apres conversion dest[] contient:↑
apres conversion dest[] contient:R
apres conversion dest[] contient:.
apres conversion dest[] contient:p
apres conversion dest[] contient:Ó
apres conversion dest[] contient:u
apres conversion dest[] contient:É
apres conversion dest[] contient:┬
apres conversion dest[] contient:─
apres conversion dest[] contient:)
apres conversion dest[] contient:▄
apres conversion dest[] contient:╬
apres conversion dest[] contient:g
apres conversion dest[] contient:\
apres conversion dest[] contient:ç
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
apres conversion dest[] contient:
Appuyez sur une touche pour continuer...

merci.

**diogene** · 13/05/2009, 14h42

div256 calcule la division entière (euclidienne) du nombre par 256. Elle renvoie le reste de la division qui est un entier, et modifie le nombre de départ pour le remplacer par le quotient.

A la fin du calcul, le quotient est 0 et tab ne contient que des valeurs 0 (la valeur 0 pas le caractère '0'). dest contient la représentation binaire pur du nombre, pas des caractères.
Ceci fait que le format %c n'est pas adapté pour lister le contenu des tableaux :

Code :

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

1
2
3
4
5
6
7
  for ( i=0; i<lentab;++i)
	  printf("avant conversion tab[] contient:%c\n", tab[i]);
....
  for ( i=0; i<lentab;++i)
	  printf("apres conversion tab[] contient:%x\n", tab[i]);
  for ( i=0; i<lentab;++i)
	  printf("apres conversion tab[] contient:%x\n", tab[i]);

Ce qui donnera le contenu final des tableaux en hexadécimal. (A la place de %x, utiliser %d ou %u pour l'obtenir en décimal)

Code :

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

1
2
3
4
5
6
7
  for(int c=0; c<indice;++c)
  {
	  tab[c]=(char)argv[1+c];
  }
  printf("tab[] contient:%s\n", argv[1]); // ce message est faux !!!!!!!!
                                          //Il liste argv[1], pas tab 
  int lentab = sizeof tab /sizeof *tab;

Non, la longueur du tableau doit être le nombre de caractères qu'il contient (indice) pour la fonction ascii2binary, pas le nombre d'éléments du tableau. Les caractères ne sont pas argv[1+c] mais argv[1][c]

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
....
  if(args != 2)
  {
    printf("erreur\n");
    printf("usage: call program with string in params");
    exit(1);
  }
  strcpy(tab,argv[1]);
  lentab = strlen(tab) ;
  lendest = sizeof dest /sizeof *dest;
  for ( i=0; i<lentab;++i)
	  printf("avant conversion tab[] contient:%c\n", tab[i]);
  ascii2binary(tab,lentab,dest,lendest);
  printf(" verification : \n");
  for ( i=0; i<lentab;++i)
	  printf("apres conversion tab[] contient:%x\n", tab[i]);
  for ( i=0; i<lendest;++i)
      printf("apres conversion dest[] contient:%x\n", dest[i]);

<math.h> est totalement inutile.

Note : Si le nombre peut être négatif , le code doit être adapté.

**Aliveli** · 13/05/2009, 15h43

Ok,

Merci ça marche j'ai simplement du changer le type du tab en char au lieu de unsigned char compte tenu de la fonction strcpy() et ce que ça peut poser probleme ça ? car de toute façon ici il s'agit de passer des valeurs décimaux positives. Et le code ressemble à ceci:

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
 
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
 
unsigned int div256(char tab[], unsigned int nbtab)
{
 unsigned int A, R ,i;
 A = tab[0];
 R = 0;
 for(i = 0; i<nbtab;i++)
 {
   A = 10*R +tab[i];
   tab[i] = A/256;
   R = A%256;
 }
 return R;
}
 
void ascii2binary (char tab[], unsigned int nbtab, unsigned char dest[],
   unsigned int nbdest)
{
  unsigned int i;
  // Si les données de départ sont en caractères :
  for(i=0 ; i<nbtab ;i++ ) tab[i] = tab[i]-'0';
  for(i=0 ; i<nbdest;i++ ) dest[i] = div256(tab,nbtab);
}
 
 
void main (int args, char * argv[])
{
 
  int indice;
  char tab[40];
  unsigned char dest[40];
 
 
 if(args != 2)
  {
    printf("erreur\n");
    printf("usage: call program with string in params");
    exit(1);
  }
  strcpy(tab,argv[1]);
  int lentab = strlen(tab) ;
  int lendest = sizeof dest /sizeof *dest;
  for ( int i=0; i<lentab;++i)
	  printf("avant conversion tab[] contient:%c\n", tab[i]);
  ascii2binary(tab,lentab,dest,lendest);
  printf(" verification : \n");
  for ( int j=0; j<lentab;++j)
	  printf("apres conversion tab[] contient:%x\n", tab[j]);
  for ( int k=0; k<lendest;++k)
      printf("apres conversion dest[] contient:%x\n", dest[k]);
 
 
  system("PAUSE");
 
}

et la capture :

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
 
avant conversion tab[] contient:1
avant conversion tab[] contient:2
avant conversion tab[] contient:3
avant conversion tab[] contient:4
avant conversion tab[] contient:5
avant conversion tab[] contient:6
avant conversion tab[] contient:7
avant conversion tab[] contient:8
avant conversion tab[] contient:9
 verification :
apres conversion tab[] contient:0
apres conversion tab[] contient:0
apres conversion tab[] contient:0
apres conversion tab[] contient:0
apres conversion tab[] contient:0
apres conversion tab[] contient:0
apres conversion tab[] contient:0
apres conversion tab[] contient:0
apres conversion tab[] contient:0
apres conversion dest[] contient:15
apres conversion dest[] contient:cd
apres conversion dest[] contient:5b
apres conversion dest[] contient:7
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
apres conversion dest[] contient:0
Appuyez sur une touche pour continuer...

Là j'ai bien un convertisseur decimal-string vers du Hexa .

Au fait etant donné qu'on cherche à avoir une representation sur 128 bits il nous faudrait bien 48 chiffres donc il faudra changer declaration de 40 en 48 :
char tab[48];
unsigned char dest[48];

Comment pourrais je faire si je veux aussi avoir un convertisseur Hexa vers du décimal-string ?

Merci

**diogene** · 13/05/2009, 17h38

Comment pourrais je faire si je veux aussi avoir un convertisseur Hexa vers du décimal-string ?

Exactement suivant le même principe, mais cette fois avec des divisions par 10 au lieu de 256.

Il faut de plus, lire les octets et remplir le tableau final à l'envers si on veut avoir le résultat correct et les chiffres dans le bon ordre (le plus significatif en tête, alors que précédemment on avait l'octet le plus significatif en queue)

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
unsigned int div10(unsigned char tab[], unsigned int nbtab)
{
 unsigned int A, R, i ;
 R = 0;
 for(i = nbtab; i>0;i--) // à l'envers parce que l'octet de poids fort est en fin de tableau
 {
   A = 256*R +tab[i-1];
   tab[i-1] = A/10;
   R = A%10;
 }
 return R;
}
void binary2ascii (unsigned char tab[], unsigned int nbtab, unsigned char dest[],
   unsigned int nbdest)
{
  unsigned int i;
  for(i = nbdest-1 ; i>0;i-- ) // à l'envers pour que le chiffre de poids faible soit en fin de tableau
   dest[i-1] = div10(tab,nbtab);
  // Si les données d'arrivée sont en caractères :
  for(i=0 ; i<nbdest-1 ;i++ ) dest[i] = dest[i]+'0';
  dest[nbdest-1]= '\0'; // mettre le zéro terminant la chaine
}
 
....
  unsigned char dest[15];
  unsigned char tab[] = "123456789";
  unsigned char res[15];
  int lentab = strlen(tab);
  int lendest = sizeof dest /sizeof *dest;
  int lenres = sizeof res /sizeof *res ;
  ascii2binary (tab,lentab,dest,lendest);
  binary2ascii(dest,lendest,res,lenres);

**Aliveli** · 13/05/2009, 18h08

Ok merci,

Je vais voir ça. Actuellement je me pose la question de l'integration du code
dans ma dll car je dispose d'un appel avec un main vers une dll.

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

fichier main:

..
code_id = atoll(argv[4]);
..
error_code =pSystem_interface->sendto_System(code_id,var_id);





fichier dll:

DLL_API(long) vgt_sendto_System	( __int64 codeid, int var_id)
{
....

writestruct(codeid);

....
}



void writestruct(__int64 codeid)
{
..
	char *ptemp_code_id= (char*)&codeid;

	frame_st.code_number[15]=0;//ptemp_code_id[15];  
	frame_st.code_number[14]=0;//ptemp_code_id[14];
	frame_st.code_number[13]=0;//ptemp_code_id[13]; 
	frame_st.code_number[12]=0;//ptemp_code_id[12];
	frame_st.code_number[11]=0;//ptemp_code_id[11];
	frame_st.code_number[10]=0;//ptemp_code_id[10]; 
	frame_st.code_number[9]=0;//ptemp_code_id[9]; 
	frame_st.code_number[8]=0;//ptemp_code_id[8];
	frame_st.code_number[7]=ptemp_code_id[7];
	frame_st.code_number[6]=ptemp_code_id[6]; 
	frame_st.code_number[5]=ptemp_code_id[5]; 
	frame_st.code_number[4]=ptemp_code_id[4];
	frame_st.code_number[3]=ptemp_code_id[3];
	frame_st.code_number[2]=ptemp_code_id[2]; 
	frame_st.code_number[1]=ptemp_code_id[1]; 
	frame_st.code_number[0]=ptemp_code_id[0];

..

}

L'idée que j'avais au départ était d'utiliser 2 variables mais là je dois revoir ça
Comment faire ? Passer directement la chaine de caractère à un tableau ? comem ci-dessous:

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

fichier main:


error_code =pSystem_interface->sendto_System(argv[4],var_id);





fichier dll:

DLL_API(long) vgt_sendto_System	( char* codeid[], int var_id)
{
....

writestruct(codeid);

....
}



void writestruct(char* codeid[])
{
..
//sachant que  code _number[] est defini comme: 
//unsigned char code_number[MAX_NUMBER];

	frame_st.code_number[15]=codeid[15];  // dois je caster 
                                                             // (unsigned char) codeid[15]; ?
	frame_st.code_number[14]=codeid[14];
	frame_st.code_number[13]=codeid[13]; 
	frame_st.code_number[12]=codeid[12];
	frame_st.code_number[11]=codeid[11];
	frame_st.code_number[10]=codeid[10]; 
	frame_st.code_number[9]=codeid[9]; 
	frame_st.code_number[8]=codeid[8];
	frame_st.code_number[7]=codeid[7];
	frame_st.code_number[6]=codeid[6]; 
	frame_st.code_number[5]=codeid[5]; 
	frame_st.code_number[4]=codeid[4];
	frame_st.code_number[3]=codeid[3];
	frame_st.code_number[2]=codeid[2]; 
	frame_st.code_number[1]=codeid[1]; 
	frame_st.code_number[0]=codeid[0];

..

}

Est ce que les passages des pointeurs se fait correctement y aura-t-il une autre solution?

Merci

**Aliveli** · 28/05/2009, 20h09

Ok,

Je reviens sur le sujet , j'ai des erreurs dans l'intégration dans mon porgramme. J'ai fait un petit programme de test qui permet de mettre en oeuvre l'application selon le cas dans lequel je suis.

Au fait je dois rester le plus modulaire possible
donc je ne dois pas utiliser de variables globales, c'est pourquoi je passe par directement des variables locales.

j'ai à l'éxecution un segmentation fault dans l'appel à ascii2binary.

mon code:

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
 
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
 
 
unsigned int div256(unsigned char tab[], unsigned int nbtab)
{
 unsigned int A, R ,i;
 A = tab[0];
 R = 0;
 for(i = 0; i<nbtab;i++)
 {
   A = 10*R +tab[i];
   printf ("pour i= %d,  valeur de A = %d\n", i, A);
   tab[i] = A/256;
   printf ("pour i= %d, valeur de  tab[i] = %s\n", i, tab[i]);
   R = A%256;
   printf ("pour i= %d,  valeur de R = %d\n", i, R);
 
 }
 
  printf ("FINAL, valeur de R = %d\n", R);
 return R;
}
 
 
 
unsigned char* ascii2binary (char tab[], unsigned int nbtab, unsigned char dest[],
   unsigned int nbdest)
{
  unsigned int i;
  // Si les données de départ sont en caractères :
  for(i=0 ; i<nbtab ;i++ ) tab[i] = tab[i]-'0';
  for(i=0 ; i<nbdest;i++ ) dest[i] = div256(tab,nbtab);
printf ("valeur de dest = %s\n", dest);
return dest;
}
 
 
int main()
{
float var, ter, ref, rep ;
 
	unsigned char dest[41];  
	char * badgeid_tab="1234567891234567891234567891234567891234"; //ce type pour badgeid_tab car il est recupéré comme ça
	int lentab = strlen(badgeid_tab) ;
  	int lendest = sizeof dest /sizeof *dest;
 
 
 
printf ("hello\n");
 
 
    *dest=ascii2binary(badgeid_tab,lentab,dest,lendest); //55 Warning
 
 
return 0;
 
}

Je compile avec gcc :

Code :

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

1
2
3
 
testmodulo.c: In function ‘main’:
testmodulo.c:55: warning: assignment makes integer from pointer without a cast

Comment pourrais je faire s'il vous plaits ?

Merci

**diogene** · 28/05/2009, 21h48

Pourquoi ta fonction ascii2binary renvoie un des paramètres (dest) qu'on lui passe ? Ca ne sert à rien !

Code :

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

1
2
3
4
5
6
7
int main()
{
....
	unsigned char dest[41];  
.....
    *dest=ascii2binary(badgeid_tab,lentab,dest,lendest); //55 Warning
...

En conséquence, tu veux mettre la valeur de retour (qui est égale à dest et est un unsigned char *) comme premier élément du tableau dest (qui est un unsigned char).
Le compilateur râle, mais il a raison !
Il trouve absurde de mettre un unsigned char* dans un unsigned char et on ne peut le lui reprocher.

**Aliveli** · 29/05/2009, 01h13

Ok,

Je fais ça car je dois utiliser à l'interieur du bloc la variable dest.

C'est vrai pour le type il y a un probleme, mais alors si je change le type de retour de la fonction ascii2binary en unsigned char au lieu de unsigned char* ça devrait aller?

Merci

**diogene** · 29/05/2009, 14h26

Pour l'instant, il n'y a aucune raison que la fonction renvoie quelque 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
17
void ascii2binary (char tab[], unsigned int nbtab, unsigned char dest[],
   unsigned int nbdest)
{
  unsigned int i;
  // Si les données de départ sont en caractères :
  for(i=0 ; i<nbtab ;i++ ) tab[i] = tab[i]-'0';
  for(i=0 ; i<nbdest;i++ ) dest[i] = div256(tab,nbtab);
printf ("valeur de dest = %s\n", dest);
}
 
int main(void)
{
....
	unsigned char dest[41];  
.....
    ascii2binary(badgeid_tab,lentab,dest,lendest); 
...

**Aliveli** · 29/05/2009, 15h29

Oui c'est exact Diogene,

ça voudrait dire que dest devrait être globale alors
mais au faut je dois éviter des variables globales.

Sachant que dest doit être locale à la fonction write_struct() et dont la definition ressemble à ceci:

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
 
 
void ascii2binary (char tab[], unsigned int nbtab, unsigned char dest[],
   unsigned int nbdest)
{
  unsigned int i;
  // Si les données de départ sont en caractères :
  for(i=0 ; i<nbtab ;i++ ) tab[i] = tab[i]-'0';
  for(i=0 ; i<nbdest;i++ ) dest[i] = div256(tab,nbtab);
 
//return dest;
}
 
void write_struct(int active_door, /*__int64 badgeid*/ char * badgeid_tab, int seq_num)
{
 
	unsigned char dest[41];  //test 090515
	int lentab = strlen(badgeid_tab) ;
  	int lendest = sizeof dest /sizeof *dest;
 
      //  *dest=ascii2binary(badgeid_tab,lentab,dest,lendest);
     ascii2binary(badgeid_tab,lentab,dest,lendest);
 
...
 
   	char *ptemp_badge_id= (char*)&dest;
 
	frame_msg_st.card_number[15]=ptemp_badge_id[15];  
	frame_msg_st.card_number[14]=ptemp_badge_id[14];
	frame_msg_st.card_number[13]=ptemp_badge_id[13]; 
	frame_msg_st.card_number[12]=ptemp_badge_id[12];
	frame_msg_st.card_number[11]=ptemp_badge_id[11];
	frame_msg_st.card_number[10]=ptemp_badge_id[10]; 
	frame_msg_st.card_number[9]=ptemp_badge_id[9]; 
	frame_msg_st.card_number[8]=ptemp_badge_id[8];
	frame_msg_st.card_number[7]=ptemp_badge_id[7];
	frame_msg_st.card_number[6]=ptemp_badge_id[6]; 
	frame_msg_st.card_number[5]=ptemp_badge_id[5]; 
	frame_msg_st.card_number[4]=ptemp_badge_id[4];
	frame_msg_st.card_number[3]=ptemp_badge_id[3];
	frame_msg_st.card_number[2]=ptemp_badge_id[2]; 
	frame_msg_st.card_number[1]=ptemp_badge_id[1]; 
	frame_msg_st.card_number[0]=ptemp_badge_id[0];
 
 
}

Tel que ci-dessus le code, cela compile bien mais ne fonctionne pas comme il se doit car dest ne prend pas sa valeur.

Quelle pourrait être l'artifice pour éviter de rendre dest globale ?

Merci

**diogene** · 29/05/2009, 18h49

ça voudrait dire que dest devrait être globale ...

Pas du tout. En aucun cas ceci implique que dest soit global. D'ailleurs si il l'était, on ne prendrait pas le soin de le passer en paramètre de la fonction.

Dans ton code de write_struct, je ne vois rien à priori qui explique que dest ne prend pas les valeurs.
A part ceci, mais qui n'explique pas :

Code :

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

char *ptemp_badge_id= (char*)&dest;

qui devrait être

Code :

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

char *ptemp_badge_id= (char*)dest;

et

Code :

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

1
2
3
4
	frame_msg_st.card_number[15]=ptemp_badge_id[15];  
	frame_msg_st.card_number[14]=ptemp_badge_id[14];
	frame_msg_st.card_number[13]=ptemp_badge_id[13];
....

qui devrait plutôt faire l'objet d'une boucle.
D'ailleurs, qu'est ce que c'est que frame_msg_st ? une variable globale ?

Pour ton problème, vérifie que badgeid_tab est bien un tableau terminé par 0 et que son contenu et sa longueur sont bien ce que tu attends

**Aliveli** · 29/05/2009, 20h12

Ok,

frame_msg_st est un struct qui est globale et sa définition se trouve dans un fichier .h à part et d'ailleurs c'est elle qui est la seule variable globale.

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_ST 
		{ 
			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[MAX_CARD_NUMBER];//DATA
			unsigned int pin_code;
			unsigned char padding_bytes[MAX_PADDING];
		};

Lorsque je fais comme ceci:

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
 
 
void ascii2binary (char tab[], unsigned int nbtab, unsigned char dest[],
   unsigned int nbdest)
{
  unsigned int i;
  // Si les données de départ sont en caractères :
  for(i=0 ; i<nbtab ;i++ ) tab[i] = tab[i]-'0';
  for(i=0 ; i<nbdest;i++ ) dest[i] = div256(tab,nbtab);
 
//return dest;
}
 
 
void write_struct(int active_door, /*__int64 badgeid*/ char * badgeid_tab, int seq_num)
{
 
	unsigned char dest[41];  //test 090515
	int lentab = strlen(badgeid_tab) ;
  	int lendest = sizeof dest /sizeof *dest;
 
      //  *dest=ascii2binary(badgeid_tab,lentab,dest,lendest);
     ascii2binary(badgeid_tab,lentab,dest,lendest);
 
 
....
 
	memset(frame_msg_st.card_number,0,MAX_CARD_NUMBER);
 
...
	// char *ptemp_badge_id= (char*)&badgeid_tab;
	//char *ptemp_badge_id= (char*)&dest;
         char *ptemp_badge_id= (char*)dest;
 
	frame_msg_st.card_number[15]=ptemp_badge_id[15];  
	frame_msg_st.card_number[14]=ptemp_badge_id[14];
	frame_msg_st.card_number[13]=ptemp_badge_id[13]; 
	frame_msg_st.card_number[12]=ptemp_badge_id[12];
	frame_msg_st.card_number[11]=ptemp_badge_id[11];
	frame_msg_st.card_number[10]=ptemp_badge_id[10]; 
	frame_msg_st.card_number[9]=ptemp_badge_id[9]; 
	frame_msg_st.card_number[8]=ptemp_badge_id[8];
	frame_msg_st.card_number[7]=ptemp_badge_id[7];
	frame_msg_st.card_number[6]=ptemp_badge_id[6]; 
	frame_msg_st.card_number[5]=ptemp_badge_id[5]; 
	frame_msg_st.card_number[4]=ptemp_badge_id[4];
	frame_msg_st.card_number[3]=ptemp_badge_id[3];
	frame_msg_st.card_number[2]=ptemp_badge_id[2]; 
	frame_msg_st.card_number[1]=ptemp_badge_id[1]; 
	frame_msg_st.card_number[0]=ptemp_badge_id[0];
 
 
 
	frame_msg_st.read_number = active_door;
 
 
 ....
 
}

cad lorsque la variable dest est en locale à la fonction dans laquelle elle est (et qu'elle doit l'être car je ne peux pas avoir de variable globale). Elle doit donc prendre le résultat de ascii2bin(), mais la variable dest ne prend rien apparement et donc la ligne :

Code :

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

1
2
3
 
 
char *ptemp_badge_id= (char*)dest;

est inutile , d'ailleurs je vois dans l'application dest ne passe rien à ptemp_badge_id.

Il y a quelquechose qui m'échappe ?

Merci

**diogene** · 30/05/2009, 13h48

Le problème est ailleurs.
Pour le confirmer, j'ai testé ce code en rajoutant pour compiler et tester :

Code :

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

1
2
3
4
5
6
#define MAX_CARD_NUMBER  15
struct
{
  char card_number[MAX_CARD_NUMBER];
  int read_number;
} frame_msg_st;

et comme main

Code :

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

1
2
3
4
5
6
int main(void)
{
  char badgeid_tab[] = "123456789";
  write_struct(3, badgeid_tab, 5);
  return 0;
}

et je retrouve bien dans frame_msg_st les bonnes valeurs.

**Aliveli** · 30/05/2009, 19h59

Oui,

Je ne comprend pas une chose c'est que à ma connaissance si je ne me trompe pas, c'est que dans ce fragment de code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
void write_struct(int active_door, /*__int64 badgeid*/ char * badgeid_tab, int seq_num)
{
 
	unsigned char dest[41];  //test 090515
	int lentab = strlen(badgeid_tab) ;
  	int lendest = sizeof dest /sizeof *dest;
 
      //  *dest=ascii2binary(badgeid_tab,lentab,dest,lendest);
     ascii2binary(badgeid_tab,lentab,dest,lendest);
 
 
....

la variable dest est passée en copie et donc après l'appel à ascii2binary()
la variable dest n'ai toujours pas initialisée et donc l'appel est sans effet pour dest est-ce exact?

Car le code que j'avais avant d'integrer la fonctionnalité 128 bits compilait et fonctionnait correctement. Et avant j'utilisais une variable _int64 et le code que voici fonctionne bien:

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
 
 
 
void write_struct(int active_door, __int64 badgeid, int seq_num)
{
	memset(frame_msg_st.card_number,0,MAX_CARD_NUMBER);
	memset(frame_msg_st.padding_bytes,0,MAX_PADDING);
 
	memset(buffer_send,0,MAX_PATH);
 
 
	frame_msg_st.sender_id	=1;//090428
	frame_msg_st.encrypt_key_id	=0;
 
	frame_msg_st.encrypt_size	=40;
	frame_msg_st.crc		=0; 
	frame_msg_st.data_length	=24; 
 
 
	frame_msg_st.packet_type	=1; 
	frame_msg_st.pin_code		=0; 
 
	frame_msg_st.sequence_number=	seq_num;
 
	char *ptemp_badge_id= (char*)&badgeid;
 
	frame_msg_st.card_number[15]=0;//ptemp_badge_id[15];  
	frame_msg_st.card_number[14]=0;//ptemp_badge_id[14];
	frame_msg_st.card_number[13]=0;//ptemp_badge_id[13]; 
	frame_msg_st.card_number[12]=0;//ptemp_badge_id[12];
	frame_msg_st.card_number[11]=0;//ptemp_badge_id[11];
	frame_msg_st.card_number[10]=0;//ptemp_badge_id[10]; 
	frame_msg_st.card_number[9]=0;//ptemp_badge_id[9]; 
	frame_msg_st.card_number[8]=0;//ptemp_badge_id[8];
	frame_msg_st.card_number[7]=ptemp_badge_id[7];
	frame_msg_st.card_number[6]=ptemp_badge_id[6]; 
	frame_msg_st.card_number[5]=ptemp_badge_id[5]; 
	frame_msg_st.card_number[4]=ptemp_badge_id[4];
	frame_msg_st.card_number[3]=ptemp_badge_id[3];
	frame_msg_st.card_number[2]=ptemp_badge_id[2]; 
	frame_msg_st.card_number[1]=ptemp_badge_id[1]; 
	frame_msg_st.card_number[0]=ptemp_badge_id[0];
 
	frame_msg_st.read_number = active_door;
 
      .....
 
 
}

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
 
 
DLL_API(long) vgt_sendto_S3100	( char* remote_host, int remote_port, int active_door, __int64 badgeid, int seq_num, int timeout_ms)
{
	long error_code=0;		
	int response_length=0;			// length of the response received
 
	char *response = (char*)malloc(MAX_PATH*sizeof(char));
	memset(response, 0, MAX_PATH*sizeof(char));
 
 
 
		memset(buffer_send,0,256);  //TO CHECK
 
 
		write_struct(active_door, badgeid, seq_num);
 
 
printf("\n\n*********************** SENDING PARAMETERS ***************************\n");
		printf("Sender ID           = %d\n", frame_msg_st.sender_id);
		printf("Encryption key ID   = %d\n", frame_msg_st.encrypt_key_id);
		printf("Encrypted size      = %d\n", frame_msg_st.encrypt_size);
		printf("CRC-32              = %u\n",frame_msg_st.crc);
		printf("Data length         = %d\n", frame_msg_st.data_length);
		printf("Sequence number     = %d\n", frame_msg_st.sequence_number);
		printf("Packet type         = %d\n", frame_msg_st.packet_type);
		printf("data: READER NUMBER = %d\n", frame_msg_st.read_number);
		printf("data: CARD NUMBER   = %Ld\n", badgeid );
		printf("data: PIN CODE      = %d\n", frame_msg_st.pin_code);
 
 
               ....	
 
}

Donc je ne vois pas le probleme ?

Merci

**diogene** · 31/05/2009, 16h13

la variable dest est passée en copie et donc après l'appel à ascii2binary()
la variable dest n'ai toujours pas initialisée et donc l'appel est sans effet pour dest est-ce exact?

Code :

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

1
2
3
4
5
6
void write_struct(int active_door, /*__int64 badgeid*/ char * badgeid_tab, int seq_num)
{
 
	unsigned char dest[41];  //test 090515
.....
     ascii2binary(badgeid_tab,lentab,dest,lendest);

NON :
dest est un tableau, donc c'est l'adresse du début du tableau qui est passée en copie et cette adresse permet d'accéder aux éléments du tableau.

Dans mon post d'hier, je te signale que j'ai testé le code tel que tu l'avais posté (en ne faisant qu'ajouter une définition compatible pour frame_msg_st et un main sommaire) et que je n'ai pas trouvé de problèmes.

Je pense qu'il faut d'abord vérifier si badgeid_tab contient bien ce qu'on veut, donc s'interresser à la fonction qui appelle write_struct()

passage de variable type 128 bits conversion vers 2 _int64

C

Discussions similaires

Partager

Partager