Componentes · 14 min de leitura

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ísticaValor do MH-Z19B
Método de mediçãoNDIR (absorção infravermelha não dispersiva)
Faixa de medição0–2000 ou 0–5000 ppm (selecionada por comando; também existe uma versão de 10000 ppm)
PrecisãoCerca de ±(50 ppm + 3–5% da leitura), dependendo da versão
Tensão de alimentação4,5–5,5 V CC
CorrenteMenos de 60 mA em média, cerca de 150 mA de pico
InterfaceUART 9600 baud 8N1, nível de 3,3 V; também tem saída PWM
Aquecimento3 minutos
Tempo de resposta (T90)Menos de 120 segundos
Condições de operação0–50 °C, 0–90% de umidade relativa (sem condensação)
Vida útilMais 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 CO2AvaliaçãoAlerta no nosso código
400–800 ppmAmbiente arejado e bem ventiladoLED verde
800–1200 ppmAceitável, o ar está começando a ficar viciadoLED amarelo
1200–2000 ppmRuim, hora de abrir uma janelaLED vermelho + buzzer
Acima de 2000 ppmMuito ruim; sonolência e dor de cabeça ficam comunsLED vermelho + buzzer
5000 ppmLimite de exposição ocupacional de 8 horas para locais de trabalhoTopo 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-Z19BArduino UnoESP32Raspberry Pi Pico
Vin (5 V)5VVIN (5V)VBUS (pino 40)
GNDGNDGNDGND
TXD10 (RX do SoftwareSerial)GPIO 16 (RX da UART2)GP1 (RX da UART0)
RXD11 (por um divisor de 1 kΩ + 2 kΩ)GPIO 17 (TX da UART2)GP0 (TX da UART0)
PWMSem conexãoSem conexãoSem conexão
HDSem conexão (no GND durante a calibração)Sem conexãoSem conexão
LEDs de alerta / buzzerD4, D5, D6 / D8GPIO 26 / GPIO 27GP15
Não tente alimentar o sensor com 3,3 V: a lâmpada infravermelha e o circuito interno precisam de 4,5–5,5 V; com 3,3 V o sensor ou não responde ou gera valores sem sentido. O segundo erro mais comum é ligar TX em TX em vez de cruzar as linhas; nesse caso o código fica acusando erro de falta de resposta. Além disso, não aperte o corpo nem o filtro do sensor, e não aqueça o corpo ao soldar os pinos; se a câmara óptica for danificada, a medição fica comprometida para sempre.

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ção9 bytes enviados (hex)Descrição
Ler CO2FF 01 86 00 00 00 00 00 79Os bytes 2 e 3 da resposta são o valor em ppm
Ligar ABCFF 01 79 A0 00 00 00 00 E6Liga a correção automática da referência a cada 24 horas (configuração de fábrica)
Desligar ABCFF 01 79 00 00 00 00 00 86Desliga a calibração automática para estufas e ambientes fechados
Calibração do zeroFF 01 87 00 00 00 00 00 78Considera o ambiente atual como 400 ppm; faça isso só ao ar livre
Faixa de 2000 ppmFF 01 99 00 00 00 07 D0 8FDefine a faixa de medição como 0–2000 ppm
Faixa de 5000 ppmFF 01 99 00 00 00 13 88 CBDefine a faixa de medição como 0–5000 ppm

Passo a passo: medindo CO2 com o Arduino Uno

  1. Ligue o pino Vin do sensor ao pino 5V do Uno e o pino GND ao GND.
  2. Ligue o pino TX do sensor ao D10; esse pino será o RX do SoftwareSerial.
  3. Ligue o pino D11 do Uno ao pino RX do sensor passando pelo divisor de tensão de 1 kΩ + 2 kΩ.
  4. Ligue os LEDs verde, amarelo e vermelho a D4, D5 e D6 com resistores de 220 Ω, e o buzzer passivo ao D8.
  5. Carregue o código, abra o Monitor Serial em 9600 baud e espere terminar o primeiro aquecimento de 3 minutos.
  6. 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.
C++ (Arduino IDE)
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.

Enviar o comando que liga a ABC uma vez no setup() coloca em um estado conhecido até um sensor cuja configuração foi alterada em outro projeto. Se for usar o código em um ambiente fechado como uma estufa, basta substituir o array CMD_ABC_ON pelos bytes FF 01 79 00 00 00 00 00 86.

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.

C++ (Arduino IDE)
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.

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

SintomaCausa provávelSolução
-1 constante (sem resposta)TX e RX ligados direto, sem cruzar, ou sensor alimentado com 3,3 VCruze TX com RX e dê 5 V ao Vin
-3 frequente (erro de checksum)Fio solto na protoboard, cabo longo ou pino inadequado para SoftwareSerialEncurte 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 minutosO aquecimento ainda está em andamentoEspere pelo menos 3 minutos e depois meça
Os valores ficam sempre baixos com o passar dos diasA ABC escolheu a referência errada em um ambiente que nunca é ventiladoDesligue a ABC e faça uma calibração manual ao ar livre
O valor trava em 2000 ppmA faixa de medição está configurada em 2000 ppmMude a faixa para 5000 ppm com o comando 0x99
A placa reinicia ou os valores saltamA corrente momentânea de cerca de 150 mA da lâmpada derruba uma alimentação fracaAdicione um capacitor de 100 µF entre Vin e GND e use uma fonte de 5 V firme
Valores baixos demais depois da calibraçãoA calibração do zero foi feita em uma sala fechadaRepita a calibração ao ar livre, depois de esperar 20 minutos
A forma mais fácil de saber se o sensor está funcionando direito é uma verificação em dois pontos: depois de alguns minutos na frente de uma janela aberta, ele deve ler entre 400 e 480 ppm, e quando você expira perto dele sem cobrir a boca, o valor deve subir para milhares de ppm em um ou dois minutos. Se faltar uma dessas reações, confira primeiro os fios, o sentido de TX e RX e a alimentação de 5 V.

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.

Ver todos os projetos
Temperatura e umidade com DHT11
AR-55Intermediário

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…

4.7(47)
83
Uso do buzzer
AR-13Iniciante

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.

4.7(92)
170
Alarme detector de gás e fumaça com ESP32 e MQ-2
ES-20Intermediário

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.

4.7(29)
44
Uso de um sensor de gás
AR-51Iniciante
Premium

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…

4.6(37)
50
Alarme com sensores de chama e gás
AR-52Avançado
Premium

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.

4.8(52)
67
Temperatura e umidade com ESP32 e DHT22 (com display LCD)
ES-15Intermediário

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.

4.8(38)
57
ESP32 HTTPClient + API de clima (com display OLED SSD1306)
ES-32Avançado
Premium

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.

4.3(10)
22
Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avançado
Premium

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.

4.7(7)
12