Lecture/Écriture EEPROM I2C avec Arduino — Guide Complet

Introduction

Avez-vous déjà eu besoin de stocker des données de configuration ou de petites quantités d’informations non volatiles dans vos projets Arduino ? Les EEPROM I2C sont une solution parfaite — elles sont bon marché, faciles à utiliser et ne nécessitent que deux fils pour la communication. Dans ce tutoriel, nous utiliserons le simulateur en ligne Velxio pour construire un test complet de lecture/écriture EEPROM I2C. Vous apprendrez à écrire des données sur une EEPROM virtuelle à l’adresse 0x50 et à les relire, en vérifiant que tout fonctionne.

Velxio fournit un environnement de simulation analogique précis au niveau SPICE, vous pouvez donc tester votre code sans aucun matériel physique. C’est parti !

Présentation du Circuit

Le circuit est remarquablement simple car l’EEPROM I2C est intégrée dans l’environnement virtuel. Le seul composant dont nous avons besoin est un Arduino Uno. L’EEPROM est simulée en interne et connectée aux broches I2C de l’Arduino (A4 pour SDA et A5 pour SCL). Aucun câblage externe n’est nécessaire — le simulateur gère le bus I2C automatiquement.

Pour configurer le circuit :

1. Ouvrez l’éditeur Velxio et ajoutez un Arduino Uno depuis le sélecteur de composants.
2. L’EEPROM I2C fait déjà partie de la simulation ; vous n’avez pas besoin de l’ajouter manuellement.
3. Le code communiquera avec l’EEPROM à l’adresse 0x50.

Vous trouverez l’Arduino Uno dans la catégorie “Microcontrôleurs” du sélecteur de composants. Une fois placé, le canevas affichera la carte prête à être programmée.

Présentation du Code

Examinons le sketch Arduino qui effectue les opérations de lecture/écriture. Le code est écrit en C++ en utilisant la bibliothèque Wire standard pour la communication I2C.

// I2C EEPROM Read/Write Test
// Virtual EEPROM at address 0x50
// Writes values to registers, then reads them back.

#include <Wire.h>

#define EEPROM_ADDR 0x50

void writeEEPROM(byte reg, byte value) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(reg);    // register address
  Wire.write(value);  // data
  Wire.endTransmission();
  delay(5); // EEPROM write cycle time
}

byte readEEPROM(byte reg) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(reg);
  Wire.endTransmission();

  Wire.requestFrom(EEPROM_ADDR, 1);
  if (Wire.available()) {
    return Wire.read();
  }
  return 0xFF;
}

void setup() {
  Wire.begin();
  Serial.begin(9600);

  Serial.println("============================");
  Serial.println(" I2C EEPROM R/W Test (0x50)");
  Serial.println("============================");
  Serial.println();

  // Write test pattern
  Serial.println("Writing test data...");
  for (byte i = 0; i < 8; i++) {
    byte value = (i + 1) * 10;  // 10, 20, 30, ...
    writeEEPROM(i, value);
    Serial.print("  Write reg[");
    Serial.print(i);
    Serial.print("] = ");
    Serial.println(value);
  }

  Serial.println();
  Serial.println("Reading back...");

  // Read back and verify
  byte errors = 0;
  for (byte i = 0; i < 8; i++) {
    byte expected = (i + 1) * 10;
    byte actual = readEEPROM(i);
    Serial.print("  Read  reg[");
    Serial.print(i);
    Serial.print("] = ");
    Serial.print(actual);

    if (actual == expected) {
      Serial.println("  [OK]");
    } else {
      Serial.print("  [FAIL] expected ");
      Serial.println(expected);
      errors++;
    }
  }

  Serial.println();
  if (errors == 0) {
    Serial.println("All tests PASSED!");
  } else {
    Serial.print(errors);
    Serial.println(" test(s) FAILED.");
  }
}

void loop() {
  // Nothing to do
  delay(1000);
}

Comment le Code Fonctionne

• writeEEPROM(reg, value) : Cette fonction envoie l’adresse du registre et l’octet de données à l’EEPROM. Elle utilise Wire.beginTransmission(), Wire.write() et Wire.endTransmission(). Un délai de 5 ms simule le temps de cycle d’écriture de l’EEPROM.
• readEEPROM(reg) : D’abord, elle envoie l’adresse du registre à l’EEPROM (une “écriture factice”), puis demande un octet avec Wire.requestFrom(). Si des données sont disponibles, elle les lit et les retourne ; sinon, elle retourne 0xFF.
• setup() : Initialise la bibliothèque Wire et la communication série. Elle écrit un motif de test (10, 20, 30, …) dans les registres 0 à 7, puis les relit et les compare aux valeurs attendues. Toute différence incrémente un compteur d’erreurs.
• loop() : Vide, avec un petit délai pour maintenir la carte active.

Concepts Clés pour les Étudiants

1. Protocole I2C : I2C utilise deux fils (SDA et SCL) et une adresse 7 bits pour communiquer avec plusieurs périphériques. L’adresse EEPROM 0x50 est courante pour de nombreuses puces de la série AT24C.
2. Cycle d’Écriture EEPROM : Les EEPROM nécessitent quelques millisecondes pour écrire les données en interne. Le delay(5) dans writeEEPROM() garantit que l’écriture se termine avant l’opération suivante.
3. Écriture Factice pour la Lecture : Pour lire un registre spécifique, vous envoyez d’abord l’adresse du registre (une opération d’écriture), puis vous émettez un redémarrage ou un arrêt/démarrage pour lire les données. Le code utilise une approche arrêt/démarrage.
4. Vérification des Erreurs : Le sketch vérifie chaque lecture par rapport à la valeur attendue, ce qui est une bonne pratique pour tester la communication.

Pièges Courants et Astuces de Débogage

• Mauvaise Adresse : Assurez-vous que l’adresse EEPROM correspond à votre périphérique. L’EEPROM virtuelle utilise 0x50. Si vous obtenez 0xFF en retour, l’adresse est peut-être erronée.
• Résistances de Tirage Manquantes : Sur du matériel réel, les lignes I2C nécessitent des résistances de tirage. Dans Velxio, elles sont simulées en interne, vous n’avez donc pas besoin de les ajouter.
• Moniteur Série : Utilisez le Moniteur Série dans Velxio pour voir la sortie. Cliquez sur l’icône du Moniteur Série dans la barre d’outils.
• Temporisation : Si les lectures échouent par intermittence, augmentez le délai après les écritures. L’EEPROM virtuelle est rapide, mais les périphériques réels peuvent nécessiter plus de temps.

Utilisez la barre d’outils pour compiler et exécuter votre code. Le Moniteur Série affichera les résultats des tests.

Extensions Suggérées

1. Écrire des Données Plus Grandes : Modifiez le code pour écrire et lire une chaîne de caractères ou un tableau d’octets.
2. Écriture par Page : De nombreuses EEPROM prennent en charge l’écriture par page (écriture de plusieurs octets en une seule transaction). Essayez de l’implémenter.
3. EEPROM Externe : Ajoutez un composant EEPROM physique (si disponible dans Velxio) et connectez-le à l’Arduino.
4. Enregistrement de Données : Utilisez l’EEPROM pour stocker des relevés de capteurs et les récupérer ultérieurement.

Conclusion

Vous avez réussi à construire un test de lecture/écriture EEPROM I2C dans Velxio ! Ce projet démontre les fondamentaux de la communication I2C et de la mémoire non volatile. L’environnement virtuel facilite l’expérimentation sans matériel. Maintenant, essayez d’étendre le code ou de l’intégrer dans un projet plus vaste.

Prêt à construire le vôtre ? Ouvrez l’exemple en direct dans Velxio et commencez à coder : Exemple de Lecture/Écriture EEPROM I2C. Bonne simulation !