Componenti · 13 min di lettura

Sensore CO2 MH-Z19: misurare i ppm con Arduino, ESP32 e Pico

Come usare il sensore CO2 NDIR MH-Z19B? Collegamento UART, lettura ppm, calibrazione ABC, preriscaldamento e codice per Uno, ESP32 e Pico con avviso LED.

Il sensore CO2 MH-Z19 è un sensore NDIR a luce infrarossa che misura direttamente la quantità di anidride carbonica nell'ambiente in ppm (parti per milione). Si collega ad Arduino, ESP32 o Raspberry Pi Pico con soli quattro fili (5 V, GND, TX, RX) e restituisce via UART un vero valore di CO2 in pochi millisecondi. A differenza dei sensori di gas economici, non stima nulla: misura quanta luce assorbono le molecole di CO2 presenti nell'aria. Per questo è uno dei modi più affidabili ed economici per costruire un avviso di ventilazione per aule, camere da letto e uffici tenuti chiusi in inverno.

In questo articolo imparerai come funziona l'MH-Z19B, i suoi pin e il collegamento corretto, come leggere i ppm con i comandi UART, il preriscaldamento di 3 minuti e la spesso fraintesa calibrazione automatica (ABC). Poi realizzeremo un avviso di ventilazione con LED verde, giallo e rosso, con codice funzionante per Arduino Uno (SoftwareSerial), ESP32 (UART hardware) e Raspberry Pi Pico (MicroPython). Vedendo come in un'aula chiusa la CO2 possa superare i 2000 ppm in una sola ora di lezione, capirai perché questo sensore è così popolare.

Cos'è il sensore CO2 MH-Z19 e come funziona?

NDIR sta per Non-Dispersive Infrared, cioè infrarosso non dispersivo. Una piccola lampada dentro il sensore emette luce infrarossa; la luce attraversa la camera di misura, dove entra l'aria attraverso il filtro, e raggiunge il rivelatore dall'altra parte. Le molecole di CO2 assorbono fortemente la luce con lunghezza d'onda di circa 4,26 micrometri. Un filtro ottico a banda stretta davanti al rivelatore lascia passare solo questa lunghezza d'onda: più CO2 c'è nell'aria, meno luce arriva al rivelatore. Il microcontrollore interno corregge la differenza in base alla temperatura, la converte in ppm e ti invia un numero già pronto. Poiché la misura si basa su un assorbimento fisico, è molto più selettiva dei sensori a semiconduttore con riscaldatore come la serie MQ: profumo, alcol o odore di cibo non alterano il valore di CO2.

CaratteristicaValore dell'MH-Z19B
Metodo di misuraNDIR (assorbimento infrarosso non dispersivo)
Intervallo di misura0–2000 o 0–5000 ppm (selezionabile con un comando; esiste anche la versione da 10000 ppm)
PrecisioneCirca ±(50 ppm + 3–5% della lettura), a seconda della versione
Tensione di alimentazione4,5–5,5 V DC
CorrenteMedia sotto i 60 mA, picco circa 150 mA
InterfacciaUART 9600 baud 8N1, livello 3,3 V; anche uscita PWM
Preriscaldamento3 minuti
Tempo di risposta (T90)Meno di 120 secondi
Condizioni di lavoro0–50 °C, umidità relativa 0–90% (senza condensa)
DurataOltre 5 anni (valore del produttore)

Livelli di CO2: cosa significano i ppm?

All'aperto, in aria pulita, oggi la CO2 è intorno ai 420 ppm. In una stanza chiusa ogni persona aggiunge continuamente CO2 con il respiro: un adulto a riposo ne produce circa 15–20 litri all'ora. Facciamo un calcolo semplice: in un'aula da 150 m³ con 25 studenti si producono circa 0,4 m³ di CO2 all'ora. Senza alcuna ventilazione sarebbe un aumento di 0,4 / 150 ≈ 0,0027, cioè circa 2700 ppm all'ora. Grazie a fessure e spifferi l'aumento reale è più lento, ma vedere 2000 ppm alla fine di un'ora di lezione a finestre chiuse non è affatto raro. A questi livelli la CO2 non è direttamente tossica, ma è il miglior indicatore di cattiva ventilazione ed è associata a stanchezza, mal di testa e distrazione. Molte linee guida per scuole e uffici considerano circa 1000 ppm come limite oltre il quale ventilare.

Intervallo di CO2ValutazioneAvviso nel nostro codice
400–800 ppmAmbiente pulito e ben ventilatoLED verde
800–1200 ppmAccettabile, l'aria inizia a diventare viziataLED giallo
1200–2000 ppmCattiva, è ora di aprire la finestraLED rosso + buzzer
Oltre 2000 ppmPessima; sonnolenza e mal di testa diventano frequentiLED rosso + buzzer
5000 ppmLimite di esposizione professionale su 8 ore nei luoghi di lavoroFondo scala della misura

Pin dell'MH-Z19B e schema di collegamento

Sull'MH-Z19B di solito ci sono 7 pin: Vin (alimentazione), GND, TX e RX (UART), PWM (uscita a larghezza d'impulso), HD (calibrazione manuale dello zero) e, in alcune versioni, Vo (uscita analogica in tensione). Sull'uscita PWM il periodo è di circa 1004 ms e il valore si calcola con la formula ppm = intervallo × (TH − 2 ms) / (TH + TL − 4 ms); ma dato che per ogni lettura serve aspettare un secondo, l'UART è molto più pratica. Useremo quindi l'UART; PWM e HD possono restare scollegati. In UART i fili vanno sempre incrociati: il TX del sensore va all'RX della scheda e l'RX del sensore al TX della scheda. Trovi le basi della comunicazione seriale nell'articolo comunicazione seriale UART.

Pin MH-Z19BArduino UnoESP32Raspberry Pi Pico
Vin (5 V)5VVIN (5V)VBUS (pin 40)
GNDGNDGNDGND
TXD10 (RX SoftwareSerial)GPIO 16 (RX UART2)GP1 (RX UART0)
RXD11 (con partitore 1 kΩ + 2 kΩ)GPIO 17 (TX UART2)GP0 (TX UART0)
PWMNon collegatoNon collegatoNon collegato
HDNon collegato (a GND durante la calibrazione)Non collegatoNon collegato
LED di avviso / buzzerD4, D5, D6 / D8GPIO 26 / GPIO 27GP15
Non provare ad alimentare il sensore a 3,3 V: la lampada a infrarossi e il circuito interno richiedono 4,5–5,5 V; a 3,3 V il sensore o non risponde affatto o produce valori privi di senso. Il secondo errore frequente è collegare TX con RX in modo diretto (TX con TX): in quel caso il codice segnala continuamente che non c'è risposta. Inoltre non premere sul corpo e sul filtro del sensore e non scaldare il corpo mentre saldi i pin; se la camera ottica si danneggia, la misura resta compromessa per sempre.

Il TX del sensore è a livello 3,3 V e l'Uno lo legge senza problemi come HIGH. In senso opposto, invece, il pin TX dell'Uno eroga 5 V. Nella documentazione del produttore il livello dell'interfaccia è indicato come 3,3 V; anche se alcuni moduli tollerano i 5 V, la via più sicura è mettere un semplice partitore di tensione tra il pin D11 dell'Uno e l'RX del sensore: 1 kΩ da D11 all'RX del sensore e 2 kΩ dall'RX del sensore a GND. L'uscita è 5 × 2 / (1 + 2) = 3,33 V. Puoi verificare i valori con le resistenze che hai usando il calcolatore del partitore di tensione, oppure usare un convertitore di livello logico bidirezionale. ESP32 e Pico lavorano già a 3,3 V, quindi con loro il partitore non serve.

Protocollo UART: come si parla con il sensore?

L'MH-Z19B funziona con impostazione 9600 baud, 8 bit di dati, nessuna parità, 1 bit di stop (8N1). Ogni comando e ogni risposta sono esattamente di 9 byte. I comandi iniziano con 0xFF, il secondo byte è il numero del sensore (0x01), il terzo è il codice del comando; l'ultimo byte è il checksum. Il checksum si ricava dalla somma dei byte da 1 a 7 così: checksum = 0xFF − (byte1 + … + byte7) + 1, con il risultato troncato a un solo byte. Nella risposta al comando di lettura il byte 0 è 0xFF, il byte 1 è 0x86; il valore di CO2 si trova nei byte 2 e 3: ppm = byte alto × 256 + byte basso. Ad esempio, se la risposta inizia con FF 86 02 58, il valore è 2 × 256 + 88 = 600 ppm. Il byte 4 è un valore approssimativo di temperatura non documentato (valore − 40 °C) ed è solo indicativo; per una vera misura di temperatura usa un sensore dedicato.

Operazione9 byte inviati (hex)Descrizione
Lettura CO2FF 01 86 00 00 00 00 00 79I byte 2 e 3 della risposta sono il valore in ppm
ABC attivoFF 01 79 A0 00 00 00 00 E6Attiva la correzione automatica della base ogni 24 ore (impostazione di fabbrica)
ABC disattivoFF 01 79 00 00 00 00 00 86Disattiva la calibrazione automatica per serre e ambienti chiusi
Calibrazione dello zeroFF 01 87 00 00 00 00 00 78Considera l'ambiente attuale come 400 ppm; eseguila solo all'aperto
Intervallo 2000 ppmFF 01 99 00 00 00 07 D0 8FImposta l'intervallo di misura a 0–2000 ppm
Intervallo 5000 ppmFF 01 99 00 00 00 13 88 CBImposta l'intervallo di misura a 0–5000 ppm

Passo dopo passo: misurare la CO2 con Arduino Uno

  1. Collega il pin Vin del sensore al pin 5V dell'Uno e il pin GND a GND.
  2. Collega il pin TX del sensore a D10; sarà l'RX di SoftwareSerial.
  3. Collega il pin D11 dell'Uno all'RX del sensore tramite un partitore di tensione 1 kΩ + 2 kΩ.
  4. Collega i LED verde, giallo e rosso con resistenze da 220 Ω rispettivamente a D4, D5 e D6, e il buzzer passivo a D8.
  5. Carica il codice, apri il Monitor Seriale a 9600 baud e aspetta che finiscano i primi 3 minuti di preriscaldamento.
  6. Tieni il sensore per qualche minuto davanti a una finestra aperta e verifica che legga circa 400–480 ppm; poi soffia da circa 30 cm di distanza e osserva il valore salire rapidamente.
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}

Il codice invia al sensore il comando di lettura da 9 byte ogni 5 secondi, poi raccoglie la risposta da 9 byte per al massimo 300 ms. Se l'intestazione (FF 86) o il checksum non corrispondono, il valore viene scartato; così una linea disturbata non genera falsi allarmi. La funzione readCO2() restituisce un codice negativo in caso di errore: -1 significa nessuna risposta, -2 intestazione sbagliata, -3 checksum errato. Poiché la temporizzazione è fatta con millis() invece di delay(), loop() non si blocca; se in futuro aggiungi un pulsante o un display, il codice resterà reattivo. Trovi la logica di questo approccio nell'articolo differenza tra millis e delay. Se preferisci una libreria pronta, la libreria MH-Z19 (Jonathan Dempsey) del Gestore Librerie incapsula lo stesso protocollo con funzioni come getCO2() e autoCalibration(); ma conoscere il protocollo grezzo ti rende molto più facile trovare il problema quando il sensore si comporta in modo strano.

Preriscaldamento: perché non fidarti dei primi 3 minuti?

Finché la lampada a infrarossi e il rivelatore non raggiungono una temperatura stabile, la misura non è affidabile. Il produttore indica un tempo di preriscaldamento di 3 minuti; in questo periodo il sensore può restituire valori fissi o privi di senso (per esempio sempre 400 o 500 ppm). Per questo il nostro codice non legge nei primi 180 secondi e stampa solo il tempo rimasto. Inoltre il tempo di risposta T90 del sensore è inferiore a 2 minuti: quando l'ambiente cambia all'improvviso, per raggiungere il 90% del valore reale possono servire uno o due minuti, quindi è normale che dopo aver aperto la finestra il valore scenda lentamente. Se noti piccole oscillazioni tra le misure, fare la media delle ultime 5–10 letture rende il valore sul display più stabile; per i metodi dai un'occhiata all'articolo filtraggio dei dati dei sensori. Se userai il dispositivo a lungo, tenerlo sempre alimentato dà risultati più coerenti che spegnerlo e riaccenderlo ogni volta.

Calibrazione automatica (ABC) e calibrazione manuale dello zero

Il punto zero dei sensori NDIR si sposta lentamente nel corso di mesi e anni. L'MH-Z19B lo corregge con l'ABC (Automatic Baseline Correction): in ogni periodo di 24 ore il sensore considera il valore più basso rilevato come aria pulita, cioè circa 400 ppm, e regola di conseguenza la propria base. L'ABC è attivo di fabbrica. In aule, uffici e camere da letto che vengono ben ventilati almeno una volta al giorno è molto utile: ottieni una precisione ragionevole per anni senza occuparti della calibrazione. Ma in serre, locali chiusi per funghi o ambienti in cui la CO2 non scende mai a 400 ppm l'ABC è dannoso: il sensore scambia per esempio 700 ppm per aria pulita e sposta tutte le misure di circa 300 ppm verso il basso. In questi casi disattiva l'ABC con il comando apposito ed esegui la calibrazione manuale a intervalli regolari.

Per la calibrazione manuale dello zero, fai funzionare il sensore all'aperto, lontano dal vento e dal respiro delle persone, e lascialo almeno 20 minuti. Poi invia il comando di calibrazione dello zero 0x87 oppure collega il pin HD a GND per almeno 7 secondi. Il sensore registra l'ambiente di quel momento come 400 ppm. Non farlo mai in una stanza chiusa; un sensore che scambia 900 ppm interni per 400 ti mostrerà sempre un'aria migliore di quella reale e tutto il senso del dispositivo di avviso andrà perso. Il comando 0x99 serve anche per scegliere tra gli intervalli 2000 e 5000 ppm; nelle aule affollate l'intervallo 5000 ppm è più sicuro, perché il valore non si blocca al tetto di 2000 ppm.

Inviare una volta in setup() il comando che attiva l'ABC riporta in uno stato noto anche un sensore la cui impostazione era stata cambiata in un altro progetto. Se userai il codice in un ambiente chiuso come una serra, ti basta sostituire l'array CMD_ABC_ON con i byte FF 01 79 00 00 00 00 00 86.

Usare l'MH-Z19B con l'ESP32

L'ESP32 ha tre UART hardware e i loro pin possono essere assegnati ai GPIO che vuoi; quindi non serve SoftwareSerial. Collega il Vin del sensore al pin VIN (5V) della scheda di sviluppo ESP32, che eroga i 5 V provenienti dall'USB. Il TX del sensore va al GPIO 16 e l'RX al GPIO 17; poiché entrambe le linee sono a livello 3,3 V, si collegano direttamente. Il codice seguente si compila allo stesso modo con l'Arduino core per ESP32 versioni 2.x e 3.x; quando il valore supera 1200 ppm accende il LED sul GPIO 26 ed emette un breve bip dal buzzer attivo sul GPIO 27. Sulle schede con modulo WROVER i GPIO 16 e 17 sono riservati alla PSRAM; in quel caso scegli per esempio i GPIO 32 e 33. Quando colleghi la scheda al Wi-Fi puoi mostrare lo stesso valore su una pagina web, sul telefono o in 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}

Misurare la CO2 con Raspberry Pi Pico e MicroPython

Sul Pico la UART0 si trova per impostazione predefinita sui pin GP0 (TX) e GP1 (RX). Collega il Vin del sensore al pin VBUS del Pico (pin 40, i 5 V dell'USB); l'uscita 3V3 non basta per il sensore. Se alimenti il Pico a batteria invece che via USB, su VBUS non c'è tensione e devi fornire al sensore una fonte da 5 V separata. Il TX del sensore va a GP1 e l'RX a GP0. Il codice invia lo stesso comando da 9 byte della versione Arduino, verifica il checksum con la funzione sum() di Python e sopra i 1200 ppm accende il LED su GP15 (con resistenza da 220 Ω). Se sei alle prime armi con MicroPython, dai prima un'occhiata all'articolo basi di 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)

Dove posizionare il sensore in aula o in stanza?

La posizione giusta conta più del codice giusto. Metti il sensore all'altezza a cui le persone sedute respirano, circa 1–1,5 metri da terra, su una parete che rappresenti la media della stanza. Se lo metti vicino a una finestra o a una porta, il valore risulta più basso del reale a causa dell'aria fresca che entra; se lo metti sul tavolo molto vicino al viso di qualcuno, vedrai valori che schizzano a ogni respiro. Evita anche posti come sopra un termosifone, davanti a una finestra con sole diretto o un bagno dove l'umidità condensa; il sensore è progettato per 0–50 °C e umidità senza condensa. L'aria entra dalle superfici filtrate del sensore; se lo metti in una scatola, fai molti fori e non ostacolare la circolazione dell'aria intorno al sensore. Se l'Uno o l'ESP32 si resettano a causa dell'assorbimento di corrente istantaneo della lampada, aggiungere un condensatore elettrolitico da 100 µF e uno ceramico da 100 nF tra Vin e GND del sensore stabilizza l'alimentazione.

Idee di progetto con l'MH-Z19

  • Semaforo di ventilazione per la classe: metti in una scatola il circuito con LED verde, giallo e rosso di questo articolo e appendilo in un punto visibile dalla cattedra.
  • Indicatore da scrivania con display: mostra il valore di CO2 a cifre grandi su un display OLED SSD1306 o su un display LCD I2C.
  • Notifica sul telefono: con l'ESP32 invia un messaggio tramite un bot Telegram quando il valore supera 1200 ppm.
  • Pannello per la casa intelligente: invia le misure a Home Assistant tramite MQTT, disegna il grafico giornaliero e crea automazioni.
  • Ventola di ventilazione automatica: quando la CO2 sale, avvia un aspiratore; per i dettagli sul pilotaggio della ventola vedi l'articolo controllo ventola con Arduino.
  • Monitoraggio della serra: disattiva l'ABC e aggiungi la misura di CO2 al progetto di serra intelligente, e osserva nel grafico che le piante consumano CO2 di giorno.
  • Indicatore d'aria colorato: fai passare dolcemente il colore di un singolo LED WS2812B dal verde a 400 ppm al rosso a 2000 ppm.
  • Registratore di dati: scrivi su scheda SD le misure di un giorno e scopri in quale ora di lezione l'aria peggiora di più; otterrai un set di dati valido per fiere della scienza e progetti scolastici.

Errori comuni e come risolverli

SintomoCausa probabileSoluzione
Sempre -1 (nessuna risposta)TX e RX collegati in modo diretto o sensore alimentato a 3,3 VIncrocia TX e RX e dai 5 V a Vin
Spesso -3 (errore di checksum)Filo di breadboard lento, cavo lungo o pin non adatto a SoftwareSerialAccorcia i cavi; su Mega e Leonardo usa i pin supportati per RX, sull'Uno D10 è sicuro
Nei primi minuti sempre 400 o 500 ppmIl preriscaldamento è in corsoAspetta almeno 3 minuti, poi misura
Con il passare dei giorni i valori sono sempre bassiIn un ambiente mai ventilato l'ABC ha scelto una base sbagliataDisattiva l'ABC ed esegui la calibrazione manuale all'aperto
Il valore si blocca a 2000 ppmL'intervallo di misura è impostato a 2000 ppmImposta l'intervallo a 5000 ppm con il comando 0x99
La scheda si resetta o i valori saltanoL'assorbimento istantaneo di circa 150 mA della lampada fa crollare un'alimentazione deboleAggiungi un condensatore da 100 µF tra Vin e GND, usa una sorgente da 5 V solida
Dopo la calibrazione i valori sono troppo bassiLa calibrazione dello zero è stata fatta in una stanza chiusaRipeti la calibrazione all'aperto dopo aver aspettato 20 minuti
Il modo più semplice per capire se il sensore funziona bene è un controllo a due punti: davanti a una finestra aperta, dopo qualche minuto, deve leggere tra 400 e 480 ppm; quando soffi da vicino senza coprire la bocca, il valore deve salire a migliaia di ppm nel giro di uno o due minuti. Se manca una di queste due reazioni, controlla prima i cavi, il verso di TX e RX e l'alimentazione a 5 V.

L'MH-Z19B è uno dei sensori con il miglior equilibrio tra prezzo e precisione tra quelli che misurano davvero la CO2; se alimentato correttamente, riscaldato per 3 minuti e con l'ABC scelto in base all'ambiente, funziona in modo affidabile per anni. Per la qualità dell'aria in generale e gli odori puoi dare un'occhiata agli articoli sull'MQ-135, e per i composti organici volatili al CCS811. Nell'app BlueGrays trovi passo dopo passo progetti ESP32 con misura di temperatura e umidità, allarme gas, display LCD e OLED, con schemi e codice, e puoi combinarli con questo sensore per costruire la tua stazione di qualità dell'aria.

Domande frequenti

Quanti ppm di CO2 dovrebbe avere una stanza?

All'aperto la CO2 è circa 420 ppm e una stanza ben ventilata resta sotto gli 800 ppm. Intorno a 1000–1200 ppm l'aria sta diventando viziata ed è ora di aprire la finestra. Sopra i 2000 ppm mal di testa, sonnolenza e distrazione diventano frequenti.

Che differenza c'è tra MH-Z19B e MH-Z19C?

Sono entrambi sensori NDIR, con la stessa piedinatura e gli stessi comandi UART; i codici di questo articolo funzionano su entrambi. La versione C è l'erede più recente ed economica della B. Poiché la C è più sensibile alla tensione di alimentazione, è importante darle veri 5 V stabili.

L'MH-Z19 funziona a 3,3 V?

No. L'alimentazione del sensore deve essere nell'intervallo 4,5–5,5 V; a 3,3 V la lampada a infrarossi non funziona bene e il sensore non risponde. Le linee UART però sono a livello 3,3 V; quindi puoi alimentare il sensore a 5 V e collegare TX e RX direttamente a ESP32 o Pico.

Bisogna disattivare la calibrazione automatica (ABC) dell'MH-Z19?

In aule, uffici e case ben ventilati almeno una volta al giorno l'ABC va lasciato attivo; il sensore si corregge ogni 24 ore sull'aria pulita. In serre, magazzini chiusi o ambienti in cui la CO2 non scende mai a 400 ppm, invece, l'ABC sposta i valori verso il basso in modo errato. Lì devi disattivare l'ABC e fare ogni tanto una calibrazione manuale all'aperto.

Che differenza c'è tra MH-Z19 e MQ-135?

L'MQ-135 è un sensore di gas a semiconduttore con riscaldatore: reagisce insieme ad alcol, ammoniaca, fumo e molti altri gas e può mostrare la CO2 solo come stima approssimativa. L'MH-Z19 invece misura direttamente la CO2 per assorbimento infrarosso, è quasi insensibile agli altri gas e restituisce un valore calibrato in ppm. Per un avviso di ventilazione la scelta giusta è l'MH-Z19.

Perché l'MH-Z19 mostra valori sbagliati appena acceso?

La lampada a infrarossi e il rivelatore del sensore hanno bisogno di circa 3 minuti di preriscaldamento per raggiungere una temperatura stabile. In questo periodo possono essere restituiti valori fissi o privi di senso. Nel codice ignora le letture dei primi 3 minuti e, quando l'ambiente cambia all'improvviso, aspetta altri 1–2 minuti perché il valore si assesti.

Vedi tutti i progetti
Temperatura e umidità con DHT11
AR-55Intermedio

Temperatura e umidità con DHT11

Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

4.7(47)
83
Uso del cicalino
AR-13Principiante

Uso del cicalino

Ti sei mai chiesto come fa un campanello o un allarme a suonare? L'Arduino fa suonare un piccolo cicalino a intervalli brevi: bip, pausa, bip, pausa.

4.7(92)
170
Allarme rilevatore di gas/fumo ESP32 MQ-2
ES-20Intermedio

Allarme rilevatore di gas/fumo ESP32 MQ-2

In questo progetto, il rilevamento di gas combustibili (GPL, metano, propano) e fumo viene effettuato tramite un modulo sensore di gas MQ-2; al rilevamento viene emesso un segnale acustico simile a una sirena tramite un cicalino passivo. L'uscita digitale di soglia (DO) del sensore viene collegata al GPIO 4 dell'ESP32; quando gas o fumo superano la soglia, DO passa a LOW e l'allarme si attiva. La sensibilità si regola tramite il potenziometro del modulo. Il cicalino è pilotato con tone().

4.7(29)
44
Utilizzo del sensore di gas
AR-51Principiante
Premium

Utilizzo del sensore di gas

Un piccolo guardiano che si accorge di una fuga di gas in cucina prima di te. Il sensore di gas annusa l'aria di continuo; finché va tutto bene resta acceso il LED verde, e quando il gas nell'aria…

4.6(37)
50
Allarme del sensore di fiamma e gas
AR-52Avanzato
Premium

Allarme del sensore di fiamma e gas

Un piccolo guardiano che ti avvisa subito se c'è una fuga di gas o compare una fiamma da qualche parte.

4.8(52)
67
ESP32 DHT22 Temperatura e umidità (con display LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura e umidità (con display LCD)

Si tratta di un progetto che misura la temperatura e l'umidità dell'ambiente tramite il sensore DHT22 e le visualizza in tempo reale su un display LCD I2C 16x2. I dati vengono letti dal sensore utilizzando il protocollo one-wire tramite la libreria Adafruit DHT. Questo progetto costituisce la base per stazioni meteorologiche IoT, sistemi di automazione domestica intelligente o sistemi di monitoraggio ambientale nelle serre. La comunicazione con il DHT22 avviene tramite il pin GPIO 4 dell'ESP32.

4.8(38)
57
ESP32 HTTPClient + API meteo (con display OLED SSD1306)
ES-32Avanzato
Premium

ESP32 HTTPClient + API meteo (con display OLED SSD1306)

L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. A differenza della versione con LCD I2C, qui usiamo un display OLED SSD1306 (128×64), con testo grande e icone vettoriali per una resa più ricca. Sette icone meteo (sole, pioggia, neve e altre) vengono disegnate al volo, senza file bitmap.

4.3(10)
22
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

4.7(7)
12