Gidsen · 15 min leestijd

Arduino geheugen vol: los Sketch too big en Low memory op

Arduino geheugen vol? Flash, SRAM en EEPROM, F() en PROGMEM, char-arrays in plaats van String, vrij RAM meten en wanneer je overstapt op een Mega of ESP32.

Een Arduino-melding dat het geheugen vol is, betekent dat je programma of je variabelen niet in het geheugen van het board passen. Meestal zie je dit op twee manieren: de code wordt nooit geüpload omdat de build stopt met Sketch too big, of de code wordt wel geüpload na de waarschuwing Low memory available, stability problems may occur en het board reset daarna willekeurig, toont rommel in de Serial Monitor of loopt vast. Omdat de Arduino Uno maar 32 KB programmageheugen en 2 KB RAM heeft, komt dit probleem vooral voor in projecten die een display, een SD-kaart en een paar sensoren combineren.

In deze gids zie je eerst het verschil tussen Flash, SRAM en EEPROM en hoe je de twee regels onderaan een build leest. Daarna leer je aan de hand van waarden die we met echte builds op een Uno hebben gemeten welke regel hoeveel geheugen kost, hoe je constante gegevens met de F()-macro en PROGMEM uit het RAM haalt, hoe je char-arrays gebruikt in plaats van String, wat bibliotheken ongemerkt kosten en hoe je vrij RAM tijdens het draaien meet. In het laatste deel lees je hoe het geheugen op de ESP32 en Raspberry Pi Pico wordt bewaakt en wanneer overstappen op een Mega of ESP32 de juiste keuze is.

Arduino Uno-board met de ATmega328P-microcontroller
De ATmega328P in het hart van de Arduino Uno: 32 KB flash, 2 KB SRAM en 1 KB EEPROM. De meeste geheugenproblemen ontstaan in die 2 KB RAM.

De drie geheugens in een Arduino: Flash, SRAM en EEPROM

De microcontroller op een Arduino bevat drie geheugens met totaal verschillende taken. In Flash (programmageheugen) staat je gecompileerde code; het blijft behouden bij stroomverlies en wordt alleen beschreven als je uploadt. SRAM (werkgeheugen) is waar variabelen, functieaanroepen en tijdelijke gegevens leven; het is snel, maar loopt leeg als het board wordt uitgezet. EEPROM is een klein gebied voor gegevens die bewaard moeten blijven maar zelden veranderen, zoals instellingen en kalibratiewaarden. Op AVR-boards zoals de Uno staan deze drie geheugens in aparte adresruimten (Harvard-architectuur). Dit detail verklaart waarom de F()- en PROGMEM-technieken die je hieronder ziet nodig zijn.

GeheugenGrootte op de UnoWat wordt opgeslagen?Bij stroomverliesSchrijfduurzaamheid
Flash32 KB (0,5 KB gereserveerd voor de bootloader, 32256 bytes bruikbaar)Programmacode, PROGMEM-gegevensBlijft behoudenOngeveer 10.000 wis-/schrijfcycli
SRAM2 KB (2048 bytes)Variabelen, arrays, stack en heapGaat verlorenOnbeperkt
EEPROM1 KB (1024 bytes)Instellingen, tellers, kalibratieBlijft behoudenOngeveer 100.000 schrijfacties per cel

EEPROM gebruiken in plaats van RAM is geen oplossing: het is traag en elke cel kan maar een beperkt aantal keren worden beschreven. Als je een snel veranderende variabele bij elke lus naar EEPROM schrijft, kun je die cel binnen enkele dagen kapotschrijven. De juiste manieren om EEPROM te gebruiken vind je in de Arduino EEPROM-tutorial.

Geheugengroottes per board

BoardFlash (program)SRAMEEPROM
Arduino Uno R3 / Nano (ATmega328P)32 KB (Uno 32256, Nano 30720 bytes bruikbaar)2 KB1 KB
Arduino Leonardo / Pro Micro (ATmega32U4)32 KB (28672 bytes bruikbaar)2,5 KB1 KB
Arduino Mega 2560256 KB (253952 bytes bruikbaar)8 KB4 KB
Arduino Uno R4 (RA4M1)256 KB32 KB8 KB (dataflash)
ESP32 (WROOM)4 MB flashchip (standaard app-partitie 1,25 MB)520 KB (ongeveer 300 KB heap blijft over voor je programma)Geen; Preferences slaat gegevens op in flash
Raspberry Pi Pico (RP2040)2 MB flashchip264 KBGeen; geëmuleerd in flash

Het verschil is enorm: de ESP32 heeft 260 keer zoveel RAM als de Uno en de Pico ongeveer 130 keer. Daarom zijn geheugenbesparingen die op een Uno echte moeite kosten op een ESP32 vaak overbodig. Toch zijn de Uno, Nano en Pro Mini dankzij hun lage prijs en eenvoud de meestgebruikte boards, dus leren leven met 2 KB loont voor elke Arduino-gebruiker.

De build-uitvoer lezen: Sketch uses en Global variables use

Aan het einde van elke geslaagde build toont de Arduino IDE twee regels. Compileer een sketch met een lege setup() en loop() voor de Uno en je ziet Sketch uses 444 bytes (1%) of program storage space en Global variables use 9 bytes (0%) of dynamic memory, leaving 2039 bytes for local variables. De eerste regel vertelt hoeveel flash het programma inneemt, de tweede hoeveel RAM globale en statische variabelen gebruiken. Het belangrijkste is dat de tweede regel alleen variabelen telt waarvan de grootte tijdens het compileren bekend is. Lokale variabelen van functies (de stack) en geheugen dat tijdens het draaien met String of malloc wordt toegewezen (de heap) worden niet meegeteld. De resterende ruimte voor "local variables" moeten ze samen delen.

MeldingWanneer verschijnt die?Wat betekent het?
Sketch uses ... bytes (x%) of program storage spaceBij elke buildRuimte die de code in flash inneemt
Global variables use ... bytes (x%) of dynamic memoryBij elke buildAandeel RAM dat globale en statische variabelen gebruiken
Low memory available, stability problems may occur.Wanneer globale variabelen meer dan ongeveer 75% van het RAM gebruikenDe code wordt geüpload, maar er blijft weinig ruimte over voor de stack en heap
Sketch too big and text section exceeds available space in boardWanneer het programma niet in flash pastDe code kan niet worden geüpload; je moet het flashgebruik verkleinen
Not enough memory and data section exceeds available space in boardWanneer globale variabelen het RAM overschrijdenDe code kan niet worden geüpload; je moet het RAM-gebruik verkleinen
De waarschuwing "Low memory" is geen fout en de code wordt zonder klagen geüpload; dat is precies het gevaar. Een sketch met bijvoorbeeld int veri[700]; gebruikt op een Uno 1588 bytes (77%) aan globale variabelen en laat maar 460 bytes over voor de stack en heap. Als een paar geneste functieaanroepen, een String-concatenatie of een buffer die een bibliotheek in begin() toewijst die ruimte opmaken, crasht het programma. De symptomen zijn willekeurige resets, beschadigde variabelen en vastlopers; om die van voedingsproblemen te onderscheiden, lees je ook Arduino blijft resetten.

Binnen het SRAM: globale variabelen, heap en stack

De 2048 bytes RAM van de Uno zijn verdeeld in vier gebieden. Onderaan staan globale variabelen met een beginwaarde (.data), daarboven globale variabelen die met nul beginnen (.bss); de compiler toont de som van die twee in de regel "Global variables use". Daarna komt de heap, die omhoog groeit: String-objecten en geheugen dat met new en malloc is toegewezen leven hier. Vanaf de bovenkant van het RAM groeit de stack omlaag: elke functieaanroep zet hier zijn terugkeeradres en lokale variabelen neer, en bij een interrupt worden hier registers opgeslagen. Als de heap en de stack elkaar in de vrije ruimte ertussen ontmoeten, overschrijven ze elkaar en gaat het programma op onvoorspelbare manieren kapot.

GebiedInhoudGroeirichtingZichtbaar in de build-uitvoer?
.dataGeïnitialiseerde globale en statische variabelen, strings zonder F()VastJa
.bssNiet-geïnitialiseerde (nul) globale en statische variabelen, bibliotheekbuffersVastJa
HeapString, new, malloc, buffers die sommige bibliotheken in begin() toewijzenOmhoogNee
StackLokale variabelen, terugkeeradressen van functies, tijdens interrupts opgeslagen registersOmlaagNee

Deze indeling heeft twee belangrijke gevolgen. Ten eerste wordt elke string zonder F() naar .data gekopieerd, omdat de AVR-processor gegevens in flash niet als een gewone variabele kan lezen. Ten tweede raakt de heap gefragmenteerd: als je Strings van verschillende grootte maakt en verwijdert, blijven er kleine gaten achter en kan er, zelfs als het totale vrije geheugen genoeg lijkt, geen groot blok meer worden toegewezen. Daarom is het in programma's die lang op een Uno draaien het veiligst om zoveel mogelijk uit de buurt van de heap te blijven.

Eerst meten: welke regel kost hoeveel geheugen?

De eerste stap bij een geheugenprobleem is meten, niet gokken. Elke rij in de tabel hieronder is de echte uitvoer van een kleine sketch die apart voor de Arduino Uno is gecompileerd met Arduino AVR core 1.8.6. De waarden kunnen per bibliotheek- en core-versie een paar bytes verschillen, maar de verhoudingen blijven altijd gelijk.

Wat staat er in de sketch?Flash (bytes)Globaal RAM (bytes)
Lege setup() en loop()4449
Serial.begin(9600)1438184
+ Serial.println("een tekst van 44 tekens")1518232
Dezelfde tekst met F()1530188
analogRead + Serial.println(int)1892188
float-berekening + Serial.println(float)3380200
String-concatenatie: "A0=" + String(analogRead(A0))3316202
Dezelfde taak met snprintf en een char-array3232194
Eén schrijfactie met Wire (I2C)2476225
SD-kaart: begin, open, println, close10496837
int veri[700]-array17801588 (77%, waarschuwing Low memory)
int veri[950]-array17802088 (101%, compileert niet)

De lessen zijn duidelijk. Serial.begin() alleen al kost 175 bytes RAM, omdat de seriële poort een ontvangstbuffer van 64 bytes en een zendbuffer van 64 bytes toewijst. Eén string van 44 tekens kost 44 bytes RAM; met F() geschreven komt dat RAM terug. Het gebruik van float voegt ongeveer 1,5 KB aan floating-point-code toe aan flash. De SD-bibliotheek verbruikt alleen al 10 KB flash en ongeveer 830 bytes RAM; 40% van het RAM van de Uno gaat naar één logbestand. Het globale RAM van het String-voorbeeld lijkt klein, maar de echte kosten verschijnen tijdens het draaien in de heap en komen nooit in de build-uitvoer.

De F()-macro: constante strings uit het RAM halen

Op een Uno staat elke string tussen aanhalingstekens, zoals "Temperature: ", in flash, maar wordt hij bij het starten van het programma naar het RAM gekopieerd en neemt daar blijvend ruimte in. De F()-macro voorkomt die kopie: de string blijft in flash staan en functies zoals Serial.print lezen hem teken voor teken rechtstreeks uit flash. F() werkt met elk object dat van de klasse Print is afgeleid, waaronder Serial, LiquidCrystal, LiquidCrystal_I2C, Adafruit SSD1306 en SD-bestanden. In een project met menu's, foutmeldingen en helpteksten kan alleen al het toevoegen van F() een paar honderd bytes RAM opleveren. De code hieronder toont het verschil en meet het vrije RAM tijdens het draaien:

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}

De functie bosRam() berekent de afstand tussen de huidige top van de stack en het einde van de heap, met andere woorden hoeveel bytes er overblijven voordat heap en stack elkaar ontmoeten. Roep hem in loop() aan direct na een display-update of een SD-schrijfactie en je vangt het slechtste moment. Een praktische regel: laat het vrije RAM op een Uno tijdens het draaien niet onder de 200–300 bytes komen. F() werkt niet met functies die een char* verwachten (strcmp, strcpy); daarvoor gebruik je de _P-versies en de PSTR()-macro die hieronder wordt getoond.

PROGMEM: grote tabellen in flash houden

F() is alleen voor strings. Voor grote arrays die nooit veranderen, zoals notenarrays, display-iconen (bitmaps), tekentabellen, kalibratiecurves of berichtenlijsten, gebruik je het sleutelwoord PROGMEM. Een array die met PROGMEM is gedeclareerd, wordt nooit naar het RAM gekopieerd; om hem te lezen heb je speciale functies zoals pgm_read_byte en pgm_read_word nodig in plaats van gewone array-toegang. Een melodie van 100 noten met tabellen voor frequentie en duur neemt bijvoorbeeld 400 bytes in; dat is een vijfde van het RAM van de Uno, en PROGMEM zet dat allemaal in 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}
Functie / macroWat doet het?
pgm_read_byte(&array[i])Leest 1 byte uit flash (byte-, char-, uint8_t-arrays, bitmaps)
pgm_read_word(&array[i])Leest 2 bytes uit flash (int, uint16_t; noten- en getallentabellen op de Uno)
pgm_read_dword / pgm_read_floatLeest long- en float-waarden van 4 bytes
pgm_read_ptr(&table[i])Leest een pointer die in flash is opgeslagen (stringtabellen)
strcpy_P(dest, src)Kopieert een string uit flash naar een RAM-buffer
strcmp_P(ram_text, PSTR("..."))Vergelijkt een string in RAM met een string in flash
strlen_P / memcpy_PBepaalt de lengte van een string in flash, kopieert een blok uit flash
Op de ESP32 en Pico blijven arrays die als const zijn gedeclareerd al in flash; PROGMEM heeft daar geen effect maar veroorzaakt ook geen fout, en de pgm_read_*-functies zijn gedefinieerd. Code die met PROGMEM is geschreven compileert dus op alle drie de boards. Eén uitzondering: bij het lezen van een pointertabel werkt pgm_read_word op de Uno, maar kapt het de pointer af op 32-bits boards; gebruik pgm_read_ptr voor draagbare code.

Gebruik char-arrays in plaats van String

De klasse String van Arduino is handig, maar elke concatenatie (+) vraagt de heap om een nieuw blok en geeft het oude vrij. Duizenden keren herhaald in de piepkleine heap van de Uno laat dit het geheugen vol gaten achter. Het programma draait uren prima en loopt dan plotseling vast, en de bug is heel moeilijk te vinden. De oplossing is char-arrays te gebruiken waarvan de grootte vooraf bekend is: het geheugen wordt één keer toegewezen, fragmenteert nooit en de gebruikte bytes verschijnen in de build-uitvoer. De code hieronder leest commando's uit de Serial Monitor zonder String en zet de meting op één regel:

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}

Drie details in de code verdienen aandacht. snprintf kent de buffergrootte, dus het loopt nooit over de array heen, ook niet bij lange tekst; sprintf biedt die bescherming niet. Omdat de printf-familie van AVR het formaat %f standaard niet ondersteunt, wordt de float-waarde eerst met dtostrf in tekst omgezet. En de limiet op de commandobuffer (konum < sizeof(komut) - 1) voorkomt dat een lange regel een ander deel van het geheugen overschrijft. Als je String toch moet gebruiken (sommige bibliotheken geven er een terug), reserveer dan tenminste vooraf de ruimte in setup() met text.reserve(64) en maak de String globaal; dat verkleint de fragmentatie sterk.

Het juiste datatype en lokale variabelen

TypeUno (AVR)ESP32 / PicoWaardebereik (Uno)
bool, char, byte1 byte1 bytebyte: 0–255
int2 bytes4 bytes-32768 tot 32767
unsigned int, uint16_t2 bytesuint16_t 2, unsigned int 4 bytes0–65535
long, unsigned long4 bytes4 bytesunsigned long: 0–4.294.967.295
float4 bytes4 bytesOngeveer 6–7 significante cijfers
double4 bytes (hetzelfde als float)8 bytesGeen verschil met float op de Uno
  • byte voor kleine getallen: Door byte in plaats van int te gebruiken voor pinnummers, tellers en percentages tussen 0 en 255 bespaar je 1 byte per variabele en 200 bytes in een array van 200 elementen.
  • const voor pinnummers: De compiler verwerkt constanten die als const byte LED_PIN = 13; zijn gedeclareerd rechtstreeks in de code en reserveert er geen RAM voor.
  • Aan/uit-vlaggen in bits: Acht bool-variabelen nemen 8 bytes in; sla dezelfde informatie op in de bits van één byte met bitRead en bitWrite en 1 byte is genoeg.
  • Pas op voor grote lokale arrays: Een char buffer[300]; die binnen een functie is gedeclareerd, verschijnt niet in de build-uitvoer, maar neemt bij elke aanroep van de functie 300 bytes stack in. Maak grote buffers globaal, zodat hun grootte zichtbaar is.
  • Vermijd recursie: Elke functie die zichzelf aanroept opent een nieuw niveau op de stack; op een Uno kunnen al een paar tientallen niveaus het RAM opmaken.
  • Geef grote structuren door als referentie: Een struct per waarde aan een functie doorgeven zet een kopie op de stack; doorgeven als referentie met const Settings& s kopieert hem niet.

De verborgen geheugenkosten van bibliotheken

Als een project plotseling zonder geheugen komt te zitten, is de boosdoener vaak niet je code maar een bibliotheek die je hebt toegevoegd. Sommige bibliotheken reserveren RAM tijdens het compileren (als globale buffer), andere nemen het uit de heap wanneer begin() wordt aangeroepen; in het tweede geval ziet de build-uitvoer er onschuldig uit, maar raakt het geheugen op zodra het board draait. Sommige waarden hieronder komen uit de meettabel hierboven, andere uit de buffergroottes van de bibliotheken:

Bibliotheek / functieRAM-kosten (Uno)Wanneer wordt het toegewezen?Lichtere optie
SerialOngeveer 175 bytes (buffers van 64 + 64 bytes)Tijdens het compileren (globaal)Verwijder Serial helemaal als je het niet nodig hebt
Wire (I2C)Ongeveer 215 bytesTijdens het compileren (globaal)Onvermijdelijk, zelfs met één I2C-apparaat; zoek de besparing elders
SoftwareSerialOngeveer 120 bytes (ontvangstbuffer van 64 bytes)Tijdens het compileren (globaal)Indien mogelijk de hardware-seriële poort, of de extra poorten van de Mega
SDOngeveer 830 bytes, plus ongeveer 10 KB flashTijdens het compileren (globaal)Laat het loggen over aan een ESP32 of een Mega
Adafruit SSD1306 128x64Framebuffer van 1024 bytesUit de heap in begin()U8g2-paginamodus (128 bytes) of U8x8 voor alleen tekst
Adafruit NeoPixel / FastLED3 bytes per led (60 leds = 180 bytes)Bij het opstartenBeperk het aantal leds tot de echte lengte van de strip

Deze tabel verklaart waarom het bijna onmogelijk is om op een Uno tegelijk een OLED-display, een SD-kaart en een Wi-Fi-module te gebruiken: de SSD1306-buffer en de SD-bibliotheek samen zijn al goed voor 1,8 KB, waardoor er van de 2 KB RAM nauwelijks iets voor je programma overblijft. De fout SSD1306 allocation failed die je bij OLED-displays krijgt, is precies deze mislukte heaptoewijzing; oplossingen vind je ook in het artikel SSD1306 OLED-display.

Sketch too big: manieren om het flashgebruik te verkleinen

  • Zet debug-uitvoer uit: Serial.print-regels die tijdens de ontwikkeling zijn toegevoegd kosten zowel flash als RAM. Met de DEBUG-macro hieronder haal je ze allemaal uit de build door één regel te wijzigen.
  • Vermijd float en sprintf: Zoals de metingen laten zien, voegt float ongeveer 1,5 KB toe en snprintf meer dan 1 KB code. De temperatuur met 10 vermenigvuldigen en als int opslaan (235 in plaats van 23,5 °C) is in de meeste projecten genoeg.
  • Maak van herhaalde code functies en arrays: Pinnummers in een array bewaren en in een lus verwerken in plaats van voor elke led een blok van tien regels te schrijven, maakt de code merkbaar korter.
  • Kies een kleinere bibliotheek: Als je geen graphics nodig hebt, nemen U8x8 of LiquidCrystal_I2C veel minder ruimte in dan bibliotheken op basis van Adafruit GFX. Overweeg om, in plaats van een hele bibliotheek binnen te halen voor één functie, dat onderdeel zelf te schrijven.
  • Controleer de board-instelling: De Arduino IDE berekent de limiet op basis van het board dat je kiest: 32256 bytes voor de Uno, 30720 voor de Nano (oude of nieuwe bootloader) en 28672 voor de Leonardo. Als het verkeerde board is gekozen, kloppen zowel de limiet als de pindefinities niet.
  • Stap over op een groter board: Als het na dit alles nog steeds niet past, draait een Mega (256 KB) of een ESP32 (1,25 MB en meer) dezelfde code met kleine aanpassingen.
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}

Met DEBUG 1 gebruikt deze sketch op een Uno 2292 bytes flash en 188 bytes RAM; zet je DEBUG 0, dan wordt de Serial-code helemaal uit de build gehaald en dalen de cijfers naar 934 bytes flash en 9 bytes RAM. De 1,3 KB flash en 179 bytes RAM daartussen zijn vaak genoeg om een nieuwe functie aan een afgerond project toe te voegen.

Geheugen meten op de ESP32

De ESP32 heeft veel geheugen, maar niet onbeperkt. Door Wi-Fi in te schakelen wordt tientallen KB RAM toegewezen, en met Bluetooth erbij kan dat richting 100 KB gaan; ook webservers, JSON-documenten en beeldbuffers vullen het geheugen snel. Sommige modules, zoals de ESP32-CAM, hebben extra PSRAM (meestal 4 MB) waar grote buffers heen gaan. Aan de flashkant kun je, als je applicatie niet in de standaardpartitie van 1,25 MB past, met de optie "Huge APP" in de instelling Partition Scheme van het menu Tools tot 3 MB gaan. Voor de algemene eigenschappen van de ESP32 lees je Wat is de 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}

De twee waardevolste getallen hier zijn getMinFreeHeap en getMaxAllocHeap. Het eerste geeft de laagste vrije heap sinds het programma startte, het tweede het grootste blok dat in één stuk kan worden toegewezen. Als de vrije heap 100 KB toont maar het grootste blok kleiner is dan 10 KB, is de heap gefragmenteerd en kan een grote String of een groot JSON-document mogelijk niet worden toegewezen. Op de ESP32 draait loop() in een eigen taak met een stack van 8 KB; uxTaskGetStackHighWaterMark toont het deel van die stack dat nooit is aangeraakt, en als dat onder een paar honderd bytes zakt, kun je de fout "Stack canary watchpoint triggered" tegenkomen.

Geheugen op de Raspberry Pi Pico en in MicroPython

De 264 KB RAM van de Pico is enorm in vergelijking met de Uno, maar de MicroPython-interpreter gebruikt er zelf een deel van; voor je programma blijft meestal ongeveer 190 KB heap over. In MicroPython wordt het geheugen beheerd door een garbage collector: objecten die niet meer worden gebruikt worden opgeruimd wanneer gc.collect() wordt aangeroepen of wanneer het geheugen bijna op is. Als het geheugen echt op is, krijg je MemoryError: memory allocation failed. Strings aan elkaar plakken in een lus, grote lijsten opbouwen en één heel lang codebestand zijn de meest voorkomende oorzaken van deze fout.

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

Om het geheugen in MicroPython te beschermen, wijs je buffers vooraf toe met bytearray en gebruik je ze opnieuw in de lus, definieer je constante getallen met const(), zet je grote modules met mpy-cross om in voorgecompileerde .mpy-bestanden en roep je gc.collect() aan vóór lange taken. De basiscommando's van MicroPython op de Pico vind je in MicroPython-basis en de algemene eigenschappen van het board in Wat is de Raspberry Pi Pico?.

Wanneer stap je over op een Mega of ESP32?

Arduino Mega 2560-board
Arduino Mega 2560: 256 KB flash, 8 KB SRAM en 4 KB EEPROM. Uno-code draait er vaak zonder wijzigingen op.
SituatieAanbeveling
Na F(), PROGMEM en char-arrays blijft het vrije RAM boven 300 bytesBlijf bij de Uno; het probleem is opgelost
Meerdere sensoren en een menu met een OLED of SD-kaart, en het RAM is nog steeds niet genoegArduino Mega 2560: 4 keer zoveel RAM, dezelfde 5V-pinnen en bibliotheken
Het programma is groter dan 32 KB maar het RAM is genoegMega of Uno R4: 256 KB flash
Je hebt Wi-Fi, een webserver, grote buffers of beeldverwerking nodigESP32: 520 KB RAM, 4 MB flash, Wi-Fi en Bluetooth
Je wilt in MicroPython werkenRaspberry Pi Pico of Pico W
Een kleine sensornode die maandenlang op batterijen moet draaienOptimaliseer op de Uno of gebruik een Pro Mini; een groter board trekt meer stroom

Als je overstapt op een Mega, blijft het grootste deel van je code hetzelfde; denk er alleen aan dat de I2C-pinnen 20 (SDA) en 21 (SCL) zijn en de SPI-pinnen 50–53. Overstappen op een ESP32 brengt verschillen met zich mee, zoals het 3,3 V-logicaniveau, andere pinnummers en het 12-bits resultaat (0–4095) van analogRead. Om te bepalen welk board bij je past, lees je de vergelijking Arduino vs ESP32, en voor een 5V-vriendelijke optie met veel meer geheugen het artikel Arduino Uno R4.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
Sketch too big, code wordt niet geüploadHet programma past niet in flashZet debug-uitvoer uit, gebruik minder float en sprintf, kies kleinere bibliotheken, stap zo nodig over op een Mega
Code wordt geüpload maar loopt na een paar minuten vastString-concatenaties fragmenteren de heapGebruik char-arrays en snprintf in plaats van String; meet het vrije RAM
Rommel in de Serial Monitor, variabelen veranderen vanzelfDe stack overschrijft de heapBreng het globale RAM onder de 75%, verwijder grote lokale arrays
SSD1306 allocation failedbegin() kan de buffer van 1 KB niet toewijzenZet strings in F(), schakel over op de paginamodus van U8g2
Het board reset willekeurig terwijl het geheugen in orde lijktHet kan een voedingsprobleem zijn in plaats van een geheugenprobleemVoed motoren en relais apart, voeg een condensator toe
Array-elementen tonen onzinwaardenSchrijven voorbij het einde van de arrayControleer de index; leid lusgrenzen af van sizeof
Stack canary watchpoint triggered op de ESP32De stack van een taak is overgelopenMaak grote lokale arrays globaal of vergroot de taakstack
Om geheugenproblemen van meet af aan te voorkomen, noteer je elke keer dat je een nieuwe module aan het project toevoegt de twee percentages uit de build-uitvoer. Begin met F() en PROGMEM toe te passen zodra het globale RAM boven de 60% komt; wachten op de waarschuwing bij 75% betekent dat je het probleem laat liggen tot het moment dat het het moeilijkst op te lossen is.

Een vol geheugen op een Arduino is meestal op te lossen zonder het board te vervangen: constante strings met F() naar flash verplaatsen, grote tabellen naar PROGMEM verplaatsen, char-arrays gebruiken in plaats van String en onnodige bibliotheken schrappen geeft 2 KB RAM verrassend veel ademruimte. In de BlueGrays-app kun je geheugenhongerige projecten verkennen, zoals OLED-spelletjes, buzzermelodieën en ledmatrix-animaties, met stapsgewijze schakelschema's en code die met deze technieken is geschreven.

Veelgestelde vragen

Wat betekent Low memory available op Arduino?

Het betekent dat globale variabelen ongeveer 75% van het RAM vullen en er weinig ruimte overblijft voor de stack en heap. De code wordt geüpload, maar tijdens het draaien kunnen willekeurige resets, vastlopers en beschadigde variabelen optreden. Constante strings in F() zetten en grote arrays naar PROGMEM verplaatsen laat de waarschuwing meestal verdwijnen.

Hoe los ik de fout Sketch too big op?

Deze fout betekent dat het programma niet in het flashgeheugen past. Zet Serial-uitvoer die voor het debuggen is toegevoegd uit, gebruik minder float en sprintf, maak van herhaalde code functies en kies kleinere bibliotheken. Past het dan nog steeds niet, stap dan over op een board met meer flash, zoals de Arduino Mega of een ESP32.

Hoeveel geheugen heeft de Arduino Uno?

De ATmega328P op de Arduino Uno heeft 32 KB flash (0,5 KB gereserveerd voor de bootloader), 2 KB SRAM en 1 KB EEPROM. Het programma komt in flash, variabelen in SRAM en blijvende instellingen in EEPROM. De meeste problemen ontstaan in die 2 KB SRAM.

Wat doet de F()-macro?

F() voorkomt dat constante strings die aan functies zoals Serial.print worden doorgegeven naar het RAM worden gekopieerd en houdt ze in flash. Op een Uno bespaart elk teken één byte RAM, wat in projecten met veel berichten oploopt tot honderden bytes. Het compileert ook op de ESP32 en Pico, maar heeft daar geen effect.

Hoe meet ik het vrije RAM op Arduino?

Op de Uno, Nano en Mega gebruik je een kleine functie die met de variabelen __heap_start en __brkval de afstand tussen de stack en de heap berekent. Op de ESP32 geven ESP.getFreeHeap() en ESP.getMinFreeHeap() dezelfde informatie, en in MicroPython gc.mem_free(). Het is belangrijk om te meten op het moment dat het geheugengebruik piekt.

Waarom is het gebruik van String op Arduino een probleem?

String-objecten vragen bij elke concatenatie nieuw geheugen aan de heap en geven het oude blok vrij, waardoor de kleine heap van de Uno na verloop van tijd fragmenteert. Zelfs als het totale vrije geheugen genoeg lijkt, kan er geen nieuw blok worden toegewezen en loopt het programma vast. Char-arrays met vaste grootte en snprintf nemen dit probleem helemaal weg.

Alle projecten bekijken