Tabella delle partizioni ESP32: layout flash e OTA
Cos'è la tabella delle partizioni dell'ESP32, come leggere le colonne di partitions.csv, gli schemi Arduino-ESP32 con le dimensioni e cosa significa N16R8.
- Autore
Mauro Brambilla- Pubblicato
- Tempo di lettura
- 10 min
- Categoria
- Guide

In breve
La tabella delle partizioni dell'ESP32 sta a 0x8000 e divide la flash in nvs, otadata, app e filesystem. Il file huge_app.csv di OpenGizmo dà un solo slot app da 3 MB e niente OTA.
La tabella delle partizioni dell'ESP32 è una piccola mappa salvata nella flash all'offset 0x8000, che dice al bootloader dove stanno l'app, lo spazio per le impostazioni (nvs), i dati OTA e il filesystem. La scegli con un file partitions.csv o con uno schema integrato come default.csv o huge_app.csv. Se la tabella supera la flash reale, la documentazione di esptool di Espressif avverte che il chip non funzionerà correttamente.
In questa guida leggiamo quella mappa come la legge il chip: le colonne del CSV, gli schemi Arduino-ESP32 con le dimensioni in KB, perché l'offset del bootloader cambia da un chip all'altro e cosa significa N16R8 nel nome di un modulo per il tuo layout. L'esempio reale è il Gizmo Ticker: ho decodificato il release-partitions.bin che scrive il suo flasher e l'ho confrontato con la documentazione di Espressif e con i file CSV di Arduino-ESP32.
Cos'è la tabella delle partizioni dell'ESP32?
Una tabella delle partizioni divide il chip di flash esterna in regioni con un nome, un tipo, un offset e una dimensione. La guida alle partition table di Espressif dice che di default viene flashata a 0x8000, occupa un settore da 4 KB ed è lunga 0xC00 byte, perché ammette al massimo 95 voci, seguite da un checksum MD5 che il bootloader usa per controllarne l'integrità.

Il bootloader è il primo programma che gira dalla flash. La pagina sul bootloader di ESP-IDF ne elenca i compiti: scegliere la partizione dell'applicazione da avviare in base alla tabella delle partizioni e a ota_data, se c'è, caricare l'immagine in RAM e passarle il controllo. Quindi la tabella non è un'impostazione dentro la tua app: è un file nella flash che esiste prima del tuo codice.
Una tabella tipica contiene quattro tipi di partizioni:
- nvs: archivio chiave-valore per impostazioni e dati Wi-Fi, usato dalla libreria Preferences
- otadata: segna quale slot app OTA avviare, 0x2000 byte
- slot app (factory, ota_0, ota_1): le immagini del firmware
- partizioni di dati come spiffs o coredump: un filesystem, i dump dei crash o i tuoi byte

Che aspetto ha un file partitions.csv?
Il CSV ha sei colonne: name, type, subtype, offset, size e flags. Gli spazi vengono ignorati, le righe che iniziano con # sono commenti e le dimensioni possono essere in esadecimale, in decimale o con K e M. Un nome è lungo al massimo 16 byte, terminatore compreso. Ecco la tabella reale di tutti i firmware OpenGizmo, dal huge_app.csv del core Arduino-ESP32, letto il 14 novembre 2026 (qui manca la riga di commento con i nomi delle colonne):
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,Tre regole spiegano la maggior parte dei numeri, tutte dalla guida ESP-IDF. Gli offset sono multipli di 4 KB (0x1000), la dimensione del settore della flash. Una partizione app deve iniziare a un multiplo di 64 KB (0x10000): per questo la prima app sta a 0x10000 e la zona da 0x9000 a 0xFFFF, prima di lei, contiene solo piccole partizioni di dati. E se lasci vuoto un offset, la partizione parte subito dopo la precedente, con le partizioni app allineate al posto tuo.
Il bootloader e le librerie cercano tipo e sottotipo, non il nome. Sempre secondo la guida, la partizione nvs predefinita è quella con tipo data e sottotipo nvs, e otadata ha sottotipo ota. La tabella binaria che scrive il flasher li salva come numeri. Ho decodificato il file distribuito con poche righe di Python: nvs è data/0x02, otadata è data/0x00, app0 è app/0x10 (ota_0), spiffs è data/0x82 e coredump è data/0x03.
Quale tabella delle partizioni usano i firmware OpenGizmo?
Tutti e tre impostano board_build.partitions = huge_app.csv in platformio.ini, per esempio nel file del Ticker, con il commento "One 3 MB app slot (no wireless updates), the same in every OpenGizmo firmware". I file release-partitions.bin del Ticker v1.2.0, del Reolink Switch v1.2.0 e della Camera v1.0.0, scaricati dalla CDN il 14 novembre 2026, sono identici byte per byte (3.072 byte) e si decodificano esattamente nel CSV qui sopra.
Cosa significa per l'hardware?
- Un solo slot app, niente OTA. C'è un unico slot
ota_0da 3 MB (3.072 KB) e nessun secondo slot, quindi una nuova immagine non ha dove essere scritta mentre la vecchia gira. Il confronto tra i metodi OTA spiega perché questo esclude gli aggiornamenti via Wi-Fi e mette a confronto le dimensioni degli slot con l'app reale. - Spazio per crescere. L'app del Ticker v1.2.0 pesa 1.796.736 byte, circa il 57% dello slot. L'app del Reolink Switch pesa 1.778.336 byte e quella della Camera 1.722.192 byte, ricavate dalle dimensioni dei file di release.
- Le impostazioni sono al sicuro. La libreria Preferences salva i dati nella partizione NVS, e lo
storage.cppdel Ticker e quello del Reolink Switch usano entrambi Preferences. Il flasher scrive bootloader, tabella,boot_app0e app, e nessuno di questi si sovrappone a 0x9000-0xDFFF, come descrive la guida al flashing dal browser. - Un filesystem inutilizzato. La partizione
spiffsda 896 KB è dichiarata, ma cercandoLittleFS,SPIFFSespiffsnei sorgentimicrocontroller/dei tre firmware non si trova nulla. La libreria condivisagizmo-commonnon rientra in quella ricerca. La partizionecoredumpda 64 KB è dove la funzione core dump di ESP-IDF scrive i dati dei crash, e se questi firmware la abilitino non l'ho verificato.
Un altro dettaglio si nota facilmente. La XIAO ESP32-S3 ha 8 MB di flash (il modello Plus ne ha 16 MB) secondo la wiki di Seeed, e il file board di PlatformIO punta a default_8MB.csv. L'override di OpenGizmo su huge_app.csv finisce a 0x400000, quindi i 4 MB superiori di quella flash non hanno nessuna partizione. Lasciarli vuoti non costa niente, e il commento nel platformio.ini del firmware dice proprio che la stessa tabella vale per ogni firmware OpenGizmo, compresa la ESP32-CAM da 4 MB.
Quali sono gli schemi di partizioni predefiniti di Arduino-ESP32?
Il core Arduino-ESP32 include decine di tabelle già pronte nella cartella tools/partitions: il 14 novembre 2026 contava più di 50 file. In Arduino IDE sono il menu Strumenti, Partition Scheme; in PlatformIO scrivi il nome del file in board_build.partitions, come mostrano i documenti PlatformIO per Espressif 32. Questi sono quelli che incontri più spesso:
| File dello schema | Flash necessaria (MB) | Slot app | Ogni slot app (KB) | Filesystem (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 |
Ho calcolato i valori in KB dagli offset e dalle dimensioni di ogni CSV (default.csv, min_spiffs.csv, no_ota.csv, default_8MB.csv e default_16MB.csv). La colonna "Flash necessaria" è il punto in cui finisce l'ultima partizione, un coredump da 64 KB: 0x400000, 0x800000 o 0x1000000. Questi file cambiano da una release del core all'altra, quindi controlla la versione con cui compili.
Lo schema è sempre lo stesso compromesso su cui ruota tutta la tabella. La flash è un budget fisso, e slot app, filesystem e dati OTA se lo contendono. Una tabella con due slot app dimezza lo spazio di ciascuno. Per questo un'app da 1,7 MB come quella del Ticker non entra negli slot da 1.280 KB di default.csv, e per questo huge_app.csv rinuncia al secondo slot per averne uno grande.
Perché gli offset della flash cambiano da un chip all'altro?
La tabella sta a 0x8000 sia sull'ESP32 classico sia sull'ESP32-S3, ma il bootloader si sposta. Le pagine sul bootloader di ESP-IDF dicono che il bootloader di secondo stadio sta a 0x1000 sull'ESP32 e a 0x0 su ESP32-S3, ESP32-C3 ed ESP32-C6. I manifest di OpenGizmo mostrano l'effetto:
| Parte | Gizmo Camera (ESP32) | Gizmo Ticker (ESP32-S3) | Dimensione (byte) |
|---|---|---|---|
| bootloader | 0x1000 (4096) | 0x0 (0) | 23.520 su ESP32, 19.968 su S3 |
| tabella delle partizioni | 0x8000 (32768) | 0x8000 (32768) | 3.072 |
| boot_app0 | 0xE000 (57344) | 0xE000 (57344) | 8.192 |
| app | 0x10000 (65536) | 0x10000 (65536) | 1.722.192 su Camera, 1.796.736 su Ticker |
I manifest sono su cdn.opengizmo.dev e le dimensioni vengono dai file che elencano. Nota che boot_app0 è di 8.192 byte a 0xE000, cioè l'offset e la dimensione esatti di otadata nella tabella qui sopra. Il suo primo settore inizia con il valore 1 ed è per il resto pieno di 0xFF a parte pochi byte, mentre il secondo settore inizia con 0. Torna con un'immagine OTA data iniziale che seleziona il primo slot app, ma non l'ho verificato sul sorgente di ESP-IDF, quindi consideralo un'inferenza. Se disegni una tabella tua, tieni quell'offset allineato a dove metti otadata, oppure controlla cosa scrive il tuo strumento di build.
Neanche l'offset della tabella è fisso: ESP-IDF lo imposta con CONFIG_PARTITION_TABLE_OFFSET e dice di aggiornare gli offset fissi nel tuo CSV se lo cambi. Il post sul flashing dal browser mostra come quegli offset finiscono in un manifest.json.
Cosa significano N16R8 e N8R2?
Nel nome di un modulo Espressif, N è la dimensione della flash in megabyte e R quella della PSRAM in megabyte. Il datasheet dell'ESP32-S3-WROOM-1 di Espressif (versione 1.8) li elenca nelle tabelle di confronto. La PSRAM è RAM aggiuntiva in un die separato, quindi non compare mai nella tabella delle partizioni. Conta solo il numero della flash.

| Modulo | Flash (MB) | PSRAM (MB) | Tabella adatta |
|---|---|---|---|
| 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 |
Dietro quella tabella ci sono due punti pratici. Primo: il datasheet dice che sui moduli con PSRAM octal (le serie R8 e R16V) i pin IO35, IO36 e IO37 sono collegati alla PSRAM e non sono disponibili per altri usi, quindi un N16R8 perde tre GPIO che un N8R2 conserva. Secondo: "Tabella adatta" è un mio abbinamento, non di Espressif: va bene qualsiasi tabella, purché finisca entro la dimensione della flash. La documentazione di esptool avverte che le partizioni devono stare nella dimensione configurata, altrimenti l'ESP32 non funzionerà correttamente.
La XIAO ESP32-S3 è una scheda, non un modulo WROOM, ma la wiki di Seeed riporta la stessa coppia di dati: il chip ESP32-S3R8 con 8 MB di PSRAM e 8 MB di flash. Per capire quale chip comprare, vedi Quale ESP32 comprare? e il confronto tra XIAO.
Come dimensionare le partizioni app, OTA e filesystem?
Parti dalla dimensione dell'app e vai verso l'esterno, e scrivi la tabella prima di flasharla.
- Misura l'app. Compila il firmware e leggi la dimensione del
.bin. Per esempio, quello del Ticker è di 1.796.736 byte. - Decidi se vuoi l'OTA. Per aggiornare via Wi-Fi servono
otadatapiù due slot app, secondo la documentazione OTA di ESP-IDF come riassunta nel confronto OTA. Ogni slot deve contenere l'app con un po' di margine per crescere. - Dai a
nvslo spazio che serve davvero. La documentazione NVS indica 12 KiB (0x3000) come minimo per un normale uso in lettura e scrittura. Le tabelle di Arduino usano 0x5000 (20 KB). - Spendi il resto in un filesystem, oppure rinuncia. Se nessuno lo monta, uno
spiffsinutilizzato è spazio sprecato che potresti dare agli slot app. - Controlla la somma. L'ultima partizione deve finire entro la dimensione della flash e ogni offset app deve essere un multiplo di 0x10000.
Per esempio, una scheda da 8 MB con due slot da 3 MB e un piccolo filesystem potrebbe usare la tabella qui sotto. È un calcolo mio, non una tabella che ho costruito o flashato, quindi trattala come un modello:
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,L'ultima riga finisce a 0x800000, esattamente 8 MB. In Arduino IDE salvala come partitions.csv nella cartella dello sketch e la build la usa al posto delle tabelle predefinite, come descrive il tutorial sulle partizioni di Arduino-ESP32. In PlatformIO punta board_build.partitions al file.
Cambiare la tabella ha un costo. ESP-IDF dice che aggiornarla non cancella i dati salvati con la vecchia tabella. Visto che ogni partizione si trova tramite il suo offset, una partizione spostata o ridimensionata leggerà i byte che ora stanno lì (è la mia lettura di come funzionano gli offset, non una citazione dalla documentazione). Lascia nvs dov'è e le impostazioni salvate continuano a funzionare; altrimenti metti in conto di ripartire da zero.
Come trovi gli offset e la dimensione della flash di una scheda?
Bastano tre comandi. I primi due leggono la tua build e il tuo chip, il terzo legge cosa c'è davvero sulla scheda.
pio project metadata -e release --json-outputesptool flash-idesptool -p /dev/ttyACM0 read-flash 0x8000 0x1000 table.binpio project metadatastampa le immagini flash con i loro indirizzi e l'offset dell'applicazione. Ilpackage_firmware.pydel Ticker legge esattamente questo per scrivere il manifest, così non digiti mai un offset a mano.esptool flash-idstampa il produttore, l'ID del dispositivo e la "Detected flash size", come descrivono i comandi base di esptool. Lancialo prima di scegliere una tabella per una scheda che non hai comprato tu.read-flashcopia la tabella fuori dalla scheda. La guida ESP-IDF documentagen_esp32part.pyper riconvertire una tabella binaria in CSV, e io ho decodificato i file distribuiti con un mio breve script.
I nomi dei comandi sono le forme con il trattino che usa la documentazione attuale di esptool; le versioni più vecchie li scrivevano con il trattino basso. Adattali alla versione che hai installato.
Cosa decide per te la tabella delle partizioni?
La tabella delle partizioni dell'ESP32 decide come un chip di flash di dimensione fissa viene diviso tra la tua app, una possibile seconda app, le tue impostazioni e un filesystem. Per OpenGizmo la risposta è stata una scelta precisa: huge_app.csv, un solo slot da 3 MB, circa il 57% occupato dall'app più grande, impostazioni in nvs che un aggiornamento via USB non tocca mai, e niente OTA.
I limiti conviene dirli ad alta voce. Ho letto le tabelle e decodificato i binari distribuiti, ma non ho flashato su una scheda una tabella modificata, quindi il CSV personalizzato qui sopra è solo un calcolo, e il ruolo di boot_app0 è un'inferenza dal suo offset, dalla dimensione e dai primi byte. Il prossimo passo utile è il confronto tra i metodi OTA, che mostra quanto costerebbe un secondo slot a questo layout, oppure il post Arduino IDE vs PlatformIO se stai ancora scegliendo dove impostare lo schema.
Domande frequenti
Trova risposte rapide alle domande più comuni su questo argomento.
Secondo la documentazione ESP-IDF, la tabella delle partizioni dell'ESP32 sta di default nella flash all'offset 0x8000. Occupa un settore da 4 KB e contiene fino a 95 voci più un checksum MD5. Il bootloader la legge a ogni avvio per trovare le partizioni app e quelle dei dati.
Autore
Mauro BrambillaPronto a costruire il tuo gizmo?
Scegli un progetto ESP32 open source e segui la sua guida passo passo, dalla lista dei componenti e dai collegamenti fino al firmware e al primo avvio.






