Bələdçilər · 11 dəq oxu

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 Uno platası və ATmega328P mikrokontrolleri
Arduino Uno-nun ürəyindəki ATmega328P: 32 KB flash, 2 KB SRAM və 1 KB EEPROM. Yaddaş problemlərinin çoxu bu 2 KB-lıq RAM-da yaşanır.

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ü
Flash32 KB (0,5 KB bootloader-ə ayrılır, 32256 bayt istifadə oluna bilər)Proqram kodu, PROGMEM məlumatlarıSaxlanılırTəxminən 10.000 silmə/yazma
SRAM2 KB (2048 bayt)Dəyişənlər, massivlər, stack və heapSilinirLimitsiz
EEPROM1 KB (1024 bayt)Ayarlar, sayğaclar, kalibrləməSaxlanılırHə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ı

PlataFlash (program)SRAMEEPROM
Arduino Uno R3 / Nano (ATmega328P)32 KB (Uno 32256, Nano 30720 bayt istifadə oluna bilər)2 KB1 KB
Arduino Leonardo / Pro Micro (ATmega32U4)32 KB (28672 bayt istifadə oluna bilər)2,5 KB1 KB
Arduino Mega 2560256 KB (253952 bayt istifadə oluna bilər)8 KB4 KB
Arduino Uno R4 (RA4M1)256 KB32 KB8 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 çipi264 KBYoxdur; 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.

MesajNə vaxt çıxır?Nə demək olduğu
Sketch uses ... bytes (x%) of program storage spaceHər kompilyasiyadaKodun flash-da tutduğu yer
Global variables use ... bytes (x%) of dynamic memoryHər kompilyasiyadaGlobal 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 boardProqram flash-a sığmayandaKod yüklənə bilməz; flash istifadəsini azaltmalısan
Not enough memory və data section exceeds available space in boardGlobal dəyişənlər RAM-ı aşandaKod yüklənə bilməz; RAM istifadəsini azaltmalısan
"Low memory" xəbərdarlığı xəta deyil və kod problemsiz yüklənir; əsl təhlükə də budur. Məsələn, int veri[700]; təyin olunmuş eskiz Uno-da 1588 bayt (77%) global dəyişən istifadə edir və stack ilə heap üçün cəmi 460 bayt buraxır. Bir neçə iç-içə funksiya çağırışı, String birləşdirməsi və ya kitabxananın begin() daxilində ayırdığı bufer bu sahəni tükətdikdə proqram çöküb. Əlamətlər təsadüfi yenidən başlamalar, pozulan dəyişənlər və donmalardır; bunları qida problemlərindən ayırmaq üçün Arduino özünü yenidən başladır yazısına da bax.

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əzmunBöyümə istiqamətiKompilyasiya çı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ərSabitBəli
.bssİlkin dəyəri verilməmiş (sıfır) global və static dəyişənlər, kitabxana buferləriSabitBəli
HeapString, new, malloc, bəzi kitabxanaların begin() daxilində ayırdığı buferlərYuxarı doğruXeyr
StackLokal dəyişənlər, funksiya qayıdış ünvanları, kəsmə zamanı saxlanılan reqistrlərAşağı doğruXeyr

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()4449
Serial.begin(9600)1438184
+ Serial.println("44 simvolluq mətn")1518232
Eyni mətn F() ilə1530188
analogRead + Serial.println(int)1892188
float hesablama + Serial.println(float)3380200
String birləşdirmə: "A0=" + String(analogRead(A0))3316202
Eyni iş snprintf və char massivi ilə3232194
Wire (I2C) ilə tək yazma2476225
SD kart: begin, open, println, close10496837
int veri[700] massivi17801588 (77%, Low memory xəbərdarlığı)
int veri[950] massivi17802088 (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:

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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(&notalar[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 / makroNə 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_float4 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_PFlash-dakı mətnin uzunluğunu tapır, flash-dan blok kopyalayır
ESP32 və Pico-da const təyin olunan massivlər onsuz da flash-da qalır; PROGMEM orada təsirsizdir, amma xəta da vermir, pgm_read_* funksiyaları da təyin olunub. Buna görə PROGMEM ilə yazdığın kod üç platada da kompilyasiya olunur. Bir istisna var: göstərici cədvəli oxuyarkən Uno-da işləyən pgm_read_word 32 bitlik platalarda göstəricini kəsir; daşına bilən kod üçün pgm_read_ptr istifadə et.

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:

C++ (Arduino IDE)
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övUno (AVR)ESP32 / PicoDəyər aralığı (Uno)
bool, char, byte1 bayt1 baytbyte: 0–255
int2 bayt4 bayt-32768 ilə 32767
unsigned int, uint16_t2 baytuint16_t 2, unsigned int 4 bayt0–65535
long, unsigned long4 bayt4 baytunsigned long: 0–4.294.967.295
float4 bayt4 baytTəxminən 6–7 mənalı rəqəm
double4 bayt (float ilə eyni)8 baytUno-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ətRAM xərci (Uno)Nə vaxt ayrılır?Daha yüngül seçim
SerialTəxminən 175 bayt (64 + 64 baytlıq buferlər)Kompilyasiyada (global)Lazım deyilsə Serial-ı tamamilə çıxar
Wire (I2C)Təxminən 215 baytKompilyasiyada (global)Tək I2C cihazı olsa belə qaçılmazdır; digər qənaətlərə fokuslan
SoftwareSerialTə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ı
SDTəxminən 830 bayt, əlavə olaraq təxminən 10 KB flashKompilyasiyada (global)Qeyd işini ESP32-yə və ya Mega-ya burax
Adafruit SSD1306 128x641024 baytlıq kadr buferibegin() daxilində heap-dənU8g2 səhifə rejimi (128 bayt) və ya yalnız mətn üçün U8x8
Adafruit NeoPixel / FastLEDHər LED üçün 3 bayt (60 LED = 180 bayt)BaşlanğıcdaLED 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.
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

Python
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?

Arduino Mega 2560 platası
Arduino Mega 2560: 256 KB flash, 8 KB SRAM və 4 KB EEPROM. Uno kodu çox vaxt heç dəyişmədən işləyir.
VəziyyətTövsiyə
F(), PROGMEM və char massivlərindən sonra boş RAM 300 baytdan yuxarıdırUno-da qal; problem həll olundu
OLED və ya SD ilə birlikdə bir neçə sensor və menyu var, RAM hələ də çatmırArduino Mega 2560: 4 dəfə çox RAM, eyni 5 V pinlər və kitabxanalar
Proqram 32 KB-ı aşır, amma RAM kifayətdirMega və ya Uno R4: 256 KB flash
Wi-Fi, veb server, böyük buferlər və ya təsvir emalı lazımdırESP32: 520 KB RAM, 4 MB flash, Wi-Fi və Bluetooth
MicroPython ilə işləmək istəyirsənRaspberry 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ətEhtimal olunan səbəbHəll
Sketch too big, kod yüklənmirProqram flash-a sığmırSazlama çı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 donurString birləşdirmələri heap-i parçalayırString ə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şirStack heap-in üstünə yazırGlobal RAM-ı 75%-dən aşağı endir, böyük lokal massivləri götür
SSD1306 allocation failedbegin() 1 KB bufer ayıra bilmirMə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ürYaddaş yox, qida problemi ola bilərMühərrik və releləri ayrıca qidalandır, kondensator əlavə et
Massiv elementləri mənasız dəyərlər göstərirMassivin sərhədindən kənara yazılırİndeksi yoxla; dövr həddini sizeof ilə hesabla
ESP32-də Stack canary watchpoint triggeredTapşırığın stack-i daşıbBöyük lokal massivləri global et və ya tapşırığın stack-ini böyüt
Yaddaş problemlərinin qarşısını əvvəldən almaq üçün layihəyə hər yeni modul əlavə etdikdə kompilyasiya çıxışındakı iki faizi qeyd et. Global RAM 60%-i keçəndə F() və PROGMEM-i tətbiq etməyə başla; 75% xəbərdarlığını gözləmək problemi ən çətin həll olunacağı ana saxlamaq deməkdir.

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.

Bütün layihələrə bax
Buzzer ilə İstiklal Marşı
AR-15Orta

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.

4.8(114)
235
DHT11 ilə temperatur və rütubət
AR-55Orta

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.

4.7(47)
83
Raket top oyunu - SSD1306
AR-86Orta
Premium

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.

4.5(47)
65
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
Piksel ilan: 8x8 matris
AR-88Qabaqcıl
Premium

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…

4.7(39)
57
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
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