EEPROM et bit de poids fort et faible

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

Voila : Mon code fonctionne bien :slight_smile:

#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();
}

Ca 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.

eeprom

L’adresse est codée sur un entier. On découpe cet entier en 2 octets qui vont être envoyés l’un après l’autre.
>> 8 décale l’entier (donc un mot de 16 bits) de 8 bits vers la droite
& 0xFF fait un masque sur l’entier pour ne conserver que les 8 bits de poids faibles.

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.

Si, par exemple, addr = 0x1234 lors de l’appel de la fonction

Wire.write((addr >> 8) & 0xFF);
addr >>8 va donner 0012
& 0xFF va donner 12
12 sera envoyé sur la liaison I2C

Wire.write((addr >> 0) & 0xFF);
addr >>0 ne va rien faire et va donner 1234 <= cette partie est parfaitement inutile
& 0xFF va donner 34
34 sera envoyé sur la liaison I2C
Cette deuxième partie pourrait s’écrire
Wire.write(addr & 0xFF);

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 :

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…

Euh, non! le 0xFF c’est pour garder la partie de droite par exemple

  0x1234
& 0x00FF
_________
= 0x0034

Bah alors si en premier lieu tu te décale de 8 a droite pour envoyer la partie de droite, le deuxième coup on envoi alors le même octet ?! Je ne comprend pas là.

Ou alors l’octet qui est envoyé (“choisi” Par write) sur les deux est celui de droite ? Et non celui de gauche…

wire.write() attend en paramètre un octet. Si on lui passe en paramètre une variable de taille supérieure le compilateur ne retient que les 8 bits de poids faibles.