Basis · 16 min leestijd

Arduino EEPROM-tutorial: lezen, schrijven, updaten, put en get

Arduino EEPROM uitgelegd: 1024 bytes op de Uno, read, write, update, put en get, de limiet van 100.000 schrijfacties, tellers en wachtwoorden opslaan, ESP32 Preferences.

Het Arduino EEPROM is een klein permanent geheugen dat zijn inhoud behoudt, ook als het board geen stroom meer krijgt. De ATmega328P op de Arduino Uno, Nano en Pro Mini heeft 1024 bytes EEPROM, en je gebruikt het met de commando's EEPROM.read(), EEPROM.write(), EEPROM.update(), EEPROM.put() en EEPROM.get() van de EEPROM-bibliotheek die met de Arduino IDE wordt meegeleverd. Het RAM waarin je variabelen staan, wordt bij elke herstart gewist, maar een instelling, teller of wachtwoord die je naar EEPROM schrijft, is er nog als het board weer opstart.

In deze gids zie je hoe EEPROM werkt, hoeveel elk board ervan heeft, hoe de commando's verschillen en de vraag die iedereen stelt: wat de levensduur van ongeveer 100.000 schrijfacties in de praktijk echt betekent. Daarna bouwen we stap voor stap een teller die zijn waarde onthoudt na stroomuitval, een settings-structuur die een wachtwoord en opties in één keer opslaat, en een ringbuffer die de schrijflevensduur met 16 vermenigvuldigt. In de laatste delen leer je hoe je hetzelfde doet op de ESP32, die geen echt EEPROM heeft, met de Preferences-bibliotheek, en op de Raspberry Pi Pico met het MicroPython-bestandssysteem.

Arduino Uno: de ATmega328P-processor bevat 1 KB EEPROM
Het EEPROM van de Arduino Uno is geen aparte chip; het zit in de ATmega328P en bewaart 1024 bytes permanente data op de adressen 0–1023.

Wat is EEPROM en hoe werkt het?

EEPROM staat voor Electrically Erasable Programmable Read-Only Memory. Elke geheugencel slaat informatie op als een elektrische lading die opgesloten zit in een geïsoleerde gate, en die lading blijft staan als de stroom uitvalt. Zie het EEPROM van de Uno als een kast met 1024 laden: elke la heeft een adres van 0 tot 1023 en bevat precies 1 byte, een getal tussen 0 en 255. Een cel die nog nooit is beschreven, leest 255 (0xFF). Lezen gaat vrijwel direct en zonder limiet; schrijven duurt ongeveer 3,3 ms per byte en slijt de cel een beetje. De datasheet van de ATmega328P specificeert minstens 100.000 schrijf-/wiscycli per EEPROM-cel en 100 jaar databehoud bij 25 °C.

KenmerkFlash (programmageheugen)SRAMEEPROM
Grootte op de Uno32 KB (0,5 KB voor de bootloader)2 KB1 KB (1024 bytes)
Wat wordt er opgeslagen?De sketch die je hebt geüploadVariabelen, arraysInstellingen, tellers, highscores
Bij stroomverliesBlijft behoudenGewistBlijft behouden
Beschrijfbaar terwijl de sketch draait?Normaal niet (alleen lezen via PROGMEM)Ja, onbeperktJa, met de EEPROM-bibliotheek
SchrijfduurzaamheidOngeveer 10.000OnbeperktOngeveer 100.000 per cel
SchrijfsnelheidAlleen bij het uploadenEén klokcyclusOngeveer 3,3 ms per byte

Kortom: SRAM is een whiteboard en EEPROM is een notitieboekje. Je kunt het whiteboard zo vaak beschrijven en uitwissen als je wilt, maar alles is weg als het licht uitgaat; wat je in het notitieboekje schrijft, blijft staan, maar je kunt niet eindeloos dezelfde pagina wissen en herschrijven. Daarom is EEPROM ideaal voor informatie die klein is en zelden verandert: kalibratiewaarden, gebruikersinstellingen, helderheid of volume, de highscore van een spel, een deurcode, geregistreerde RFID-kaarten of de laatste stand van een lamp. Voor grote data die vaak wordt geschreven, zoals een temperatuurlog die elke seconde meet, is een SD-kaartmodule de betere keuze. Vraag je je af waarom het RAM zo snel vol raakt? Lees dan Arduino heeft te weinig geheugen.

Hoeveel EEPROM heeft elk board?

BoardProcessorEEPROMOpmerking
Arduino Uno R3, Nano, Pro MiniATmega328P1024 bytesEcht EEPROM
Arduino Mega 2560ATmega25604096 bytesEcht EEPROM
Arduino Leonardo, MicroATmega32U41024 bytesEcht EEPROM
Arduino Nano EveryATmega4809256 bytesEcht EEPROM, maar klein
Arduino Uno R4 Minima, WiFiRenesas RA4M18 KBDataflash; de EEPROM-bibliotheek werkt met dezelfde commando's
ESP32ESP32 (Xtensa)GeenNVS-partitie in flash; Preferences aanbevolen
ESP8266 (NodeMCU, Wemos D1)ESP8266GeenGeëmuleerd in flash; vereist EEPROM.begin() en commit()
Raspberry Pi PicoRP2040GeenEen bestand in MicroPython, geëmuleerd EEPROM in flash met de Arduino-core

Als je code tussen boards verhuist, zet de EEPROM-grootte dan niet vast in de code; EEPROM.length() geeft de echte EEPROM-grootte van het board terug (1024 op de Uno, 4096 op de Mega), zodat dezelfde wis- of dumpcode overal werkt. Voor het overige geheugen en de pins van de Uno zie je Arduino Uno-pins, en voor het kiezen van een board lees je Welke Arduino moet ik kopen?.

EEPROM-commando's: read, write, update, put en get

De EEPROM-bibliotheek zit in het boardpakket, dus er hoeft niets geïnstalleerd te worden; zet gewoon de regel #include <EEPROM.h> bovenaan je sketch. Adressen beginnen bij 0 en eindigen op de Uno bij 1023. De tabel hieronder vat samen wat elk commando doet en of het de cellen slijt:

CommandoWat het doetGrootteSlijtage
EEPROM.read(address)Leest één byte (0–255)1 byteGeen, lezen is gratis
EEPROM.write(address, value)Herschrijft de byte bij elke aanroep1 byteGebruikt bij elke aanroep een cyclus
EEPROM.update(address, value)Leest eerst en schrijft alleen als de waarde verschilt1 byteAlleen als de waarde verandert
EEPROM.put(address, data)Schrijft een int, float, array of struct byte voor byte; gebruikt intern updatesizeof(data)Alleen de bytes die veranderd zijn
EEPROM.get(address, variable)Leest terug wat put heeft geschreven, als hetzelfde typesizeof(variable)Geen
EEPROM[address]Toegang als bij een array; lezen is gratis, toewijzen met = werkt als write1 byteBij elke toewijzing
EEPROM.length()Geeft de totale EEPROM-grootte terug-Geen
EEPROM.write() en EEPROM.read() verwerken maar één byte. Als je een getal groter dan 255 schrijft, zoals 300, compileert de sketch zonder fout, maar wordt alleen de lage byte opgeslagen: 300 − 256 = 44. Gebruik voor data van meerdere bytes, zoals int, long, float en structs, altijd EEPROM.put() en EEPROM.get(). Ook de toewijzing EEPROM[5] = x werkt als write, niet als update.

Eerste sketch: schrijven naar en lezen uit EEPROM

C++ (Arduino IDE)
1#include <EEPROM.h>
2
3void setup() {
4  Serial.begin(9600);
5  Serial.print(F("EEPROM boyutu / size: "));
6  Serial.println(EEPROM.length());            // Uno'da 1024 / 1024 on the Uno
7
8  byte first = EEPROM.read(0);                // 0. adresi oku / read address 0
9  Serial.print(F("Adres 0 / address 0: "));
10  Serial.println(first);                      // ilk seferde 255 / 255 the first time
11
12  EEPROM.update(0, 42);                       // farklıysa yazar / writes only if different
13  EEPROM.write(1, 7);                         // her seferinde yazar / writes every time
14
15  int number = 300;
16  EEPROM.put(10, number);                     // int = 2 bayt: 10 ve 11 / int = 2 bytes: 10 and 11
17  float temperature = 23.75;
18  EEPROM.put(12, temperature);                // float = 4 bayt: 12-15 / float = 4 bytes: 12-15
19
20  int readNumber;
21  float readTemperature;
22  EEPROM.get(10, readNumber);                 // put ile aynı tür / same type as put
23  EEPROM.get(12, readTemperature);
24  Serial.println(readNumber);                 // 300
25  Serial.println(readTemperature);            // 23.75
26
27  EEPROM.update(20, 300);                     // HATA: yalnız alt bayt (44) kalır / BUG: only the low byte (44) is kept
28  Serial.println(EEPROM.read(20));            // 44
29}
30
31void loop() {}

Upload de sketch en open de Serial Monitor op 9600 baud. Bij de eerste run leest adres 0 255, omdat die cel nog nooit is beschreven. Druk nu op de resetknop van het board of haal de USB-kabel eruit en steek hem er weer in: nu leest het 42. Dat is het bewijs dat EEPROM zijn data behoudt. De write()-regel voor adres 1 herschrijft de cel daarentegen bij elke start, ook al is de waarde altijd 7; met update() zou hij alleen de eerste keer schrijven. De waarde 300 op de laatste regel laat de valkuil uit de waarschuwing hierboven zien, en op het scherm verschijnt 44. Als de instelling Compiler warnings in Preferences op iets anders staat dan None, markeert de compiler deze regel met large integer implicitly truncated to unsigned type.

Bij put() en get() moet je weten hoeveel bytes elk stukje data inneemt; anders schrijf je twee variabelen over elkaar heen en raakt er een beschadigd. In het voorbeeld neemt de int de adressen 10 en 11 in, dus de float begint op adres 12. Dit zijn de groottes van de datatypes op de Uno:

DatatypeGrootte op de UnoBereikVoorbeeldgebruik
byte, bool, char1 byte0–255, true/false of één tekenAan/uit-stand, modusselectie
int2 bytes−32.768 tot 32.767Kalibratie-offset
unsigned int, uint16_t2 bytes0–65.535Highscore van een spel
long, unsigned long4 bytesOngeveer ±2,1 miljard of 0–4,29 miljardTeller die lang doorloopt
float4 bytes6–7 cijfers nauwkeurigheidKalibratiefactor van een sensor
char array[10]10 bytes9 tekens plus de afsluiterWachtwoord, apparaatnaam
Maak bovenaan je sketch een adreskaart, zoals const int ADDR_MODE = 0; const int ADDR_SCORE = 1; const int ADDR_CAL = 3;. Bereken het volgende adres altijd als het vorige adres + sizeof(vorige data), en laat er een paar bytes tussen vrij zodat je later nieuwe velden kunt toevoegen.

Schrijfduurzaamheid van EEPROM: wat betekent de limiet van 100.000?

100.000 schrijfacties klinkt veel, maar een slecht opgebouwde sketch kan er in enkele minuten doorheen. De formule voor de levensduur is simpel: levensduur = 100.000 ÷ hoe vaak je naar dezelfde cel schrijft. Het belangrijkste is dat de limiet voor elke cel apart geldt, niet voor het EEPROM als geheel; als je steeds naar hetzelfde adres blijft schrijven, slijt alleen die cel. Lezen heeft helemaal geen invloed op de levensduur. De tabel laat zien hoe lang een cel meegaat als hetzelfde adres met verschillende snelheden wordt beschreven:

Hoe vaak hetzelfde adres wordt beschrevenGeschatte levensduur
write() in loop() zonder delay (ongeveer 300 keer per seconde)5–6 minuten
Elke secondeOngeveer 28 uur
Elke minuutOngeveer 69 dagen
Elke 10 minutenOngeveer 1,9 jaar
Eén keer per uurOngeveer 11 jaar
10 keer per dagOngeveer 27 jaar

100.000 is het minimum dat de fabrikant garandeert; veel chips gaan veel langer mee, maar ontwerp je project daar niet op. Een versleten cel valt niet plotseling uit; hij begint de waarde die je schreef niet meer vast te houden en sommige bits kantelen vanzelf. Als dat gebeurt, kun je de data naar een ander adres verplaatsen, want de andere cellen worden er niet door beïnvloed. Zo verleng je de levensduur:

  • Gebruik update() en put(): Beide lezen de cel voor het schrijven en schrijven helemaal niet als de waarde gelijk is.
  • Schrijf alleen bij een wijziging: Sla een instelling op als de gebruiker die echt verandert, niet bij elke ronde door loop().
  • Stel het opslaan uit: Als een waarde snel achter elkaar verandert, schrijf hem dan één keer een paar seconden na de laatste wijziging; met millis() gaat dat makkelijk.
  • Schrijf bij gebeurtenissen: Sla de highscore op als het spel eindigt en menu-instellingen als de gebruiker het menu verlaat.
  • Spreid de schrijfacties: Schrijf een teller die vaak verandert om beurten naar meerdere adressen in plaats van naar één (zie het ringbuffer-voorbeeld hieronder).
  • Gebruik extern geheugen als dat nodig is: Kies voor heel frequent opslaan een extern EEPROM met 1 miljoen cycli, FRAM of een SD-kaart.

Voorbeeld 1: een teller die stroomuitval overleeft

In het eerste voorbeeld bouwen we een teller die bij elke druk op een knop omhooggaat en verdergaat waar hij was gebleven nadat het board uit- en weer aangezet is. Sluit het ene pootje van de knop aan op D2 en het andere op GND; we gebruiken de interne pull-upweerstand, dus er is geen extra weerstand nodig (details in Een knop aansluiten op Arduino, pinlocaties in de tool Pinout). De truc is dat de sketch de teller niet bij elke druk opslaat, maar 5 seconden na de laatste druk. Zelfs als iemand 20 keer achter elkaar op de knop drukt, wordt het EEPROM dus maar één keer beschreven.

C++ (Arduino IDE)
1#include <EEPROM.h>
2
3const byte BUTTON_PIN = 2;                     // buton D2 ile GND arasında / button between D2 and GND
4const int  COUNT_ADDR = 0;                     // sayaç 0-3. baytlarda / counter in bytes 0-3
5const unsigned long SAVE_DELAY = 5000;         // son basıştan 5 sn sonra yaz / write 5 s after the last press
6
7unsigned long count = 0;
8bool dirty = false;                            // kaydedilmemiş değişiklik / unsaved change
9unsigned long lastPress = 0;
10unsigned long lastChange = 0;
11bool lastReading = HIGH;
12bool stableState = HIGH;
13
14void setup() {
15  Serial.begin(9600);
16  pinMode(BUTTON_PIN, INPUT_PULLUP);
17  EEPROM.get(COUNT_ADDR, count);
18  if (count == 0xFFFFFFFF) count = 0;          // boş EEPROM / blank EEPROM
19  Serial.print(F("Kayitli sayac / stored count: "));
20  Serial.println(count);
21}
22
23void loop() {
24  bool reading = digitalRead(BUTTON_PIN);
25  if (reading != lastReading) {                // pin değişti, sayacı başlat / pin changed, restart timer
26    lastChange = millis();
27    lastReading = reading;
28  }
29  if (millis() - lastChange > 30 && reading != stableState) {   // 30 ms sabit kaldı / stable for 30 ms
30    stableState = reading;
31    if (stableState == LOW) {                  // yeni basış / new press
32      count++;
33      dirty = true;
34      lastPress = millis();
35      Serial.println(count);
36    }
37  }
38
39  if (dirty && millis() - lastPress > SAVE_DELAY) {   // sessiz dönemden sonra yaz / write after a quiet period
40    EEPROM.put(COUNT_ADDR, count);
41    dirty = false;
42    Serial.println(F("EEPROM'a yazildi / saved to EEPROM"));
43  }
44}

De variabele dirty betekent dat er een wijziging in RAM is die nog niet is opgeslagen. De teller is een unsigned long, dus hij neemt 4 bytes in (adressen 0–3) en kan meer dan 4 miljard keer drukken tellen. In een leeg EEPROM zijn die vier bytes 0xFF, dus bij de eerste start lees je 4.294.967.295; als de code die waarde ziet, begint hij de teller bij nul. Omdat put() alleen de bytes schrijft die veranderd zijn, slijt meestal alleen de laagste byte terwijl de teller oploopt. Als de stroom wegvalt binnen de 5 seconden vóór een opslag, gaan de laatste drukken verloren; dat is een kleine prijs voor het beschermen van het EEPROM.

Voorbeeld 2: instellingen en een wachtwoord opslaan in een struct

In plaats van meerdere instellingen naar losse adressen te schrijven, is het netter en veiliger ze in een struct te verzamelen en met één put() op te slaan. In dit voorbeeld slaan we de helderheid van de led en een wachtwoord van 4–6 tekens op. De eerste twee velden van de structuur zijn essentieel: magic (een magisch getal) vertelt ons of de instellingen van deze sketch echt naar EEPROM zijn geschreven, en version voorkomt dat oude, incompatibele data wordt gelezen nadat je later een nieuw veld aan de structuur toevoegt. Als een van beide niet klopt, schrijft de sketch de standaardinstellingen.

C++ (Arduino IDE)
1#include <EEPROM.h>
2
3const uint16_t MAGIC = 0xB6A1;                 // "ayar yazıldı" işareti / "settings written" marker
4const byte VERSION = 1;                        // yapı değişince artır / bump when the struct changes
5const int  SETTINGS_ADDR = 0;
6const byte LED_PIN = 9;                        // PWM pini / PWM pin
7
8struct Settings {
9  uint16_t magic;
10  byte version;
11  char password[7];                            // en çok 6 karakter + '\0' / up to 6 chars + '\0'
12  byte brightness;                             // LED parlaklığı 0-255 / LED brightness 0-255
13};
14
15Settings cfg;
16
17void writeDefaults() {
18  cfg.magic = MAGIC;
19  cfg.version = VERSION;
20  strcpy(cfg.password, "1234");
21  cfg.brightness = 128;
22  EEPROM.put(SETTINGS_ADDR, cfg);
23}
24
25void setup() {
26  Serial.begin(9600);
27  pinMode(LED_PIN, OUTPUT);
28  EEPROM.get(SETTINGS_ADDR, cfg);
29  if (cfg.magic != MAGIC || cfg.version != VERSION) {   // ilk açılış ya da eski yapı / first boot or old layout
30    writeDefaults();
31    Serial.println(F("Varsayilan ayarlar yazildi / defaults written"));
32  }
33  analogWrite(LED_PIN, cfg.brightness);
34  Serial.print(F("Ayar boyutu / settings size: "));
35  Serial.println(sizeof(Settings));            // Uno'da 11 bayt / 11 bytes on the Uno
36  Serial.println(F("Komutlar / commands: b0-255   p<eski>,<yeni>   ?"));
37}
38
39void loop() {
40  if (!Serial.available()) return;
41  String line = Serial.readStringUntil('\n');
42  line.trim();
43
44  if (line.startsWith("b")) {                  // örnek / example: b200
45    cfg.brightness = constrain(line.substring(1).toInt(), 0, 255);
46    analogWrite(LED_PIN, cfg.brightness);
47    EEPROM.put(SETTINGS_ADDR, cfg);            // yalnız değişen bayt yazılır / only the changed byte is written
48    Serial.println(F("Parlaklik kaydedildi / brightness saved"));
49  } else if (line.startsWith("p")) {           // örnek / example: p1234,5678
50    int comma = line.indexOf(',');
51    if (comma < 0) {
52      Serial.println(F("Bicim / format: p1234,5678"));
53      return;
54    }
55    String oldPw = line.substring(1, comma);
56    String newPw = line.substring(comma + 1);
57    if (oldPw != cfg.password) {
58      Serial.println(F("Eski sifre yanlis / wrong old password"));
59    } else if (newPw.length() < 4 || newPw.length() > 6) {
60      Serial.println(F("Yeni sifre 4-6 karakter olmali / new password must be 4-6 chars"));
61    } else {
62      newPw.toCharArray(cfg.password, sizeof(cfg.password));
63      EEPROM.put(SETTINGS_ADDR, cfg);
64      Serial.println(F("Sifre degisti / password changed"));
65    }
66  } else if (line == "?") {
67    Serial.print(F("Parlaklik / brightness: "));
68    Serial.println(cfg.brightness);
69  }
70}

Sluit de led via een ledweerstand aan op D9 (220 ohm is prima); D9 is een PWM-pin. Open de Serial Monitor op 9600 baud, stel het regeleinde in op New Line en probeer deze commando's: b200 zet de helderheid op 200, p1234,5678 verandert het wachtwoord van 1234 in 5678 en ? toont de huidige helderheid. Als je het board uit- en weer aanzet, komt de led terug op dezelfde helderheid en werkt het nieuwe wachtwoord nog steeds. De struct neemt 11 bytes in op de Uno; omdat put() alleen de bytes schrijft die veranderd zijn, slijt het wijzigen van de helderheid één enkele cel. Je kunt dezelfde structuur aanpassen voor een codeslot met keypad of de 4-byte-ID's van toegestane kaarten in een array opslaan met de RFID RC522. Als seriële commando's nieuw voor je zijn, lees dan Arduino Serial Monitor.

Zet nooit een String-object in EEPROM. Een String bevat het adres en de lengte van de tekst in RAM, niet de tekst zelf; als je EEPROM.put(0, name) aanroept, gaan een paar bytes aan pointer naar EEPROM in plaats van de tekst, en na een herstart lees je onzin. Sla tekst altijd op als een char array met vaste grootte, zoals in het voorbeeld. EEPROM is bovendien niet versleuteld: iedereen die een programmer op het board aansluit, kan het lezen. Deze aanpak is prima voor hobbyslotjes, niet voor alles wat echte beveiliging nodig heeft.

De schrijflevensduur vermenigvuldigen: een ringbuffer (wear leveling)

Als je een vaak bijgewerkte teller steeds naar hetzelfde adres schrijft, slijt die ene cel snel. Met een ringbuffer schrijf je de waarde om beurten naar verschillende slots: één opslag gaat naar het ene slot, de volgende naar het volgende slot, en na het laatste slot begin je weer vooraan. Elk slot wordt maar één keer per 16 opslagen beschreven, dus de levensduur wordt 16 keer zo lang, ongeveer 1,6 miljoen opslagen. Bij het opstarten worden alle slots gelezen om de nieuwste waarde te vinden; omdat de teller alleen maar omhooggaat, is de grootste waarde de nieuwste.

C++ (Arduino IDE)
1#include <EEPROM.h>
2
3const int  RING_START = 100;                   // halka 100. adresten başlar / ring starts at address 100
4const byte SLOTS = 16;                         // 16 yuva x 4 bayt = 64 bayt / 16 slots x 4 bytes = 64 bytes
5
6uint32_t counter = 0;
7byte slot = 0;
8
9void loadCounter() {
10  for (byte i = 0; i < SLOTS; i++) {
11    uint32_t v;
12    EEPROM.get(RING_START + i * 4, v);
13    if (v != 0xFFFFFFFF && v >= counter) {     // en büyük değer en yenisidir / the largest value is the newest
14      counter = v;
15      slot = i;
16    }
17  }
18}
19
20void saveCounter() {
21  slot = (slot + 1) % SLOTS;                   // her kayıtta sıradaki yuva / next slot on every save
22  EEPROM.put(RING_START + slot * 4, counter);
23}
24
25void setup() {
26  Serial.begin(9600);
27  loadCounter();
28  counter++;                                   // örnek: her açılışı say / example: count every boot
29  saveCounter();
30  Serial.print(F("Acilis sayisi / boot count: "));
31  Serial.println(counter);
32  Serial.print(F("Kullanilan yuva / slot used: "));
33  Serial.println(slot);
34}
35
36void loop() {}

Het voorbeeld verhoogt de teller bij elke start; je kunt dat vervangen door een knop, een sensorgebeurtenis of een urenteller. Meer slots betekent evenredig meer levensduur: 64 slots nemen 256 bytes in en gaan ongeveer 6,4 miljoen opslagen mee. Als het board met andere sketches is gebruikt, kan er oude data in het ringgebied staan, dus wis het EEPROM vóór het eerste gebruik met de onderstaande code. In geavanceerdere projecten kun je ook een CRC-controlesom toevoegen, zoals in Arduino's eigen voorbeeld eeprom_crc, om beschadigde data op te sporen.

Hoe reset je het EEPROM? Wist uploaden het?

Een gewone upload via de USB-kabel schrijft alleen het programmageheugen; de data in EEPROM blijft behouden. Als je een nieuw project uploadt, blijven de instellingen van het vorige project dus in EEPROM staan en kan de nieuwe code waarden lezen die hij niet verwacht. Op de Uno wordt het EEPROM alleen gewist als je een ISP-programmer gebruikt met Sketch > Upload Using Programmer of Tools > Burn Bootloader; deze handelingen wissen de hele chip, en de EESAVE-bit die het EEPROM beschermt staat in de fuse-instellingen van de Uno uit. Upload deze sketch één keer om het EEPROM zelf te wissen:

C++ (Arduino IDE)
1#include <EEPROM.h>
2
3void setup() {
4  for (uint16_t i = 0; i < EEPROM.length(); i++) {
5    EEPROM.update(i, 255);                     // fabrika durumu 0xFF / factory state 0xFF
6  }
7  pinMode(LED_BUILTIN, OUTPUT);
8  digitalWrite(LED_BUILTIN, HIGH);             // LED yandı: bitti / LED on: done
9}
10
11void loop() {}

Het voorbeeld File > Examples > EEPROM > eeprom_clear van de Arduino IDE schrijft 0 naar elke cel; wij zetten de cellen terug in hun fabrieksstaat van 255. Zo herkent code die een magisch getal of 0xFF controleert het EEPROM weer als leeg. Omdat we update() gebruiken, worden cellen die al 255 zijn helemaal niet beschreven. Het beschrijven van alle 1024 cellen op de Uno duurt hooguit ongeveer 3,4 seconden; als de ingebouwde led gaat branden, is het klaar. Upload daarna je echte sketch.

EEPROM op de ESP32: de Preferences-bibliotheek

De ESP32 heeft geen echt EEPROM. Permanente data staat in de NVS-partitie (Non-Volatile Storage) van het externe flashgeheugen; in de standaard partitietabel is dit gebied 20 KB. De aanpak die Espressif aanbeveelt is de Preferences-bibliotheek die met het ESP32-boardpakket wordt meegeleverd. Preferences slaat data op via namespace- en key-namen in plaats van adressen, dus je hoeft nooit te onthouden op welk adres de teller stond. NVS schrijft elke nieuwe waarde naar de volgende vrije entry op de pagina en markeert de oude als gewist, dus wear leveling gebeurt automatisch. Namen van namespaces en keys mogen maximaal 15 tekens lang zijn en zijn hoofdlettergevoelig. Ben je nieuw met de ESP32, begin dan met Wat is de ESP32.

C++ (Arduino IDE)
1#include <Preferences.h>
2
3Preferences prefs;
4
5void setup() {
6  Serial.begin(115200);
7  prefs.begin("bluegrays", false);             // ad alanı; false = okuma + yazma / namespace; false = read + write
8
9  uint32_t boots = prefs.getUInt("boots", 0);  // anahtar yoksa 0 / 0 if the key is missing
10  boots++;
11  prefs.putUInt("boots", boots);
12
13  if (!prefs.isKey("ssid")) {                  // ilk açılış / first boot
14    prefs.putString("ssid", "EvAgi");          // örnek değer / example value
15  }
16  String ssid = prefs.getString("ssid", "");   // kayıtlı Wi-Fi adı / stored Wi-Fi name
17  int brightness = prefs.getInt("bright", 128);   // yoksa 128 / 128 if missing
18
19  Serial.print("Acilis / boot: ");
20  Serial.println(boots);
21  Serial.print("SSID: ");
22  Serial.println(ssid);
23  Serial.print("Parlaklik / brightness: ");
24  Serial.println(brightness);
25  Serial.print("Bos kayit yeri / free entries: ");
26  Serial.println(prefs.freeEntries());
27  prefs.end();                                 // ad alanını kapat / close the namespace
28}
29
30void loop() {}
CommandoWat het doet
prefs.begin("name", false)Opent de namespace; false betekent lezen en schrijven, true betekent alleen lezen
putUInt, putInt, putFloat, putBool, putString, putBytesSlaat de waarde op onder een key-naam
getUInt("key", default)Leest de waarde; geeft de standaardwaarde terug als de key niet bestaat
isKey("key")Controleert of de key bestaat
remove("key")Verwijdert één enkele key
clear()Verwijdert alle keys in de geopende namespace
freeEntries()Geeft het aantal vrije entries in NVS terug
end()Sluit de namespace

Je moet een waarde teruglezen met hetzelfde type als waarmee je hem hebt geschreven: als je schrijft met putUInt en leest met getInt, krijg je de standaardwaarde. Er is ook een reden dat we isKey() aanroepen vóór getString(): als Core Debug Level in het menu Tools op Error of hoger staat, wordt bij het lezen van een niet-bestaande tekstkey nvs_get_str len fail: ssid NOT_FOUND naar de Serial Monitor geprint; het is onschuldig maar verwarrend. Opnieuw uploaden via USB wist NVS niet, maar als Erase All Flash Before Sketch Upload op Enabled staat, wist elke upload alle entries. Wifigegevens opslaan met Preferences is gebruikelijk; als je de netwerknaam en het wachtwoord liever vanaf je telefoon invoert, werkt ESP32 WiFiManager ook, en de ESP32 bewaart zijn wifi-instellingen in hetzelfde NVS-gebied. Voor kortlevende waarden die het ontwaken uit deep sleep moeten overleven, past RTC-geheugen beter, omdat dat de flash helemaal niet slijt; zie ESP32 deep sleep.

Als je oude Arduino-code naar de ESP32 overzet, werkt de EEPROM-bibliotheek ook, met twee verschillen: voor gebruik moet je met EEPROM.begin(size) aangeven hoeveel bytes je nodig hebt, en na wijzigingen moet je EEPROM.commit() aanroepen. put() en write() veranderen alleen de kopie in RAM; zonder commit() komt er niets in de flash terecht. Op de ESP32 draait deze bibliotheek als één datablob binnen NVS en Espressif beschouwt hem als verouderd; elke byte van een nieuw aangemaakt gebied is 0xFF. Dezelfde code compileert ook voor de ESP8266, waar de grootte maximaal 4096 bytes kan zijn en elke commit() een flashsector van 4 KB wist en herschrijft, dus roep commit spaarzaam aan.

C++ (Arduino IDE)
1#include <EEPROM.h>
2
3void setup() {
4  Serial.begin(115200);
5  EEPROM.begin(64);                            // kullanılacak bayt sayısı / number of bytes to use
6  uint32_t boots;
7  EEPROM.get(0, boots);
8  if (boots == 0xFFFFFFFF) boots = 0;          // yeni alan 0xFF dolu / a fresh area is 0xFF
9  boots++;
10  EEPROM.put(0, boots);                        // yalnız RAM'deki kopyayı değiştirir / changes only the RAM copy
11  EEPROM.commit();                             // flaşa şimdi yazılır / written to flash now
12  Serial.println(boots);
13  EEPROM.end();
14}
15
16void loop() {}

Permanente data op de Raspberry Pi Pico: het MicroPython-bestandssysteem

De RP2040-chip van de Raspberry Pi Pico heeft ook geen EEPROM; het board heeft 2 MB flashgeheugen. MicroPython reserveert ongeveer 1,4 MB van die flash voor een LittleFS-bestandssysteem (minder op de Pico W vanwege de wifi-firmware). Op de Pico is het equivalent van EEPROM dus het schrijven van je instellingen naar een klein bestand. LittleFS spreidt schrijfacties over verschillende flashblokken, dus het doet zelf aan wear leveling, en het bestandssysteem raakt niet beschadigd, zelfs niet als de stroom uitvalt tijdens het schrijven. De onderstaande code slaat instellingen op als JSON, telt elke start en slaat de teller op telkens als een knop tussen GP15 en GND wordt ingedrukt.

MicroPython
1import json, os, time
2from machine import Pin
3
4FILE = "settings.json"
5DEFAULTS = {"boots": 0, "count": 0, "password": "1234"}
6
7def load():
8    try:
9        with open(FILE) as f:
10            data = json.load(f)
11    except (OSError, ValueError):            # dosya yok ya da bozuk / file missing or corrupt
12        data = {}
13    for key, value in DEFAULTS.items():      # eksik anahtarları tamamla / fill in missing keys
14        data.setdefault(key, value)
15    return data
16
17def save(data):
18    with open(FILE + ".tmp", "w") as f:      # önce geçici dosyaya yaz / write a temp file first
19        json.dump(data, f)
20    os.rename(FILE + ".tmp", FILE)           # sonra eskisinin yerine koy / then replace the old one
21
22settings = load()
23settings["boots"] += 1
24save(settings)
25print("Acilis / boot:", settings["boots"], "Sayac / count:", settings["count"])
26
27button = Pin(15, Pin.IN, Pin.PULL_UP)        # buton GP15 ile GND arasında / button between GP15 and GND
28
29while True:
30    if button.value() == 0:                  # basıldı / pressed
31        time.sleep_ms(30)                    # sıçramayı bekle / let the bounce settle
32        if button.value() == 0:
33            settings["count"] += 1
34            save(settings)                   # seyrek olay, her basışta yaz / rare event, save on each press
35            print("Sayac / count:", settings["count"])
36            while button.value() == 0:       # bırakılmasını bekle / wait for release
37                time.sleep_ms(10)
38            time.sleep_ms(30)                # bırakma sıçraması / release bounce
39    time.sleep_ms(10)

In plaats van het bestand direct te overschrijven, schrijven we eerst naar een tijdelijk .tmp-bestand en zetten we dat met os.rename() op de plaats van het oude, zodat het oude instellingenbestand intact blijft, zelfs als het schrijven wordt onderbroken. Als het bestand ontbreekt of de inhoud beschadigd is, valt load() terug op de standaardwaarden, en als je later een nieuwe instelling aan het programma toevoegt, vult setdefault() de ontbrekende key automatisch aan. Als je de Pico programmeert met de Arduino IDE, kun je ook de EEPROM-bibliotheek in de Arduino-Pico-core van Earle Philhower gebruiken: EEPROM.begin(256) opent een gebied van 256–4096 bytes en EEPROM.commit() slaat je wijzigingen op. Dit geëmuleerde EEPROM staat in de laatste sector van 4 KB van de flash en elke commit() wist en herschrijft die sector; de flash is gespecificeerd voor ongeveer 100.000 wiscycli per sector, dus commit spaarzaam. Begin je net met de Pico, dan zijn Wat is de Raspberry Pi Pico en MicroPython-basis goede plekken om te starten.

Meer permanent geheugen: extern EEPROM, FRAM en SD-kaarten

Als 1 KB niet genoeg is of je heel vaak moet opslaan, kun je extern geheugen toevoegen. I2C-EEPROM-chips zoals de AT24C256 bieden 32 KB en ongeveer 1 miljoen schrijfcycli, en worden met alleen de draden SDA en SCL aangesloten (Wat is I2C). Een weinig bekend detail: veel DS3231-RTC-klokmodules in de handel hebben al een AT24C32-EEPROM van 4 KB aan boord, meestal bereikbaar op I2C-adres 0x57. Voor taken die vele keren per seconde opslaan passen FRAM-modules met ongeveer een biljoen (10^12) schrijfcycli beter, en voor grote datalogs een SD-kaartmodule die data als bestanden opslaat.

Projectideeën met EEPROM

  • Een lamp die zijn laatste stand onthoudt: Zet na een stroomstoring de lamp op een relais terug in de stand van vóór de uitval.
  • Een kluis met een wijzigbare code: Schrijf de nieuwe code die op een keypad is ingevoerd naar EEPROM, zodat de code kan veranderen zonder de sketch opnieuw te uploaden.
  • Deurslot met kaarten: Sla de ID's van toegestane kaarten op die met de RFID RC522 zijn gescand en voeg nieuwe kaarten toe met een mastercard.
  • Permanente highscore: Bewaar de beste score in Simon, T-Rex of Snake; voorbeeldcode vind je in Arduino-spelprojecten.
  • Een robotarm die bewegingen opneemt: Neem servohoeken houding voor houding op en speel ze terug; de code in Arduino-robotarm doet dit met EEPROM.update().
  • Een weegschaal die zijn kalibratie onthoudt: Sla de kalibratiefactor die je met de HX711-loadcell hebt gevonden op als float met put().
  • Resetteller: Tel hoe vaak het board herstart om voedingsproblemen te diagnosticeren; de methode staat in Arduino blijft resetten.

Veelgemaakte fouten en hoe je ze oplost

SymptoomOorzaakOplossing
De eerste start leest 255, -1, 65535 of nanHet EEPROM is nog nooit beschreven; lege cellen zijn 0xFFSchrijf standaardwaarden als een controle op een magisch getal of 0xFF faalt
300 geschreven, 44 gelezenwrite() en read() verwerken maar 1 byteGebruik put() en get() voor data van meerdere bytes
Twee waarden beschadigen elkaarDe adressen overlappen; een int neemt 2 bytes in, een float 4Maak een adreskaart en bereken adressen met sizeof
Tekst wordt na een herstart onzinEr is een String-object met put() geschrevenSla de tekst op als een char array
Nieuwe code leest de instellingen van het oude projectEen gewone upload wist het EEPROM nietGebruik een magisch getal en een versieveld, of wis het EEPROM
Instellingen zijn na het uploaden verdwenenUploaden met een programmer op de Uno, de optie Erase All Flash op de ESP32Upload gewoon via USB, zet de ESP32-optie op Disabled
Waarden worden niet opgeslagen op de ESP32EEPROM.begin() of EEPROM.commit() ontbreektVoeg beide toe, of stap over op Preferences
Preferences geeft altijd de standaardwaarde terugLezen met een ander type, een naam langer dan 15 tekens of een andere namespaceLaat de types van put en get overeenkomen, houd namen kort
Fout nvs_open failed: NOT_FOUNDEen namespace die nooit is aangemaakt is alleen-lezen geopend (true)Open de namespace eerst met false en schrijf een waarde
Waarden raken na een tijd beschadigdConstant schrijven in loop() of een spanningsdip tijdens een schrijfactieGebruik update() en uitgestelde opslag, voeg een ringbuffer en een CRC toe
Kijken wat er in het EEPROM staat is de snelste manier om te debuggen. Lees de eerste 64 adressen met EEPROM.read() in een for-lus en print ze naar de Serial Monitor (of open het kant-en-klare Arduino-voorbeeld eeprom_read), en je ziet meteen lege cellen, waarden die naar het verkeerde adres zijn geschreven en data die van oude projecten is overgebleven.

EEPROM is de makkelijkste manier om je Arduino-projecten een geheugen te geven: met een paar regels code bescherm je de instellingen, tellers en wachtwoorden van je apparaat tegen stroomuitval. Het enige waarop je moet letten is de schrijfduurzaamheid; zolang je update() en put() gebruikt en niet onnodig schrijft, werkt het EEPROM van de Uno jarenlang probleemloos. In de BlueGrays-app vind je projecten die je met EEPROM kunt uitbreiden, zoals de 4x4-keypad-wachtwoordapp, de slimme elektronische kluis, RFID-authenticatie en de spellen Simon en T-Rex, elk met schakelschema's en stap-voor-stapcode.

Veelgestelde vragen

Hoe vaak kun je naar het Arduino EEPROM schrijven?

De datasheet van de ATmega328P specificeert minstens 100.000 schrijf-/wiscycli voor elke EEPROM-cel. De limiet geldt per cel en lezen heeft er helemaal geen invloed op. Als je elke seconde naar hetzelfde adres schrijft, is de cel in ongeveer 28 uur versleten; als je update() gebruikt en alleen schrijft als de waarde verandert, gaat het EEPROM jaren mee.

Wist het uploaden van een nieuwe sketch het Arduino EEPROM?

Nee. Een gewone upload via USB schrijft alleen het programmageheugen en de data in EEPROM blijft behouden. Op de Uno wordt het EEPROM alleen gewist als je met een ISP-programmer uploadt of de bootloader brandt. Gebruik een controle op een magisch getal, zodat een nieuw project geen oude instellingen oppikt.

Wat is het verschil tussen EEPROM.write en EEPROM.update?

write() schrijft de waarde bij elke aanroep opnieuw naar de cel en gebruikt telkens een schrijfcyclus. update() leest de cel eerst en schrijft helemaal niet als de waarde gelijk is. Het resultaat is identiek, maar update() beschermt de levensduur van het EEPROM; put() gebruikt intern dezelfde methode.

Hoe wis ik het Arduino EEPROM?

Schrijf 255 (of 0) naar elk adres met een for-lus die loopt tot EEPROM.length(); het voorbeeld eeprom_clear in de Arduino IDE schrijft standaard 0. Het wissen van alle 1024 bytes op de Uno duurt ongeveer 3,4 seconden. Laat de wissketch na afloop niet op het board staan; upload je echte programma.

Heeft de ESP32 EEPROM?

De ESP32 heeft geen echt EEPROM; permanente data staat in de NVS-partitie van het flashgeheugen. Voor nieuwe projecten wordt de Preferences-bibliotheek aanbevolen. De EEPROM-bibliotheek werkt nog voor oude code, maar je moet eerst EEPROM.begin(size) aanroepen en na elke wijziging EEPROM.commit().

Hoe sla ik een int, een float of tekst op in EEPROM?

Schrijf data van meerdere bytes, zoals int, long, float en structs, met EEPROM.put(address, variable) en lees ze met EEPROM.get(address, variable). Een int neemt 2 bytes in en een float 4, dus kies het volgende adres daarop. Sla tekst op als een char array met vaste grootte, niet als String.

Alle projecten bekijken
LED schakelen met een knop (aan/uit)
AR-10Beginner

LED schakelen met een knop (aan/uit)

Druk één keer op de knop en het licht gaat aan, druk nog een keer en het gaat uit, net als de lichtschakelaar in je kamer. De Arduino merkt elke druk op en zet de led in de tegenovergestelde toestand.

4.7(103)
177
Teller met 7-segmentdisplay en knoppen
AR-43Gevorderd
Premium

Teller met 7-segmentdisplay en knoppen

Een eenvoudige teller met drie knoppen: met de ene knop gaat het cijfer op het display er één omhoog, met de andere één omlaag en de derde zet het terug op nul.

4.6(35)
47
Codeslot met 4x4-keypad en LCD
AR-64Gevorderd
Premium

Codeslot met 4x4-keypad en LCD

Een klein elektronisch deurslot dat iedereen buiten houdt die de code niet kent.

4.8(59)
75
Slimme elektronische kluis
AR-92Gevorderd
Premium

Slimme elektronische kluis

Een kleine kluis voor je waardevolle spullen die opent met een code. Je tikt je viercijferige code in op het toetsenbord; klopt hij, dan opent de servomotor het slot, gaat het groene lampje aan en…

4.7(42)
63
RFID-authenticatie
AR-54Gemiddeld
Premium

RFID-authenticatie

Net als de kaartlezer bij een appartementsdeur: je houdt je kaart bij de RFID-lezer en de Arduino vergelijkt het nummer met het opgeslagen nummer.

4.8(65)
84
Arduino-geheugenspel (4 leds + 4 knoppen + buzzer)
AR-93Gevorderd
Premium

Arduino-geheugenspel (4 leds + 4 knoppen + buzzer)

Vertrouw je op je geheugen? Vier gekleurde leds lichten na elkaar op en spelen elk hun eigen toon; jij herhaalt dezelfde volgorde door op de knoppen te drukken.

4.8(46)
69
OLED T-Rex Run: Arduino-dinosaurusspel
AR-87Gevorderd
Premium

OLED T-Rex Run: Arduino-dinosaurusspel

Het dinosaurusspel dat verschijnt als je internet wegvalt, nu op je bureau: de dinosaurus rent over het kleine OLED-scherm, cactussen komen op je af en jij springt met één knop.

4.7(33)
53
ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
ES-33Gevorderd
Premium

ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)

De Deep Sleep-modus van de ESP32 schakelt de CPU en de meeste randapparatuur uit, waardoor het stroomverbruik daalt tot ongeveer 10µA; dat is cruciaal voor IoT-apparaten op batterijen. Dit project gebruikt drie wekbronnen: een timer (15 s), een externe pin (EXT0, de knop op GPIO 33) en een touchpin (T0/GPIO 4). Tellers met RTC_DATA_ATTR blijven behouden tijdens deep sleep.

4.3(10)
16