Panduan · 13 mnt baca

Arduino Kehabisan Memori: Mengatasi Sketch Too Big dan Low Memory

Arduino kehabisan memori? Pelajari Flash, SRAM, EEPROM, F() dan PROGMEM, array char sebagai pengganti String, cara mengukur RAM bebas, serta kapan beralih ke Mega atau ESP32.

Peringatan Arduino kehabisan memori berarti program atau variabelmu tidak muat di memori board, dan biasanya muncul dalam dua bentuk: kode sama sekali tidak bisa di-upload karena kompilasi berhenti dengan Sketch too big, atau kode berhasil di-upload setelah peringatan Low memory available, stability problems may occur, lalu board reset secara acak, mencetak karakter sampah di Serial Monitor, atau macet. Karena Arduino Uno hanya memiliki memori program 32 KB dan RAM 2 KB, masalah ini sangat umum pada proyek yang menggabungkan layar, kartu SD, dan beberapa sensor.

Dalam panduan ini, kamu akan terlebih dahulu mempelajari perbedaan Flash, SRAM, dan EEPROM serta cara membaca dua baris di akhir kompilasi. Lalu, dengan nilai yang kami ukur dari kompilasi nyata pada Uno, kamu akan mempelajari berapa banyak memori yang dipakai setiap baris, cara memindahkan data konstan dari RAM dengan makro F() dan PROGMEM, cara memakai array char sebagai pengganti String, penggunaan memori library yang tersembunyi, serta cara mengukur RAM bebas ketika program berjalan. Di bagian terakhir, kamu akan mempelajari cara memantau memori pada ESP32 dan Raspberry Pi Pico serta kapan beralih ke Mega atau ESP32 merupakan keputusan yang tepat.

Board Arduino Uno dan mikrokontroler ATmega328P-nya
ATmega328P yang menjadi inti Arduino Uno: flash 32 KB, SRAM 2 KB, dan EEPROM 1 KB. Sebagian besar masalah memori terjadi di RAM 2 KB tersebut.

Tiga memori dalam Arduino: Flash, SRAM, dan EEPROM

Mikrokontroler pada Arduino memiliki tiga memori dengan tugas yang sama sekali berbeda. Flash (memori program) menyimpan kode hasil kompilasimu; isinya tetap tersimpan ketika daya terputus dan hanya ditulis ketika kamu melakukan upload. SRAM (memori kerja) adalah tempat variabel, pemanggilan fungsi, dan data sementara berada; memori ini cepat, tetapi isinya hilang ketika board dimatikan. EEPROM adalah area kecil untuk data yang harus disimpan tetapi jarang berubah, seperti pengaturan dan nilai kalibrasi. Pada board AVR seperti Uno, ketiga memori ini berada di ruang alamat terpisah (arsitektur Harvard). Detail ini menjelaskan mengapa teknik F() dan PROGMEM yang akan kamu lihat di bawah diperlukan.

MemoriUkuran pada UnoApa yang disimpan?Ketika daya terputusKetahanan tulis
Flash32 KB (0,5 KB dicadangkan untuk bootloader, 32.256 byte bisa dipakai)Kode program, data PROGMEMTetap tersimpanSekitar 10.000 siklus hapus/tulis
SRAM2 KB (2048 byte)Variabel, array, stack, dan heapHilangTidak terbatas
EEPROM1 KB (1024 byte)Pengaturan, penghitung, kalibrasiTetap tersimpanSekitar 100.000 penulisan per sel

Memakai EEPROM sebagai pengganti RAM bukan solusi: EEPROM lambat dan setiap sel memiliki batas jumlah penulisan. Jika kamu menulis variabel yang berubah cepat ke EEPROM pada setiap perulangan, sel itu bisa aus dalam beberapa hari. Kamu bisa mempelajari cara memakai EEPROM dengan benar dalam tutorial EEPROM Arduino.

Ukuran memori menurut board

BoardFlash (program)SRAMEEPROM
Arduino Uno R3 / Nano (ATmega328P)32 KB (Uno 32.256, Nano 30.720 byte bisa dipakai)2 KB1 KB
Arduino Leonardo / Pro Micro (ATmega32U4)32 KB (28.672 byte bisa dipakai)2,5 KB1 KB
Arduino Mega 2560256 KB (253.952 byte bisa dipakai)8 KB4 KB
Arduino Uno R4 (RA4M1)256 KB32 KB8 KB (flash data)
ESP32 (WROOM)Chip flash 4 MB (partisi aplikasi bawaan 1,25 MB)520 KB (sekitar 300 KB heap tersisa untuk programmu)Tidak ada; Preferences menyimpan data di flash
Raspberry Pi Pico (RP2040)Chip flash 2 MB264 KBTidak ada; diemulasikan di flash

Perbedaannya sangat besar: RAM ESP32 260 kali lebih besar daripada Uno, sedangkan Pico sekitar 130 kali. Karena itu, penghematan memori yang membutuhkan usaha besar pada Uno sering kali tidak diperlukan pada ESP32. Meski begitu, Uno, Nano, dan Pro Mini merupakan board yang paling banyak dipakai berkat harga yang rendah dan kesederhanaannya, sehingga belajar bekerja dengan 2 KB bermanfaat bagi setiap pengguna Arduino.

Membaca hasil kompilasi: Sketch uses dan Global variables use

Di akhir setiap kompilasi yang berhasil, Arduino IDE mencetak dua baris. Kompilasikan sketch dengan setup() dan loop() kosong untuk Uno, dan kamu akan melihat Sketch uses 444 bytes (1%) of program storage space serta Global variables use 9 bytes (0%) of dynamic memory, leaving 2039 bytes for local variables. Baris pertama menunjukkan berapa banyak flash yang dipakai program, sedangkan baris kedua menunjukkan berapa banyak RAM yang dipakai variabel global dan statis. Hal pentingnya, baris kedua hanya menghitung variabel yang ukurannya sudah diketahui ketika kompilasi. Variabel lokal fungsi (stack) dan memori yang dialokasikan ketika program berjalan dengan String atau malloc (heap) tidak termasuk. Ruang “local variables” yang tersisa harus dibagi di antara keduanya.

PesanKapan muncul?Apa artinya?
“Sketch uses ... bytes (x%) of program storage space”Pada setiap kompilasiRuang yang dipakai kode di flash
“Global variables use ... bytes (x%) of dynamic memory”Pada setiap kompilasiBagian RAM yang dipakai variabel global dan statis
“Low memory available, stability problems may occur.”Ketika variabel global melampaui sekitar 75% RAMKode bisa di-upload, tetapi hanya sedikit ruang tersisa untuk stack dan heap
“Sketch too big” dan “text section exceeds available space in board”Ketika program tidak muat di flashKode tidak bisa di-upload; kamu perlu mengurangi penggunaan flash
“Not enough memory” dan “data section exceeds available space in board”Ketika variabel global melampaui kapasitas RAMKode tidak bisa di-upload; kamu perlu mengurangi penggunaan RAM
Peringatan “Low memory” bukan error dan kode tetap di-upload tanpa masalah; justru itulah bahayanya. Misalnya, sketch dengan int veri[700]; memakai 1588 byte (77%) untuk variabel global pada Uno dan hanya menyisakan 460 byte untuk stack dan heap. Ketika beberapa pemanggilan fungsi bersarang, penggabungan String, atau buffer yang dialokasikan library di begin() menghabiskan ruang itu, program akan berhenti bekerja. Gejalanya adalah reset acak, variabel rusak, dan macet; untuk membedakannya dari masalah daya, baca juga Kenapa Arduino-ku terus reset?.

Di dalam SRAM: variabel global, heap, dan stack

RAM Uno sebesar 2048 byte dibagi menjadi empat area. Di bagian paling bawah terdapat variabel global dengan nilai awal (.data), di atasnya variabel global yang dimulai dari nol (.bss); compiler menampilkan jumlah keduanya pada baris “Global variables use”. Berikutnya ada heap, yang tumbuh ke atas: objek String serta memori yang dialokasikan dengan new dan malloc berada di sini. Dari bagian paling atas RAM, stack tumbuh ke bawah: setiap pemanggilan fungsi menempatkan alamat kembalian dan variabel lokalnya di sini, dan register disimpan di sini ketika interrupt terjadi. Jika heap dan stack bertemu di ruang bebas di antaranya, keduanya saling menimpa dan program rusak dengan cara yang tidak bisa diprediksi.

AreaIsiArah pertumbuhanTerlihat dalam hasil kompilasi?
.dataVariabel global dan statis yang diinisialisasi, string yang tidak dibungkus F()TetapYa
.bssVariabel global dan statis yang tidak diinisialisasi (nol), buffer libraryTetapYa
HeapString, new, malloc, buffer yang dialokasikan beberapa library di begin()Ke atasTidak
StackVariabel lokal, alamat kembalian fungsi, register yang disimpan selama interruptKe bawahTidak

Susunan ini memiliki dua konsekuensi penting. Pertama, setiap string yang tidak dibungkus F() disalin ke .data, karena prosesor AVR tidak bisa membaca data di flash seperti variabel biasa. Kedua, heap mengalami fragmentasi: ketika kamu membuat dan menghapus String dengan ukuran berbeda, celah kecil tertinggal, dan meskipun total memori bebas terlihat cukup, satu blok besar tidak bisa dialokasikan. Karena itu, pada program yang berjalan lama di Uno, menghindari heap sebisa mungkin merupakan pendekatan paling aman.

Ukur dahulu: berapa banyak memori yang dipakai setiap baris?

Langkah pertama untuk menyelesaikan masalah memori adalah mengukur, bukan menebak. Setiap baris pada tabel di bawah merupakan hasil nyata sketch kecil yang dikompilasi secara terpisah untuk Arduino Uno dengan Arduino AVR core 1.8.6. Nilainya bisa berubah beberapa byte tergantung versi library dan core, tetapi proporsinya selalu tetap sama.

Apa isi sketch-nya?Flash (byte)RAM global (byte)
setup() dan loop() kosong4449
Serial.begin(9600)1438184
+ Serial.println("a 44-character text") (menambahkan baris yang mencetak teks 44 karakter)1518232
Teks yang sama dengan F()1530188
analogRead + Serial.println(int)1892188
Perhitungan float + Serial.println(float)3380200
Penggabungan String: "A0=" + String(analogRead(A0))3316202
Tugas yang sama dengan snprintf dan array char3232194
Satu penulisan dengan Wire (I2C)2476225
Kartu SD: begin, open, println, close10496837
Array int veri[700]17801588 (77%, peringatan Low memory)
Array int veri[950]17802088 (101%, gagal dikompilasi)

Pelajarannya jelas. Serial.begin() saja memakai 175 byte RAM, karena port serial mengalokasikan buffer penerimaan 64 byte dan buffer pengiriman 64 byte. Satu string berisi 44 karakter memakai 44 byte RAM; jika ditulis dengan F(), RAM itu kembali bebas. Pemakaian float menambahkan sekitar 1,5 KB kode floating-point ke flash. Library SD sendiri menghabiskan flash 10 KB dan sekitar 830 byte RAM; 40% RAM Uno dipakai untuk satu file log. RAM global pada contoh String terlihat kecil, tetapi penggunaan sebenarnya muncul di heap ketika program berjalan dan tidak pernah terlihat dalam hasil kompilasi.

Makro F(): memindahkan string konstan dari RAM

Pada Uno, setiap string dalam tanda kutip seperti “Temperature: ” berada di flash, tetapi disalin ke RAM ketika program dimulai dan terus menempati ruang di sana. Makro F() mencegah penyalinan ini: string tetap berada di flash dan fungsi seperti Serial.print membacanya karakter demi karakter langsung dari flash. F() bekerja dengan setiap objek turunan kelas Print, termasuk Serial, LiquidCrystal, LiquidCrystal_I2C, Adafruit SSD1306, dan file SD. Pada proyek dengan menu, pesan error, dan teks bantuan, menambahkan F() saja bisa membebaskan kembali beberapa ratus byte RAM. Kode di bawah menunjukkan perbedaannya dan mengukur RAM bebas ketika program berjalan:

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}

Fungsi bosRam() menghitung jarak antara puncak stack sekarang dan akhir heap, dengan kata lain berapa byte tersisa sebelum heap dan stack bertemu. Panggil fungsi ini di dalam loop() tepat setelah pembaruan layar atau penulisan SD untuk menangkap kondisi terburuk. Aturan praktis: pada Uno, jangan biarkan RAM bebas turun di bawah 200–300 byte ketika program berjalan. F() tidak bekerja dengan fungsi yang mengharapkan char* (strcmp, strcpy); untuk fungsi tersebut, gunakan versi _P dan makro PSTR() yang ditunjukkan di bawah.

PROGMEM: menyimpan tabel besar di flash

F() hanya untuk string. Untuk array besar yang tidak pernah berubah, seperti array nada, ikon layar (bitmap), tabel karakter, kurva kalibrasi, atau daftar pesan, gunakan kata kunci PROGMEM. Array yang dideklarasikan dengan PROGMEM tidak pernah disalin ke RAM; untuk membacanya, kamu membutuhkan fungsi khusus seperti pgm_read_byte dan pgm_read_word sebagai pengganti akses array biasa. Misalnya, melodi 100 nada dengan tabel frekuensi dan durasi memakai 400 byte; itu seperlima RAM Uno, dan PROGMEM memindahkan semuanya ke flash.

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}
Fungsi / makroApa fungsinya?
pgm_read_byte(&array[i])Membaca 1 byte dari flash (array byte, char, uint8_t, bitmap)
pgm_read_word(&array[i])Membaca 2 byte dari flash (int, uint16_t; tabel nada dan angka pada Uno)
pgm_read_dword / pgm_read_floatMembaca nilai long dan float berukuran 4 byte
pgm_read_ptr(&table[i])Membaca pointer yang disimpan di flash (tabel string)
strcpy_P(dest, src)Menyalin string dari flash ke buffer RAM
strcmp_P(ram_text, PSTR("..."))Membandingkan string di RAM dengan string di flash
strlen_P / memcpy_PMengambil panjang string di flash, menyalin blok dari flash
Pada ESP32 dan Pico, array yang dideklarasikan sebagai const sudah tetap berada di flash; PROGMEM tidak berpengaruh di sana, tetapi juga tidak menimbulkan error, dan fungsi pgm_read_* tersedia. Jadi, kode yang ditulis dengan PROGMEM bisa dikompilasi pada ketiga board. Ada satu pengecualian: ketika membaca tabel pointer, pgm_read_word bekerja pada Uno tetapi memotong pointer pada board 32-bit; gunakan pgm_read_ptr agar kode bisa dipakai lintas platform.

Gunakan array char sebagai pengganti String

Kelas String Arduino memang praktis, tetapi setiap penggabungan (+) meminta blok baru dari heap dan membebaskan blok lama. Jika diulang ribuan kali pada heap Uno yang kecil, memori menjadi penuh celah. Program berjalan lancar selama berjam-jam, lalu tiba-tiba macet, dan bug-nya sangat sulit ditemukan. Solusinya adalah memakai array char yang ukurannya diketahui sejak awal: memori dialokasikan sekali, tidak pernah terfragmentasi, dan jumlah byte yang dipakai terlihat dalam hasil kompilasi. Kode di bawah membaca perintah dari Serial Monitor tanpa String dan memformat hasil pengukuran menjadi satu baris:

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}

Ada tiga detail pada kode yang perlu diperhatikan. snprintf mengetahui ukuran buffer, sehingga tidak pernah melampaui batas array meskipun teksnya panjang; sprintf tidak memberikan perlindungan itu. Karena keluarga printf pada AVR tidak mendukung format %f secara bawaan, nilai float terlebih dahulu diubah menjadi teks dengan dtostrf. Selain itu, batas pada buffer perintah (konum < sizeof(komut) - 1) mencegah baris panjang menimpa bagian memori lain. Jika kamu harus memakai String (beberapa library mengembalikan String), setidaknya cadangkan ruang sejak awal di setup() dengan text.reserve(64) dan jadikan String sebagai variabel global; ini sangat mengurangi fragmentasi.

Tipe data yang tepat dan variabel lokal

TipeUno (AVR)ESP32 / PicoRentang nilai (Uno)
bool, char, byte (tipe data 1 byte)1 byte1 bytebyte: 0–255
int2 byte4 byte-32768 hingga 32767
unsigned int, uint16_t2 byteuint16_t 2, unsigned int 4 byte0–65535
long, unsigned long (tipe bilangan bulat 4 byte)4 byte4 byteunsigned long: 0–4.294.967.295
float4 byte4 byteSekitar 6–7 digit signifikan
double4 byte (sama dengan float)8 byteTidak berbeda dari float pada Uno
  • byte untuk angka kecil: Memakai byte sebagai pengganti int untuk nomor pin, penghitung, dan persentase antara 0 dan 255 menghemat 1 byte per variabel dan 200 byte dalam array berisi 200 elemen.
  • const untuk nomor pin: Compiler menyisipkan konstanta yang dideklarasikan sebagai const byte LED_PIN = 13; langsung ke kode dan tidak mencadangkan RAM untuknya.
  • Flag nyala/mati dalam bit: Delapan variabel bool memakai 8 byte; simpan informasi yang sama dalam bit satu byte dengan bitRead dan bitWrite, dan 1 byte sudah cukup.
  • Waspadai array lokal besar: char buffer[300]; yang dideklarasikan di dalam fungsi tidak muncul dalam hasil kompilasi, tetapi memakai stack 300 byte setiap kali fungsi dipanggil. Jadikan buffer besar sebagai variabel global agar ukurannya terlihat.
  • Hindari rekursi: Setiap fungsi yang memanggil dirinya sendiri membuka tingkat baru pada stack; pada Uno, beberapa puluh tingkat saja bisa menghabiskan RAM.
  • Teruskan struktur besar melalui referensi: Meneruskan struct ke fungsi berdasarkan nilai menempatkan salinannya di stack; meneruskannya melalui referensi sebagai const Settings& s tidak menyalinnya.

Penggunaan memori library yang tersembunyi

Ketika proyek tiba-tiba kehabisan memori, penyebabnya sering kali bukan kodemu, melainkan library yang kamu tambahkan. Beberapa library mencadangkan RAM ketika kompilasi (sebagai buffer global), sedangkan yang lain mengambilnya dari heap ketika begin() dipanggil; pada kasus kedua, hasil kompilasi terlihat baik-baik saja, tetapi memori habis setelah board berjalan. Sebagian nilai di bawah berasal dari tabel pengukuran di atas, dan sisanya dari ukuran buffer library:

Library / fiturPenggunaan RAM (Uno)Kapan dialokasikan?Pilihan yang lebih ringan
SerialSekitar 175 byte (buffer 64 + 64 byte)Ketika kompilasi (global)Hapus Serial sepenuhnya jika tidak diperlukan
Wire (I2C)Sekitar 215 byteKetika kompilasi (global)Tidak bisa dihindari meskipun hanya ada satu perangkat I2C; fokus pada penghematan lain
SoftwareSerialSekitar 120 byte (buffer penerimaan 64 byte)Ketika kompilasi (global)Port serial perangkat keras jika memungkinkan, atau port tambahan Mega
SDSekitar 830 byte, ditambah sekitar 10 KB flashKetika kompilasi (global)Serahkan pencatatan data kepada ESP32 atau Mega
Adafruit SSD1306 128x64Frame buffer 1024 byteDari heap di dalam begin()Mode halaman U8g2 (128 byte) atau U8x8 untuk teks saja
Adafruit NeoPixel / FastLED3 byte per LED (60 LED = 180 byte)Ketika program dimulaiBatasi jumlah LED sesuai panjang strip sebenarnya

Tabel ini menjelaskan mengapa memakai layar OLED, kartu SD, dan modul Wi-Fi secara bersamaan pada Uno hampir mustahil: buffer SSD1306 dan library SD saja berjumlah 1,8 KB, sehingga hampir tidak ada yang tersisa dari RAM 2 KB untuk programmu. Error SSD1306 allocation failed yang muncul pada layar OLED memang disebabkan kegagalan alokasi heap ini; kamu juga bisa menemukan solusinya dalam artikel layar OLED SSD1306.

Sketch too big: cara mengurangi penggunaan flash

  • Matikan output debug: Baris Serial.print yang ditambahkan selama pengembangan memakai flash sekaligus RAM. Dengan makro DEBUG di bawah, kamu bisa menghapus semuanya dari hasil kompilasi dengan mengubah satu baris saja.
  • Hindari float dan sprintf: Seperti terlihat pada pengukuran, float menambahkan sekitar 1,5 KB dan snprintf lebih dari 1 KB kode. Mengalikan suhu dengan 10 dan menyimpannya sebagai int (235 sebagai pengganti 23,5 °C) sudah cukup untuk sebagian besar proyek.
  • Ubah kode berulang menjadi fungsi dan array: Menyimpan nomor pin dalam array dan memprosesnya dalam perulangan, alih-alih menulis blok sepuluh baris untuk setiap LED, akan memperpendek kode secara nyata.
  • Pilih library yang lebih kecil: Jika tidak membutuhkan grafis, U8x8 atau LiquidCrystal_I2C memakai ruang jauh lebih sedikit daripada library berbasis Adafruit GFX. Daripada menambahkan seluruh library untuk satu fungsi, pertimbangkan menulis bagian itu sendiri.
  • Periksa pengaturan board: Arduino IDE menghitung batas berdasarkan board yang kamu pilih: 32.256 byte untuk Uno, 30.720 untuk Nano (bootloader lama atau baru), dan 28.672 untuk Leonardo. Jika board yang dipilih salah, batas dan definisi pin sama-sama salah.
  • Beralih ke board yang lebih besar: Jika masih tidak muat setelah semua langkah ini, Mega (256 KB) atau ESP32 (1,25 MB dan lebih) bisa menjalankan kode yang sama dengan sedikit perubahan.
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}

Dengan DEBUG 1, sketch ini memakai flash 2292 byte dan RAM 188 byte pada Uno; atur DEBUG 0 dan kode Serial dihapus sepenuhnya dari hasil kompilasi, sehingga nilainya turun menjadi flash 934 byte dan RAM 9 byte. Selisih flash 1,3 KB dan RAM 179 byte itu sering kali cukup untuk menambahkan fitur baru ke proyek yang sudah selesai.

Mengukur memori pada ESP32

ESP32 memiliki banyak memori, tetapi tidak tanpa batas. Mengaktifkan Wi-Fi mengalokasikan puluhan KB RAM, dan dengan tambahan Bluetooth jumlahnya bisa mendekati 100 KB; web server, dokumen JSON, dan buffer gambar juga cepat memenuhi memori. Beberapa modul, seperti ESP32-CAM, memiliki PSRAM tambahan (biasanya 4 MB) untuk menampung buffer besar. Di sisi flash, jika aplikasimu tidak muat di partisi bawaan 1,25 MB, kamu bisa menaikkannya hingga 3 MB dengan opsi “Huge APP” pada pengaturan Partition Scheme di menu Tools. Untuk fitur umum ESP32, lihat Apa Itu ESP32?.

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}

Dua angka paling berguna di sini adalah getMinFreeHeap dan getMaxAllocHeap. Yang pertama memberikan heap bebas terendah sejak program dimulai, sedangkan yang kedua memberikan blok terbesar yang bisa dialokasikan secara utuh. Jika heap bebas menunjukkan 100 KB tetapi blok terbesarnya di bawah 10 KB, heap mengalami fragmentasi dan String atau dokumen JSON yang besar mungkin tidak bisa dialokasikan. Pada ESP32, loop() berjalan dalam task tersendiri dengan stack 8 KB; uxTaskGetStackHighWaterMark menunjukkan bagian stack itu yang belum pernah dipakai, dan jika turun di bawah beberapa ratus byte, kamu mungkin menemui error “Stack canary watchpoint triggered”.

Memori pada Raspberry Pi Pico dan di MicroPython

RAM Pico sebesar 264 KB sangat besar dibandingkan Uno, tetapi interpreter MicroPython memakai sebagian untuk dirinya sendiri; programmu biasanya mendapat sisa heap sekitar 190 KB. Dalam MicroPython, memori dikelola oleh garbage collector: objek yang tidak lagi dipakai dibersihkan ketika gc.collect() dipanggil atau ketika memori hampir habis. Ketika memori benar-benar habis, muncul MemoryError: memory allocation failed. Menggabungkan string dalam perulangan, membuat list besar, dan satu file kode yang sangat panjang merupakan penyebab paling umum error ini.

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]))

Untuk menghemat memori di MicroPython, alokasikan buffer sejak awal dengan bytearray dan gunakan kembali dalam perulangan, definisikan angka konstan dengan const(), ubah modul besar menjadi file .mpy yang sudah dikompilasi dengan mpy-cross, dan panggil gc.collect() sebelum pekerjaan panjang. Kamu bisa mempelajari perintah dasar MicroPython pada Pico dalam dasar-dasar MicroPython, serta fitur umum board dalam Apa Itu Raspberry Pi Pico?.

Kapan sebaiknya beralih ke Mega atau ESP32?

Board Arduino Mega 2560
Arduino Mega 2560: flash 256 KB, SRAM 8 KB, dan EEPROM 4 KB. Kode Uno sering kali bisa berjalan di board ini tanpa perubahan apa pun.
SituasiSaran
Setelah memakai F(), PROGMEM, dan array char, RAM bebas tetap di atas 300 byteTetap gunakan Uno; masalah sudah teratasi
Beberapa sensor dan menu dengan OLED atau kartu SD, tetapi RAM masih tidak cukupArduino Mega 2560: RAM 4 kali lebih besar, pin 5 V dan library yang sama
Program melebihi 32 KB, tetapi RAM cukupMega atau Uno R4: flash 256 KB
Kamu membutuhkan Wi-Fi, web server, buffer besar, atau pengolahan gambarESP32: RAM 520 KB, flash 4 MB, Wi-Fi, dan Bluetooth
Kamu ingin bekerja dengan MicroPythonRaspberry Pi Pico atau Pico W
Simpul sensor kecil yang harus berjalan dengan baterai selama berbulan-bulanOptimalkan pada Uno atau gunakan Pro Mini; board yang lebih besar menarik lebih banyak arus

Ketika beralih ke Mega, sebagian besar kodemu tetap sama; cukup ingat bahwa pin I2C-nya adalah 20 (SDA) dan 21 (SCL), sedangkan pin SPI-nya 50–53. Beralih ke ESP32 membawa perbedaan seperti level logika 3,3 V, nomor pin berbeda, dan hasil analogRead 12-bit (0–4095). Untuk menentukan board yang cocok, baca perbandingan Arduino vs ESP32, dan untuk pilihan yang cocok dengan 5 V serta memiliki memori jauh lebih besar, baca artikel Arduino Uno R4.

Kesalahan umum dan cara mengatasinya

GejalaKemungkinan penyebabSolusi
Sketch too big, kode tidak bisa di-uploadProgram tidak muat di flashMatikan output debug, kurangi float dan sprintf, pilih library yang lebih kecil, beralih ke Mega jika perlu
Kode bisa di-upload, tetapi macet setelah beberapa menitPenggabungan String membuat heap terfragmentasiGunakan array char dan snprintf sebagai pengganti String; ukur RAM bebas
Karakter sampah di Serial Monitor, variabel berubah sendiriStack menimpa heapTurunkan penggunaan RAM global di bawah 75%, hapus array lokal besar
“SSD1306 allocation failed”begin() tidak bisa mengalokasikan buffer 1 KBBungkus string dengan F(), beralih ke mode halaman U8g2
Board reset secara acak meskipun memori terlihat baik-baik sajaMungkin masalah daya, bukan memoriBeri daya motor dan relay secara terpisah, tambahkan kapasitor
Elemen array menunjukkan nilai yang tidak masuk akalPenulisan melewati batas akhir arrayPeriksa indeks; tentukan batas perulangan dari sizeof
“Stack canary watchpoint triggered” pada ESP32Stack suatu task meluapJadikan array lokal besar sebagai variabel global atau perbesar stack task
Untuk mencegah masalah memori sejak awal, catat dua persentase dari hasil kompilasi setiap kali menambahkan modul baru ke proyek. Mulailah menerapkan F() dan PROGMEM begitu penggunaan RAM global melampaui 60%; menunggu peringatan 75% berarti menunda masalah hingga titik paling sulit untuk menyelesaikannya.

Kehabisan memori pada Arduino biasanya bisa diatasi tanpa mengganti board: memindahkan string konstan ke flash dengan F(), memindahkan tabel besar ke PROGMEM, memakai array char sebagai pengganti String, dan menghapus library yang tidak diperlukan memberikan ruang bebas yang mengejutkan pada RAM 2 KB. Dalam aplikasi BlueGrays, kamu bisa menjelajahi proyek yang membutuhkan banyak memori seperti game OLED, melodi buzzer, dan animasi LED matrix, lengkap dengan skema rangkaian langkah demi langkah serta kode yang ditulis menggunakan teknik-teknik ini.

Pertanyaan umum

Apa arti Low memory available pada Arduino?

Artinya variabel global memenuhi sekitar 75% RAM dan hanya sedikit ruang tersisa untuk stack dan heap. Kode bisa di-upload, tetapi reset acak, macet, dan variabel rusak bisa muncul ketika program berjalan. Membungkus string konstan dengan F() dan memindahkan array besar ke PROGMEM biasanya menghilangkan peringatan ini.

Bagaimana cara mengatasi error Sketch too big?

Error ini berarti program tidak muat di memori flash. Matikan output Serial yang ditambahkan untuk debugging, kurangi float dan sprintf, ubah kode berulang menjadi fungsi, dan pilih library yang lebih kecil. Jika masih tidak muat, beralihlah ke board dengan flash lebih besar seperti Arduino Mega atau ESP32.

Berapa banyak memori yang dimiliki Arduino Uno?

ATmega328P pada Arduino Uno memiliki flash 32 KB (0,5 KB dicadangkan untuk bootloader), SRAM 2 KB, dan EEPROM 1 KB. Program masuk ke flash, variabel ke SRAM, dan pengaturan permanen ke EEPROM. Sebagian besar masalah terjadi pada SRAM 2 KB tersebut.

Apa fungsi makro F()?

F() mencegah string konstan yang diteruskan ke fungsi seperti Serial.print disalin ke RAM dan menyimpannya di flash. Pada Uno, setiap karakter menghemat satu byte RAM, yang bisa mencapai ratusan byte pada proyek dengan banyak pesan. Kode ini juga bisa dikompilasi pada ESP32 dan Pico, tetapi tidak berpengaruh di sana.

Bagaimana cara mengukur RAM bebas pada Arduino?

Pada Uno, Nano, dan Mega, gunakan fungsi kecil yang menghitung jarak antara stack dan heap dengan variabel __heap_start dan __brkval. Pada ESP32, ESP.getFreeHeap() dan ESP.getMinFreeHeap() memberikan informasi yang sama, dan di MicroPython gunakan gc.mem_free(). Pengukuran perlu dilakukan ketika penggunaan memori mencapai puncaknya.

Mengapa memakai String pada Arduino menjadi masalah?

Objek String meminta memori baru dari heap pada setiap penggabungan dan melepaskan blok lama, sehingga heap Uno yang kecil mengalami fragmentasi seiring waktu. Meskipun total memori bebas terlihat cukup, blok baru tidak bisa dialokasikan dan program macet. Array char berukuran tetap dan snprintf menghilangkan masalah ini sepenuhnya.

Lihat semua proyek
Lagu Kebangsaan Turki dengan Buzzer
AR-15Menengah

Lagu Kebangsaan Turki dengan Buzzer

Tekan tombol dan buzzer kecil mulai memainkan Lagu Kebangsaan Turki, nada demi nada.

4.8(114)
235
Suhu dan Kelembapan dengan DHT11
AR-55Menengah

Suhu dan Kelembapan dengan DHT11

Seberapa hangat kamarmu, dan apakah udaranya lembap atau kering? Sensor DHT11 mengukur suhu dan kelembapan, dan Arduino menulis nilainya di layar LCD dua baris, diperbarui setiap beberapa detik.

4.7(47)
83
Game Bola Pemukul - SSD1306
AR-86Menengah
Premium

Game Bola Pemukul - SSD1306

Satu bola, dua pemukul, dan kamu: kamu bermain tenis meja, salah satu video game paling awal, di layar OLED kecil.

4.5(47)
65
OLED T-Rex Run: Game Dinosaurus Arduino
AR-87Mahir
Premium

OLED T-Rex Run: Game Dinosaurus Arduino

Game dinosaurus yang muncul ketika internetmu putus, sekarang ada di mejamu: dinosaurus berlari di layar OLED kecil, kaktus datang menghampiri, dan kamu melompat dengan satu tombol.

4.7(33)
53
Ular Piksel Matrix 8x8
AR-88Mahir
Premium

Ular Piksel Matrix 8x8

Buat sendiri dan mainkan game ular klasik. Di matrix lampu 8x8 yang berwarna-warni, kamu mengarahkan ular hijau dengan joystick dan memakan apel merah; di setiap apel ular bertambah panjang, sedikit…

4.7(39)
57
Game Memori Arduino (4 LED + 4 Tombol + Buzzer)
AR-93Mahir
Premium

Game Memori Arduino (4 LED + 4 Tombol + Buzzer)

Percaya dengan ingatanmu? Empat LED berwarna menyala berurutan, masing-masing memainkan nadanya sendiri, dan kamu mengulang urutan yang sama dengan menekan tombol.

4.8(46)
69
Kunci Sandi dengan Keypad 4x4 dan LCD
AR-64Mahir
Premium

Kunci Sandi dengan Keypad 4x4 dan LCD

Kunci pintu elektronik kecil yang menahan siapa pun yang tidak tahu kodenya. Kamu menekan tombol pagar lalu mengetik kodenya di keypad; jika benar, layar menulis akses diberikan, LED hijau menyala…

4.8(59)
75