OTA en ESP32 comparado: web, GitHub y HTTPS pull
Actualización OTA del ESP32 comparada: ArduinoOTA, subida web, HTTPS pull desde GitHub Releases y USB, con particiones, seguridad y rollback.
- Autor
Mauro Brambilla- Publicado
- Tiempo de lectura
- 11 min
- Categoría
- Comparativas

En resumen
ArduinoOTA y la subida web empujan un .bin por tu LAN, el HTTPS pull hace que la placa lo descargue, y los tres necesitan dos slots de app OTA. OpenGizmo no usa ninguno: flashea por USB.
Una actualización OTA del ESP32 reemplaza el firmware en ejecución por Wi-Fi: el chip escribe la imagen nueva en la partición libre de las dos de app OTA y luego se reinicia desde ella. Puedes empujar el .bin desde tu computadora (ArduinoOTA), subirlo desde una página de la placa, o dejar que la placa lo descargue por HTTPS desde un servidor o GitHub Releases. Los tres necesitan una tabla de particiones con dos slots de app.
Este post compara esos métodos, más el flasheo normal por USB, en esfuerzo, seguridad, rollback y coste de memoria flash. Los datos de OTA salen de la documentación y el código fuente de ESP-IDF y Arduino-ESP32, enlazados en el texto. Los de OpenGizmo salen de los tres repositorios del firmware, que leí para este post. No probé ninguno de los métodos OTA en hardware, así que aquí no hay ningún benchmark.
¿Cómo funciona una actualización OTA del ESP32?
OTA significa over-the-air: el firmware que ya está en ejecución recibe el siguiente e lo instala. La documentación de OTA de Espressif dice que las funciones OTA escriben la imagen nueva en el slot que no está seleccionado para el arranque, y solo después de verificarla se actualiza la partición OTA data para indicar que esa imagen debe usarse en el próximo arranque.
Por eso una descarga interrumpida es inofensiva: la app en ejecución nunca se toca. La documentación pone un solo límite. El camino seguro cubre las aplicaciones. El bootloader, la tabla de particiones y las particiones de datos son una "unsafe update" en la misma página, porque un corte de corriente durante la copia final puede dejar el dispositivo inservible.
El diseño mínimo, en la misma página, es "at least two OTA app slot partitions (i.e., ota_0 and ota_1) and an OTA Data Partition". La guía de la tabla de particiones muestra todo el mapa de la memoria flash. Para esta comparación, el único número que importa es el tamaño del slot, porque la imagen nueva tiene que caber en un slot distinto de aquel desde el que estás ejecutando.
ArduinoOTA, subida web o HTTPS pull: ¿cuál elegir?
La diferencia está en quién inicia la transferencia y de dónde sale el .bin. Aquí van las cuatro formas lado a lado.

| Método | Quién lo inicia | Red | Dos slots OTA | Protección de serie |
|---|---|---|---|---|
| ArduinoOTA | Tu computadora, con espota.py o PlatformIO | Misma LAN, encontrada por IP o mDNS | Sí | Contraseña opcional; transferencia en TCP simple |
| Subida web | Tú, desde un navegador | Misma LAN, página HTTP en la placa | Sí | Ninguna, o la basic auth que añadas |
| HTTPS pull | La placa, con un temporizador o un botón | Cualquier red que llegue al servidor | Sí | TLS, si le das un certificado |
| Reflasheo por USB | Tú, con un cable | Ninguna | No | Acceso físico |
ArduinoOTA: empujar desde tu computadora
La librería ArduinoOTA del core Arduino-ESP32 escucha por defecto en el puerto 3232 y llama a la placa esp32- más su dirección MAC, a menos que uses setHostname(). Una herramienta envía una invitación UDP, y la placa abre una conexión TCP de vuelta a la computadora para descargar la imagen. Debes llamar a handle() en loop(), o la placa nunca responde.
Según el código fuente, la contraseña se hashea con SHA-256 y se comprueba con un challenge-response basado en PBKDF2-HMAC-SHA256. La imagen en sí llega por TCP simple, hasta donde muestra el código, con una comprobación MD5 solo de integridad. El mDNS viene activado por defecto, lo cual es cómodo y también es el punto donde los nombres .local fallan en Android y en algunos routers.
PlatformIO lo soporta directamente. Sus docs de Espressif 32 dicen que pongas upload_protocol = espota y upload_port con la dirección IP o el nombre mDNS, y --auth en upload_flags para la contraseña. Si además estás eligiendo toolchain, Arduino IDE vs PlatformIO explica las ventajas de cada uno.
Subida web: una página en la placa
Un web updater sirve un formulario de subida desde el propio ESP32. La página de OTA web update de Espressif recorre el ejemplo OTAWebUpdater: entra en http://esp32.local, inicia sesión con los valores por defecto admin y admin, y elige el binario compilado. La página dice que la placa y la computadora deben estar en la misma red, y no dice nada sobre cambiar ese login.
ElegantOTA envuelve la misma idea en una página más bonita. Su edición gratuita hace actualizaciones de firmware y de sistema de archivos, verificación MD5 y basic auth HTTP opcional, bajo la licencia AGPL-3.0. La actualización automática y la descarga directa son funciones Pro. Con ESPAsyncWebServer necesitas el flag de build ELEGANTOTA_USE_ASYNC_WEBSERVER=1, y el README avisa de que no puedes usar el servidor síncrono y el asíncrono en un mismo firmware.
El punto débil es el HTTP simple. Una contraseña escrita en un formulario HTTP cruza tu Wi-Fi sin cifrar, el mismo límite que tiene un portal cautivo abierto, como explica la comparativa de provisioning. En una LAN doméstica puede ser aceptable. En una red compartida, no.
HTTPS pull: la placa descarga la imagen
Con un pull, es la placa la que decide cuándo actualizarse. En ESP-IDF, esp_https_ota() lo hace en una sola llamada a partir de una URL, y esp_https_ota_begin(), perform() y finish() te dan control sobre el bucle. En el core de Arduino, HTTPUpdate hace el mismo trabajo. Envía la versión actual en un header x-ESP32-version y trata una respuesta 204 o 304 como "no hay actualización", así que el servidor puede decidir qué enviar.
Es el único método que funciona a través de internet y no necesita a nadie cerca. También es el método donde más importan los detalles de seguridad, así que tienen su propia sección más abajo.
Reflasheo por USB: nada de OTA
Un flasheo por USB solo necesita un slot de app, la placa al alcance y un cable. Es lo que hace el flasher desde el navegador, y vuelvo a él con los números de OpenGizmo más abajo.
¿Cómo se actualiza un ESP32 desde GitHub Releases?
GitHub Releases es un lugar gratuito para alojar archivos .bin con versión, y la placa puede descargarlos con un HTTPS pull. Tres detalles deciden si funciona.
- Sube la imagen de la app, no el flash combinado. Un OTA escribe una sola imagen de app en un slot, así que sube solo la app. Un archivo combinado incluye también el bootloader y la tabla de particiones, que no son una imagen de app. Las releases de OpenGizmo ya publican la app sola como
release-firmware.bin, junto a las piezas del bootloader, la tabla de particiones yboot_app0. - Espera una redirección. Los docs de assets de releases de GitHub dicen que los clientes deben manejar tanto una respuesta 200 como una 302. El constructor de HTTPUpdate desactiva las redirecciones por defecto, según el código fuente, así que una 302 hace fallar la actualización hasta que llames a su método
setFollowRedirects(). En ESP-IDF, los docs de HTTPS OTA añaden que los certificados CA de los destinos de las redirecciones también deben estar encert_pem. - Cuidado con el límite de peticiones. La API REST permite 60 peticiones por hora por dirección IP sin autenticación. No verifiqué si las descargas simples de assets cuentan, así que consulta pocas veces: una vez al día sobra para un gadget de escritorio.
Un diseño más limpio separa la comprobación de la descarga: consulta un archivo de versión diminuto y descarga el .bin solo cuando el número es mayor. La API de releases también lista un digest SHA-256 por cada asset. Para el release-firmware.bin del Ticker muestra sha256:647b987e..., que leí de la API el 14 de noviembre de 2026, así que una placa podría compararlo con el digest de lo que escribió.
Aquí no publico un ejemplo de código, porque no compilé ninguno para este post. Las llamadas a la API de arriba están en los docs enlazados, y cada una trae un ejemplo.
¿Qué distribución de particiones necesita el OTA?
El OTA necesita una partición OTA data y dos slots de app OTA, cada uno lo bastante grande para tu app. El tamaño del slot es donde se atascan los proyectos. El core Arduino-ESP32 incluye varias tablas, y leí sus definiciones para compararlas con un firmware real: la app del Gizmo Ticker v1.2.0, que pesa 1.796.736 bytes según su release en GitHub.

| Tabla (core Arduino-ESP32) | Slots de app | Tamaño del slot (bytes) | Tamaño del slot (MiB) | ¿Cabe la app de 1.796.736 B? |
|---|---|---|---|---|
| huge_app.csv | 1 (ota_0) | 0x300000 = 3.145.728 | 3,00 | Sí, pero sin segundo 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 de margen |
| default_8MB.csv | 2 | 0x330000 = 3.342.336 | 3,19 | Sí, necesita 8 MB de flash |
Las definiciones están en los archivos del core default.csv, min_spiffs.csv, default_8MB.csv y huge_app.csv. Las cuatro mantienen nvs en 0x9000 con 0x5000 bytes y la primera app en 0x10000. La guía de la tabla de particiones lista estas y los demás esquemas completos. Los slots de 1,25 MiB de la tabla por defecto son la trampa: un firmware con una pila TLS, un servidor web asíncrono y una aplicación web dentro puede superar ese tamaño, y la actualización falla.
Dos reglas más de la guía de tablas de particiones de Espressif: las particiones de app deben estar en límites de 64 KB (0x10000), y la partición OTA data mide 0x2000 bytes. Cambiar la tabla ya queda fuera del camino OTA seguro, así que pasar de una tabla de un slot a una de dos slots es un flasheo único por USB.
¿Cómo haces seguro el OTA: HTTPS, firma y rollback?
Existen cuatro protecciones distintas, y cada una responde a una pregunta diferente: si es el servidor correcto, si la imagen es mía, si es defectuosa y si es más antigua que la que ya ejecuto.
| Pregunta | Mecanismo | Qué necesita | Qué no hace |
|---|---|---|---|
| ¿Es el servidor correcto? | TLS con cert_pem o el bundle de certificados | Un certificado raíz en la flash, o crt_bundle_attach | No prueba que el archivo sea tuyo |
| ¿Es mía esta imagen? | Imágenes firmadas: Secure Boot v2, o la comprobación de firma solo por software | Una clave de firma; Secure Boot v2 quema eFuses | El modo solo software no detiene a quien pueda escribir en la flash |
| ¿Es defectuosa esta imagen? | Rollback al slot OTA anterior | Dos slots, un bootloader compilado con la opción de rollback | Solo se hace rollback entre slots OTA, no a una app factory |
| ¿Es más antigua esta imagen? | Anti-rollback con una versión de seguridad en eFuse | Una versión de seguridad en la app, comparada con el eFuse | No se puede deshacer una vez escrito el eFuse |
Comprobación del servidor. La página de ESP-IDF dice que el certificado raíz en formato PEM va en cert_pem, y recomienda la raíz del servidor, no un intermedio, porque las raíces duran más. También dice que si no se define el transporte se usa TLS por defecto, así que una URL http:// falla a menos que esté activado CONFIG_ESP_HTTPS_OTA_ALLOW_HTTP. Como alternativa, crt_bundle_attach verifica contra el ESP x509 Certificate Bundle.
Esto importa para el propio código de OpenGizmo. El cliente de datos de mercado del Gizmo Ticker llama a clientSecure.setInsecure() en api.cpp, lo que cifra el tráfico pero acepta cualquier certificado. Es un intercambio razonable para el precio de una cripto. Sería malo para un firmware, porque cualquiera que pueda suplantar al servidor en tu red podría enviarte código. Un cliente OTA debe verificar el servidor.
Firma. La página de Secure Boot v2 de Espressif dice que la app se verifica en cada actualización OTA, y que en el ESP32 clásico Secure Boot v2 requiere la revisión de chip v3.0 o posterior. Se activa mediante eFuses, así que planifica antes las claves. El modo solo software comprueba las firmas durante el OTA, y la página advierte de que no protege contra un atacante con acceso de escritura a la flash.
Rollback. El rollback de ESP-IDF es una opción del bootloader, CONFIG_BOOTLOADER_APP_ROLLBACK, que la página de OTA dice que viene activada por defecto en ESP-IDF. Una imagen nueva arranca en estado pending-verify, y si la app nunca llama a esp_ota_mark_app_valid_cancel_rollback(), el bootloader la salta en el siguiente arranque. El código de arranque de Arduino-ESP32 en esp32-hal-misc.c tiene hooks para esto, verifyOta() y verifyRollbackLater(). No verifiqué si el bootloader precompilado de Arduino tiene el rollback activado, así que comprueba tu propia build antes de confiar en él. La clase Update del core también tiene canRollBack() y rollBack() para arrancar el otro slot a mano.
ESPHome toma el camino gestionado: su componente OTA ofrece una plataforma esphome, una web_server y una http_request que descarga desde un servidor, con el safe mode activado automáticamente. Si prefieres no construir nada de esto, mira ESPHome vs firmware personalizado.
¿Usa OpenGizmo el OTA?
No. Busqué en los tres repositorios del firmware y en las versiones de gizmo-common que fijan (v2.5.1 para el Ticker y el Reolink Switch, v2.4.0 para la Camera) las cadenas ota, ArduinoOTA, HTTPUpdate, Update.h y esp_ota, y el 14 de noviembre de 2026 no encontré código OTA. El Gizmo Ticker, el Gizmo Reolink Switch y la Gizmo Camera establecen todos board_build.partitions = huge_app.csv, y el comentario de esa misma línea dice "One 3 MB app slot (no wireless updates), the same in every OpenGizmo firmware". Puedes verlo en el platformio.ini del Ticker.

Las actualizaciones van por USB. Cada página de proyecto tiene una tarjeta que flashea la última release desde el navegador, como muestra la guía de ESP Web Tools. Tres cosas hacen que funcione bien aquí, y todas están en los repositorios:
- La aplicación web está dentro del firmware.
gizmo-commonla sirve desde assets incluidos en la imagen de la app, así que hay un solo archivo que actualizar, no una imagen de sistema de archivos aparte. - Los ajustes sobreviven. El flasher escribe cuatro partes y nunca borra la región
nvs, así que una actualización por USB conserva el Wi-Fi y los ajustes guardados. - La versión se ve. Cada build informa su versión en
/api/device, y el workflow de release comprueba que la versión sea nueva antes de publicar.
El coste es real: necesitas la placa y un cable, y una placa cerrada en su carcasa o montada fuera de alcance es un fastidio de actualizar.
Con un solo slot, de todos modos, no hay espacio para un OTA. Los tamaños de las apps en las releases son 1.796.736 bytes (Ticker v1.2.0), 1.778.336 (Reolink Switch v1.2.0) y 1.722.192 (Camera v1.0.0), así que ninguna cabe en los slots de 1,25 MiB de default.csv.
¿Cómo se añadiría el OTA encima?
Esto es un plan, no algo que haya construido. La XIAO ESP32-S3 tiene 8 MB de flash según la wiki de Seeed, así que default_8MB.csv da dos slots de 3,19 MiB, y las apps del Ticker y del Reolink caben en cada uno. La flash de la placa de la Camera conviene comprobarla en tu módulo. Los pasos serían:
- Publicar una release con la nueva tabla de particiones por USB, porque la tabla queda fuera del camino OTA seguro. El flasher ya escribe
release-partitions.binen 0x8000. - Añadir un HTTPS pull que consulte el manifiesto de la release o un archivo de versión, y descargue
release-firmware.binsolo cuando sea más nuevo. - Verificar el servidor con el bundle de certificados, nunca con
setInsecure(), y comparar el SHA-256 del asset. - Marcar la imagen nueva como válida solo cuando el servidor web y el Wi-Fi estén en marcha, para que una imagen defectuosa haga rollback.
El precio es que la flash ahora guarda dos copias de la app, así que el área de app se reparte entre ellas, y que hay que escribir código que decida cuándo es seguro reiniciar un dispositivo que alguien está mirando.
¿Qué método OTA del ESP32 deberías usar?
Usa ArduinoOTA con PlatformIO mientras desarrollas, porque quita el cable del ciclo de editar y probar. Usa una página de subida web cuando otra persona tiene que actualizar unas pocas placas y puedes proteger la página. Usa un HTTPS pull cuando hay muchas placas fuera de alcance, y solo con verificación de certificados, comprobación de tamaño y rollback activos. Usa USB cuando la placa está en tu escritorio, el firmware es pequeño y los ajustes deben sobrevivir, que es donde está OpenGizmo hoy.
El límite de esta comparativa es que leí los docs y el código fuente y no ejecuté ninguno de los métodos, así que no tengo tiempos, tasas de fallo ni cifras de consumo. Lo primero que debes comprobar en tu propio proyecto es el tamaño del slot frente a tu app. Después mira cómo el flasher construye y sube las releases, y lee el post de la tabla de particiones antes de cambiar la tuya.
Preguntas frecuentes
Encuentra respuestas rápidas a las preguntas más comunes sobre este tema.
Sí, con un HTTPS pull. La placa pide el asset .bin de la release, y GitHub responde con una redirección, así que el cliente HTTP debe seguir redirecciones. Después escribe el archivo en el slot OTA libre. HTTPUpdate, en el core Arduino-ESP32, trae las redirecciones desactivadas por defecto, así que tienes que activarlas.
Autor
Mauro Brambilla¿Listo para montar tu propio gizmo?
Elige un proyecto open source con ESP32 y sigue su guía paso a paso, desde la lista de componentes y el cableado hasta el firmware y el primer arranque.





