Az Arduino EEPROM: Tartós Adattárolás Mikrokontrollerekkel

Amikor változókat definiál és használ egy vázlaton belül, a generált adatok csak addig maradnak meg, amíg az Arduino be van kapcsolva. Ha az adatokat későbbi felhasználásra is tárolni szeretné, akkor az Arduino EEPROM-ot kell használnia. Ez a memória típus lehetővé teszi, hogy az adatok megőrződjenek még az Arduino újraindítása vagy kikapcsolása után is, ami rendkívül hasznos számos projektben.

Mi az EEPROM és hogyan működik?

Az EEPROM, vagyis az Electrically Erasable Programmable Read-Only Memory (elektromosan törölhető programozható csak olvasható memória) egy olyan típusú memória, amely az Arduino lapkán található mikrokontrolleren (például az ATMEGA328 az Arduino UNO esetében) helyezkedik el. A változók, amelyek az EEPROM-ban tárolódnak, ott is maradnak, még akkor is, ha az Arduino-t alaphelyzetbe állítja vagy kikapcsolja. Az EEPROM elektronikusan olvasható, törölhető és újraírható. Ez a tulajdonság teszi lehetővé, hogy a beállításokat, kalibrációs adatokat vagy más fontos információkat tartósan eltároljuk, anélkül, hogy a tápellátás megszakadása esetén elveszítenénk azokat.

Az EEPROM kapacitása az Arduino lapkákon lévő mikrokontrollerektől függ. Például egy ATmega328 alapú Arduino UNO 1 KB EEPROM-mal rendelkezik. Fontos megjegyezni, hogy az EEPROM-nak véges élettartama van. Az Arduino esetében az EEPROM minden pozíciója 100 000 írási/törlési ciklusra van specifikálva. Az olvasások száma azonban korlátlan. Ez a korlátozás azt jelenti, hogy körültekintően kell eljárni az adatok írásával és törlésével, hogy maximalizáljuk az EEPROM élettartamát. Nem szeretné, ha ez megtörténne, vagyis az EEPROM elhasználódna a túlzott írás miatt.

Adatok írása az EEPROM-ba

Adatok írásához az EEPROM-ba az EEPROM.write() függvényt használjuk, amely két argumentumot fogad el: a memóriacímét, ahová írni szeretnénk, és az írandó bájtot. A címek 0-tól a memória maximális méretéig terjednek. Például, ha a 0-ás címre szeretnénk egy értéket írni, a függvény hívása a következőképpen néz ki: EEPROM.write(0, érték);.

Példakód az írásra:

#include <EEPROM.h>void setup() { Serial.begin(9600); int ertek = 9; // Az írandó érték EEPROM.write(0, ertek); // Írás a 0-ás címre Serial.print("Az ertek irva a 0-as cimre: "); Serial.println(EEPROM.read(0)); // Ellenőrzés olvasással}void loop() { // Nincs teendő a loop-ban ebben az egyszerű példában}

Fontos megjegyezni, hogy az EEPROM.write() minden esetben ír a memóriába, még akkor is, ha az írandó érték megegyezik a már ott tárolttal. Ez a nem kívánt írási ciklusok számát növelheti, és lerövidítheti az EEPROM élettartamát. Ezért érdemes megfontolni az EEPROM.update() függvény használatát.

Adatok olvasása az EEPROM-ból

Egy bájt olvasásához az EEPROM-ból az EEPROM.read() függvényt használjuk, amely egy argumentumot fogad el: a memóriacímét, ahonnan olvasni szeretnénk. A függvény visszaadja az adott címen tárolt bájt értékét.

Példakód az olvasásra:

#include <EEPROM.h>void setup() { Serial.begin(9600); int olvasottErtek = EEPROM.read(0); // Olvasás a 0-ás címről Serial.print("A 0-as cimen tarolt ertek: "); Serial.println(olvasottErtek);}void loop() { // Nincs teendő a loop-ban ebben az egyszerű példában}

Jelenleg a 0-ás címen 9 van tárolva. Ez az érték megmarad, még akkor is, ha az Arduino-t kikapcsolja és újra bekapcsolja.

Az EEPROM.update() függvény

Az EEPROM.update() függvény különösen hasznos. Ez a függvény csak akkor ír az EEPROM-ba, ha az új érték eltér a már tárolt értéktől. Ezáltal megakadályozza a felesleges írási ciklusokat, és meghosszabbítja az EEPROM élettartamát, összhangban az élettartamra vonatkozó 100 000 írási/törlési ciklus specifikációval. Ha például a 0-ás címen már 9 van tárolva, és az EEPROM.update(0, 9); hívást hajtjuk végre, a függvény nem fog ténylegesen írni a memóriába, mivel az érték nem változott. Ez a funkció kulcsfontosságú a robusztus és tartós alkalmazások fejlesztésében.

Példakód az EEPROM.update() használatára:

#include <EEPROM.h>void setup() { Serial.begin(9600); int ujErtek = 15; EEPROM.update(0, ujErtek); // Csak akkor ír, ha az ujErtek eltér a tárolttól Serial.print("A 0-as cimen tarolt ertek az update utan: "); Serial.println(EEPROM.read(0));}void loop() { // Nincs teendő a loop-ban ebben az egyszerű példában}

Praktikus példa: LED állapotának mentése nyomógombbal

Az EEPROM hasznosságának bemutatására egy egyszerű példát fogunk megvizsgálni: egy LED állapotának mentését, amelyet egy nyomógomb vezérel. Ez egy debounce kód, amely megváltoztatja a LED állapotát minden alkalommal, amikor megnyomja a nyomógombot. A kód elején, a setup() függvényben ellenőrizzük az EEPROM-ban elmentett ledState állapotot, és ennek megfelelően bekapcsoljuk vagy kikapcsoljuk a LED-et, amikor újraindítjuk a programot. Így a LED állapota megmarad a tápellátás megszakítása után is.

Az alábbiakban bemutatjuk a projekthez tartozó kapcsolási rajzot és az Arduino kódot. Másolja be a következő kódot az Arduino IDE-be, és töltse fel az Arduino lapkájára.

Kapcsolási rajz:A kapcsolási rajz egy egyszerű elrendezést mutat be, ahol egy nyomógomb csatlakozik az Arduino egyik digitális bemenetéhez (például D2), egy ellenállással lehúzó konfigurációban, és egy LED csatlakozik egy másik digitális kimenethez (például D13), egy áramkorlátozó ellenállással sorba kötve.

Arduino kód:

#include <EEPROM.h>const int LED_PIN = 13; // LED a 13-as digitális pin-enconst int BUTTON_PIN = 2; // Nyomógomb a 2-es digitális pin-enint ledState; // A LED aktuális állapotaint lastButtonState; // Az előző nyomógomb állapot tárolásáralong lastDebounceTime = 0; // Az utolsó debounce időbélyeglong debounceDelay = 50; // Debounce késleltetésvoid setup() { Serial.begin(9600); pinMode(LED_PIN, OUTPUT); pinMode(BUTTON_PIN, INPUT_PULLUP); // Belső felhúzó ellenállás használata // EEPROM-ból olvasva beállítjuk a LED állapotát ledState = EEPROM.read(0); if (ledState != LOW && ledState != HIGH) { // Ha az EEPROM-ban nincs érvényes érték (pl. első indítás), // akkor alapértelmezett állapotra állítjuk ledState = LOW; EEPROM.update(0, ledState); } digitalWrite(LED_PIN, ledState); Serial.print("Kezdeti LED allapot (EEPROM-bol): "); Serial.println(ledState == HIGH ? "BE" : "KI"); lastButtonState = digitalRead(BUTTON_PIN);}void loop() { int reading = digitalRead(BUTTON_PIN); if (reading != lastButtonState) { lastDebounceTime = millis(); } if ((millis() - lastDebounceTime) > debounceDelay) { if (reading != ledState) { // Ha a nyomógomb állapota megváltozott if (reading == LOW) { // Ha a gombot lenyomták (pullup esetén LOW) ledState = !ledState; // Állapotváltás digitalWrite(LED_PIN, ledState); // LED beállítása EEPROM.update(0, ledState); // Az új állapot mentése az EEPROM-ba Serial.print("LED allapot valtozott: "); Serial.println(ledState == HIGH ? "BE" : "KI"); } } } lastButtonState = reading; // Mentse az olvasást}

Ebben a példában, a program elején, a setup() függvényben ellenőrizzük a 0-ás EEPROM címen tárolt ledState változót. Ha az EEPROM-ban található érték nem felel meg a HIGH vagy LOW logikai állapotnak (ez az első indításkor fordulhat elő, amikor az EEPROM-ban véletlenszerű adatok lehetnek), akkor alapértelmezetten LOW-ra állítjuk a LED állapotát, és ezt az értéket beírjuk az EEPROM-ba. Ez biztosítja, hogy a program mindig érvényes alapállapottal induljon. Ezután a loop() függvény figyeli a nyomógombot, és annak megnyomásakor megváltoztatja a LED állapotát, majd az új állapotot azonnal elmenti az EEPROM-ba az EEPROM.update() függvény segítségével. Így az Arduino újraindításakor vagy áramszünet esetén is megmarad a LED utolsó állapota. Ez csak egy egyszerű példa az EEPROM használatának megértéséhez. Az EEPROM számos más alkalmazási területen is hasznosítható, például szenzoradatok naplózására, felhasználói beállítások tárolására vagy eszközkonfigurációk megőrzésére.

tags: #eprom #torles #arduino