Pico I2C EEPROM Lesen/Schreiben: Nichtflüchtigen Speicher im Browser simulieren

Einleitung

Hast du schon einmal Daten speichern wollen, die einen Stromausfall überstehen? In eingebetteten Systemen ist EEPROM (Electrically Erasable Programmable Read-Only Memory) die erste Wahl für nichtflüchtigen Speicher. Heute simulieren wir einen I2C-EEPROM-Lese-/Schreibvorgang mit dem Raspberry Pi Pico – und das alles in deinem Browser mit Velxio. Keine Hardware erforderlich!

Wir schreiben ein paar Bytes auf das EEPROM, lesen sie zurück und überprüfen, ob sie übereinstimmen. Dabei lernst du das I2C-Protokoll, die Wire-Bibliothek und das Debuggen von seriellen Ausgaben kennen. Los geht’s!

Schaltungsaufbau

Öffne das Beispiel in Velxio und du siehst die Schaltung auf der Leinwand. Die Hauptkomponenten sind:

• Raspberry Pi Pico (der Mikrocontroller)
• Rote LED (beschriftet mit led-write) – leuchtet während eines Schreibvorgangs
• Grüne LED (beschriftet mit led-read) – leuchtet während eines Lesevorgangs

Verdrahtungsdetails

Hinweis: In dieser Simulation ist das I2C-EEPROM virtuell – es ist in die Velxio-Umgebung integriert. Die LEDs dienen als visuelle Indikatoren: Die rote LED blinkt während eines Schreibvorgangs, die grüne LED während eines Lesevorgangs. In einer realen Schaltung würdest du die SDA- und SCL-Leitungen des EEPROMs mit den I2C-Pins des Pico verbinden (standardmäßig GPIO4 und GPIO5, aber hier verwenden wir D12 und D10 für die LEDs).

Code-Durchlauf

Lass uns den Arduino-Sketch Schritt für Schritt durchgehen. Der Code verwendet die Wire-Bibliothek zur Kommunikation über I2C.

Includes und Definitionen

#include <Wire.h>

#define EEPROM_ADDR 0x50

Wir binden die Wire-Bibliothek ein und definieren die I2C-Adresse des EEPROMs als 0x50. Dies ist eine gängige Adresse für 24LC-Serie-EEPROMs.

Hilfsfunktionen

void eepromWrite(byte memAddr, byte data) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(memAddr);
  Wire.write(data);
  Wire.endTransmission();
  delay(5); // EEPROM-Schreibzyklus
}

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: Sendet die Speicheradresse gefolgt vom Datenbyte. Der delay(5) simuliert den internen Schreibzyklus des EEPROMs (typischerweise 5 ms).
• eepromRead: Sendet zuerst die Speicheradresse (ein „Dummy-Schreibvorgang“) und fordert dann ein Byte vom EEPROM an. Gibt das Byte oder 0xFF zurück, wenn nichts verfügbar ist.

Setup

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

  // 8 Bytes schreiben
  Serial.println("Schreibe 8 Bytes...");
  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();

  // Zurücklesen
  Serial.println("Lese zurück...");
  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(" FEHLER (erwartet 0x");
      Serial.print(testData[i], HEX);
      Serial.println(")");
    }
  }

  Serial.println();
  Serial.print("Ergebnis: ");
  Serial.print(pass);
  Serial.println("/8 bestanden");
}

• Initialisiert die serielle Schnittstelle mit 115200 Baud und den I2C-Bus mit Wire.begin().
• Schreibt 8 Bytes (0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE) auf die Adressen 0–7.
• Liest jede Adresse zurück und vergleicht sie mit den ursprünglichen Daten. Gibt „OK“ oder „FEHLER“ aus.
• Gibt schließlich die Anzahl der bestandenen Tests aus.

Loop

void loop() {
  delay(10000);
}

Es gibt nichts, das wiederholt ausgeführt werden muss – der Test läuft einmal in setup(). Die Loop verzögert nur, um die serielle Ausgabe sichtbar zu halten.

Wichtige Konzepte

• I2C-Protokoll: Ein serieller Zweidraht-Bus (SDA, SCL) für die Kommunikation zwischen Mikrocontrollern und Peripheriegeräten. Jedes Gerät hat eine eindeutige Adresse.
• Wire-Bibliothek: Arduinos integrierte Bibliothek für I2C. beginTransmission(), write(), endTransmission(), requestFrom() und read() sind die Kernfunktionen.
• EEPROM-Adressierung: EEPROMs sind in Speicherbänken organisiert. Wir schreiben ein Speicheradress-Byte vor den Daten.
• Schreibzyklus-Verzögerung: EEPROMs benötigen einige Millisekunden, um Daten zu speichern. Der delay(5) stellt sicher, dass der Schreibvorgang abgeschlossen ist, bevor die nächste Operation beginnt.

Häufige Fallstricke & Debugging-Tipps

1. Falsche I2C-Adresse: Überprüfe die EEPROM-Adresse. Gängige Adressen sind 0x50 bis 0x57 (abhängig von den A0/A1/A2-Pins).
2. Fehlende Pull-Up-Widerstände: In echter Hardware benötigen SDA und SCL Pull-Up-Widerstände (4,7 kΩ). Velxios virtuelles EEPROM übernimmt dies intern.
3. Baudrate des seriellen Monitors: Stelle sicher, dass der serielle Monitor auf 115200 Baud eingestellt ist. Eine falsche Einstellung führt zu unleserlichen Zeichen.
4. Timing des Schreibzyklus: Wenn du den delay(5) auslässt, speichert das EEPROM die Daten möglicherweise nicht korrekt. Erhöhe die Verzögerung bei Bedarf.
5. LEDs blinken nicht: Überprüfe die Verkabelung. Die rote LED ist mit D12 verbunden, die grüne mit D10. Beide Kathoden gehen an GND.

Vorschläge für Erweiterungen

• Sensordaten speichern und abrufen: Lies einen Temperatursensor aus und speichere den letzten Wert im EEPROM.
• Einen Taster hinzufügen: Verwende einen Drucktaster, um einen Lese- oder Schreibvorgang auszulösen.
• Auf 256 Bytes erweitern: Ändere den Code, um einen größeren Datenblock zu schreiben.
• EEPROM für Konfiguration nutzen: Speichere Kalibrierungswerte oder Benutzereinstellungen.

Probier es selbst aus!

Bereit zum Experimentieren? Öffne das Live-Beispiel in Velxio:

Pico I2C EEPROM R/W starten

Klicke auf die Schaltfläche Ausführen in der Editor-Symbolleiste, um zu kompilieren und zu simulieren. Beobachte die serielle Ausgabe in der Konsole – du solltest sehen, dass alle 8 Bytes erfolgreich zurückgelesen werden.

Nutze die Leinwand-Symbolleiste, um zu zoomen, zu schwenken und die Schaltung zu inspizieren.

Musst du weitere Komponenten hinzufügen? Öffne die Komponentenauswahl, um Teile zu durchsuchen.

Viel Spaß beim Simulieren!