Arduino yaddaşı çatmır: Sketch too big və Low Memory həlli
Arduino yaddaş çatışmazlığı xəbərdarlığı niyə çıxır? Flash, SRAM və EEPROM fərqi, F() və PROGMEM, String əvəzinə char massivi, boş RAM-ın ölçülməsi və Mega ya da ESP32-yə keçid.
Arduino yaddaş çatışmazlığı xəbərdarlığı proqramın və ya dəyişənlərin platanın yaddaşına sığmadığını bildirir və adətən iki şəkildə qarşına çıxır: kod ümumiyyətlə yüklənmir və kompilyasiya Sketch too big xətası ilə dayanır, ya da kod yüklənir, amma Low memory available, stability problems may occur xəbərdarlığından sonra plata təsadüfi şəkildə yenidən başlayır, Serial Monitor-a mənasız simvollar yazır və ya donur. Arduino Uno-da cəmi 32 KB proqram yaddaşı və 2 KB RAM olduğu üçün bu problem xüsusilə ekran, SD kart və bir neçə sensoru birləşdirən layihələrdə çox rast gəlinir.
Bu bələdçidə əvvəlcə Flash, SRAM və EEPROM arasındakı fərqi və kompilyasiya çıxışındakı iki sətri necə oxuyacağını görəcəksən. Sonra Uno-da real kompilyasiyalarla ölçdüyümüz dəyərlərlə hansı sətrin nə qədər yaddaş yediyini, F() makrosu və PROGMEM ilə sabit məlumatları RAM-dan çıxarmağı, String əvəzinə char massivi istifadə etməyi, kitabxanaların gizli xərcini və boş RAM-ı iş zamanı ölçməyi öyrənəcəksən. Son bölmədə ESP32 və Raspberry Pi Pico-da yaddaşın necə izləndiyini və Mega ya da ESP32-yə keçməyin nə vaxt düzgün qərar olduğunu tapacaqsan.

Arduino-da üç yaddaş: Flash, SRAM və EEPROM
Arduino-dakı mikrokontrollerin içində vəzifələri tamamilə fərqli üç yaddaş var. Flash (proqram yaddaşı) kompilyasiya olunmuş kodunu saxlayır; qida kəsiləndə silinmir və yalnız kod yükləyəndə yazılır. SRAM (iş yaddaşı) dəyişənlərin, funksiya çağırışlarının və müvəqqəti məlumatların saxlandığı yerdir; sürətlidir, amma plata söndükdə içi boşalır. EEPROM isə ayarlar və kalibrləmə dəyərləri kimi az, lakin daimi qalmalı məlumatlar üçün ayrılmış kiçik sahədir. Uno kimi AVR platalarında bu üç yaddaş ayrı ünvan fəzalarındadır (Harvard arxitekturası). Bu detal aşağıda görəcəyin F() və PROGMEM üsullarının niyə lazım olduğunu izah edir.
| Yaddaş | Uno-da ölçüsü | Nə saxlanılır? | Qida kəsiləndə | Yazma ömrü |
|---|---|---|---|---|
| Flash | 32 KB (0,5 KB bootloader-ə ayrılır, 32256 bayt istifadə oluna bilər) | Proqram kodu, PROGMEM məlumatları | Saxlanılır | Təxminən 10.000 silmə/yazma |
| SRAM | 2 KB (2048 bayt) | Dəyişənlər, massivlər, stack və heap | Silinir | Limitsiz |
| EEPROM | 1 KB (1024 bayt) | Ayarlar, sayğaclar, kalibrləmə | Saxlanılır | Hər xanaya təxminən 100.000 yazma |
EEPROM-u RAM əvəzinə istifadə etmək həll deyil: həm yavaşdır, həm də hər xananın yazma ömrü məhduddur. Tez-tez dəyişən dəyişəni hər dövrdə EEPROM-a yazsan, bir neçə gün ərzində həmin xananı sıradan çıxara bilərsən. EEPROM-dan düzgün istifadə yollarını Arduino EEPROM istifadəsi yazısında ətraflı tapa bilərsən.
Platalara görə yaddaş miqdarı
| Plata | Flash (program) | SRAM | EEPROM |
|---|---|---|---|
| Arduino Uno R3 / Nano (ATmega328P) | 32 KB (Uno 32256, Nano 30720 bayt istifadə oluna bilər) | 2 KB | 1 KB |
| Arduino Leonardo / Pro Micro (ATmega32U4) | 32 KB (28672 bayt istifadə oluna bilər) | 2,5 KB | 1 KB |
| Arduino Mega 2560 | 256 KB (253952 bayt istifadə oluna bilər) | 8 KB | 4 KB |
| Arduino Uno R4 (RA4M1) | 256 KB | 32 KB | 8 KB (data flash) |
| ESP32 (WROOM) | 4 MB flash çipi (susmaya görə tətbiq bölməsi 1,25 MB) | 520 KB (proqrama təxminən 300 KB heap qalır) | Yoxdur; Preferences ilə flash-da saxlanılır |
| Raspberry Pi Pico (RP2040) | 2 MB flash çipi | 264 KB | Yoxdur; flash-da emulyasiya olunur |
Cədvəldəki fərq çox böyükdür: ESP32-nin RAM-ı Uno-nunkundan 260 dəfə, Pico-nunku isə təxminən 130 dəfə çoxdur. Buna görə Uno-da böyük səy tələb edən yaddaş qənaətləri ESP32-də çox vaxt lazımsızdır. Yenə də Uno, Nano və Pro Mini aşağı qiymətləri və sadəlikləri səbəbindən ən çox istifadə olunan platalar olduğu üçün 2 KB ilə yaşamağı öyrənmək hər Arduino istifadəçisinə fayda verir.
Kompilyasiya çıxışını oxumaq: Sketch uses və Global variables use
Hər uğurlu kompilyasiyanın sonunda Arduino IDE iki sətir yazır. Boş setup() və loop() olan eskizi Uno üçün kompilyasiya etdikdə bunu görürsən: Sketch uses 444 bytes (1%) of program storage space və Global variables use 9 bytes (0%) of dynamic memory, leaving 2039 bytes for local variables. Birinci sətir proqramın flash-da tutduğu yeri, ikincisi global və static dəyişənlərin RAM-da tutduğu yeri göstərir. Kritik məqam budur: ikinci sətir yalnız ölçüsü kompilyasiya zamanı məlum olan dəyişənləri sayır. Funksiyaların lokal dəyişənləri (stack) və String ya da malloc kimi iş zamanı ayrılan yaddaş (heap) bu rəqəmə daxil deyil. Qalan "local variables" sahəsi onların bölüşəcəyi yerdir.
| Mesaj | Nə vaxt çıxır? | Nə demək olduğu |
|---|---|---|
| Sketch uses ... bytes (x%) of program storage space | Hər kompilyasiyada | Kodun flash-da tutduğu yer |
| Global variables use ... bytes (x%) of dynamic memory | Hər kompilyasiyada | Global və static dəyişənlərin RAM-dakı payı |
| Low memory available, stability problems may occur. | Global dəyişənlər RAM-ın təxminən 75%-ni keçəndə | Kod yüklənir, amma stack və heap üçün yer az qalıb |
| Sketch too big və text section exceeds available space in board | Proqram flash-a sığmayanda | Kod yüklənə bilməz; flash istifadəsini azaltmalısan |
| Not enough memory və data section exceeds available space in board | Global dəyişənlər RAM-ı aşanda | Kod yüklənə bilməz; RAM istifadəsini azaltmalısan |
SRAM-ın içi: global dəyişənlər, heap və stack
Uno-nun 2048 baytlıq RAM-ı dörd bölgəyə ayrılır. Ən aşağıda başlanğıc dəyəri olan global dəyişənlər (.data), onun üstündə sıfırla başlayan global dəyişənlər (.bss) yerləşir; kompilyator bu ikisinin cəmini "Global variables use" sətrində göstərir. Sonra heap gəlir və yuxarı doğru böyüyür: String obyektləri, new və malloc ilə ayrılan yaddaş buradadır. RAM-ın ən yuxarısından isə stack aşağı doğru böyüyür: hər funksiya çağırışı qayıdış ünvanını və lokal dəyişənlərini bura qoyur, kəsmə (interrupt) gələndə reqistrlər də bura saxlanılır. Heap ilə stack ortadakı boşluqda qarşılaşsa, bir-birinin üstünə yazır və proqram gözlənilməz şəkildə pozulur.
| Bölgə | Məzmun | Böyümə istiqaməti | Kompilyasiya çıxışında görünürmü? |
|---|---|---|---|
| .data | İlkin dəyəri verilmiş global və static dəyişənlər, F() daxilinə alınmamış mətnlər | Sabit | Bəli |
| .bss | İlkin dəyəri verilməmiş (sıfır) global və static dəyişənlər, kitabxana buferləri | Sabit | Bəli |
| Heap | String, new, malloc, bəzi kitabxanaların begin() daxilində ayırdığı buferlər | Yuxarı doğru | Xeyr |
| Stack | Lokal dəyişənlər, funksiya qayıdış ünvanları, kəsmə zamanı saxlanılan reqistrlər | Aşağı doğru | Xeyr |
Bu quruluşun iki mühüm nəticəsi var. Birincisi, F() daxilinə alınmamış hər mətn .data bölgəsinə kopyalanır, çünki AVR prosessoru flash-dakı məlumatı adi dəyişən kimi oxuya bilmir. İkincisi, heap-də parçalanma baş verir: müxtəlif ölçülü String-lər yaradıb sildikcə arada kiçik boşluqlar qalır və ümumi boş yaddaş kifayət qədər görünsə belə, böyük parça ayrıla bilmir. Buna görə Uno-da uzun müddət işləyən proqramlarda heap-ə mümkün qədər toxunmamaq ən etibarlı yoldur.
Əvvəlcə ölç: hansı sətir nə qədər yaddaş xərcləyir?
Yaddaş problemini həll etməyin ilk addımı təxmin etmək yox, ölçməkdir. Aşağıdakı cədvəlin hər sətri Arduino AVR core 1.8.6 ilə Arduino Uno üçün ayrıca kompilyasiya edilmiş kiçik eskizin real çıxışıdır. Dəyərlər kitabxana və core versiyasına görə bir neçə bayt dəyişə bilər, amma nisbətlər həmişə eyni qalır.
| Eskizdə nə var? | Flash (bayt) | Global RAM (bayt) |
|---|---|---|
| Boş setup() və loop() | 444 | 9 |
| Serial.begin(9600) | 1438 | 184 |
| + Serial.println("44 simvolluq mətn") | 1518 | 232 |
| Eyni mətn F() ilə | 1530 | 188 |
| analogRead + Serial.println(int) | 1892 | 188 |
| float hesablama + Serial.println(float) | 3380 | 200 |
| String birləşdirmə: "A0=" + String(analogRead(A0)) | 3316 | 202 |
| Eyni iş snprintf və char massivi ilə | 3232 | 194 |
| Wire (I2C) ilə tək yazma | 2476 | 225 |
| SD kart: begin, open, println, close | 10496 | 837 |
| int veri[700] massivi | 1780 | 1588 (77%, Low memory xəbərdarlığı) |
| int veri[950] massivi | 1780 | 2088 (101%, kompilyasiya olunmur) |
Cədvəldən çıxan dərslər aydındır. Təkcə Serial.begin() 175 bayt RAM tələb edir, çünki serial port 64 baytlıq qəbul və 64 baytlıq göndərmə buferi ayırır. 44 simvolluq tək mətn 44 bayt RAM tutur; eyni mətn F() ilə yazılanda bu RAM geri qayıdır. float istifadəsi flash-a təxminən 1,5 KB üzən nöqtə kodu əlavə edir. SD kitabxanası tək başına 10 KB flash və təxminən 830 bayt RAM işlədir; Uno-nun RAM-ının 40%-i yalnız bir log faylına gedir. String nümunəsinin global RAM-ı kiçik görünür, amma əsl xərci iş zamanı heap-də ortaya çıxır və kompilyasiya çıxışında heç görünmür.
F() makrosu: sabit mətnləri RAM-dan çıxar
Uno-da "Sicaklik: " kimi dırnaq içindəki hər mətn flash-da durur, amma proqram başlayanda RAM-a kopyalanır və orada sonadək yer tutur. F() makrosu bu kopyalanmanın qarşısını alır: mətn flash-da qalır, Serial.print kimi funksiyalar onu hərf-hərf birbaşa flash-dan oxuyur. F() Print sinfindən törəyən hər obyektlə işləyir; Serial, LiquidCrystal, LiquidCrystal_I2C, Adafruit SSD1306 və SD faylları bunlardandır. Menyuları, xəta mesajları və kömək mətnləri olan layihədə yalnız F() əlavə etmək bir neçə yüz bayt RAM qazandıra bilər. Aşağıdakı kod həm fərqi göstərir, həm də boş RAM-ı iş zamanı ölçür:
1// Boş RAM'i ölçmek ve F() ile RAM kazanmak (Uno, Nano, Mega)
2// Measure free RAM and save RAM with F() (Uno, Nano, Mega)
3extern int __heap_start, *__brkval; // avr-libc heap sınırları / avr-libc heap limits
4
5int bosRam() {
6 int yerel; // stack'in o anki tepesi / current top of the stack
7 return (int)&yerel - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
8}
9
10void setup() {
11 Serial.begin(9600);
12 Serial.println("Bu metin RAM'e kopyalanir"); // RAM'de 26 bayt / 26 bytes of RAM
13 Serial.println(F("Bu metin flasta kalir")); // RAM'de 0 bayt / 0 bytes of RAM
14 Serial.print(F("Bos RAM / Free RAM: "));
15 Serial.println(bosRam());
16}
17
18void loop() {
19}bosRam() funksiyası stack-in cari zirvəsi ilə heap-in sonu arasındakı məsafəni hesablayır; yəni heap ilə stack-in qarşılaşmasına neçə bayt qaldığını göstərir. Bu funksiyanı loop() daxilində, ekran yenilənməsindən və ya SD yazmasından dərhal sonra çağırsan, ən pis anı tutarsan. Praktik qayda: Uno-da iş zamanı boş RAM-ın 200–300 baytdan aşağı düşməsinə icazə vermə. F() char* gözləyən funksiyalarla (strcmp, strcpy) işləmir; onlar üçün aşağıda görəcəyin _P versiyalarından və PSTR() makrosundan istifadə edirsən.
PROGMEM: böyük cədvəlləri flash-da saxlamaq
F() yalnız mətnlər üçündür. Not massivləri, ekran ikonaları (bitmap), simvol cədvəlləri, kalibrləmə əyriləri və ya mesaj siyahıları kimi heç dəyişməyən böyük massivlər üçün PROGMEM açar sözündən istifadə edirsən. PROGMEM ilə təyin olunan massiv RAM-a heç kopyalanmır; onu oxumaq üçün adi massiv girişi əvəzinə pgm_read_byte, pgm_read_word kimi xüsusi funksiyalar lazımdır. Məsələn, 100 notluq melodiya tezlik və müddət cədvəli ilə 400 bayt edir; bu, Uno-nun RAM-ının beşdə biridir və PROGMEM ilə tamamilə flash-a daşınır.
1// Mesaj listesi ve nota tablosu flaşta (PROGMEM)
2// Message list and note table kept in flash (PROGMEM)
3const char m0[] PROGMEM = "Sistem hazir";
4const char m1[] PROGMEM = "Sensor hatasi";
5const char m2[] PROGMEM = "Kapi acik";
6const char* const mesajlar[] PROGMEM = { m0, m1, m2 }; // işaretçi tablosu da flaşta / pointer table in flash too
7
8const uint16_t notalar[] PROGMEM = { 262, 294, 330, 349, 392, 440, 494, 523 }; // Do-Re-Mi ... Do (Hz)
9const byte BUZZER_PIN = 8;
10
11void setup() {
12 Serial.begin(9600);
13 char tampon[20]; // RAM'de tek ortak tampon / one shared RAM buffer
14 for (byte i = 0; i < 3; i++) {
15 strcpy_P(tampon, (const char*)pgm_read_ptr(&mesajlar[i])); // flaştan RAM'e kopyala / copy flash -> RAM
16 Serial.println(tampon);
17 }
18 for (byte i = 0; i < 8; i++) {
19 uint16_t frekans = pgm_read_word(¬alar[i]); // 2 baytlık değeri oku / read a 2-byte value
20 tone(BUZZER_PIN, frekans, 200);
21 delay(250);
22 }
23}
24
25void loop() {
26}| Funksiya / makro | Nə edir? |
|---|---|
| pgm_read_byte(&dizi[i]) | Flash-dan 1 bayt oxuyur (byte, char, uint8_t massivləri, bitmap-lər) |
| pgm_read_word(&dizi[i]) | Flash-dan 2 bayt oxuyur (int, uint16_t; Uno-da not və rəqəm cədvəlləri) |
| pgm_read_dword / pgm_read_float | 4 baytlıq long və float dəyərlərini oxuyur |
| pgm_read_ptr(&tablo[i]) | Flash-dakı göstəricini oxuyur (mətn cədvəlləri) |
| strcpy_P(hedef, kaynak) | Flash-dakı mətni RAM-dakı buferə kopyalayır |
| strcmp_P(ram_text, PSTR("...")) | RAM-dakı mətni flash-dakı mətnlə müqayisə edir |
| strlen_P / memcpy_P | Flash-dakı mətnin uzunluğunu tapır, flash-dan blok kopyalayır |
String əvəzinə char massivi istifadə et
Arduino-nun String sinfi rahatdır, amma hər birləşdirmə əməliyyatında (+) heap-dən yeni parça istəyir, köhnəsini azad edir. Uno-nun kiçik heap-ində bu əməliyyat minlərlə dəfə təkrarlananda yaddaş deşik-deşik olur. Proqram saatlarla problemsiz işləyir, sonra birdən donur və xətanı tapmaq çox çətindir. Həll ölçüsü əvvəlcədən məlum olan char massivləri istifadə etməkdir: yaddaş bir dəfə ayrılır, heç parçalanmır və istifadə olunan bayt sayı kompilyasiya çıxışında görünür. Aşağıdakı kod Serial Monitor-dan gələn əmrləri String istifadə etmədən oxuyur və ölçməni tək sətirdə formatlayır:
1// String yerine sabit boyutlu char dizileri / fixed-size char arrays instead of String
2char komut[16]; // gelen komut tamponu / incoming command buffer
3byte konum = 0; // tampondaki karakter sayısı / characters in the buffer
4
5void setup() {
6 Serial.begin(9600);
7 pinMode(13, OUTPUT);
8 Serial.println(F("Komutlar / Commands: LED ON, LED OFF, OLC"));
9}
10
11void olcumGonder() {
12 int ham = analogRead(A0);
13 float volt = ham * 5.0 / 1023.0; // Uno: 5 V, 10 bit
14 char vMetin[8];
15 dtostrf(volt, 4, 2, vMetin); // AVR'de snprintf %f desteklemez / AVR snprintf has no %f
16 char satir[40];
17 snprintf(satir, sizeof(satir), "A0=%d ham, %s V", ham, vMetin); // taşma olmaz / never overflows
18 Serial.println(satir);
19}
20
21void komutIsle(const char* k) {
22 if (strcmp_P(k, PSTR("LED ON")) == 0) digitalWrite(13, HIGH); // PSTR: metin flaşta / literal in flash
23 else if (strcmp_P(k, PSTR("LED OFF")) == 0) digitalWrite(13, LOW);
24 else if (strcmp_P(k, PSTR("OLC")) == 0) olcumGonder();
25 else Serial.println(F("Bilinmeyen komut / Unknown command"));
26}
27
28void loop() {
29 while (Serial.available()) {
30 char c = Serial.read();
31 if (c == '\n') { // satır bitti / line complete
32 komut[konum] = '\0';
33 komutIsle(komut);
34 konum = 0;
35 } else if (c != '\r' && konum < sizeof(komut) - 1) {
36 komut[konum++] = c; // taşmadan ekle / append without overflow
37 }
38 }
39}Kodda diqqət ediləcək üç detal var. snprintf buferin ölçüsünü bildiyi üçün mətn uzun gəlsə belə massivdən daşmır; sprintf bu qorunmanı vermir. AVR-in printf ailəsi susmaya görə %f formatını dəstəkləmədiyindən float dəyər əvvəlcə dtostrf ilə mətnə çevrilir. Əmr buferinin həddi (konum < sizeof(komut) - 1) də uzun sətrin yaddaşın başqa yerini əzməsinin qarşısını alır. String istifadə etməli olsan (bəzi kitabxanalar String qaytarır), ən azı setup() daxilində metin.reserve(64) ilə lazım olan yeri əvvəlcədən ayır və String-i global təyin et; beləliklə parçalanma xeyli azalır.
Düzgün verilənlər növü və lokal dəyişənlər
| Növ | Uno (AVR) | ESP32 / Pico | Dəyər aralığı (Uno) |
|---|---|---|---|
| bool, char, byte | 1 bayt | 1 bayt | byte: 0–255 |
| int | 2 bayt | 4 bayt | -32768 ilə 32767 |
| unsigned int, uint16_t | 2 bayt | uint16_t 2, unsigned int 4 bayt | 0–65535 |
| long, unsigned long | 4 bayt | 4 bayt | unsigned long: 0–4.294.967.295 |
| float | 4 bayt | 4 bayt | Təxminən 6–7 mənalı rəqəm |
| double | 4 bayt (float ilə eyni) | 8 bayt | Uno-da float-dan fərqi yoxdur |
- Kiçik ədədlər üçün byte: 0–255 arasındakı pin nömrələri, sayğaclar və faizlər üçün int əvəzinə byte istifadə etmək hər dəyişəndə 1 bayt, 200 elementli massivdə 200 bayt qazandırır.
- Pin nömrələri üçün const: const byte LED_PIN = 13; şəklində təyin olunan sabitləri kompilyator birbaşa koda gömür, RAM-da yer ayırmır.
- Açıq/bağlı məlumatları bitlərdə saxla: 8 ədəd bool 8 bayt tutur; eyni məlumatı bir byte-ın bitlərində bitRead və bitWrite ilə saxlasan, 1 bayt kifayətdir.
- Böyük lokal massivlərə diqqət et: Funksiya daxilində təyin olunan char tampon[300]; kompilyasiya çıxışında görünmür, amma funksiya hər çağırılanda stack-dən 300 bayt alır. Böyük buferləri global et ki, ölçüləri görünsün.
- Rekursiyadan qaç: Özünü çağıran hər funksiya stack-də yeni qat açır; Uno-da bir neçə onluq dərinlik belə RAM-ı bitirə bilər.
- Böyük strukturları istinadla ötür: struct-ı funksiyaya dəyərlə göndərmək onun surətini stack-ə qoyur; const Ayar& a şəklində istinadla göndərmək kopyalamır.
Kitabxanaların gizli yaddaş xərci
Layihədə yaddaş birdən tükənibsə, günahkar çox vaxt sənin kodun yox, əlavə etdiyin kitabxana olur. Bəzi kitabxanalar RAM-ı kompilyasiya zamanı (global bufer kimi), bəziləri isə begin() çağırılanda heap-dən ayırır; ikinci halda kompilyasiya çıxışı günahsız görünür, amma plata işləyəndə yaddaş bitir. Aşağıdakı dəyərlərin bir hissəsi yuxarıdakı ölçmə cədvəlindən, bir hissəsi kitabxanaların bufer ölçülərindən gəlir:
| Kitabxana / xüsusiyyət | RAM xərci (Uno) | Nə vaxt ayrılır? | Daha yüngül seçim |
|---|---|---|---|
| Serial | Təxminən 175 bayt (64 + 64 baytlıq buferlər) | Kompilyasiyada (global) | Lazım deyilsə Serial-ı tamamilə çıxar |
| Wire (I2C) | Təxminən 215 bayt | Kompilyasiyada (global) | Tək I2C cihazı olsa belə qaçılmazdır; digər qənaətlərə fokuslan |
| SoftwareSerial | Təxminən 120 bayt (64 baytlıq qəbul buferi) | Kompilyasiyada (global) | Mümkünsə aparat serial portu və ya Mega-nın əlavə portları |
| SD | Təxminən 830 bayt, əlavə olaraq təxminən 10 KB flash | Kompilyasiyada (global) | Qeyd işini ESP32-yə və ya Mega-ya burax |
| Adafruit SSD1306 128x64 | 1024 baytlıq kadr buferi | begin() daxilində heap-dən | U8g2 səhifə rejimi (128 bayt) və ya yalnız mətn üçün U8x8 |
| Adafruit NeoPixel / FastLED | Hər LED üçün 3 bayt (60 LED = 180 bayt) | Başlanğıcda | LED sayını real lent uzunluğu ilə məhdudlaşdır |
Bu cədvəl Uno-da OLED ekranı, SD kartı və Wi-Fi modulunu eyni anda istifadə etməyin niyə demək olar ki, mümkünsüz olduğunu izah edir: yalnız SSD1306 buferi ilə SD kitabxanası birlikdə 1,8 KB edir və 2 KB-lıq RAM-dan proqramına demək olar ki, heç nə qalmır. OLED ekranda qarşılaşdığın SSD1306 allocation failed xətası məhz bu heap ayrılmasının uğursuz olmasıdır; həllərini OLED ekran SSD1306 yazısında da tapa bilərsən.
Sketch too big: flash yaddaşını azaltmağın yolları
- Sazlama çıxışını söndür: İnkişaf zamanı əlavə edilən Serial.print sətirləri həm flash, həm RAM xərcləyir. Aşağıdakı DEBUG makrosu ilə tək sətri dəyişərək hamısını kompilyasiyadan çıxara bilərsən.
- float və sprintf-dən qaç: Ölçmədə gördüyün kimi float təxminən 1,5 KB, snprintf isə 1 KB-dan çox kod əlavə edir. Temperaturu 10-a vurub int kimi saxlamaq (23,5 °C əvəzinə 235) əksər layihələrdə kifayətdir.
- Təkrarlanan kodu funksiyaya və massivə çevir: Hər LED üçün ayrı-ayrı yazılmış on sətirlik bloklar əvəzinə pin nömrələrini massivdə saxlayıb dövrlə emal etmək kodu nəzərəçarpacaq dərəcədə qısaldır.
- Daha kiçik kitabxana seç: Qrafika lazım deyilsə, U8x8 və ya LiquidCrystal_I2C Adafruit GFX əsaslı kitabxanalardan çox az yer tutur. Kitabxananın tək bir funksiyası üçün bütün kitabxananı əlavə etmək əvəzinə həmin hissəni özün yazmağı düşün.
- Plata ayarını yoxla: Arduino IDE həddi seçdiyin plataya görə hesablayır: Uno üçün 32256, Nano üçün (köhnə və ya yeni bootloader) 30720, Leonardo üçün 28672 bayt. Yanlış plata seçilibsə, həm hədd, həm də pin təyinatları yanlış olur.
- Daha böyük plataya keç: Bütün bunlardan sonra hələ də sığmırsa, Mega (256 KB) və ya ESP32 (1,25 MB və daha çox) eyni kodu kiçik dəyişikliklərlə işlədir.
1// DEBUG makrosu: hata ayıklama çıktısını tek satırla aç/kapat
2// DEBUG macro: switch debug output on/off with one line
3#define DEBUG 1 // yayında 0 yap / set to 0 for release
4
5#if DEBUG
6 #define DBG(x) Serial.print(x)
7 #define DBGLN(x) Serial.println(x)
8#else
9 #define DBG(x)
10 #define DBGLN(x)
11#endif
12
13void setup() {
14#if DEBUG
15 Serial.begin(9600);
16#endif
17 pinMode(13, OUTPUT);
18 DBGLN(F("Basladi / Started"));
19}
20
21void loop() {
22 int deger = analogRead(A0);
23 digitalWrite(13, deger > 512 ? HIGH : LOW); // asıl iş / the real job
24 DBG(F("A0: "));
25 DBGLN(deger);
26 delay(500);
27}DEBUG 1 olanda bu eskiz Uno-da 2292 bayt flash və 188 bayt RAM istifadə edir; DEBUG 0 etdikdə Serial kodu tamamilə kompilyasiyadan çıxır və dəyərlər 934 bayt flash və 9 bayt RAM-a enir. Aradakı 1,3 KB flash və 179 bayt RAM bitmiş layihəyə yeni xüsusiyyət əlavə etmək üçün çox vaxt kifayətdir.
ESP32-də yaddaşı ölçmək
ESP32-də yaddaş bol olsa da, limitsiz deyil. Wi-Fi açılanda onlarla KB RAM ayrılır, Bluetooth da əlavə olunanda bu miqdar 100 KB-a yaxınlaşa bilər; veb server, JSON sənədləri və görüntü buferləri də tez yer tutur. ESP32-CAM kimi bəzi modullarda əlavə PSRAM (əksərən 4 MB) olur və böyük buferlər ora qoyulur. Flash tərəfdə tətbiq 1,25 MB-lıq susmaya görə bölməyə sığmasa, Tools menyusundakı Partition Scheme ayarından "Huge APP" seçimi ilə 3 MB-a qədər artıra bilərsən. ESP32-nin ümumi xüsusiyyətləri üçün ESP32 nədir? yazısına baxa bilərsən.
1// ESP32 bellek raporu / ESP32 memory report
2void setup() {
3 Serial.begin(115200);
4 delay(500);
5 Serial.printf("Bos heap / Free heap: %u bayt\n", ESP.getFreeHeap());
6 Serial.printf("En dusuk heap / Minimum free heap: %u bayt\n", ESP.getMinFreeHeap());
7 Serial.printf("En buyuk blok / Largest free block: %u bayt\n", ESP.getMaxAllocHeap());
8 Serial.printf("PSRAM: %u bayt\n", ESP.getPsramSize());
9 Serial.printf("Program / Sketch: %u, bos alan / free: %u bayt\n", ESP.getSketchSize(), ESP.getFreeSketchSpace());
10}
11
12void loop() {
13 // loop görevinin hiç kullanılmamış stack'i / never-used stack of the loop task
14 Serial.printf("loop stack bos / free: %u bayt\n", (unsigned)uxTaskGetStackHighWaterMark(NULL));
15 Serial.printf("Bos heap / Free heap: %u bayt\n", ESP.getFreeHeap());
16 delay(5000);
17}Buradakı ən qiymətli iki ədəd getMinFreeHeap və getMaxAllocHeap-dir. Birincisi proqram açıldığından bəri boş heap-in düşdüyü ən aşağı dəyəri, ikincisi tək parça halında ayrıla bilən ən böyük bloku verir. Boş heap 100 KB görünəndə ən böyük blok 10 KB-dan aşağıdırsa, heap parçalanıb və böyük String ya da JSON sənədi ayrıla bilməyə bilər. ESP32-də loop() öz tapşırığında (task) 8 KB-lıq stack ilə işləyir; uxTaskGetStackHighWaterMark bu stack-in heç toxunulmamış hissəsini göstərir və bir neçə yüz baytdan aşağı enərsə, "Stack canary watchpoint triggered" xətası ilə qarşılaşa bilərsən.
Raspberry Pi Pico və MicroPython-da yaddaş
Pico-nun 264 KB RAM-ı Uno ilə müqayisədə çox böyükdür, amma MicroPython interpretatoru bunun bir hissəsini özü istifadə edir; proqramına adətən 190 KB civarında heap qalır. MicroPython-da yaddaş zibil yığıcı (garbage collector) ilə idarə olunur: artıq istifadə olunmayan obyektlər gc.collect() çağırılanda və ya yaddaş dolmaq üzrə olanda təmizlənir. Yaddaş həqiqətən bitəndə MemoryError: memory allocation failed xətası alırsan. Dövr daxilində mətn birləşdirmək, böyük siyahılar yaratmaq və çox uzun tək kod faylı bu xətanın ən geniş yayılmış səbəbləridir.
1import gc
2import micropython
3
4gc.collect() # önce çöpleri topla / collect garbage first
5print("Bos RAM / Free RAM:", gc.mem_free(), "bayt")
6print("Kullanilan / Used:", gc.mem_alloc(), "bayt")
7micropython.mem_info() # ayrıntılı rapor / detailed report
8
9# Kötü: her turda yeni metin nesnesi / bad: a new string object every loop
10# satir = ""
11# for i in range(100): satir += str(i) + ","
12
13# İyi: tek seferlik bytearray tamponu / good: one preallocated bytearray buffer
14tampon = bytearray(64)
15for i in range(10):
16 tampon[i] = 48 + i # ASCII '0'..'9'
17print(bytes(tampon[:10]))MicroPython-da yaddaşı qorumaq üçün buferləri əvvəlcədən bytearray ilə ayır və dövrdə təkrar istifadə et, sabit ədədləri const() ilə təyin et, böyük modulları mpy-cross ilə əvvəlcədən kompilyasiya olunmuş .mpy fayllarına çevir və uzun işlərdən əvvəl gc.collect() çağır. Pico-da MicroPython-un əsas əmrlərini MicroPython əsasları yazısında, platanın ümumi xüsusiyyətlərini Raspberry Pi Pico nədir? yazısında tapa bilərsən.
Nə vaxt Mega-ya və ya ESP32-yə keçməli?

| Vəziyyət | Tövsiyə |
|---|---|
| F(), PROGMEM və char massivlərindən sonra boş RAM 300 baytdan yuxarıdır | Uno-da qal; problem həll olundu |
| OLED və ya SD ilə birlikdə bir neçə sensor və menyu var, RAM hələ də çatmır | Arduino Mega 2560: 4 dəfə çox RAM, eyni 5 V pinlər və kitabxanalar |
| Proqram 32 KB-ı aşır, amma RAM kifayətdir | Mega və ya Uno R4: 256 KB flash |
| Wi-Fi, veb server, böyük buferlər və ya təsvir emalı lazımdır | ESP32: 520 KB RAM, 4 MB flash, Wi-Fi və Bluetooth |
| MicroPython ilə işləmək istəyirsən | Raspberry Pi Pico və ya Pico W |
| Batareya ilə aylarla işləməli kiçik sensor düyünü | Uno-da optimallaşdır və ya Pro Mini istifadə et; böyük plata daha çox cərəyan çəkir |
Mega-ya keçəndə kodun böyük hissəsi eynən qalır; yalnız I2C pinlərinin 20 (SDA) və 21 (SCL), SPI pinlərinin 50–53 olduğunu unutma. ESP32-yə keçiddə isə 3,3 V məntiq səviyyəsi, fərqli pin nömrələri və analogRead-in 12 bitlik (0–4095) nəticəsi kimi fərqlər var. Hansı platanın sənə uyğun olduğuna qərar vermək üçün Arduino yoxsa ESP32? müqayisəsinə, 5 V ilə uyğun, amma daha geniş yaddaşı olan seçim üçün Arduino Uno R4 yazısına göz at.
Tez-tez edilən xətalar və həlləri
| Əlamət | Ehtimal olunan səbəb | Həll |
|---|---|---|
| Sketch too big, kod yüklənmir | Proqram flash-a sığmır | Sazlama çıxışını söndür, float və sprintf-i azalt, kiçik kitabxana seç, lazım olsa Mega |
| Kod yüklənir, amma bir neçə dəqiqə sonra donur | String birləşdirmələri heap-i parçalayır | String əvəzinə char massivi və snprintf istifadə et; boş RAM-ı ölç |
| Serial Monitor-da mənasız simvollar, dəyişənlər özbaşına dəyişir | Stack heap-in üstünə yazır | Global RAM-ı 75%-dən aşağı endir, böyük lokal massivləri götür |
| SSD1306 allocation failed | begin() 1 KB bufer ayıra bilmir | Mətnləri F() daxilinə al, U8g2 səhifə rejiminə keç |
| Plata təsadüfi yenidən başlayır, yaddaş qaydasında görünür | Yaddaş yox, qida problemi ola bilər | Mühərrik və releləri ayrıca qidalandır, kondensator əlavə et |
| Massiv elementləri mənasız dəyərlər göstərir | Massivin sərhədindən kənara yazılır | İndeksi yoxla; dövr həddini sizeof ilə hesabla |
| ESP32-də Stack canary watchpoint triggered | Tapşırığın stack-i daşıb | Böyük lokal massivləri global et və ya tapşırığın stack-ini böyüt |
Arduino-da yaddaş çatışmazlığı çox vaxt platanı dəyişmədən həll olunur: sabit mətnləri F() ilə flash-a almaq, böyük cədvəlləri PROGMEM-ə daşımaq, String əvəzinə char massivi istifadə etmək və lazımsız kitabxanaları təmizləmək 2 KB-lıq RAM-ı təəccüblü dərəcədə rahatlaşdırır. BlueGrays tətbiqində OLED oyunları, melodiya çalan buzzer layihələri və LED matris animasiyaları kimi yaddaşı çətinləşdirən layihələri addım-addım dövrə sxemi və bu üsullarla yazılmış kodları ilə araşdıra bilərsən.
Tez-tez verilən suallar
Arduino-da Low memory available xəbərdarlığı nə deməkdir?
Global dəyişənlərin RAM-ın təxminən 75%-ni doldurduğunu və stack ilə heap üçün az yer qaldığını bildirir. Kod yüklənir, amma işləyərkən təsadüfi yenidən başlamalar, donmalar və pozulmuş dəyişənlər görünə bilər. Sabit mətnləri F() daxilinə almaq və böyük massivləri PROGMEM-ə daşımaq çox vaxt xəbərdarlığı aradan qaldırır.
Sketch too big xətası necə düzəldilir?
Bu xəta proqramın flash yaddaşa sığmadığını göstərir. Sazlama üçün əlavə edilmiş Serial çıxışlarını söndür, float və sprintf istifadəsini azalt, təkrarlanan kodu funksiyalara çevir və daha kiçik kitabxanalar seç. Yenə də sığmırsa, Arduino Mega və ya ESP32 kimi flash-ı böyük plataya keç.
Arduino Uno-nun yaddaşı nə qədərdir?
Arduino Uno-dakı ATmega328P-də 32 KB flash (0,5 KB bootloader-ə ayrılır), 2 KB SRAM və 1 KB EEPROM var. Proqram flash-a, dəyişənlər SRAM-a, daimi ayarlar EEPROM-a yazılır. Problemlərin çoxu bu 2 KB-lıq SRAM-da çıxır.
F() makrosu nəyə lazımdır?
F(), Serial.print kimi funksiyalara verilən sabit mətnlərin RAM-a kopyalanmasının qarşısını alır və onları flash-da saxlayır. Uno-da hər simvol bir bayt RAM qənaəti deməkdir; çoxlu mesajı olan layihələrdə yüzlərlə bayt qazandırır. ESP32 və Pico-da da kompilyasiya olunur, amma orada təsiri yoxdur.
Arduino-da boş RAM necə ölçülür?
Uno, Nano və Mega-da __heap_start və __brkval dəyişənləri ilə stack ilə heap arasındakı məsafəni hesablayan kiçik funksiyadan istifadə olunur. ESP32-də ESP.getFreeHeap() və ESP.getMinFreeHeap(), MicroPython-da gc.mem_free() eyni məlumatı verir. Ölçməni yaddaşın ən çox istifadə olunduğu anda aparmaq vacibdir.
Arduino-da String istifadə etmək niyə problem yaradır?
String obyektləri hər birləşdirmədə heap-dən yeni yaddaş istəyir və köhnəsini buraxır; Uno-nun kiçik heap-i zamanla parçalanır. Ümumi boş yaddaş kifayət qədər görünsə belə, yeni parça ayrıla bilmir və proqram donur. Sabit ölçülü char massivləri və snprintf bu problemi tamamilə aradan qaldırır.
Bu yazıdan sonra edə biləcəyin layihələr
Bütün layihələrə bax
Buzzer ilə İstiklal Marşı
Düyməyə basanda kiçik buzzer Türkiyənin dövlət himni İstiklal Marşı-nı not-not çalmağa başlayır.

DHT11 ilə temperatur və rütubət
Otağın neçə dərəcədir, hava rütubətlidir, yoxsa quru? DHT11 sensoru temperaturu və rütubəti ölçür, Arduino da bu dəyərləri iki sətirlik LCD ekrana yazır və bir neçə saniyədən bir yeniləyir.

Raket top oyunu - SSD1306
Bir top, iki raket və sən: video oyunların ən qədimlərindən olan stolüstü tennisi kiçik OLED ekranda oynayı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.

Piksel ilan: 8x8 matris
Klassik ilan oyununu özün qur və oyna. Rəngli 8x8 işıq matrisində yaşıl ilanı coystiklə idarə edib qırmızı almaları yeyirsən; hər almada ilan uzanır, bir az sürətlənir və xalın kiçik rəqəm ekranında…

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.

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

