Rehberler · 11 dk okuma

Arduino Bellek Yetersiz: Sketch too big ve Low Memory Çözümü

Arduino bellek yetersiz uyarısı neden çıkar? Flash, SRAM ve EEPROM farkı, F() ve PROGMEM, String yerine char dizisi, boş RAM ölçme ve Mega ya da ESP32'ye geçiş.

Arduino bellek yetersiz uyarısı, programın ya da değişkenlerin kartın belleğine sığmadığını söyler ve genellikle iki biçimde karşına çıkar: kod hiç yüklenmez ve derleme Sketch too big hatasıyla durur ya da kod yüklenir ama Low memory available, stability problems may occur uyarısının ardından kart rastgele resetlenir, Seri Monitör'e anlamsız karakterler basar ya da donar. Arduino Uno'nun yalnızca 32 KB program belleği ve 2 KB RAM'i olduğu için bu sorun özellikle ekran, SD kart ve birkaç sensörü bir araya getiren projelerde çok sık görülür.

Bu rehberde önce Flash, SRAM ve EEPROM arasındaki farkı ve derleme çıktısındaki iki satırı nasıl okuyacağını göreceksin. Ardından Uno'da gerçek derlemelerle ölçtüğümüz değerlerle hangi satırın ne kadar bellek yediğini, F() makrosu ve PROGMEM ile sabit verileri RAM'den çıkarmayı, String yerine char dizisi kullanmayı, kütüphanelerin gizli maliyetini ve boş RAM'i çalışma anında ölçmeyi öğreneceksin. Son bölümde ESP32 ve Raspberry Pi Pico'da belleğin nasıl izlendiğini ve Mega ya da ESP32'ye geçmenin ne zaman doğru karar olduğunu bulacaksın.

Arduino Uno kartı ve ATmega328P mikrodenetleyicisi
Arduino Uno'nun kalbindeki ATmega328P: 32 KB flaş, 2 KB SRAM ve 1 KB EEPROM. Bellek sorunlarının çoğu bu 2 KB'lık RAM'de yaşanır.

Arduino'da üç bellek: Flash, SRAM ve EEPROM

Arduino'daki mikrodenetleyicinin içinde görevleri tamamen farklı üç bellek bulunur. Flash (program belleği) derlenmiş kodunu saklar; elektrik kesilince silinmez ve yalnızca kod yüklerken yazılır. SRAM (çalışma belleği) değişkenlerin, fonksiyon çağrılarının ve geçici verilerin tutulduğu yerdir; hızlıdır ama kart kapanınca içi boşalır. EEPROM ise ayarlar ve kalibrasyon değerleri gibi az ama kalıcı olması gereken verilere ayrılmış küçük bir alandır. Uno gibi AVR kartlarda bu üç bellek ayrı adres alanlarındadır (Harvard mimarisi). Bu ayrıntı, aşağıda göreceğin F() ve PROGMEM tekniklerinin neden gerekli olduğunu açıklar.

BellekUno'da boyutNe saklanır?Elektrik kesilinceYazma ömrü
Flash32 KB (0,5 KB bootloader'a ayrılır, 32256 bayt kullanılabilir)Program kodu, PROGMEM verileriKorunurYaklaşık 10.000 silme/yazma
SRAM2 KB (2048 bayt)Değişkenler, diziler, stack ve heapSilinirSınırsız
EEPROM1 KB (1024 bayt)Ayarlar, sayaçlar, kalibrasyonKorunurHücre başına yaklaşık 100.000 yazma

EEPROM'u RAM yerine kullanmak çözüm değildir: hem yavaştır hem de her hücrenin yazma ömrü sınırlıdır. Sık değişen bir değişkeni her döngüde EEPROM'a yazarsan birkaç gün içinde o hücreyi yıpratabilirsin. EEPROM'u doğru kullanmanın yollarını Arduino EEPROM kullanımı yazısında ayrıntılı bulabilirsin.

Kartlara göre bellek miktarları

KartFlash (program)SRAMEEPROM
Arduino Uno R3 / Nano (ATmega328P)32 KB (Uno 32256, Nano 30720 bayt kullanılabilir)2 KB1 KB
Arduino Leonardo / Pro Micro (ATmega32U4)32 KB (28672 bayt kullanılabilir)2,5 KB1 KB
Arduino Mega 2560256 KB (253952 bayt kullanılabilir)8 KB4 KB
Arduino Uno R4 (RA4M1)256 KB32 KB8 KB (veri flaşı)
ESP32 (WROOM)4 MB flaş yonga (varsayılan uygulama bölümü 1,25 MB)520 KB (programa yaklaşık 300 KB heap kalır)Yok; Preferences ile flaşta tutulur
Raspberry Pi Pico (RP2040)2 MB flaş yonga264 KBYok; flaşta öykünülür

Tablodaki fark çok büyüktür: ESP32'nin RAM'i Uno'nunkinin 260 katı, Pico'nunki yaklaşık 130 katıdır. Bu yüzden Uno'da büyük çaba gerektiren bellek tasarrufları ESP32'de çoğu zaman gereksizdir. Yine de Uno, Nano ve Pro Mini düşük fiyatları ve basitlikleri nedeniyle en çok kullanılan kartlar olduğu için 2 KB ile yaşamayı öğrenmek her Arduino kullanıcısının işine yarar.

Derleme çıktısını okumak: Sketch uses ve Global variables use

Her başarılı derlemenin sonunda Arduino IDE iki satır yazar. Boş bir setup() ve loop() içeren taslağı Uno için derlediğinde şunu görürsün: Sketch uses 444 bytes (1%) of program storage space ve Global variables use 9 bytes (0%) of dynamic memory, leaving 2039 bytes for local variables. İlk satır programın flaşta kapladığı yeri, ikincisi global ve static değişkenlerin RAM'de kapladığı yeri söyler. Kritik nokta şudur: ikinci satır yalnızca derleme sırasında boyutu belli olan değişkenleri sayar. Fonksiyonların yerel değişkenleri (stack) ve String ya da malloc gibi çalışma anında ayrılan bellek (heap) bu sayıya dahil değildir. Kalan "local variables" alanı onların paylaşacağı yerdir.

MesajNe zaman çıkar?Ne anlama gelir?
Sketch uses ... bytes (x%) of program storage spaceHer derlemedeKodun flaşta kapladığı yer
Global variables use ... bytes (x%) of dynamic memoryHer derlemedeGlobal ve static değişkenlerin RAM'deki payı
Low memory available, stability problems may occur.Global değişkenler RAM'in yaklaşık %75'ini geçinceKod yüklenir ama stack ve heap için yer az kaldı
Sketch too big ve text section exceeds available space in boardProgram flaşa sığmayıncaKod yüklenemez; flaşı küçültmen gerekir
Not enough memory ve data section exceeds available space in boardGlobal değişkenler RAM'i aşıncaKod yüklenemez; RAM kullanımını azaltman gerekir
"Low memory" uyarısı bir hata değildir ve kod sorunsuz yüklenir; asıl tehlike de budur. Örneğin int veri[700]; tanımlı bir taslak Uno'da 1588 bayt (%77) global değişken kullanır ve stack ile heap'e yalnızca 460 bayt bırakır. Birkaç iç içe fonksiyon çağrısı, bir String birleştirmesi ya da bir kütüphanenin begin() içinde ayırdığı tampon bu alanı tükettiğinde program çöker. Belirtiler rastgele resetler, bozulan değişkenler ve donmalardır; bunları güç sorunlarından ayırmak için Arduino kendini resetliyor yazısına da bak.

SRAM'in içi: global değişkenler, heap ve stack

Uno'nun 2048 baytlık RAM'i dört bölgeye ayrılır. En altta başlangıç değeri olan global değişkenler (.data), onun üstünde sıfırla başlayan global değişkenler (.bss) bulunur; derleyici bu ikisinin toplamını "Global variables use" satırında gösterir. Ardından heap gelir ve yukarı doğru büyür: String nesneleri, new ve malloc ile ayrılan bellek buradadır. RAM'in en tepesinden ise stack aşağı doğru büyür: her fonksiyon çağrısı dönüş adresini ve yerel değişkenlerini buraya koyar, kesme (interrupt) geldiğinde yazmaçlar da buraya kaydedilir. Heap ile stack ortadaki boşlukta karşılaşırsa birbirinin üstüne yazar ve program öngörülemez biçimde bozulur.

BölgeİçerikBüyüme yönüDerleme çıktısında görünür mü?
.dataİlk değeri verilmiş global ve static değişkenler, F() içine alınmamış metinlerSabitEvet
.bssİlk değeri verilmemiş (sıfır) global ve static değişkenler, kütüphane tamponlarıSabitEvet
HeapString, new, malloc, bazı kütüphanelerin begin() içinde ayırdığı tamponlarYukarı doğruHayır
StackYerel değişkenler, fonksiyon dönüş adresleri, kesme sırasında kaydedilen yazmaçlarAşağı doğruHayır

Bu yapı iki önemli sonucu doğurur. Birincisi, F() içine alınmamış her metin .data bölgesine kopyalanır, çünkü AVR işlemcisi flaştaki veriyi sıradan bir değişken gibi okuyamaz. İkincisi, heap'te parçalanma olur: farklı boyutlarda String'ler oluşturup sildikçe arada küçük boşluklar kalır ve toplam boş bellek yeterli görünse bile büyük bir parça ayrılamaz. Bu yüzden Uno'da uzun süre çalışan programlarda heap'e mümkün olduğunca dokunmamak en güvenli yoldur.

Ölç: hangi satır ne kadar bellek harcıyor?

Bellek sorununu çözmenin ilk adımı tahmin etmek değil ölçmektir. Aşağıdaki tablodaki her satır, Arduino AVR çekirdeği 1.8.6 ile Arduino Uno için ayrı ayrı derlenmiş küçük bir taslağın gerçek çıktısıdır. Değerler kütüphane ve çekirdek sürümüne göre birkaç bayt değişebilir, ama oranlar her zaman aynıdır.

Taslakta ne var?Flash (bayt)Global RAM (bayt)
Boş setup() ve loop()4449
Serial.begin(9600)1438184
+ Serial.println("44 karakterlik bir metin")1518232
Aynı metin F() ile1530188
analogRead + Serial.println(int)1892188
float hesap + Serial.println(float)3380200
String birleştirme: "A0=" + String(analogRead(A0))3316202
Aynı iş snprintf ve char dizisiyle3232194
Wire (I2C) ile tek bir yazma2476225
SD kart: begin, open, println, close10496837
int veri[700] dizisi17801588 (%77, Low memory uyarısı)
int veri[950] dizisi17802088 (%101, derlenmez)

Tablodan çıkan dersler nettir. Yalnızca Serial.begin() 175 bayt RAM ister, çünkü seri port 64 baytlık bir alma ve 64 baytlık bir gönderme tamponu ayırır. 44 karakterlik tek bir metin 44 bayt RAM yer; aynı metin F() ile yazılınca bu RAM geri gelir. float kullanmak flaşa yaklaşık 1,5 KB kayan nokta kodu ekler. SD kütüphanesi tek başına 10 KB flaş ve yaklaşık 830 bayt RAM tüketir; Uno'nun RAM'inin %40'ı yalnızca bir log dosyasına gider. String örneğinin global RAM'i küçük görünür ama asıl maliyeti çalışma sırasında heap'te ortaya çıkar ve derleme çıktısında hiç görünmez.

F() makrosu: sabit metinleri RAM'den çıkar

Uno'da "Sicaklik: " gibi tırnak içindeki her metin flaşta durur, ama program başlarken RAM'e kopyalanır ve orada sonuna kadar yer kaplar. F() makrosu bu kopyalamayı engeller: metin flaşta kalır, Serial.print gibi fonksiyonlar onu harf harf doğrudan flaştan okur. F(), Print sınıfından türeyen her nesneyle çalışır; Serial, LiquidCrystal, LiquidCrystal_I2C, Adafruit SSD1306 ve SD dosyaları bunlardandır. Menüleri, hata mesajları ve yardım metinleri olan bir projede yalnızca F() eklemek birkaç yüz bayt RAM kazandırabilir. Aşağıdaki kod hem farkı gösterir hem de boş RAM'i çalışma anında ölçer:

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() fonksiyonu, stack'in o anki tepesiyle heap'in sonu arasındaki mesafeyi hesaplar; yani heap ile stack'in karşılaşmasına kaç bayt kaldığını gösterir. Bu fonksiyonu loop() içinde, ekran güncellemesinden ya da SD yazmasından hemen sonra çağırırsan en kötü anı yakalarsın. Pratik bir kural: Uno'da çalışma sırasında boş RAM'in 200–300 baytın altına düşmesine izin verme. F() bir char* bekleyen fonksiyonlarla (strcmp, strcpy) çalışmaz; onlar için aşağıda göreceğin _P sürümlerini ve PSTR() makrosunu kullanırsın.

PROGMEM: büyük tabloları flaşta tutmak

F() yalnızca metinler içindir. Nota dizileri, ekran simgeleri (bitmap), karakter tabloları, kalibrasyon eğrileri ya da mesaj listeleri gibi hiç değişmeyen büyük diziler için PROGMEM anahtar kelimesini kullanırsın. PROGMEM ile tanımlanan dizi RAM'e hiç kopyalanmaz; onu okumak için normal dizi erişimi yerine pgm_read_byte, pgm_read_word gibi özel fonksiyonlar gerekir. Örneğin 100 notalık bir melodi frekans ve süre tablosuyla 400 bayt eder; bu, Uno'nun RAM'inin beşte biridir ve PROGMEM ile tamamen flaşa taşı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}
Fonksiyon / makroNe yapar?
pgm_read_byte(&dizi[i])Flaştan 1 bayt okur (byte, char, uint8_t dizileri, bitmap'ler)
pgm_read_word(&dizi[i])Flaştan 2 bayt okur (int, uint16_t; Uno'da nota ve sayı tabloları)
pgm_read_dword / pgm_read_float4 baytlık long ve float değerleri okur
pgm_read_ptr(&tablo[i])Flaştaki bir işaretçiyi okur (metin tabloları)
strcpy_P(hedef, kaynak)Flaştaki metni RAM'deki bir tampona kopyalar
strcmp_P(ram_metin, PSTR("..."))RAM'deki metni flaştaki metinle karşılaştırır
strlen_P / memcpy_PFlaştaki metnin uzunluğunu bulur, flaştan blok kopyalar
ESP32 ve Pico'da const tanımlanan diziler zaten flaşta kalır; PROGMEM orada etkisizdir ama hata da vermez, pgm_read_* fonksiyonları da tanımlıdır. Bu yüzden PROGMEM ile yazdığın kod üç kartta da derlenir. Bir istisna var: işaretçi tablosu okurken Uno'da çalışan pgm_read_word, 32 bitlik kartlarda işaretçiyi keser; taşınabilir kod için pgm_read_ptr kullan.

String yerine char dizisi kullan

Arduino'nun String sınıfı kullanışlıdır ama her birleştirme işleminde (+) heap'ten yeni bir parça ister, eskisini serbest bırakır. Uno'nun küçük heap'inde bu işlem binlerce kez tekrarlanınca bellek delik deşik olur. Program saatlerce sorunsuz çalışıp sonra birden donar ve hatayı bulmak çok zordur. Çözüm, boyutu baştan belli olan char dizileri kullanmaktır: bellek bir kez ayrılır, hiç parçalanmaz ve kullanılan bayt sayısı derleme çıktısında görünür. Aşağıdaki kod, Seri Monitör'den gelen komutları String kullanmadan okur ve ölçümü tek bir satırda biçimlendirir:

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 dikkat edilecek üç ayrıntı var. snprintf, tamponun boyutunu bildiği için metin uzun gelse bile diziden taşmaz; sprintf bu korumayı vermez. AVR'nin printf ailesi varsayılan olarak %f biçimini desteklemediğinden float değer önce dtostrf ile metne çevrilir. Komut tamponunun sınırı (konum < sizeof(komut) - 1) da uzun bir satırın belleğin başka bir yerini ezmesini engeller. String kullanmak zorundaysan (bazı kütüphaneler String döndürür) en azından setup() içinde metin.reserve(64) ile gereken yeri baştan ayır ve String'i global tanımla; böylece parçalanma büyük ölçüde azalır.

Doğru veri türü ve yerel değişkenler

TürUno (AVR)ESP32 / PicoDeğer aralığı (Uno)
bool, char, byte1 bayt1 baytbyte: 0–255
int2 bayt4 bayt-32768 ile 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 baytYaklaşık 6–7 anlamlı basamak
double4 bayt (float ile aynı)8 baytUno'da float'tan farkı yok
  • Küçük sayılar için byte: 0–255 arasındaki pin numaraları, sayaçlar ve yüzdeler için int yerine byte kullanmak her değişkende 1 bayt, 200 elemanlı bir dizide 200 bayt kazandırır.
  • Pin numaraları için const: const byte LED_PIN = 13; biçiminde tanımlanan sabitleri derleyici doğrudan koda gömer, RAM'de yer ayırmaz.
  • Açık/kapalı bilgileri bitlerde: 8 adet bool 8 bayt tutar; aynı bilgiyi bir byte'ın bitlerinde bitRead ve bitWrite ile saklarsan 1 bayt yeter.
  • Büyük yerel dizilere dikkat: Bir fonksiyon içinde tanımlanan char tampon[300]; derleme çıktısında görünmez ama fonksiyon her çağrıldığında stack'ten 300 bayt alır. Büyük tamponları global yap ki boyutları görünsün.
  • Özyinelemeden (recursion) kaçın: Kendini çağıran her fonksiyon stack'te yeni bir kat açar; Uno'da birkaç düzine derinlik bile RAM'i bitirebilir.
  • Büyük yapıları referansla geçir: Bir struct'ı fonksiyona değerle göndermek onun kopyasını stack'e koyar; const Ayar& a biçiminde referansla göndermek kopyalamaz.

Kütüphanelerin gizli bellek maliyeti

Projede bellek birden tükendiyse suçlu çoğu zaman senin kodun değil, eklediğin kütüphanedir. Bazı kütüphaneler RAM'i derleme sırasında (global tampon olarak), bazıları ise begin() çağrıldığında heap'ten ayırır; ikinci durumda derleme çıktısı masum görünür ama kart çalışınca bellek biter. Aşağıdaki değerlerin bir kısmı yukarıdaki ölçüm tablosundan, bir kısmı kütüphanelerin tampon boyutlarından gelir:

Kütüphane / özellikRAM maliyeti (Uno)Ne zaman ayrılır?Daha hafif seçenek
SerialYaklaşık 175 bayt (64 + 64 bayt tampon)Derlemede (global)Gerekmiyorsa Serial'ı tamamen kaldır
Wire (I2C)Yaklaşık 215 baytDerlemede (global)Tek I2C cihazı varsa bile kaçınılmaz; diğer tasarruflara odaklan
SoftwareSerialYaklaşık 120 bayt (64 bayt alma tamponu)Derlemede (global)Mümkünse donanım seri portu ya da Mega'nın ek portları
SDYaklaşık 830 bayt, ayrıca yaklaşık 10 KB flaşDerlemede (global)Kayıt işini ESP32'ye ya da Mega'ya bırak
Adafruit SSD1306 128x641024 bayt görüntü tamponubegin() içinde heap'tenU8g2 sayfa modu (128 bayt) ya da yalnız metin için U8x8
Adafruit NeoPixel / FastLEDLED başına 3 bayt (60 LED = 180 bayt)BaşlangıçtaLED sayısını gerçek şerit uzunluğuyla sınırla

Bu tablo, Uno'da neden OLED ekran, SD kart ve Wi-Fi modülünü aynı anda kullanmanın neredeyse imkânsız olduğunu açıklar: yalnızca SSD1306 tamponu ile SD kütüphanesi birlikte 1,8 KB eder ve 2 KB'lık RAM'den programına neredeyse hiçbir şey kalmaz. OLED ekranda karşılaştığın SSD1306 allocation failed hatası tam olarak bu heap ayırmasının başarısız olmasıdır; çözümleri OLED ekran SSD1306 yazısında da bulabilirsin.

Sketch too big: flaş belleği küçültmenin yolları

  • Hata ayıklama çıktısını kapat: Geliştirme sırasında eklenen Serial.print satırları hem flaş hem RAM harcar. Aşağıdaki DEBUG makrosuyla tek satırı değiştirerek hepsini derlemeden çıkarabilirsin.
  • float ve sprintf'ten kaçın: Ölçümde gördüğün gibi float yaklaşık 1,5 KB, snprintf de 1 KB'tan fazla kod ekler. Sıcaklığı 10 ile çarpıp int olarak tutmak (23,5 °C yerine 235) çoğu projede yeterlidir.
  • Tekrarlanan kodu fonksiyona ve diziye çevir: Her LED için ayrı ayrı yazılmış on satırlık bloklar yerine pin numaralarını bir dizide tutup döngüyle işlemek kodu belirgin biçimde kısaltır.
  • Daha küçük kütüphane seç: Grafik gerekmiyorsa U8x8 ya da LiquidCrystal_I2C, Adafruit GFX tabanlı kütüphanelere göre çok daha az yer kaplar. Bir kütüphanenin tek bir fonksiyonu için bütün kütüphaneyi eklemek yerine o kısmı kendin yazmayı düşün.
  • Kart ayarını kontrol et: Arduino IDE sınırı seçtiğin karta göre hesaplar: Uno için 32256, Nano için (eski ya da yeni bootloader) 30720, Leonardo için 28672 bayt. Yanlış kart seçiliyse hem sınır hem de pin tanımları yanlış olur.
  • Daha büyük karta geç: Bütün bunlardan sonra hâlâ sığmıyorsa Mega (256 KB) ya da ESP32 (1,25 MB ve üstü) aynı kodu küçük değişikliklerle çalıştırır.
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 iken bu taslak Uno'da 2292 bayt flaş ve 188 bayt RAM kullanır; DEBUG 0 yaptığında Serial kodu tamamen derlemeden çıkar ve değerler 934 bayt flaşa ve 9 bayt RAM'e iner. Aradaki 1,3 KB flaş ve 179 bayt RAM, bitmiş bir projeye yeni bir özellik eklemek için çoğu zaman yeterlidir.

ESP32'de belleği ölçmek

ESP32'de bellek bol olsa da sınırsız değildir. Wi-Fi açıldığında onlarca KB RAM ayrılır, Bluetooth da eklenince bu miktar 100 KB'a yaklaşabilir; web sunucusu, JSON belgeleri ve görüntü tamponları da hızla yer kaplar. ESP32-CAM gibi bazı modüllerde ek PSRAM (çoğunlukla 4 MB) bulunur ve büyük tamponlar oraya konur. Flaş tarafında, uygulama 1,25 MB'lık varsayılan bölüme sığmazsa Araçlar menüsündeki Partition Scheme ayarından "Huge APP" seçeneğiyle 3 MB'a çıkabilirsin. ESP32'nin genel özellikleri için ESP32 nedir? yazısına bakabilirsin.

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}

Buradaki en değerli iki sayı getMinFreeHeap ve getMaxAllocHeap'tir. İlki program açıldığından beri boş heap'in düştüğü en düşük değeri, ikincisi tek parça hâlinde ayrılabilecek en büyük bloğu verir. Boş heap 100 KB görünürken en büyük blok 10 KB'ın altındaysa heap parçalanmıştır ve büyük bir String ya da JSON belgesi ayrılamayabilir. ESP32'de loop() kendi görevinde (task) 8 KB'lık bir stack ile çalışır; uxTaskGetStackHighWaterMark bu stack'in hiç dokunulmamış kısmını gösterir ve birkaç yüz baytın altına inerse "Stack canary watchpoint triggered" hatasıyla karşılaşabilirsin.

Raspberry Pi Pico ve MicroPython'da bellek

Pico'nun 264 KB RAM'i Uno'ya göre çok büyüktür ama MicroPython yorumlayıcısı bunun bir kısmını kendisi kullanır; programına genellikle 190 KB civarında heap kalır. MicroPython'da bellek çöp toplayıcı (garbage collector) ile yönetilir: artık kullanılmayan nesneler gc.collect() çağrıldığında ya da bellek dolmak üzereyken temizlenir. Bellek gerçekten bittiğinde MemoryError: memory allocation failed hatası alırsın. Döngü içinde metin birleştirmek, büyük listeler oluşturmak ve çok uzun tek bir kod dosyası bu hatanın en yaygın sebepleridir.

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 belleği korumak için tamponları baştan bytearray ile ayır ve döngüde yeniden kullan, sabit sayıları const() ile tanımla, büyük modülleri mpy-cross ile önceden derlenmiş .mpy dosyalarına çevir ve uzun işlerden önce gc.collect() çağır. Pico'da MicroPython'un temel komutlarını MicroPython temelleri yazısında, kartın genel özelliklerini Raspberry Pi Pico nedir? yazısında bulabilirsin.

Ne zaman Mega'ya ya da ESP32'ye geçmeli?

Arduino Mega 2560 kartı
Arduino Mega 2560: 256 KB flaş, 8 KB SRAM ve 4 KB EEPROM. Uno kodu çoğu zaman hiç değiştirmeden çalışır.
DurumÖneri
F(), PROGMEM ve char dizilerinden sonra boş RAM 300 baytın üzerindeUno'da kal; sorun çözüldü
OLED ya da SD ile birlikte birkaç sensör ve menü var, RAM hâlâ yetmiyorArduino Mega 2560: 4 kat RAM, aynı 5 V pinler ve kütüphaneler
Program 32 KB'ı aşıyor ama RAM yetiyorMega ya da Uno R4: 256 KB flaş
Wi-Fi, web sunucusu, büyük tamponlar ya da görüntü işleme gerekiyorESP32: 520 KB RAM, 4 MB flaş, Wi-Fi ve Bluetooth
MicroPython ile çalışmak istiyorsunRaspberry Pi Pico ya da Pico W
Pille aylarca çalışması gereken küçük bir sensör düğümüUno'da optimize et ya da Pro Mini kullan; büyük kart daha çok akım çeker

Mega'ya geçerken kodun büyük kısmı aynen kalır; yalnızca I2C pinlerinin 20 (SDA) ve 21 (SCL), SPI pinlerinin 50–53 olduğunu unutma. ESP32'ye geçişte ise 3,3 V mantık seviyesi, farklı pin numaraları ve analogRead'in 12 bitlik (0–4095) sonucu gibi farklar vardır. Hangi kartın sana uygun olduğuna karar vermek için Arduino mu ESP32 mi? karşılaştırmasına, 5 V uyumlu ama çok daha geniş belleği olan seçenek için Arduino Uno R4 yazısına göz at.

Sık yapılan hatalar ve çözümleri

BelirtiOlası sebepÇözüm
Sketch too big, kod yüklenmiyorProgram flaşa sığmıyorDebug çıktısını kapat, float ve sprintf'i azalt, küçük kütüphane seç, gerekirse Mega
Kod yükleniyor ama birkaç dakika sonra donuyorString birleştirmeleri heap'i parçalıyorString yerine char dizisi ve snprintf kullan; boş RAM'i ölç
Seri Monitör'de anlamsız karakterler, değişkenler kendiliğinden değişiyorStack heap'in üstüne yazıyorGlobal RAM'i %75'in altına indir, büyük yerel dizileri kaldır
SSD1306 allocation failedbegin() 1 KB tampon ayıramıyorMetinleri F() içine al, U8g2 sayfa moduna geç
Kart rastgele resetleniyor, bellek yerinde görünüyorBellek değil güç sorunu olabilirMotor ve röleleri ayrı besle, kondansatör ekle
Dizi elemanları saçma değerler gösteriyorDizinin sınırı dışına yazılıyorİndeksi kontrol et; döngü sınırını sizeof ile hesapla
ESP32'de Stack canary watchpoint triggeredGörev stack'i taştıBüyük yerel dizileri global yap ya da görev stack'ini büyüt
Bellek sorunlarını en baştan önlemek için projeye her yeni modül eklediğinde derleme çıktısındaki iki yüzdeyi bir kenara not et. Global RAM %60'ı geçtiğinde F() ve PROGMEM'i uygulamaya başla; %75 uyarısını beklemek, sorunu en zor çözüleceği ana bırakmak demektir.

Arduino'da bellek yetersizliği çoğu zaman kartı değiştirmeden çözülür: sabit metinleri F() ile flaşa almak, büyük tabloları PROGMEM'e taşımak, String yerine char dizisi kullanmak ve gereksiz kütüphaneleri ayıklamak 2 KB'lık RAM'i şaşırtıcı ölçüde rahatlatır. BlueGrays uygulamasında OLED oyunları, melodi çalan buzzer projeleri ve LED matris animasyonları gibi belleği zorlayan projeleri adım adım devre şeması ve bu tekniklerle yazılmış kodlarıyla inceleyebilirsin.

Sıkça sorulan sorular

Arduino'da Low memory available uyarısı ne demek?

Global değişkenlerin RAM'in yaklaşık %75'ini doldurduğunu ve stack ile heap'e az yer kaldığını söyler. Kod yüklenir ama çalışırken rastgele resetler, donmalar ve bozuk değişkenler görülebilir. Sabit metinleri F() içine almak ve büyük dizileri PROGMEM'e taşımak çoğu zaman uyarıyı ortadan kaldırır.

Sketch too big hatası nasıl düzeltilir?

Bu hata programın flaş belleğe sığmadığını gösterir. Hata ayıklama için eklenen Serial çıktılarını kapat, float ve sprintf kullanımını azalt, tekrarlanan kodu fonksiyonlara çevir ve daha küçük kütüphaneler seç. Yine de sığmıyorsa Arduino Mega ya da ESP32 gibi flaşı büyük bir karta geç.

Arduino Uno'nun belleği ne kadar?

Arduino Uno'daki ATmega328P'de 32 KB flaş (0,5 KB bootloader'a ayrılır), 2 KB SRAM ve 1 KB EEPROM bulunur. Program flaşa, değişkenler SRAM'e, kalıcı ayarlar EEPROM'a yazılır. Sorunların çoğu bu 2 KB'lık SRAM'de çıkar.

F() makrosu ne işe yarar?

F(), Serial.print gibi fonksiyonlara verilen sabit metinlerin RAM'e kopyalanmasını engeller ve onları flaşta tutar. Uno'da her karakter bir bayt RAM tasarrufu demektir; çok sayıda mesaj içeren projelerde yüzlerce bayt kazandırır. ESP32 ve Pico'da da derlenir ama orada etkisi yoktur.

Arduino'da boş RAM nasıl ölçülür?

Uno, Nano ve Mega'da __heap_start ve __brkval değişkenleriyle stack ile heap arasındaki mesafeyi hesaplayan küçük bir fonksiyon kullanılır. ESP32'de ESP.getFreeHeap() ve ESP.getMinFreeHeap(), MicroPython'da gc.mem_free() aynı bilgiyi verir. Ölçümü belleğin en çok kullanıldığı anda yapmak önemlidir.

Arduino'da String kullanmak neden sorun çıkarır?

String nesneleri her birleştirmede heap'ten yeni bellek ister ve eskisini bırakır; Uno'nun küçük heap'i zamanla parçalanır. Toplam boş bellek yeterli görünse bile yeni bir parça ayrılamaz ve program donar. Sabit boyutlu char dizileri ve snprintf bu sorunu tamamen ortadan kaldırır.

Tüm projeleri gör
Buzzer İle İstiklal Marşı
AR-15Orta

Buzzer İle İstiklal Marşı

Butona bastığında küçük bir buzzer İstiklal Marşı'nı nota nota çalmaya başlar. Arduino her notayı doğru yükseklikte ve doğru sürede çalarak marşın iki kıtasını baştan sona seslendirir, bitince yeni…

4.8(114)
235
DHT11 İle Sıcaklık Ve Nem
AR-55Orta

DHT11 İle Sıcaklık Ve Nem

Odan kaç derece, hava nemli mi, kuru mu? DHT11 sensörü sıcaklığı ve nemi ölçer, Arduino da bu değerleri iki satırlık LCD ekrana yazar ve birkaç saniyede bir yeniler.

4.7(47)
83
Raket Topu Oyunu - SSD1306
AR-86Orta
Premium

Raket Topu Oyunu - SSD1306

Bir top, iki raket ve sen: video oyunlarının en eskilerinden masa tenisini küçük bir OLED ekranda oynarsın.

4.5(47)
65
OLED T-Rex Run: Arduino Dinozor Oyunu
AR-87İleri
Premium

OLED T-Rex Run: Arduino Dinozor Oyunu

İnternet kesilince çıkan dinozor oyunu artık masanda: küçük OLED ekranda dinozor koşar, kaktüsler üstüne gelir ve sen tek butonla zıplarsın.

4.7(33)
53
Piksel Yılan: 8x8 Matris
AR-88İleri
Premium

Piksel Yılan: 8x8 Matris

Klasik yılan oyununu kendi ellerinle kur ve oyna. Renkli 8x8 ışık matrisinde yeşil yılanı oyun çubuğuyla yönlendirip kırmızı elmaları yersin; her elmada yılan uzar, biraz daha hızlanır ve puanın…

4.7(39)
57
Arduino Hafıza Oyunu (4 LED + 4 Buton + Buzzer)
AR-93İleri
Premium

Arduino Hafıza Oyunu (4 LED + 4 Buton + Buzzer)

Hafızana güveniyor musun? Dört renkli LED sırayla yanar ve her biri kendi notasını çalar; sen de aynı sırayı butonlara basarak tekrar edersin.

4.8(46)
69
4x4 Keypad LCD Ekran Şifre Uygulaması
AR-64İleri
Premium

4x4 Keypad LCD Ekran Şifre Uygulaması

Doğru şifreyi bilmeyenin giremediği küçük bir elektronik kapı kilidi. Kare tuşuna basıp şifreyi tuş takımından girersin; şifre doğruysa ekranda giriş izni yazar, yeşil LED yanar ve servo motor kapıyı…

4.8(59)
75