Arduino UNO – I2C EEPROM beschreiben & lesen

In diesem Beitrag möchte ich dir zeigen, wie du einen EEPROM Baustein per I2C Schnittstelle am Arduino UNO beschreiben und lesen kannst.

Der hier verwendete EEPROM Baustein hat eine Speicherkapazität von 256K, dieses ist für die meisten Daten am Arduino ausreichend. Wenn du mehr Daten speichern möchtest, dann empfehle ich dir eine SD-Karte mit entsprechendem Modul.

Benötigte Ressourcen für den Anschluss des EEPROM an den Arduino UNO

In den nachfolgenden Abschnitten möchte ich dir zeigen wie du den EEPROM anschließt und programmierst, dafür benötigst du:

• einen Arduino UNO*,
• ein USB-Datenkabel*,
• ein EEPROM mit I2C Schnittstelle*,
• vier Breadboardkabel*, männlich-weiblich, 10 cm

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Technische Daten des EEPROM mit 256 K

Es gibt die EEPROMs in diversen Ausführungen, allgemein unterscheiden sich diese jedoch in der Speicherkapazität. Wie erwähnt verwende ich ein Modul mit 256 K Speicher.

Varianten	24C16 – 16 K 24C64 – 64 K 24C128 – 128 K 24C256 – 256 K
Betriebsspannung	2.7 V bis 5.5 V
Schnittstelle	I2C Auswahl der Adresse per Jumper
maximale Schreib-/Lese Zyklen	über 1 Million mal
Datensicherheit	speichern der Daten bis zu 40 Jahre

Aufbau des I2C EEPROM Moduls

Kommen wir zunächst zum Aufbau des EEPROM Moduls.

Mit den Jumpern A0 bis A2 können wir verschiedene I2C Adressen setzen und somit entweder mehrere dieser Module einsetzen oder bei Adressenkonflikt diesen lösen.

A0
I2C device found at address 0x19  !
I2C device found at address 0x51  !
I2C device found at address 0x59  !

A1
I2C device found at address 0x1A  !
I2C device found at address 0x52  !
I2C device found at address 0x5A  !

A2 & ohne Jumper
I2C device found at address 0x18  !
I2C device found at address 0x50  !
I2C device found at address 0x58  !

Die I2C Adressen habe ich mit dem I2C Scanner von Arduino Playground ermittelt.

Die Adressen wechselst du, indem du EINEN der Jumper auf die vordere Position setzt. In dem Bild ist der Jumper A0 aktiv und können die I2C Adressen 0x19, 0x51 & 0x59 verwendet werden.

Anschluss des EEPROM an den Arduino

Durch die I2C Schnittstelle ist zumindest der Anschluss sehr einfach. Du findest am Arduino die I2C Schnittstelle an den Pins analog A4 = SDA & analog A5 = SCL.

Die Schaltung ist dann wirklich recht einfach, denn wir müssen lediglich die nachfolgenden Pins verbinden:

I2C EEPROM	Arduino UNO
VCC	3.3V
GND	GND
SDA	analog A4
SCL	analog A5

Programmieren des EEPROMs in der Arduino IDE 2.0

Auf der offiziellen Seite von Arduino.cc findest du ein Beispiel, wo du lediglich deine I2C Adresse anpassen musst. Ich habe dieses einmal genommen und zu einer kleinen Bibliothek umgeschrieben / exportiert. Der Code wurde von mir nicht wesentlich verändert. Ich habe lediglich die Funktionen so aufbereitet, dass diese über eine Klasse geladen werden.

Du kannst dir diese von meinem GitHub Repository StefanDraeger/AT24C256EEPROM_lib als ZIP-Datei herunterladen.

Diese ZIP-Datei kannst du dann über Sketch > Include Library > Add ZIP. Library… in deine IDE integrieren.

Beispiel – schreiben & lesen von Daten eines EEPROMs

Das nachfolgende Beispiel findest du ebenfalls in der Bibliothek.

#include <at24c256eeprom.h>
#include <Wire.h>

//create object of type AT24C 
//with I2C Address 0x51
AT24C at24c256 = AT24C(0x51);

void setup() {
  //content to write
  char data[] = "Hello World!";
  //begin OneWire communication
  Wire.begin();
  //begin serial communication
  Serial.begin(9600);
  //write content from field data to eeprom
  at24c256.write_page(0, (byte *)data, sizeof(data));
  //tiny break for 100 ms.
  delay(100);
  //write message to serial interface
  Serial.println("Write data successfull.");
}

void loop() {
  //start with address 0
  int addr = 0;
  //read the first byte
  byte b = at24c256.read_byte(0);
  //as long as the value in the variable b
  //is not equal to 0 makes..
  while (b != 0) {
    //print character to serial interface
    Serial.print((char)b);
    //increment address
    addr++;
    //read content from new address
    b = at24c256.read_byte(addr);
  }
  //send linebreak to serial interface
  Serial.println(" ");
  //tiny break for 2 seconds
  delay(2000);
}

Wenn man das Beispiel auf den Arduino überspielt hat, wird nachfolgende Ausgabe erzeugt.

Wir können nun die nachfolgenden Zeilen aus dem Beispiel entfernen oder auskommentieren und erneut das Beispiel hochladen, um zu verifizieren, dass wirklich die Daten aus dem EEPROM geladen werden.