Composants · 15 min de lecture

Capteur CO2 MH-Z19 : mesure en ppm avec Arduino, ESP32, Pico

Comment utiliser le capteur de CO2 MH-Z19B ? Branchement UART, lecture en ppm, calibration ABC, préchauffage et code Uno, ESP32, Pico avec alerte d'aération.

Le capteur de CO2 MH-Z19 est un capteur NDIR à lumière infrarouge qui mesure directement la quantité de dioxyde de carbone de l'air en ppm (parties par million). Il se branche à un Arduino, un ESP32 ou un Raspberry Pi Pico avec seulement quatre fils (5 V, GND, TX, RX) et fournit en UART une vraie valeur de CO2 en quelques millisecondes. Contrairement aux capteurs de gaz bon marché, il ne devine pas : il mesure la quantité de lumière absorbée par les molécules de CO2 présentes dans l'air. C'est donc l'un des moyens les plus fiables et les plus économiques de fabriquer un avertisseur d'aération pour les salles de classe, les chambres et les bureaux dont les fenêtres restent fermées en hiver.

Dans cet article, tu vas découvrir le fonctionnement du MH-Z19B, ses broches et son branchement correct, la lecture des ppm avec les commandes UART, le préchauffage de 3 minutes et la calibration automatique (ABC), qui prête souvent à confusion. Ensuite, nous monterons un avertisseur d'aération à LED verte, jaune et rouge avec des codes fonctionnels pour Arduino Uno (SoftwareSerial), ESP32 (UART matériel) et Raspberry Pi Pico (MicroPython). Quand tu verras le CO2 dépasser 2000 ppm en une heure de cours dans une salle fermée, tu comprendras pourquoi ce capteur est si populaire.

Qu'est-ce que le capteur de CO2 MH-Z19 et comment fonctionne-t-il ?

NDIR signifie en anglais Non-Dispersive Infrared, c'est-à-dire infrarouge non dispersif. Une petite lampe à l'intérieur du capteur émet de la lumière infrarouge ; celle-ci traverse la chambre de mesure remplie d'air entré par le filtre et atteint le détecteur en face. Les molécules de CO2 absorbent fortement la lumière d'une longueur d'onde d'environ 4,26 micromètres. Le filtre optique à bande étroite placé devant le détecteur ne laisse passer que cette longueur d'onde : plus il y a de CO2 dans l'air, moins de lumière arrive au détecteur. Le microcontrôleur du capteur corrige cet écart en fonction de la température, le convertit en ppm et t'envoie un nombre prêt à l'emploi. Comme la mesure repose sur une absorption physique, elle est bien plus sélective que celle des capteurs à semi-conducteur chauffés de la série MQ : parfum, alcool ou odeur de cuisine ne changent pas la valeur de CO2.

CaractéristiqueValeur du MH-Z19B
Méthode de mesureNDIR (absorption infrarouge non dispersive)
Plage de mesure0–2000 ou 0–5000 ppm (au choix par commande ; une version 10000 ppm existe aussi)
PrécisionEnviron ±(50 ppm + 3–5 % de la lecture), selon la version
Tension d'alimentation4,5–5,5 V DC
CourantMoyenne inférieure à 60 mA, pointe d'environ 150 mA
InterfaceUART 9600 bauds 8N1, niveau 3,3 V ; sortie PWM également
Préchauffage3 minutes
Temps de réponse (T90)Moins de 120 secondes
Conditions de fonctionnement0–50 °C, 0–90 % d'humidité relative (sans condensation)
Durée de viePlus de 5 ans (valeur du fabricant)

Niveaux de CO2 : que signifie chaque valeur en ppm ?

Dans l'air extérieur propre, le CO2 se situe aujourd'hui autour de 420 ppm. Dans une pièce fermée, chaque personne y ajoute du CO2 en respirant : un adulte au repos en rejette environ 15 à 20 litres par heure. Faisons un calcul simple : dans une salle de 150 m³, 25 élèves produisent environ 0,4 m³ de CO2 par heure. Sans aucune aération, cela représenterait 0,4 / 150 ≈ 0,0027, soit environ 2700 ppm de hausse par heure. Grâce aux interstices des portes et aux fuites, la hausse réelle est plus lente, mais voir 2000 ppm à la fin d'un cours fenêtres fermées n'a rien de rare. À ces niveaux, le CO2 n'est pas directement toxique ; c'est surtout le meilleur indicateur d'une mauvaise aération, associé à la fatigue, aux maux de tête et au manque de concentration. De nombreux guides pour les écoles et les bureaux retiennent environ 1000 ppm comme limite d'aération.

Plage de CO2ÉvaluationAlerte dans notre code
400–800 ppmAir propre, bien aéréLED verte
800–1200 ppmAcceptable, l'air commence à être viciéLED jaune
1200–2000 ppmMauvais, il est temps d'ouvrir la fenêtreLED rouge + buzzer
Plus de 2000 ppmTrès mauvais ; somnolence et maux de tête fréquentsLED rouge + buzzer
5000 ppmLimite d'exposition professionnelle sur 8 heures en milieu de travailPlafond de la plage de mesure

Broches du MH-Z19B et schéma de branchement

Le MH-Z19B possède généralement 7 broches : Vin (alimentation), GND, TX et RX (UART), PWM (sortie à largeur d'impulsion), HD (calibration manuelle du zéro) et, sur certaines versions, Vo (sortie de tension analogique). Sur la sortie PWM, la période est d'environ 1004 ms et la valeur se calcule avec la formule ppm = plage × (TH − 2 ms) / (TH + TL − 4 ms) ; mais comme il faut attendre une seconde par lecture, l'UART est bien plus pratique. Nous utiliserons donc l'UART ; PWM et HD peuvent rester en l'air. En UART, les fils se branchent toujours en croix : le TX du capteur va au RX de la carte, le RX du capteur au TX de la carte. Tu trouveras les bases de la communication série dans l'article Communication série UART.

Broche du MH-Z19BArduino UnoESP32Raspberry Pi Pico
Vin (5 V)5VVIN (5V)VBUS (broche 40)
GNDGNDGNDGND
TXD10 (RX SoftwareSerial)GPIO 16 (RX UART2)GP1 (RX UART0)
RXD11 (avec diviseur 1 kΩ + 2 kΩ)GPIO 17 (TX UART2)GP0 (TX UART0)
PWMLibreLibreLibre
HDLibre (à GND pour la calibration)LibreLibre
LED d'alerte / buzzerD4, D5, D6 / D8GPIO 26 / GPIO 27GP15
N'essaie pas d'alimenter le capteur en 3,3 V : la lampe infrarouge et le circuit interne exigent 4,5–5,5 V ; en 3,3 V, le capteur ne répond pas du tout ou produit des valeurs absurdes. La deuxième erreur fréquente consiste à brancher TX et RX en direct (TX sur TX) ; dans ce cas, le code affiche sans cesse une erreur d'absence de réponse. Évite aussi d'appuyer sur le boîtier et le filtre du capteur, et de chauffer le boîtier en soudant ses broches : si la chambre optique est endommagée, la mesure est définitivement faussée.

La sortie TX du capteur est au niveau 3,3 V et l'Uno la lit sans problème comme un HIGH. Dans l'autre sens, la broche TX de l'Uno délivre 5 V. La documentation du fabricant indique un niveau d'interface de 3,3 V ; même si certains modules tolèrent 5 V, le plus sûr est de placer un simple diviseur de tension entre la broche D11 de l'Uno et le RX du capteur : 1 kΩ de D11 vers le RX du capteur, 2 kΩ du RX du capteur vers GND. La sortie vaut 5 × 2 / (1 + 2) = 3,33 V. Tu peux vérifier les valeurs avec les résistances dont tu disposes grâce au calculateur de diviseur de tension, ou utiliser un convertisseur de niveau logique bidirectionnel. L'ESP32 et le Pico fonctionnant déjà en 3,3 V, ils n'ont pas besoin de diviseur.

Protocole UART : comment parler au capteur ?

Le MH-Z19B fonctionne avec le réglage 9600 bauds, 8 bits de données, sans parité, 1 bit de stop (8N1). Chaque commande et chaque réponse font exactement 9 octets. Les commandes commencent par 0xFF, le deuxième octet est le numéro du capteur (0x01), le troisième le code de commande ; le dernier octet est la somme de contrôle (checksum). Le checksum se calcule à partir de la somme des octets 1 à 7 : checksum = 0xFF − (octet1 + … + octet7) + 1, le résultat étant tronqué à un octet. Dans la réponse à la commande de lecture, l'octet 0 vaut 0xFF et l'octet 1 vaut 0x86 ; la valeur de CO2 se trouve dans les octets 2 et 3 : ppm = octet haut × 256 + octet bas. Par exemple, si la réponse commence par FF 86 02 58, la valeur est 2 × 256 + 88 = 600 ppm. L'octet 4 est une valeur de température approximative non documentée (valeur − 40 °C), donnée à titre indicatif seulement ; pour une vraie mesure de température, utilise un capteur séparé.

Opération9 octets envoyés (hex)Explication
Lecture du CO2FF 01 86 00 00 00 00 00 79Les octets 2 et 3 de la réponse donnent la valeur en ppm
ABC activéFF 01 79 A0 00 00 00 00 E6Active la correction automatique de la base sur 24 heures (réglage d'usine)
ABC désactivéFF 01 79 00 00 00 00 00 86Désactive la calibration automatique pour serres et lieux fermés
Calibration du zéroFF 01 87 00 00 00 00 00 78Considère l'air ambiant comme 400 ppm ; à faire uniquement en plein air
Plage 2000 ppmFF 01 99 00 00 00 07 D0 8FRègle la plage de mesure sur 0–2000 ppm
Plage 5000 ppmFF 01 99 00 00 00 13 88 CBRègle la plage de mesure sur 0–5000 ppm

Pas à pas : mesurer le CO2 avec l'Arduino Uno

  1. Relie la broche Vin du capteur à la broche 5V de l'Uno et sa broche GND à GND.
  2. Relie la broche TX du capteur à D10 ; cette broche sera le RX de SoftwareSerial.
  3. Relie la broche D11 de l'Uno au RX du capteur via un diviseur de tension 1 kΩ + 2 kΩ.
  4. Relie les LED verte, jaune et rouge à D4, D5 et D6 avec des résistances de 220 Ω, et le buzzer passif à D8.
  5. Téléverse le code, ouvre le moniteur série à 9600 bauds et attends la fin des 3 premières minutes de préchauffage.
  6. Garde le capteur quelques minutes devant une fenêtre ouverte : tu dois lire environ 400–480 ppm ; puis souffle dessus à environ 30 cm et observe la valeur grimper rapidement.
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}

Le code envoie au capteur la commande de lecture de 9 octets toutes les 5 secondes, puis recueille la réponse de 9 octets pendant 300 ms au maximum. Si l'en-tête (FF 86) ou le checksum ne correspond pas, la valeur est ignorée ; ainsi, une ligne bruitée ne déclenche pas de fausse alarme. La fonction readCO2() renvoie un code négatif en cas d'erreur : -1 signifie pas de réponse, -2 en-tête incorrect, -3 checksum erroné. Comme la temporisation utilise millis() au lieu de delay(), loop() n'est pas bloquée ; si tu ajoutes plus tard un bouton ou un écran, le code restera réactif. Tu trouveras la logique de cette approche dans l'article Différence entre millis et delay. Si tu préfères une bibliothèque toute faite, la bibliothèque MH-Z19 (Jonathan Dempsey) du gestionnaire de bibliothèques encapsule le même protocole avec des fonctions comme getCO2() et autoCalibration() ; mais connaître le protocole brut t'aidera beaucoup à trouver le problème quand le capteur se comporte de façon inattendue.

Préchauffage : pourquoi ne pas se fier aux 3 premières minutes ?

Tant que la lampe infrarouge et le détecteur n'ont pas atteint une température stable, la mesure n'est pas fiable. Le fabricant indique un préchauffage de 3 minutes ; pendant ce temps, le capteur peut renvoyer des valeurs fixes ou absurdes (par exemple toujours 400 ou 500 ppm). C'est pourquoi notre code ne lit rien pendant les 180 premières secondes et affiche seulement le temps restant. De plus, le temps de réponse T90 du capteur est inférieur à 2 minutes : quand l'environnement change brusquement, atteindre 90 % de la vraie valeur peut prendre une ou deux minutes ; il est donc normal que la valeur baisse lentement après l'ouverture de la fenêtre. Si tu constates de petites fluctuations entre les mesures, faire la moyenne des 5 à 10 dernières lectures calme la valeur affichée ; pour les méthodes, jette un œil à l'article Filtrage des données de capteur. Si tu comptes utiliser l'appareil longtemps, le laisser alimenté en continu donne des résultats plus constants que de l'éteindre et de le rallumer à chaque fois.

Calibration automatique (ABC) et calibration manuelle du zéro

Le point zéro des capteurs NDIR dérive lentement au fil des mois et des années. Le MH-Z19B corrige cela avec l'ABC (Automatic Baseline Correction) : à chaque période de 24 heures, le capteur considère la valeur la plus basse observée comme de l'air propre, soit environ 400 ppm, et ajuste sa base en conséquence. L'ABC est activé d'usine. Dans les salles de classe, bureaux et chambres aérés à fond au moins une fois par jour, c'est très utile ; tu obtiens une précision raisonnable pendant des années sans t'occuper de calibration. En revanche, dans les serres, les salles de culture de champignons fermées ou tout lieu où le CO2 ne descend jamais à 400 ppm, l'ABC est nuisible : le capteur prend par exemple 700 ppm pour de l'air propre par erreur et décale toutes les mesures d'environ 300 ppm vers le bas. Dans ces endroits, désactive l'ABC avec la commande prévue et fais une calibration manuelle à intervalles réguliers.

Pour la calibration manuelle du zéro, fais fonctionner le capteur en plein air, à l'abri du vent et de la respiration des gens, pendant au moins 20 minutes. Ensuite, envoie la commande de calibration du zéro 0x87 ou relie la broche HD à GND pendant au moins 7 secondes. Le capteur enregistre alors l'air ambiant comme 400 ppm. Ne fais jamais cette opération dans une pièce fermée : un capteur qui prend 900 ppm intérieurs pour 400 t'affichera en permanence un air meilleur qu'il ne l'est, et tout l'intérêt de ton avertisseur disparaît. La commande 0x99 sert aussi à choisir entre les plages 2000 ppm et 5000 ppm ; dans les classes bondées, la plage 5000 ppm est plus sûre pour que la valeur ne plafonne pas à 2000 ppm.

Envoyer une fois dans setup() la commande qui active l'ABC remet dans un état connu même un capteur dont le réglage a été modifié dans un autre projet. Si tu utilises le code dans un lieu fermé comme une serre, il suffit de remplacer le tableau CMD_ABC_ON par les octets FF 01 79 00 00 00 00 00 86.

Utiliser le MH-Z19B avec l'ESP32

L'ESP32 possède trois UART matériels dont les broches peuvent être attribuées aux GPIO de ton choix ; SoftwareSerial n'est donc pas nécessaire. Relie le Vin du capteur à la broche VIN (5V) de la carte de développement ESP32, qui fournit les 5 V venant de l'USB. Le TX du capteur va au GPIO 16 et son RX au GPIO 17 ; les deux lignes étant au niveau 3,3 V, elles se branchent directement. Le code ci-dessous se compile de la même façon avec l'ESP32 Arduino core 2.x et 3.x ; quand la valeur dépasse 1200 ppm, il allume la LED du GPIO 26 et fait émettre un court bip au buzzer actif du GPIO 27. Sur les cartes à module WROVER, les GPIO 16 et 17 sont réservés à la PSRAM ; choisis alors par exemple les GPIO 32 et 33. Une fois la carte connectée au Wi-Fi, tu peux afficher la même valeur sur une page web, sur ton téléphone ou dans 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}

Mesurer le CO2 avec Raspberry Pi Pico et MicroPython

Sur le Pico, l'UART0 se trouve par défaut sur les broches GP0 (TX) et GP1 (RX). Relie le Vin du capteur à la broche VBUS du Pico (broche 40, les 5 V venant de l'USB) ; la sortie 3V3 est insuffisante pour le capteur. Si tu alimentes le Pico par pile au lieu de l'USB, VBUS n'a pas de tension et tu dois fournir au capteur une source de 5 V séparée. Le TX du capteur va à GP1 et son RX à GP0. Le code envoie la même commande de 9 octets que la version Arduino, vérifie le checksum avec la fonction sum() de Python et, au-dessus de 1200 ppm, allume la LED de GP15 (avec une résistance de 220 Ω). Si tu débutes avec MicroPython, tu peux d'abord lire l'article Bases de MicroPython.

MicroPython
1from machine import UART, Pin
2import time
3
4# MH-Z19B TX -> GP1, MH-Z19B RX -> GP0, Vin -> VBUS (5 V)
5uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1), timeout=300)
6led = Pin(15, Pin.OUT)                      # uyarı LED'i / warning LED
7
8CMD_READ = bytes([0xFF, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79])
9WARMUP_MS = 180000                          # 3 dakika ön ısınma / 3 minute warm-up
10ALARM_PPM = 1200
11start = time.ticks_ms()
12
13def checksum(packet):
14    return (0xFF - (sum(packet[1:8]) & 0xFF) + 1) & 0xFF
15
16def read_co2():
17    while uart.any():
18        uart.read()                         # eski baytları at / drop old bytes
19    uart.write(CMD_READ)
20    time.sleep_ms(100)                      # cevabın gelmesini bekle / wait for the answer
21    resp = uart.read(9)
22    if not resp or len(resp) != 9:
23        return None                         # cevap yok / no answer
24    if resp[0] != 0xFF or resp[1] != 0x86:
25        return None                         # yanlış başlık / wrong header
26    if resp[8] != checksum(resp):
27        return None                         # checksum hatası / checksum error
28    return resp[2] * 256 + resp[3]
29
30while True:
31    elapsed = time.ticks_diff(time.ticks_ms(), start)
32    if elapsed < WARMUP_MS:
33        print("Isiniyor / Warming up:", (WARMUP_MS - elapsed) // 1000, "s")
34    else:
35        ppm = read_co2()
36        if ppm is None:
37            print("Okuma hatasi / Read error")
38        else:
39            print("CO2:", ppm, "ppm")
40            led.value(1 if ppm >= ALARM_PPM else 0)
41    time.sleep(5)

Où placer le capteur dans une salle de classe ou une pièce ?

Le bon emplacement compte plus que le bon code. Place le capteur à la hauteur où les gens assis respirent, à environ 1–1,5 mètre du sol, sur un mur représentatif de la moyenne de la pièce. Près d'une fenêtre ou d'une porte, l'air frais entrant fait afficher une valeur trop basse ; posé sur une table tout près du visage de quelqu'un, tu verras des valeurs qui bondissent à chaque respiration. Évite aussi le dessus d'un radiateur, l'appui de fenêtre en plein soleil et les endroits où l'humidité se condense comme la salle de bains ; le capteur est conçu pour 0–50 °C et une humidité sans condensation. L'air entre par les surfaces filtrées du capteur ; si tu le mets dans un boîtier, fais-y beaucoup de trous et ne gêne pas la circulation de l'air autour. Si l'Uno ou l'ESP32 redémarre à cause de l'appel de courant instantané de la lampe, ajouter entre Vin et GND du capteur un condensateur électrolytique de 100 µF et un condensateur céramique de 100 nF stabilise l'alimentation.

Idées de projets avec le MH-Z19

  • Feu tricolore d'aération pour la classe : mets le circuit à LED verte, jaune et rouge de cet article dans un boîtier et accroche-le à un endroit visible depuis le bureau du professeur.
  • Afficheur de bureau avec écran : affiche la valeur de CO2 en gros chiffres sur un écran OLED SSD1306 ou un écran LCD I2C.
  • Notification sur le téléphone : avec l'ESP32, envoie un message via un bot Telegram quand la valeur dépasse 1200 ppm.
  • Tableau de maison connectée : envoie les mesures vers Home Assistant via MQTT, trace le graphique quotidien et crée des automatisations.
  • Ventilateur d'aération automatique : fais tourner une extraction quand le CO2 monte ; pour le pilotage du ventilateur, consulte l'article Contrôle de ventilateur avec Arduino.
  • Suivi de serre : en désactivant l'ABC, ajoute la mesure de CO2 au projet de serre intelligente et vois sur le graphique que les plantes consomment du CO2 le jour.
  • Indicateur d'air coloré : fais passer en douceur la couleur d'une seule LED WS2812B du vert à 400 ppm au rouge à 2000 ppm.
  • Enregistreur de données : écris une journée de mesures sur une carte SD et examine à quel cours l'air se dégrade le plus ; tu obtiens un solide jeu de données pour les concours de sciences et les projets scolaires.

Erreurs fréquentes et solutions

SymptômeCause possibleSolution
Toujours -1 (pas de réponse)TX et RX branchés en direct ou capteur alimenté en 3,3 VCroise TX et RX, alimente Vin en 5 V
Souvent -3 (erreur de checksum)Fil de breadboard mal serré, câble long ou broche inadaptée à SoftwareSerialRaccourcis les câbles ; sur Mega et Leonardo, utilise les broches RX prises en charge ; sur Uno, D10 convient
400 ou 500 ppm fixes les premières minutesLe préchauffage est en coursAttends au moins 3 minutes, puis mesure
Valeurs toujours basses au fil des joursDans un lieu jamais aéré, l'ABC a choisi une mauvaise baseDésactive l'ABC, fais une calibration manuelle en plein air
La valeur reste bloquée à 2000 ppmLa plage de mesure est réglée sur 2000 ppmPasse la plage à 5000 ppm avec la commande 0x99
La carte redémarre ou les valeurs sautentLe courant instantané d'environ 150 mA de la lampe fait s'effondrer une alimentation faibleAjoute un condensateur de 100 µF entre Vin et GND, utilise une bonne source de 5 V
Valeurs trop basses après la calibrationLa calibration du zéro a été faite dans une pièce ferméeRefais la calibration en plein air après 20 minutes d'attente
Le moyen le plus simple de savoir si le capteur fonctionne bien est un contrôle en deux points : devant une fenêtre ouverte, il doit lire entre 400 et 480 ppm après quelques minutes, et quand tu souffles dessus de près sans te boucher la bouche, la valeur doit grimper à plusieurs milliers de ppm en une ou deux minutes. S'il manque l'une de ces deux réactions, vérifie d'abord les câbles, le sens de TX et RX et l'alimentation 5 V.

Le MH-Z19B offre l'un des meilleurs compromis prix-précision parmi les capteurs qui mesurent vraiment le CO2 ; correctement alimenté, préchauffé 3 minutes et avec le réglage ABC adapté à l'environnement, il fonctionne de façon fiable pendant des années. Pour la qualité de l'air générale et les odeurs, tu peux aussi jeter un œil aux articles sur le MQ-135 et, pour les composés organiques volatils, sur le CCS811. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas et codes, des projets ESP32 de mesure de température et d'humidité, d'alarme gaz et d'affichage LCD et OLED ; en les combinant avec ce capteur, tu peux monter ta propre station de qualité de l'air.

Questions fréquentes

Quel taux de CO2 faut-il dans une pièce ?

Le CO2 est d'environ 420 ppm à l'extérieur, et une pièce bien aérée reste sous 800 ppm. Autour de 1000–1200 ppm, l'air devient vicié et il est temps d'ouvrir la fenêtre. Au-dessus de 2000 ppm, maux de tête, somnolence et manque de concentration deviennent fréquents.

Quelle différence entre le MH-Z19B et le MH-Z19C ?

Les deux sont des capteurs NDIR, avec le même brochage et les mêmes commandes UART ; les codes de cet article fonctionnent avec les deux. La version C est le successeur plus récent et plus économique du B. Comme elle est plus sensible à la tension d'alimentation, il est important de lui fournir de vrais 5 V stables.

Le capteur MH-Z19 fonctionne-t-il en 3,3 V ?

Non. L'alimentation du capteur doit être comprise entre 4,5 et 5,5 V ; en 3,3 V, la lampe infrarouge ne fonctionne pas correctement et le capteur ne répond pas. En revanche, les lignes UART sont au niveau 3,3 V : tu peux donc alimenter le capteur en 5 V et brancher TX et RX directement à l'ESP32 ou au Pico.

Faut-il désactiver la calibration automatique (ABC) du MH-Z19 ?

Dans les salles de classe, bureaux et maisons aérés à fond au moins une fois par jour, l'ABC doit rester activé ; le capteur se corrige toutes les 24 heures par rapport à l'air propre. Dans les serres, entrepôts fermés ou lieux où le CO2 ne descend jamais à 400 ppm, l'ABC décale les valeurs vers le bas à tort. Là, désactive l'ABC et fais de temps en temps une calibration manuelle en plein air.

Quelle différence entre le MH-Z19 et le MQ-135 ?

Le MQ-135 est un capteur de gaz à semi-conducteur chauffé ; il réagit à l'alcool, à l'ammoniac, à la fumée et à de nombreux gaz à la fois, et ne peut donner qu'une estimation grossière du CO2. Le MH-Z19 mesure directement le CO2 par absorption infrarouge, est presque insensible aux autres gaz et fournit une valeur calibrée en ppm. Pour une alerte d'aération, le bon choix est le MH-Z19.

Pourquoi le MH-Z19 affiche-t-il une mauvaise valeur au démarrage ?

La lampe infrarouge et le détecteur du capteur ont besoin d'environ 3 minutes de préchauffage pour atteindre une température stable. Pendant ce temps, des valeurs fixes ou absurdes peuvent être renvoyées. Dans ton code, ignore les lectures des 3 premières minutes et attends encore 1 à 2 minutes pour que la valeur se stabilise quand l'environnement change brusquement.

Voir tous les projets
Température et humidité avec DHT11
AR-55Intermédiaire

Température et humidité avec DHT11

Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

4.7(47)
83
Utilisation du buzzer
AR-13Débutant

Utilisation du buzzer

Tu t'es déjà demandé comment une sonnette ou une alarme produit son son ? L'Arduino fait biper un petit buzzer à intervalles courts : bip, silence, bip, silence.

4.7(92)
170
Alarme de détection de gaz/fumée ESP32 MQ-2
ES-20Intermédiaire

Alarme de détection de gaz/fumée ESP32 MQ-2

Dans ce projet, la détection de gaz combustibles (GPL, méthane, propane) et de fumée est assurée par un module capteur de gaz MQ-2 ; dès la détection, une alarme sonore semblable à une sirène retentit via un buzzer passif. La sortie numérique de seuil (DO) du capteur est connectée au GPIO 4 de l'ESP32 ; quand le gaz ou la fumée dépasse le seuil, DO passe à LOW et l'alarme se déclenche. La sensibilité se règle via le potentiomètre du module. Le buzzer est piloté par tone().

4.7(29)
44
Utilisation des capteurs de gaz
AR-51Débutant
Premium

Utilisation des capteurs de gaz

Un petit gardien qui repère une fuite de gaz dans la cuisine avant toi. Le capteur de gaz renifle l'air sans arrêt ; tant que tout va bien, la LED verte reste allumée, et quand le gaz dans l'air…

4.6(37)
50
Alarme du capteur de flamme et de gaz
AR-52Avancé
Premium

Alarme du capteur de flamme et de gaz

Un petit gardien qui te prévient tout de suite en cas de fuite de gaz ou de flamme quelque part.

4.8(52)
67
ESP32 DHT22 Température et humidité (avec écran LCD)
ES-15Intermédiaire

ESP32 DHT22 Température et humidité (avec écran LCD)

Il s'agit d'un projet permettant de mesurer la température ambiante et le taux d'humidité à l'aide d'un capteur DHT22 et d'afficher ces données en temps réel sur un écran LCD I2C 16x2. Les données du capteur sont lues à l'aide du protocole one-wire grâce à la bibliothèque Adafruit DHT. Ce projet constitue la base des stations météo IoT, de la domotique ou des systèmes de surveillance de l'environnement dans les serres.

4.8(38)
57
ESP32 HTTPClient + API météo (avec écran OLED SSD1306)
ES-32Avancé
Premium

ESP32 HTTPClient + API météo (avec écran OLED SSD1306)

L'ESP32 appelle par Internet une API météo (wttr.in) en REST avec HTTPClient.h. Contrairement à la version LCD I2C, on utilise ici un écran OLED SSD1306 (128×64), avec un grand texte et des icônes vectorielles pour un affichage plus riche. Sept icônes météo (soleil, pluie, neige et plus) sont dessinées à la volée, sans fichier bitmap.

4.3(10)
22
Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avancé
Premium

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.

4.7(7)
12