ESPHome es un sistema para generar firmware de microcontroladores a partir de una configuración YAML e integrarlos directamente en Home Assistant.
La solución natural a este problema es fabricar nuestro propio hardware. En luisllamas.es llevamos años programando microcontroladores ESP8266 y ESP32 en C++ mediante el IDE de Arduino.
Sin embargo, escribir código en C++ desde cero para gestionar la reconexión WiFi, mantener un socket abierto, publicar payloads estructurados y gestionar la disponibilidad (LWT) es un proceso repetitivo, tedioso y propenso a errores. Para evitar reinventar la rueda en cada nodo, el ecosistema de Home Assistant nos proporciona una herramienta extremadamente práctica: ESPHome.
¿Qué es ESPHome?
ESPHome es un sistema que nos permite crear firmwares personalizados para microcontroladores (ESP8266, ESP32, RP2040, etc.) escribiendo únicamente archivos de configuración en formato YAML, sin tocar una sola línea de código en C/C++.
El funcionamiento interno es muy elegante:
- Nosotros definimos el hardware (pines, sensores, relés) en un archivo YAML.
- El motor de ESPHome (escrito en Python) lee ese YAML y genera dinámicamente el código fuente en C++ correspondiente.
- Descarga las librerías necesarias de PlatformIO.
- Compila el código C++ en un binario (
.bin). - Flashea el binario en nuestro microcontrolador.
El resultado es un dispositivo IoT robusto, con gestión automática de reconexiones WiFi, control de reinicios por Watchdog, y soporte para actualizaciones inalámbricas (OTA - Over The Air).
ESPHome no elimina la necesidad de entender electrónica básica. Si conectamos un sensor al pin equivocado, alimentamos un módulo de 3.3V con 5V o mezclamos masa de forma incorrecta, el YAML no nos va a salvar. La configuración simplifica el software, no anula la física.
La API nativa frente a MQTT
Tradicionalmente, los dispositivos maker se comunicaban con el servidor mediante el protocolo MQTT. Aunque MQTT es excelente (y lo veremos en el próximo artículo), ESPHome utiliza por defecto su propia API Nativa.
La API nativa de ESPHome utiliza una conexión TCP persistente en el puerto 6053, codificando los datos mediante Protocol Buffers de Google.
Esto presenta tres ventajas arquitectónicas muy claras para nuestro servidor:
- Menor sobrecarga (Overhead): Protocol Buffers es un formato de serialización binario, mucho más ligero y rápido de procesar que las cadenas de texto JSON sobre MQTT.
- Latencia casi nula: Al mantener un socket TCP abierto directamente con el Core de Home Assistant, la latencia entre pulsar un botón en el ESP32 y que Home Assistant lo registre es de apenas un par de milisegundos.
- Auto-descubrimiento inmediato: Cuando conectas un nodo ESPHome a la corriente, Home Assistant lo detecta instantáneamente. Con un solo clic, todas las entidades (sensores, interruptores, diagnósticos) aparecen en la máquina de estados.
Instalación y primer flasheo
Para empezar a usar ESPHome en nuestra arquitectura basada en HAOS, instalaremos ESPHome Device Builder.
Debemos ir a la tienda de aplicaciones de Home Assistant, buscar “ESPHome Device Builder” e instalarlo. Esto levanta un contenedor con el entorno de compilación y una interfaz web para gestionar las configuraciones.
La primera instalación y las actualizaciones OTA
Para que podamos actualizar nuestra placa por WiFi (OTA), primero necesita tener el firmware de ESPHome instalado con las credenciales de nuestra red.
En una placa nueva, la primera instalación normalmente se realiza por USB desde un ordenador. Un navegador compatible con WebSerial puede instalar el firmware siguiendo el asistente; según el chip y el adaptador USB, todavía puede ser necesario instalar su controlador.
Una vez completado el primer flasheo, podemos desconectar el ESP32 del ordenador. Las siguientes compilaciones y actualizaciones podrán instalarse por el aire mediante OTA.
Si un nodo ESPHome va a quedarse fijo en una ubicación importante, suele compensar reservarle la IP en el router. No porque ESPHome lo necesite siempre, sino porque hace más fácil depurarlo, entrar en sus logs y localizarlo rápidamente cuando algo falla.
Anatomía de un nodo ESPHome (YAML)
Vamos a analizar el código estructurado de un nodo real. Supongamos que queremos fabricar un sensor de temperatura de alta precisión para un acuario utilizando una sonda sumergible Dallas DS18B20, conectada al pin GPIO4 de un ESP32.
El archivo de configuración YAML se divide en bloques lógicos. Así sería el código completo para tener el sensor reportando datos a Home Assistant:
# 1. METADATOS DEL DISPOSITIVO
esphome:
name: sensor-acuario
friendly_name: "Sensor de Acuario"
# 2. DEFINICIÓN DEL HARDWARE CORE
esp32:
board: esp32dev
framework:
type: arduino
# 3. COMUNICACIONES Y SERVICIOS BASE
wifi:
ssid: !secret wifi_ssid
password: !secret wifi_password
# Habilita la API nativa para Home Assistant
api:
encryption:
key: !secret api_encryption_key
# Habilita las actualizaciones por el aire
ota:
- platform: esphome
password: !secret ota_password
# 4. DEFINICIÓN DE COMPONENTES FÍSICOS
# El bus 1-Wire necesario para el sensor Dallas/DS18B20
one_wire:
- platform: gpio
pin: GPIO4
sensor:
# Definimos la plataforma del sensor
- platform: dallas_temp
address: 0x51011453ABF5AA28 # La dirección única interna del sensor
name: "Temperatura Agua Acuario"
unit_of_measurement: "°C"
accuracy_decimals: 2
update_interval: 10s
# Sensores de diagnóstico internos (opcionales pero recomendados)
- platform: wifi_signal
name: "Señal WiFi Acuario"
update_interval: 60s
El concepto de plataformas
La verdadera gracia de ESPHome radica en el bloque sensor (o switch, binary_sensor, display).
ESPHome tiene soporte nativo para cientos de plataformas. Si mañana decidimos añadir una pantalla OLED I2C para ver la temperatura físicamente en el acuario, no tenemos que buscar librerías de Adafruit, inicializar el bus I2C en el setup(), ni gestionar la limpieza del buffer en el loop().
Simplemente añadimos el bloque i2c: definiendo los pines SDA y SCL, y un bloque display: con la plataforma ssd1306_i2c. ESPHome se encarga de todo el código de bajo nivel durante la compilación.
Lógica en el edge
ESPHome no es solo un puente “tonto” que envía datos al servidor. Es capaz de ejecutar automatizaciones en el propio microcontrolador.
Si implementamos un relé en el ESP32 para encender el calentador del acuario, podemos programar en el propio YAML de ESPHome una regla de seguridad: “Si la temperatura baja de 24°C, enciende el relé”.
# Fragmento de automatización on-device en ESPHome
sensor:
- platform: dallas_temp
# ...
on_value_range:
- below: 24.0
then:
- switch.turn_on: rele_calentador
Esta lógica se ejecuta en el propio ESP32. Si Home Assistant o la red se caen, el microcontrolador puede seguir manteniendo la temperatura del acuario de forma autónoma.
