Monitor de CO₂ DIY con ESP32 y Home Assistant: controla la calidad del aire en casa

De regalo navideño a proyecto DIY

Estas Navidades, mi hermana se pidió un monitor de CO₂. Yo, hasta ese momento, ni me lo había

planteado. Cuando le pregunté para qué lo quería, me explicó que cuando el CO₂ se acumula en un espacio cerrado baja la concentración, aumenta la fatiga e incluso pueden aparecer dolores de cabeza. En su oficina en Alemania, me dijo, lo usan constantemente.

A mí, sinceramente, me sonó más a una excusa elegante para abrir las ventanas. Y claro, abrir ventanas en pleno invierno no está precisamente entre mis planes favoritos: yo soy más de estar calentito. Pero, pensándolo bien… tenía todo el sentido del mundo.

El problema es que los monitores “buenos de verdad” no son precisamente baratos, y muchos de los modelos baratos ni siquiera miden CO₂ real. Lo que hacen es estimar un valor aproximado (eCO₂) a partir de otros gases como los compuestos orgánicos volátiles (TVOC), lo que los convierte en poco más que un

número bonito en una pantalla. En cambio, dispositivos como los de SwitchBot utilizan sensores NDIR (Non-Dispersive Infrared), que sí miden el CO₂ real haciendo pasar luz infrarroja por una cámara de aire: cuantas más moléculas de CO₂ hay, más luz absorben.

Y claro… ahí fue cuando pensé:

Esto es básicamente un sensor bueno metido en una caja bonita. ¿Será posible montarlo DIY por lo que cuestan dos cervezas?

Spoiler: No, pero por lo que cuestan 10 cervezas sí. Con una placa ESP32-C3, una pequeña pantalla OLED y un par de sensores, puedes montar tu propio monitor de calidad del aire capaz de medir CO₂ real con precisión, además de temperatura, humedad y presión atmosférica; y de paso, que se integre con tu domótica.

Pero antes de entrar al lío, vamos a asentar lo básico.

¿Qué es un ESP32?

Si nunca has oído hablar de él, el ESP32 es un microcontrolador fabricado por la empresa china Espressif. Piensa en él como un cerebro diminuto con WiFi y Bluetooth integrados, capaz de conectarse a internet y hablar con sensores, pantallas o cualquier cosa que le enchufes. Es el corazón de millones de proyectos de electrónica casera: pequeño, barato y sorprendentemente capaz.

El modelo que yo compré es el ESP32-C3 Super Mini: 16 pines, USB-C, del tamaño de un chicle. Menos de 2 €.

Históricamente, estos chips se programaban con Arduino (C/C++) Más adelante surgió PlatformIO, que trajo más comodidad y gestión de proyectos dentro de VS Code. Y por último apareció ESP-IDF, el framework oficial de Espressif: máximo control, pero también máxima complejidad.

¿Y si no sabes programar en C? Aquí entra el protagonista silencioso de este proyecto.

ESPHome: firmware sin escribir código

ESPHome cambia las reglas del juego. En lugar de programar, describes tu dispositivo en un archivo YAML: qué sensores tiene, cómo quieres mostrar los datos, con qué frecuencia se actualizan. ESPHome lee esa descripción, genera el firmware en C++, lo

compila y lo flashea al ESP32 automáticamente. Para que te hagas una idea: si vienes del mundo cloud, es exactamente Infrastructure as Code, pero para hardware.

Y lo mejor: se conecta solo a Home Assistant. Tus sensores aparecen como entidades, con histórico y gráficas, sin que tengas que escribir una sola línea de código complicada.

Ejemplo de yaml:

sensor:
  - platform: aht10
    variant: AHT20
    temperature:
      name: "Temperatura"
    humidity:
      name: "Humedad"

¿Y qué es Home Assistant – HA?

Home Assistant es una plataforma de domótica open source que centraliza el control de todos los dispositivos de tu casa: sensores, luces, enchufes inteligentes, automatizaciones… Todo desde un único panel, ejecutándose en tu red local, sin depender de la nube de ningún fabricante. Es, en esencia, tu propio control plane para el hogar.

En este proyecto, Home Assistant es quien almacena el histórico de tus mediciones, te muestra gráficas de evolución y puede lanzar automatizaciones.

Es compatible con cualquier dispositivo inteligente que tengas en casa, y es fácilmente personalizable desde la interfaz web y desde plantillas yaml.

Además tiene apps móviles:

Android: https://play.google.com/store/apps/details?id=io.homeassistant.companion.android&hl=es_419

iOS: https://apps.apple.com/es/app/home-assistant/id1099568401

Cómo instalar Home Assistant

Home Assistant puede correr en casi cualquier hardware: Raspberry Pi, mini PC, NAS, máquina virtual… Hay varias opciones de instalación (Home Assistant OS, Docker, Supervised), pero la más rápida si ya tienes una Raspberry Pi es tirar de Docker. La imagen es para la Raspberry Pi 4 pero a mí me va genial en la 3.

docker pull ghcr.io/home-assistant/raspberrypi4-homeassistant:stable

docker run -d \
  --name homeassistant \
  --restart=unless-stopped \
  -v /root/homeassistant:/config \
  -e TZ=Europe/Madrid \
  --network=host \
  ghcr.io/home-assistant/raspberrypi4-homeassistant:stable

Cambia /root/homeassistant por la ruta donde quieras guardar la configuración. Una vez arrancado, abre http://:8123 en el navegador y sigue el asistente inicial.

Una vez instalado, verás que fácil es agregar el ESP32 para que autoreconozca automáticamente cualquier sensor. Solo ir a http://192.168.x.x:8123/config/integrations/dashboard y buscar “ESPHome” en Añadir integración, donde introduciremos la IP de nuestro ESP32 (que aparecerá en los logs nada más flasheemos)

Para las demás formas de instalación, echa un ojo a la documentación oficial: home-assistant.io/installation

La lista de la compra

Con la teoría clara, vamos a lo que importa: qué comprar. Son cuatro componentes, todos se conectan al ESP32 con los mismos cuatro cables (luego te explico cómo), y el coste total ronda los 18€, pero solo porque el sensor de CO₂ es la parte más cara (13€ ~); el resto de piezas suman 5€.

Opcionalmente: una protoboard (placa de pruebas sin soldadura) para montar todo rápido, y un hub I²C si quieres algo más limpio y permanente.

Las conexiones: I²C

Todos los módulos se comunican usando I²C (Inter-Integrated Circuit), un protocolo que permite conectar varios dispositivos compartiendo solo dos cables de datos:

• SDA (datos) → GPIO4
• SCL (reloj) → GPIO5

Cada sensor tiene su propia dirección en el bus, así que no se pisan entre sí. La pantalla OLED, el SCD40, el AHT20 y el BMP280 conviven todos en esos mismos dos cables.

Para la alimentación:

• VCC/VDD → 3.3V del ESP32
• GND → GND del ESP32

Requisitos de software – ESP32

Necesitas Python y pip instalados. Después:

pip install esphome

Para que el ordenador reconozca el ESP32 al conectarlo por USB, necesitas el driver del chip USB-serie que lleve tu placa (varía según fabricante):

Yo instalé todos, ya que no estaba seguro de cuál necesitaba.

Flashear el ESP32

Con ESPHome instalado y los drivers en su sitio, flashear es un solo comando. Pero hay un par de cosas que preparar antes.

Configurar tus credenciales

Los YAML los he implementado utilizando !secret para no llevar contraseñas en el código. Copia el archivo de ejemplo y rellénalo con tus datos:

cp esphome/secrets.yaml.example esphome/secrets.yaml

wifi_ssid: "TuRedWiFi"
wifi_password: "TuContraseña"
ota_password: "una_clave_segura"
api_encryption_key: "clave_base64_de_32_bytes"

Para generar la clave de cifrado de la API:

openssl rand -base64 32

Primera vez: flashear por USB

La primera vez hay que flashear por cable. Conecta el ESP32 al ordenador por USB-C y mantén pulsado el botón BOOT de la placa mientras lo enchufas (suéltalo una vez conectado). Esto pone al chip en modo de programación.

Si ves que se conecta y desconecta repetidas veces es que tu cable no es de datos, consigue un cable mejor.

Ahora elige el YAML del proyecto que quieras y ejecuta, por ejemplo para flashear sensors_best_pages.yaml

# Reemplaza COMx por tu puerto (COM3, COM4... en Windows; /dev/ttyUSB0 en Linux)
esphome run sensors_best_pages.yaml --device COMx

ESPHome hará todo el trabajo: leerá el YAML, generará el código C++, lo compilará, lo subirá al ESP32 y abrirá el log en tiempo real para que veas cómo arranca. La primera compilación tarda unos minutos (descarga dependencias y compila el framework entero); las siguientes son mucho más rápidas.

A partir de la segunda vez: por cable o por OTA (por WiFi)

Una vez que el ESP32 está conectado a tu WiFi, ya no necesitas el cable. ESPHome puede actualizar el firmware por el aire (OTA, Over-The-Air):

esphome run esphome/sensors_best_pages.yaml --device 192.168.1.x

Laboratorio 1: el ticker de VWCE en la pantalla

Entre que me llegaban los sensores, quise probar a ejecutar algún tipo de lógica dentro del ESP32, y se me ocurrió mostrar el precio del ETF VWCE (Vanguard FTSE All-World, cotización en XETRA) en la pantalla OLED.

ESPHome no solo lee sensores físicos conectados por cable. Gracias a los bloques lambda, puedes escribir código C++ directamente dentro del YAML. Es la válvula de escape de ESPHome: cuando lo que necesitas no existe como componente, te lo programa Claude te lo programas tú.

Lo implementé de dos maneras diferentes:

La versión directa – Lambda con petición HTTPS

El ESP32 hace él solito la petición HTTPS a Yahoo Finance, parsea el JSON de respuesta con expresiones regulares directamente en un lambda de C++ (sí, dentro del YAML) y actualiza el sensor en pantalla.

La pantalla muestra el ticker (VWCE), el mercado (XETRA), el precio en grande y unas barras de señal WiFi en la cabecera. Minimalista pero funcional.

Flasheamos vwce.yaml

Home Assistant lo detecta como un sensor y te lo muestra, con gráficos e históricos.

Sensor REST en Home Assistant

Aquí cambiamos la estrategia: en lugar de que el ESP32 haga la petición, es Home Assistant quien obtiene el precio mediante un sensor REST y se lo envía al dispositivo vía la API nativa de ESPHome. El ESP32 solo se preocupa de mostrar el dato en pantalla.

Para que Home Assistant haga este trabajo necesitamos configurar los siguientes yaml:

configuration.yaml (editar el que ya existe para añadir lo siguiente)

# Custom
sensor: !include vwce_sensor.yaml

vwce_sensor.yaml (y crear este nuevo)

# Sensor REST de VWCE para Home Assistant
- platform: rest
  name: vwce_precio_yahoo
  unique_id: vwce_precio_yahoo
  resource: https://query1.finance.yahoo.com/v8/finance/chart/VWCE.DE
  value_template: "{{ value_json.chart.result[0].meta.regularMarketPrice }}"
  scan_interval: 60
  unit_of_measurement: "EUR"
  state_class: measurement
  device_class: monetary

docker restart homeassistant

Mientras que en el ESP32 flasheamos vwce_dummy.yaml

Estas fueron solo dos pruebas para entrar en calor y ver cómo interactúan los dos sistemas, ESPHome y Home Assistant. Y ahora sí, empezamos con los sensores de verdad.

Laboratorio 2: la estación de calidad del aire

El banco de pruebas

Flasheamos sensors_lab.yaml

La primera versión expone todos los datos de todos los sensores a Home Assistant: siete entidades en total.

¿Para qué siete si hay datos repetidos? Para comparar.

• El SCD40 lee entre 1,5 y 2 °C por encima de la temperatura real. No es un fallo: es self-heating, el autocalentamiento del chip. El sensor necesita estar a temperatura estable para calibrar el CO₂ correctamente, así que genera calor a propósito. Para CO₂ es una joya; para temperatura ambiente, mejor no fiarte de él.
• El AHT20 es el más preciso para temperatura (±0,3 °C) y humedad (±2 % RH). Sin autocalentamiento apreciable. Es el sensor de referencia.
• El BMP280 da temperatura (±0,5 °C), pero su valor estrella es la presión barométrica: ahí no tiene competencia en el bus.

La pantalla en esta versión tiene dos páginas que rotan cada 6 segundos:

1. Página CO₂: número grande en el centro con la concentración, y temperatura/humedad del SCD40 en el pie (para comparar, aunque sabemos que no son las más precisas).
2. Página Clima: temperatura y humedad del AHT20, presión del BMP280.

Así se ve en Home Assistant

La versión limpia

Una vez que tienes claro de qué sensor fiarte para cada magnitud, la versión “best” solo expone a Home Assistant cuatro entidades: las mejores de cada uno.

Flasheamos sensors_best.yaml o sensors_best_pages.yaml

Las lecturas de temperatura del SCD40 y del BMP280 siguen existiendo internamente (internal: true): las usa el firmware para diagnóstico, pero no crean entidades en Home Assistant. Menos ruido, datos limpios.

La diferencia entre las dos variantes está en la pantalla:

• sensors_best_pages.yaml → Cuatro páginas a pantalla completa, una por métrica. Cada dato ocupa toda la OLED con una fuente de 40 px. Debajo del número de CO₂ aparece la calidad del aire en texto: BUENO (< 700 ppm), ACEPTABLE (700-1000), MALO (1000-1500) o PELIGROSO (> 1500).
• sensors_best.yaml → Una sola página compacta con las cuatro métricas. CO₂ grande en el centro con la calidad del aire a la izquierda; temperatura, humedad y presión en tres columnas al pie. Para los que prefieren verlo todo de un vistazo.

Lo que hay que saber del SCD40: paciencia los primeros días

El SCD40 tiene una función llamada ASC (Automatic Self-Calibration) en la cual el sensor asume que la concentración más baja de CO₂ que detecta en un periodo de siete días corresponde al aire exterior (~415 ppm) y se recalibra solo en base a eso.

Para que funcione bien necesitas dos cosas:

1. Que el sensor esté encendido de forma continua. No lo apagues cada noche; necesita datos de al menos una semana completa.
2. Que la habitación se ventile al menos una vez a la semana. Si no, nunca “ve” aire limpio y no tiene referencia.

Aviso para el primer arranque: si lo enciendes en una habitación cerrada por primera vez, puede tardar varios días en estabilizarse. No te fíes de los primeros valores y dale tiempo.

En mi caso aparecen valores altos, ya que he hecho las pruebas en una habitación donde no ventilo nada.

Tabla estándar de clasificación de CO₂ en interiores:

Recapitulando

Por unos 15-20 € y un rato de cacharreo tienes un monitor de calidad del aire con CO₂ real (NDIR), temperatura precisa, humedad y presión barométrica. Se integra con Home Assistant, puedes ver el histórico en gráficas, crear automatizaciones y, sobre todo, saber cuándo abrir la ventana de verdad y no por intuición o porque “huele raro”.

Mi hermana tenía razón. El CO₂ importa. Y ahora tengo los datos para demostrarlo.

El repo

Repo: https://github.com/evaristorivi/esp32-esphome-homeassistant-lab

Encontrarás información más detallada y conforme avance el proyecto más YAMLs.

Próximos pasos

Esto no acaba aquí. Tengo un par de ideas en la recámara:

Encoder rotatorio (KY-040) Ahora mismo las páginas rotan solas cada 6 segundos. La idea es añadir un encoder rotatorio para cambiar de página girando la ruedecilla y confirmar con un clic. Nada de esperar: tú decides qué dato ver en cada momento.

Módulo KY-040 encoder rotatorio 360°, 5V

Cheap Yellow Display (CYD) La ESP32-2432S028R es una placa todo-en-uno con un ESP32 más potente, pantalla TFT de 2,8 pulgadas a color y táctil. Pasar de una OLED monocromo de 0,96″ a una pantalla a color con interacción táctil es un salto considerable, y quiero ver cómo quedan los mismos sensores en ese formato. Aunque, siendo sincero, lo primero que voy a probar con ella es el ESP32 Marauder… y ya después me pongo serio con los sensores. Pero eso quizás ya da para otra entrada.

Pantalla Inteligente ESP32 2.8″ TFT 240×320 táctil

Y hasta aquí

Si has llegado hasta el final, gracias por la paciencia. Lo que empezó como curiosidad por un regalo navideño terminó convirtiéndose en un proyecto que sigo ampliando. Si te animas a montarlo, todo el código está en el repositorio listo para flashear, y si te surge cualquier duda, los issues de GitHub están abiertos.

Nos leemos en la próxima.