Arduino EEPROM istifadəsi: daimi yaddaşa məlumat yazma və oxuma
Arduino EEPROM necə istifadə olunur? Uno-da 1024 bayt daimi yaddaş, read, write, update, put, get, 100.000 yazma ömrü, sayğac və şifrə qeydi, ESP32 Preferences.
Arduino EEPROM, platanın elektriki kəsiləndə belə içindəki məlumatı saxlayan kiçik daimi yaddaşdır. Arduino Uno, Nano və Pro Mini-dəki ATmega328P prosessorunda 1024 baytlıq EEPROM var və ona Arduino IDE ilə hazır gələn EEPROM kitabxanasının EEPROM.read(), EEPROM.write(), EEPROM.update(), EEPROM.put() və EEPROM.get() komandaları ilə çatırsan. Dəyişənlərin saxlandığı RAM hər yenidən başlamada sıfırlanır, EEPROM-a yazdığın ayar, sayğac və ya şifrə isə plata yenidən işə düşəndə olduğu kimi yerində qalır.
Bu bələdçidə EEPROM-un necə işlədiyini, hansı platada nə qədər yer olduğunu, komandaların fərqini və ən çox maraq doğuran məsələni, yəni təxminən 100.000 yazmalıq ömrün praktikada nə demək olduğunu görəcəksən. Sonra elektrik kəsilsə də unutmayan sayğacı, şifrəni və ayarları birdəfəlik saxlayan ayar strukturunu və yazma ömrünü 16 dəfə artıran dairəvi bufer nümunəsini addım-addım quracağıq. Son bölmələrdə real EEPROM-u olmayan ESP32-də Preferences kitabxanası ilə, Raspberry Pi Pico-da isə MicroPython fayl sistemi ilə eyni işi necə görəcəyini öyrənəcəksən.

EEPROM nədir, necə işləyir?
EEPROM ingiliscə Electrically Erasable Programmable Read-Only Memory (elektriklə silinə bilən, proqramlaşdırıla bilən yalnız oxunan yaddaş) ifadəsinin abreviaturasıdır. Hər yaddaş xanası məlumatı izolə olunmuş qapının içində qapanan elektrik yükü ilə saxlayır; bu yük qida kəsiləndə də itmir. Uno-nun EEPROM-unu 1024 siyirtməli şkaf kimi düşün: hər siyirtmənin 0-dan 1023-ə qədər bir ünvanı var və hər siyirtməyə düz 1 bayt, yəni 0 ilə 255 arasında bir ədəd sığır. Heç yazılmamış xana 255 (0xFF) oxunur. Oxuma demək olar ki, ani gedir və limitsiz edilə bilər; yazma isə bayt başına təxminən 3,3 ms çəkir və xananı bir az yeyindirir. ATmega328P-nin datasheet-i hər EEPROM xanası üçün ən azı 100.000 yazma-silmə dövrü və 25 °C-də 100 il məlumat saxlama müddəti verir.
| Xüsusiyyət | Flash (proqram yaddaşı) | SRAM | EEPROM |
|---|---|---|---|
| Uno-da ölçüsü | 32 KB (0,5 KB-ı yükləyici üçün) | 2 KB | 1 KB (1024 bayt) |
| Nə saxlanır? | Yüklədiyin proqram | Dəyişənlər, massivlər | Ayarlar, sayğaclar, rekordlar |
| Elektrik kəsiləndə | Qorunur | Silinir | Qorunur |
| Proqram işləyərkən yazıla bilirmi? | Normalda xeyr (PROGMEM ilə yalnız oxunur) | Bəli, limitsiz | Bəli, EEPROM kitabxanası ilə |
| Yazma ömrü | Təxminən 10.000 | Limitsiz | Hər xanada təxminən 100.000 |
| Yazma sürəti | Yalnız kod yükləyəndə | Bir takt dövrü | Bayt başına təxminən 3,3 ms |
Qısası, SRAM yazı taxtası, EEPROM isə dəftərdir. Taxtaya istədiyin qədər yazıb silə bilərsən, amma işıqlar sönəndə hər şey gedir; dəftərə yazdığın qalır, amma eyni səhifəni sonsuza qədər silib yaza bilməzsən. Buna görə EEPROM kalibrləmə dəyərləri, istifadəçi ayarları, parlaqlıq və ya səs səviyyəsi, oyun rekordu, qapı şifrəsi, qeydə alınmış RFID kartlar və lampanın son vəziyyəti kimi az yer tutan və nadir dəyişən məlumatlar üçün idealdır. Saniyədə bir ölçmə qeyd edən temperatur jurnalı kimi böyük və tez-tez yazılan məlumatlar üçün isə SD kart modulu daha düzgün seçimdir. RAM-ın niyə tez dolduğunu maraqlanırsansa, Arduino yaddaş çatışmır yazısına bax.
Hansı platada nə qədər EEPROM var?
| Plata | Prosessor | EEPROM | Qeyd |
|---|---|---|---|
| Arduino Uno R3, Nano, Pro Mini | ATmega328P | 1024 bayt | Real EEPROM |
| Arduino Mega 2560 | ATmega2560 | 4096 bayt | Real EEPROM |
| Arduino Leonardo, Micro | ATmega32U4 | 1024 bayt | Real EEPROM |
| Arduino Nano Every | ATmega4809 | 256 bayt | Real EEPROM, amma az yer |
| Arduino Uno R4 Minima, WiFi | Renesas RA4M1 | 8 KB | Data flash; EEPROM kitabxanası eyni komandalarla işləyir |
| ESP32 | ESP32 (Xtensa) | Yoxdur | Flaşdakı NVS bölməsi; Preferences tövsiyə olunur |
| ESP8266 (NodeMCU, Wemos D1) | ESP8266 | Yoxdur | Flaşda imitasiya olunur; EEPROM.begin() və commit() lazımdır |
| Raspberry Pi Pico | RP2040 | Yoxdur | MicroPython-da fayl, Arduino nüvəsində flaşda imitasiya olunan EEPROM |
Kodunu fərqli platalara keçirəcəksənsə EEPROM ölçüsünü sabit ədəd kimi yazma; EEPROM.length() funksiyası platanın real EEPROM ölçüsünü qaytarır (Uno-da 1024, Mega-da 4096). Beləliklə eyni silmə və ya skan kodu hər platada düzgün işləyir. Uno-nun digər yaddaş və pin xüsusiyyətləri üçün Arduino Uno pinləri, plata seçimi üçün Hansı Arduino-nu almalıyam? yazılarına baxa bilərsən.
EEPROM komandaları: read, write, update, put və get
EEPROM kitabxanası plata paketi ilə birlikdə gəlir; ayrıca quraşdırmağa ehtiyac yoxdur, kodun ən üstünə #include <EEPROM.h> sətrini yazmaq kifayətdir. Ünvanlar 0-dan başlayır və Uno-da 1023-də bitir. Aşağıdakı cədvəl hər komandanın nə etdiyini və xanaları yeyindirib-yeyindirmədiyini xülasə edir:
| Komanda | Nə edir? | Ölçü | Yeyilmə |
|---|---|---|---|
| EEPROM.read(ünvan) | Bir bayt oxuyur (0–255) | 1 bayt | Yoxdur, oxuma sərbəstdir |
| EEPROM.write(ünvan, dəyər) | Baytı hər çağırışda yenidən yazır | 1 bayt | Hər çağırışda bir dövr sərf edir |
| EEPROM.update(ünvan, dəyər) | Əvvəl oxuyur, dəyər fərqlidirsə yazır | 1 bayt | Yalnız dəyər dəyişəndə |
| EEPROM.put(ünvan, məlumat) | int, float, massiv və ya struct-u bayt-bayt yazır; daxildə update istifadə edir | sizeof(məlumat) | Yalnız dəyişən baytlar |
| EEPROM.get(ünvan, dəyişən) | put ilə yazılanı eyni tipdə geri oxuyur | sizeof(dəyişən) | Yoxdur |
| EEPROM[ünvan] | Massiv kimi çıxış; oxumaq sərbəstdir, = ilə mənimsətmə write kimi işləyir | 1 bayt | Hər mənimsətmədə sərf edir |
| EEPROM.length() | Ümumi EEPROM ölçüsünü verir | - | Yoxdur |
İlk proqram: EEPROM-a məlumat yazma və oxuma
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() {}Kodu yüklə və Serial Monitor-u 9600 baud sürətində aç. İlk işə salmada 0-cı ünvan 255 oxunur, çünki həmin xanaya əvvəllər heç yazılmayıb. İndi platanın reset düyməsinə bas və ya USB kabelini çıxarıb yenidən tax: bu dəfə 42 oxunur. EEPROM-un daimiliyinin sübutu budur. 1-ci ünvana yazan write() sətri isə dəyər həmişə 7 olduğu halda hər açılışda xananı yenidən yazır; update() istifadə etsəydik yalnız ilk dəfə yazacaqdı. Son sətirdəki 300 dəyəri xəbərdarlıqdakı tələni göstərir və ekranda 44 görünür. Preferences-də Compiler warnings ayarı None-dan fərqli səviyyədədirsə, kompilyator bu sətir üçün large integer implicitly truncated to unsigned type xəbərdarlığını verir.
put() və get() istifadə edəndə hər məlumatın neçə bayt tutduğunu bilməlisən; əks halda iki dəyişəni üst-üstə yazıb birini korlayarsan. Nümunədə int 10 və 11-ci ünvanları tutduğu üçün float-u 12-ci ünvandan başlatdıq. Uno-da məlumat tiplərinin ölçüləri belədir:
| Məlumat tipi | Uno-da ölçüsü | Dəyər aralığı | İstifadə nümunəsi |
|---|---|---|---|
| byte, bool, char | 1 bayt | 0–255, true/false və ya tək simvol | Açıq-bağlı vəziyyət, rejim seçimi |
| int | 2 bayt | −32.768 ilə 32.767 | Kalibrləmə fərqi |
| unsigned int, uint16_t | 2 bayt | 0–65.535 | Oyun rekordu |
| long, unsigned long | 4 bayt | Təxminən ±2,1 milyard və ya 0–4,29 milyard | Uzun müddətli sayğac |
| float | 4 bayt | 6–7 rəqəm dəqiqlik | Sensor kalibrləmə əmsalı |
| char massiv[10] | 10 bayt | 9 simvol və sonlandırıcı | Şifrə, cihaz adı |
EEPROM yazma ömrü: 100.000 limiti nə deməkdir?
100.000 yazma çox görünür, amma yanlış qurulmuş kod bu limiti bir neçə dəqiqəyə tükədə bilər. Ömrü hesablamağın düsturu sadədir: ömür = 100.000 ÷ eyni xanaya yazma tezliyi. Vacib məqam budur ki, limit bütün EEPROM üçün deyil, hər xana üçün ayrıca keçərlidir; eyni ünvana yazmağa davam etdikcə yalnız həmin xana yeyilir. Oxumanın isə ömrə heç bir təsiri yoxdur. Aşağıdakı cədvəl eyni ünvana müxtəlif tezliklə yazılanda xananın nə qədər dözəcəyini göstərir:
| Eyni ünvana yazma tezliyi | Təxmini ömür |
|---|---|
| loop()-da gecikməsiz write() (saniyədə təxminən 300 dəfə) | 5–6 dəqiqə |
| Hər saniyə | Təxminən 28 saat |
| Hər dəqiqə | Təxminən 69 gün |
| 10 dəqiqədən bir | Təxminən 1,9 il |
| Saatda bir dəfə | Təxminən 11 il |
| Gündə 10 dəfə | Təxminən 27 il |
100.000 istehsalçının zəmanət verdiyi ən aşağı dəyərdir; bir çox çip bundan çox daha artıqa dözür, amma layihəni buna güvənərək dizayn etmə. Yeyilən xana birdən ölmür; əvvəlcə yazdığın dəyəri saxlaya bilməməyə, bəzi bitləri özbaşına dəyişməyə başlayır. Belə halda məlumatı başqa ünvana köçürə bilərsən, çünki digər xanalar bundan təsirlənmir. Ömrü uzatmağın yolları bunlardır:
- update() və put() istifadə et: İkisi də yazmadan əvvəl xananı oxuyur və dəyər eynidirsə heç yazmır.
- Yalnız dəyişəndə yaz: Ayarı hər loop() turunda deyil, istifadəçi həqiqətən dəyişəndə yadda saxla.
- Qeydi gecikdir: Dəyər ardıcıl dəyişirsə, son dəyişiklikdən bir neçə saniyə sonra bircə dəfə yaz; bunu millis() ilə asanlıqla edirsən.
- Hadisə anında yaz: Oyun rekordunu oyun bitəndə, menyu ayarını menyudan çıxanda yadda saxla.
- Yazmaları paylaşdır: Tez-tez dəyişən sayğacı tək ünvan əvəzinə bir neçə ünvana növbə ilə yaz (aşağıdakı dairəvi bufer nümunəsi).
- Lazım olsa xarici yaddaş istifadə et: Çox tez-tez qeyd lazımdırsa, 1 milyon dövrlük xarici EEPROM, FRAM və ya SD kart seç.
Nümunə 1: Elektrik kəsilsə də unutmayan sayğac
İlk nümunədə düyməyə hər basılanda artan və plata söndürülüb-yandırılanda qaldığı yerdən davam edən sayğac quracağıq. Düymənin bir ayağını D2-yə, digərini GND-yə qoş; daxili pull-up rezistorundan istifadə etdiyimiz üçün əlavə rezistora ehtiyac yoxdur (təfərrüatlar Arduino-ya düymə qoşulması yazısında, pin yerləri Pinout alətində). Kodun əsas məqamı sayğacı hər basışda deyil, son basışdan 5 saniyə sonra yadda saxlamasıdır. Beləliklə, kimsə düyməyə ardıcıl 20 dəfə bassa belə, EEPROM-a yalnız bir dəfə yazılır.
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}dirty dəyişəni RAM-da hələ yadda saxlanmamış dəyişiklik olduğunu göstərir. Sayğac unsigned long tipində olduğu üçün 4 bayt (0–3-cü ünvanlar) tutur və 4 milyarddan çox basışı say bilər. Heç yazılmamış EEPROM-da bu dörd bayt 0xFF olduğundan ilk açılışda 4.294.967.295 oxunur; kod bu dəyəri görəndə sayğacı sıfırdan başladır. put() yalnız dəyişən baytları yazdığından sayğac artarkən çox vaxt yalnız ən alt bayt yeyilir. Qeydə qədər olan 5 saniyə ərzində elektrik kəsilsə, son basışlar itir; bu, EEPROM ömrünü qorumaq üçün ödənilən kiçik bədəldir.
Nümunə 2: Ayarları və şifrəni struct ilə saxlamaq
Bir neçə ayarı ayrı-ayrı ünvanlara yazmaq əvəzinə hamısını bir struct-da toplayıb tək put() ilə yadda saxlamaq həm daha səliqəli, həm də daha etibarlıdır. Bu nümunədə LED parlaqlığını və 4–6 simvollu şifrəni saxlayırıq. Strukturun əvvəlindəki iki sahə çox vacibdir: magic (sehrli ədəd) EEPROM-a bu proqramın ayarlarının həqiqətən yazılıb-yazılmadığını başa düşməyə imkan verir; version isə struktura sonradan yeni sahə əlavə edəndə köhnə və uyğunsuz məlumatın oxunmasının qarşısını alır. İkisindən biri uyğun gəlməsə, kod defolt ayarları yazır.
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}LED-i bir LED rezistoru (220 om kifayətdir) üzərindən D9-a qoş; D9 bir PWM pinidir. Serial Monitor-u 9600 baud sürətində açıb sətir sonu ayarını New Line et və bu komandaları yoxla: b200 parlaqlığı 200 edir, p1234,5678 şifrəni 1234-dən 5678-ə çevirir, ? cari parlaqlığı göstərir. Platanı söndürüb yandıranda LED eyni parlaqlıqla yanır və yeni şifrə qüvvədə qalır. Struct Uno-da 11 bayt tutur; put() yalnız dəyişən baytları yazdığı üçün parlaqlığı dəyişmək tək xananı yeyindirir. Eyni strukturu keypad-li şifrəli kilidə uyğunlaşdıra və ya RFID RC522 ilə səlahiyyətli kartların 4 baytlıq identifikatorlarını massiv kimi saxlaya bilərsən. Serial komandalara yenisənsə, Arduino Serial Monitor yazısına bax.
Yazma ömrünü artırmaq: dairəvi bufer (wear leveling)
Tez-tez yenilənən sayğacı həmişə eyni ünvana yazmaq o tək xananı sürətlə tükədir. Dairəvi bufer (ring buffer) üsulunda dəyəri növbə ilə müxtəlif yuvalara yazırsan: ilk qeyd bir yuvaya, sonrakı qeyd növbətiyə gedir və son yuvadan sonra əvvələ qayıdılır. Hər yuva 16 qeydə bir dəfə yazıldığı üçün ömür 16 dəfə, yəni təxminən 1,6 milyon qeydə çatır. Açılışda ən son dəyəri tapmaq üçün bütün yuvalar oxunur; sayğac həmişə artdığı üçün ən böyük dəyər ən yenisidir.
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() {}Nümunə hər açılışda sayğacı bir artırır; sən bunu düymə, sensor hadisəsi və ya iş saatı sayğacı ilə əvəz edə bilərsən. Yuva sayını artırdıqca ömür də eyni nisbətdə artır: 64 yuva 256 bayt tutur və təxminən 6,4 milyon qeydə dözür. Plata əvvəllər başqa proqramlarda istifadə olunubsa, dairə bölgəsində köhnə məlumatlar qalmış ola bilər; ilk istifadədən əvvəl aşağıdakı silmə kodu ilə EEPROM-u təmizlə. Daha inkişaf etmiş layihələrdə Arduino-nun öz eeprom_crc nümunəsindəki kimi CRC yoxlama cəmi əlavə edərək korlanmış məlumatı da aşkar edə bilərsən.
EEPROM necə sıfırlanır? Kod yükləyəndə silinirmi?
USB kabeli ilə normal yükləmə edəndə Arduino yalnız proqram yaddaşını yazır; EEPROM-dakı məlumatlar qorunur. Buna görə yeni layihə yükləyəndə əvvəlki layihənin ayarları EEPROM-da qalır və yeni kodun gözləmədiyi dəyərləri oxumasına səbəb ola bilər. Uno-da EEPROM yalnız ISP proqramlaşdırıcı ilə Sketch > Upload Using Programmer və ya Tools > Burn Bootloader edildikdə silinir; bu əməliyyatlar çipi tamamilə silir və Uno-nun fuse ayarlarında EEPROM-u qoruyan EESAVE biti bağlıdır. EEPROM-u özün təmizləmək üçün bu kodu bir dəfə yüklə:
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() {}Arduino IDE-dəki File > Examples > EEPROM > eeprom_clear nümunəsi bütün xanalara 0 yazır; biz isə xanaları zavod vəziyyəti olan 255-ə qaytarırıq. Beləliklə, magic ədəd və 0xFF yoxlaması edən kodlar EEPROM-u yenidən boş kimi tanıyır. update() istifadə etdiyimiz üçün artıq 255 olan xanalara heç yazılmır. Uno-da 1024 xananın hamısını yazmaq ən çoxu təxminən 3,4 saniyə çəkir; daxili LED yananda əməliyyat bitib. Sonra əsas proqramını yüklə.
ESP32-də EEPROM: Preferences kitabxanası
ESP32-də real EEPROM yoxdur. Daimi məlumatlar xarici flaş yaddaşın NVS (Non-Volatile Storage) adlı bölməsində saxlanır; defolt bölmə cədvəlində bu sahə 20 KB-dır. Espressif-in tövsiyə etdiyi yol ESP32 plata paketi ilə gələn Preferences kitabxanasıdır. Preferences məlumatı ünvan əvəzinə ad sahəsi (namespace) və açar (key) adları ilə saxlayır; yəni sayğacın hansı ünvanda olduğunu düşünmürsən. NVS yeni dəyəri hər dəfə səhifədəki növbəti boş qeydə yazıb köhnəsini silinmiş kimi işarələdiyi üçün yeyilmənin bərabərləşdirilməsi öz-özünə baş verir. Ad sahəsi və açar adları ən çox 15 simvol ola bilər və böyük-kiçik hərfə həssasdır. ESP32-yə yenisənsə, əvvəlcə ESP32 nədir yazısına bax.
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() {}| Komanda | Nə edir? |
|---|---|
| prefs.begin("name", false) | Ad sahəsini açır; false oxuma və yazma, true yalnız oxuma |
| putUInt, putInt, putFloat, putBool, putString, putBytes | Dəyəri açar adı ilə yadda saxlayır |
| getUInt("açar", defolt) | Dəyəri oxuyur; açar yoxdursa defolt dəyəri qaytarır |
| isKey("açar") | Açarın mövcud olub-olmadığına baxır |
| remove("açar") | Tək açarı silir |
| clear() | Açıq ad sahəsindəki bütün açarları silir |
| freeEntries() | NVS-də qalan boş qeydlərin sayını verir |
| end() | Ad sahəsini bağlayır |
Dəyəri hansı tiplə yazmısansa, o tiplə oxumalısan: putUInt ilə yazıb getInt ilə oxusan, defolt dəyər qayıdır. Kodda getString()-dən əvvəl isKey() istifadə etməyimizin də səbəbi var: Tools menyusundakı Core Debug Level ayarı Error və ya daha yuxarıdırsa, mövcud olmayan mətn açarını oxumaq Serial Monitor-a nvs_get_str len fail: ssid NOT_FOUND sətrini yazır; zərərsizdir, amma çaşdırır. Kodu USB-dən yenidən yükləmək NVS-i silmir, lakin Erase All Flash Before Sketch Upload seçimi Enabled-dirsə, hər yükləmədə bütün qeydlər gedir. Wi-Fi məlumatlarını Preferences ilə saxlamaq geniş yayılıb; şəbəkə adını və şifrəni telefondan daxil etmək üçün ESP32 WiFiManager də ESP32-nin Wi-Fi ayarlarını eyni NVS sahəsində saxlayır. Dərin yuxudan oyananda saxlanmalı olan qısaömürlü dəyərlər üçün flaşı heç yeyindirməyən RTC yaddaşı daha uyğundur; təfərrüatlar ESP32 deep sleep yazısında.
Köhnə Arduino kodlarını ESP32-yə keçirəndə EEPROM kitabxanası da işləyir, amma iki fərqi var: istifadədən əvvəl EEPROM.begin(ölçü) ilə neçə bayt istifadə edəcəyini deməlisən, dəyişiklikdən sonra da EEPROM.commit() çağırmalısan. put() və write() yalnız RAM-dakı nüsxəni dəyişir; commit() olmadan heç nə flaşa yazılmır. ESP32-də bu kitabxana NVS içində tək məlumat bloku kimi işləyir və Espressif tərəfindən köhnəlmiş (deprecated) sayılır; yeni yaradılan sahənin bütün baytları 0xFF-dir. Eyni kod ESP8266-da da kompilyasiya olunur; orada ölçü ən çox 4096 bayt ola bilər və hər commit() 4 KB-lıq flaş sektorunu silib yenidən yazır, buna görə commit-i nadir çağır.
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() {}Raspberry Pi Pico-da daimi məlumat: MicroPython fayl sistemi
Raspberry Pi Pico-nun RP2040 çipində də EEPROM yoxdur; platanın üzərində 2 MB-lıq flaş yaddaş var. MicroPython bu flaşın təxminən 1,4 MB-lıq hissəsini LittleFS fayl sistemi kimi ayırır (Pico W-də Wi-Fi proqramı səbəbindən daha az). Yəni Pico-da EEPROM-un qarşılığı ayarlarını kiçik bir fayla yazmaqdır. LittleFS yazmaları flaşın müxtəlif bloklarına paylaşdırdığı üçün yeyilmənin bərabərləşdirilməsini özü edir və yazma zamanı elektrik kəsilsə belə fayl sistemi korlanmır. Aşağıdakı kod ayarları JSON formatında saxlayır, hər açılışı sayır və GP15 ilə GND arasına qoşulmuş düyməyə hər basılanda sayğacı yadda saxlayır.
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)Faylı birbaşa üzərinə yazmaq əvəzinə əvvəlcə .tmp uzantılı müvəqqəti fayla yazıb sonra os.rename() ilə köhnəsinin yerinə qoyuruq; beləliklə, yazma yarımçıq qalsa belə, köhnə ayar faylı sağlam qalır. Fayl yoxdursa və ya məzmunu korlanıbsa, load() defolt dəyərlərə qayıdır; proqrama sonradan yeni ayar əlavə edəndə setdefault() çatışmayan açarı öz-özünə tamamlayır. Pico-nu Arduino IDE ilə proqramlaşdırırsansa, Earle Philhower-in Arduino-Pico nüvəsindəki EEPROM kitabxanasından da istifadə edə bilərsən: EEPROM.begin(256) ilə 256–4096 bayt arasında sahə açır, dəyişiklikləri EEPROM.commit() ilə yadda saxlayırsan. Bu imitasiya EEPROM flaşın sonundakı 4 KB-lıq sektorda durur və hər commit() o sektoru silib yenidən yazır; flaş da sektor başına təxminən 100.000 silmə dövrünə dözdüyü üçün commit-i nadir çağır. Pico-ya yeni başlayırsansa, Raspberry Pi Pico nədir və MicroPython əsasları yazıları yaxşı başlanğıcdır.
Daha çox daimi yaddaş: xarici EEPROM, FRAM və SD kart
1 KB çatmırsa və ya çox tez-tez qeyd etməlisənsə, xarici yaddaş əlavə edə bilərsən. AT24C256 kimi I2C EEPROM çipləri 32 KB yer və təxminən 1 milyon yazma dövrü təklif edir; yalnız SDA və SCL naqilləri ilə qoşulur (I2C nədir). Az bilinən bir təfərrüat: bazardakı bir çox DS3231 RTC saat modulunun üzərində artıq 4 KB-lıq AT24C32 EEPROM var və adətən 0x57 I2C ünvanından çatılır. Saniyədə dəfələrlə qeyd tələb edən işlər üçün təxminən bir trilyon (10^12) yazma dövrünə dözən FRAM modulları, böyük məlumat jurnalları üçün isə məlumatı fayl kimi saxlayan SD kart modulu daha uyğundur.
EEPROM ilə layihə ideyaları
- Son vəziyyəti xatırlayan lampa: Elektrik gedib-gələndə releyə qoşulu lampanı kəsilmədən əvvəlki vəziyyətinə qaytar.
- Şifrəsi dəyişdirilə bilən seyf: Keypad ilə daxil edilən yeni şifrəni EEPROM-a yaz; kod yenidən yüklənmədən şifrə dəyişsin.
- Kartlı qapı kilidi: RFID RC522 ilə oxudulan səlahiyyətli kartların identifikatorlarını saxla, idarəçi kartı ilə yeni kart əlavə et.
- Daimi oyun rekordu: Simon, T-Rex və ya ilan oyununda ən yüksək xalı saxla; nümunə kodlar Arduino oyun layihələri yazısında.
- Hərəkətləri qeyd edən robot qol: Servo bucaqlarını poza-poza qeyd edib təkrar oynat; Arduino robot qol yazısındakı kod bunu EEPROM.update() ilə edir.
- Kalibrləməni unutmayan tərəzi: HX711 yük hüceyrəsi ilə tapdığın kalibrləmə əmsalını float kimi put() ilə saxla.
- Reset sayğacı: Platanın neçə dəfə yenidən başladığını sayaraq qida problemlərini diaqnoz et; üsul Arduino daim resetlənir yazısında.
Tez-tez edilən səhvlər və həlləri
| Əlamət | Səbəb | Həll |
|---|---|---|
| İlk açılışda 255, -1, 65535 və ya nan oxunur | EEPROM-a heç yazılmayıb; boş xanalar 0xFF-dir | Magic ədəd və ya 0xFF yoxlaması ilə defolt dəyərləri yaz |
| 300 yazıldı, 44 oxunur | write() və read() yalnız 1 bayt daşıyır | Çoxbaytlı məlumatlar üçün put() və get() istifadə et |
| İki dəyər bir-birini korlayır | Ünvanlar üst-üstə düşür; int 2, float 4 bayt tutur | Ünvan xəritəsi qur, ünvanları sizeof ilə hesabla |
| Yenidən başladanda mətn mənasız simvollara çevrilir | String obyekti put() ilə yazılıb | Mətni char massivi kimi saxla |
| Yeni kod köhnə layihənin ayarlarını oxuyur | Normal yükləmə EEPROM-u silmir | Magic ədəd və versiya sahəsi istifadə et və ya EEPROM-u təmizlə |
| Ayarlar kod yükləyəndə silindi | Uno-da proqramlaşdırıcı ilə yükləmə, ESP32-də Erase All Flash seçimi | USB-dən normal yüklə, ESP32-də seçimi Disabled et |
| ESP32-də dəyərlər yadda saxlanmır | EEPROM.begin() və ya EEPROM.commit() çatışmır | İkisini də əlavə et və ya Preferences-ə keç |
| Preferences həmişə defolt dəyəri qaytarır | Fərqli tiplə oxuma, 15 simvolu aşan ad və ya fərqli ad sahəsi | put və get tiplərini uyğunlaşdır, adları qısa saxla |
| nvs_open failed: NOT_FOUND xətası | Heç yaradılmamış ad sahəsi yalnız oxuma (true) rejimində açılıb | Ad sahəsini əvvəlcə false ilə açıb bir dəyər yaz |
| Bir müddətdən sonra dəyərlər korlanır | loop()-da fasiləsiz yazma və ya yazma zamanı qidanın düşməsi | update() və gecikmiş qeyd istifadə et, dairəvi bufer və CRC əlavə et |
EEPROM, Arduino layihələrinə yaddaş qazandırmağın ən asan yoludur: bir neçə sətir kodla cihazının ayarlarını, sayğaclarını və şifrələrini elektrik kəsilmələrindən qoruyursan. Diqqət etməli olduğun yeganə şey yazma ömrüdür; update() və put() istifadə etdiyin və lazımsız yerə yazmadığın müddətcə Uno-nun EEPROM-u illərlə problemsiz işləyir. BlueGrays tətbiqində 4x4 keypad ilə şifrə tətbiqi, ağıllı elektron seyf, RFID kimlik doğrulaması, Simon və T-Rex oyunları kimi EEPROM ilə inkişaf etdirə biləcəyin layihələri dövrə sxemləri və addım-addım kodları ilə tapa bilərsən.
Tez-tez verilən suallar
Arduino EEPROM neçə dəfə yazıla bilər?
ATmega328P-nin datasheet-i hər EEPROM xanası üçün ən azı 100.000 yazma-silmə dövrü verir. Limit xana başınadır və oxuma ömrə heç təsir etmir. Eyni ünvana saniyədə bir dəfə yazmaq xananı təxminən 28 saata tükədir; update() istifadə edib yalnız dəyər dəyişəndə yazsan, EEPROM illərlə dözür.
Arduino-ya yeni kod yükləyəndə EEPROM silinirmi?
Xeyr. USB üzərindən normal yükləmə yalnız proqram yaddaşını yazır və EEPROM-dakı məlumatlar qorunur. EEPROM Uno-da yalnız ISP proqramlaşdırıcı ilə yükləmə edildikdə və ya yükləyici yazıldıqda silinir. Yeni layihədə köhnə ayarlarla qarşılaşmamaq üçün magic ədəd yoxlamasından istifadə et.
EEPROM.write ilə EEPROM.update arasındakı fərq nədir?
write() dəyəri hər çağırışda xanaya yenidən yazır və hər dəfə bir yazma dövrü sərf edir. update() əvvəlcə xananı oxuyur, dəyər eynidirsə heç yazmır. Nəticə eynidir, amma update() EEPROM ömrünü qoruyur; put() də daxildə eyni üsuldan istifadə edir.
Arduino EEPROM necə təmizlənir?
EEPROM.length() qədər dönən for dövrü ilə bütün ünvanlara 255 (və ya 0) yazırsan; Arduino IDE-dəki eeprom_clear nümunəsi hazır olaraq 0 yazır. Uno-da 1024 baytı silmək təxminən 3,4 saniyə çəkir. Proses bitəndə silmə kodunu platada saxlama, əsas proqramını yüklə.
ESP32-də EEPROM varmı?
ESP32-də real EEPROM yoxdur; daimi məlumatlar flaş yaddaşdakı NVS bölməsində saxlanır. Yeni layihələrdə Preferences kitabxanası tövsiyə olunur. Köhnə kodlar üçün EEPROM kitabxanası da işləyir, amma əvvəlcə EEPROM.begin(ölçü), hər dəyişiklikdən sonra isə EEPROM.commit() çağırmaq məcburidir.
EEPROM-a int, float və ya mətn necə yadda saxlanır?
int, long, float və struct kimi çoxbaytlı məlumatları EEPROM.put(ünvan, dəyişən) ilə yazır, EEPROM.get(ünvan, dəyişən) ilə oxuyursan. int 2, float 4 bayt tutduğu üçün sonrakı məlumatın ünvanını buna uyğun seç. Mətni String kimi yox, sabit ölçülü char massivi kimi saxla.
Bu yazıdan sonra edə biləcəyin layihələr
Bütün layihələrə bax
Düymə ilə LED yandırma (On Off)
Düyməyə bir dəfə basanda işıq yanır, bir daha basanda sönür; tam otağındakı lampa düyməsi kimi.

7 seqmentli displey və düymələrlə sayğac
Üç düymeli sadə sayğac: birinə basdıqca ekrandakı rəqəm bir artır, digərinə basdıqca bir azalır, üçüncüsü sıfıra qaytarır.

4x4 keypad və LCD ekranla şifrə tətbiqi
Düzgün şifrəni bilməyənin girə bilmədiyi kiçik elektron qapı kilidi. Kvadrat düyməsinə basıb şifrəni klaviaturadan daxil edirsən; şifrə düzgündürsə ekranda giriş icazəsi yazılır, yaşıl LED yanır və…

Ağıllı elektron seyf
Qiymətli əşyalarını saxlaya biləcəyin, şifrə ilə açılan kiçik seyf. Düymə panelindən dörd rəqəmli şifrəni daxil edirsən; düzgündürsə servo mühərrik kilidi açır, yaşıl işıq yanır və ekran seyfin…

RFID ilə kimlik doğrulama
Bina qapısındakı kartlı giriş kimi: kartını RFID oxuyucuya yaxınlaşdırırsan, Arduino kartın nömrəsini qeydə alınmışla müqayisə edir.

Arduino yaddaş oyunu (4 LED + 4 düymə + buzzer)
Yaddaşına güvənirsən? Dörd rəngli LED ardıcıl yanır və hər biri öz notunu çalır; sən də eyni ardıcıllığı düymələrə basaraq təkrarlayırsan.

OLED T-Rex Run: Arduino dinozavr oyunu
İnternet kəsiləndə çıxan dinozavr oyunu artıq masandadır: kiçik OLED ekranda dinozavr qaçır, kaktuslar üstünə gəlir və sən bir düymə ilə tullanırsan.

ESP32 Deep Sleep — batareya qənaəti (OLED + RTC RAM sayğac)
ESP32-nin Deep Sleep rejimi CPU-nu və əksər periferiyaları söndürərək cərəyan istehlakını təxminən 10µA səviyyəsinə endirir; batareya ilə işləyən IoT cihazları üçün çox vacibdir. Bu layihədə üç oyanma mənbəyi istifadə edirik: taymer (15 san), xarici pin (EXT0, GPIO 33-dəki düymə) və toxunma pini (T0/GPIO 4). RTC_DATA_ATTR ilə işarələnən sayğaclar deep sleep boyunca qorunur.
Digər yazılar
BlueGrays tətbiqi
Bu dövrəni telefonunda addım-addım qur
Dövrə sxemi, kod və hissə siyahısı bir ekranda. 500-dən çox Arduino, ESP32 və Pico layihəsi səni gözləyir.
Telefonunla skan et
Kameranı koda tut; telefonunun tətbiq mağazası açılır.
ya da mağazada aç

