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.

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.
| Geheugen | Grootte op de Uno | Wat wordt opgeslagen? | Bij stroomverlies | Schrijfduurzaamheid |
|---|---|---|---|---|
| Flash | 32 KB (0,5 KB gereserveerd voor de bootloader, 32256 bytes bruikbaar) | Programmacode, PROGMEM-gegevens | Blijft behouden | Ongeveer 10.000 wis-/schrijfcycli |
| SRAM | 2 KB (2048 bytes) | Variabelen, arrays, stack en heap | Gaat verloren | Onbeperkt |
| EEPROM | 1 KB (1024 bytes) | Instellingen, tellers, kalibratie | Blijft behouden | Ongeveer 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
| Board | Flash (program) | SRAM | EEPROM |
|---|---|---|---|
| Arduino Uno R3 / Nano (ATmega328P) | 32 KB (Uno 32256, Nano 30720 bytes bruikbaar) | 2 KB | 1 KB |
| Arduino Leonardo / Pro Micro (ATmega32U4) | 32 KB (28672 bytes bruikbaar) | 2,5 KB | 1 KB |
| Arduino Mega 2560 | 256 KB (253952 bytes bruikbaar) | 8 KB | 4 KB |
| Arduino Uno R4 (RA4M1) | 256 KB | 32 KB | 8 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 flashchip | 264 KB | Geen; 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.
| Melding | Wanneer verschijnt die? | Wat betekent het? |
|---|---|---|
| Sketch uses ... bytes (x%) of program storage space | Bij elke build | Ruimte die de code in flash inneemt |
| Global variables use ... bytes (x%) of dynamic memory | Bij elke build | Aandeel RAM dat globale en statische variabelen gebruiken |
| Low memory available, stability problems may occur. | Wanneer globale variabelen meer dan ongeveer 75% van het RAM gebruiken | De 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 board | Wanneer het programma niet in flash past | De code kan niet worden geüpload; je moet het flashgebruik verkleinen |
| Not enough memory and data section exceeds available space in board | Wanneer globale variabelen het RAM overschrijden | De code kan niet worden geüpload; je moet het RAM-gebruik verkleinen |
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.
| Gebied | Inhoud | Groeirichting | Zichtbaar in de build-uitvoer? |
|---|---|---|---|
| .data | Geïnitialiseerde globale en statische variabelen, strings zonder F() | Vast | Ja |
| .bss | Niet-geïnitialiseerde (nul) globale en statische variabelen, bibliotheekbuffers | Vast | Ja |
| Heap | String, new, malloc, buffers die sommige bibliotheken in begin() toewijzen | Omhoog | Nee |
| Stack | Lokale variabelen, terugkeeradressen van functies, tijdens interrupts opgeslagen registers | Omlaag | Nee |
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() | 444 | 9 |
| Serial.begin(9600) | 1438 | 184 |
| + Serial.println("een tekst van 44 tekens") | 1518 | 232 |
| Dezelfde tekst met F() | 1530 | 188 |
| analogRead + Serial.println(int) | 1892 | 188 |
| float-berekening + Serial.println(float) | 3380 | 200 |
| String-concatenatie: "A0=" + String(analogRead(A0)) | 3316 | 202 |
| Dezelfde taak met snprintf en een char-array | 3232 | 194 |
| Eén schrijfactie met Wire (I2C) | 2476 | 225 |
| SD-kaart: begin, open, println, close | 10496 | 837 |
| int veri[700]-array | 1780 | 1588 (77%, waarschuwing Low memory) |
| int veri[950]-array | 1780 | 2088 (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:
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.
1// Mesaj listesi ve nota tablosu flaşta (PROGMEM)
2// Message list and note table kept in flash (PROGMEM)
3const char m0[] PROGMEM = "Sistem hazir";
4const char m1[] PROGMEM = "Sensor hatasi";
5const char m2[] PROGMEM = "Kapi acik";
6const char* const mesajlar[] PROGMEM = { m0, m1, m2 }; // işaretçi tablosu da flaşta / pointer table in flash too
7
8const uint16_t notalar[] PROGMEM = { 262, 294, 330, 349, 392, 440, 494, 523 }; // Do-Re-Mi ... Do (Hz)
9const byte BUZZER_PIN = 8;
10
11void setup() {
12 Serial.begin(9600);
13 char tampon[20]; // RAM'de tek ortak tampon / one shared RAM buffer
14 for (byte i = 0; i < 3; i++) {
15 strcpy_P(tampon, (const char*)pgm_read_ptr(&mesajlar[i])); // flaştan RAM'e kopyala / copy flash -> RAM
16 Serial.println(tampon);
17 }
18 for (byte i = 0; i < 8; i++) {
19 uint16_t frekans = pgm_read_word(¬alar[i]); // 2 baytlık değeri oku / read a 2-byte value
20 tone(BUZZER_PIN, frekans, 200);
21 delay(250);
22 }
23}
24
25void loop() {
26}| Functie / macro | Wat 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_float | Leest 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_P | Bepaalt de lengte van een string in flash, kopieert een blok uit flash |
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:
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
| Type | Uno (AVR) | ESP32 / Pico | Waardebereik (Uno) |
|---|---|---|---|
| bool, char, byte | 1 byte | 1 byte | byte: 0–255 |
| int | 2 bytes | 4 bytes | -32768 tot 32767 |
| unsigned int, uint16_t | 2 bytes | uint16_t 2, unsigned int 4 bytes | 0–65535 |
| long, unsigned long | 4 bytes | 4 bytes | unsigned long: 0–4.294.967.295 |
| float | 4 bytes | 4 bytes | Ongeveer 6–7 significante cijfers |
| double | 4 bytes (hetzelfde als float) | 8 bytes | Geen 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 / functie | RAM-kosten (Uno) | Wanneer wordt het toegewezen? | Lichtere optie |
|---|---|---|---|
| Serial | Ongeveer 175 bytes (buffers van 64 + 64 bytes) | Tijdens het compileren (globaal) | Verwijder Serial helemaal als je het niet nodig hebt |
| Wire (I2C) | Ongeveer 215 bytes | Tijdens het compileren (globaal) | Onvermijdelijk, zelfs met één I2C-apparaat; zoek de besparing elders |
| SoftwareSerial | Ongeveer 120 bytes (ontvangstbuffer van 64 bytes) | Tijdens het compileren (globaal) | Indien mogelijk de hardware-seriële poort, of de extra poorten van de Mega |
| SD | Ongeveer 830 bytes, plus ongeveer 10 KB flash | Tijdens het compileren (globaal) | Laat het loggen over aan een ESP32 of een Mega |
| Adafruit SSD1306 128x64 | Framebuffer van 1024 bytes | Uit de heap in begin() | U8g2-paginamodus (128 bytes) of U8x8 voor alleen tekst |
| Adafruit NeoPixel / FastLED | 3 bytes per led (60 leds = 180 bytes) | Bij het opstarten | Beperk 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.
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?.
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.
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?

| Situatie | Aanbeveling |
|---|---|
| Na F(), PROGMEM en char-arrays blijft het vrije RAM boven 300 bytes | Blijf 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 genoeg | Arduino Mega 2560: 4 keer zoveel RAM, dezelfde 5V-pinnen en bibliotheken |
| Het programma is groter dan 32 KB maar het RAM is genoeg | Mega of Uno R4: 256 KB flash |
| Je hebt Wi-Fi, een webserver, grote buffers of beeldverwerking nodig | ESP32: 520 KB RAM, 4 MB flash, Wi-Fi en Bluetooth |
| Je wilt in MicroPython werken | Raspberry Pi Pico of Pico W |
| Een kleine sensornode die maandenlang op batterijen moet draaien | Optimaliseer 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
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Sketch too big, code wordt niet geüpload | Het programma past niet in flash | Zet 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 vast | String-concatenaties fragmenteren de heap | Gebruik char-arrays en snprintf in plaats van String; meet het vrije RAM |
| Rommel in de Serial Monitor, variabelen veranderen vanzelf | De stack overschrijft de heap | Breng het globale RAM onder de 75%, verwijder grote lokale arrays |
| SSD1306 allocation failed | begin() kan de buffer van 1 KB niet toewijzen | Zet strings in F(), schakel over op de paginamodus van U8g2 |
| Het board reset willekeurig terwijl het geheugen in orde lijkt | Het kan een voedingsprobleem zijn in plaats van een geheugenprobleem | Voed motoren en relais apart, voeg een condensator toe |
| Array-elementen tonen onzinwaarden | Schrijven voorbij het einde van de array | Controleer de index; leid lusgrenzen af van sizeof |
| Stack canary watchpoint triggered op de ESP32 | De stack van een taak is overgelopen | Maak grote lokale arrays globaal of vergroot de taakstack |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
Turks volkslied met een buzzer
Druk op de knop en een kleine buzzer speelt noot voor noot het Turkse volkslied (İstiklal Marşı).

Temperatuur en luchtvochtigheid met DHT11
Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

Paddleballspel - SSD1306
Een bal, twee batjes en jij: op een klein OLED-scherm speel je tafeltennis, een van de allereerste videogames.

OLED T-Rex Run: Arduino-dinosaurusspel
Het dinosaurusspel dat verschijnt als je internet wegvalt, nu op je bureau: de dinosaurus rent over het kleine OLED-scherm, cactussen komen op je af en jij springt met één knop.

Pixelslang 8x8-matrix
Bouw het klassieke slangenspel zelf en speel het. Op een kleurrijke 8x8-lichtmatrix stuur je met een joystick een groene slang en eet je rode appels.

Arduino-geheugenspel (4 leds + 4 knoppen + buzzer)
Vertrouw je op je geheugen? Vier gekleurde leds lichten na elkaar op en spelen elk hun eigen toon; jij herhaalt dezelfde volgorde door op de knoppen te drukken.

Codeslot met 4x4-keypad en LCD
Een klein elektronisch deurslot dat iedereen buiten houdt die de code niet kent.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

