INHALT
Das nichtflüchtige EEPROM des Arduino kann zur Speicherung wichtiger Daten verwendet werden. Es kann z.B. zum Speichern von Einstellungen und Systemparametern verwendet werden, so dass bei einem Stromausfall die Daten im EEPROM Arduino nicht verloren gehen. Im Folgenden wird die Arbeit mit dem EEPROM anhand von Beispielen zum Schreiben und Lesen von Daten mit Hilfe der Bibliotheksbefehle EEPROM.h erläutert.
Bestandteile:
- Arduino Uno / Arduino Nano / Arduino Mega
EEPROM ist eine Art Halbleiterspeicher, der das Lesen, Schreiben und Löschen von Daten mit Hilfe elektrischer Signale ermöglicht. Er speichert Daten auch dann, wenn keine Stromversorgung vorhanden ist. EEPROMs werden in verschiedenen Geräten wie Digitalkameras, Spielkonsolen, Mobiltelefonen und Computern verwendet, um Einstellungen, Konfigurationen und andere Serviceinformationen zu speichern.
Was ist das EEPROM Speichers Arduino?
Der EEPROM (Electrically Erasable Programmable Read-Only Memory) im Arduino ist ein nichtflüchtiger Speicher, der Informationen auch nach einem Stromausfall über Jahrzehnte speichern kann. Die Zellen des EEPROM-Speichers können bei einer Temperatur von mindestens 24°C mehrere hunderttausend Mal neu beschrieben und jederzeit wieder ausgelesen werden. Die EEPROM-Kapazität der gängigsten Arduino-Boards ist wie folgt:
ATmega168 (Arduino Nano) – 512 Byte;
ATmega328 (Arduino Uno oder Arduino Nano) – 1 KByte;
ATmega1280, ATmega2560 (Arduino Mega) – 4 KByte.
Das Schreiben eines Bytes in das EEPROM dauert ca. 3,3 µs, das Lesen eines Bytes ca. 0,4 µs. Jedes Byte (Zelle) im Arduino EEPROM ist standardmäßig auf 255 gesetzt (d.h. es wurden noch keine Daten in die Zelle geschrieben). Wenn die Daten mehr als ein Byte belegen (z.B. eine Zahl größer als 255), werden sie auf mehrere Zellen verteilt. Dies ist wichtig, wenn Sie große Zahlen oder Zeichenketten schreiben.
Arduino EEPROM.h Library Befehle Beschreibung
Funktion |
Kurzbeschreibung |
read() |
EEPROM.read(address) Liest ein Byte aus dem Arduino EEPROM an der Adresse address. |
write() |
EEPROM.write(address, value) Schreibt ein Byte mit dem Wert value in das EEPROM an der Adresse address. |
update() |
EEPROM.update(address, value) Ein Analogon der Funktion write(), aber neue Daten werden nur dann in die Zelle geschrieben, wenn sie sich von den bereits geschriebenen Daten unterscheiden. Mit dieser Funktion können Sie die Lebensdauer des EEPROM-Speichers verlängern. |
get() |
EEPROM.get(address, data) Liest einen beliebigen Datentyp aus dem Arduino EEPROM an der Adresse address. Die data können von beliebigem Typ sein, z.B. int oder float. |
put() |
EEPROM.put(address, data) Schreibt eine beliebige Art von Daten in das Arduino EEPROM an der Adresse address. Die Funktion schreibt nur andere Daten in die Zelle. |
EEPROM[] |
EEPROM[address] Erlaubt die Behandlung der Arduino EEPROM-Bytes als Array. Bytes können gelesen und geschrieben werden. |
Schreiben, Lesen und Löschen von EEPROM Arduino
Laden Sie den folgenden Code auf den Arduino. Wenn Sie den Arduino IDE Port Monitor öffnen, erhalten Sie Informationen über die Größe des Eeprom-Speichers in Bytes sowie Informationen über den Inhalt jeder Zelle. Wenn der Eeprom-Speicher noch nicht benutzt wurde, ist der Wert jeder Zelle 255. Wenn Sie mit einem ATmega168-basierten Mikrocontroller Arduino arbeiten, endet die while-Schleife bei 512 Zellen.
Programm Arduino für Lesen von Daten EEPROM.read()
#include "EEPROM.h" int address; byte value; void setup() { Serial.begin(9600); // die Speichergröße in Bytes herausfinden Serial.println(EEPROM.length()); delay(1000); // Anzeige des Wertes jeder Zelle auf dem Portmonitor while (address < EEPROM.length()) { value = EEPROM.read(address); Serial.print("Address: " + String(address)); Serial.println(", value: " + String(value)); address++; delay(100); } } void loop() { }
Das folgende Programm schreibt bei jedem Neustart des Mikrocontrollers den Wert 100 in Zelle 1 – Befehl EEPROM.write(1, 100);
Im Gegensatz zu diesem Befehl schreibt die folgende Funktion – EEPROM.update(2, 100);
– die Information nur einmal in Zelle 2. Da die Speicherressourcen immer noch begrenzt sind, ist es besser, den Befehl EEPROM.update() zu verwenden. Laden Sie den folgenden Code in das Arduino.
Programm für Schreiben EEPROM.write() und EEPROM.update()
#include "EEPROM.h" int address; byte value; void setup() { Serial.begin(9600); // die Speichergröße in Bytes herausfinden Serial.println(EEPROM.length()); delay(1000); // Schreibe den Wert "100" in 1 Zelle EEPROM.write(1, 100); // Schreibe den Wert "100" in 2 Zelle EEPROM.update(2, 100); delay(1000); // Anzeige des Wertes jeder Zelle auf dem Portmonitor while (address < EEPROM.length()) { value = EEPROM.read(address); Serial.print("Address: " + String(address)); Serial.println(", value: " + String(value)); address++; delay(100); } } void loop() { }
Um den nichtflüchtigen Speicher des Arduino-EEPROMs zu löschen (das EEPROM auf die Werkseinstellungen zurückzusetzen), müssen alle Speicherzellen mit dem Wert 255 überschrieben werden. Dazu kann man eine for- oder while-Schleife im Programm verwenden. Dies ist ein ziemlich einfacher Sketch, um alle Informationen aus dem nichtflüchtigen Speicher des Arduino-Mikrocontrollers zu löschen.
Programm Arduino für Löschen des EEPROM Speichers
#include "EEPROM.h" int address; void setup() { // Überschreiben aller Zellen im EEPROM Speicher while (address < EEPROM.length()) { EEPROM.update(address, 255); address++; } } void loop() { }
Als Beispiel soll eine Zahl größer als 255 im EEPROM gespeichert werden. Beispielsweise muss die Zahl 999 durch den Multiplikator (High-Byte) dividiert und die fehlende Zahl (Low-Byte) in das EEPROM geschrieben werden. Somit belegt die Zahl 999 zwei Speicherplätze, d.h. 999 = 3×256 + 231. Um die Zahl auf dem Monitor des Arduino-IDE-Ports anzuzeigen, muss sie mit der Funktion word() „zusammengesetzt“ werden.
Programm als Beispiel für die Arbeit mit dem EEPROM
#include "EEPROM.h" // die im EEPROM zu speichernde Nummer int num = 999; void setup() { Serial.begin(9600); // 999 in High- und Low-Bytes zerlegen byte hi = highByte(num); byte low = lowByte(num); // High-Byte in Zelle 1, Low-Byte in Zelle 2 speichern EEPROM.update(1, hi); EEPROM.update(2, low); delay(1000); // Auslesen der Informationen aus EEPROM Zelle 1 und 2 byte val1 = EEPROM.read(1); byte val2 = EEPROM.read(2); Serial.println("highByte: " + String(val1)); Serial.println("lowByte: " + String(val2)); // die Zahl 999 eingeben und auf dem Portmonitor anzeigen int NUM = word(hi, low); Serial.println("int num: " + String(NUM)); } void loop() { }
Schlussfolgerung. Das Hauptproblem beim Speichern großer Zahlen (int, float) im EEPROM besteht darin, nicht versehentlich die gewünschte Zelle mit neuen Informationen zu überschreiben. Um dies zu erreichen, muss die Größe der Information mit Hilfe der Funktionen EEPROM.put() und EEPROM.get() berücksichtigt werden. Wenn Sie Fragen haben, können Sie diese gerne in den Kommentaren zu diesem Artikel stellen.
Schreibe einen Kommentar