MH-Z19 CO2-Sensor: ppm messen mit Arduino, ESP32 und Pico
MH-Z19B CO2-Sensor nutzen: UART-Anschluss, ppm auslesen, ABC-Kalibrierung, Aufwärmzeit und Code für Uno, ESP32 und Pico mit LED-Lüftungsampel.
Der MH-Z19 CO2-Sensor ist ein NDIR-Sensor, der mit Infrarotlicht arbeitet und die Kohlendioxid-Konzentration in der Umgebung direkt in ppm (parts per million) misst. Er wird mit nur vier Drähten (5 V, GND, TX, RX) an Arduino, ESP32 oder Raspberry Pi Pico angeschlossen und liefert über UART in wenigen Millisekunden einen echten CO2-Wert. Anders als billige Gassensoren schätzt er nicht, sondern misst, wie stark die CO2-Moleküle in der Luft das Licht absorbieren. Deshalb ist er einer der zuverlässigsten und günstigsten Wege, ein Lüftungswarngerät für Klassenzimmer, Schlafzimmer und Büros zu bauen, deren Fenster im Winter geschlossen bleiben.
In diesem Beitrag lernst du, wie der MH-Z19B funktioniert, welche Pins er hat und wie du ihn richtig anschließt, wie du per UART-Befehl ppm ausliest, was es mit den 3 Minuten Aufwärmzeit auf sich hat und wie die oft verwirrende automatische Kalibrierung (ABC) funktioniert. Danach bauen wir mit Code für Arduino Uno (SoftwareSerial), ESP32 (Hardware-UART) und Raspberry Pi Pico (MicroPython) eine Lüftungswarnung mit grüner, gelber und roter LED. Wenn du siehst, wie der CO2-Wert in einem geschlossenen Klassenzimmer in einer Schulstunde über 2000 ppm steigen kann, verstehst du, warum dieser Sensor so beliebt ist.
Was ist der MH-Z19 CO2-Sensor und wie funktioniert er?
NDIR steht für Non-Dispersive Infrared, also nichtdispersives Infrarot. Eine kleine Lampe im Sensor sendet Infrarotlicht aus; das Licht durchquert die Messkammer, in die die Luft durch einen Filter strömt, und erreicht den Detektor auf der anderen Seite. CO2-Moleküle absorbieren Licht mit einer Wellenlänge von etwa 4,26 Mikrometern sehr stark. Ein schmalbandiger optischer Filter vor dem Detektor lässt nur diese Wellenlänge durch: Je mehr CO2 in der Luft ist, desto weniger Licht erreicht den Detektor. Der Mikrocontroller im Sensor korrigiert diesen Unterschied temperaturabhängig, rechnet ihn in ppm um und sendet dir eine fertige Zahl. Weil die Messung auf physikalischer Absorption beruht, ist sie viel selektiver als bei beheizten Halbleitersensoren wie der MQ-Serie: Parfüm, Alkohol oder Kochgerüche verändern den CO2-Wert nicht.
| Eigenschaft | Wert beim MH-Z19B |
|---|---|
| Messverfahren | NDIR (nichtdispersive Infrarot-Absorption) |
| Messbereich | 0–2000 oder 0–5000 ppm (per Befehl wählbar; es gibt auch eine 10000-ppm-Version) |
| Genauigkeit | Etwa ±(50 ppm + 3–5 % des Messwerts), je nach Version |
| Versorgungsspannung | 4,5–5,5 V DC |
| Strom | Im Mittel unter 60 mA, Spitze etwa 150 mA |
| Schnittstelle | UART 9600 Baud 8N1, 3,3-V-Pegel; zusätzlich PWM-Ausgang |
| Aufwärmzeit | 3 Minuten |
| Ansprechzeit (T90) | Unter 120 Sekunden |
| Betriebsbedingungen | 0–50 °C, 0–90 % relative Luftfeuchtigkeit (nicht kondensierend) |
| Lebensdauer | Mehr als 5 Jahre (Herstellerangabe) |
CO2-Werte: Was bedeuten die ppm?
An der frischen Außenluft liegt CO2 heute bei etwa 420 ppm. In einem geschlossenen Raum gibt jeder Mensch mit jedem Atemzug CO2 ab: Ein ruhender Erwachsener produziert etwa 15–20 Liter CO2 pro Stunde. Eine einfache Rechnung: In einem Klassenzimmer mit 150 m³ Volumen erzeugen 25 Schüler pro Stunde etwa 0,4 m³ CO2. Ohne jede Lüftung wären das 0,4 / 150 ≈ 0,0027, also ein Anstieg um rund 2700 ppm pro Stunde. Durch Türspalten und Undichtigkeiten steigt der Wert in der Praxis langsamer, aber 2000 ppm am Ende einer Unterrichtsstunde mit geschlossenen Fenstern sind keine Seltenheit. In diesen Bereichen ist CO2 nicht direkt giftig, aber es ist der beste Indikator für schlechte Lüftung und wird mit Müdigkeit, Kopfschmerzen und Konzentrationsschwäche in Verbindung gebracht. Viele Leitfäden für Schulen und Büros sehen etwa 1000 ppm als Lüftungsgrenze.
| CO2-Bereich | Bewertung | Warnung in unserem Code |
|---|---|---|
| 400–800 ppm | Frische, gut gelüftete Umgebung | Grüne LED |
| 800–1200 ppm | Akzeptabel, die Luft wird schlechter | Gelbe LED |
| 1200–2000 ppm | Schlecht, Zeit zum Fensteröffnen | Rote LED + Buzzer |
| Über 2000 ppm | Sehr schlecht; Müdigkeit und Kopfschmerzen häufen sich | Rote LED + Buzzer |
| 5000 ppm | Arbeitsplatzgrenzwert für 8 Stunden Exposition | Obergrenze des Messbereichs |
MH-Z19B-Pins und Schaltplan
Der MH-Z19B hat meist 7 Pins: Vin (Versorgung), GND, TX und RX (UART), PWM (Pulsbreitenausgang), HD (manuelle Nullpunktkalibrierung) und bei manchen Versionen Vo (analoger Spannungsausgang). Beim PWM-Ausgang beträgt die Periode etwa 1004 ms, und der Wert wird mit der Formel ppm = Bereich × (TH − 2 ms) / (TH + TL − 4 ms) berechnet; da man für jede Messung aber eine Sekunde warten muss, ist UART viel praktischer. Wir nutzen UART; PWM und HD bleiben unbeschaltet. Bei UART werden die Leitungen immer über Kreuz verbunden: TX des Sensors geht an RX des Boards, RX des Sensors an TX des Boards. Die Grundlagen der seriellen Kommunikation findest du im Beitrag UART-Kommunikation.
| MH-Z19B-Pin | 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 (über Spannungsteiler 1 kΩ + 2 kΩ) | GPIO 17 (UART2 TX) | GP0 (UART0 TX) |
| PWM | Offen | Offen | Offen |
| HD | Offen (bei Kalibrierung an GND) | Offen | Offen |
| Warn-LEDs / Buzzer | D4, D5, D6 / D8 | GPIO 26 / GPIO 27 | GP15 |
Der TX-Ausgang des Sensors hat 3,3-V-Pegel, den der Uno problemlos als HIGH liest. In Gegenrichtung gibt der TX-Pin des Uno aber 5 V aus. In den Herstellerunterlagen ist der Schnittstellenpegel mit 3,3 V angegeben; manche Module vertragen 5 V, doch am sichersten setzt du zwischen Pin D11 des Uno und den RX des Sensors einen einfachen Spannungsteiler: von D11 über 1 kΩ zum RX des Sensors, vom RX des Sensors über 2 kΩ nach GND. Die Ausgangsspannung beträgt 5 × 2 / (1 + 2) = 3,33 V. Die Werte kannst du mit dem Spannungsteiler-Rechner an die Widerstände anpassen, die du hast, oder du nutzt einen bidirektionalen Logikpegel-Wandler. ESP32 und Pico arbeiten ohnehin mit 3,3 V, dort brauchst du keinen Teiler.
UART-Protokoll: So sprichst du mit dem Sensor
Der MH-Z19B arbeitet mit 9600 Baud, 8 Datenbits, keine Parität, 1 Stoppbit (8N1). Jeder Befehl und jede Antwort ist genau 9 Bytes lang. Befehle beginnen mit 0xFF, das zweite Byte ist die Sensornummer (0x01), das dritte der Befehlscode; das letzte Byte ist die Prüfsumme (Checksum). Sie wird aus der Summe der Bytes 1 bis 7 so berechnet: Checksum = 0xFF − (Byte1 + … + Byte7) + 1, das Ergebnis wird auf ein Byte gekürzt. In der Antwort auf den Lesebefehl ist Byte 0 gleich 0xFF und Byte 1 gleich 0x86; der CO2-Wert steckt in Byte 2 und 3: ppm = High-Byte × 256 + Low-Byte. Beginnt die Antwort zum Beispiel mit FF 86 02 58, ist der Wert 2 × 256 + 88 = 600 ppm. Byte 4 ist ein nicht dokumentierter, grober Temperaturwert (Wert − 40 °C) und dient nur als Anhaltspunkt; für eine echte Temperaturmessung nimm einen separaten Sensor.
| Aktion | Gesendete 9 Bytes (Hex) | Erklärung |
|---|---|---|
| CO2 lesen | FF 01 86 00 00 00 00 00 79 | Byte 2 und 3 der Antwort sind der ppm-Wert |
| ABC ein | FF 01 79 A0 00 00 00 00 E6 | Schaltet die automatische 24-Stunden-Basiskorrektur ein (Werkseinstellung) |
| ABC aus | FF 01 79 00 00 00 00 00 86 | Schaltet die automatische Kalibrierung für Gewächshäuser und geschlossene Räume aus |
| Nullpunktkalibrierung | FF 01 87 00 00 00 00 00 78 | Setzt die aktuelle Umgebung als 400 ppm; nur an der frischen Luft ausführen |
| Bereich 2000 ppm | FF 01 99 00 00 00 07 D0 8F | Stellt den Messbereich auf 0–2000 ppm |
| Bereich 5000 ppm | FF 01 99 00 00 00 13 88 CB | Stellt den Messbereich auf 0–5000 ppm |
Schritt für Schritt: CO2 messen mit dem Arduino Uno
- Verbinde den Vin-Pin des Sensors mit dem 5V-Pin des Uno und GND mit GND.
- Verbinde den TX-Pin des Sensors mit D10; dieser Pin ist der RX von SoftwareSerial.
- Verbinde den Pin D11 des Uno über einen Spannungsteiler aus 1 kΩ + 2 kΩ mit dem RX-Pin des Sensors.
- Schließe die grüne, gelbe und rote LED über 220-Ω-Widerstände an D4, D5 und D6 an, den passiven Buzzer an D8.
- Lade den Code hoch, öffne den Seriellen Monitor mit 9600 Baud und warte, bis die ersten 3 Minuten Aufwärmzeit vorbei sind.
- Halte den Sensor einige Minuten vor ein offenes Fenster und beobachte, dass er etwa 400–480 ppm liest; atme dann aus etwa 30 cm Entfernung darauf und sieh zu, wie der Wert schnell steigt.
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}Der Code sendet dem Sensor alle 5 Sekunden den 9-Byte-Lesebefehl und sammelt dann höchstens 300 ms lang die 9-Byte-Antwort. Stimmen Header (FF 86) oder Checksum der Antwort nicht, wird der Wert verworfen; so löst eine gestörte Leitung keinen Fehlalarm aus. Die Funktion readCO2() gibt im Fehlerfall einen negativen Code zurück: -1 bedeutet keine Antwort, -2 falscher Header, -3 falsche Checksum. Das Timing läuft mit millis() statt delay(), deshalb blockiert loop() nicht; wenn du später Taster oder ein Display ergänzt, reagiert der Code weiterhin. Die Logik dahinter findest du im Beitrag Unterschied zwischen millis und delay. Wenn du lieber eine fertige Bibliothek nutzt: Die Bibliothek MH-Z19 (Jonathan Dempsey) im Bibliotheksverwalter kapselt dasselbe Protokoll mit Funktionen wie getCO2() und autoCalibration(); das Rohprotokoll zu kennen, hilft dir aber enorm bei der Fehlersuche, wenn sich der Sensor unerwartet verhält.
Aufwärmzeit: Warum du den ersten 3 Minuten nicht trauen solltest
Solange Infrarotlampe und Detektor keine stabile Temperatur erreicht haben, ist die Messung nicht zuverlässig. Der Hersteller gibt eine Aufwärmzeit von 3 Minuten an; in dieser Zeit kann der Sensor konstante oder sinnlose Werte (zum Beispiel dauerhaft 400 oder 500 ppm) liefern. Unser Code liest deshalb in den ersten 180 Sekunden nicht aus und gibt nur die Restzeit aus. Außerdem liegt die Ansprechzeit T90 des Sensors unter 2 Minuten: Ändert sich die Umgebung plötzlich, kann es ein bis zwei Minuten dauern, bis 90 % des echten Werts erreicht sind; dass der Wert nach dem Öffnen des Fensters nur langsam sinkt, ist also normal. Siehst du kleine Schwankungen zwischen den Messungen, beruhigt der Mittelwert der letzten 5–10 Messungen die Anzeige; Methoden dazu findest du im Beitrag Sensordaten filtern. Wenn du das Gerät dauerhaft nutzt, liefert eine ständige Versorgung konsistentere Ergebnisse als das wiederholte Aus- und Einschalten.
Automatische Kalibrierung (ABC) und manuelle Nullpunktkalibrierung
Der Nullpunkt von NDIR-Sensoren driftet im Lauf von Monaten und Jahren langsam. Der MH-Z19B korrigiert das mit ABC (Automatic Baseline Correction): Der Sensor betrachtet den niedrigsten Wert jedes 24-Stunden-Zeitraums als Frischluft, also etwa 400 ppm, und passt seine Basis entsprechend an. ABC ist ab Werk eingeschaltet. In Klassenzimmern, Büros und Schlafzimmern, die mindestens einmal am Tag gründlich gelüftet werden, ist das sehr nützlich; du bekommst jahrelang eine ordentliche Genauigkeit, ohne dich um die Kalibrierung zu kümmern. In Gewächshäusern, geschlossenen Pilzzuchträumen oder Umgebungen, in denen CO2 nie auf 400 ppm fällt, ist ABC dagegen schädlich: Der Sensor hält zum Beispiel 700 ppm fälschlich für Frischluft und verschiebt alle Messungen um etwa 300 ppm nach unten. Schalte ABC dort mit dem Ausschaltbefehl ab und kalibriere in regelmäßigen Abständen manuell.
Für die manuelle Nullpunktkalibrierung betreibst du den Sensor im Freien, weit weg von Wind und dem Atem von Menschen, und lässt ihn mindestens 20 Minuten laufen. Danach sendest du entweder den Nullpunkt-Befehl 0x87 oder legst den HD-Pin mindestens 7 Sekunden lang an GND. Der Sensor speichert die aktuelle Umgebung dann als 400 ppm. Mach das niemals in einem geschlossenen Raum; ein Sensor, der 900 ppm drinnen für 400 hält, zeigt dir dauerhaft bessere Luft an, als sie ist, und der ganze Sinn deines Warngeräts geht verloren. Auch die Wahl zwischen den Bereichen 2000 ppm und 5000 ppm erfolgt mit dem Befehl 0x99; in vollen Klassenzimmern ist der 5000-ppm-Bereich sicherer, damit der Wert nicht bei 2000 ppm an die Obergrenze stößt.
MH-Z19B mit dem ESP32 verwenden
Der ESP32 hat drei Hardware-UARTs, deren Pins du beliebigen GPIOs zuweisen kannst; SoftwareSerial brauchst du deshalb nicht. Verbinde Vin des Sensors mit dem Pin VIN (5V) deines ESP32-Entwicklungsboards, der die 5 V vom USB liefert. TX des Sensors geht an GPIO 16, RX an GPIO 17; da beide Leitungen 3,3-V-Pegel haben, werden sie direkt verbunden. Der Code unten lässt sich mit dem ESP32-Arduino-Core 2.x und 3.x gleich kompilieren; übersteigt der Wert 1200 ppm, schaltet er die LED an GPIO 26 ein und lässt den aktiven Buzzer an GPIO 27 kurz piepen. Bei Boards mit WROVER-Modul sind GPIO 16 und 17 für das PSRAM reserviert; wähle dann zum Beispiel GPIO 32 und 33. Wenn du das Board mit dem WLAN verbindest, kannst du denselben Wert auf einer Webseite, auf dem Handy oder in Home Assistant anzeigen.
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-Messung mit Raspberry Pi Pico und MicroPython
Beim Pico liegt UART0 standardmäßig auf den Pins GP0 (TX) und GP1 (RX). Verbinde Vin des Sensors mit dem Pin VBUS des Pico (Pin 40, die 5 V vom USB); der 3V3-Ausgang reicht für den Sensor nicht aus. Betreibst du den Pico statt über USB mit einer Batterie, liegt an VBUS keine Spannung an, und du musst den Sensor aus einer separaten 5-V-Quelle versorgen. TX des Sensors geht an GP1, RX an GP0. Der Code sendet denselben 9-Byte-Befehl wie die Arduino-Version, prüft die Checksum mit der Python-Funktion sum() und schaltet über 1200 ppm die LED an GP15 (mit 220-Ω-Widerstand) ein. Wenn du neu bei MicroPython bist, wirf zuerst einen Blick auf den Beitrag MicroPython-Grundlagen.
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)Wohin mit dem Sensor im Klassenzimmer oder Raum?
Der richtige Ort ist wichtiger als der richtige Code. Platziere den Sensor auf Atemhöhe der sitzenden Personen, etwa 1–1,5 Meter über dem Boden, an einer Wand, die den Durchschnitt des Raums repräsentiert. Stellst du ihn an ein Fenster oder in den Türbereich, fällt der Wert wegen der hereinströmenden Frischluft zu niedrig aus; liegt er direkt vor jemandes Gesicht auf dem Tisch, siehst du bei jedem Atemzug Sprünge. Meide außerdem Orte wie die Oberseite von Heizkörpern, Fensterbänke mit direkter Sonne und Bäder, in denen Feuchtigkeit kondensiert; der Sensor ist für 0–50 °C und nicht kondensierende Luftfeuchtigkeit ausgelegt. Die Luft gelangt über die gefilterten Flächen des Sensors ins Innere; wenn du ihn in ein Gehäuse setzt, mache viele Löcher hinein und behindere die Luftzirkulation um den Sensor nicht. Wenn Uno oder ESP32 wegen des kurzzeitigen Stromhungers der Lampe neu starten, beruhigt ein Kondensator aus 100 µF Elko und 100 nF Keramik zwischen Vin und GND die Versorgung.
Projektideen mit dem MH-Z19
- Lüftungsampel fürs Klassenzimmer: Baue die Schaltung mit grüner, gelber und roter LED aus diesem Beitrag in ein Gehäuse und hänge sie so auf, dass sie vom Lehrerpult aus zu sehen ist.
- Tischanzeige mit Display: Zeige den CO2-Wert mit großen Ziffern auf einem SSD1306-OLED-Display oder einem I2C-LCD-Display an.
- Benachrichtigung aufs Handy: Sende mit dem ESP32 eine Nachricht über einen Telegram-Bot, sobald der Wert 1200 ppm überschreitet.
- Smart-Home-Dashboard: Übertrage die Messwerte per MQTT an Home Assistant, zeichne das Tagesdiagramm und richte Automatisierungen ein.
- Automatischer Lüfter: Schalte einen Abluftventilator ein, wenn CO2 steigt; Details zur Lüftersteuerung findest du im Beitrag Lüftersteuerung mit Arduino.
- Gewächshaus-Überwachung: Schalte ABC aus, ergänze das smarte Gewächshausprojekt um eine CO2-Messung und sieh im Diagramm, dass Pflanzen tagsüber CO2 verbrauchen.
- Farbige Luftanzeige: Lass die Farbe einer einzelnen WS2812B-LED sanft von Grün bei 400 ppm zu Rot bei 2000 ppm wechseln.
- Datenlogger: Schreibe die Messwerte eines Tages auf eine SD-Karte und untersuche, in welcher Unterrichtsstunde die Luft am schlechtesten wird; für Wissenschaftsmessen und Jugend-forscht-Projekte bekommst du so einen starken Datensatz.
Häufige Fehler und Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Ständig -1 (keine Antwort) | TX und RX gerade verbunden oder Sensor mit 3,3 V versorgt | TX mit RX über Kreuz verbinden, Vin mit 5 V versorgen |
| Häufig -3 (Checksum-Fehler) | Wackelige Breadboard-Drähte, lange Kabel oder ein für SoftwareSerial ungeeigneter Pin | Kabel kürzen; bei Mega und Leonardo die für RX unterstützten Pins nutzen, beim Uno ist D10 sicher |
| In den ersten Minuten konstant 400 oder 500 ppm | Aufwärmzeit läuft noch | Mindestens 3 Minuten warten, dann messen |
| Werte werden mit den Tagen immer niedriger | In einem nie gelüfteten Raum hat ABC die Basis falsch gesetzt | ABC ausschalten, manuell an der frischen Luft kalibrieren |
| Wert bleibt bei 2000 ppm hängen | Messbereich ist auf 2000 ppm eingestellt | Mit dem Befehl 0x99 den Bereich auf 5000 ppm stellen |
| Board startet neu oder Werte springen | Der kurzzeitige Strom der Lampe von etwa 150 mA lässt eine schwache Versorgung einbrechen | 100-µF-Kondensator zwischen Vin und GND einbauen, eine stabile 5-V-Quelle nutzen |
| Werte nach der Kalibrierung viel zu niedrig | Nullpunktkalibrierung wurde im geschlossenen Raum durchgeführt | Kalibrierung im Freien nach 20 Minuten Wartezeit wiederholen |
Der MH-Z19B gehört unter den Sensoren, die CO2 wirklich messen, zu den besten im Verhältnis von Preis und Genauigkeit; richtig versorgt, nach 3 Minuten Aufwärmzeit und mit passend zur Umgebung gewähltem ABC-Modus arbeitet er jahrelang zuverlässig. Für allgemeine Luftqualität und Gerüche kannst du dir die Beiträge zum MQ-135 ansehen, für flüchtige organische Verbindungen den zum CCS811. In der BlueGrays-App findest du Schritt für Schritt Schaltpläne und Code für Temperatur- und Feuchtemessung, Gasalarm sowie ESP32-Projekte mit LCD- und OLED-Display, die du mit diesem Sensor kombinieren kannst, um deine eigene Luftqualitätsstation zu bauen.
Häufige Fragen
Wie viel ppm CO2 sollte ein Raum haben?
An der Außenluft liegt CO2 bei etwa 420 ppm, und ein gut gelüfteter Raum bleibt unter 800 ppm. Um 1000–1200 ppm ist die Luft verbraucht, und es ist Zeit, das Fenster zu öffnen. Über 2000 ppm häufen sich Kopfschmerzen, Müdigkeit und Konzentrationsprobleme.
Was ist der Unterschied zwischen MH-Z19B und MH-Z19C?
Beide sind NDIR-Sensoren, haben dieselbe Pinbelegung und dieselben UART-Befehle; der Code in diesem Beitrag läuft auf beiden. Die C-Version ist der neuere und günstigere Nachfolger der B-Version. Da die C-Version empfindlicher auf die Versorgungsspannung reagiert, ist es wichtig, ihr stabile, echte 5 V zu geben.
Funktioniert der MH-Z19 mit 3,3 V?
Nein. Die Versorgung des Sensors muss im Bereich 4,5–5,5 V liegen; bei 3,3 V arbeitet die Infrarotlampe nicht richtig und der Sensor antwortet nicht. Die UART-Leitungen haben allerdings 3,3-V-Pegel, sodass du den Sensor mit 5 V versorgen und TX und RX direkt an ESP32 oder Pico anschließen kannst.
Sollte ich die automatische Kalibrierung (ABC) beim MH-Z19 ausschalten?
In Klassenzimmern, Büros und Wohnungen, die mindestens einmal am Tag gründlich gelüftet werden, sollte ABC eingeschaltet bleiben; der Sensor korrigiert sich alle 24 Stunden anhand der Frischluft. In Gewächshäusern, geschlossenen Lagern oder Umgebungen, in denen CO2 nie auf 400 ppm fällt, verschiebt ABC die Werte dagegen fälschlich nach unten. Dort solltest du ABC ausschalten und gelegentlich manuell an der frischen Luft kalibrieren.
Was ist der Unterschied zwischen MH-Z19 und MQ-135?
Der MQ-135 ist ein beheizter Halbleiter-Gassensor; er reagiert gleichzeitig auf Alkohol, Ammoniak, Rauch und viele andere Gase und kann CO2 nur grob schätzen. Der MH-Z19 misst CO2 dagegen direkt per Infrarotabsorption, wird von anderen Gasen kaum beeinflusst und liefert einen in ppm kalibrierten Wert. Für eine Lüftungswarnung ist der MH-Z19 die richtige Wahl.
Warum zeigt der MH-Z19 nach dem Einschalten falsche Werte an?
Die Infrarotlampe und der Detektor des Sensors brauchen etwa 3 Minuten Aufwärmzeit, bis sie eine stabile Temperatur erreichen. In dieser Zeit können konstante oder sinnlose Werte erscheinen. Ignoriere in deinem Code die Messungen der ersten 3 Minuten und warte nach einer plötzlichen Änderung der Umgebung 1–2 Minuten, bis sich der Wert eingependelt hat.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Temperatur und Luftfeuchtigkeit mit DHT11
Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

Verwendung des Summers
Hast du dich mal gefragt, wie eine Türklingel oder ein Alarm seinen Ton erzeugt? Der Arduino lässt einen kleinen Summer in kurzen Abständen piepen: piep, Pause, piep, Pause.

ESP32 MQ-2 Gas-/Rauchmelder-Alarm
In diesem Projekt wird die Erkennung brennbarer Gase (LPG, Methan, Propan) und Rauch mit einem MQ-2-Gassensormodul durchgeführt; bei Erkennung ertönt über einen passiven Summer ein sirenenähnlicher Alarmton. Der digitale Schwellenausgang (DO) des Sensors wird an GPIO 4 des ESP32 angeschlossen; überschreiten Gas oder Rauch den Schwellenwert, geht DO auf LOW und der Alarm wird ausgelöst. Die Empfindlichkeit wird über das Potentiometer eingestellt. Der passive Summer wird mit tone() angesteuert.

Verwendung von Gassensoren
Ein kleiner Wächter, der ein Gasleck in der Küche bemerkt, bevor du es tust. Der Gassensor schnuppert ständig an der Luft; solange alles in Ordnung ist, leuchtet die grüne LED, übersteigt das Gas in…

Flammen- und Gassensor-Alarm
Ein kleiner Wächter, der dich sofort warnt, wenn Gas austritt oder irgendwo eine Flamme auftaucht.

ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
Bei diesem Projekt werden die Umgebungstemperatur und die Luftfeuchtigkeit mit einem DHT22-Sensor gemessen und in Echtzeit auf einem 16x2 I2C-LCD angezeigt. Mithilfe der Adafruit-DHT-Bibliothek werden die Daten über das One-Wire-Protokoll vom Sensor ausgelesen. Dieses Projekt bildet die Grundlage für IoT-Wetterstationen, Smart-Home-Automatisierung oder Umgebungsüberwachungssysteme in Gewächshäusern. Die Kommunikation mit dem DHT22 erfolgt über den GPIO-4-Pin des ESP32.

ESP32 HTTPClient + Wetter-API (mit SSD1306-OLED-Display)
Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Anders als die I2C-LCD-Version nutzt dieses Projekt ein SSD1306-OLED (128×64) mit großer Schrift und Vektor-Icons für eine reichere Darstellung. Sieben Wetter-Icons (sonnig, Regen, Schnee und mehr) werden ohne Bitmap-Dateien direkt gezeichnet.

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

