Arduino Speicher voll: Sketch too big und Low Memory beheben
Arduino Speicher voll? Unterschied Flash, SRAM und EEPROM, F() und PROGMEM, char-Arrays statt String, freien RAM messen und wann sich Mega oder ESP32 lohnt.
Die Meldung, dass der Arduino Speicher voll ist, sagt dir, dass dein Programm oder deine Variablen nicht in den Speicher des Boards passen, und sie zeigt sich meist auf zwei Arten: Der Code lässt sich gar nicht hochladen, weil der Build mit Sketch too big abbricht, oder er wird nach der Warnung Low memory available, stability problems may occur hochgeladen und das Board startet danach zufällig neu, schreibt wirre Zeichen in den seriellen Monitor oder friert ein. Da der Arduino Uno nur 32 KB Programmspeicher und 2 KB RAM hat, tritt das Problem besonders oft in Projekten auf, die ein Display, eine SD-Karte und ein paar Sensoren kombinieren.
In dieser Anleitung siehst du zuerst den Unterschied zwischen Flash, SRAM und EEPROM und wie du die zwei Zeilen am Ende eines Builds liest. Anschließend lernst du anhand von Werten, die wir mit echten Builds auf einem Uno gemessen haben, welche Zeile wie viel Speicher frisst, wie du konstante Daten mit dem F()-Makro und PROGMEM aus dem RAM holst, warum char-Arrays besser sind als String, was Bibliotheken heimlich kosten und wie du den freien RAM zur Laufzeit misst. Im letzten Teil findest du, wie man den Speicher auf ESP32 und Raspberry Pi Pico überwacht und wann der Umstieg auf einen Mega oder ESP32 die richtige Entscheidung ist.

Die drei Speicher eines Arduino: Flash, SRAM und EEPROM
Im Mikrocontroller eines Arduino stecken drei Speicher mit völlig unterschiedlichen Aufgaben. Der Flash (Programmspeicher) enthält deinen kompilierten Code; er bleibt ohne Strom erhalten und wird nur beim Hochladen beschrieben. Im SRAM (Arbeitsspeicher) liegen Variablen, Funktionsaufrufe und temporäre Daten; er ist schnell, wird aber beim Ausschalten gelöscht. Das EEPROM ist ein kleiner Bereich für Daten, die dauerhaft bleiben, sich aber selten ändern, etwa Einstellungen und Kalibrierwerte. Auf AVR-Boards wie dem Uno liegen diese drei Speicher in getrennten Adressräumen (Harvard-Architektur). Dieses Detail erklärt, warum die F()- und PROGMEM-Techniken weiter unten nötig sind.
| Speicher | Größe beim Uno | Was wird gespeichert? | Bei Stromausfall | Schreibzyklen |
|---|---|---|---|---|
| Flash | 32 KB (0,5 KB für den Bootloader, 32256 Byte nutzbar) | Programmcode, PROGMEM-Daten | Bleibt erhalten | Etwa 10.000 Lösch-/Schreibzyklen |
| SRAM | 2 KB (2048 Byte) | Variablen, Arrays, Stack und Heap | Geht verloren | Unbegrenzt |
| EEPROM | 1 KB (1024 Byte) | Einstellungen, Zähler, Kalibrierung | Bleibt erhalten | Etwa 100.000 Schreibvorgänge pro Zelle |
Das EEPROM statt des RAM zu nutzen ist keine Lösung: Es ist langsam, und jede Zelle verträgt nur eine begrenzte Zahl von Schreibvorgängen. Schreibst du eine sich schnell ändernde Variable in jedem Durchlauf ins EEPROM, kannst du die Zelle innerhalb weniger Tage verschleißen. Wie man das EEPROM richtig nutzt, steht ausführlich im Artikel Arduino EEPROM verwenden.
Speichergrößen nach Board
| Board | Flash (Programm) | SRAM | EEPROM |
|---|---|---|---|
| Arduino Uno R3 / Nano (ATmega328P) | 32 KB (Uno 32256, Nano 30720 Byte nutzbar) | 2 KB | 1 KB |
| Arduino Leonardo / Pro Micro (ATmega32U4) | 32 KB (28672 Byte nutzbar) | 2,5 KB | 1 KB |
| Arduino Mega 2560 | 256 KB (253952 Byte nutzbar) | 8 KB | 4 KB |
| Arduino Uno R4 (RA4M1) | 256 KB | 32 KB | 8 KB (Daten-Flash) |
| ESP32 (WROOM) | 4-MB-Flash-Chip (Standard-App-Partition 1,25 MB) | 520 KB (etwa 300 KB Heap bleiben fürs Programm) | Keins; Preferences speichert im Flash |
| Raspberry Pi Pico (RP2040) | 2-MB-Flash-Chip | 264 KB | Keins; im Flash emuliert |
Der Unterschied ist riesig: Der ESP32 hat 260-mal so viel RAM wie der Uno, der Pico etwa 130-mal so viel. Deshalb sind Speichertricks, die auf dem Uno viel Mühe kosten, auf dem ESP32 oft unnötig. Trotzdem sind Uno, Nano und Pro Mini wegen ihres niedrigen Preises und ihrer Einfachheit die meistgenutzten Boards, und es lohnt sich für jeden Arduino-Nutzer, mit 2 KB auszukommen.
Die Build-Ausgabe lesen: Sketch uses und Global variables use
Am Ende jedes erfolgreichen Builds gibt die Arduino IDE zwei Zeilen aus. Kompilierst du einen Sketch mit leerem setup() und loop() für den Uno, siehst du Sketch uses 444 bytes (1%) of program storage space und Global variables use 9 bytes (0%) of dynamic memory, leaving 2039 bytes for local variables. Die erste Zeile zeigt den Platz des Programms im Flash, die zweite den RAM-Bedarf der globalen und statischen Variablen. Entscheidend ist: Die zweite Zeile zählt nur Variablen, deren Größe beim Kompilieren feststeht. Lokale Variablen der Funktionen (Stack) und zur Laufzeit mit String oder malloc reservierter Speicher (Heap) sind nicht enthalten. Der verbleibende Bereich "local variables" ist das, was sich beide teilen müssen.
| Meldung | Wann erscheint sie? | Was bedeutet sie? |
|---|---|---|
| Sketch uses ... bytes (x%) of program storage space | Bei jedem Build | Platzbedarf des Codes im Flash |
| Global variables use ... bytes (x%) of dynamic memory | Bei jedem Build | RAM-Anteil der globalen und statischen Variablen |
| Low memory available, stability problems may occur. | Wenn globale Variablen etwa 75 % des RAM überschreiten | Der Code wird hochgeladen, aber für Stack und Heap bleibt wenig Platz |
| Sketch too big und text section exceeds available space in board | Wenn das Programm nicht in den Flash passt | Hochladen unmöglich; der Flash-Bedarf muss sinken |
| Not enough memory und data section exceeds available space in board | Wenn globale Variablen den RAM überschreiten | Hochladen unmöglich; der RAM-Bedarf muss sinken |
Im SRAM: globale Variablen, Heap und Stack
Die 2048 Byte RAM des Uno sind in vier Bereiche geteilt. Ganz unten liegen globale Variablen mit Startwert (.data), darüber globale Variablen, die bei null beginnen (.bss); die Summe beider zeigt der Compiler in der Zeile "Global variables use". Danach folgt der Heap, der nach oben wächst: String-Objekte und mit new und malloc reservierter Speicher liegen hier. Vom oberen Ende des RAM wächst der Stack nach unten: Jeder Funktionsaufruf legt dort seine Rücksprungadresse und lokalen Variablen ab, und bei einem Interrupt werden dort Register gesichert. Treffen Heap und Stack im freien Bereich dazwischen aufeinander, überschreiben sie sich gegenseitig und das Programm verhält sich unvorhersehbar.
| Bereich | Inhalt | Wachstumsrichtung | In der Build-Ausgabe sichtbar? |
|---|---|---|---|
| .data | Initialisierte globale und statische Variablen, Texte ohne F() | Fest | Ja |
| .bss | Nicht initialisierte (null) globale und statische Variablen, Bibliothekspuffer | Fest | Ja |
| Heap | String, new, malloc, Puffer, die manche Bibliotheken in begin() anlegen | Nach oben | Nein |
| Stack | Lokale Variablen, Rücksprungadressen, bei Interrupts gesicherte Register | Nach unten | Nein |
Dieser Aufbau hat zwei wichtige Folgen. Erstens wird jeder Text ohne F() in den Bereich .data kopiert, weil der AVR-Prozessor Daten im Flash nicht wie eine gewöhnliche Variable lesen kann. Zweitens fragmentiert der Heap: Legst du Strings unterschiedlicher Größe an und löschst sie wieder, bleiben kleine Lücken zurück, und selbst wenn insgesamt genug frei scheint, lässt sich kein großer Block mehr reservieren. Deshalb ist es bei lange laufenden Programmen auf dem Uno am sichersten, den Heap möglichst gar nicht zu benutzen.
Erst messen: Welche Zeile kostet wie viel Speicher?
Der erste Schritt zur Lösung eines Speicherproblems ist Messen, nicht Raten. Jede Zeile der folgenden Tabelle ist die echte Ausgabe eines kleinen Sketches, der einzeln mit dem Arduino-AVR-Core 1.8.6 für den Arduino Uno kompiliert wurde. Je nach Bibliotheks- und Core-Version können sich die Werte um einige Byte ändern, die Verhältnisse bleiben aber immer gleich.
| Was steht im Sketch? | Flash (Byte) | Globaler RAM (Byte) |
|---|---|---|
| Leeres setup() und loop() | 444 | 9 |
| Serial.begin(9600) | 1438 | 184 |
| + Serial.println("ein Text mit 44 Zeichen") | 1518 | 232 |
| Derselbe Text mit F() | 1530 | 188 |
| analogRead + Serial.println(int) | 1892 | 188 |
| float-Rechnung + Serial.println(float) | 3380 | 200 |
| String-Verkettung: "A0=" + String(analogRead(A0)) | 3316 | 202 |
| Dieselbe Aufgabe mit snprintf und char-Array | 3232 | 194 |
| Ein einzelner Schreibvorgang mit Wire (I2C) | 2476 | 225 |
| SD-Karte: begin, open, println, close | 10496 | 837 |
| Array int veri[700] | 1780 | 1588 (77 %, Low-memory-Warnung) |
| Array int veri[950] | 1780 | 2088 (101 %, lässt sich nicht kompilieren) |
Die Lehren sind eindeutig. Schon Serial.begin() braucht 175 Byte RAM, weil die serielle Schnittstelle einen 64-Byte-Empfangs- und einen 64-Byte-Sendepuffer anlegt. Ein einziger Text mit 44 Zeichen kostet 44 Byte RAM; mit F() geschrieben, ist dieser RAM wieder frei. float fügt dem Flash etwa 1,5 KB Gleitkommacode hinzu. Die SD-Bibliothek allein verbraucht 10 KB Flash und etwa 830 Byte RAM; 40 % des Uno-RAM gehen für eine einzige Logdatei drauf. Der globale RAM des String-Beispiels wirkt klein, seine echten Kosten entstehen aber zur Laufzeit im Heap und tauchen in der Build-Ausgabe nie auf.
Das F()-Makro: konstante Texte raus aus dem RAM
Auf dem Uno liegt jeder Text in Anführungszeichen wie "Temperatur: " im Flash, wird beim Programmstart aber in den RAM kopiert und belegt dort dauerhaft Platz. Das Makro F() verhindert diese Kopie: Der Text bleibt im Flash, und Funktionen wie Serial.print lesen ihn Zeichen für Zeichen direkt aus dem Flash. F() funktioniert mit jedem Objekt, das von der Klasse Print abgeleitet ist, darunter Serial, LiquidCrystal, LiquidCrystal_I2C, Adafruit SSD1306 und SD-Dateien. In einem Projekt mit Menüs, Fehlermeldungen und Hilfetexten bringt allein das Ergänzen von F() oft einige hundert Byte RAM zurück. Der folgende Code zeigt den Unterschied und misst den freien RAM zur Laufzeit:
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}Die Funktion bosRam() berechnet den Abstand zwischen der aktuellen Spitze des Stacks und dem Ende des Heaps, also wie viele Byte noch frei sind, bevor sich beide treffen. Rufst du sie in loop() direkt nach einer Display-Aktualisierung oder einem SD-Schreibvorgang auf, erwischst du den ungünstigsten Moment. Eine praktische Regel: Lass den freien RAM auf dem Uno zur Laufzeit nicht unter 200–300 Byte sinken. F() funktioniert nicht mit Funktionen, die ein char* erwarten (strcmp, strcpy); dafür nutzt du die _P-Varianten und das Makro PSTR(), die du weiter unten siehst.
PROGMEM: große Tabellen im Flash halten
F() ist nur für Texte gedacht. Für große Arrays, die sich nie ändern, etwa Notenfolgen, Display-Symbole (Bitmaps), Zeichentabellen, Kalibrierkurven oder Meldungslisten, verwendest du das Schlüsselwort PROGMEM. Ein mit PROGMEM deklariertes Array wird nie in den RAM kopiert; zum Lesen brauchst du statt des normalen Array-Zugriffs spezielle Funktionen wie pgm_read_byte und pgm_read_word. Eine Melodie mit 100 Noten belegt mit Frequenz- und Dauertabelle zum Beispiel 400 Byte; das ist ein Fünftel des Uno-RAM, und PROGMEM verschiebt alles in den 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}| Funktion / Makro | Was macht sie? |
|---|---|
| pgm_read_byte(&array[i]) | Liest 1 Byte aus dem Flash (byte-, char-, uint8_t-Arrays, Bitmaps) |
| pgm_read_word(&array[i]) | Liest 2 Byte aus dem Flash (int, uint16_t; Noten- und Zahlentabellen auf dem Uno) |
| pgm_read_dword / pgm_read_float | Liest 4-Byte-Werte vom Typ long und float |
| pgm_read_ptr(&tabelle[i]) | Liest einen im Flash gespeicherten Zeiger (Texttabellen) |
| strcpy_P(ziel, quelle) | Kopiert einen Text aus dem Flash in einen RAM-Puffer |
| strcmp_P(ram_text, PSTR("...")) | Vergleicht einen Text im RAM mit einem Text im Flash |
| strlen_P / memcpy_P | Ermittelt die Länge eines Flash-Texts, kopiert einen Block aus dem Flash |
char-Arrays statt String verwenden
Die Klasse String von Arduino ist bequem, fordert aber bei jeder Verkettung (+) einen neuen Block vom Heap an und gibt den alten frei. Tausendfach wiederholt, durchlöchert das den winzigen Heap des Uno. Das Programm läuft stundenlang problemlos und friert dann plötzlich ein, und der Fehler ist sehr schwer zu finden. Die Lösung sind char-Arrays mit von vornherein bekannter Größe: Der Speicher wird einmal reserviert, fragmentiert nie, und der Verbrauch erscheint in der Build-Ausgabe. Der folgende Code liest Befehle aus dem seriellen Monitor ohne String und formatiert die Messung in eine einzige Zeile:
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}Drei Details im Code verdienen Aufmerksamkeit. snprintf kennt die Puffergröße und läuft deshalb selbst bei langem Text nie über das Array hinaus; sprintf bietet diesen Schutz nicht. Da die printf-Familie des AVR das Format %f standardmäßig nicht unterstützt, wird der float-Wert vorher mit dtostrf in Text umgewandelt. Und die Grenze des Befehlspuffers (konum < sizeof(komut) - 1) verhindert, dass eine lange Zeile einen anderen Speicherbereich überschreibt. Musst du String verwenden (manche Bibliotheken liefern einen zurück), reserviere den Platz wenigstens in setup() mit text.reserve(64) und deklariere den String global; das verringert die Fragmentierung erheblich.
Der richtige Datentyp und lokale Variablen
| Typ | Uno (AVR) | ESP32 / Pico | Wertebereich (Uno) |
|---|---|---|---|
| bool, char, byte | 1 Byte | 1 Byte | byte: 0–255 |
| int | 2 Byte | 4 Byte | -32768 bis 32767 |
| unsigned int, uint16_t | 2 Byte | uint16_t 2, unsigned int 4 Byte | 0–65535 |
| long, unsigned long | 4 Byte | 4 Byte | unsigned long: 0–4.294.967.295 |
| float | 4 Byte | 4 Byte | Etwa 6–7 signifikante Stellen |
| double | 4 Byte (wie float) | 8 Byte | Auf dem Uno kein Unterschied zu float |
- byte für kleine Zahlen: Für Pinnummern, Zähler und Prozentwerte zwischen 0 und 255 spart byte statt int ein Byte pro Variable und 200 Byte in einem Array mit 200 Elementen.
- const für Pinnummern: Konstanten wie const byte LED_PIN = 13; bettet der Compiler direkt in den Code ein und reserviert dafür keinen RAM.
- Ein/Aus-Zustände in Bits: Acht bool-Variablen belegen 8 Byte; speicherst du dieselbe Information mit bitRead und bitWrite in den Bits eines Bytes, reicht 1 Byte.
- Vorsicht bei großen lokalen Arrays: Ein char puffer[300]; innerhalb einer Funktion erscheint nicht in der Build-Ausgabe, belegt aber bei jedem Aufruf 300 Byte Stack. Mach große Puffer global, damit ihre Größe sichtbar ist.
- Rekursion vermeiden: Jede Funktion, die sich selbst aufruft, öffnet eine neue Ebene auf dem Stack; auf dem Uno können schon ein paar Dutzend Ebenen den RAM aufbrauchen.
- Große Strukturen per Referenz übergeben: Übergibst du ein struct als Wert, landet eine Kopie auf dem Stack; als Referenz wie const Einstellung& e wird nichts kopiert.
Die versteckten Speicherkosten von Bibliotheken
Geht einem Projekt plötzlich der Speicher aus, ist oft nicht dein Code schuld, sondern eine hinzugefügte Bibliothek. Manche Bibliotheken reservieren RAM schon beim Kompilieren (als globalen Puffer), andere holen ihn beim Aufruf von begin() aus dem Heap; im zweiten Fall sieht die Build-Ausgabe harmlos aus, doch zur Laufzeit geht der Speicher aus. Ein Teil der folgenden Werte stammt aus der Messtabelle oben, ein Teil aus den Puffergrößen der Bibliotheken:
| Bibliothek / Funktion | RAM-Kosten (Uno) | Wann reserviert? | Leichtere Alternative |
|---|---|---|---|
| Serial | Etwa 175 Byte (64 + 64 Byte Puffer) | Beim Kompilieren (global) | Serial ganz weglassen, wenn nicht nötig |
| Wire (I2C) | Etwa 215 Byte | Beim Kompilieren (global) | Auch bei nur einem I2C-Gerät unvermeidbar; anderswo sparen |
| SoftwareSerial | Etwa 120 Byte (64 Byte Empfangspuffer) | Beim Kompilieren (global) | Wenn möglich die Hardware-Schnittstelle oder die Zusatzports des Mega |
| SD | Etwa 830 Byte, dazu etwa 10 KB Flash | Beim Kompilieren (global) | Das Loggen einem ESP32 oder Mega überlassen |
| Adafruit SSD1306 128x64 | 1024 Byte Bildpuffer | Aus dem Heap in begin() | U8g2 im Seitenmodus (128 Byte) oder U8x8 nur für Text |
| Adafruit NeoPixel / FastLED | 3 Byte pro LED (60 LEDs = 180 Byte) | Beim Start | LED-Anzahl auf die echte Streifenlänge begrenzen |
Diese Tabelle erklärt, warum OLED-Display, SD-Karte und WLAN-Modul auf einem Uno gleichzeitig kaum möglich sind: Allein der SSD1306-Puffer und die SD-Bibliothek ergeben zusammen 1,8 KB, sodass von den 2 KB RAM fürs Programm fast nichts bleibt. Der Fehler SSD1306 allocation failed bei OLED-Displays ist genau diese fehlgeschlagene Heap-Reservierung; Lösungen findest du auch im Artikel OLED-Display SSD1306.
Sketch too big: Wege, den Flash-Bedarf zu senken
- Debug-Ausgaben abschalten: Während der Entwicklung eingefügte Serial.print-Zeilen kosten Flash und RAM. Mit dem DEBUG-Makro unten entfernst du sie alle aus dem Build, indem du eine einzige Zeile änderst.
- float und sprintf vermeiden: Wie die Messungen zeigen, fügt float etwa 1,5 KB und snprintf über 1 KB Code hinzu. Die Temperatur mal 10 als int zu speichern (235 statt 23,5 °C) reicht in den meisten Projekten.
- Wiederholten Code in Funktionen und Arrays umwandeln: Pinnummern in einem Array zu halten und in einer Schleife zu verarbeiten, statt für jede LED einen zehnzeiligen Block zu schreiben, verkürzt den Code spürbar.
- Kleinere Bibliothek wählen: Ohne Grafik belegen U8x8 oder LiquidCrystal_I2C viel weniger Platz als Bibliotheken auf Basis von Adafruit GFX. Statt einer ganzen Bibliothek für eine einzige Funktion kannst du diesen Teil auch selbst schreiben.
- Board-Einstellung prüfen: Die Arduino IDE berechnet die Grenze nach dem gewählten Board: 32256 Byte für den Uno, 30720 für den Nano (alter oder neuer Bootloader) und 28672 für den Leonardo. Ist das falsche Board gewählt, stimmen weder Grenze noch Pindefinitionen.
- Auf ein größeres Board wechseln: Passt es danach immer noch nicht, führt ein Mega (256 KB) oder ein ESP32 (1,25 MB und mehr) denselben Code mit kleinen Änderungen aus.
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}Mit DEBUG 1 belegt dieser Sketch auf dem Uno 2292 Byte Flash und 188 Byte RAM; mit DEBUG 0 verschwindet der Serial-Code komplett aus dem Build, und die Werte sinken auf 934 Byte Flash und 9 Byte RAM. Die 1,3 KB Flash und 179 Byte RAM Unterschied reichen oft, um einem fertigen Projekt eine neue Funktion hinzuzufügen.
Speicher auf dem ESP32 messen
Der ESP32 hat viel Speicher, aber nicht unbegrenzt. Beim Einschalten des WLAN werden einige Dutzend KB RAM belegt, mit Bluetooth zusammen können es fast 100 KB werden; auch Webserver, JSON-Dokumente und Bildpuffer füllen den Speicher schnell. Manche Module wie der ESP32-CAM haben zusätzlichen PSRAM (meist 4 MB), in den große Puffer ausgelagert werden. Passt deine Anwendung auf der Flash-Seite nicht in die Standardpartition von 1,25 MB, kommst du mit der Option "Huge APP" unter Partition Scheme im Menü Werkzeuge auf 3 MB. Die allgemeinen Eigenschaften des ESP32 findest du unter Was ist der 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}Die zwei wertvollsten Zahlen hier sind getMinFreeHeap und getMaxAllocHeap. Die erste nennt den niedrigsten freien Heap seit Programmstart, die zweite den größten Block, der am Stück reserviert werden kann. Zeigt der freie Heap 100 KB, der größte Block aber unter 10 KB, ist der Heap fragmentiert, und ein großer String oder ein JSON-Dokument lässt sich womöglich nicht anlegen. Auf dem ESP32 läuft loop() in einem eigenen Task mit 8 KB Stack; uxTaskGetStackHighWaterMark zeigt den nie benutzten Teil dieses Stacks, und sinkt er unter einige hundert Byte, droht der Fehler "Stack canary watchpoint triggered".
Speicher auf dem Raspberry Pi Pico und in MicroPython
Die 264 KB RAM des Pico sind im Vergleich zum Uno riesig, doch der MicroPython-Interpreter nutzt selbst einen Teil davon; deinem Programm bleiben meist rund 190 KB Heap. In MicroPython wird der Speicher von einem Garbage Collector verwaltet: Nicht mehr benutzte Objekte werden aufgeräumt, wenn gc.collect() aufgerufen wird oder der Speicher knapp wird. Ist der Speicher wirklich voll, erscheint MemoryError: memory allocation failed. Texte in Schleifen zu verketten, große Listen anzulegen und eine einzige sehr lange Codedatei sind die häufigsten Ursachen.
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]))Um in MicroPython Speicher zu sparen, legst du Puffer vorab mit bytearray an und verwendest sie in der Schleife wieder, definierst konstante Zahlen mit const(), wandelst große Module mit mpy-cross in vorkompilierte .mpy-Dateien um und rufst vor langen Aufgaben gc.collect() auf. Die Grundbefehle von MicroPython auf dem Pico findest du in MicroPython Grundlagen, die allgemeinen Eigenschaften des Boards unter Was ist der Raspberry Pi Pico?.
Wann lohnt sich der Umstieg auf Mega oder ESP32?

| Situation | Empfehlung |
|---|---|
| Nach F(), PROGMEM und char-Arrays bleiben über 300 Byte RAM frei | Beim Uno bleiben; Problem gelöst |
| Mehrere Sensoren und ein Menü mit OLED oder SD-Karte, RAM reicht trotzdem nicht | Arduino Mega 2560: 4-facher RAM, dieselben 5-V-Pins und Bibliotheken |
| Das Programm ist größer als 32 KB, der RAM reicht | Mega oder Uno R4: 256 KB Flash |
| WLAN, Webserver, große Puffer oder Bildverarbeitung nötig | ESP32: 520 KB RAM, 4 MB Flash, WLAN und Bluetooth |
| Du willst mit MicroPython arbeiten | Raspberry Pi Pico oder Pico W |
| Kleiner Sensorknoten, der monatelang mit Batterie laufen soll | Auf dem Uno optimieren oder einen Pro Mini nehmen; ein größeres Board braucht mehr Strom |
Beim Wechsel auf den Mega bleibt der Großteil deines Codes gleich; denk nur daran, dass I2C an den Pins 20 (SDA) und 21 (SCL) und SPI an den Pins 50–53 liegt. Beim Wechsel auf den ESP32 gibt es Unterschiede wie den 3,3-V-Logikpegel, andere Pinnummern und das 12-Bit-Ergebnis (0–4095) von analogRead. Welches Board zu dir passt, klärt der Vergleich Arduino oder ESP32; eine 5-V-freundliche Option mit viel mehr Speicher stellt der Artikel Arduino Uno R4 vor.
Häufige Fehler und ihre Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Sketch too big, Code lässt sich nicht hochladen | Das Programm passt nicht in den Flash | Debug-Ausgaben abschalten, float und sprintf reduzieren, kleinere Bibliotheken, notfalls Mega |
| Code läuft, friert aber nach einigen Minuten ein | String-Verkettungen fragmentieren den Heap | char-Arrays und snprintf statt String; freien RAM messen |
| Wirre Zeichen im seriellen Monitor, Variablen ändern sich von selbst | Der Stack überschreibt den Heap | Globalen RAM unter 75 % bringen, große lokale Arrays entfernen |
| SSD1306 allocation failed | begin() kann den 1-KB-Puffer nicht reservieren | Texte in F() setzen, auf U8g2 im Seitenmodus wechseln |
| Das Board startet zufällig neu, obwohl der Speicher reicht | Eher ein Stromversorgungs- als ein Speicherproblem | Motoren und Relais separat versorgen, Kondensator ergänzen |
| Array-Elemente zeigen unsinnige Werte | Es wird über das Array-Ende hinaus geschrieben | Index prüfen; Schleifengrenzen mit sizeof berechnen |
| Stack canary watchpoint triggered auf dem ESP32 | Der Stack eines Tasks ist übergelaufen | Große lokale Arrays global machen oder den Task-Stack vergrößern |
Wenn der Arduino-Speicher voll ist, lässt sich das meist ohne Boardwechsel lösen: Konstante Texte mit F() in den Flash, große Tabellen in PROGMEM, char-Arrays statt String und überflüssige Bibliotheken streichen verschaffen den 2 KB RAM erstaunlich viel Luft. In der BlueGrays-App findest du speicherhungrige Projekte wie OLED-Spiele, Summer-Melodien und LED-Matrix-Animationen mit Schritt-für-Schritt-Schaltplänen und Code, der mit diesen Techniken geschrieben ist.
Häufige Fragen
Was bedeutet Low memory available beim Arduino?
Die globalen Variablen belegen etwa 75 % des RAM, und für Stack und Heap bleibt wenig Platz. Der Code wird hochgeladen, doch zur Laufzeit können zufällige Resets, Hänger und beschädigte Variablen auftreten. Konstante Texte in F() zu setzen und große Arrays in PROGMEM zu verschieben, beseitigt die Warnung meistens.
Wie behebe ich den Fehler Sketch too big?
Der Fehler bedeutet, dass das Programm nicht in den Flash-Speicher passt. Schalte Serial-Ausgaben zum Debuggen ab, reduziere float und sprintf, fasse wiederholten Code in Funktionen zusammen und wähle kleinere Bibliotheken. Passt es dann immer noch nicht, wechsle auf ein Board mit mehr Flash wie den Arduino Mega oder einen ESP32.
Wie viel Speicher hat der Arduino Uno?
Der ATmega328P des Arduino Uno hat 32 KB Flash (0,5 KB davon für den Bootloader), 2 KB SRAM und 1 KB EEPROM. Das Programm landet im Flash, Variablen im SRAM und dauerhafte Einstellungen im EEPROM. Die meisten Probleme entstehen in den 2 KB SRAM.
Was macht das F()-Makro?
F() verhindert, dass konstante Texte für Funktionen wie Serial.print in den RAM kopiert werden, und hält sie im Flash. Auf dem Uno spart jedes Zeichen ein Byte RAM, bei vielen Meldungen kommen so Hunderte Byte zusammen. Auf ESP32 und Pico kompiliert es ebenfalls, hat dort aber keine Wirkung.
Wie misst man den freien RAM beim Arduino?
Auf Uno, Nano und Mega nutzt man eine kleine Funktion, die mit den Variablen __heap_start und __brkval den Abstand zwischen Stack und Heap berechnet. Auf dem ESP32 liefern ESP.getFreeHeap() und ESP.getMinFreeHeap() dieselbe Information, in MicroPython gc.mem_free(). Wichtig ist, im Moment der höchsten Speicherauslastung zu messen.
Warum ist String beim Arduino ein Problem?
String-Objekte fordern bei jeder Verkettung neuen Speicher vom Heap an und geben den alten frei, sodass der kleine Heap des Uno mit der Zeit fragmentiert. Selbst wenn insgesamt genug frei scheint, lässt sich kein neuer Block reservieren und das Programm friert ein. char-Arrays fester Größe und snprintf beseitigen dieses Problem vollständig.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Türkische Nationalhymne mit Summer
Drückst du den Knopf, spielt ein kleiner Summer die türkische Nationalhymne, Note für Note.

Temperatur und Luftfeuchtigkeit mit DHT11
Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

Paddle-Ball-Spiel - SSD1306
Ein Ball, zwei Schläger und du: Du spielst Tischtennis, eines der allerersten Videospiele, auf einem kleinen OLED-Display.

OLED T-Rex Run: Arduino Dinosaurier Spiel
Das Dinosaurierspiel, das erscheint, wenn das Internet weg ist, jetzt auf deinem Schreibtisch: Der Dino rennt über das kleine OLED-Display, Kakteen kommen auf ihn zu, und du springst mit einem…

Pixel-Schlange 8x8 Matrix
Bau das klassische Schlangenspiel selbst und spiel es. Auf einer bunten 8x8-Lichtmatrix steuerst du eine grüne Schlange mit dem Joystick und frisst rote Äpfel; mit jedem Apfel wird die Schlange…

Arduino Gedächtnisspiel (4 LEDs + 4 Taster + Summer)
Vertraust du deinem Gedächtnis? Vier bunte LEDs leuchten nacheinander auf, jede mit ihrem eigenen Ton, und du wiederholst die Reihenfolge mit den Tastern.

Passwortschloss mit 4x4-Tastenfeld und LCD
Ein kleines elektronisches Türschloss, das niemanden ohne den richtigen Code hereinlässt.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

