ESP32-Partitionstabelle erklärt: Flash-Layout und OTA
Was die ESP32-Partitionstabelle ist, wie die Spalten der partitions.csv funktionieren, die Arduino-ESP32-Schemata mit Größen und was N16R8 bedeutet.
- Autor
Mauro Brambilla- Veroffentlicht
- Lesezeit
- 9 Min.
- Kategorie
- Anleitungen

Kurz gesagt
Die ESP32-Partitionstabelle liegt bei 0x8000 und teilt den Flash in nvs, otadata, App und Dateisystem. Die huge_app.csv von OpenGizmo gibt einen App-Slot mit 3 MB und kein OTA.
Die ESP32-Partitionstabelle ist eine kleine Karte im Flash bei Offset 0x8000, die dem Bootloader sagt, wo App, Einstellungsspeicher (nvs), OTA-Daten und Dateisystem liegen. Du legst sie mit einer partitions.csv fest oder mit einem eingebauten Schema wie default.csv oder huge_app.csv. Reicht die Tabelle über die echte Flash-Größe hinaus, warnt die esptool-Dokumentation von Espressif, dass der Chip nicht richtig funktioniert.
Dieser Guide liest die Karte so, wie es der Chip tut: die CSV-Spalten, die Arduino-ESP32-Schemata mit ihren Größen in KB, warum der Bootloader-Offset je nach Chip anders ist und was N16R8 im Modulnamen für dein Layout bedeutet. Das echte Beispiel ist der Gizmo Ticker: Ich habe die release-partitions.bin dekodiert, die sein Flasher schreibt, und sie mit der Dokumentation von Espressif und den CSV-Dateien von Arduino-ESP32 abgeglichen.
Was ist die ESP32-Partitionstabelle?
Eine Partitionstabelle teilt den externen Flash-Chip in benannte Bereiche mit Typ, Offset und Größe auf. Der Partitionstabellen-Guide von Espressif sagt, dass sie standardmäßig bei 0x8000 geflasht wird, einen 4-KB-Sektor belegt und 0xC00 Bytes lang ist, weil sie höchstens 95 Einträge zulässt, gefolgt von einer MD5-Prüfsumme, mit der der Bootloader ihre Integrität prüft.

Der Bootloader ist das erste Programm, das aus dem Flash läuft. Die Bootloader-Seite von ESP-IDF listet seine Aufgaben auf: anhand der Partitionstabelle und, falls vorhanden, von ota_data die App-Partition zum Booten wählen, das Image in den RAM laden und die Kontrolle übergeben. Die Tabelle ist also keine Einstellung in deiner App, sondern eine Datei im Flash, die schon vor deinem Code da ist.
Eine typische Tabelle enthält vier Arten von Partitionen:
- nvs: Schlüssel-Wert-Speicher für Einstellungen und WLAN-Daten, genutzt von der Preferences-Bibliothek
- otadata: merkt sich, welcher OTA-App-Slot gebootet wird, 0x2000 Bytes
- App-Slots (factory, ota_0, ota_1): die Firmware-Images
- Datenpartitionen wie spiffs oder coredump: ein Dateisystem, Absturz-Dumps oder deine eigenen Bytes

Wie sieht eine partitions.csv aus?
Die CSV hat sechs Spalten: name, type, subtype, offset, size und flags. Leerraum wird ignoriert, Zeilen mit # am Anfang sind Kommentare, und Größen dürfen hexadezimal, dezimal oder mit K und M stehen. Ein Name ist höchstens 16 Bytes lang, inklusive Terminator. Hier die echte Tabelle aller OpenGizmo-Firmwares, aus dem huge_app.csv des Arduino-ESP32-Cores, gelesen am 14. November 2026 (die Kommentarzeile mit den Spaltennamen fehlt hier):
nvs, data, nvs, 0x9000, 0x5000,
otadata, data, ota, 0xe000, 0x2000,
app0, app, ota_0, 0x10000, 0x300000,
spiffs, data, spiffs, 0x310000,0xE0000,
coredump, data, coredump,0x3F0000,0x10000,Drei Regeln erklären die meisten Zahlen, alle aus dem ESP-IDF-Guide. Offsets sind Vielfache von 4 KB (0x1000), der Sektorgröße des Flashs. Eine app-Partition muss bei einem Vielfachen von 64 KB (0x10000) beginnen. Deshalb liegt die erste App bei 0x10000, und der Bereich von 0x9000 bis 0xFFFF davor enthält nur kleine Datenpartitionen. Und lässt du einen Offset leer, beginnt die Partition direkt nach der vorherigen, App-Partitionen werden dabei für dich ausgerichtet.
Bootloader und Bibliotheken suchen nach Typ und Subtyp, nicht nach dem Namen. Laut demselben Guide ist die standardmäßige nvs-Partition die mit Typ data und Subtyp nvs, und otadata hat den Subtyp ota. Die binäre Tabelle, die der Flasher schreibt, speichert sie als Zahlen. Ich habe die ausgelieferte Datei mit ein paar Zeilen Python dekodiert: nvs ist data/0x02, otadata ist data/0x00, app0 ist app/0x10 (ota_0), spiffs ist data/0x82 und coredump ist data/0x03.
Welche Partitionstabelle nutzen die OpenGizmo-Firmwares?
Alle drei setzen in der platformio.ini board_build.partitions = huge_app.csv, zum Beispiel in der Datei des Tickers, mit dem Kommentar "One 3 MB app slot (no wireless updates), the same in every OpenGizmo firmware". Die release-partitions.bin-Dateien des Tickers v1.2.0, des Reolink Switch v1.2.0 und der Camera v1.0.0, wie sie am 14. November 2026 vom CDN geliefert wurden, sind Byte für Byte identisch (3.072 Bytes) und lassen sich genau in die CSV oben dekodieren.
Was heißt das für die Hardware?
- Ein App-Slot, kein OTA. Es gibt einen einzigen
ota_0-Slot mit 3 MB (3.072 KB) und keinen zweiten, ein neues Image hat also keinen Platz, solange das alte läuft. Der Vergleich der OTA-Methoden erklärt, warum das WLAN-Updates ausschließt, und vergleicht die Slot-Größen mit der echten App. - Luft nach oben. Die Ticker-App v1.2.0 ist 1.796.736 Bytes groß, etwa 57 % des Slots. Die App des Reolink Switch hat 1.778.336 Bytes und die der Camera 1.722.192 Bytes, entnommen aus den Größen der Release-Dateien.
- Einstellungen sind sicher. Die Preferences-Bibliothek speichert Daten in der NVS-Partition, und die
storage.cppvon Ticker und Reolink Switch nutzen beide Preferences. Der Flasher schreibt Bootloader, Tabelle,boot_app0und App, und nichts davon überlappt 0x9000 bis 0xDFFF, wie der Guide zum Flashen im Browser beschreibt. - Ein ungenutztes Dateisystem. Die 896 KB große
spiffs-Partition ist deklariert, aber eine Suche nachLittleFS,SPIFFSundspiffsin denmicrocontroller/-Quellen aller drei Firmwares findet nichts. Die gemeinsame Bibliothekgizmo-commondeckt diese Suche nicht ab. In die 64 KB großecoredump-Partition schreibt die Core-Dump-Funktion von ESP-IDF Absturzdaten. Ob diese Firmwares sie aktivieren, habe ich nicht geprüft.
Ein Detail übersieht man leicht. Das XIAO ESP32-S3 hat laut Seeeds Wiki 8 MB Flash (das Plus-Modell 16 MB), und die Board-Datei von PlatformIO verweist auf default_8MB.csv. Die OpenGizmo-Umstellung auf huge_app.csv endet bei 0x400000, die oberen 4 MB dieses Flashs haben also gar keine Partition. Sie leer zu lassen kostet nichts, und der Kommentar in der platformio.ini der Firmware sagt genau das: dieselbe Tabelle in jeder OpenGizmo-Firmware, auch in der ESP32-CAM mit 4 MB.
Welche Standard-Partitionsschemata hat Arduino-ESP32?
Der Arduino-ESP32-Core bringt Dutzende fertige Tabellen im Ordner tools/partitions mit: Am 14. November 2026 waren es mehr als 50 Dateien. In der Arduino IDE sind sie das Menü Werkzeuge, Partition Scheme, und in PlatformIO trägst du den Dateinamen in board_build.partitions ein, wie die PlatformIO-Doku zu Espressif 32 zeigt. Diese begegnen dir am häufigsten:
| Schema-Datei | Nötiger Flash (MB) | App-Slots | Jeder App-Slot (KB) | Dateisystem (KB) |
|---|---|---|---|---|
| default.csv | 4 | 2 (OTA) | 1.280 | 1.408 |
| min_spiffs.csv | 4 | 2 (OTA) | 1.920 | 128 |
| no_ota.csv | 4 | 1 | 2.048 | 1.920 |
| huge_app.csv | 4 | 1 | 3.072 | 896 |
| default_8MB.csv | 8 | 2 (OTA) | 3.264 | 1.536 |
| default_16MB.csv | 16 | 2 (OTA) | 6.400 | 3.456 |
Die KB-Werte habe ich aus den Offsets und Größen jeder CSV berechnet (default.csv, min_spiffs.csv, no_ota.csv, default_8MB.csv und default_16MB.csv). Die Spalte "Nötiger Flash" gibt an, wo die letzte Partition endet, ein 64 KB großes coredump: 0x400000, 0x800000 oder 0x1000000. Diese Dateien ändern sich zwischen Core-Releases, prüfe also die Version, mit der du baust.
Das Muster ist der Kompromiss, um den sich die ganze Tabelle dreht. Flash ist ein festes Budget, und jeder App-Slot, das Dateisystem und die OTA-Daten konkurrieren darum. Eine Tabelle mit zwei App-Slots halbiert den Platz pro Slot. Darum passt eine 1,7-MB-App wie die des Tickers nicht in die 1.280-KB-Slots von default.csv, und darum verzichtet huge_app.csv auf den zweiten Slot, um einen großen zu bekommen.
Warum unterscheiden sich die Flash-Offsets je nach Chip?
Die Tabelle selbst liegt beim klassischen ESP32 und beim ESP32-S3 bei 0x8000, aber der Bootloader wandert. Die Bootloader-Seiten von ESP-IDF sagen, dass der Second-Stage-Bootloader beim ESP32 bei 0x1000 liegt und beim ESP32-S3, ESP32-C3 und ESP32-C6 bei 0x0. Die OpenGizmo-Manifeste zeigen den Effekt:
| Teil | Gizmo Camera (ESP32) | Gizmo Ticker (ESP32-S3) | Größe (Bytes) |
|---|---|---|---|
| Bootloader | 0x1000 (4096) | 0x0 (0) | 23.520 beim ESP32, 19.968 beim S3 |
| Partitionstabelle | 0x8000 (32768) | 0x8000 (32768) | 3.072 |
| boot_app0 | 0xE000 (57344) | 0xE000 (57344) | 8.192 |
| App | 0x10000 (65536) | 0x10000 (65536) | 1.722.192 bei der Camera, 1.796.736 beim Ticker |
Die Manifeste liegen auf cdn.opengizmo.dev, und die Größen stammen aus den Dateien, die sie auflisten. Beachte, dass boot_app0 8.192 Bytes groß ist und bei 0xE000 liegt, also genau Offset und Größe von otadata in der Tabelle oben. Sein erster Sektor beginnt mit dem Wert 1 und ist bis auf ein paar Bytes sonst mit 0xFF gefüllt, der zweite Sektor beginnt mit 0. Das passt zu einem anfänglichen OTA-Data-Image, das den ersten App-Slot auswählt, aber ich habe es nicht am Quellcode von ESP-IDF geprüft, nimm es also als Schlussfolgerung. Wenn du eine eigene Tabelle entwirfst, halte diesen Offset im Gleichschritt mit der Stelle, an die du otadata legst, oder prüfe, was dein Build-Tool schreibt.
Auch der Offset der Tabelle selbst ist nicht fest: ESP-IDF setzt ihn mit CONFIG_PARTITION_TABLE_OFFSET und sagt, du sollst feste Offsets in deiner CSV anpassen, wenn du ihn änderst. Der Beitrag zum Flashen im Browser zeigt, wie diese Offsets in einer manifest.json landen.
Was bedeuten N16R8 und N8R2?
In einem Espressif-Modulnamen ist N die Flash-Größe in Megabyte und R die PSRAM-Größe in Megabyte. Das Datenblatt des ESP32-S3-WROOM-1 von Espressif (Version 1.8) listet sie in seinen Vergleichstabellen auf. PSRAM ist zusätzlicher RAM auf einem separaten Die und taucht deshalb nie in der Partitionstabelle auf. Nur die Flash-Zahl zählt.

| Modul | Flash (MB) | PSRAM (MB) | Passende Tabelle |
|---|---|---|---|
| ESP32-S3-WROOM-1-N8R2 | 8, Quad SPI | 2, Quad SPI | default_8MB.csv |
| ESP32-S3-WROOM-1-N8R8 | 8, Quad SPI | 8, Octal SPI | default_8MB.csv |
| ESP32-S3-WROOM-1-N16R8 | 16, Quad SPI | 8, Octal SPI | default_16MB.csv |
Hinter dieser Tabelle stecken zwei praktische Punkte. Erstens sagt das Datenblatt, dass bei Modulen mit Octal-PSRAM (den Serien R8 und R16V) die Pins IO35, IO36 und IO37 mit dem PSRAM verbunden sind und nicht für andere Zwecke zur Verfügung stehen, ein N16R8 verliert also drei GPIOs, die ein N8R2 behält. Zweitens ist "Passende Tabelle" meine Zuordnung, nicht die von Espressif: Jede Tabelle funktioniert, solange sie innerhalb der Flash-Größe endet. Die esptool-Dokumentation warnt, dass Partitionen in die konfigurierte Größe passen müssen, sonst funktioniert der ESP32 nicht richtig.
Das XIAO ESP32-S3 ist ein Board und kein WROOM-Modul, aber Seeeds Wiki nennt dasselbe Paar an Fakten: den Chip ESP32-S3R8 mit 8 MB PSRAM und 8 MB Flash. Welchen Chip du überhaupt kaufen solltest, steht in Welchen ESP32 solltest du kaufen? und im XIAO-Vergleich.
Wie dimensionierst du App-, OTA- und Dateisystem-Partitionen?
Geh von der App-Größe nach außen vor und schreib die Tabelle auf, bevor du sie flashst.
- Miss die App. Baue die Firmware und lies die Größe der
.binab. Beim Ticker sind es zum Beispiel 1.796.736 Bytes. - Entscheide dich für oder gegen OTA. Für Updates per WLAN brauchst du
otadataplus zwei App-Slots, laut ESP-IDF-OTA-Doku, wie im OTA-Vergleich zusammengefasst. Jeder Slot muss die App mit Luft zum Wachsen aufnehmen können. - Plane
nvsrealistisch. Die NVS-Dokumentation nennt 12 KiB (0x3000) als Minimum für normalen Lese- und Schreibbetrieb. Die Arduino-Tabellen nutzen 0x5000 (20 KB). - Gib den Rest für ein Dateisystem aus oder verzichte darauf. Wenn es niemand einhängt, ist ein ungenutztes
spiffsverschwendeter Platz, den du den App-Slots geben könntest. - Prüfe die Summe. Die letzte Partition muss spätestens an der Flash-Größe enden, und jeder App-Offset muss ein Vielfaches von 0x10000 sein.
Ein Board mit 8 MB, zwei 3-MB-Slots und einem kleinen Dateisystem könnte zum Beispiel die folgende Tabelle nutzen. Das ist meine eigene Rechnung, keine Tabelle, die ich gebaut oder geflasht habe, nimm sie also als Vorlage:
nvs, data, nvs, 0x9000, 0x5000,
otadata, data, ota, 0xe000, 0x2000,
app0, app, ota_0, 0x10000, 0x300000,
app1, app, ota_1, 0x310000, 0x300000,
spiffs, data, spiffs, 0x610000, 0x1E0000,
coredump, data, coredump,0x7F0000, 0x10000,Die letzte Zeile endet bei 0x800000, genau 8 MB. Speichere sie in der Arduino IDE als partitions.csv im Sketch-Ordner, dann nutzt der Build sie statt der vordefinierten Tabellen, wie das Arduino-ESP32-Tutorial zu Partitionen beschreibt. In PlatformIO zeigst du mit board_build.partitions auf die Datei.
Eine Änderung der Tabelle hat ihren Preis. ESP-IDF sagt, dass ein Update der Tabelle Daten, die unter der alten Tabelle gespeichert waren, nicht löscht. Da jede Partition über ihren Offset gefunden wird, liest eine verschobene oder in der Größe geänderte Partition die Bytes, die jetzt dort liegen (das ist meine Lesart, wie Offsets funktionieren, kein Zitat aus der Doku). Lass nvs dort, wo es ist, und die gespeicherten Einstellungen funktionieren weiter. Sonst plane einen sauberen Neustart ein.
Wie findest du die Offsets und die Flash-Größe eines Boards?
Drei Befehle reichen. Die ersten beiden lesen deinen Build und deinen Chip, der dritte liest, was wirklich auf dem Board ist.
pio project metadata -e release --json-outputesptool flash-idesptool -p /dev/ttyACM0 read-flash 0x8000 0x1000 table.binpio project metadatagibt die Flash-Images mit ihren Adressen und den Offset der Anwendung aus. Daspackage_firmware.pydes Tickers liest genau das, um das Manifest zu schreiben, du tippst also nie einen Offset von Hand.esptool flash-idgibt den Hersteller, die Geräte-ID und die "Detected flash size" aus, laut den grundlegenden esptool-Befehlen. Führe es aus, bevor du eine Tabelle für ein Board wählst, das du nicht selbst gekauft hast.read-flashkopiert die Tabelle vom Board. Der ESP-IDF-Guide dokumentiertgen_esp32part.py, um eine binäre Tabelle zurück in CSV zu wandeln. Ich habe die ausgelieferten Dateien stattdessen mit einem eigenen kurzen Skript dekodiert.
Die Befehlsnamen sind die Formen mit Bindestrich, die die aktuelle esptool-Dokumentation nutzt, ältere Versionen schrieben sie mit Unterstrich. Passe sie an die Version an, die du installiert hast.
Was entscheidet die Partitionstabelle für dich?
Die ESP32-Partitionstabelle entscheidet, wie ein Flash-Chip fester Größe zwischen deiner App, einer möglichen zweiten App, deinen Einstellungen und einem Dateisystem aufgeteilt wird. Für OpenGizmo ist die Antwort eine bewusste: huge_app.csv, ein 3-MB-Slot, etwa 57 % davon von der größten App belegt, Einstellungen in nvs, die ein USB-Update nie anfasst, und kein OTA.
Die Grenzen sollte man laut aussprechen. Ich habe die Tabellen gelesen und die ausgelieferten Binärdateien dekodiert, aber keine geänderte Tabelle auf ein Board geflasht, die eigene CSV oben ist also reine Rechnung, und die Rolle von boot_app0 ist eine Schlussfolgerung aus Offset, Größe und ersten Bytes. Als Nächstes lohnt sich der Vergleich der OTA-Methoden, der zeigt, was ein zweiter Slot dieses Layout kosten würde, oder der Beitrag Arduino IDE vs PlatformIO, wenn du noch wählst, wo du das Schema festlegst.
Haufig gestellte Fragen
Finden Sie schnelle Antworten auf die haufigsten Fragen zu diesem Thema.
Laut ESP-IDF-Dokumentation liegt die ESP32-Partitionstabelle standardmäßig im Flash bei Offset 0x8000. Sie belegt genau einen 4-KB-Sektor und fasst bis zu 95 Einträge plus eine MD5-Prüfsumme. Der Bootloader liest sie bei jedem Start ein, um die App- und die Datenpartitionen zu finden.
Autor
Mauro BrambillaLust, dein eigenes Gizmo zu bauen?
Such dir ein Open-Source-Projekt mit dem ESP32 aus und folge der Schritt-für-Schritt-Anleitung, von der Teileliste und der Verkabelung bis zur Firmware und zum ersten Start.






