Como funciona la actualización sin cable en Arduino


¿Vale la pena el OTA en ESP32 si siempre pulso BOOT al cargar?

Imagina esto: Has perfeccionado tu prototipo basado en un ESP32. Lo instalas incluso integrado con Home Assistant integrado. Funciona perfecto… hasta que descubres un bug en el cálculo . ¿Y ahora? ¿Abrir el dispositivo sacar cables y pulsar BOOT otra vez? ¡Aquí entra el OTA para salvarte!
Sí, vale la pena implementarlo aunque la primera carga requiera el botón BOOT. Te explico paso a paso por qué.

La situación actual

Programar un ESP32 por USB/serial siempre exige pulsar BOOT (y a veces RESET) para entrar en modo de flasheo.
Esto es inherente al hardware, independientemente de si usas OTA o no.​

La clave del OTA

Después de esa primera carga, el OTA elimina el cable para siempre.

Paso 1 (instalación inicial):

  • Subes firmware con OTA incluido vía USB (sí, con BOOT).

Paso 2 (actualizaciones futuras):

  • El ESP32 se conecta a WiFi.
  • Envías nuevo firmware remotamente desde Arduino IDE (puerto de red), ESPHome o web server.
  • Cero cables, cero botones, cero contacto físico.

Código listo para usar (OTA básico)

Aquí un sketch mínimo basado en el ejemplo oficial BasicOTA. Cárgalo primero por USB:

#include <WiFi.h>
#include <ESPmDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
const char* ssid = "TU_WIFI"; // Cambia por tu red
const char* password = "TU_PASS"; // Cambia por tu clave
void setup() {
Serial.begin(115200);
Serial.println("Booting OTA");
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
while (WiFi.waitForConnectResult() != WL_CONNECTED) {
Serial.println("Connection Failed! Rebooting...");
delay(5000);
ESP.restart();
}
// Config OTA
ArduinoOTA.setHostname("OTA"); // Nombre visible en red
// ArduinoOTA.setPassword("admin"); // Descomenta para contraseña
ArduinoOTA
.onStart([]() {
String type;
if (ArduinoOTA.getCommand() == U_FLASH)
type = "sketch";
else
type = "filesystem";
Serial.println("Start updating " + type);
})
.onEnd([]() {
Serial.println("\nEnd");
})
.onProgress([](unsigned int progress, unsigned int total) {
Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
})
.onError([](ota_error_t error) {
Serial.printf("Error[%u]: ", error);
if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
else if (error == OTA_END_ERROR) Serial.println("End Failed");
});
ArduinoOTA.begin();
Serial.println("Ready");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
}
void loop() {
ArduinoOTA.handle(); // ¡Esencial! Mantiene OTA activo
// Aquí va tu código ...
}

Pasos para usar:

  1. Cambia SSID/PASS, compila y sube por USB (con BOOT).
  2. Abre Monitor Serie: anota la IP y hostname.
  3. En Arduino IDE: Herramientas > Puerto → selecciona el puerto de red («OTA at IP»).
  4. Sube sketches futuros sin cable.

Cuándo brilla el OTA

  • Instalaciones fijas: Cuadros eléctricos, sensores ocultos ,etc.
  • Flotas de dispositivos: 10+ ESP32 sin visitas.
  • Mantenimiento remoto: Bugs corregidos desde móvil.
  • Alta disponibilidad: Rollbacks automáticos.

Consideraciones clave

  • Seguridad: Activa contraseña con ArduinoOTA.setPassword(). Para prod, usa HTTPS/firmas.
  • Estabilidad: Siempre llama ArduinoOTA.handle() en loop.
  • WiFi: Reconexión auto si signal débil.

Conclusión práctica:

OTA = libertad total post-instalación. Una carga USB inicial, luego updates inalámbricos infinitos.

2024 04 06 19 25 03 Monitorización de gases con Arduino   Buscar con Google y 6 páginas más   Person

ESPurna: La «Chispa» Open-Source para Domótica con ESP32


ESPurna, palabra catalana y valenciana que significa «chispa» —una partícula incandescente de combustión o roce, o figurativamente una pequeña cantidad o persona ingeniosa—, adquiere nuevo sentido como firmware open-source para ESP8266 y ESP32. Desarrollado inicialmente por Xose Pérez y adaptado para ESP32 en forks como RDobrinov/espurna32, transforma placas económicas en hubs IoT para interruptores, luces y sensores. Soporta MQTT con auto-descubrimiento, Alexa, Google Assistant, modos de bajo consumo, hasta 5 redes WiFi, mDNS, NetBIOS y OTA vía web, ideal para domótica avanzada.​

esp8266 a6f

Características Destacadas de ESPurna

ESPurna gestiona switches con botones digitales/analógicos, pulsos configurables, sincronización de relés (todos iguales, solo uno ON) y estados al boot (ON/OFF/toggle). Incluye luces con color/brightness, sensores de potencia (voltaje, corriente, energía), temperatura/humedad (DHT, BME280), y LED notificadores para WiFi/relés/MQTT. Ofrece REST API para relays/sensores, backup/restore, AP/STA WiFi con IP estático, y protección contra KRACK en Arduino Core >=2.4.0; botones permiten toggle, AP mode (doble click), reboot (largo) o factory reset (extra largo).​

Preparación del Entorno con PlatformIO

PlatformIO en VSCode es la herramienta oficial para compilar ESPurna ESP32, gestionando Arduino-ESP32 core, lib_deps como FauxmoESP, AsyncTCP, MQTT y sensores.

Estos son los pasos resumidos para instalar el entorno:

  • Instala VSCode desde code.visualstudio.com, añade extensión PlatformIO IDE (marketplace)
  • Clona git clone https://github.com/RDobrinov/espurna32.git vía terminal (Terminal > New Terminal),
  • Aabre la carpeta con File > Open Folder.
  • PlatformIO detecta platformio.ini automáticamente
  • Descarga dependencias;
  • Edita para default_envs = esp32dev, board = esp32dev, framework = arduino, upload_speed = 921600,
  • Compila con icono check (Build).
  • Verifica logs en terminal para errores;
  • Reinicia VSCode o pio lib install si faltan paquetes.​

Instalación Paso a Paso en ESP32

Requisitos: Cable USB, drivers CH340/CP210x, esptool.py (pip install esptool). Pon ESP32 en bootloader (BOOT/GPIO0 a LOW al resetear/alimentar); verifica esptool.py --chip esp32 --port /dev/ttyUSB0 chip_id.​

  • Borrado: esptool.py --chip esp32 --port /dev/ttyUSB0 erase_flash.
  • Flasheo: esptool.py --chip esp32 --port /dev/ttyUSB0 write_flash -z 0x1000 espurna-esp32.bin (binario de releases).​
  • Alternativa PlatformIO: Build exitoso > Upload; Arduino IDE requiere boards ESP32 y abrir espurna.ino.​

Post-instalación: Conéctate a AP «espurna-XXXXXX» (pass: espurna123), accede 192.168.4.1 para WiFi/MQTT/OTA; soporta reverse proxy seguro.​

Integración con Home Assistant vía MQTT

Configura MQTT en web ESPurna (broker IP/usuario/pass/puerto 1883) y activa «Home Assistant MQTT Discovery» para auto-publicación de switches/luces/sensores. En HA: Añade integración MQTT (Configuración > Integraciones > MQTT), conecta broker (Mosquitto recomendado para retain y estabilidad). Dispositivos aparecen automáticamente vía topics homeassistant/switch/[device]/config; controla relés, mide potencia/RGB sin YAML. Evita «unavailable» en reinicios HA con retain flags; ideal para energy dashboards.​

ESPurna vs. ESPHome: Comparativa Detallada

AspectoESPurna​ESPHome ​
ConfiguraciónCompilación hardware-específica, web intuitivaYAML declarativo, compilación automática
Integración HAMQTT Discovery robusto, topics estándarNativa profunda, zero-config en HA
Facilidad de UsoAvanzados: control firmware detalladoPrincipiantes: automatizaciones rápidas
Soporte HardwareAmplio (sensores, relés, Alexa/Google/OTA)HA-optimizado, actualizaciones fluidas
PersonalizaciónEdición código, REST APIConfig centralizada, sin código directo
Curva AprendizajePronunciada por compilación manualBaja, ideal domótica compleja

ESPurna brilla en versatilidad MQTT y soporte multi-plataforma para expertos en IoT/hardware, mientras ESPHome prioriza simplicidad HA. Prueba ESPurna si buscas personalización profunda en ESP32 para NILM o sensores energéticos.​

    https://github.com/RDobrinov/espurna32