Ratgeber · 13 Min. Lesezeit

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.

Arduino-Uno-Board mit ATmega328P-Mikrocontroller
Der ATmega328P im Herzen des Arduino Uno: 32 KB Flash, 2 KB SRAM und 1 KB EEPROM. Die meisten Speicherprobleme entstehen in diesen 2 KB RAM.

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.

SpeicherGröße beim UnoWas wird gespeichert?Bei StromausfallSchreibzyklen
Flash32 KB (0,5 KB für den Bootloader, 32256 Byte nutzbar)Programmcode, PROGMEM-DatenBleibt erhaltenEtwa 10.000 Lösch-/Schreibzyklen
SRAM2 KB (2048 Byte)Variablen, Arrays, Stack und HeapGeht verlorenUnbegrenzt
EEPROM1 KB (1024 Byte)Einstellungen, Zähler, KalibrierungBleibt erhaltenEtwa 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

BoardFlash (Programm)SRAMEEPROM
Arduino Uno R3 / Nano (ATmega328P)32 KB (Uno 32256, Nano 30720 Byte nutzbar)2 KB1 KB
Arduino Leonardo / Pro Micro (ATmega32U4)32 KB (28672 Byte nutzbar)2,5 KB1 KB
Arduino Mega 2560256 KB (253952 Byte nutzbar)8 KB4 KB
Arduino Uno R4 (RA4M1)256 KB32 KB8 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-Chip264 KBKeins; 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.

MeldungWann erscheint sie?Was bedeutet sie?
Sketch uses ... bytes (x%) of program storage spaceBei jedem BuildPlatzbedarf des Codes im Flash
Global variables use ... bytes (x%) of dynamic memoryBei jedem BuildRAM-Anteil der globalen und statischen Variablen
Low memory available, stability problems may occur.Wenn globale Variablen etwa 75 % des RAM überschreitenDer Code wird hochgeladen, aber für Stack und Heap bleibt wenig Platz
Sketch too big und text section exceeds available space in boardWenn das Programm nicht in den Flash passtHochladen unmöglich; der Flash-Bedarf muss sinken
Not enough memory und data section exceeds available space in boardWenn globale Variablen den RAM überschreitenHochladen unmöglich; der RAM-Bedarf muss sinken
Die Warnung "Low memory" ist kein Fehler, und der Code wird anstandslos hochgeladen; genau darin liegt die Gefahr. Ein Sketch mit int veri[700]; belegt auf dem Uno zum Beispiel 1588 Byte (77 %) für globale Variablen und lässt Stack und Heap nur 460 Byte. Verbrauchen ein paar verschachtelte Funktionsaufrufe, eine String-Verkettung oder ein Puffer, den eine Bibliothek in begin() anlegt, diesen Platz, stürzt das Programm ab. Die Symptome sind zufällige Resets, beschädigte Variablen und Hänger; um sie von Stromversorgungsproblemen zu unterscheiden, lies auch Arduino startet ständig neu.

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.

BereichInhaltWachstumsrichtungIn der Build-Ausgabe sichtbar?
.dataInitialisierte globale und statische Variablen, Texte ohne F()FestJa
.bssNicht initialisierte (null) globale und statische Variablen, BibliothekspufferFestJa
HeapString, new, malloc, Puffer, die manche Bibliotheken in begin() anlegenNach obenNein
StackLokale Variablen, Rücksprungadressen, bei Interrupts gesicherte RegisterNach untenNein

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()4449
Serial.begin(9600)1438184
+ Serial.println("ein Text mit 44 Zeichen")1518232
Derselbe Text mit F()1530188
analogRead + Serial.println(int)1892188
float-Rechnung + Serial.println(float)3380200
String-Verkettung: "A0=" + String(analogRead(A0))3316202
Dieselbe Aufgabe mit snprintf und char-Array3232194
Ein einzelner Schreibvorgang mit Wire (I2C)2476225
SD-Karte: begin, open, println, close10496837
Array int veri[700]17801588 (77 %, Low-memory-Warnung)
Array int veri[950]17802088 (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:

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}

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.

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}
Funktion / MakroWas 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_floatLiest 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_PErmittelt die Länge eines Flash-Texts, kopiert einen Block aus dem Flash
Auf ESP32 und Pico bleiben als const deklarierte Arrays ohnehin im Flash; PROGMEM hat dort keine Wirkung, verursacht aber auch keinen Fehler, und die pgm_read_*-Funktionen sind definiert. Mit PROGMEM geschriebener Code kompiliert also auf allen drei Boards. Eine Ausnahme: Beim Lesen einer Zeigertabelle funktioniert pgm_read_word auf dem Uno, schneidet den Zeiger auf 32-Bit-Boards aber ab; für portablen Code nimmst du pgm_read_ptr.

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:

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}

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

TypUno (AVR)ESP32 / PicoWertebereich (Uno)
bool, char, byte1 Byte1 Bytebyte: 0–255
int2 Byte4 Byte-32768 bis 32767
unsigned int, uint16_t2 Byteuint16_t 2, unsigned int 4 Byte0–65535
long, unsigned long4 Byte4 Byteunsigned long: 0–4.294.967.295
float4 Byte4 ByteEtwa 6–7 signifikante Stellen
double4 Byte (wie float)8 ByteAuf 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 / FunktionRAM-Kosten (Uno)Wann reserviert?Leichtere Alternative
SerialEtwa 175 Byte (64 + 64 Byte Puffer)Beim Kompilieren (global)Serial ganz weglassen, wenn nicht nötig
Wire (I2C)Etwa 215 ByteBeim Kompilieren (global)Auch bei nur einem I2C-Gerät unvermeidbar; anderswo sparen
SoftwareSerialEtwa 120 Byte (64 Byte Empfangspuffer)Beim Kompilieren (global)Wenn möglich die Hardware-Schnittstelle oder die Zusatzports des Mega
SDEtwa 830 Byte, dazu etwa 10 KB FlashBeim Kompilieren (global)Das Loggen einem ESP32 oder Mega überlassen
Adafruit SSD1306 128x641024 Byte BildpufferAus dem Heap in begin()U8g2 im Seitenmodus (128 Byte) oder U8x8 nur für Text
Adafruit NeoPixel / FastLED3 Byte pro LED (60 LEDs = 180 Byte)Beim StartLED-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.
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}

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?.

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}

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.

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

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?

Arduino Mega 2560
Arduino Mega 2560: 256 KB Flash, 8 KB SRAM und 4 KB EEPROM. Uno-Code läuft darauf oft ganz ohne Änderungen.
SituationEmpfehlung
Nach F(), PROGMEM und char-Arrays bleiben über 300 Byte RAM freiBeim Uno bleiben; Problem gelöst
Mehrere Sensoren und ein Menü mit OLED oder SD-Karte, RAM reicht trotzdem nichtArduino Mega 2560: 4-facher RAM, dieselben 5-V-Pins und Bibliotheken
Das Programm ist größer als 32 KB, der RAM reichtMega oder Uno R4: 256 KB Flash
WLAN, Webserver, große Puffer oder Bildverarbeitung nötigESP32: 520 KB RAM, 4 MB Flash, WLAN und Bluetooth
Du willst mit MicroPython arbeitenRaspberry Pi Pico oder Pico W
Kleiner Sensorknoten, der monatelang mit Batterie laufen sollAuf 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

SymptomMögliche UrsacheLösung
Sketch too big, Code lässt sich nicht hochladenDas Programm passt nicht in den FlashDebug-Ausgaben abschalten, float und sprintf reduzieren, kleinere Bibliotheken, notfalls Mega
Code läuft, friert aber nach einigen Minuten einString-Verkettungen fragmentieren den Heapchar-Arrays und snprintf statt String; freien RAM messen
Wirre Zeichen im seriellen Monitor, Variablen ändern sich von selbstDer Stack überschreibt den HeapGlobalen RAM unter 75 % bringen, große lokale Arrays entfernen
SSD1306 allocation failedbegin() kann den 1-KB-Puffer nicht reservierenTexte in F() setzen, auf U8g2 im Seitenmodus wechseln
Das Board startet zufällig neu, obwohl der Speicher reichtEher ein Stromversorgungs- als ein SpeicherproblemMotoren und Relais separat versorgen, Kondensator ergänzen
Array-Elemente zeigen unsinnige WerteEs wird über das Array-Ende hinaus geschriebenIndex prüfen; Schleifengrenzen mit sizeof berechnen
Stack canary watchpoint triggered auf dem ESP32Der Stack eines Tasks ist übergelaufenGroße lokale Arrays global machen oder den Task-Stack vergrößern
Um Speicherproblemen von Anfang an vorzubeugen, notiere bei jedem neuen Modul die beiden Prozentwerte aus der Build-Ausgabe. Beginne mit F() und PROGMEM, sobald der globale RAM 60 % überschreitet; auf die 75-%-Warnung zu warten heißt, das Problem bis zu dem Moment aufzuschieben, in dem es am schwersten zu lösen ist.

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.

Alle Projekte ansehen
Türkische Nationalhymne mit Summer
AR-15Mittel

Türkische Nationalhymne mit Summer

Drückst du den Knopf, spielt ein kleiner Summer die türkische Nationalhymne, Note für Note.

4.8(114)
235
Temperatur und Luftfeuchtigkeit mit DHT11
AR-55Mittel

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…

4.7(47)
83
Paddle-Ball-Spiel - SSD1306
AR-86Mittel
Premium

Paddle-Ball-Spiel - SSD1306

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

4.5(47)
65
OLED T-Rex Run: Arduino Dinosaurier Spiel
AR-87Fortgeschritten
Premium

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…

4.7(33)
53
Pixel-Schlange 8x8 Matrix
AR-88Fortgeschritten
Premium

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…

4.7(39)
57
Arduino Gedächtnisspiel (4 LEDs + 4 Taster + Summer)
AR-93Fortgeschritten
Premium

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.

4.8(46)
69
Passwortschloss mit 4x4-Tastenfeld und LCD
AR-64Fortgeschritten
Premium

Passwortschloss mit 4x4-Tastenfeld und LCD

Ein kleines elektronisches Türschloss, das niemanden ohne den richtigen Code hereinlässt.

4.8(59)
75