Arduino EEPROM

Inhalt

5 Minuten

Überblick

EEPROM des Arduino UNO R3

Das EEPROM (Electrically Erasable Programmable Read-Only Memory) ist eine kleine „Festplatte“. Allerdings fasst sie nur 1024 Byte. Jeder Speicherplatz ist 1 Byte groß und kann deshalb nur eine 1 Byte große Variable oder einen Teil einer anderen Variablen aufnehmen.
Der Inhalt bleibt nach dem Ausschalten erhalten.

EEPROM des ESP32

Der ESP32 hat keinen eigenen Baustein für das EEPROM, er nutzt vielmehr einen Teil des Flash-Speichers (non-volatile storage NVS) und zwar 512 Byte.
⇒ Beispiel: NVS mit Preferences

Funktionen der Bibliothek EEPROM

Schlüsselwort	Aktion
write(Speicherplatz, Wert)	beschreibt einen Speicherplatz nur für 1 Byte große Variable (byte, char)
update(Speicherplatz, Wert)	aktualisiert den Wert eines Speicherplatzes Im Unterschied zu write() wird der Wert nur geschrieben, wenn er sich vom bisherigen Wert unterscheidet. nur für 1 Byte große Variable (byte, char)
read(Speicherplatz, Wert)	liest den Wert an einem Speicherplatz nur für 1 Byte große Variable (byte, char)
put(Speicherplatz, Wert)	schreibt den Wert ungeachtet der Größe der Variable anwendbar für alle Variablen
get(Speicherplatz, Wert)	liest den Wert ungeachtet der Größe der Variable anwendbar für alle Variablen
length()	zeigt die Größe des EEPROMs an

Jeder Funktion muss EEPROM. vorangestellt werden.

Verschiedene Variablen speichern

byte

// eingebaute Bibliothek einbinden 
#include "EEPROM.h"

// nur für ESP32
#define EEPROM_GROESSE 6

byte Zufallszahl; 
byte MaxWuerfeln = 5; 
int Minimum = 1; 
int Maximum = 7; 

void setup() 
{ 
  // nur für ESP32
  // EEPROM.begin(EEPROM_GROESSE);

  Serial.begin(9600);
  
  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);
 
  // Zufallsgenerator starten   
  randomSeed(analogRead(A0)); 

  // Zufallszahlen schreiben   
  for (int i = 0; i < MaxWuerfeln; i++)   
  { 
    Zufallszahl = random(Minimum, Maximum); 
    EEPROM.write(i, Zufallszahl);   
  } 

  // Zufallszahlen lesen  
  for (byte i = 0; i < MaxWuerfeln; i++) 
  { 
    Serial.println(EEPROM.read(i));
  } 
} 

void loop() 
{  
  // bleibt leer, Programm wird nur einmal ausgeführt 
}

// eingebaute Bibliothek einbinden

#include "EEPROM.h"

// nur für ESP32

#define EEPROM_GROESSE 6

byte Zufallszahl;

byte MaxWuerfeln = 5;

int Minimum = 1;

int Maximum = 7;

void setup()

{

// nur für ESP32

// EEPROM.begin(EEPROM_GROESSE);

Serial.begin(9600);

// auf serielle Verbindung warten

while (!Serial);

delay(1000);

// Zufallsgenerator starten

randomSeed(analogRead(A0));

// Zufallszahlen schreiben

for (int i = 0; i < MaxWuerfeln; i++)

{

Zufallszahl = random(Minimum, Maximum);

EEPROM.write(i, Zufallszahl);

}

// Zufallszahlen lesen

for (byte i = 0; i < MaxWuerfeln; i++)

{

Serial.println(EEPROM.read(i));

}

void loop()

{

// bleibt leer, Programm wird nur einmal ausgeführt

}

char-Array

#include "EEPROM.h"

// ESP32
#define EEPROM_GROESSE 40

void setup() 
{ 
  // nur für ESP32
  // EEPROM.begin(EEPROM_GROESSE);

  Serial.begin(9600); 
  
  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);

  char BeispielString1[] = "Programmieren mit "; 
  char BeispielString2[] = "Arduino ist toll!"; 

  // Startadresse 
  int SpeicherAdresse = 0; 

  // ersten String schreiben 
  EEPROM.put(SpeicherAdresse, BeispielString1); 

  // Startadresse auf das Zeichen hinter das Ende des ersten Strings setzen 
  SpeicherAdresse = sizeof(BeispielString1); 

  // String schreiben 
  EEPROM.put(SpeicherAdresse, BeispielString2); 

  // ersten String lesen 
  for (int i = 0; i < sizeof(BeispielString1) - 1; i++)
  { 
    Serial.print(char(EEPROM.read(i)));
   }

  // zweiten String lesen 
  for (int i = SpeicherAdresse; i < SpeicherAdresse + sizeof(BeispielString2) - 1; i++) 
  { 
    Serial.print(char(EEPROM.read(i)));
  }
}

void loop()
{ 
  // bleibt leer -> das Programm soll nur einmal ausgeführt werden
}

#include "EEPROM.h"

// ESP32

#define EEPROM_GROESSE 40

void setup()

{

// nur für ESP32

// EEPROM.begin(EEPROM_GROESSE);

Serial.begin(9600);

// auf serielle Verbindung warten

while (!Serial);

delay(1000);

char BeispielString1[] = "Programmieren mit ";

char BeispielString2[] = "Arduino ist toll!";

// Startadresse

int SpeicherAdresse = 0;

// ersten String schreiben

EEPROM.put(SpeicherAdresse, BeispielString1);

// Startadresse auf das Zeichen hinter das Ende des ersten Strings setzen

SpeicherAdresse = sizeof(BeispielString1);

// String schreiben

EEPROM.put(SpeicherAdresse, BeispielString2);

// ersten String lesen

for (int i = 0; i < sizeof(BeispielString1) - 1; i++)

{

Serial.print(char(EEPROM.read(i)));

}

// zweiten String lesen

for (int i = SpeicherAdresse; i < SpeicherAdresse + sizeof(BeispielString2) - 1; i++)

{

Serial.print(char(EEPROM.read(i)));

}

void loop()

{

// bleibt leer -> das Programm soll nur einmal ausgeführt werden

}

int

#include "EEPROM.h"

// nur für ESP32
#define EEPROM_GROESSE 30

void setup()
{
  // nur für ESP32
  // EEPROM.begin(EEPROM_GROESSE);

  Serial.begin(9600);
  
  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);

  int Zahl1 = 12;
  int Zahl2 = 21;
 
  // "Hilfsvariable", in die das Ergebnis des Speicherauslesens geschrieben wird
  int Ergebnis;
 
  // 1. Zahl schreiben
  int Speicheradresse = 0;
  EEPROM.put(Speicheradresse, Zahl1);
 
  // 2. Zahl schreiben
  // Speicheradresse um Länge der Variable int verschieben
  Speicheradresse += sizeof(int);
  EEPROM.put(Speicheradresse, Zahl2);

  // Produkt berechnen und schreiben
  // Speicheradresse um Länge der Variable int verschieben
  Speicheradresse += sizeof(int);
  EEPROM.put(Speicheradresse, Zahl1 * Zahl2);

  // Speicheradresse auf Start setzen
  Speicheradresse = 0;
  
  // Daten in die "Hilfsvariable" Ergebnis einlesen und anzeigen
  EEPROM.get(Speicheradresse, Ergebnis);
  Serial.print(String(Ergebnis) + " * ");

  // Speicheradresse um Länge der Variable int verschieben
  Speicheradresse += sizeof(int);

  // Daten in die "Hilfsvariable" Ergebnis einlesen und anzeigen
  EEPROM.get(Speicheradresse, Ergebnis);
  Serial.print(String(Ergebnis) + " = ");
  Speicheradresse += sizeof(int);
  EEPROM.get(Speicheradresse, Ergebnis);
  Serial.print(Ergebnis);
}

 void loop()
 {
   // bleibt leer -> das Programm soll nur einmal ausgeführt werden
 }

#include "EEPROM.h"

// nur für ESP32

#define EEPROM_GROESSE 30

void setup()

{

// nur für ESP32

// EEPROM.begin(EEPROM_GROESSE);

Serial.begin(9600);

// auf serielle Verbindung warten

while (!Serial);

delay(1000);

int Zahl1 = 12;

int Zahl2 = 21;

// "Hilfsvariable", in die das Ergebnis des Speicherauslesens geschrieben wird

int Ergebnis;

// 1. Zahl schreiben

int Speicheradresse = 0;

EEPROM.put(Speicheradresse, Zahl1);

// 2. Zahl schreiben

// Speicheradresse um Länge der Variable int verschieben

Speicheradresse += sizeof(int);

EEPROM.put(Speicheradresse, Zahl2);

// Produkt berechnen und schreiben

// Speicheradresse um Länge der Variable int verschieben

Speicheradresse += sizeof(int);

EEPROM.put(Speicheradresse, Zahl1 * Zahl2);

// Speicheradresse auf Start setzen

Speicheradresse = 0;

// Daten in die "Hilfsvariable" Ergebnis einlesen und anzeigen

EEPROM.get(Speicheradresse, Ergebnis);

Serial.print(String(Ergebnis) + " * ");

// Speicheradresse um Länge der Variable int verschieben

Speicheradresse += sizeof(int);

// Daten in die "Hilfsvariable" Ergebnis einlesen und anzeigen

EEPROM.get(Speicheradresse, Ergebnis);

Serial.print(String(Ergebnis) + " = ");

Speicheradresse += sizeof(int);

EEPROM.get(Speicheradresse, Ergebnis);

Serial.print(Ergebnis);

}

void loop()

{

// bleibt leer -> das Programm soll nur einmal ausgeführt werden

}

float

#include "EEPROM.h"

// nur für ESP32
#define EEPROM_GROESSE 30

void setup()
{
  // nur für ESP32
  // EEPROM.begin(EEPROM_GROESSE);

  Serial.begin(9600);
  
  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);

  float Zahl1 = 12.56;
  float Zahl2 = 21.23;
 
  // "Hilfsvariable", in die das Ergebnis des Speicherauslesens geschrieben wird
  float Ergebnis;

  // formatierte Zahl , statt .
  String ErgebnisFormat;
 
  // 1. Zahl schreiben
  int Speicheradresse = 0;
  EEPROM.put(Speicheradresse, Zahl1);

  // 2. Zahl schreiben
  // Speicheradresse um Länge der Variable float verschieben
  Speicheradresse += sizeof(float);
  EEPROM.put(Speicheradresse, Zahl2);

  // Produkt berechnen und schreiben
  // Speicheradresse um Länge der Variable float verschieben
  Speicheradresse += sizeof(float);
  EEPROM.put(Speicheradresse, Zahl1 * Zahl2);

  // Speicheradresse auf Start setzen
  Speicheradresse = 0;

  // Daten in die "Hilfsvariable" Ergebnis einlesen und anzeigen
  EEPROM.get(Speicheradresse, Ergebnis);

  // Zahl formatieren, , statt .
  ErgebnisFormat = String(Ergebnis);
  ErgebnisFormat.replace(".", ",");
  Serial.print(ErgebnisFormat + " * ");

  // Speicheradresse um Länge der Variable float verschieben
  Speicheradresse += sizeof(float);

  // Daten in die "Hilfsvariable" Ergebnis einlesen und anzeigen
  EEPROM.get(Speicheradresse, Ergebnis);
  ErgebnisFormat = String(Ergebnis);
  ErgebnisFormat.replace(".", ",");
  Serial.print(ErgebnisFormat + " = ");
   
  Speicheradresse += sizeof(float);
  EEPROM.get(Speicheradresse, Ergebnis);
  ErgebnisFormat = String(Ergebnis);
  ErgebnisFormat.replace(".", ",");
  Serial.print(ErgebnisFormat);
}

void loop()
{
  // bleibt leer -> das Programm soll nur einmal ausgeführt werden
}

#include "EEPROM.h"

// nur für ESP32

#define EEPROM_GROESSE 30

void setup()

{

// nur für ESP32

// EEPROM.begin(EEPROM_GROESSE);

Serial.begin(9600);

// auf serielle Verbindung warten

while (!Serial);

delay(1000);

float Zahl1 = 12.56;

float Zahl2 = 21.23;

// "Hilfsvariable", in die das Ergebnis des Speicherauslesens geschrieben wird

float Ergebnis;

// formatierte Zahl , statt .

String ErgebnisFormat;

// 1. Zahl schreiben

int Speicheradresse = 0;

EEPROM.put(Speicheradresse, Zahl1);

// 2. Zahl schreiben

// Speicheradresse um Länge der Variable float verschieben

Speicheradresse += sizeof(float);

EEPROM.put(Speicheradresse, Zahl2);

// Produkt berechnen und schreiben

// Speicheradresse um Länge der Variable float verschieben

Speicheradresse += sizeof(float);

EEPROM.put(Speicheradresse, Zahl1 * Zahl2);

// Speicheradresse auf Start setzen

Speicheradresse = 0;

// Daten in die "Hilfsvariable" Ergebnis einlesen und anzeigen

EEPROM.get(Speicheradresse, Ergebnis);

// Zahl formatieren, , statt .

ErgebnisFormat = String(Ergebnis);

ErgebnisFormat.replace(".", ",");

Serial.print(ErgebnisFormat + " * ");

// Speicheradresse um Länge der Variable float verschieben

Speicheradresse += sizeof(float);

// Daten in die "Hilfsvariable" Ergebnis einlesen und anzeigen

EEPROM.get(Speicheradresse, Ergebnis);

ErgebnisFormat = String(Ergebnis);

ErgebnisFormat.replace(".", ",");

Serial.print(ErgebnisFormat + " = ");

Speicheradresse += sizeof(float);

EEPROM.get(Speicheradresse, Ergebnis);

ErgebnisFormat = String(Ergebnis);

ErgebnisFormat.replace(".", ",");

Serial.print(ErgebnisFormat);

}

void loop()

{

// bleibt leer -> das Programm soll nur einmal ausgeführt werden

}

Flash-Speicher

SRAM

Speichermanagement

Letzte Aktualisierung: Feb. 8, 2026 @ 23:04