Əsaslar · 13 dəq oxu

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.

Arduino Uno: ATmega328P prosessorunun içində 1 KB EEPROM var
Arduino Uno-nun EEPROM-u ayrıca çip deyil; ATmega328P prosessorunun içindədir və 0–1023 ünvanlarında cəmi 1024 bayt daimi məlumat saxlayır.

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ətFlash (proqram yaddaşı)SRAMEEPROM
Uno-da ölçüsü32 KB (0,5 KB-ı yükləyici üçün)2 KB1 KB (1024 bayt)
Nə saxlanır?Yüklədiyin proqramDəyişənlər, massivlərAyarlar, sayğaclar, rekordlar
Elektrik kəsiləndəQorunurSilinirQorunur
Proqram işləyərkən yazıla bilirmi?Normalda xeyr (PROGMEM ilə yalnız oxunur)Bəli, limitsizBəli, EEPROM kitabxanası ilə
Yazma ömrüTəxminən 10.000LimitsizHər xanada təxminən 100.000
Yazma sürətiYalnı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?

PlataProsessorEEPROMQeyd
Arduino Uno R3, Nano, Pro MiniATmega328P1024 baytReal EEPROM
Arduino Mega 2560ATmega25604096 baytReal EEPROM
Arduino Leonardo, MicroATmega32U41024 baytReal EEPROM
Arduino Nano EveryATmega4809256 baytReal EEPROM, amma az yer
Arduino Uno R4 Minima, WiFiRenesas RA4M18 KBData flash; EEPROM kitabxanası eyni komandalarla işləyir
ESP32ESP32 (Xtensa)YoxdurFlaşdakı NVS bölməsi; Preferences tövsiyə olunur
ESP8266 (NodeMCU, Wemos D1)ESP8266YoxdurFlaşda imitasiya olunur; EEPROM.begin() və commit() lazımdır
Raspberry Pi PicoRP2040YoxdurMicroPython-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:

KomandaNə edir?ÖlçüYeyilmə
EEPROM.read(ünvan)Bir bayt oxuyur (0–255)1 baytYoxdur, oxuma sərbəstdir
EEPROM.write(ünvan, dəyər)Baytı hər çağırışda yenidən yazır1 baytHə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ır1 baytYalnı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ə edirsizeof(məlumat)Yalnız dəyişən baytlar
EEPROM.get(ünvan, dəyişən)put ilə yazılanı eyni tipdə geri oxuyursizeof(dəyişən)Yoxdur
EEPROM[ünvan]Massiv kimi çıxış; oxumaq sərbəstdir, = ilə mənimsətmə write kimi işləyir1 baytHər mənimsətmədə sərf edir
EEPROM.length()Ümumi EEPROM ölçüsünü verir-Yoxdur
EEPROM.write() və EEPROM.read() yalnız tək baytla işləyir. 300 kimi 255-dən böyük ədədi write ilə yazsan, kod xəta vermədən kompilyasiya olunur, amma xanaya yalnız aşağı bayt, yəni 300 − 256 = 44 yazılır. int, long, float və struct kimi çoxbaytlı məlumatlar üçün həmişə EEPROM.put() və EEPROM.get() istifadə et. Eyni şəkildə EEPROM[5] = x mənimsətməsi də update kimi deyil, write kimi davranır.

İlk proqram: EEPROM-a məlumat yazma və oxuma

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() {}

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 tipiUno-da ölçüsüDəyər aralığıİstifadə nümunəsi
byte, bool, char1 bayt0–255, true/false və ya tək simvolAçıq-bağlı vəziyyət, rejim seçimi
int2 bayt−32.768 ilə 32.767Kalibrləmə fərqi
unsigned int, uint16_t2 bayt0–65.535Oyun rekordu
long, unsigned long4 baytTəxminən ±2,1 milyard və ya 0–4,29 milyardUzun müddətli sayğac
float4 bayt6–7 rəqəm dəqiqlikSensor kalibrləmə əmsalı
char massiv[10]10 bayt9 simvol və sonlandırıcıŞifrə, cihaz adı
Kodunun əvvəlində bir ünvan xəritəsi yarat: const int ADDR_MODE = 0; const int ADDR_SCORE = 1; const int ADDR_CAL = 3; kimi. Növbəti ünvanı həmişə əvvəlki ünvan + sizeof(əvvəlki məlumat) kimi hesabla və gələcəkdə yeni sahələr əlavə edə bilmək üçün aralarında bir neçə bayt boş burax.

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 tezliyiTə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 birTə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.

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}

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.

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}

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.

EEPROM-a heç vaxt String obyekti qoyma. String mətnin özünü deyil, RAM-dakı ünvanını və uzunluğunu saxlayır; EEPROM.put(0, ad) yazanda EEPROM-a mətn əvəzinə bir neçə baytlıq göstərici gedir və yenidən başladanda mənasız simvollar oxuyursan. Mətnləri həmişə nümunədəki kimi sabit ölçülü char massivi kimi saxla. Bundan əlavə, EEPROM şifrələnmir; platanın üstünə proqramlaşdırıcı qoşan şəxs məzmunu oxuya bilər. Bu üsul hobbi kilidləri üçün uyğundur, real təhlükəsizlik tələb edən işlər üçün deyil.

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.

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() {}

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ə:

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() {}

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.

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() {}
KomandaNə edir?
prefs.begin("name", false)Ad sahəsini açır; false oxuma və yazma, true yalnız oxuma
putUInt, putInt, putFloat, putBool, putString, putBytesDə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.

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() {}

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.

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)

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ətSəbəbHəll
İlk açılışda 255, -1, 65535 və ya nan oxunurEEPROM-a heç yazılmayıb; boş xanalar 0xFF-dirMagic ədəd və ya 0xFF yoxlaması ilə defolt dəyərləri yaz
300 yazıldı, 44 oxunurwrite() 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 çevrilirString obyekti put() ilə yazılıbMətni char massivi kimi saxla
Yeni kod köhnə layihənin ayarlarını oxuyurNormal yükləmə EEPROM-u silmirMagic ədəd və versiya sahəsi istifadə et və ya EEPROM-u təmizlə
Ayarlar kod yükləyəndə silindiUno-da proqramlaşdırıcı ilə yükləmə, ESP32-də Erase All Flash seçimiUSB-dən normal yüklə, ESP32-də seçimi Disabled et
ESP32-də dəyərlər yadda saxlanmırEEPROM.begin() və ya EEPROM.commit() çatışmırİkisini də əlavə et və ya Preferences-ə keç
Preferences həmişə defolt dəyəri qaytarırFərqli tiplə oxuma, 15 simvolu aşan ad və ya fərqli ad sahəsiput 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ıbAd sahəsini əvvəlcə false ilə açıb bir dəyər yaz
Bir müddətdən sonra dəyərlər korlanırloop()-da fasiləsiz yazma və ya yazma zamanı qidanın düşməsiupdate() və gecikmiş qeyd istifadə et, dairəvi bufer və CRC əlavə et
EEPROM-da nə olduğunu görmək ən sürətli diaqnoz üsuludur. for dövrü ilə ilk 64 ünvanı EEPROM.read() ilə oxuyub Serial Monitor-a yazdırsan (və ya Arduino-nun hazır eeprom_read nümunəsini açsan), boş xanaları, yanlış ünvana yazılmış dəyərləri və köhnə layihələrdən qalan məlumatları dərhal görərsən.

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.

Bütün layihələrə bax
Düymə ilə LED yandırma (On Off)
AR-10Başlanğıc

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.

4.7(103)
177
7 seqmentli displey və düymələrlə sayğac
AR-43Qabaqcıl
Premium

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.

4.6(35)
47
4x4 keypad və LCD ekranla şifrə tətbiqi
AR-64Qabaqcıl
Premium

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ə…

4.8(59)
75
Ağıllı elektron seyf
AR-92Qabaqcıl
Premium

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…

4.7(42)
63
RFID ilə kimlik doğrulama
AR-54Orta
Premium

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.

4.8(65)
84
Arduino yaddaş oyunu (4 LED + 4 düymə + buzzer)
AR-93Qabaqcıl
Premium

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.

4.8(46)
69
OLED T-Rex Run: Arduino dinozavr oyunu
AR-87Qabaqcıl
Premium

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.

4.7(33)
53
ESP32 Deep Sleep — batareya qənaəti (OLED + RTC RAM sayğac)
ES-33Qabaqcıl
Premium

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.

4.3(10)
16