OTA ESP32 a confronto: web, GitHub, HTTPS pull
Aggiornamento OTA dell'ESP32 a confronto: ArduinoOTA, upload web, HTTPS pull da GitHub Releases e USB, con partizioni, sicurezza e rollback.
- Autore
Mauro Brambilla- Pubblicato
- Tempo di lettura
- 11 min
- Categoria
- Confronti

In breve
ArduinoOTA e l'upload web spingono un .bin sulla tua LAN, l'HTTPS pull lo fa scaricare alla scheda, e tutti e tre richiedono due slot app OTA. OpenGizmo non ne usa nessuno: flasha via USB.
Un aggiornamento OTA dell'ESP32 sostituisce il firmware in esecuzione via Wi-Fi: il chip scrive la nuova immagine nella partizione libera tra due partizioni app OTA, poi si riavvia da lì. Puoi spingere il .bin dal computer (ArduinoOTA), caricarlo da una pagina servita dalla scheda, oppure lasciare che sia la scheda a scaricarlo in HTTPS da un server o da GitHub Releases. Tutti e tre richiedono una tabella delle partizioni con due slot app.
Questo post confronta questi metodi, più il classico flash via USB, per fatica, sicurezza, rollback e costo in memoria flash. I fatti sull'OTA vengono dalla documentazione e dal sorgente di ESP-IDF e Arduino-ESP32, linkati nel testo. Quelli su OpenGizmo vengono dai tre repository del firmware, che ho letto per questo post. Non ho provato nessuno dei metodi OTA su hardware, quindi qui non c'è nessun benchmark.
Come funziona un aggiornamento OTA dell'ESP32?
OTA sta per over-the-air: il firmware già in esecuzione riceve quello successivo e lo installa. La documentazione OTA di Espressif dice che le funzioni OTA scrivono la nuova immagine nello slot che non è selezionato per l'avvio, e solo dopo la verifica la partizione OTA data viene aggiornata per indicare che quell'immagine va usata al prossimo avvio.
È per questo che un download interrotto non fa danni: l'app in esecuzione non viene mai toccata. La documentazione pone un solo limite. Il percorso sicuro vale per le applicazioni. Il bootloader, la tabella delle partizioni e le partizioni dati sono un "unsafe update" nella stessa pagina, perché un'interruzione di corrente durante la copia finale può rompere il dispositivo.
Il layout minimo, sempre nella stessa pagina, è "at least two OTA app slot partitions (i.e., ota_0 and ota_1) and an OTA Data Partition". La guida alla tabella delle partizioni mostra tutta la mappa della memoria flash. Per questo confronto l'unico numero che conta è la dimensione dello slot, perché la nuova immagine deve entrare in uno slot diverso da quello da cui sta girando il firmware.
ArduinoOTA, upload web o HTTPS pull: quale scegliere?
La differenza sta in chi avvia il trasferimento e da dove arriva il .bin. Ecco i quattro modi a confronto.

| Metodo | Chi lo avvia | Rete | Due slot OTA | Protezione di base |
|---|---|---|---|---|
| ArduinoOTA | Il tuo computer, con espota.py o PlatformIO | Stessa LAN, trovata per IP o mDNS | Sì | Password facoltativa; trasferimento in TCP semplice |
| Upload web | Tu, da un browser | Stessa LAN, pagina HTTP sulla scheda | Sì | Nessuna, o la basic auth che aggiungi tu |
| HTTPS pull | La scheda, con un timer o un pulsante | Qualsiasi rete che raggiunga il server | Sì | TLS, se le dai un certificato |
| Re-flash via USB | Tu, con un cavo | Nessuna | No | Accesso fisico |
ArduinoOTA: spingere dal computer
La libreria ArduinoOTA del core Arduino-ESP32 ascolta di default sulla porta 3232 e chiama la scheda esp32- più il suo indirizzo MAC, a meno che tu non usi setHostname(). Uno strumento manda un invito UDP, e la scheda apre una connessione TCP verso il computer per scaricare l'immagine. Devi chiamare handle() in loop(), altrimenti la scheda non risponde mai.
Secondo il sorgente, la password viene hashata con SHA-256 e controllata con un challenge-response basato su PBKDF2-HMAC-SHA256. L'immagine in sé arriva in TCP semplice, per quanto si vede dal sorgente, con un controllo MD5 solo per l'integrità. L'mDNS è attivo di default: comodo, ed è anche il punto in cui i nomi .local falliscono su Android e su alcuni router.
PlatformIO lo supporta direttamente. Le sue docs su Espressif 32 dicono di impostare upload_protocol = espota e upload_port sull'indirizzo IP o sul nome mDNS, con --auth in upload_flags per la password. Se stai scegliendo anche la toolchain, Arduino IDE o PlatformIO spiega i compromessi.
Upload web: una pagina sulla scheda
Un web updater serve un modulo di upload direttamente dall'ESP32. La pagina OTA web update di Espressif descrive l'esempio OTAWebUpdater: vai su http://esp32.local, accedi con admin e admin (le credenziali di default) e scegli il binario compilato. La pagina dice che scheda e computer devono stare sulla stessa rete, e non dice nulla su come cambiare quel login.
ElegantOTA riprende la stessa idea in una pagina più curata. La versione gratuita fa aggiornamenti di firmware e filesystem, verifica MD5 e basic auth HTTP facoltativa, con licenza AGPL-3.0. Aggiornamento automatico e download diretto sono funzioni Pro. Con ESPAsyncWebServer serve il flag di build ELEGANTOTA_USE_ASYNC_WEBSERVER=1, e il README avverte che non puoi usare il server sincrono e quello asincrono nello stesso firmware.
Il punto debole è l'HTTP semplice. Una password digitata in un modulo HTTP attraversa il tuo Wi-Fi in chiaro, lo stesso limite di un captive portal aperto, come spiega il confronto sul provisioning. Su una LAN di casa può andare bene. Su una rete condivisa no.
HTTPS pull: la scheda scarica l'immagine
Con un pull è la scheda a decidere quando aggiornarsi. In ESP-IDF, esp_https_ota() lo fa con una sola chiamata a partire da un URL, mentre esp_https_ota_begin(), perform() e finish() ti danno il controllo del ciclo. Nel core Arduino fa lo stesso lavoro HTTPUpdate. Manda la versione corrente in un header x-ESP32-version e tratta una risposta 204 o 304 come "nessun aggiornamento", così il server può decidere cosa inviare.
È l'unico metodo che funziona attraverso internet e non richiede nessuno nei paraggi. È anche quello in cui i dettagli di sicurezza contano di più, quindi hanno una sezione tutta loro più sotto.
Re-flash via USB: nessun OTA
Un flash via USB richiede un solo slot app, la scheda a portata di mano e un cavo. È quello che fa il flasher da browser, e ci torno con i numeri di OpenGizmo qui sotto.
Come si aggiorna un ESP32 da GitHub Releases?
GitHub Releases è un posto gratuito dove ospitare file .bin versionati, e la scheda può scaricarli con un HTTPS pull. Tre dettagli decidono se funziona.
- Carica l'immagine dell'app, non il flash unito. Un OTA scrive nello slot una sola immagine app, quindi carica solo l'app. Un file unito contiene anche il bootloader e la tabella delle partizioni, che non sono un'immagine app. Le release di OpenGizmo pubblicano già la sola app come
release-firmware.bin, accanto ai pezzi di bootloader, tabella delle partizioni eboot_app0. - Aspettati un redirect. Le docs sugli asset delle release di GitHub dicono che i client devono gestire sia una risposta 200 sia una 302. Il costruttore di HTTPUpdate disattiva i redirect di default, secondo il sorgente, quindi una 302 manda in errore l'aggiornamento finché non chiami il suo metodo
setFollowRedirects(). In ESP-IDF, le docs dell'HTTPS OTA aggiungono che neicert_pemdevono stare anche i certificati CA delle destinazioni dei redirect. - Attento al rate limit. L'API REST permette 60 richieste all'ora per indirizzo IP senza autenticazione. Non ho verificato se i semplici download degli asset contino, quindi interroga di rado: una volta al giorno basta e avanza per un gadget da scrivania.
Un'impostazione più pulita separa il controllo dal download: leggi un minuscolo file di versione e scarichi il .bin solo se il numero è più alto. L'API delle release elenca anche un digest SHA-256 per ogni asset. Per il release-firmware.bin del Ticker stampa sha256:647b987e..., che ho letto dall'API il 14 novembre 2026, così una scheda potrebbe confrontarlo con il digest di ciò che ha scritto.
Qui non pubblico un esempio di codice, perché non ne ho compilato uno per questo post. Le chiamate API di cui sopra sono nelle docs linkate, e ognuna ha un esempio.
Che layout di partizioni richiede l'OTA?
L'OTA richiede una partizione OTA data e due slot app OTA, ognuno abbastanza grande per la tua app. La dimensione dello slot è dove i progetti inciampano. Il core Arduino-ESP32 include diverse tabelle, e ne ho letto le definizioni per confrontarle con un firmware reale: l'app del Gizmo Ticker v1.2.0, che pesa 1.796.736 byte secondo la sua release su GitHub.

| Tabella (core Arduino-ESP32) | Slot app | Dimensione slot (byte) | Dimensione slot (MiB) | Ci sta l'app da 1.796.736 B? |
|---|---|---|---|---|
| huge_app.csv | 1 (ota_0) | 0x300000 = 3.145.728 | 3,00 | Sì, ma senza secondo slot |
| default.csv | 2 | 0x140000 = 1.310.720 | 1,25 | No |
| min_spiffs.csv | 2 | 0x1E0000 = 1.966.080 | 1,88 | Sì, con 169.344 B di margine |
| default_8MB.csv | 2 | 0x330000 = 3.342.336 | 3,19 | Sì, servono 8 MB di flash |
Le definizioni sono nei file del core default.csv, min_spiffs.csv, default_8MB.csv e huge_app.csv. Tutte e quattro tengono nvs a 0x9000 con 0x5000 byte e la prima app a 0x10000. La guida alla tabella delle partizioni elenca queste e gli altri schemi per intero. Gli slot da 1,25 MiB della tabella di default sono la trappola: un firmware con uno stack TLS, un web server asincrono e una web app incorporata può superare quella dimensione, e l'aggiornamento fallisce.
Altre due regole dalla guida alle tabelle delle partizioni di Espressif: le partizioni app devono stare su confini da 64 KB (0x10000), e la partizione OTA data è di 0x2000 byte. Cambiare la tabella è già di per sé fuori dal percorso OTA sicuro, quindi passare da una tabella a uno slot a una a due slot richiede un flash via USB una tantum.
Come rendi sicuro l'OTA: HTTPS, firma e rollback?
Esistono quattro protezioni distinte, e ognuna risponde a una domanda diversa: è il server giusto, l'immagine è mia, è difettosa, è più vecchia di quella che ho già.
| Domanda | Meccanismo | Cosa serve | Cosa non fa |
|---|---|---|---|
| È il server giusto? | TLS con cert_pem o il bundle di certificati | Un certificato root in flash, o crt_bundle_attach | Non dimostra che il file sia tuo |
| L'immagine è mia? | Immagini firmate: Secure Boot v2, o la verifica della firma solo software | Una chiave di firma; Secure Boot v2 brucia gli eFuse | La modalità solo software non ferma chi può scrivere nella flash |
| L'immagine è difettosa? | Rollback allo slot OTA precedente | Due slot, un bootloader compilato con l'opzione di rollback | Il rollback vale solo per gli slot OTA, non per un'app factory |
| L'immagine è più vecchia? | Anti-rollback con una versione di sicurezza negli eFuse | Una versione di sicurezza nell'app, confrontata con gli eFuse | Non si annulla dopo aver scritto l'eFuse |
Controllo del server. La pagina di ESP-IDF dice che il certificato root in formato PEM va in cert_pem, e consiglia la root del server, non un intermedio, perché le root durano più a lungo. Dice anche che se il trasporto non è impostato si usa TLS di default, quindi un URL http:// fallisce a meno che non sia abilitato CONFIG_ESP_HTTPS_OTA_ALLOW_HTTP. In alternativa, crt_bundle_attach verifica con l'ESP x509 Certificate Bundle.
Questo riguarda anche il codice di OpenGizmo. Il client dei dati di mercato del Gizmo Ticker chiama clientSecure.setInsecure() in api.cpp, che cifra il traffico ma accetta qualsiasi certificato. È un compromesso accettabile per il prezzo di una criptovaluta. Sarebbe pessimo per un firmware, perché chiunque riesca a impersonare il server sulla tua rete potrebbe mandarti codice. Un client OTA deve verificare il server.
Firma. La pagina su Secure Boot v2 di Espressif dice che l'app viene verificata a ogni aggiornamento OTA, e che sull'ESP32 classico Secure Boot v2 richiede la revisione del chip v3.0 o successiva. Si attiva tramite gli eFuse, quindi pianifica prima le chiavi. La modalità solo software controlla le firme durante l'OTA, e la pagina avverte che non protegge da un attaccante con accesso in scrittura alla flash.
Rollback. Il rollback di ESP-IDF è un'opzione del bootloader, CONFIG_BOOTLOADER_APP_ROLLBACK, che la pagina OTA dice essere abilitata di default in ESP-IDF. Una nuova immagine parte nello stato pending-verify, e se l'app non chiama mai esp_ota_mark_app_valid_cancel_rollback(), al riavvio successivo il bootloader la salta. Il codice di avvio di Arduino-ESP32 in esp32-hal-misc.c ha degli hook per questo, verifyOta() e verifyRollbackLater(). Non ho verificato se il bootloader Arduino precompilato abbia il rollback abilitato, quindi controlla la tua build prima di contarci. La classe Update del core ha anche canRollBack() e rollBack() per avviare a mano l'altro slot.
ESPHome sceglie la strada gestita: il suo componente OTA offre una piattaforma esphome, una web_server e una http_request che scarica da un server, con la safe mode attivata in automatico. Se preferisci non costruire niente di tutto questo, vedi ESPHome o firmware personalizzato.
OpenGizmo usa l'OTA?
No. Ho cercato nei tre repository del firmware e nelle versioni di gizmo-common che fissano (v2.5.1 per il Ticker e il Reolink Switch, v2.4.0 per la Camera) le stringhe ota, ArduinoOTA, HTTPUpdate, Update.h e esp_ota, e il 14 novembre 2026 non ho trovato codice OTA. Il Gizmo Ticker, il Gizmo Reolink Switch e la Gizmo Camera impostano tutti board_build.partitions = huge_app.csv, e il commento della riga stessa dice "One 3 MB app slot (no wireless updates), the same in every OpenGizmo firmware". Lo trovi nel platformio.ini del Ticker.

Gli aggiornamenti passano invece dall'USB. Ogni pagina di progetto ha una card che flasha l'ultima release dal browser, come mostra la guida a ESP Web Tools. Tre cose lo fanno funzionare bene qui, e sono tutte nei repository:
- La web app è dentro il firmware.
gizmo-commonla serve da asset incorporati nell'immagine dell'app, quindi c'è un solo file da aggiornare, non un'immagine di filesystem separata. - Le impostazioni sopravvivono. Il flasher scrive quattro parti e non cancella mai la regione
nvs, quindi un aggiornamento via USB conserva il Wi-Fi e le impostazioni salvate. - La versione è visibile. Ogni build riporta la sua versione in
/api/device, e il workflow di release controlla che la versione sia nuova prima di pubblicare.
Il costo è reale: servono la scheda e un cavo, e una scheda chiusa nel suo case o montata fuori portata è una seccatura da aggiornare.
Con un solo slot, comunque, non c'è spazio per un OTA. Le dimensioni delle app nelle release sono 1.796.736 byte (Ticker v1.2.0), 1.778.336 (Reolink Switch v1.2.0) e 1.722.192 (Camera v1.0.0), quindi nessuna entra negli slot da 1,25 MiB di default.csv.
Come si potrebbe aggiungere l'OTA?
Questo è un piano, non qualcosa che ho costruito. La XIAO ESP32-S3 ha 8 MB di flash secondo la wiki di Seeed, quindi default_8MB.csv dà due slot da 3,19 MiB, e le app del Ticker e del Reolink ci stanno in ciascuno. La flash della scheda della Camera è da controllare sul tuo modulo. I passaggi sarebbero:
- Pubblicare una release con la nuova tabella delle partizioni via USB, perché la tabella è fuori dal percorso OTA sicuro. Il flasher scrive già
release-partitions.bina 0x8000. - Aggiungere un HTTPS pull che controlla il manifest della release o un file di versione, e scarica
release-firmware.binsolo se è più recente. - Verificare il server con il bundle di certificati, mai con
setInsecure(), e confrontare lo SHA-256 dell'asset. - Segnare la nuova immagine come valida solo dopo che web server e Wi-Fi sono attivi, così un'immagine difettosa torna indietro.
Il prezzo è che la flash ora contiene due copie dell'app, quindi l'area app va divisa tra le due, e che devi scrivere codice che decida quando è sicuro riavviare un dispositivo che qualcuno sta guardando.
Quale metodo OTA dell'ESP32 dovresti usare?
Usa ArduinoOTA con PlatformIO mentre sviluppi, perché toglie il cavo dal ciclo modifica-e-prova. Usa una pagina di upload web quando qualcun altro deve aggiornare qualche scheda e puoi proteggere la pagina. Usa un HTTPS pull quando molte schede stanno fuori portata, e solo con verifica dei certificati, controllo delle dimensioni e rollback attivi. Usa l'USB quando la scheda è sulla tua scrivania, il firmware è piccolo e le impostazioni devono sopravvivere: è dove si trova OpenGizmo oggi.
Il limite di questo confronto è che ho letto le docs e il sorgente e non ho provato nessun metodo, quindi non ho tempi, tassi di errore o consumi. La prima cosa da controllare nel tuo progetto è la dimensione dello slot rispetto alla tua app. Poi guarda come il flasher costruisce e carica le release, e leggi il post sulla tabella delle partizioni prima di cambiare la tua.
Domande frequenti
Trova risposte rapide alle domande più comuni su questo argomento.
Sì, con un HTTPS pull. La scheda richiede l'asset .bin della release, a cui GitHub risponde con un redirect: il client HTTP deve quindi seguire i redirect. Poi scrive il file nello slot OTA libero. HTTPUpdate, nel core Arduino-ESP32, ha i redirect disattivati di default, quindi devi attivarli tu.
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.





