Discussion :

[Guyome41]

Bonjour à tous, j’expérimente les EEPROM, j’ai bien tous compris sauf cette histoire de “bit de poids fort et faible” lors de la fonction write de la bibliothèque Wire.

Voila : Mon code 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
#include <Wire.h>
#define EEPROM01 0x50
 
void setup() {
  Serial.begin(9600);
  Wire.begin();
}
 
void loop() {
  ecriture_eeprom(1, EEPROM01, 23);
  delay(1000);  
 
  Serial.println(lecture_eeprom(1, EEPROM01));
  delay(1000);  
}
 
int lecture_eeprom(int addr, int eeprom) {
  int valeur = 12;
 
  Wire.beginTransmission(eeprom);
  Wire.write((addr >> 8) & 0xFF);
  Wire.write((addr >> 0) & 0xFF);
  Wire.endTransmission();
 
  Wire.requestFrom(eeprom, 1);
  valeur = Wire.read();
  Wire.endTransmission();
 
  return valeur;
}
 
void ecriture_eeprom(int addr, int eeprom, int donnee) {
  Wire.beginTransmission(eeprom);
  Wire.write((addr >> 8) & 0xFF);
  Wire.write((addr >> 0) & 0xFF);
  Wire.write(donnee);
  Wire.endTransmission();
}

Ceci inscrit le nombre 23 à l’adresse 1 puis je li cette valeur. Je ne comprend pas c’est :

Pourquoi >> 8 et pourquoi & 0xFF ?

J’aime bien “imager” les choses et j’ai mis en upload une image dont je me représente les adresses de mon eeprom. Merci d’avance pour vos explication.

[foetus]

Tu travailles avec des nombre sur 16 bits/ 2 octets.

Et donc tu as l'octet de poids fort (le + à gauche, si je ne me trompe pas ) et l'octet de poids faible (l'autre octet donc)
Ceci est important à cause de l'"endianess" (boutisme en français) ()

Les opérateurs << et >> en C, sont des opérateurs binaires de décalage de bits - respectivement vers la gauche et vers la droite :

• (addr >> 0) ce décalage ne sert à rien
• (addr >> 8) ce décalage va décaler tous les bits de 8 vers la droite - en gros, en castant en char, on récupère l'octet de poids fort

PS : ces opérateurs servent aussi à faire des multiplications ou des divisions avec des puissances de 2 (2, 4, 8, 16, ...)

Les opérateurs & et | en C, sont des opérateurs binaires qui correspond respectivement à ET et à OU.
Ne pas confondre avec les opérateurs && et || qui en C, sont des opérateurs logiques.
0xFF s'appelle 1 masque, et donc & 0xFF permet, si tu appliques la table du ET, à mettre à 0 (zéro) l'octet de poids fort, mais à conserver l'octet de poids faible.
Cela évite d'avoir des surprises lorsque tu récupères ta valeur (à moins que tu travailles avec des char et donc tes données seront tronquées, mais cela ne semble pas être le cas)

[Guyome41]

Merci pour ta réponse, mais je ne comprends pas pourquoi le premier write décale de 8 toute suite ?
Ça veux dire que ça commence à lire l’octet de droite et le deuxième write loctet de gauche ?

Ou alors le premier write veux dire , Read le premier octet et décalle toi de 8 pour read celui de droite ?

[foetus]

Tu veux transmettre 1 adresse et éventuellement 1 valeur. Mais la transmission, ce fait octet par octet. Donc :

• pour ta donnée (de type int), tu vas la tronquer et transmettre qu'1 char
• pour ton adresse, tu vas d'abord transmettre l'octet de poids fort puis celui de poids faible. C'est 1 choix, tu transmets ton adresse dans le même ordre qu'elle est.

Il n'y a presque rien à comprendre

[kaitlyn]

Salut,

Merci pour ta réponse, mais je ne comprends pas pourquoi le premier write décale de 8 toute suite ?
Ça veux dire que ça commence à lire l’octet de droite et le deuxième write loctet de gauche ?

Ou alors le premier write veux dire , Read le premier octet et décalle toi de 8 pour read celui de droite ?

Sinon, c'est juste une question de protocole, une règle de transmission de données sur un bus: un premier signale qui indique le début de transmission Wire.beginTransmission, un second qui indique la partie "centaine" de l'adresse où se placer dans l'eeprom Wire.write(mem_address >> 8);, un troisième qui indique la partie "dizaine" de l'adresse où se placer dans l'eeprom Wire.write(mem_address & 0xFF);, ensuite on lit ou écrit à cette emplacement Wire.read ou Wire.write. Si tu souhaites te placer à l'adresse (ou offset) 0x1234 (12 cent 34 en hexadécimal), la première formule permet d’extraire les centaines (Most Significant Byte), soit 0x12. La deuxième, les dizaines (Least Significant Byte), c.-à-d. 0x34. Quant au fonctionnement de ces formules, il a déjà été expliqué par foetus.

[Guyome41]

Merci beaucoup pour vos réponses. Effectivement c'est bien plus clair et je cherché bien plus compliqué.
Tout simplement l'adresse est codé sur 16bit (donc 2octets) avec le protocole I2C on doit envoyer octet par octet donc on doit découper l'adresse en deux partie. Bien sûr on commence par la partie de droite puis la gauche sinon ça inverse tous... C'est comme ci (exemple en décimale) on envoyé 1526 : je découpe 15 / 26 et j'envoie d'abord 26 puis 15 dans le cas contraire ça donnerai 2615.

Pour l'histoire de 0xFF c'est effectivement pour garder que la partie de gauche.

Pour l'histoire, au début je n'avais pas du tout compris ça :

J'avais compris dans la ligne :

Code :

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

Wire.write((1 >> 8) & 0xFF);

Vas à l'adresse 1 et déplace toi de 8bit vers la droite dans l'adresse 1.
Je pensais avec l'image que je vous ai posté que chaque adresse avais 2 octets....

[Jay M]

Pour l'histoire de 0xFF c'est effectivement pour garder que la partie de gauche.

en fait ça ne sert à rien parce que write() ne prend qu'un octet donc le compilateur prendra de toutes façons que l'octet de poids faible.

[Bousk]

Tu es sûrement sur une plateforme qui a des int sur 16bits = 2octets, donc pour envoyer un int il faut le couper en 2 octets pour envoyer chaque octet. Et à la réception, tu fais l'opération inverse pour recréer la vraie valeur.
Je prêche pour ma paroisse, tu pourras en lire plus ici https://bousk.developpez.com/cours/s...on-bases/#LI-A
Qu'est-ce que l'endianness, ce que ça implique et pourquoi c'est important pour sérialiser ses données et comment ça marche.