Discussion :

[mormic]

Bonjour

Je souhaite stocker en mémoire EEPROM des codes en hexadécimale de 32 bits (ex: 49D8A78F)
J'ai bien compris que chaque emplacement mémoire ne peut stocker qu'un octet.
Il doit falloir convertir ce code en String.
Puis le découper en 4 octets.
Mais ne connaissant pas le langage C je me plante dans les conversions.

Si quelqu'un pouvait m'aider.

Merci

Michel

[TintinTerm]

Je ne suis qu'un débutant, mais je sais que long permet d'écrire sur 32 bits
http://arduino.cc/en/Reference/long

[Vincent PETIT]

Salut à tous les deux,
D'après l'API de ARDUINO http://arduino.cc/en/Reference/EEPROMWrite

Apparemment oui, on ne peut écrire que des octets dans l'EEPROM. Je dis apparemment car je n'ai pas d'ARDUINO mais j'ai programmé sur d'autres microcontrôleurs.

Il doit falloir convertir ce code en String.
Puis le découper en 4 octets.
Mais ne connaissant pas le langage C je me plante dans les conversions.

Heureusement, le langage C permet de faire plus simple

@Michel, la démonstration que je vais faire ci dessous et volontaire pour que tu comprennes bien ce que je fais et la démarche employée. Tu dis ne pas bien maîtriser le C alors si je te donne le truc tout fait, ça va peut être solutionner ton problème tout de suite mais si tu n'as pas compris tu risques de retomber sur un problème similaire en étant à nouveau bloqué.

Petit rappel sur les masques binaires avec ton exemple 0x49D8A78F (ici il s'agit d'un masque "ET" qui est l'opérateur "&" en C) :

Code C :

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

1
2
3
4
5
6
7
8
9
10
11
12
  int octet0 = 0x49D8A78F & 0xFF; // ça donne quoi ?
 
/*      4    9    D    8    A    7    8    F
 *      
 *    0100 1001 1101 1000 1010 0111 1000 1111
 *  &
 *    0000 0000 0000 0000 0000 0000 1111 1111   
 *    ---------------------------------------
 *  = 0000 0000 0000 0000 0000 0000 1000 1111
 *  
 *      0    0    0    0    0    0    8    F      
 */

Ah ! En faisant un masque "ET", de valeur 0xFF, avec ma valeur 32 bits j'arrive a extraire le dernier octet, octet 0 qui vaut bien 8F.

Continuons...

Instinctivement, pour extraire le octet 1 qui devrait valoir A7, on pourrait faire ceci

Code C :

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

1
2
3
4
5
6
7
8
9
10
11
12
  int octet1 = 0x49D8A78F & 0xFF00; // ça donne quoi ?
 
/*      4    9    D    8    A    7    8    F
 *      
 *    0100 1001 1101 1000 1010 0111 1000 1111
 *  &
 *    0000 0000 0000 0000 1111 1111 0000 0000    
 *    ---------------------------------------
 *  = 0000 0000 0000 0000 1010 0111 0000 0000
 *  
 *      0    0    0    0    A    7    0    0      
 */

J'arrive bien à extraire A7 mais ça fait plutôt A700 et ça ne m'arrange pas car ça fait 2 octets et moi je voulais A7 tout court !

Ce qui serait bien c'est de décaler les bits vers la droite pour que mon A700 se transforme par A7. En C tu as l'opérateur décalage binaires ">> (nombre de bits)".
Par contre, dois je décaler avant ou après les masques "ET" ?

Moi je décalerai de 8 bits avant le masque pour garder le même masque.

Code C :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
  int octet1 = 0x49D8A78F >> 8 & 0xFF; // ça donne quoi ?
 
/*      4    9    D    8    A    7    8    F
 *
 *    0100 1001 1101 1000 1010 0111 1000 1111
 *  >> 8
 *    0000 0000 0100 1001 1101 1000 1010 0111
 *      0    0    4    9    D    8    A    7
 *  &
 *    0000 0000 0000 0000 0000 0000 1111 1111 
 *    ---------------------------------------
 *  = 0000 0000 0000 0000 0000 0000 1010 0111
 *
 *      0    0    0    0    0    0    A    7    
 */

Voilà ce qui donne pour extraire les octets :

Code C :

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

1
2
3
4
5
 
  int octet0 = 0x49D8A78F >> 0 & 0xFF; /* Donnera 8F */
  int octet1 = 0x49D8A78F >> 8 & 0xFF; /* Donnera A7 */
  int octet2 = 0x49D8A78F >> 16 & 0xFF;/* Donnera D8 */
  int octet3 = 0x49D8A78F >> 24 & 0xFF;/* Donnera 49 */

Tu peux faire une fonction, optimiser le code comme par exemple pour la première ligne où je fais un décalage de 0 bit vers la droite (pour uniformiser le code), tu peux retirer l'opérateur si tu le souhaites même si le compilateur est suffisamment intelligent pour le faire à ta place, tu peux même trouver un autre moyen d'extraire les octets.

Ai je été clair ?

A+
Vincent

[mormic]

Bonjour Vincent

Merci pour ce cours Arduino clair et précis.
C'est tout à fait ce que j'attendais.
Tu as raison de ne pas mâcher le travail, parfois il suffit juste d'un petit coup de pouce pour débloquer la situation.
Et c'est tellement enrichissant de faire les choses soi-même (lorsqu'on a le temps)
Je vais mettre tout cela en application .

Cordialement

Michel