Bauteile · 12 Min. Lesezeit

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.

EigenschaftWert beim MH-Z19B
MessverfahrenNDIR (nichtdispersive Infrarot-Absorption)
Messbereich0–2000 oder 0–5000 ppm (per Befehl wählbar; es gibt auch eine 10000-ppm-Version)
GenauigkeitEtwa ±(50 ppm + 3–5 % des Messwerts), je nach Version
Versorgungsspannung4,5–5,5 V DC
StromIm Mittel unter 60 mA, Spitze etwa 150 mA
SchnittstelleUART 9600 Baud 8N1, 3,3-V-Pegel; zusätzlich PWM-Ausgang
Aufwärmzeit3 Minuten
Ansprechzeit (T90)Unter 120 Sekunden
Betriebsbedingungen0–50 °C, 0–90 % relative Luftfeuchtigkeit (nicht kondensierend)
LebensdauerMehr 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-BereichBewertungWarnung in unserem Code
400–800 ppmFrische, gut gelüftete UmgebungGrüne LED
800–1200 ppmAkzeptabel, die Luft wird schlechterGelbe LED
1200–2000 ppmSchlecht, Zeit zum FensteröffnenRote LED + Buzzer
Über 2000 ppmSehr schlecht; Müdigkeit und Kopfschmerzen häufen sichRote LED + Buzzer
5000 ppmArbeitsplatzgrenzwert für 8 Stunden ExpositionObergrenze 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-PinArduino UnoESP32Raspberry Pi Pico
Vin (5 V)5VVIN (5V)VBUS (Pin 40)
GNDGNDGNDGND
TXD10 (SoftwareSerial RX)GPIO 16 (UART2 RX)GP1 (UART0 RX)
RXD11 (über Spannungsteiler 1 kΩ + 2 kΩ)GPIO 17 (UART2 TX)GP0 (UART0 TX)
PWMOffenOffenOffen
HDOffen (bei Kalibrierung an GND)OffenOffen
Warn-LEDs / BuzzerD4, D5, D6 / D8GPIO 26 / GPIO 27GP15
Versuche nicht, den Sensor mit 3,3 V zu versorgen: Die Infrarotlampe und die interne Schaltung brauchen 4,5–5,5 V; bei 3,3 V antwortet der Sensor entweder gar nicht oder liefert unsinnige Werte. Der zweite häufige Fehler ist, TX und RX gerade zu verbinden (TX mit TX); dann meldet der Code ständig „keine Antwort“. Drücke außerdem nicht auf Gehäuse und Filter des Sensors und erhitze das Gehäuse nicht beim Löten an den Pins; wird die optische Kammer beschädigt, ist die Messung dauerhaft gestört.

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.

AktionGesendete 9 Bytes (Hex)Erklärung
CO2 lesenFF 01 86 00 00 00 00 00 79Byte 2 und 3 der Antwort sind der ppm-Wert
ABC einFF 01 79 A0 00 00 00 00 E6Schaltet die automatische 24-Stunden-Basiskorrektur ein (Werkseinstellung)
ABC ausFF 01 79 00 00 00 00 00 86Schaltet die automatische Kalibrierung für Gewächshäuser und geschlossene Räume aus
NullpunktkalibrierungFF 01 87 00 00 00 00 00 78Setzt die aktuelle Umgebung als 400 ppm; nur an der frischen Luft ausführen
Bereich 2000 ppmFF 01 99 00 00 00 07 D0 8FStellt den Messbereich auf 0–2000 ppm
Bereich 5000 ppmFF 01 99 00 00 00 13 88 CBStellt den Messbereich auf 0–5000 ppm

Schritt für Schritt: CO2 messen mit dem Arduino Uno

  1. Verbinde den Vin-Pin des Sensors mit dem 5V-Pin des Uno und GND mit GND.
  2. Verbinde den TX-Pin des Sensors mit D10; dieser Pin ist der RX von SoftwareSerial.
  3. Verbinde den Pin D11 des Uno über einen Spannungsteiler aus 1 kΩ + 2 kΩ mit dem RX-Pin des Sensors.
  4. Schließe die grüne, gelbe und rote LED über 220-Ω-Widerstände an D4, D5 und D6 an, den passiven Buzzer an D8.
  5. Lade den Code hoch, öffne den Seriellen Monitor mit 9600 Baud und warte, bis die ersten 3 Minuten Aufwärmzeit vorbei sind.
  6. 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.
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}

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.

Den ABC-Einschaltbefehl einmal in setup() zu senden, bringt sogar einen Sensor in einen bekannten Zustand, dessen Einstellung in einem früheren Projekt geändert wurde. Willst du den Code in einer geschlossenen Umgebung wie einem Gewächshaus nutzen, ersetze einfach das Array CMD_ABC_ON durch die Bytes FF 01 79 00 00 00 00 00 86.

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.

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}

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.

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)

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

SymptomMögliche UrsacheLösung
Ständig -1 (keine Antwort)TX und RX gerade verbunden oder Sensor mit 3,3 V versorgtTX 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 PinKabel 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 ppmAufwärmzeit läuft nochMindestens 3 Minuten warten, dann messen
Werte werden mit den Tagen immer niedrigerIn einem nie gelüfteten Raum hat ABC die Basis falsch gesetztABC ausschalten, manuell an der frischen Luft kalibrieren
Wert bleibt bei 2000 ppm hängenMessbereich ist auf 2000 ppm eingestelltMit dem Befehl 0x99 den Bereich auf 5000 ppm stellen
Board startet neu oder Werte springenDer kurzzeitige Strom der Lampe von etwa 150 mA lässt eine schwache Versorgung einbrechen100-µF-Kondensator zwischen Vin und GND einbauen, eine stabile 5-V-Quelle nutzen
Werte nach der Kalibrierung viel zu niedrigNullpunktkalibrierung wurde im geschlossenen Raum durchgeführtKalibrierung im Freien nach 20 Minuten Wartezeit wiederholen
Ob der Sensor richtig arbeitet, erkennst du am einfachsten mit einem Zwei-Punkte-Test: Vor einem offenen Fenster sollte er nach einigen Minuten 400–480 ppm lesen, und wenn du aus der Nähe ohne Abdecken darauf atmest, sollte der Wert innerhalb von ein bis zwei Minuten auf mehrere tausend ppm steigen. Fehlt eine der beiden Reaktionen, prüfe zuerst Kabel, die TX/RX-Richtung und die 5-V-Versorgung.

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.

Alle Projekte ansehen
Temperatur und Luftfeuchtigkeit mit DHT11
AR-55Mittel

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…

4.7(47)
83
Verwendung des Summers
AR-13Anfänger

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.

4.7(92)
170
ESP32 MQ-2 Gas-/Rauchmelder-Alarm
ES-20Mittel

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.

4.7(29)
44
Verwendung von Gassensoren
AR-51Anfänger
Premium

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…

4.6(37)
50
Flammen- und Gassensor-Alarm
AR-52Fortgeschritten
Premium

Flammen- und Gassensor-Alarm

Ein kleiner Wächter, der dich sofort warnt, wenn Gas austritt oder irgendwo eine Flamme auftaucht.

4.8(52)
67
ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
ES-15Mittel

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.

4.8(38)
57
ESP32 HTTPClient + Wetter-API (mit SSD1306-OLED-Display)
ES-32Fortgeschritten
Premium

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.

4.3(10)
22
ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Fortgeschritten
Premium

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.

4.7(7)
12