MH-Z19 CO2-sensor: meet ppm met Arduino, ESP32 en Pico
Hoe gebruik je de MH-Z19B NDIR CO2-sensor? UART-bedrading, ppm uitlezen, ABC-kalibratie, opwarmtijd en code voor Uno, ESP32 en Pico voor een ventilatiewaarschuwing.
De MH-Z19 CO2-sensor is een NDIR-sensor die met infrarood licht de hoeveelheid koolstofdioxide in de lucht rechtstreeks meet in ppm (parts per million). Hij sluit met maar vier draden (5 V, GND, TX, RX) aan op een Arduino, ESP32 of Raspberry Pi Pico en geeft binnen milliseconden een echte CO2-waarde via UART. In tegenstelling tot goedkope gassensoren gokt hij niet: hij meet hoeveel licht de CO2-moleculen in de lucht absorberen. Daardoor is hij een van de betrouwbaarste en goedkoopste manieren om een ventilatiewaarschuwing te bouwen voor klaslokalen, slaapkamers en kantoren waar de ramen in de winter dicht blijven.
In dit bericht leer je hoe de MH-Z19B werkt, wat zijn pinnen zijn en hoe je hem juist bedraadt, hoe je ppm uitleest met UART-commando's, hoe de opwarmtijd van 3 minuten zit en hoe de vaak verwarrende automatische kalibratie (ABC) werkt. Daarna bouwen we een ventilatiewaarschuwing met groene, gele en rode leds, met werkende code voor de Arduino Uno (SoftwareSerial), ESP32 (hardware-UART) en Raspberry Pi Pico (MicroPython). Als je ziet dat CO2 in een gesloten klaslokaal binnen één les boven 2000 ppm kan komen, begrijp je meteen waarom deze sensor zo populair is.
Wat is de MH-Z19 CO2-sensor en hoe werkt hij?
NDIR staat voor Non-Dispersive Infrared. Een kleine lamp in de sensor zendt infrarood licht uit; het licht gaat door een meetkamer gevuld met lucht die via een filter binnenkomt en bereikt de detector aan de andere kant. CO2-moleculen absorberen licht sterk bij een golflengte van ongeveer 4,26 micrometer. Een smalbandig optisch filter voor de detector laat alleen die golflengte door: hoe meer CO2 in de lucht, hoe minder licht de detector bereikt. Een microcontroller in de sensor corrigeert dit verschil voor de temperatuur, rekent het om naar een ppm-waarde en stuurt je die als kant-en-klaar getal. Omdat de meting op fysieke absorptie berust, is hij veel selectiever dan verwarmde halfgeleidersensoren zoals de MQ-serie: parfum, alcohol of kooklucht veranderen de CO2-waarde niet.
| Eigenschap | Waarde MH-Z19B |
|---|---|
| Meetmethode | NDIR (niet-dispersieve infraroodabsorptie) |
| Meetbereik | 0–2000 of 0–5000 ppm (te kiezen met een commando; er bestaat ook een versie van 10000 ppm) |
| Nauwkeurigheid | Ongeveer ±(50 ppm + 3–5% van de meting), afhankelijk van de versie |
| Voedingsspanning | 4,5–5,5 V gelijkspanning |
| Stroom | Gemiddeld minder dan 60 mA, piek ongeveer 150 mA |
| Interface | UART 9600 baud 8N1, 3,3 V-niveau; ook een PWM-uitgang |
| Opwarmtijd | 3 minuten |
| Responstijd (T90) | Minder dan 120 seconden |
| Gebruiksomstandigheden | 0–50 °C, 0–90% relatieve luchtvochtigheid (niet-condenserend) |
| Levensduur | Meer dan 5 jaar (opgave van de fabrikant) |
CO2-niveaus: wat betekent elke ppm-waarde?
In schone buitenlucht ligt CO2 tegenwoordig rond 420 ppm. In een gesloten ruimte voegt elke persoon bij elke ademhaling CO2 toe: een volwassene in rust produceert ongeveer 15–20 liter CO2 per uur. Een snelle berekening: in een klaslokaal van 150 m³ produceren 25 leerlingen ongeveer 0,4 m³ CO2 per uur. Zonder enige ventilatie is dat 0,4 / 150 ≈ 0,0027, oftewel een stijging van ongeveer 2700 ppm per uur. Door kieren rond deuren en lekken stijgt het in werkelijkheid langzamer, maar 2000 ppm aan het einde van een les met gesloten ramen is verre van zeldzaam. Op dit niveau is CO2 niet direct giftig, maar het is wel de beste indicator voor slechte ventilatie en wordt in verband gebracht met vermoeidheid, hoofdpijn en concentratieverlies. Veel richtlijnen voor scholen en kantoren hanteren ongeveer 1000 ppm als ventilatiegrens.
| CO2-bereik | Beoordeling | Waarschuwing in onze code |
|---|---|---|
| 400–800 ppm | Frisse, goed geventileerde ruimte | Groene led |
| 800–1200 ppm | Acceptabel, de lucht wordt langzaam bedompt | Gele led |
| 1200–2000 ppm | Slecht, tijd om een raam open te zetten | Rode led + buzzer |
| Boven 2000 ppm | Zeer slecht; slaperigheid en hoofdpijn komen vaak voor | Rode led + buzzer |
| 5000 ppm | Grenswaarde voor beroepsmatige blootstelling over 8 uur op werkplekken | Bovenkant van het meetbereik |
Pinnen van de MH-Z19B en bedradingsschema
De MH-Z19B heeft meestal 7 pinnen: Vin (voeding), GND, TX en RX (UART), PWM (pulsbreedte-uitgang), HD (handmatige nulkalibratie) en bij sommige versies Vo (analoge spanningsuitgang). Op de PWM-uitgang is de periode ongeveer 1004 ms en wordt de waarde berekend met de formule ppm = bereik × (TH − 2 ms) / (TH + TL − 4 ms); maar omdat je voor elke meting een seconde moet wachten, is UART veel praktischer. Wij gebruiken UART, dus PWM en HD kunnen onaangesloten blijven. Bij UART worden de draden altijd gekruist: de TX van de sensor gaat naar de RX van het board en de RX van de sensor naar de TX van het board. De basis van seriële communicatie vind je uitgebreid in het bericht UART seriële communicatie.
| Pin MH-Z19B | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Vin (5 V) | 5V | VIN (5V) | VBUS (pin 40) |
| GND | GND | GND | GND |
| TX | D10 (SoftwareSerial RX) | GPIO 16 (UART2 RX) | GP1 (UART0 RX) |
| RX | D11 (via 1 kΩ + 2 kΩ spanningsdeler) | GPIO 17 (UART2 TX) | GP0 (UART0 TX) |
| PWM | Niet aangesloten | Niet aangesloten | Niet aangesloten |
| HD | Niet aangesloten (tijdens kalibratie naar GND) | Niet aangesloten | Niet aangesloten |
| Waarschuwingsleds / buzzer | D4, D5, D6 / D8 | GPIO 26 / GPIO 27 | GP15 |
De TX-uitgang van de sensor staat op 3,3 V en de Uno leest dat zonder problemen als HIGH. In de andere richting geeft de TX-pin van de Uno echter 5 V af. In de documenten van de fabrikant is het interfaceniveau 3,3 V; sommige modules verdragen 5 V, maar het veiligst is een eenvoudige spanningsdeler tussen pin D11 van de Uno en de RX van de sensor: 1 kΩ van D11 naar de RX van de sensor en 2 kΩ van de RX van de sensor naar GND. De uitgang wordt dan 5 × 2 / (1 + 2) = 3,33 V. Met de spanningsdelercalculator kun je de waarden controleren aan de hand van de weerstanden die je hebt, of je gebruikt een bidirectionele niveauconverter. De ESP32 en Pico werken al op 3,3 V, dus die hebben geen deler nodig.
UART-protocol: hoe praat je met de sensor?
De MH-Z19B werkt met 9600 baud, 8 databits, geen pariteit, 1 stopbit (8N1). Elk commando en elk antwoord is precies 9 bytes lang. Commando's beginnen met 0xFF, de tweede byte is het sensornummer (0x01), de derde is de commandocode en de laatste byte is de checksum. De checksum bereken je uit de som van byte 1 tot en met 7 zo: checksum = 0xFF − (byte1 + … + byte7) + 1, waarbij het resultaat wordt afgekapt tot één byte. In het antwoord op het leescommando is byte 0 gelijk aan 0xFF en byte 1 aan 0x86; de CO2-waarde staat in byte 2 en 3: ppm = hoge byte × 256 + lage byte. Begint het antwoord bijvoorbeeld met FF 86 02 58, dan is de waarde 2 × 256 + 88 = 600 ppm. Byte 4 is een niet-gedocumenteerde, grove temperatuurwaarde (waarde − 40 °C) en geeft alleen een indruk; gebruik voor echte temperatuurmeting een aparte sensor.
| Bewerking | Verzonden 9 bytes (hex) | Beschrijving |
|---|---|---|
| CO2 lezen | FF 01 86 00 00 00 00 00 79 | Byte 2 en 3 van het antwoord vormen de ppm-waarde |
| ABC aan | FF 01 79 A0 00 00 00 00 E6 | Schakelt de automatische basislijncorrectie van 24 uur in (fabrieksinstelling) |
| ABC uit | FF 01 79 00 00 00 00 00 86 | Schakelt de automatische kalibratie uit, voor kassen en afgesloten ruimtes |
| Nulkalibratie | FF 01 87 00 00 00 00 00 78 | Beschouwt de huidige omgeving als 400 ppm; doe dit alleen buiten |
| Bereik 2000 ppm | FF 01 99 00 00 00 07 D0 8F | Stelt het meetbereik in op 0–2000 ppm |
| Bereik 5000 ppm | FF 01 99 00 00 00 13 88 CB | Stelt het meetbereik in op 0–5000 ppm |
Stap voor stap: CO2 meten met de Arduino Uno
- Verbind de pin Vin van de sensor met de 5V-pin van de Uno en de pin GND met GND.
- Verbind de pin TX van de sensor met D10; deze pin wordt de RX van SoftwareSerial.
- Verbind pin D11 van de Uno via de spanningsdeler van 1 kΩ + 2 kΩ met de RX-pin van de sensor.
- Sluit de groene, gele en rode led via weerstanden van 220 Ω aan op D4, D5 en D6, en de passieve buzzer op D8.
- Upload de code, open de Serial Monitor op 9600 baud en wacht tot de eerste opwarmtijd van 3 minuten voorbij is.
- Houd de sensor een paar minuten voor een open raam en controleer of hij rond 400–480 ppm aangeeft. Adem daarna op ongeveer 30 cm afstand uit en zie hoe de waarde snel stijgt.
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}Elke 5 seconden stuurt de code het leescommando van 9 bytes naar de sensor en verzamelt daarna het antwoord van 9 bytes gedurende maximaal 300 ms. Komt de header (FF 86) of de checksum van het antwoord niet overeen, dan wordt de waarde weggegooid, zodat een rumoerige lijn geen vals alarm kan veroorzaken. De functie readCO2() geeft bij een fout een negatieve code terug: -1 betekent geen antwoord, -2 een verkeerde header en -3 een foute checksum. Omdat de timing met millis() gebeurt in plaats van met delay(), wordt loop() niet geblokkeerd; als je later een knop of display toevoegt, blijft de code responsief. De redenering achter deze aanpak vind je in het bericht millis versus delay. Als je liever een kant-en-klare bibliotheek gebruikt, verpakt de bibliotheek MH-Z19 (van Jonathan Dempsey) in de Library Manager hetzelfde protocol in functies als getCO2() en autoCalibration(); maar als je het ruwe protocol kent, vind je veel makkelijker de oorzaak wanneer de sensor zich onverwacht gedraagt.
Opwarmtijd: waarom vertrouw je de eerste 3 minuten niet?
Metingen zijn pas betrouwbaar als de infraroodlamp en de detector een stabiele temperatuur hebben bereikt. De fabrikant geeft een opwarmtijd van 3 minuten; in die tijd kan de sensor constante of betekenisloze waarden geven (bijvoorbeeld steeds 400 of 500 ppm). Daarom doet onze code de eerste 180 seconden geen metingen en toont alleen de resterende tijd. Daarnaast is de responstijd T90 van de sensor minder dan 2 minuten: als de omgeving plotseling verandert, kan het een of twee minuten duren voordat 90% van de echte waarde is bereikt, dus het is normaal dat de waarde langzaam daalt nadat je een raam opent. Zie je kleine schommelingen tussen metingen, dan stabiliseert het gemiddelde van de laatste 5–10 metingen de getoonde waarde; methodes vind je in het bericht sensordata filteren. Als je het apparaat lang gebruikt, geeft continu voeden consistentere resultaten dan het telkens uit- en aanzetten.
Automatische kalibratie (ABC) en handmatige nulkalibratie
Het nulpunt van NDIR-sensoren verschuift in maanden en jaren langzaam. De MH-Z19B corrigeert dit met ABC (Automatic Baseline Correction): in elke periode van 24 uur beschouwt de sensor de laagste waarde die hij zag als frisse lucht, dus ongeveer 400 ppm, en past zijn basislijn daarop aan. ABC staat vanaf de fabriek aan. In klaslokalen, kantoren en slaapkamers die minstens één keer per dag goed worden geventileerd, is dit erg nuttig; je krijgt jarenlang redelijke nauwkeurigheid zonder je met kalibratie bezig te houden. In kassen, afgesloten paddenstoelenkamers of op elke plek waar CO2 nooit tot 400 ppm daalt, is ABC echter schadelijk: de sensor houdt bijvoorbeeld 700 ppm voor frisse lucht en verschuift al je metingen ongeveer 300 ppm naar beneden. Schakel ABC op zulke plekken uit met het commando ABC uit en kalibreer regelmatig handmatig.
Laat de sensor voor een handmatige nulkalibratie buiten draaien, uit de wind en uit de buurt van de adem van mensen, en laat hem minstens 20 minuten staan. Stuur daarna het nulkalibratiecommando 0x87 of verbind de HD-pin minstens 7 seconden met GND. De sensor legt de huidige omgeving vast als 400 ppm. Doe dit nooit in een gesloten ruimte; een sensor die 900 ppm binnen voor 400 aanziet, toont altijd betere lucht dan je werkelijk hebt, en dan is het hele nut van het waarschuwingsapparaat weg. Het commando 0x99 dient ook om te kiezen tussen het bereik van 2000 ppm en dat van 5000 ppm; in drukke klaslokalen is het bereik van 5000 ppm veiliger, zodat de waarde niet tegen het plafond van 2000 ppm aanloopt.
De MH-Z19B gebruiken met de ESP32
De ESP32 heeft drie hardware-UART's en hun pinnen kun je aan elke gewenste GPIO toewijzen, dus SoftwareSerial is niet nodig. Verbind de Vin van de sensor met de pin VIN (5V) van het ESP32-devboard, die de 5 V van USB levert. De TX van de sensor gaat naar GPIO 16 en de RX naar GPIO 17; omdat beide lijnen op 3,3 V-niveau staan, kun je ze direct verbinden. De onderstaande code compileert op dezelfde manier op ESP32 Arduino core 2.x en 3.x; als de waarde 1200 ppm overschrijdt, laat hij de led op GPIO 26 branden en klinkt er een korte piep uit de actieve buzzer op GPIO 27. Op boards met WROVER-modules zijn GPIO 16 en 17 gereserveerd voor PSRAM; kies dan bijvoorbeeld GPIO 32 en 33. Zodra je het board met Wi-Fi verbindt, kun je dezelfde waarde tonen op een webpagina, op je telefoon of in 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}CO2 meten met de Raspberry Pi Pico en MicroPython
Op de Pico zit UART0 standaard op de pinnen GP0 (TX) en GP1 (RX). Verbind de Vin van de sensor met de pin VBUS van de Pico (pin 40, de 5 V van USB); de 3V3-uitgang is niet genoeg voor de sensor. Voed je de Pico met een batterij in plaats van via USB, dan staat er geen spanning op VBUS en moet je de sensor een aparte 5 V-bron geven. De TX van de sensor gaat naar GP1 en de RX naar GP0. De code stuurt hetzelfde commando van 9 bytes als de Arduino-versie, controleert de checksum met de functie sum() van Python en laat boven 1200 ppm de led op GP15 branden (met een weerstand van 220 Ω). Ben je nieuw met MicroPython, kijk dan eerst naar het bericht MicroPython-basis.
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)Waar plaats je de sensor in een klaslokaal of kamer?
De juiste plek is belangrijker dan de juiste code. Plaats de sensor op de hoogte waar mensen zittend ademen, ongeveer 1–1,5 meter boven de vloer, aan een wand die het gemiddelde van de ruimte vertegenwoordigt. Zet je hem in een raam of deuropening, dan geeft hij door de binnenkomende frisse lucht een lagere waarde dan de werkelijkheid; zet je hem op een bureau vlak bij iemands gezicht, dan zie je pieken bij elke ademhaling. Vermijd ook plekken als de bovenkant van een radiator, een raam in direct zonlicht en een badkamer waar vocht condenseert; de sensor is ontworpen voor 0–50 °C en niet-condenserende luchtvochtigheid. De lucht komt binnen via de gefilterde vlakken van de sensor; zet je hem in een behuizing, maak dan veel gaten en blokkeer de luchtstroom rond de sensor niet. Als je Uno of ESP32 reset door de kortstondige stroomopname van de lamp, stabiliseert een elco van 100 µF en een keramische condensator van 100 nF tussen Vin en GND van de sensor de voeding.
Projectideeën met de MH-Z19
- Ventilatiestoplicht voor het klaslokaal: Zet de schakeling met groene, gele en rode led uit dit bericht in een doosje en hang hem op een plek die je vanaf het bureau van de docent kunt zien.
- Bureaudisplay met scherm: Toon de CO2-waarde in grote cijfers op een SSD1306 OLED-display of een I2C-LCD.
- Melding op je telefoon: Stuur met de ESP32 een bericht via een Telegram-bot wanneer de waarde boven 1200 ppm komt.
- Domoticapaneel: Stuur de metingen met MQTT en Home Assistant naar Home Assistant, teken een dagelijkse grafiek en stel automatiseringen in.
- Automatische ventilator: Laat een afzuigventilator draaien wanneer CO2 stijgt; zie voor de details over het aansturen van ventilatoren het bericht Arduino-ventilatorregeling.
- Kasmonitoring: Schakel ABC uit en voeg CO2-meting toe aan het slimme-kasproject, en zie in de grafiek hoe planten overdag CO2 verbruiken.
- Kleurenluchtindicator: Laat een enkele WS2812B-led vloeiend verlopen van groen bij 400 ppm naar rood bij 2000 ppm.
- Datalogger: Schrijf de metingen van een dag naar een SD-kaart en zie in welke les de lucht het slechtst wordt; je krijgt een sterke dataset voor wetenschapsbeurzen en schoolonderzoeken.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Steeds -1 (geen antwoord) | TX en RX recht doorverbonden, of de sensor wordt gevoed met 3,3 V | Kruis TX met RX en geef Vin 5 V |
| Vaak -3 (checksumfout) | Losse breadboarddraad, lange kabel of een pin die niet geschikt is voor SoftwareSerial | Kort de draden in; gebruik op de Mega en Leonardo pinnen die voor RX ondersteund worden, op de Uno is D10 veilig |
| Constant 400 of 500 ppm in de eerste minuten | De opwarmtijd loopt nog | Wacht minstens 3 minuten en meet dan |
| Waarden blijven met de dagen te laag | ABC koos de verkeerde basislijn in een ruimte die nooit wordt geventileerd | Zet ABC uit en kalibreer handmatig buiten |
| Waarde blijft hangen op 2000 ppm | Het meetbereik staat op 2000 ppm | Stel het bereik in op 5000 ppm met het commando 0x99 |
| Board reset of waarden springen | De kortstondige stroom van ongeveer 150 mA van de lamp laat een zwakke voeding instorten | Voeg een condensator van 100 µF toe tussen Vin en GND en gebruik een stevige 5 V-bron |
| Waarden te laag na kalibratie | De nulkalibratie is in een gesloten ruimte uitgevoerd | Herhaal de kalibratie buiten na 20 minuten wachten |
De MH-Z19B is een van de sensoren met de beste balans tussen prijs en nauwkeurigheid onder de sensoren die echt CO2 meten; als hij goed gevoed is, 3 minuten is opgewarmd en de ABC-instelling bij de omgeving past, werkt hij jarenlang betrouwbaar. Voor algemene luchtkwaliteit en geuren kun je ook het bericht over de MQ-135 bekijken, en voor vluchtige organische stoffen het bericht over de CCS811. In de BlueGrays-app vind je temperatuur- en vochtmeting, gasalarm en LCD- en OLED-ESP32-projecten met stapsgewijze schakelschema's en code, en die kun je combineren met deze sensor om je eigen luchtkwaliteitsstation te bouwen.
Veelgestelde vragen
Hoeveel ppm CO2 hoort er in een kamer te zitten?
Buiten is CO2 ongeveer 420 ppm en een goed geventileerde kamer blijft onder 800 ppm. Rond 1000–1200 ppm is een teken dat de lucht bedompt is en het tijd is om een raam open te zetten. Boven 2000 ppm komen hoofdpijn, slaperigheid en concentratieverlies vaak voor.
Wat is het verschil tussen de MH-Z19B en de MH-Z19C?
Beide zijn NDIR-sensoren met dezelfde pinout en dezelfde UART-commando's, dus de code in dit bericht werkt op beide. De C-versie is de nieuwere, zuinigere opvolger van de B. Omdat de C-versie gevoeliger is voor de voedingsspanning, is het belangrijk hem een stabiele, echte 5 V te geven.
Werkt de MH-Z19-sensor op 3,3 V?
Nee. De voeding van de sensor moet tussen 4,5 en 5,5 V liggen; bij 3,3 V werkt de infraroodlamp niet goed en reageert de sensor niet. De UART-lijnen staan echter op 3,3 V-niveau, dus je kunt de sensor voeden met 5 V en TX en RX direct met een ESP32 of Pico verbinden.
Moet ik de automatische kalibratie (ABC) van de MH-Z19 uitschakelen?
In klaslokalen, kantoren en woningen die minstens één keer per dag goed worden geventileerd, moet ABC aan blijven; de sensor corrigeert zichzelf elke 24 uur aan de hand van frisse lucht. In kassen, gesloten opslagruimtes of overal waar CO2 nooit tot 400 ppm daalt, verschuift ABC de waarden ten onrechte naar beneden. Zet ABC daar uit en kalibreer af en toe handmatig buiten.
Wat is het verschil tussen de MH-Z19 en de MQ-135?
De MQ-135 is een verwarmde halfgeleider-gassensor; hij reageert tegelijk op alcohol, ammoniak, rook en veel andere gassen en kan alleen een grove schatting van CO2 geven. De MH-Z19 meet CO2 rechtstreeks via infraroodabsorptie, wordt nauwelijks beïnvloed door andere gassen en geeft een gekalibreerde waarde in ppm. Voor een ventilatiewaarschuwing is de MH-Z19 de juiste keuze.
Waarom toont de MH-Z19 verkeerde waarden als hij net is aangezet?
De infraroodlamp en de detector van de sensor hebben ongeveer 3 minuten opwarmtijd nodig om een stabiele temperatuur te bereiken. In die tijd kan hij constante of betekenisloze waarden geven. Negeer in je code de metingen van de eerste 3 minuten en wacht nog 1–2 minuten tot de waarde zich stabiliseert nadat de omgeving plotseling verandert.
Projecten om hierna te bouwen
Alle projecten bekijken
Temperatuur en luchtvochtigheid met DHT11
Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

Een buzzer gebruiken
Heb je je ooit afgevraagd hoe een deurbel of alarm geluid maakt? De Arduino laat een kleine buzzer met korte tussenpozen piepen: piep, pauze, piep, pauze.

ESP32 MQ-2 gas-/rookmelderalarm
In dit project detecteer je brandbaar gas (LPG, methaan, propaan) en rook met een MQ-2-gassensormodule en speelt een passieve buzzer bij detectie een sirene-achtig alarm af. De digitale drempeluitgang (DO) van de sensor is verbonden met GPIO 4 van de ESP32. Overschrijdt gas of rook de drempel, dan wordt DO LOW en gaat het alarm af. De gevoeligheid stel je in met de potentiometer op de module. De passieve buzzer wordt met tone() aangestuurd voor een sireneffect met twee frequenties.

Een gassensor gebruiken
Een kleine bewaker die een gaslek in de keuken eerder opmerkt dan jij. De gassensor snuffelt voortdurend aan de lucht; zolang alles goed is blijft de groene led branden, en als het gas in de lucht…

Alarm met vlam- en gassensor
Een kleine bewaker die je meteen waarschuwt als er gas lekt of ergens een vlam verschijnt.

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

ESP32 HTTPClient + weer-API (met SSD1306 OLED-display)
In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Anders dan bij de I2C-LCD-versie gebruiken we hier een SSD1306 OLED-display (128×64), met grote tekst en vectoricoontjes voor een rijkere weergave. Zeven weericonen (zonnig, regenachtig, sneeuw en meer) worden direct getekend, zonder bitmapbestanden.

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

