ESP32 Partitionen, sichtbare und unsichtbare einfach erklärt

Der ESP32 besitzt mehrere Speicherbereiche, die klar voneinander getrennt sind – für Code, Dateien, Einstellungen und Platz für OTA‑Updates. Diese Aufteilung entscheidet darüber, ob dein Projekt problemlos läuft oder beim Kompilieren scheitert.
Dieser Artikel erklärt dir kompakt und praxisnah, wie Partitionstabellen funktionieren, welche Layouts sinnvoll sind und warum LittleFS heute das Dateisystem deiner Wahl sein sollte.

1. Was genau ist eine Partitionstabelle?

Stellt euch die 4 MB Flash-Speicher eures ESP32 wie einen großen, leeren Kleiderschrank vor. Wenn wir da jetzt einfach unseren Programmcode, ein paar Bilder für einen Webserver und unser WLAN-Passwort wild auf einen Haufen werfen, findet der Controller später nichts mehr wieder. Es gäbe ein heilloses Chaos.
Damit Ordnung herrscht, wird dieser Schrank in verschiedene Fächer (Partitionen) unterteilt. Jedes Fach bekommt eine feste Größe und darf nur für einen ganz bestimmten Zweck genutzt werden. Der Bauplan für diese Fächer ist die sogenannte Partitionstabelle.

Der tiefe Blick unter die Motorhaube: Die versteckten System-Partitionen

Bevor wir uns anschauen, an welchen Schrauben wir selbst drehen können, müssen wir uns die „ungeschminkte Wahrheit“ des ESP32 ansehen. Wenn ihr in der Arduino IDE ein Layout auswählt, wird euch nämlich nicht der gesamte Speicher gezeigt. Die Entwickler verstecken ganz bewusst einige Fächer vor uns, damit wir sie nicht aus Versehen löschen.

Wer den Speicher aber mal mit Profi-Tools wie ESPConnect oder esptool komplett ausliest, sieht, dass ganz am Anfang des Speichers diese drei lebenswichtigen System-Fächer liegen:

• Bootloader (Startadresse 0x0):
  Das ist der Anlasser eures ESP32. Man kann es sich vorstellen wie das BIOS (Basic Input/Output System) bei einem klassischen Computer. Wenn der ESP32 Strom bekommt, schaut er als allererstes auf die Adresse Null. Dieses winzige Programm (oft 32 KB groß) weckt die Hardware auf und sucht dann nach dem Inhaltsverzeichnis, um zu wissen, wo euer eigentliches Programm liegt.

• Partition Table (Startadresse 0x8000):
  Das ist unser Inhaltsverzeichnis! Die Information, wo welches Fach im Schrank beginnt und wie groß es ist, muss natürlich auch auf dem Chip gespeichert werden. Das passiert genau hier.

• phy_init (Meistens bei Startadresse 0xF000 wenn 4 MB Flash):
  In diesem kleinen Bereich liegen die Kalibrierungsdaten für den Funk-Chip. Der ESP32 muss genau wissen, wie er seine internen Antennen ansteuern muss, damit WLAN (Wireless Local Area Network) und Bluetooth sauber funktionieren.

Hätten wir Bastler Zugriff auf diese Fächer und würden sie versehentlich überschreiben, wüsste der kleine Chip beim nächsten Start nicht mehr, was er tun soll. Er wäre dann „gebrickt“ (nutzlos wie ein Ziegelstein).

Jetzt, wo wir wissen, dass das Fundament sicher gegossen ist, schauen wir uns den restlichen Platz an. Das sind die Fächer, die wir in unseren Projekten wirklich nutzen und deren Größe wir selbst bestimmen können.
Bei den meisten unserer Projekte gibt es vier Haupt-Fächer:

• App (Das Programm-Fach): Hier landet der reine Programmcode, den wir selbst getippt haben.
• LittleFS (Das Datei-Fach): Hier können wir Dateien wie auf einem kleinen USB-Stick (Universal Serial Bus) ablegen. Zum Beispiel HTML-Seiten (Hypertext Markup Language – für Webseiten), CSS-Dateien (Cascading Style Sheets – für das Design) oder Bilder.
• NVS (Das Notiz-Fach): NVS bedeutet Non-Volatile Storage (nicht-flüchtiger Speicher). Das Fach ist winzig klein, merkt sich aber Dinge dauerhaft, auch ohne Strom. Zum Beispiel die SSID (Service Set Identifier – der Name eures WLANs) und das dazugehörige Passwort.
• OTA (Das Update-Fach): OTA heißt Over-The-Air (über die Luft). Wenn wir unser fertiges Projekt später bequem über das WLAN (Wireless Local Area Network) updaten wollen, ohne ein Kabel anzuschließen, brauchen wir dieses Fach.

Beispiel: Partitionsvorgaben in der Arduino IDE

In der Arduino IDE (der integrierten Entwicklungsumgebung) haben es uns die Entwickler glücklicherweise sehr einfach gemacht. Wir müssen keine komplizierten Textdateien schreiben, um den Flash-Speicher unseres ESP32 aufzuteilen.

Sobald ihr euer ESP32-Board in der Software ausgewählt habt, klickt ihr oben im Menü einfach auf Werkzeuge -> Partition Scheme. Dort klappt eine ganze Liste mit fertigen Vorgaben (Presets) auf. Hier sind die vier wichtigsten Auswahlmöglichkeiten, die ihr für eure Projekte kennen solltet:

2. Warum gibt es verschiedene Aufteilungen?

• Default 4MB with spiffs (1.2MB APP/1.5MB SPIFFS)
  • Was es ist: Unser Allrounder und die Standard-Einstellung.
  • Die Aufteilung: 1,2 MB für euren Programmcode, 1,2 MB als Reserve für WLAN-Updates (OTA – Over-The-Air) und 1,5 MB für eure Dateien (wie Webseiten oder Bilder).
  • Wann nutzen? Für 90 % eurer Projekte. Perfekt für einen Webserver, den ihr später bequem vom PC aus updaten möchtet, ohne das Gerät aufschrauben zu müssen.
• Huge APP (3MB No OTA/1MB SPIFFS)
  • Was es ist: Der Retter für riesigen Programmcode.
  • Die Aufteilung: Gigantische 3 MB für euer Programm, 0 MB für OTA und 1 MB für Dateien.
  • Wann nutzen? Wenn ihr enorm viele Bibliotheken (Libraries) einbindet, zum Beispiel für Displays oder komplexe Berechnungen. Der Kompromiss: Ihr opfert hier komplett die Möglichkeit, das Gerät über WLAN zu updaten! Ihr müsst also immer das USB-Kabel anschließen.
• No OTA (2MB APP/2MB SPIFFS)
  • Was es ist: Die große Daten-Festplatte.
  • Die Aufteilung: 2 MB für das Programm, 0 MB für OTA-Updates und satte 2 MB für den Dateispeicher.
  • Wann nutzen? Wenn ihr einen reinen Datensammler baut (z. B. um Temperaturwerte über ein ganzes Jahr zu protokollieren) oder sehr viele Grafiken lokal speichern wollt. Auch hier entfällt das WLAN-Update.
• Minimal SPIFFS (1.9MB APP with OTA/190KB SPIFFS)
  • Was es ist: Viel Programmcode, aber mit Update-Funktion.
  • Die Aufteilung: Knapp 2 MB für euer Programm, Platz für OTA-Updates, aber dafür ein winziges Datei-Fach (nur 190 Kilobyte).
  • Wann nutzen? Wenn euer Code zu groß für den Standard ist, ihr aber unbedingt WLAN-Updates braucht und eh kaum Dateien speichern müsst.

Hinweis für die Praxis: Auch wenn in diesem Menü noch der veraltete Begriff „SPIFFS“ steht, richtet die Arduino IDE damit einfach nur das Datei-Fach in der gewünschten Größe ein. Wenn ihr in eurem Code dann, wie von mir empfohlen, die Bibliothek LittleFS.h nutzt, wird dieser Platz völlig automatisch mit dem modernen und sicheren LittleFS-Dateisystem beschrieben! Lasst euch von dem Namen im Menü also nicht verwirren.

3. Was ist mit ESP32-Boards mit 8 MB oder 16 MB?

Auf dem Markt gibt es auch Modelle (wie ESP32-WROVER oder neuere ESP32-S3 Boards) mit 8 MB oder satten 16 MB Flash-Speicher. Um im Bild zu bleiben: Hier kauft ihr einfach einen deutlich größeren Schrank!
Wählt ihr so ein Board in der Software aus, schaltet die IDE neue Layouts frei. Bei 16 MB könnt ihr beispielsweise 3 MB für extrem lange Programme reservieren und habt gigantische 9 MB oder mehr nur für eure Dateien übrig. Für so riesige Fächer nutzt der Controller dann oft das FAT-Dateisystem (File Allocation Table – bekannt von PC-Laufwerken). Das ist perfekt für datenhungrige Projekte mit großen Displays.

4. Wichtig: Warum SPIFFS veraltet ist (und wir LittleFS nutzen)

Wenn ihr ältere Tutorials lest, stolpert ihr beim Datei-Fach oft über den Begriff SPIFFS (Serial Peripheral Interface Flash File System). Das war lange Zeit der absolute Standard, aber es gibt eine wichtige Regel für alle neuen Projekte: SPIFFS ist veraltet!
Es wird von den Entwicklern nicht mehr weiterentwickelt. SPIFFS kannte keine echten Ordnerstrukturen (es hat sie nur simuliert) und war sehr anfällig für Datenverlust bei plötzlichen Stromausfällen.
Der moderne, offizielle Nachfolger heißt LittleFS (das kleine Dateisystem).

• Es unterstützt echte Ordner.
• Es ist extrem robust gegen Stromausfälle (Crash-resistent).
• Es besitzt einen intelligenten Verschleißausgleich (Wear Leveling), der den Flash-Speicher schont und seine Lebensdauer erhöht.
  Nutzt also ab sofort immer LittleFS!
• Unter Werkzeuge -> Partition Scheme steht zum Beispiel weiterhin „Default 4MB with spiffs“
  Verwendet ihr nun
  #include "LittleFS.h"
LittleFS.begin(true)
  im Code, ignorieren die meisten der ESP32 den Reservierten Platz mit Bezeichnung Spiff! In diesem Fall nehmen sie sich einfach den reservierten Platz und formatiert ihn blitzsauber mit dem modernen LittleFS-Dateisystem.

5. Profi-Tipp: Die Partitionstabelle selbst auslesen

Wenn ihr wirklich verstehen wollt, was auf dem Chip passiert, können wir den Bauplan direkt vom ESP32 herunterladen. Dazu nutzen wir das Kommandozeilen-Programm esptool, vom Hersteller Espressif selbst.

Schritt 1: Wir lesen den Speicher ab der Adresse 0x8000 (dort liegt die Tabelle) mit einer Größe von 0xC00 (das sind 3 KB bzw. Kilobyte) im Hexadezimalsystem (Zahlensystem zur Basis 16) aus. Öffnet euer Terminal und gebt ein:

esptool –port COM3 read_flash 0x8000 0xC00 meine_tabelle.bin

(Ersetzt COM3 durch euren echten USB-Anschluss).

Schritt 2: Da die Datei meine_tabelle.bin nun ein unlesbares Binär-Wirrwarr ist, übersetzen wir sie mit einem kleinen Python-Skript, das die Entwicklungsumgebungen mitliefern:

python gen_esp32part.py meine_tabelle.bin

und wenn gen_esp32part.py nicht gleich gefunden wird dann

python C:\Users\username\.platformio\packages\framework-arduinoespressif32\tools\gen_esp32part.py meine_tabelle.bin

Das Ergebnis im Terminal ist eine saubere, lesbare Liste eurer exakten Fächer, ihrer Startadressen und Größen! Alternative wie schon erwähnt: ESPConnect (Bild 2)

6. Praxis: So nutzt ihr LittleFS in der Arduino IDE

Der Wechsel von SPIFFS zu LittleFS im Code ist kinderleicht. Hier ist ein minimalistischer Sketch, der eine Datei erstellt, beschreibt und wieder ausliest:

#include "LittleFS.h" // Das neue Dateisystem einbinden!

void setup() {
  Serial.begin(115200);
  Serial.println("\n--- ESP32 LittleFS Test startet ---");

  // Das "true" formatiert den Speicher automatisch, falls er noch leer ist
  if (!LittleFS.begin(true)) {
    Serial.println("Fehler beim Mounten (Einbinden) von LittleFS.");
    return;
  }

  // 1. Datei zum Schreiben öffnen
  File file = LittleFS.open("/hallo.txt", FILE_WRITE);
  if (!file) {
    Serial.println("Fehler beim Öffnen.");
    return;
  }

  // 2. Text speichern und Datei sauber schließen
  file.print("Hallo von Prilchen Labs! Ich liege im LittleFS-Speicher.");
  file.close();

  // 3. Datei zum Lesen erneut öffnen
  file = LittleFS.open("/hallo.txt");

  // 4. Inhalt Zeichen für Zeichen ausgeben
  Serial.println("Inhalt:");
  while (file.available()) {
    Serial.write(file.read()); 
  }
  file.close();
}

void loop() {}

7. Praxis: LittleFS in VS Code (PlatformIO) nutzen

Werden die Projekte komplexer, empfehle ich oft den Wechsel zum Editor VS Code (Visual Studio Code) mit der Erweiterung PlatformIO. Hier funktioniert das Einstellen des Dateisystems etwas anders.
Der Bauplan:
Wir haben kein Aufklapp-Menü, sondern die Konfigurationsdatei platformio.ini. Dort fügen wir einfach zwei Zeilen hinzu, um unser Layout (z. B. eine vorkonfigurierte CSV-Datei, Comma-Separated Values) und das Dateisystem zu definieren:

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
board_build.partitions = default.csv 
board_build.filesystem = littlefs

Dateien hochladen:

1. Erstellt im Hauptordner eures Projekts (neben der platformio.ini) einen Ordner namens data und legt dort eure HTML-Dateien oder Bilder ab.
2. Klickt links auf das Alien-Logo von PlatformIO.
3. Öffnet unter Project Tasks -> esp32dev -> Platform den Punkt Build Filesystem Image. PlatformIO packt die Dateien nun zusammen.
4. Klickt danach auf Upload Filesystem Image. Die Daten werden in das Datei-Fach eures ESP32 geschrieben.
5. Erst danach ladet ihr über den normalen Upload-Pfeil euer eigentliches Programm hoch.
   Das war ein tiefer Einblick in den Maschinenraum des ESP32. Wenn die IDE beim Kompilieren das nächste Mal meckert, wisst ihr jetzt genau, an welchen Stellschrauben ihr drehen müsst. Lasst das alte SPIFFS ruhen und setzt auf LittleFS.
   Wenn noch Fragen offen sind, haut sie gerne in die Kommentare.
   Bis dahin: Frohes Tüfteln!
   Euer Prilchen

Und wie ist die Partitionierung beim klassischen Arduino?

Ein klassischer Arduino (wie der Uno oder Nano mit einem AVR-Chip wie dem ATmega328P) besitzt so etwas wie eine flexible Partitionstabelle überhaupt nicht.

Warum gibt es beim Arduino keine Partitionen?

Der ESP32 hat einen riesigen Allzweck-Flash-Speicher, den wir per Software (durch unsere .csv-Baupläne) in verschiedene Fächer unterteilen.

Ein klassischer Arduino nutzt hingegen eine völlig andere innere Hardware-Architektur (die sogenannte Harvard-Architektur). Hier sind die verschiedenen Speicherbereiche keine Software-Einstellung, sondern physikalisch komplett getrennte Bauteile im Inneren des Mikrocontrollers. Der Schrank ist hier also schon ab Werk aus massivem Holz fest verleimt, da lässt sich keine Trennwand mehr verschieben.

Beim Arduino Uno sieht dieser fest zementierte Bauplan so aus:

• Flash-Speicher (Der Programmspeicher): Das ist der feste Ort, an dem ausschließlich euer geschriebener Code landet. Beim Uno sind das exakt 32 KB (Kilobyte). Ein winziger Teil davon (meist 0,5 KB) ist fest für den Bootloader (das Startprogramm) reserviert, der Rest ist für euren Sketch. Ein flexibler Bereich für Dateien (wie das LittleFS-Dateisystem) oder gar Platz für OTA-Updates (Over-The-Air, also über WLAN) ist hier hardwareseitig gar nicht vorgesehen.
• SRAM (Der Arbeitsspeicher): SRAM steht für Static Random Access Memory. Das ist der flüchtige „Schreibtisch“, auf dem der Arduino seine Berechnungen durchführt und Variablen ablegt, solange das Programm läuft. Beim Uno ist dieser Schreibtisch winzige 2 KB groß. Zieht ihr den Stecker, ist der SRAM sofort leer.
• EEPROM (Das feste Notizbuch): EEPROM steht für Electrically Erasable Programmable Read-Only Memory. Das ist das Gegenstück zu unserem winzigen NVS-Fach beim ESP32. Das EEPROM ist ein spezieller, langsamer Speicherbaustein, der seine Daten auch ohne Strom behält. Beim Uno habt ihr hier genau 1 KB Platz, um euch kleine Dinge wie Kalibrierungswerte von Sensoren oder Status-Informationen dauerhaft zu merken.

Fazit für den Wechsel zum ESP32

Beim klassischen Arduino müsst ihr euch also nie den Kopf über Partitionen zerbrechen. Ihr schreibt euren Code, und wenn die 32 KB Flash voll sind, ist das Gerät voll.

Erst beim Umstieg auf den deutlich mächtigeren ESP32 bekommt ihr diesen riesigen, leeren Schrank hingestellt, in den ihr dank der Partitionstabelle eure Fächer für riesige Programme, Dateisysteme und WLAN-Updates völlig frei nach euren Wünschen einbauen könnt!