Sensor de CO2 MH-Z19: medir ppm con Arduino, ESP32 y Pico
Cómo usar el sensor de CO2 MH-Z19B: conexión UART, lectura de ppm, calibración ABC, precalentamiento y código para Uno, ESP32 y Pico con alarma.
El sensor de CO2 MH-Z19 es un sensor NDIR que funciona con luz infrarroja y mide directamente la cantidad de dióxido de carbono del ambiente en ppm (partes por millón). Se conecta a Arduino, ESP32 o Raspberry Pi Pico con solo cuatro cables (5 V, GND, TX, RX) y entrega un valor real de CO2 por UART en pocos milisegundos. A diferencia de los sensores de gas baratos, no adivina: mide cuánta luz absorben las moléculas de CO2 del aire. Por eso es una de las formas más fiables y económicas de montar un aviso de ventilación para aulas, dormitorios y oficinas con las ventanas cerradas en invierno.
En este artículo aprenderás cómo funciona el MH-Z19B, sus pines y la conexión correcta, cómo leer ppm con comandos UART, los 3 minutos de precalentamiento y la calibración automática (ABC), que suele confundir. Después montaremos un aviso de ventilación con LED verde, amarillo y rojo con código para Arduino Uno (SoftwareSerial), ESP32 (UART por hardware) y Raspberry Pi Pico (MicroPython). Cuando veas que en un aula cerrada el CO2 puede superar las 2000 ppm en una sola clase, entenderás por qué este sensor es tan popular.
¿Qué es el sensor de CO2 MH-Z19 y cómo funciona?
NDIR significa Non-Dispersive Infrared, es decir, infrarrojo no dispersivo. Una pequeña lámpara dentro del sensor emite luz infrarroja; esa luz atraviesa la cámara de medición, donde entra el aire a través de un filtro, y llega al detector del otro lado. Las moléculas de CO2 absorben con fuerza la luz de unos 4,26 micrómetros de longitud de onda. El filtro óptico de banda estrecha delante del detector deja pasar solo esa longitud de onda; cuanto más CO2 hay en el aire, menos luz llega al detector. El microcontrolador interno corrige esa diferencia según la temperatura, la convierte en ppm y te envía un número ya listo. Como la medida se basa en una absorción física, es mucho más selectivo que los sensores semiconductores con calefactor como la serie MQ: el perfume, el alcohol o el olor a comida no cambian el valor de CO2.
| Característica | Valor del MH-Z19B |
|---|---|
| Método de medida | NDIR (absorción de infrarrojo no dispersivo) |
| Rango de medida | 0–2000 o 0–5000 ppm (se elige por comando; también existe una versión de 10000 ppm) |
| Precisión | Aprox. ±(50 ppm + 3–5 % de la lectura), según la versión |
| Tensión de alimentación | 4,5–5,5 V DC |
| Corriente | Media por debajo de 60 mA, pico de unos 150 mA |
| Interfaz | UART 9600 baudios 8N1, nivel de 3,3 V; también salida PWM |
| Precalentamiento | 3 minutos |
| Tiempo de respuesta (T90) | Menos de 120 segundos |
| Condiciones de trabajo | 0–50 °C, 0–90 % de humedad relativa (sin condensación) |
| Vida útil | Más de 5 años (valor del fabricante) |
Niveles de CO2: qué significa cada valor en ppm
En el aire limpio del exterior el CO2 ronda hoy las 420 ppm. En una habitación cerrada, cada persona añade CO2 continuamente al respirar: un adulto en reposo emite unos 15–20 litros de CO2 por hora. Hagamos un cálculo sencillo: en un aula de 150 m³ con 25 alumnos se producen unos 0,4 m³ de CO2 por hora. Sin ninguna ventilación, eso supondría un aumento de 0,4 / 150 ≈ 0,0027 por hora, es decir, unas 2700 ppm. En la realidad sube más despacio gracias a rendijas y fugas, pero ver 2000 ppm al final de una clase con las ventanas cerradas no es nada raro. A estos niveles el CO2 no es tóxico directamente, pero es el mejor indicador de mala ventilación y se asocia con cansancio, dolor de cabeza y falta de concentración. Muchas guías para escuelas y oficinas consideran unas 1000 ppm como límite para ventilar.
| Rango de CO2 | Valoración | Aviso en nuestro código |
|---|---|---|
| 400–800 ppm | Ambiente limpio y bien ventilado | LED verde |
| 800–1200 ppm | Aceptable, el aire empieza a viciarse | LED amarillo |
| 1200–2000 ppm | Malo, hora de abrir la ventana | LED rojo + zumbador |
| Más de 2000 ppm | Muy malo; aumentan la somnolencia y el dolor de cabeza | LED rojo + zumbador |
| 5000 ppm | Límite de exposición laboral de 8 horas | Tope del rango de medida |
Pines del MH-Z19B y esquema de conexión
El MH-Z19B suele tener 7 pines: Vin (alimentación), GND, TX y RX (UART), PWM (salida por ancho de pulso), HD (calibración manual de cero) y, en algunas versiones, Vo (salida analógica). En la salida PWM el periodo es de unos 1004 ms y el valor se calcula con la fórmula ppm = rango × (TH − 2 ms) / (TH + TL − 4 ms); sin embargo, como hay que esperar un segundo por cada lectura, la UART es mucho más práctica. Nosotros usaremos la UART; PWM y HD pueden quedar sin conectar. En la UART los cables siempre se conectan cruzados: el TX del sensor va al RX de la placa y el RX del sensor al TX de la placa. Los fundamentos de la comunicación serie los tienes en el artículo comunicación serie UART.
| Pin del MH-Z19B | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Vin (5 V) | 5V | VIN (5V) | VBUS (pin 40) |
| GND | GND | GND | GND |
| TX | D10 (RX de SoftwareSerial) | GPIO 16 (RX de UART2) | GP1 (RX de UART0) |
| RX | D11 (con divisor de 1 kΩ + 2 kΩ) | GPIO 17 (TX de UART2) | GP0 (TX de UART0) |
| PWM | Sin conectar | Sin conectar | Sin conectar |
| HD | Sin conectar (a GND al calibrar) | Sin conectar | Sin conectar |
| LED de aviso / zumbador | D4, D5, D6 / D8 | GPIO 26 / GPIO 27 | GP15 |
La salida TX del sensor es de 3,3 V y el Uno la lee sin problema como HIGH. En sentido contrario, el pin TX del Uno entrega 5 V. La documentación del fabricante indica un nivel de interfaz de 3,3 V; aunque algunos módulos aguantan 5 V, lo más seguro es poner un divisor de tensión sencillo entre el pin D11 del Uno y el RX del sensor: 1 kΩ de D11 al RX del sensor y 2 kΩ del RX del sensor a GND. La salida queda en 5 × 2 / (1 + 2) = 3,33 V. Puedes comprobar los valores con las resistencias que tengas usando la calculadora de divisor de tensión, o emplear un conversor de nivel lógico bidireccional. El ESP32 y la Pico ya trabajan a 3,3 V, así que con ellos no hace falta divisor.
Protocolo UART: cómo hablar con el sensor
El MH-Z19B trabaja con 9600 baudios, 8 bits de datos, sin paridad y 1 bit de parada (8N1). Cada comando y cada respuesta ocupan exactamente 9 bytes. Los comandos empiezan con 0xFF, el segundo byte es el número de sensor (0x01), el tercero es el código del comando y el último es la suma de comprobación (checksum). El checksum se obtiene de la suma de los bytes 1 a 7 así: checksum = 0xFF − (byte1 + … + byte7) + 1, recortado a un solo byte. En la respuesta al comando de lectura, el byte 0 es 0xFF y el byte 1 es 0x86; el valor de CO2 está en los bytes 2 y 3: ppm = byte alto × 256 + byte bajo. Por ejemplo, si la respuesta empieza por FF 86 02 58, el valor es 2 × 256 + 88 = 600 ppm. El byte 4 es un valor de temperatura aproximado y no documentado (valor − 40 °C) que solo sirve como referencia; para medir la temperatura de verdad usa otro sensor.
| Operación | 9 bytes enviados (hex) | Explicación |
|---|---|---|
| Leer CO2 | FF 01 86 00 00 00 00 00 79 | Los bytes 2 y 3 de la respuesta son el valor en ppm |
| Activar ABC | FF 01 79 A0 00 00 00 00 E6 | Activa la corrección automática de línea base cada 24 horas (ajuste de fábrica) |
| Desactivar ABC | FF 01 79 00 00 00 00 00 86 | Desactiva la calibración automática para invernaderos y ambientes cerrados |
| Calibración de cero | FF 01 87 00 00 00 00 00 78 | Toma el ambiente actual como 400 ppm; hazla solo al aire libre |
| Rango 2000 ppm | FF 01 99 00 00 00 07 D0 8F | Fija el rango de medida en 0–2000 ppm |
| Rango 5000 ppm | FF 01 99 00 00 00 13 88 CB | Fija el rango de medida en 0–5000 ppm |
Paso a paso: medir CO2 con Arduino Uno
- Conecta el pin Vin del sensor al pin 5V del Uno y el pin GND a GND.
- Conecta el pin TX del sensor a D10; ese pin será el RX de SoftwareSerial.
- Conecta el pin D11 del Uno al pin RX del sensor a través de un divisor de tensión de 1 kΩ + 2 kΩ.
- Conecta los LED verde, amarillo y rojo a D4, D5 y D6 con resistencias de 220 Ω, y el zumbador pasivo a D8.
- Sube el código, abre el Monitor Serie a 9600 baudios y espera a que terminen los 3 minutos de precalentamiento.
- Mantén el sensor unos minutos delante de una ventana abierta y comprueba que lee unas 400–480 ppm; después sopla a unos 30 cm de distancia y observa cómo el valor sube rápido.
1#include <SoftwareSerial.h>
2
3// MH-Z19B TX -> D10, MH-Z19B RX -> D11 (1k + 2k bölücü / 1k + 2k divider)
4SoftwareSerial co2Serial(10, 11); // RX, TX
5
6const byte GREEN_LED = 4;
7const byte YELLOW_LED = 5;
8const byte RED_LED = 6;
9const byte BUZZER = 8; // pasif buzzer / passive buzzer
10
11const byte CMD_READ[9] = {0xFF, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79};
12const byte CMD_ABC_ON[9] = {0xFF, 0x01, 0x79, 0xA0, 0x00, 0x00, 0x00, 0x00, 0xE6};
13
14const unsigned long WARMUP_MS = 180000UL; // 3 dakika ön ısınma / 3 minute warm-up
15const unsigned long READ_INTERVAL = 5000UL; // 5 saniyede bir ölç / read every 5 s
16
17unsigned long lastRead = 0;
18
19byte calcChecksum(const byte *packet) {
20 byte sum = 0;
21 for (byte i = 1; i < 8; i++) {
22 sum += packet[i];
23 }
24 return (byte)(0xFF - sum + 1);
25}
26
27int readCO2() {
28 byte resp[9];
29 while (co2Serial.available()) {
30 co2Serial.read(); // eski baytları at / drop old bytes
31 }
32 co2Serial.write(CMD_READ, 9);
33
34 byte count = 0;
35 unsigned long start = millis();
36 while (count < 9 && millis() - start < 300) {
37 if (co2Serial.available()) {
38 resp[count++] = co2Serial.read();
39 }
40 }
41 if (count < 9) return -1; // cevap yok / no answer
42 if (resp[0] != 0xFF || resp[1] != 0x86) return -2; // yanlış başlık / wrong header
43 if (resp[8] != calcChecksum(resp)) return -3; // checksum hatası / checksum error
44 return ((int)resp[2] << 8) | resp[3]; // ppm = yüksek*256 + düşük / high*256 + low
45}
46
47void setLeds(bool g, bool y, bool r) {
48 digitalWrite(GREEN_LED, g ? HIGH : LOW);
49 digitalWrite(YELLOW_LED, y ? HIGH : LOW);
50 digitalWrite(RED_LED, r ? HIGH : LOW);
51}
52
53void setup() {
54 Serial.begin(9600);
55 co2Serial.begin(9600);
56 pinMode(GREEN_LED, OUTPUT);
57 pinMode(YELLOW_LED, OUTPUT);
58 pinMode(RED_LED, OUTPUT);
59 pinMode(BUZZER, OUTPUT);
60 delay(500);
61 co2Serial.write(CMD_ABC_ON, 9); // ABC açık; sera için kapat / ABC on; turn off for greenhouses
62 Serial.println(F("MH-Z19B on isinma basladi / warm-up started"));
63}
64
65void loop() {
66 unsigned long now = millis();
67 if (now - lastRead < READ_INTERVAL) return;
68 lastRead = now;
69
70 if (now < WARMUP_MS) {
71 Serial.print(F("Isiniyor / Warming up: "));
72 Serial.print((WARMUP_MS - now) / 1000);
73 Serial.println(F(" s"));
74 return;
75 }
76
77 int ppm = readCO2();
78 if (ppm < 0) {
79 Serial.print(F("Okuma hatasi / Read error: "));
80 Serial.println(ppm);
81 return;
82 }
83
84 Serial.print(F("CO2: "));
85 Serial.print(ppm);
86 Serial.println(F(" ppm"));
87
88 if (ppm < 800) {
89 setLeds(true, false, false); // temiz hava / fresh air
90 } else if (ppm < 1200) {
91 setLeds(false, true, false); // havalandırmaya hazırlan / ventilate soon
92 } else {
93 setLeds(false, false, true); // pencereyi aç / open the window
94 tone(BUZZER, 2000, 200);
95 }
96}El código envía al sensor el comando de lectura de 9 bytes cada 5 segundos y después recoge la respuesta de 9 bytes durante un máximo de 300 ms. Si la cabecera (FF 86) o el checksum no coinciden, el valor se descarta; así una línea con ruido no genera falsas alarmas. La función readCO2() devuelve un código negativo en caso de error: -1 significa que no hubo respuesta, -2 cabecera incorrecta y -3 checksum erróneo. Como el tiempo se controla con millis() en lugar de delay(), loop() no se bloquea; si más adelante añades un botón o una pantalla, el código no dejará de responder. La lógica de este enfoque la tienes en el artículo diferencia entre millis y delay. Si prefieres una librería ya hecha, la librería MH-Z19 (Jonathan Dempsey) del Gestor de Bibliotecas envuelve el mismo protocolo con funciones como getCO2() y autoCalibration(); pero conocer el protocolo en bruto te facilita mucho encontrar el problema cuando el sensor se comporta de forma inesperada.
Precalentamiento: por qué no debes fiarte de los primeros 3 minutos
La medida no es fiable hasta que la lámpara infrarroja y el detector alcanzan una temperatura estable. El fabricante indica un precalentamiento de 3 minutos; durante ese tiempo el sensor puede devolver valores fijos o sin sentido (por ejemplo, siempre 400 o 500 ppm). Por eso nuestro código no lee durante los primeros 180 segundos y solo escribe el tiempo restante. Además, el tiempo de respuesta T90 del sensor es inferior a 2 minutos: cuando el ambiente cambia de golpe, alcanzar el 90 % del valor real puede llevar uno o dos minutos, así que es normal que el valor baje despacio cuando abres la ventana. Si ves pequeñas oscilaciones entre medidas, hacer la media de las últimas 5–10 lecturas estabiliza el valor en pantalla; para los métodos, échale un vistazo al artículo filtrado de datos de sensores. Si vas a usar el dispositivo mucho tiempo, mantenerlo alimentado de forma continua da resultados más coherentes que apagarlo y encenderlo cada vez.
Calibración automática (ABC) y calibración manual de cero
El punto cero de los sensores NDIR se desplaza poco a poco con los meses y los años. El MH-Z19B lo corrige con ABC (Automatic Baseline Correction): en cada periodo de 24 horas el sensor toma el valor más bajo que ha visto como aire limpio, es decir, unas 400 ppm, y ajusta su línea base en consecuencia. El ABC viene activado de fábrica. En aulas, oficinas y dormitorios que se ventilan bien al menos una vez al día resulta muy útil; obtienes una precisión razonable durante años sin tocar la calibración. Sin embargo, en invernaderos, cuartos cerrados de setas o ambientes donde el CO2 nunca baja a 400 ppm, el ABC es perjudicial: el sensor toma por error, por ejemplo, 700 ppm como aire limpio y desplaza todas las medidas unas 300 ppm hacia abajo. En esos lugares desactiva el ABC con el comando correspondiente y haz una calibración manual cada cierto tiempo.
Para la calibración manual de cero, deja el sensor funcionando al aire libre, lejos del viento y del aliento de las personas, durante al menos 20 minutos. Después envía el comando de calibración de cero 0x87 o conecta el pin HD a GND durante al menos 7 segundos. El sensor guardará el ambiente de ese momento como 400 ppm. No hagas nunca esta operación en una habitación cerrada; un sensor que toma 900 ppm de interior por 400 te mostrará siempre un aire mejor de lo que es y el aviso perderá todo su sentido. Para elegir entre los rangos de 2000 y 5000 ppm también se usa el comando 0x99; en aulas llenas es más seguro el rango de 5000 ppm para que el valor no choque contra el tope de 2000 ppm.
Usar el MH-Z19B con ESP32
El ESP32 tiene tres UART por hardware y sus pines se pueden asignar a los GPIO que quieras, así que no hace falta SoftwareSerial. Conecta el Vin del sensor al pin VIN (5V) de la placa de desarrollo ESP32, que entrega los 5 V del USB. El TX del sensor va al GPIO 16 y el RX al GPIO 17; como ambas líneas son de 3,3 V, se conectan directamente. El código siguiente compila igual con las versiones 2.x y 3.x del core de Arduino para ESP32; cuando el valor supera las 1200 ppm enciende el LED del GPIO 26 y da un pitido corto con el zumbador activo del GPIO 27. En las placas con módulo WROVER los GPIO 16 y 17 están reservados para la PSRAM; en ese caso elige, por ejemplo, el GPIO 32 y el 33. Si conectas la placa al Wi-Fi, podrás mostrar el mismo valor en una página web, en el móvil o en Home Assistant.
1#include <Arduino.h>
2
3HardwareSerial co2Serial(2); // UART2
4
5const int CO2_RX = 16; // ESP32 RX <- MH-Z19B TX
6const int CO2_TX = 17; // ESP32 TX -> MH-Z19B RX
7const int ALARM_LED = 26;
8const int BUZZER = 27; // aktif buzzer / active buzzer
9const int ALARM_PPM = 1200;
10
11const uint8_t CMD_READ[9] = {0xFF, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79};
12const unsigned long WARMUP_MS = 180000UL; // 3 dakika ön ısınma / 3 minute warm-up
13
14uint8_t calcChecksum(const uint8_t *packet) {
15 uint8_t sum = 0;
16 for (int i = 1; i < 8; i++) {
17 sum += packet[i];
18 }
19 return (uint8_t)(0xFF - sum + 1);
20}
21
22int readCO2() {
23 uint8_t resp[9];
24 while (co2Serial.available()) {
25 co2Serial.read(); // tamponu temizle / flush buffer
26 }
27 co2Serial.write(CMD_READ, sizeof(CMD_READ));
28 if (co2Serial.readBytes(resp, 9) != 9) return -1; // zaman aşımı / timeout
29 if (resp[0] != 0xFF || resp[1] != 0x86) return -2; // yanlış başlık / wrong header
30 if (resp[8] != calcChecksum(resp)) return -3; // checksum hatası / checksum error
31 return resp[2] * 256 + resp[3];
32}
33
34void setup() {
35 Serial.begin(115200);
36 co2Serial.begin(9600, SERIAL_8N1, CO2_RX, CO2_TX);
37 co2Serial.setTimeout(300); // readBytes en fazla 300 ms bekler / readBytes waits max 300 ms
38 pinMode(ALARM_LED, OUTPUT);
39 pinMode(BUZZER, OUTPUT);
40 Serial.println("MH-Z19B + ESP32 hazir / ready");
41}
42
43void loop() {
44 static unsigned long lastRead = 0;
45 unsigned long now = millis();
46 if (now - lastRead < 5000) return;
47 lastRead = now;
48
49 if (now < WARMUP_MS) {
50 Serial.printf("Isiniyor / Warming up: %lu s\n", (WARMUP_MS - now) / 1000);
51 return;
52 }
53
54 int ppm = readCO2();
55 if (ppm < 0) {
56 Serial.printf("Okuma hatasi / Read error: %d\n", ppm);
57 return;
58 }
59 Serial.printf("CO2: %d ppm\n", ppm);
60
61 bool alarm = (ppm >= ALARM_PPM);
62 digitalWrite(ALARM_LED, alarm ? HIGH : LOW);
63 if (alarm) {
64 digitalWrite(BUZZER, HIGH); // kısa bip / short beep
65 delay(150);
66 digitalWrite(BUZZER, LOW);
67 }
68}Medir CO2 con Raspberry Pi Pico y MicroPython
En la Pico, la UART0 está por defecto en los pines GP0 (TX) y GP1 (RX). Conecta el Vin del sensor al pin VBUS de la Pico (pin 40, los 5 V del USB); la salida de 3V3 no es suficiente para el sensor. Si alimentas la Pico con pilas en lugar de USB, en VBUS no habrá tensión y tendrás que darle al sensor una fuente de 5 V aparte. El TX del sensor va a GP1 y el RX a GP0. El código envía el mismo comando de 9 bytes que la versión de Arduino, verifica el checksum con la función sum() de Python y, por encima de 1200 ppm, enciende el LED de GP15 (con una resistencia de 220 Ω). Si estás empezando con MicroPython, antes puedes echar un vistazo al artículo fundamentos de MicroPython.
1from machine import UART, Pin
2import time
3
4# MH-Z19B TX -> GP1, MH-Z19B RX -> GP0, Vin -> VBUS (5 V)
5uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1), timeout=300)
6led = Pin(15, Pin.OUT) # uyarı LED'i / warning LED
7
8CMD_READ = bytes([0xFF, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79])
9WARMUP_MS = 180000 # 3 dakika ön ısınma / 3 minute warm-up
10ALARM_PPM = 1200
11start = time.ticks_ms()
12
13def checksum(packet):
14 return (0xFF - (sum(packet[1:8]) & 0xFF) + 1) & 0xFF
15
16def read_co2():
17 while uart.any():
18 uart.read() # eski baytları at / drop old bytes
19 uart.write(CMD_READ)
20 time.sleep_ms(100) # cevabın gelmesini bekle / wait for the answer
21 resp = uart.read(9)
22 if not resp or len(resp) != 9:
23 return None # cevap yok / no answer
24 if resp[0] != 0xFF or resp[1] != 0x86:
25 return None # yanlış başlık / wrong header
26 if resp[8] != checksum(resp):
27 return None # checksum hatası / checksum error
28 return resp[2] * 256 + resp[3]
29
30while True:
31 elapsed = time.ticks_diff(time.ticks_ms(), start)
32 if elapsed < WARMUP_MS:
33 print("Isiniyor / Warming up:", (WARMUP_MS - elapsed) // 1000, "s")
34 else:
35 ppm = read_co2()
36 if ppm is None:
37 print("Okuma hatasi / Read error")
38 else:
39 print("CO2:", ppm, "ppm")
40 led.value(1 if ppm >= ALARM_PPM else 0)
41 time.sleep(5)¿Dónde colocar el sensor en el aula o la habitación?
El lugar correcto importa más que el código correcto. Coloca el sensor a la altura a la que respiran las personas sentadas, a unos 1–1,5 metros del suelo, en una pared que represente el promedio de la habitación. Si lo pones junto a una ventana o puerta, el valor saldrá más bajo de lo real por el aire limpio que entra; si lo pones sobre la mesa muy cerca de la cara de alguien, verás valores que saltan con cada respiración. Evita también lugares como encima de un radiador, delante de una ventana con sol directo o un baño donde se condensa la humedad; el sensor está diseñado para 0–50 °C y humedad sin condensación. El aire entra por las superficies con filtro del sensor; si lo metes en una caja, hazla con muchos orificios y no bloquees la circulación de aire a su alrededor. Si el Uno o el ESP32 se reinician por el consumo instantáneo de corriente de la lámpara, añadir un condensador electrolítico de 100 µF y uno cerámico de 100 nF entre Vin y GND del sensor estabiliza la alimentación.
Ideas de proyectos con el MH-Z19
- Semáforo de ventilación para el aula: Mete el circuito con LED verde, amarillo y rojo de este artículo en una caja y cuélgalo en un lugar visible desde la mesa del profesor.
- Medidor de mesa con pantalla: Muestra el valor de CO2 con cifras grandes en una pantalla OLED SSD1306 o en una pantalla LCD I2C.
- Notificación al móvil: Con el ESP32, envía un mensaje por un bot de Telegram cuando el valor supere las 1200 ppm.
- Panel de casa inteligente: Envía las medidas a Home Assistant por MQTT, dibuja la gráfica diaria y crea automatizaciones.
- Ventilador de extracción automático: Pon en marcha un extractor cuando el CO2 suba; para los detalles del control de ventiladores, consulta el artículo control de ventiladores con Arduino.
- Monitorización de invernadero: Desactiva el ABC y añade la medida de CO2 al proyecto de invernadero inteligente; verás en la gráfica cómo las plantas consumen CO2 durante el día.
- Indicador de aire en color: Haz pasar suavemente el color de un único LED WS2812B del verde a 400 ppm al rojo a 2000 ppm.
- Registrador de datos: Guarda las medidas de un día en una tarjeta SD y analiza en qué clase se vicia más el aire; obtendrás un conjunto de datos excelente para ferias de ciencias y proyectos escolares.
Errores frecuentes y cómo solucionarlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| Siempre -1 (sin respuesta) | TX y RX conectados en directo o sensor alimentado con 3,3 V | Conecta TX con RX de forma cruzada y da 5 V a Vin |
| Muchos -3 (error de checksum) | Cable suelto en la protoboard, cable largo o pin no apto para SoftwareSerial | Acorta los cables; en Mega y Leonardo usa los pines admitidos para RX; en el Uno, D10 es seguro |
| 400 o 500 ppm fijas los primeros minutos | El precalentamiento sigue en curso | Espera al menos 3 minutos y luego mide |
| Con el paso de los días los valores son siempre bajos | En un ambiente nunca ventilado el ABC eligió mal la línea base | Desactiva el ABC y haz una calibración manual al aire libre |
| El valor se queda clavado en 2000 ppm | El rango de medida está en 2000 ppm | Cambia el rango a 5000 ppm con el comando 0x99 |
| La placa se reinicia o los valores saltan | La corriente instantánea de unos 150 mA de la lámpara hunde una alimentación débil | Añade un condensador de 100 µF entre Vin y GND y usa una fuente de 5 V sólida |
| Tras calibrar, los valores son demasiado bajos | La calibración de cero se hizo en una habitación cerrada | Repite la calibración al aire libre tras esperar 20 minutos |
El MH-Z19B es uno de los sensores con mejor equilibrio entre precio y precisión entre los que miden CO2 de verdad; si lo alimentas bien, lo dejas calentar 3 minutos y eliges el ajuste ABC según el ambiente, funciona de forma fiable durante años. Para la calidad general del aire y los olores, echa también un vistazo a los artículos del MQ-135, y para los compuestos orgánicos volátiles, del CCS811. En la app de BlueGrays encontrarás paso a paso, con esquemas y código, proyectos con ESP32 de medida de temperatura y humedad, alarma de gas y pantallas LCD y OLED; combinándolos con este sensor podrás montar tu propia estación de calidad del aire.
Preguntas frecuentes
¿Cuántas ppm de CO2 debe haber en una habitación?
En el exterior el CO2 ronda las 420 ppm y una habitación bien ventilada se mantiene por debajo de 800 ppm. Alrededor de 1000–1200 ppm es señal de que el aire se está viciando y es hora de abrir la ventana. Por encima de 2000 ppm son más frecuentes el dolor de cabeza, la somnolencia y la falta de concentración.
¿Qué diferencia hay entre el MH-Z19B y el MH-Z19C?
Ambos son sensores NDIR con la misma disposición de pines y los mismos comandos UART, así que el código de este artículo funciona con los dos. La versión C es la sucesora más nueva y económica de la B. Como la C es más sensible a la tensión de alimentación, es importante darle unos 5 V estables y reales.
¿Funciona el sensor MH-Z19 con 3,3 V?
No. La alimentación del sensor debe estar entre 4,5 y 5,5 V; con 3,3 V la lámpara infrarroja no funciona bien y el sensor no responde. Eso sí, las líneas UART son de 3,3 V, así que puedes alimentar el sensor con 5 V y conectar TX y RX directamente al ESP32 o a la Pico.
¿Hay que desactivar la calibración automática (ABC) del MH-Z19?
En aulas, oficinas y casas que se ventilan bien al menos una vez al día, el ABC debe quedar activado; el sensor se corrige solo cada 24 horas respecto al aire limpio. En invernaderos, almacenes cerrados o lugares donde el CO2 nunca baja a 400 ppm, el ABC desplaza los valores hacia abajo de forma errónea. Allí conviene desactivarlo y hacer de vez en cuando una calibración manual al aire libre.
¿Qué diferencia hay entre el MH-Z19 y el MQ-135?
El MQ-135 es un sensor de gas semiconductor con calefactor; reacciona a la vez al alcohol, al amoníaco, al humo y a muchos gases, y solo puede dar una estimación aproximada del CO2. El MH-Z19, en cambio, mide directamente el CO2 por absorción de infrarrojo, apenas le afectan otros gases y entrega un valor calibrado en ppm. Para un aviso de ventilación, la elección correcta es el MH-Z19.
¿Por qué el MH-Z19 muestra un valor erróneo al encenderlo?
La lámpara infrarroja y el detector del sensor necesitan unos 3 minutos de precalentamiento hasta alcanzar una temperatura estable. Durante ese tiempo pueden devolver valores fijos o sin sentido. En tu código ignora las lecturas de los primeros 3 minutos y espera 1–2 minutos más para que el valor se asiente cuando el ambiente cambie de golpe.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Temperatura y humedad con DHT11
¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

Uso del zumbador
¿Alguna vez te has preguntado cómo suena un timbre o una alarma? El Arduino hace pitar un pequeño zumbador a intervalos cortos: pip, silencio, pip, silencio.

Alarma de detector de gas/humo ESP32 MQ-2
En este proyecto, la detección de gases combustibles (GLP, metano, propano) y humo se realiza mediante un módulo sensor de gas MQ-2; al detectarlos, se emite un sonido de alarma similar a una sirena a través de un zumbador pasivo. La salida digital de umbral (DO) del sensor se conecta al GPIO 4 del ESP32; cuando el gas o el humo superan el umbral, DO pasa a LOW y se activa la alarma. La sensibilidad se ajusta con el potenciómetro del módulo. El zumbador se controla con tone().

Uso del sensor de gas
Un pequeño vigilante que detecta un escape de gas en la cocina antes que tú. El sensor de gas olfatea el aire sin parar; mientras todo va bien se enciende el LED verde, y cuando el gas del aire…

Alarma con sensor de llama y gas
Un pequeño vigilante que te avisa enseguida si hay una fuga de gas o aparece una llama en algún sitio.

ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
Se trata de un proyecto que mide la temperatura y la humedad ambientales mediante el sensor DHT22 y las muestra en tiempo real en una pantalla LCD I2C 16x2. Los datos del sensor se leen mediante el protocolo de un solo cable (one-wire) utilizando la biblioteca DHT de Adafruit. Este proyecto constituye la base para estaciones meteorológicas IoT, sistemas de automatización doméstica inteligente o sistemas de monitorización ambiental en invernaderos.

ESP32 HTTPClient + API del tiempo (con pantalla OLED SSD1306)
El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. A diferencia de la versión con LCD I2C, aquí usamos una pantalla OLED SSD1306 (128×64), con letra grande e iconos vectoriales para una vista más rica. Siete iconos del tiempo (soleado, lluvia, nieve y más) se dibujan al momento, sin archivos bitmap.

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

