Discussion :

[Bernabé01]

bonjour ,

je cherche une fonction qui prend en parametre un type primitif , et qui retourne un pointeur sur un tableau de unsigned char contenant la valeur du parametre.

l'objectif est de faire une librairie pour arduino ( pour communiquer avec node.js ).

je suis arrivée pour les "int" , mais le même procédé ne fonctionne pas avec les "float" :

Code :

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

1
2
3
4
unsigned char * tab ;
float test = 256 ;
 
tab = *( reiterpret_cast<*unsigned char>( $test ) );

tab[0] = 01 et tab[1] = 00 ( LE ).
le résultat est bon mais avec float ça marche pas.

avez vous une solution meilleur ?

[Médinoc]

Ceci devrait marcher:

Code :

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

tab = reinterpret_cast<unsigned char*>( &test );

[Médinoc]

Normalement, (float)256 correspond à 0x43800000, ou en binaire:
0b01000011 10000000 00000000 00000000
(J'ai mis l'exposant en rouge: Il vaut 8+127).
Tout ça correspond à +1.000000 * 2^8.

[Bernabé01]

merci Médinoc ,

ça fonctionne, code arduino :

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
 
 
unsigned char * tab ;
float test = 256 ;
 
// the setup routine runs once when you press reset:
void setup() {     
 
tab = reinterpret_cast<unsigned char*>( &test ); 
Serial.begin(9600);
 
Serial.println( test );
Serial.println( tab[0] );
Serial.println( tab[1] );
 
test = 256.1;
tab = reinterpret_cast<unsigned char*>( &test ); 
Serial.println( test );
Serial.println( tab[0] );
Serial.println( tab[1] );
 
test = -0.1;
tab = reinterpret_cast<unsigned char*>( &test ); 
Serial.println( test );
Serial.println( tab[0] );
Serial.println( tab[1] );
 
test = 3333.1;
tab = reinterpret_cast<unsigned char*>( &test ); 
Serial.println( test );
Serial.println( tab[0] );
Serial.println( tab[1] );
 
Serial.println( test );
Serial.println( tab[0] );
Serial.println( tab[1] );
 
/////////////////////
int test = 256 ;
tab = reinterpret_cast<unsigned char*>( &test ); 
Serial.println( String( "\nint " ) + test );
Serial.println( tab[0] );
Serial.println( tab[1] );
 
unsigned int test1 = 256 ;
tab = reinterpret_cast<unsigned char*>( &test1 ); 
Serial.println( String( "\nuInt " ) + test );
Serial.println( tab[0] );
Serial.println( tab[1] );
 
char test2 = 97 ;
tab = reinterpret_cast<unsigned char*>( &test2 ); 
Serial.println( String( "\nchar " ) + test2 );
Serial.println( tab[0] );
Serial.println( tab[1] );
 
unsigned char test3 = 97 ;
tab = reinterpret_cast<unsigned char*>( &test3 ); 
Serial.println( String( "\nuChar " ) + test3 );
Serial.println( tab[0] );
Serial.println( tab[1] );
 
}
 
// the loop routine runs over and over again forever:
void loop() {
 
}

résultat :

256.00
0
0
256.10
205
12
-0.10
205
204
3333.10
154
81
3333.10
154
81

int 256
0
1

uInt 256
0
1

char a
97
97

uChar 97
97
0


comment je peut faire l opération inverse ? retrouver un type premier a partir d 'un pointeur sur tableau unsigned char ?

j'utilise les "unsigned char" parce que ça va jusqu a 256 , mais est ce que ça ferait une différence avec "char" ?

[Médinoc]

Facile:

Code C++ :

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

1
2
3
4
5
6
7
unsigned char test[4];
/*Ici j'initialise manuellement parce que c'est juste un exemple*/
test[0] = 0x43;
test[1] = 0x80;
test[2] = 0x00;
test[3] = 0x00;
float f = *reinterpret_cast<float*>(test);

Note que tu vas te heurter à des problèmes d'endianness si les autres machines ne sont pas des x86. Normalement quand on sérialise, on force également une endianness (typiquement big-endian, la convention "network").