Qué es ESPHome y cómo crear sensores baratos para Home Assistant

Llega un momento en el que el mercado se queda corto. Quieres un sensor que te avise si el cartero ha echado cartas en el buzón. O necesitas medir la humedad de la tierra de tus 5 macetas sin gastarte 150€ en sensores Zigbee. O quizás quieres controlar una tira LED con efectos personalizados que ninguna app comercial ofrece.

La solución no está en comprar más dispositivos de marca, sino en fabricarlos tú mismo. Y antes de que cierres la pestaña pensando «yo no sé programar en C++ ni soldar cables», déjame presentarte a tu nuevo mejor amigo: ESPHome.

ESPHome es la herramienta que ha democratizado la electrónica DIY. Te permite coger un microchip de 3€ y convertirlo en un dispositivo inteligente de gama alta, totalmente integrado en Home Assistant, escribiendo solo unas líneas de texto simple.

¿Qué es ESPHome? La revolución del «No-Code» para hardware

Tradicionalmente, programar un microcontrolador (como un Arduino) requieria escribir código complejo, compilar librerías y pelearse con errores de sintaxis. ESPHome elimina todo eso.

Funciona mediante archivos de configuración YAML, el mismo lenguaje que ya usas en Home Assistant. Tú solo le dices al sistema: «Tengo un sensor conectado al pin 5», y ESPHome se encarga automáticamente de escribir el código C++, compilarlo e instalarlo en la placa.

¿Por qué elegir ESPHome frente a Tasmota o Arduino?

Si llevas tiempo en esto, te sonará Tasmota (muy usado para liberar enchufes inteligentes chinos) o el entorno Arduino. ¿Por qué ESPHome ha arrasado en la comunidad de Home Assistant?

Los protagonistas: ESP32 vs ESP8266 (NodeMCU/D1 Mini)

Para usar ESPHome necesitas un «cerebro». Existen dos familias de chips principales que cuestan menos que un café y que debes conocer.

• ESP8266 (D1 Mini / NodeMCU): El veterano. Es barato, pequeño y tiene Wi-Fi.

  Uso ideal: Sensores simples (puerta, temperatura), relés para luces o proyectos donde el espacio es crítico.

• ESP32: El hermano mayor vitaminado. Tiene Wi-Fi y Bluetooth, es más rápido y tiene más pines.

  Uso ideal: Cámaras (ESP32-CAM), Proxys Bluetooth para Home Assistant, control de pantallas o proyectos con muchos sensores a la vez.

Para empezar, te recomiendo comprar un pack de D1 Mini (ESP8266). Son indestructibles, muy baratos y perfectos para aprender.

La magia de la «API Nativa» (Adiós al retardo)

Aunque ESPHome soporta el protocolo MQTT del que ya hablamos, su gran ventaja es su API Nativa.

La API Nativa conecta tu sensor directamente con Home Assistant mediante un protocolo super optimizado. Es más rápido que MQTT, mucho más estable y, lo mejor de todo, permite que Home Assistant configure el dispositivo automáticamente en cuanto lo conectas a la corriente.

Hardware necesario: Tu kit de inicio por menos de 10€

Lo mejor de ESPHome no es el software, es el precio. Por lo que te cuesta un solo sensor de puerta de una marca conocida, aquí puedes fabricarte cinco. Vamos a llenar tu carrito de la compra con los componentes esenciales.

El cerebro: Diferencias entre ESP8266 y ESP32

Ya los mencionamos en la introducción, pero ahora vamos a ver cuál debes elegir para tu proyecto específico. Equivocarse aquí no es grave (son baratos), pero puede limitar lo que hagas después.

Cuándo usar ESP8266 (D1 Mini, NodeMCU)

El ESP8266 es el «guerrero low-cost». Tiene un solo núcleo de procesamiento y menos memoria, pero consume muy poco y es extremadamente compacto.

• Elige el modelo «D1 Mini»: Es del tamaño de una moneda de 2€. Es perfecto para esconderlo dentro de cajas de luz o detrás de muebles.
• Uso recomendado: Sensores de temperatura, botones simples, relés para encender luces y tiras LED analógicas (blancas).

Cuándo usar ESP32 (Bluetooth, más pines, mayor potencia)

El ESP32 es la evolución. Tiene doble núcleo, más pines para conectar cosas y, lo más importante: Bluetooth.

• Bluetooth Proxy: Esta es la «killer feature». Un ESP32 con ESPHome puede actuar como antena Bluetooth para Home Assistant. Si tienes un termómetro Xiaomi que no llega a tu servidor, pones un ESP32 cerca y este repetirá la señal vía Wi-Fi.
• Uso recomendado: Cámaras (ESP32-CAM), control de pantallas, audio, o si quieres usarlo como extensor de Bluetooth.

Sensores baratos compatibles (Temperatura, Humedad, Presencia, Luz)

Aquí es donde ESPHome humilla a los sensores Zigbee comerciales en precio. Estos son los componentes «pata negra» que recomendamos:

Actuadores básicos (Relés, LEDs, Zumbadores)

No solo de medir vive la domótica; a veces queremos «hacer» cosas.

• Relés (Relays): Permiten encender aparatos de 220V (como una lámpara o un ventilador) usando la señal de 3.3V del chip. Ojo: Manipular 220V requiere precaución extrema.
• LEDs Direccionables (WS2812B): Las famosas tiras «Neopixel». Puedes controlar el color de cada LED individualmente para crear efectos de aviso.
• Zumbadores (Buzzers): Pequeños altavoces para pitar cuando se abre una puerta o termina la lavadora.

Herramientas físicas necesarias (Cables Dupont, Breadboard, USB)

Para esta guía NO necesitas soldador. Vamos a usar el sistema de prototipado rápido.

• Breadboard (Placa de prototipos): Una tabla con agujeros conectados internamente. Pinchas el chip y los cables, y todo funciona por contacto. Sin estaño ni quemaduras.
• Cables Dupont: Cables con conectores macho/hembra en las puntas. Son el «Lego» de la electrónica.
• Cable USB de DATOS: Parece una tontería, pero el 50% de los problemas de los novatos es usar un cable USB que solo sirve para cargar (el que venía con un vapeador o un juguete). Asegúrate de que tu cable transmite datos.

Primeros pasos: Instalación y configuración del entorno

Ya tienes tu placa ESP8266 o ESP32 encima de la mesa. Ahora toca darle vida. A diferencia de otros sistemas, ESPHome tiene una interfaz visual excelente (el Dashboard) desde donde gestionarás toda tu flota de dispositivos.

Métodos de instalación de ESPHome

Dependiendo de cómo tengas montado tu servidor, tienes dos caminos:

Instalación como Add-on en Home Assistant (Recomendado)

Si utilizas Home Assistant OS o Supervised, esta es la vía rápida. El Dashboard de ESPHome se integra dentro de tu menú lateral de Home Assistant.

1. Ve a Ajustes > Complementos (Add-ons) > Tienda.
2. Busca «ESPHome».
3. Dale a Instalar y activa las casillas «Iniciar al arranque» y «Mostrar en la barra lateral».
4. Pulsa Iniciar. En unos segundos, tendrás la pestaña ESPHome lista a la izquierda.

Instalación vía Docker o Python (CLI) para usuarios avanzados

Si seguiste nuestra guía de virtualización con Proxmox y prefieres tener los servicios separados en contenedores LXC o Docker, puedes instalar el Dashboard de forma independiente.

Simplemente lanza este contenedor Docker:

docker run -d --name="esphome" -p 6052:6052 -v /path/to/config:/config esphome/esphome

Creación de tu primer «Nodo» o dispositivo

Vamos a crear el firmware para tu placa. En el Dashboard de ESPHome, verás un botón grande que dice «+ NEW DEVICE».

El asistente de configuración (Wizard)

El sistema te guiará paso a paso. No te preocupes, es difícil romper nada aquí:

1. Nombre: Ponle algo descriptivo y sin espacios (ej: sensor-salon).
2. Dispositivo: Selecciona tu placa.
   • Si es una D1 Mini o NodeMCU, elige ESP8266.
   • Si es una placa moderna, elige ESP32.
3. Clave de encriptación: El asistente generará una «Encryption Key» para la API. Guárdala (aunque se queda en el fichero YAML), es la contraseña que usará Home Assistant para hablar con el dispositivo.

Entendiendo la estructura básica del YAML (esphome, wifi, logger, api)

Una vez creado, pulsa en «EDIT». Verás un archivo de texto. Esto es el ADN de tu dispositivo. Aunque parece código, es solo una lista de configuraciones:

esphome:
  name: sensor-salon

esp8266:
  board: d1_mini

# Configuración de red
wifi:
  ssid: "MiCasa_2.4G"
  password: "TuContraseñaWifi"

# Componentes vitales
api:    # Permite hablar con Home Assistant
ota:    # Permite actualizaciones sin cables
logger: # Muestra logs de error por USB/Wifi

El proceso de Flasheo (Grabación)

Tenemos el código, pero está en tu ordenador, no en el chip. Toca transferirlo.

Primera carga por cable USB (Web Flasher vs. Serial)

La primera vez que programas una placa virgen, obligatoriamente tienes que conectarla por cable USB al servidor o al ordenador donde estés viendo el Dashboard.

Gracias a la tecnología moderna, ahora puedes hacerlo directamente desde el navegador (Chrome o Edge):

1. Conecta la placa al USB de tu PC.
2. En el Dashboard de ESPHome, pulsa los 3 puntos del dispositivo > Install.
3. Selecciona «Plug into this computer».
4. Se abrirá una ventana del navegador pidiendo permiso para acceder al puerto COM. Selecciónalo y dale a conectar.

Actualizaciones posteriores vía OTA (Over The Air)

Aquí viene la magia. Una vez que has hecho la primera carga por cable y el dispositivo se conecta a tu Wi-Fi, ya no necesitas el cable nunca más.

Para cambiar la configuración en el futuro (por ejemplo, para añadir un sensor nuevo a la misma placa), editas el YAML, pulsas Install y eliges «Wirelessly». ESPHome enviará el nuevo firmware por el aire en segundos. Puedes reprogramar un sensor que está sellado dentro de una pared sin abrirlo.

Convirtiendo sensores baratos en dispositivos inteligentes

Aquí es donde ocurre la magia. Vamos a conectar componentes físicos a los «Pines» (patillas metálicas) de tu placa y decirle a ESPHome qué hacer con ellos. No necesitas saber programación, solo copiar estos bloques en tu archivo YAML.

Configuración de sensores binarios (Binary Sensors)

Un sensor binario es aquel que solo tiene dos estados: Encendido/Apagado (ON/OFF). Son los más fáciles de configurar.

Botones físicos y sensores de contacto (Reed switch)

Imagina que quieres sensorizar una ventana. Usarás un interruptor magnético (Reed Switch) de 1€. Conectas un cable a un pin (ej: D2) y el otro a GND (Tierra).

binary_sensor:
  - platform: gpio
    pin:
      number: D2
      mode: INPUT_PULLUP # Vital: Evita lecturas fantasma si no pulsas
      inverted: true     # Para que salga "Cerrado" al juntar el imán
    name: "Ventana Salón"
    device_class: window

Sensores de movimiento (PIR) y radar (mmWave)

La mayoría de sensores PIR baratos (como el HC-SR501) funcionan igual que un botón: cuando ven movimiento, envían 3.3V a un pin.

binary_sensor:
  - platform: gpio
    pin: D1
    name: "Movimiento Pasillo"
    device_class: motion

Configuración de sensores de medición (Sensor Component)

Aquí hablamos de sensores que devuelven un número (25.5°C, 80% humedad, 300 lux).

Temperatura y Humedad (DHT11/22 vs. BME280/AHT10)

Es el «Hola Mundo» de ESPHome. Aunque el DHT11 es muy popular, recomendamos encarecidamente gastar 1€ más en un AHT10 o BME280 (que usa protocolo I2C) por su precisión y fiabilidad.

Configuración para DHT22 (Clásico):

sensor:
  - platform: dht
    pin: D4
    temperature:
      name: "Temperatura Salón"
    humidity:
      name: "Humedad Salón"
    model: DHT22
    update_interval: 60s

Sensores de luz (LDR y BH1750)

Para automatizar tus luces, necesitas saber cuánta luz natural hay. El BH1750 es digital y muy preciso (mide Luxes reales).

# Requiere habilitar i2c al principio del YAML
i2c:
  sda: D2
  scl: D1

sensor:
  - platform: bh1750
    name: "Luz Ambiental"
    address: 0x23
    update_interval: 60s

Lectura de voltaje analógico (ADC)

El pin A0 del ESP8266 permite leer voltajes. Útil para medir el nivel de batería de un dispositivo, la humedad del suelo con sensores resistivos o la luz con una fotorresistencia (LDR) barata.

El poder de los Filtros en ESPHome (Clave para datos limpios)

Esta es la diferencia entre un aficionado y un pro. Los sensores baratos son «ruidosos» (a veces dan picos absurdos) o envían demasiados datos. Los filtros limpian la señal antes de enviarla a Home Assistant.

Filtros básicos: Offset y Multiply

¿Tu termómetro marca 1 grado más que el termostato oficial? Corrígelo en origen.

sensor:
  - platform: dht
    # ... resto config ...
    temperature:
      name: "Temperatura Calibrada"
      filters:
        - offset: -1.0  # Resta 1 grado

Filtros de suavizado: Sliding Window Moving Average

Si tu sensor oscila mucho (ahora 20.1, luego 20.5, luego 20.2), usa este filtro para hacer una media de las últimas lecturas y enviar un valor estable y suave.

      filters:
        - sliding_window_moving_average:
            window_size: 15
            send_every: 15

Optimización de tráfico: Delta y Throttle

No quieres llenar la base de datos de Home Assistant con 50 lecturas por minuto si la temperatura no ha cambiado. Usa estos filtros para decir: «Solo envíame datos si la temperatura cambia más de 0.5 grados O si han pasado 5 minutos».

      filters:
        - or:
            - throttle: 300s
            - delta: 0.5

Controlando el mundo físico: Actuadores y Luces

Ya sabemos si hace frío o si alguien ha entrado en la habitación. Ahora vamos a hacer que la casa reaccione: encender una lámpara, bajar una persiana o activar el riego. Para ello, usamos los Actuadores.

Control de interruptores y relés (Switch Component)

El componente más básico es el switch. Sirve para cualquier cosa que se pueda encender o apagar.

switch:
  - platform: gpio
    pin: D1
    name: "Relé Riego"
    id: relay_riego

Relés mecánicos vs. Estado sólido

Para controlar aparatos de 220V (una lámpara de mesa), necesitas un intermediario. El pin del ESP8266 solo da 3.3V, insuficiente para mover nada grande.

• Relés Mecánicos (Los azules): Hacen «clic» al activarse. Son baratos y aguantan mucha potencia. Ideales para luces o electrodomésticos.
• Relés de Estado Sólido (SSR): Son silenciosos y muy rápidos, pero se calientan. Úsalos si vas a encender y apagar algo muy rápido (como un control de temperatura PID).

Funciones de enclavamiento (Interlock) y restauración de estado

ESPHome tiene funciones de seguridad que los dispositivos comerciales a veces olvidan.

Interlock (Vital para persianas): Si usas dos relés para controlar un motor de persiana (uno para subir, otro para bajar), NUNCA deben activarse a la vez o quemarás el motor. Con interlock, ESPHome apaga automáticamente uno antes de encender el otro.

switch:
  - platform: gpio
    pin: D1
    name: "Subir Persiana"
    interlock: [relay_bajar] # Bloquea al otro

  - platform: gpio
    pin: D2
    name: "Bajar Persiana"
    id: relay_bajar
    interlock: [relay_subir] # Bloquea al otro

Restore Mode: ¿Qué pasa si se va la luz? Puedes decidir si el relé debe volver a «OFF», a «ON» o recordar el estado que tenía antes del corte (RESTORE_DEFAULT_OFF).

Iluminación avanzada (Light Component)

Aquí es donde ESPHome brilla con luz propia (literalmente). Puedes crear efectos que harían palidecer a una bombilla Philips Hue.

Tiras LED monocromáticas y RGB

Para tiras LED «tontas» (las que cambian de color toda la tira a la vez), necesitas transistores MOSFET para amplificar la señal.

# Primero defines las salidas (pines)
output:
  - platform: esp8266_pwm
    pin: D1
    id: output_red
  - platform: esp8266_pwm
    pin: D2
    id: output_green
  - platform: esp8266_pwm
    pin: D3
    id: output_blue

# Luego creas la luz combinándolas
light:
  - platform: rgb
    name: "Tira LED Cocina"
    red: output_red
    green: output_green
    blue: output_blue

LEDs direccionables (Neopixel/WS2812b) y efectos

Las tiras WS2812b (Neopixel) permiten controlar cada LED individualmente. Solo necesitan 3 cables: 5V, GND y Datos.

light:
  - platform: neopixelbus
    type: GRB
    variant: WS2812x
    pin: D4
    num_leds: 60
    name: "Neopixel Gamer"
    effects:
      - rainbow:
      - pulse:
      - random:

Si quieres montar un sistema Ambilight detrás de tu TV o una iluminación gamer, estas son las tiras que necesitas.

Salidas genéricas (Output Component) y PWM

A veces no quieres encender o apagar, sino regular intensidad. Para eso usamos PWM (Pulse Width Modulation).

Esto permite atenuar (dimmear) una luz o controlar la velocidad de un ventilador pequeño. En el bloque de código de la tira RGB anterior, ya usamos esp8266_pwm. Si usas un ESP32, el componente se llama ledc y es mucho más potente, permitiendo frecuencias más altas para evitar el parpadeo en cámaras.

Automatización «On-Device»: Inteligencia sin depender del servidor

Hasta ahora, hemos usado el ESP8266/ESP32 como un simple «mensajero»: lee un dato y se lo envía a Home Assistant. Pero, ¿qué pasa si se cae el Wi-Fi? ¿O si Home Assistant se está reiniciando?

Si usas un interruptor inteligente comercial y se cae la red, a menudo te quedas a oscuras. Con ESPHome, puedes programar «reflejos» directamente en el chip. Esto es la Automatización On-Device.

Por qué automatizar en el ESP y no en Home Assistant

Imagina que tu cuerpo es tu casa inteligente. Home Assistant es tu cerebro (pensamiento complejo), pero ESPHome es tu médula espinal (reflejos).

• Velocidad instantánea: Al no viajar por el Wi-Fi, la reacción es de 0 milisegundos. Pulsas y enciende.
• Robustez total: Si un calefactor se sobrecalienta, el ESP lo apaga solo, incluso si el servidor se ha quemado.
• Resiliencia: Tu casa sigue funcionando (las luces encienden, las persianas bajan) aunque no tengas internet.

La lógica de disparadores (Triggers)

En ESPHome, todo funciona por «Causa y Efecto». Los disparadores escuchan eventos.

on_press, on_value_range, on_boot

Estos son los «oídos» de tu automatización:

• on_press: Ideal para botones físicos. Se activa al pulsar.
• on_value_range: Vigila un sensor numérico. «Si la temperatura pasa de 80ºC…».
• on_boot: Se ejecuta nada más enchufar el dispositivo. Útil para definir el estado inicial (ej: asegurar que la cafetera arranca APAGADA).

Acciones predefinidas (Actions)

Una vez que el disparador salta, ejecutamos una lista de órdenes. Esto se escribe anidado dentro del sensor en el YAML.

Controlar interruptores, retardos (delay) y condiciones (if/then)

Veamos un ejemplo práctico: Un temporizador de escalera. Pulsas el botón, se enciende la luz, espera 1 minuto y se apaga sola. Todo gestionado por el chip.

binary_sensor:
  - platform: gpio
    pin: D1
    name: "Pulsador Escalera"
    on_press:
      then:
        - switch.turn_on: relay_luz  # Enciende la luz
        - delay: 60s                 # Espera un minuto
        - switch.turn_off: relay_luz # Apaga la luz

Ahora un ejemplo de seguridad: Protección de sobrecalentamiento.

sensor:
  - platform: dht
    # ... configuración del sensor ...
    temperature:
      name: "Temperatura Caldera"
      on_value_range:
        above: 80.0
        then:
          - switch.turn_off: relay_caldera
          - logger.log: "¡EMERGENCIA! Apagando por seguridad."

Sincronización de acciones con Home Assistant

A veces quieres que tu dispositivo ESPHome controle algo que no está conectado a él físicamente (por ejemplo, que un botón ESPHome encienda una bombilla Zigbee de IKEA).

Para eso usamos la acción homeassistant.service. El ESP le «grita» a Home Assistant para que haga algo.

binary_sensor:
  - platform: gpio
    pin: D2
    name: "Botón Maestro"
    on_press:
      then:
        - homeassistant.service:
            service: light.toggle
            data:
              entity_id: light.bombilla_zigbee_salon

De esta forma, integras tu hardware DIY de 3€ perfectamente con el resto de tu ecosistema domótico.

Nivel Experto: Optimizaciones y funciones avanzadas

Ya sabes encender luces y leer sensores. Pero, ¿qué pasa si quieres poner un sensor en el buzón donde no hay enchufes? ¿O si tienes 20 persianas y no quieres copiar y pegar el mismo código 20 veces? Aquí es donde optimizamos.

Gestión de energía y baterías (Deep Sleep)

El chip ESP8266/ESP32 es muy potente, pero esa potencia tiene un coste: el Wi-Fi consume mucha batería. Si conectas un ESP encendido todo el rato a una pila, durará menos de 24 horas.

La solución es el Deep Sleep (Sueño Profundo). El chip se apaga casi por completo, consumiendo apenas unos microamperios, y solo se despierta para trabajar unos segundos.

Configuración del componente deep_sleep

Para activar esto, añadimos un bloque al final de nuestro YAML. Con esto, el dispositivo se despertará, hará sus tareas (leer sensores), y se volverá a dormir.

deep_sleep:
  run_duration: 10s   # Tiempo que permanece despierto para enviar datos
  sleep_duration: 10min # Tiempo que duerme (ahorrando batería)

Despertar por tiempo vs. Despertar por pin (Wakeup Sources)

Hay dos formas de sacar al chip de su sueño:

• Por Tiempo (Timer): Como en el ejemplo anterior. «Despierta cada 10 minutos, mide la temperatura y duerme». Ideal para termómetros.
• Por Pin (GPIO): «Duerme para siempre hasta que alguien pulse este botón». Ideal para timbres, sensores de puerta o buzones. Es lo que permite que una batería dure meses.

Para despertar por Pin en un ESP32:

esp32_ble_tracker: # Desactivar Bluetooth ahorra batería

deep_sleep:
  # ...
  wakeup_pin:
    number: GPIO33
    inverted: true
    mode: INPUT_PULLUP

Uso de Substitutions y Packages

Cuando empieces a domotizar toda la casa, te encontrarás con 15 archivos YAML casi idénticos. Mantener eso es una pesadilla. ESPHome nos ofrece herramientas para evitar repetirnos.

Cómo reutilizar código YAML para flotas de dispositivos

Las Substitutions son como variables que defines al principio del archivo. En lugar de buscar y reemplazar «Habitación 1» por «Habitación 2» en 50 líneas, solo lo cambias arriba.

substitutions:
  nombre_dispositivo: "persiana-salon"
  nombre_amigable: "Persiana Salón"

esphome:
  name: ${nombre_dispositivo}
  friendly_name: ${nombre_amigable}

Gestión de secretos (secrets.yaml)

Nunca, bajo ningún concepto, escribas tu contraseña de Wi-Fi directamente en el archivo del nodo si planeas compartir tu código. Usa el archivo secrets.yaml (que está en la carpeta de configuración de ESPHome).

En secrets.yaml:

wifi_ssid: "MiRedSecreta"
wifi_pass: "ContraseñaSuperDificil"
mqtt_pass: "ClaveMQTT"

En tu nodo (salon.yaml):

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_pass

Global Variables y paso de datos internos

A veces necesitas que el ESP recuerde cosas, como «¿Cuántas veces se ha abierto la puerta hoy?». Para eso sirven las Global Variables. Son variables que viven en la memoria RAM del chip.

globals:
  - id: contador_aperturas
    type: int
    restore_value: no
    initial_value: '0'

binary_sensor:
  - platform: gpio
    # ...
    on_press:
      then:
        - lambda: |-
            id(contador_aperturas) += 1;
            ESP_LOGD("main", "La puerta se ha abierto %d veces", id(contador_aperturas));

El uso de lambda (código C++ incrustado) te da un poder ilimitado para crear lógica compleja sin depender de Home Assistant.

La frontera final: Lambdas y Código C++ personalizado

YAML es genial para configurar cosas estáticas, pero a veces la lógica de la vida real es demasiado compleja para una lista de «si pasa esto, haz aquello». A veces necesitas matemáticas, bucles o condiciones complejas.

Aquí entran las Lambdas. Son pequeñas ventanas en tu archivo YAML donde puedes escribir código C++ puro. Es como abrir el capó del coche y ajustar el motor directamente.

¿Qué son las Lambdas en ESPHome?

Una Lambda es un bloque de código que se ejecuta dentro del procesador del ESP. Se define con la sintaxis lambda: |-. Todo lo que escribas debajo se compilará tal cual.

La gran diferencia es el retorno:

• En un sensor, la lambda debe terminar con return valor; (devuelve el dato a publicar).
• En una acción (dentro de un on_press), la lambda ejecuta órdenes pero no necesita devolver nada.

Insertando lógica compleja con C++ dentro de YAML

Vamos a ver cómo manipular los datos al nivel más bajo posible.

Lectura y manipulación de sensores con .state

Imagina que quieres crear un «Sensor Virtual» que calcule la sensación térmica basándose en la temperatura y la humedad que miden otros dos sensores físicos.

Para acceder al valor de cualquier componente en C++, usamos su id(nombre_id).state.

sensor:
  - platform: template
    name: "Sensación Térmica (Índice de Calor)"
    unit_of_measurement: "°C"
    lambda: |-
      float temp = id(mi_temperatura).state;
      float hum = id(mi_humedad).state;

      // Si algún sensor falla (es NaN), no calculamos nada
      if (isnan(temp) || isnan(hum)) {
        return NAN;
      }

      // Fórmula simplificada del Heat Index
      return temp + 0.5555 * ((temp - 14.5) + (hum / 100.0));
    update_interval: 60s

Llamadas a servicios de Home Assistant desde C++

A veces, YAML se queda corto para llamar a Home Assistant con datos dinámicos. Desde una lambda, puedes construir llamadas complejas.

Este ejemplo envía una notificación al móvil con el valor exacto de voltaje cuando la batería está crítica:

binary_sensor:
  - platform: gpio
    name: "Alerta Batería Baja"
    on_press:
      then:
        - lambda: |-
            // Construimos el mensaje dinámicamente
            float voltios = id(sensor_voltaje).state;
            std::string mensaje = "¡Atención! Batería al " + to_string(voltios) + "V";
            
            // Llamamos al servicio de Home Assistant
            id(homeassistant_service).call("notify.mobile_app_mi_movil", mensaje);

Custom Components: Cuando el YAML no es suficiente

¿Qué pasa si tienes un sensor industrial raro que compraste en eBay y no aparece en la lista de componentes oficiales de ESPHome? No hay problema: puedes escribir tu propio driver.

Estructura de un componente externo

Puedes crear un archivo mi_sensor.h en la misma carpeta que tu YAML. Este archivo contendrá una clase de C++ que hereda de PollingComponent.

Luego, lo incluyes en tu YAML así:

esphome:
  includes:
    - mi_sensor.h

custom_component:
  - lambda: |-
      auto mi_sensor = new MiSensorPersonalizado();
      return {mi_sensor};

Importar librerías externas de Arduino

Lo mejor de ESPHome es que es compatible con el ecosistema PlatformIO. Si existe una librería de Arduino para tu sensor, puedes descargarla y usarla automáticamente.

Solo tienes que añadir la referencia a la librería en el bloque principal:

esphome:
  libraries:
    - "Adafruit NeoPixel"
    - "Wire"
    # Puedes poner incluso la URL de un repositorio Git

Mantenimiento, Seguridad y Solución de problemas

Crear un dispositivo es divertido, pero mantenerlo funcionando durante años requiere disciplina. Un ESP32 es un pequeño ordenador conectado a tu red; si no lo proteges, es una puerta trasera abierta.

Asegurando tus dispositivos (Native API Encryption y contraseñas OTA)

Por defecto, ESPHome intenta ser seguro, pero tú debes cerrar el candado. Hay dos barreras que siempre debes configurar:

1. Encriptación de la API: Cifra la comunicación entre el dispositivo y Home Assistant. Si un hacker entra en tu Wi-Fi y «escucha» el tráfico, solo verá ruido, no tus datos de sensores.
2. Contraseña OTA (Over-The-Air): Impide que alguien (o un vecino gracioso con conocimientos) suba un firmware malicioso a tu dispositivo de forma inalámbrica.

api:
  encryption:
    key: "Clave_Generada_Muy_Larga_De_Base64"

ota:
  password: "TuContraseñaSecretaOTA"

Interpretación de Logs y niveles de depuración (DEBUG vs. VERBOSE)

Cuando algo no funciona, el componente logger es tu mejor amigo. Puedes ver los logs conectando el cable USB o de forma inalámbrica desde el Dashboard.

Es vital elegir el nivel de detalle adecuado (level):

• INFO (Por defecto): Muestra eventos importantes (conexión Wi-Fi, arranque). Es lo ideal para producción.
• DEBUG: Muestra cada vez que un sensor lee un dato o una automatización se dispara. Úsalo cuando estés creando el dispositivo.
• VERBOSE / VERY_VERBOSE: Muestra TODO, incluyendo lecturas eléctricas internas.

Errores comunes de compilación y bootloops

Dos pesadillas recurrentes:

1. Error de compilación (YAML):
Suele ser un problema de indentación (espacios). En YAML, los espacios son sagrados. Si te falta una librería, el compilador te avisará en rojo.

2. El temido «Bootloop» (Reinicio infinito):
Has subido un código erróneo que hace que el chip se reinicie nada más arrancar. Entra en un bucle infinito de reinicios.

La solución: El «Safe Mode»
ESPHome es listo. Si detecta que el dispositivo se ha reiniciado más de 10 veces seguidas rápidamente, entra automáticamente en Modo Seguro. En este modo, no ejecuta tu código (ni sensores, ni luces), solo se conecta al Wi-Fi y espera una actualización OTA. Esto te permite subir un firmware corregido y salvar el dispositivo sin desmontarlo de la pared.

Estrategias de backup y recuperación de nodos

¿Qué pasa si cae un rayo y fríe tu ESP8266? ¿Pierdes tu configuración?

Con ESPHome, el hardware es desechable; el valor está en el software.

• Backup simple: Tu «dispositivo» es en realidad el archivo .yaml en la carpeta /config/esphome/. Haz copias de seguridad de esa carpeta regularmente.
• Recuperación total: Si un chip muere, compra otro igual (por 3€), conéctalo al PC y dale al botón «Install» usando el mismo archivo YAML. Home Assistant ni siquiera notará el cambio; para él, el dispositivo ha resucitado como si nada.

Conclusión: El poder de crear tu propia tecnología

Empezamos este artículo con un chip de 3 euros y lo hemos terminado con un dispositivo inteligente capaz de medir, actuar y pensar por sí mismo. ESPHome no es solo una herramienta; es la puerta de entrada al verdadero control domótico.

Mientras que comprar dispositivos comerciales te limita a lo que el fabricante decidió que necesitabas, ESPHome te permite construir exactamente lo que tú quieres.

---

Preguntas Frecuentes sobre ESPHome

¿Necesito saber programar en C++ para usarlo?

Rotundamente NO. El 95% de los usuarios de ESPHome nunca escriben una línea de C++. Todo se hace mediante archivos de configuración YAML (muy parecidos a los de Home Assistant). El sistema se encarga de traducir ese YAML a código máquina automáticamente.

¿Es mejor ESPHome o Tasmota?

Depende. Tasmota es genial para «liberar» dispositivos comerciales (como enchufes Sonoff o Shelly) porque ya viene precompilado y se configura vía web. ESPHome es superior para crear tus propios sensores desde cero gracias a su integración nativa con Home Assistant y su flexibilidad para combinar componentes.

¿Puedo conectar mi ESP a redes Wi-Fi 5GHz?

No. Las placas ESP8266 y ESP32 estándar solo tienen antena para 2.4GHz. Asegúrate de tener esta banda activa en tu router o no podrás conectarlas. Existen modelos nuevos (ESP32-C5) con soporte 5GHz, pero aún son raros y caros.

¿Qué pasa si me equivoco y el dispositivo entra en bucle?

No te preocupes. ESPHome tiene un sistema de Safe Mode. Si el chip se reinicia muchas veces seguidas por un error en tu código, entra automáticamente en un modo de emergencia donde solo activa el Wi-Fi y la OTA, permitiéndote subir una corrección sin tener que desmontar nada.

¿Te ha sido útil? ¡Compártelo con otros!

WhatsApp Facebook X (Twitter) Telegram

Únete a la Comunidad

Síguenos en nuestras redes para ver tutoriales en vídeo, ideas de decoración y trucos rápidos para tu hogar inteligente.