I2C-EEPROM Lesen/Schreiben mit Arduino: Eine vollständige Anleitung

Einleitung

Hast du jemals Konfigurationsdaten oder kleine Mengen nichtflüchtiger Informationen in deinen Arduino-Projekten speichern müssen? I2C-EEPROMs sind eine perfekte Lösung – sie sind günstig, einfach zu verwenden und benötigen nur zwei Leitungen für die Kommunikation. In diesem Tutorial verwenden wir den Velxio-Browser-Simulator, um einen vollständigen I2C-EEPROM-Lese-/Schreibtest zu erstellen. Du lernst, wie du Daten auf ein virtuelles EEPROM unter der Adresse 0x50 schreibst und sie zurückliest, um zu überprüfen, ob alles funktioniert.

Velxio bietet eine SPICE-genaue analoge Simulationsumgebung, sodass du deinen Code ohne physische Hardware testen kannst. Lass uns eintauchen!

Schaltungsdurchlauf

Die Schaltung ist bemerkenswert einfach, da das I2C-EEPROM in die virtuelle Umgebung integriert ist. Die einzige Komponente, die wir benötigen, ist ein Arduino Uno. Das EEPROM wird intern simuliert und mit den I2C-Pins des Arduino verbunden (A4 für SDA und A5 für SCL). Es ist keine externe Verkabelung erforderlich – der Simulator verwaltet den I2C-Bus automatisch.

So richtest du die Schaltung ein:

1. Öffne den Velxio-Editor und füge einen Arduino Uno aus der Komponentenauswahl hinzu.
2. Das I2C-EEPROM ist bereits Teil der Simulation; du musst es nicht manuell hinzufügen.
3. Der Code kommuniziert mit dem EEPROM unter der Adresse 0x50.

Du findest den Arduino Uno unter der Kategorie “Mikrocontroller” in der Komponentenauswahl. Nach dem Platzieren zeigt die Leinwand das Board bereit zur Programmierung.

Code-Durchlauf

Lass uns den Arduino-Sketch untersuchen, der die Lese-/Schreiboperationen durchführt. Der Code ist in C++ unter Verwendung der standardmäßigen Wire-Bibliothek für die I2C-Kommunikation geschrieben.

// 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);
}

Wie der Code funktioniert

• writeEEPROM(reg, value): Diese Funktion sendet die Registeradresse und das Datenbyte an das EEPROM. Sie verwendet Wire.beginTransmission(), Wire.write() und Wire.endTransmission(). Eine Verzögerung von 5 ms simuliert die Schreibzykluszeit des EEPROMs.
• readEEPROM(reg): Zuerst sendet sie die Registeradresse an das EEPROM (ein “Dummy-Schreibvorgang”), dann fordert sie ein Byte mit Wire.requestFrom() an. Wenn Daten verfügbar sind, liest und gibt sie sie zurück; andernfalls gibt sie 0xFF zurück.
• setup(): Initialisiert die Wire-Bibliothek und die serielle Kommunikation. Sie schreibt ein Testmuster (10, 20, 30, …) in die Register 0 bis 7, liest sie dann zurück und vergleicht sie mit den erwarteten Werten. Jede Abweichung erhöht einen Fehlerzähler.
• loop(): Leer, mit einer kleinen Verzögerung, um das Board aktiv zu halten.

Schlüsselkonzepte für Studierende

1. I2C-Protokoll: I2C verwendet zwei Leitungen (SDA und SCL) und eine 7-Bit-Adresse, um mit mehreren Geräten zu kommunizieren. Die EEPROM-Adresse 0x50 ist bei vielen AT24C-Serie-Chips üblich.
2. EEPROM-Schreibzyklus: EEPROMs benötigen einige Millisekunden, um Daten intern zu schreiben. Das delay(5) in writeEEPROM() stellt sicher, dass der Schreibvorgang vor der nächsten Operation abgeschlossen ist.
3. Dummy-Schreibvorgang zum Lesen: Um von einem bestimmten Register zu lesen, sendest du zuerst die Registeradresse (ein Schreibvorgang), dann führst du einen wiederholten Start oder Stopp/Start aus, um die Daten zu lesen. Der Code verwendet einen Stopp/Start-Ansatz.
4. Fehlerprüfung: Der Sketch überprüft jeden gelesenen Wert gegen den erwarteten Wert, was eine gute Praxis zum Testen der Kommunikation ist.

Häufige Fallstricke und Debugging-Tipps

• Falsche Adresse: Stelle sicher, dass die EEPROM-Adresse mit deinem Gerät übereinstimmt. Das virtuelle EEPROM verwendet 0x50. Wenn du 0xFF zurückbekommst, könnte die Adresse falsch sein.
• Fehlende Pull-up-Widerstände: In echter Hardware benötigen I2C-Leitungen Pull-up-Widerstände. In Velxio werden sie intern simuliert, sodass du sie nicht hinzufügen musst.
• Serieller Monitor: Verwende den seriellen Monitor in Velxio, um die Ausgabe zu sehen. Klicke auf das Symbol des seriellen Monitors in der Symbolleiste.
• Timing: Wenn Lesevorgänge zeitweise fehlschlagen, erhöhe die Verzögerung nach Schreibvorgängen. Das virtuelle EEPROM ist schnell, aber echte Geräte benötigen möglicherweise mehr Zeit.

Verwende die Symbolleiste, um deinen Code zu kompilieren und auszuführen. Der serielle Monitor zeigt die Testergebnisse an.

Vorgeschlagene Erweiterungen

1. Größere Daten schreiben: Ändere den Code, um einen String oder ein Byte-Array zu schreiben und zu lesen.
2. Seitenschreiben: Viele EEPROMs unterstützen Seitenschreiben (mehrere Bytes in einer Transaktion schreiben). Versuche, dies zu implementieren.
3. Externes EEPROM: Füge eine physische EEPROM-Komponente hinzu (falls in Velxio verfügbar) und verbinde sie mit dem Arduino.
4. Datenprotokollierung: Verwende das EEPROM, um Sensorwerte zu speichern und später abzurufen.

Fazit

Du hast erfolgreich einen I2C-EEPROM-Lese-/Schreibtest in Velxio erstellt! Dieses Projekt demonstriert die Grundlagen der I2C-Kommunikation und des nichtflüchtigen Speichers. Die virtuelle Umgebung macht es einfach, ohne Hardware zu experimentieren. Versuche nun, den Code zu erweitern oder in ein größeres Projekt zu integrieren.

Bereit, dein eigenes zu bauen? Öffne das Live-Beispiel in Velxio und beginne mit dem Programmieren: I2C-EEPROM-Lese-/Schreibbeispiel. Viel Spaß beim Simulieren!