Sensor de CO2 MH-Z19: meça ppm com Arduino, ESP32 e Pico
Como usar o sensor de CO2 NDIR MH-Z19B? Ligação UART, leitura em ppm, calibração ABC, aquecimento e códigos para Uno, ESP32 e Pico com alerta de ventilação.
O sensor de CO2 MH-Z19 é um sensor NDIR que usa luz infravermelha para medir a quantidade de dióxido de carbono no ar diretamente em ppm (partes por milhão). Ele se conecta a um Arduino, ESP32 ou Raspberry Pi Pico com apenas quatro fios (5 V, GND, TX, RX) e devolve um valor real de CO2 pela UART em poucos milissegundos. Ao contrário dos sensores de gás baratos, ele não faz estimativas: mede quanta luz as moléculas de CO2 do ar absorvem. Por isso é uma das formas mais confiáveis e econômicas de montar um alerta de ventilação para salas de aula, quartos e escritórios onde as janelas ficam fechadas no inverno.
Neste post você vai aprender como o MH-Z19B funciona, seus pinos e a ligação correta, como ler ppm com comandos UART, o aquecimento de 3 minutos e a calibração automática (ABC), que costuma gerar confusão. Depois vamos montar um alerta de ventilação com LEDs verde, amarelo e vermelho, com código funcionando para Arduino Uno (SoftwareSerial), ESP32 (UART de hardware) e Raspberry Pi Pico (MicroPython). Quando você vir como o CO2 de uma sala de aula fechada pode passar de 2000 ppm em uma única aula, vai entender por que esse sensor é tão popular.
O que é o sensor de CO2 MH-Z19 e como ele funciona?
NDIR significa Non-Dispersive Infrared, ou infravermelho não dispersivo. Uma pequena lâmpada dentro do sensor emite luz infravermelha; a luz atravessa uma câmara de medição cheia do ar que entra por um filtro e chega ao detector do outro lado. As moléculas de CO2 absorvem fortemente a luz com comprimento de onda de cerca de 4,26 micrômetros. Um filtro óptico de banda estreita na frente do detector deixa passar só esse comprimento de onda; quanto mais CO2 no ar, menos luz chega ao detector. Um microcontrolador dentro do sensor corrige essa diferença conforme a temperatura, converte em um valor em ppm e envia para você como um número pronto. Como a medição se baseia em absorção física, ela é muito mais seletiva que os sensores semicondutores com aquecedor, como os da série MQ: perfume, álcool ou cheiro de comida não alteram a leitura de CO2.
| Característica | Valor do MH-Z19B |
|---|---|
| Método de medição | NDIR (absorção infravermelha não dispersiva) |
| Faixa de medição | 0–2000 ou 0–5000 ppm (selecionada por comando; também existe uma versão de 10000 ppm) |
| Precisão | Cerca de ±(50 ppm + 3–5% da leitura), dependendo da versão |
| Tensão de alimentação | 4,5–5,5 V CC |
| Corrente | Menos de 60 mA em média, cerca de 150 mA de pico |
| Interface | UART 9600 baud 8N1, nível de 3,3 V; também tem saída PWM |
| Aquecimento | 3 minutos |
| Tempo de resposta (T90) | Menos de 120 segundos |
| Condições de operação | 0–50 °C, 0–90% de umidade relativa (sem condensação) |
| Vida útil | Mais de 5 anos (valor do fabricante) |
Níveis de CO2: o que significa cada valor em ppm?
No ar limpo ao ar livre, o CO2 hoje fica em torno de 420 ppm. Em uma sala fechada, cada pessoa adiciona CO2 a cada respiração: um adulto em repouso libera cerca de 15–20 litros de CO2 por hora. Vamos fazer uma conta rápida: em uma sala de aula de 150 m³, 25 alunos produzem cerca de 0,4 m³ de CO2 por hora. Sem nenhuma ventilação, isso daria 0,4 / 150 ≈ 0,0027, ou seja, um aumento de cerca de 2700 ppm por hora. Graças às frestas das portas e aos vazamentos, o aumento real é mais lento, mas ver 2000 ppm no fim de uma aula com as janelas fechadas está longe de ser raro. Nesses níveis o CO2 não é diretamente tóxico, mas é o melhor indicador de ventilação ruim e está associado a cansaço, dor de cabeça e perda de concentração. Muitas diretrizes para escolas e escritórios consideram cerca de 1000 ppm como o limite de ventilação.
| Faixa de CO2 | Avaliação | Alerta no nosso código |
|---|---|---|
| 400–800 ppm | Ambiente arejado e bem ventilado | LED verde |
| 800–1200 ppm | Aceitável, o ar está começando a ficar viciado | LED amarelo |
| 1200–2000 ppm | Ruim, hora de abrir uma janela | LED vermelho + buzzer |
| Acima de 2000 ppm | Muito ruim; sonolência e dor de cabeça ficam comuns | LED vermelho + buzzer |
| 5000 ppm | Limite de exposição ocupacional de 8 horas para locais de trabalho | Topo da faixa de medição |
Pinos do MH-Z19B e esquema de ligação
O MH-Z19B normalmente tem 7 pinos: Vin (alimentação), GND, TX e RX (UART), PWM (saída por largura de pulso), HD (calibração manual do zero) e, em algumas versões, Vo (saída de tensão analógica). Na saída PWM o período é de cerca de 1004 ms e o valor é calculado pela fórmula ppm = faixa × (TH − 2 ms) / (TH + TL − 4 ms); mas, como é preciso esperar um segundo a cada leitura, a UART é muito mais prática. Vamos usar a UART, então PWM e HD podem ficar sem conexão. Na UART os fios são sempre cruzados: o TX do sensor vai para o RX da placa, e o RX do sensor vai para o TX da placa. Você encontra os fundamentos da comunicação serial em detalhes no post comunicação serial UART.
| Pino do MH-Z19B | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Vin (5 V) | 5V | VIN (5V) | VBUS (pino 40) |
| GND | GND | GND | GND |
| TX | D10 (RX do SoftwareSerial) | GPIO 16 (RX da UART2) | GP1 (RX da UART0) |
| RX | D11 (por um divisor de 1 kΩ + 2 kΩ) | GPIO 17 (TX da UART2) | GP0 (TX da UART0) |
| PWM | Sem conexão | Sem conexão | Sem conexão |
| HD | Sem conexão (no GND durante a calibração) | Sem conexão | Sem conexão |
| LEDs de alerta / buzzer | D4, D5, D6 / D8 | GPIO 26 / GPIO 27 | GP15 |
A saída TX do sensor fica em 3,3 V, e o Uno lê isso como HIGH sem problema. No sentido contrário, porém, o pino TX do Uno fornece 5 V. Os documentos do fabricante indicam o nível da interface como 3,3 V; embora alguns módulos tolerem 5 V, o caminho mais seguro é um divisor de tensão simples entre o pino D11 do Uno e o RX do sensor: 1 kΩ do D11 até o RX do sensor, e 2 kΩ do RX do sensor até o GND. A saída fica 5 × 2 / (1 + 2) = 3,33 V. Você pode conferir os valores com os resistores que tem na calculadora de divisor de tensão ou usar um conversor de nível lógico bidirecional. O ESP32 e o Pico já funcionam com 3,3 V, então não precisam de divisor.
Protocolo UART: como conversar com o sensor?
O MH-Z19B trabalha com 9600 baud, 8 bits de dados, sem paridade, 1 bit de parada (8N1). Todo comando e toda resposta têm exatamente 9 bytes. Os comandos começam com 0xFF, o segundo byte é o número do sensor (0x01), o terceiro é o código do comando, e o último byte é o checksum (soma de verificação). O checksum é obtido a partir da soma dos bytes 1 a 7 assim: checksum = 0xFF − (byte1 + … + byte7) + 1, com o resultado truncado em um único byte. Na resposta ao comando de leitura, o byte 0 é 0xFF e o byte 1 é 0x86; o valor de CO2 fica nos bytes 2 e 3: ppm = byte alto × 256 + byte baixo. Por exemplo, se a resposta começa com FF 86 02 58, o valor é 2 × 256 + 88 = 600 ppm. O byte 4 é um valor de temperatura aproximado e não documentado (valor − 40 °C) e serve só para dar uma ideia; para medir temperatura de verdade, use um sensor separado.
| Operação | 9 bytes enviados (hex) | Descrição |
|---|---|---|
| Ler CO2 | FF 01 86 00 00 00 00 00 79 | Os bytes 2 e 3 da resposta são o valor em ppm |
| Ligar ABC | FF 01 79 A0 00 00 00 00 E6 | Liga a correção automática da referência a cada 24 horas (configuração de fábrica) |
| Desligar ABC | FF 01 79 00 00 00 00 00 86 | Desliga a calibração automática para estufas e ambientes fechados |
| Calibração do zero | FF 01 87 00 00 00 00 00 78 | Considera o ambiente atual como 400 ppm; faça isso só ao ar livre |
| Faixa de 2000 ppm | FF 01 99 00 00 00 07 D0 8F | Define a faixa de medição como 0–2000 ppm |
| Faixa de 5000 ppm | FF 01 99 00 00 00 13 88 CB | Define a faixa de medição como 0–5000 ppm |
Passo a passo: medindo CO2 com o Arduino Uno
- Ligue o pino Vin do sensor ao pino 5V do Uno e o pino GND ao GND.
- Ligue o pino TX do sensor ao D10; esse pino será o RX do SoftwareSerial.
- Ligue o pino D11 do Uno ao pino RX do sensor passando pelo divisor de tensão de 1 kΩ + 2 kΩ.
- Ligue os LEDs verde, amarelo e vermelho a D4, D5 e D6 com resistores de 220 Ω, e o buzzer passivo ao D8.
- Carregue o código, abra o Monitor Serial em 9600 baud e espere terminar o primeiro aquecimento de 3 minutos.
- Segure o sensor na frente de uma janela aberta por alguns minutos e confira se ele lê por volta de 400–480 ppm; depois expire a cerca de 30 cm de distância e veja o valor subir 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}A cada 5 segundos o código envia o comando de leitura de 9 bytes ao sensor e, em seguida, recolhe a resposta de 9 bytes por até 300 ms. Se o cabeçalho da resposta (FF 86) ou o checksum não baterem, o valor é descartado, assim uma linha com ruído não gera alarme falso. A função readCO2() retorna um código negativo em caso de erro: -1 significa sem resposta, -2 significa cabeçalho errado, -3 significa checksum inválido. Como a temporização é feita com millis() em vez de delay(), o loop() não fica bloqueado; quando você adicionar um botão ou um display mais tarde, o código continua respondendo. Você encontra a lógica dessa abordagem no post millis ou delay. Se preferir uma biblioteca pronta, a biblioteca MH-Z19 (de Jonathan Dempsey) no Gerenciador de Bibliotecas encapsula o mesmo protocolo com funções como getCO2() e autoCalibration(); mas conhecer o protocolo bruto facilita muito encontrar o problema quando o sensor se comporta de forma inesperada.
Aquecimento: por que não confiar nos primeiros 3 minutos?
As medições não são confiáveis até a lâmpada infravermelha e o detector chegarem a uma temperatura estável. O fabricante indica um tempo de aquecimento de 3 minutos; nesse período o sensor pode devolver valores constantes ou sem sentido (por exemplo, sempre 400 ou 500 ppm). Por isso nosso código não faz leituras nos primeiros 180 segundos e só mostra o tempo restante. Além disso, o tempo de resposta T90 do sensor é inferior a 2 minutos: quando o ambiente muda de repente, pode levar um ou dois minutos para chegar a 90% do valor real, então é normal a leitura cair devagar depois que você abre uma janela. Se notar pequenas oscilações entre as medições, tirar a média das últimas 5–10 leituras estabiliza o valor mostrado; veja os métodos no post filtragem de dados de sensores. Se for usar o dispositivo por muito tempo, mantê-lo alimentado o tempo todo dá resultados mais consistentes do que desligar e ligar a cada vez.
Calibração automática (ABC) e calibração manual do zero
O ponto zero dos sensores NDIR se desloca lentamente ao longo de meses e anos. O MH-Z19B corrige isso com a ABC (Automatic Baseline Correction, correção automática da referência): a cada período de 24 horas, o sensor considera o menor valor que viu como ar fresco, ou seja, cerca de 400 ppm, e ajusta sua referência de acordo. A ABC vem ligada de fábrica. Em salas de aula, escritórios e quartos bem ventilados pelo menos uma vez por dia, isso é muito útil; você tem uma precisão razoável por anos sem se preocupar com calibração. Porém, em estufas, salas fechadas de cultivo de cogumelos ou qualquer lugar onde o CO2 nunca cai para 400 ppm, a ABC atrapalha: o sensor confunde, por exemplo, 700 ppm com ar fresco e desloca todas as suas medições para baixo em cerca de 300 ppm. Nesses lugares, desative a ABC com o comando de desligar a ABC e faça uma calibração manual em intervalos regulares.
Para a calibração manual do zero, ligue o sensor ao ar livre, longe do vento e da respiração das pessoas, e deixe-o assim por pelo menos 20 minutos. Depois, envie o comando de calibração do zero 0x87 ou ligue o pino HD ao GND por pelo menos 7 segundos. O sensor registra o ambiente atual como 400 ppm. Nunca faça isso em uma sala fechada; um sensor que toma 900 ppm internos por 400 vai sempre mostrar um ar melhor do que o real, e todo o sentido do dispositivo de alerta se perde. O comando 0x99 também é usado para escolher entre as faixas de 2000 ppm e 5000 ppm; em salas de aula lotadas, a faixa de 5000 ppm é mais segura para o valor não bater no teto em 2000 ppm.
Usando o MH-Z19B com o ESP32
O ESP32 tem três UARTs de hardware, e os pinos delas podem ser atribuídos a qualquer GPIO, então não é preciso usar SoftwareSerial. Ligue o Vin do sensor ao pino VIN (5V) da placa de desenvolvimento ESP32, que fornece os 5 V vindos do USB. O TX do sensor vai para o GPIO 16 e o RX para o GPIO 17; como as duas linhas estão em nível de 3,3 V, a ligação é direta. O código abaixo compila do mesmo jeito no core do Arduino para ESP32 2.x e 3.x; quando o valor passa de 1200 ppm, ele acende o LED do GPIO 26 e dá um bipe curto no buzzer ativo do GPIO 27. Em placas com módulos WROVER, os GPIO 16 e 17 são reservados para a PSRAM; nesse caso escolha, por exemplo, os GPIO 32 e 33. Ao conectar a placa ao Wi-Fi, você pode mostrar o mesmo valor em uma página web, no celular ou no 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}Medição de CO2 com Raspberry Pi Pico e MicroPython
No Pico, a UART0 fica por padrão nos pinos GP0 (TX) e GP1 (RX). Ligue o Vin do sensor ao pino VBUS do Pico (pino 40, os 5 V do USB); a saída 3V3 não é suficiente para o sensor. Se você alimentar o Pico com bateria em vez de USB, não há tensão no VBUS e é preciso dar ao sensor uma fonte de 5 V separada. O TX do sensor vai para o GP1 e o RX para o GP0. O código envia o mesmo comando de 9 bytes da versão para Arduino, verifica o checksum com a função sum() do Python e acende o LED do GP15 (com resistor de 220 Ω) acima de 1200 ppm. Se você está começando no MicroPython, pode dar uma olhada antes no post 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)Onde colocar o sensor na sala de aula ou no quarto?
O lugar certo importa mais que o código certo. Coloque o sensor na altura em que as pessoas respiram sentadas, cerca de 1–1,5 metro acima do chão, em uma parede que represente a média do ambiente. Se você colocá-lo em uma janela ou na entrada da porta, o valor vai ficar mais baixo que o real por causa do ar fresco que entra; se colocá-lo sobre uma mesa muito perto do rosto de alguém, você verá picos a cada respiração. Evite também lugares como em cima de um aquecedor, uma janela com sol direto e um banheiro onde a umidade condensa; o sensor foi projetado para 0–50 °C e umidade sem condensação. O ar entra pelas superfícies com filtro do sensor; se for colocá-lo em uma caixa, faça bastante furos e não bloqueie a circulação de ar em volta do sensor. Se o seu Uno ou ESP32 reiniciar por causa do consumo momentâneo de corrente da lâmpada, adicionar um capacitor eletrolítico de 100 µF e um cerâmico de 100 nF entre o Vin e o GND do sensor estabiliza a alimentação.
Ideias de projetos com o MH-Z19
- Semáforo de ventilação para a sala de aula: Coloque o circuito com LEDs verde, amarelo e vermelho deste post em uma caixa e pendure onde dê para ver da mesa do professor.
- Indicador de mesa com display: Mostre o valor de CO2 com dígitos grandes em um display OLED de 0,96 polegada (SSD1306) ou em um LCD I2C.
- Notificação no celular: Com o ESP32, envie uma mensagem por um bot do Telegram quando o valor passar de 1200 ppm.
- Painel de casa inteligente: Envie as leituras para o Home Assistant com MQTT e Home Assistant, faça um gráfico diário e crie automações.
- Ventoinha de ventilação automática: Acione um exaustor quando o CO2 subir; veja os detalhes de como acionar a ventoinha no post controle de ventoinha com Arduino.
- Monitoramento de estufa: Desligue a ABC, adicione a medição de CO2 ao projeto de estufa inteligente e veja no gráfico como as plantas consomem CO2 durante o dia.
- Indicador colorido da qualidade do ar: Faça um único LED WS2812B passar suavemente do verde em 400 ppm para o vermelho em 2000 ppm.
- Datalogger: Grave as medições de um dia em um cartão SD e veja em qual aula o ar fica pior; você terá um ótimo conjunto de dados para feiras de ciências e projetos de pesquisa escolares.
Erros comuns e como corrigi-los
| Sintoma | Causa provável | Solução |
|---|---|---|
| -1 constante (sem resposta) | TX e RX ligados direto, sem cruzar, ou sensor alimentado com 3,3 V | Cruze TX com RX e dê 5 V ao Vin |
| -3 frequente (erro de checksum) | Fio solto na protoboard, cabo longo ou pino inadequado para SoftwareSerial | Encurte os fios; no Mega e no Leonardo use pinos compatíveis para RX, no Uno o D10 é seguro |
| 400 ou 500 ppm constantes nos primeiros minutos | O aquecimento ainda está em andamento | Espere pelo menos 3 minutos e depois meça |
| Os valores ficam sempre baixos com o passar dos dias | A ABC escolheu a referência errada em um ambiente que nunca é ventilado | Desligue a ABC e faça uma calibração manual ao ar livre |
| O valor trava em 2000 ppm | A faixa de medição está configurada em 2000 ppm | Mude a faixa para 5000 ppm com o comando 0x99 |
| A placa reinicia ou os valores saltam | A corrente momentânea de cerca de 150 mA da lâmpada derruba uma alimentação fraca | Adicione um capacitor de 100 µF entre Vin e GND e use uma fonte de 5 V firme |
| Valores baixos demais depois da calibração | A calibração do zero foi feita em uma sala fechada | Repita a calibração ao ar livre, depois de esperar 20 minutos |
O MH-Z19B é um dos sensores com melhor equilíbrio entre preço e precisão entre os que realmente medem CO2; depois de alimentado corretamente, aquecido por 3 minutos e com a ABC configurada de acordo com o ambiente, ele funciona de forma confiável por anos. Para qualidade do ar em geral e odores, você também pode ver o post sobre o MQ-135 e, para compostos orgânicos voláteis, o post sobre o CCS811. No app BlueGrays você encontra projetos de medição de temperatura e umidade, alarme de gás e projetos com ESP32 e displays LCD e OLED, com esquemas do circuito e códigos passo a passo, e pode combiná-los com este sensor para montar sua própria estação de qualidade do ar.
Perguntas frequentes
Quantos ppm de CO2 um ambiente deve ter?
Ao ar livre, o CO2 fica em torno de 420 ppm, e um ambiente bem ventilado fica abaixo de 800 ppm. Algo em torno de 1000–1200 ppm é sinal de que o ar ficou viciado e está na hora de abrir uma janela. Acima de 2000 ppm, dor de cabeça, sonolência e perda de concentração ficam comuns.
Qual é a diferença entre o MH-Z19B e o MH-Z19C?
Os dois são sensores NDIR com a mesma pinagem e os mesmos comandos UART, então o código deste post funciona em ambos. A versão C é a sucessora mais nova e mais econômica da B. Como a versão C é mais sensível à tensão de alimentação, é importante fornecer a ela 5 V estáveis e reais.
O sensor MH-Z19 funciona com 3,3 V?
Não. A alimentação do sensor precisa estar na faixa de 4,5–5,5 V; com 3,3 V a lâmpada infravermelha não funciona direito e o sensor não responde. Porém, as linhas da UART estão em nível de 3,3 V, então você pode alimentar o sensor com 5 V e ligar TX e RX diretamente a um ESP32 ou Pico.
Devo desligar a calibração automática (ABC) do MH-Z19?
Em salas de aula, escritórios e casas bem ventilados pelo menos uma vez por dia, a ABC deve ficar ligada; o sensor se corrige a cada 24 horas com base no ar fresco. Em estufas, depósitos fechados ou qualquer lugar onde o CO2 nunca cai para 400 ppm, a ABC desloca os valores para baixo de forma errada. Nesses casos, desligue a ABC e faça de vez em quando uma calibração manual ao ar livre.
Qual é a diferença entre o MH-Z19 e o MQ-135?
O MQ-135 é um sensor de gás semicondutor com aquecedor; ele reage ao mesmo tempo a álcool, amônia, fumaça e muitos outros gases, e só consegue dar uma estimativa aproximada do CO2. O MH-Z19 mede o CO2 diretamente por absorção infravermelha, quase não é afetado por outros gases e fornece um valor calibrado em ppm. Para um alerta de ventilação, o MH-Z19 é a escolha certa.
Por que o MH-Z19 mostra valores errados logo que é ligado?
A lâmpada infravermelha e o detector do sensor precisam de cerca de 3 minutos de aquecimento para chegar a uma temperatura estável. Nesse período, ele pode devolver valores constantes ou sem sentido. No seu código, ignore as leituras dos primeiros 3 minutos e espere mais 1–2 minutos para o valor se estabilizar quando o ambiente muda de repente.
Projetos para montar depois desta leitura
Ver todos os projetos
Temperatura e umidade com DHT11
Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

Uso do buzzer
Já se perguntou como uma campainha ou um alarme produz som? O Arduino faz um pequeno buzzer emitir bipes em intervalos curtos: bipe, pausa, bipe, pausa.

Alarme detector de gás e fumaça com ESP32 e MQ-2
Neste projeto, um módulo sensor de gás MQ-2 detecta gases combustíveis (LPG, metano e propano) e fumaça, acionando um alarme tipo sirene em um buzzer passivo. A saída digital de limiar (DO) do sensor é conectada ao GPIO 4 do ESP32. Quando a concentração de gás ou fumaça ultrapassa o limiar, DO passa para LOW e o alarme é acionado. A sensibilidade é ajustada pelo potenciômetro do módulo. O buzzer passivo é acionado com tone() para criar um efeito de sirene que alterna entre duas frequências.

Uso de um sensor de gás
Um pequeno guardião que percebe um vazamento de gás na cozinha antes de você. O sensor de gás monitora o ar continuamente; enquanto está tudo bem, o LED verde fica aceso e, quando o gás no ar…

Alarme com sensores de chama e gás
Um pequeno guardião que avisa você imediatamente quando há um vazamento de gás ou surge uma chama.

Temperatura e umidade com ESP32 e DHT22 (com display LCD)
Este projeto mede a temperatura e a umidade do ambiente com um sensor DHT22 e exibe os dados em tempo real em um LCD I2C 16x2. Os dados são lidos do sensor pelo protocolo de um fio (one-wire) com a biblioteca Adafruit DHT. Este projeto serve de base para estações meteorológicas IoT, automação residencial ou sistemas de monitoramento ambiental em estufas. A comunicação com o DHT22 é feita pelo pino GPIO 4 do ESP32.

ESP32 HTTPClient + API de clima (com display OLED SSD1306)
Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Diferentemente da versão anterior com LCD I2C, aqui usamos um display OLED SSD1306 (128×64), que permite usar fontes grandes, ícones vetoriais e uma apresentação visual rica em uma única tela. Sete ícones vetoriais de condições do tempo (ensolarado, parcialmente nublado, nublado, chuvoso, com neve, com tempestade e com neblina) são desenhados durante a execução, sem arquivos bitmap.

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

