Lecture/Écriture EEPROM I2C sur Pico — Simulez une mémoire non volatile dans votre navigateur

Introduction

Avez-vous déjà souhaité stocker des données qui survivent à une coupure d’alimentation ? Dans les systèmes embarqués, l’EEPROM (mémoire morte programmable effaçable électriquement) est la solution de référence pour le stockage non volatile. Aujourd’hui, nous allons simuler une opération de lecture/écriture d’une EEPROM I2C en utilisant le Raspberry Pi Pico — le tout dans votre navigateur avec Velxio. Aucun matériel requis !

Nous allons écrire quelques octets dans l’EEPROM, les relire et vérifier qu’ils correspondent. En chemin, vous apprendrez le protocole I2C, la bibliothèque Wire et comment déboguer la sortie série. C’est parti !

Présentation du circuit

Ouvrez l’exemple dans Velxio et vous verrez le circuit sur le canevas. Les composants principaux sont :

• Raspberry Pi Pico (le microcontrôleur)
• LED rouge (étiquetée led-write) – s’allume pendant une opération d’écriture
• LED verte (étiquetée led-read) – s’allume pendant une opération de lecture

Détails du câblage

Remarque : Dans cette simulation, l’EEPROM I2C est virtuelle — elle est intégrée à l’environnement Velxio. Les LEDs sont utilisées comme indicateurs visuels : la LED rouge clignote pendant une écriture, la LED verte pendant une lecture. Dans un circuit réel, vous connecteriez les lignes SDA et SCL de l’EEPROM aux broches I2C du Pico (GPIO4 et GPIO5 par défaut, mais ici nous utilisons D12 et D10 pour les LEDs).

Analyse du code

Décortiquons le sketch Arduino. Le code utilise la bibliothèque Wire pour communiquer via I2C.

Includes et définitions

#include <Wire.h>

#define EEPROM_ADDR 0x50

Nous incluons la bibliothèque Wire et définissons l’adresse I2C de l’EEPROM comme 0x50. C’est une adresse courante pour les EEPROM de la série 24LC.

Fonctions auxiliaires

void eepromWrite(byte memAddr, byte data) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(memAddr);
  Wire.write(data);
  Wire.endTransmission();
  delay(5); // Cycle d'écriture EEPROM
}

byte eepromRead(byte memAddr) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(memAddr);
  Wire.endTransmission();
  Wire.requestFrom(EEPROM_ADDR, 1);
  return Wire.available() ? Wire.read() : 0xFF;
}

• eepromWrite : Envoie l’adresse mémoire suivie de l’octet de données. Le delay(5) simule le cycle d’écriture interne de l’EEPROM (généralement 5 ms).
• eepromRead : Envoie d’abord l’adresse mémoire (une « écriture factice »), puis demande un octet à l’EEPROM. Retourne l’octet ou 0xFF si rien n’est disponible.

Setup

void setup() {
  Serial.begin(115200);
  delay(500);
  Wire.begin();
  Serial.println("=== Test EEPROM I2C Pico ===");
  Serial.println();

  // Écriture de 8 octets
  Serial.println("Écriture de 8 octets...");
  byte testData[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE};
  for (int i = 0; i < 8; i++) {
    eepromWrite(i, testData[i]);
    Serial.print("  ["); Serial.print(i);
    Serial.print("] = 0x");
    if (testData[i] < 16) Serial.print('0');
    Serial.println(testData[i], HEX);
  }
  Serial.println();

  // Relecture
  Serial.println("Relecture...");
  int pass = 0;
  for (int i = 0; i < 8; i++) {
    byte val = eepromRead(i);
    Serial.print("  ["); Serial.print(i);
    Serial.print("] = 0x");
    if (val < 16) Serial.print('0');
    Serial.print(val, HEX);
    if (val == testData[i]) {
      Serial.println(" OK");
      pass++;
    } else {
      Serial.print(" ÉCHEC (attendu 0x");
      Serial.print(testData[i], HEX);
      Serial.println(")");
    }
  }

  Serial.println();
  Serial.print("Résultat : ");
  Serial.print(pass);
  Serial.println("/8 réussis");
}

• Initialise la liaison série à 115200 bauds et le bus I2C avec Wire.begin().
• Écrit 8 octets (0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE) aux adresses 0 à 7.
• Relit chaque adresse et compare avec les données d’origine. Affiche « OK » ou « ÉCHEC ».
• Enfin, affiche le nombre de tests réussis.

Loop

void loop() {
  delay(10000);
}

Rien à faire en boucle — le test s’exécute une fois dans setup(). La boucle se contente d’une temporisation pour garder la sortie série visible.

Concepts clés

• Protocole I2C : Un bus série à deux fils (SDA, SCL) pour la communication entre microcontrôleurs et périphériques. Chaque périphérique possède une adresse unique.
• Bibliothèque Wire : La bibliothèque intégrée d’Arduino pour l’I2C. beginTransmission(), write(), endTransmission(), requestFrom() et read() en sont les fonctions principales.
• Adressage EEPROM : Les EEPROM sont organisées en banques mémoire. On écrit un octet d’adresse mémoire avant les données.
• Délai du cycle d’écriture : Les EEPROM ont besoin de quelques millisecondes pour stocker les données. Le delay(5) garantit que l’écriture est terminée avant l’opération suivante.

Pièges courants et conseils de débogage

1. Mauvaise adresse I2C : Vérifiez l’adresse de l’EEPROM. Les adresses courantes vont de 0x50 à 0x57 (selon les broches A0/A1/A2).
2. Résistances de tirage manquantes : Sur du matériel réel, SDA et SCL nécessitent des résistances de tirage (4,7 kΩ). L’EEPROM virtuelle de Velxio gère cela en interne.
3. Débit en bauds du moniteur série : Assurez-vous que le moniteur série est réglé sur 115200 bauds. Une discordance produit du charabia.
4. Temporisation du cycle d’écriture : Si vous sautez le delay(5), l’EEPROM risque de ne pas stocker correctement les données. Augmentez le délai si nécessaire.
5. Les LEDs ne clignotent pas : Vérifiez le câblage. La LED rouge est connectée à D12, la verte à D10. Les deux cathodes vont à GND.

Extensions suggérées

• Stocker et récupérer des données de capteur : Lisez un capteur de température et enregistrez la dernière valeur dans l’EEPROM.
• Ajouter un bouton : Utilisez un bouton poussoir pour déclencher une lecture ou une écriture.
• Passer à 256 octets : Modifiez le code pour écrire un bloc de données plus grand.
• Utiliser l’EEPROM pour la configuration : Stockez des valeurs d’étalonnage ou des paramètres utilisateur.

Essayez par vous-même !

Prêt à expérimenter ? Ouvrez l’exemple en direct dans Velxio :

Lancer la lecture/écriture EEPROM I2C sur Pico

Cliquez sur le bouton Exécuter dans la barre d’outils de l’éditeur pour compiler et simuler. Observez la sortie série dans la console — vous devriez voir les 8 octets relus avec succès.

Utilisez la barre d’outils du canevas pour zoomer, vous déplacer et inspecter le circuit.

Besoin d’ajouter d’autres composants ? Ouvrez le sélecteur de composants pour parcourir les pièces.

Bonne simulation !