Capteur CO₂ Infrarouge NDIR MH-Z19 / MH-Z19B / MH-Z19C / MH-Z19E

Module de mesure du dioxyde de carbone 400–5000 ppm / 0–5000 ppm avec sortie UART & PWM

Arduino • ESP32 • ESP8266 • Raspberry Pi • STM32 • Domotique • Serre • HVAC • Qualité de l’air

Description générale

Le capteur CO₂ MH-Z19 est un module de mesure du dioxyde de carbone basé sur la technologie
NDIR infrarouge non dispersive. Il permet de mesurer la concentration de CO₂ dans l’air avec une bonne stabilité,
une réponse fiable et une intégration simple dans les projets électroniques, domotiques, IoT et industriels.

Contrairement aux capteurs de gaz chimiques classiques, un capteur NDIR mesure le CO₂ grâce à l’absorption infrarouge.
Cette méthode offre une meilleure sélectivité, une durée de vie plus longue et une meilleure stabilité pour une surveillance continue
de la qualité de l’air intérieur.

Ce module est particulièrement adapté pour les projets avec Arduino, ESP32, ESP8266, Raspberry Pi, STM32,
automate, système de ventilation, tableau de bord environnemental, station météo intérieure, serre intelligente ou système HVAC.

Utilisation recommandée : qualité de l’air intérieur, salle de classe, bureau, maison connectée,
serre agricole, ventilation automatique, purificateur d’air, laboratoire, station météo, système IoT et monitoring industriel.

Caractéristiques techniques principales

Caractéristique	Détail
Gaz détecté	Dioxyde de carbone CO₂
Technologie	NDIR infrarouge non dispersif
Plage de mesure	400–5000 ppm ou 0–5000 ppm selon version et configuration
Sorties	UART TTL / PWM selon modèle
Alimentation	Généralement 5V DC selon version
Niveau logique	TTL 3.3V, souvent compatible avec microcontrôleurs 5V
Compatibilité	Arduino, ESP32, ESP8266, Raspberry Pi, STM32, systèmes embarqués

Détail des variations disponibles

Tableau comparatif des versions

Version	Profil	Meilleure utilisation
MH-Z19	Version classique	Arduino, apprentissage, prototype CO₂
MH-Z19B	Version populaire	Domotique, ESP32, Home Assistant, MQTT
MH-Z19C	Version moderne	Boîtier connecté, IoT compact, écran OLED
MH-Z19E	Version avancée	Monitoring continu, HVAC, bâtiments intelligents

Niveaux indicatifs de CO₂

Niveau CO₂	Interprétation	Action recommandée
400 à 700 ppm	Air généralement bien renouvelé	Situation normale
700 à 1000 ppm	Air correct mais à surveiller	Aération possible
1000 à 1500 ppm	Renouvellement d’air insuffisant	Aérer ou activer ventilation
Plus de 1500 ppm	Air chargé en CO₂	Ventilation fortement conseillée

Exemple de câblage Arduino UNO

MH-Z19	Arduino UNO
Vin	5V
GND	GND
TX	D10 RX logiciel
RX	D11 TX logiciel

Code Arduino UART pour lire le CO₂

Ce code permet de lire la valeur CO₂ en ppm via la liaison série UART du module.

#include <SoftwareSerial.h>

SoftwareSerial mhz19(10, 11); 
// Arduino D10 = RX reçoit TX du capteur
// Arduino D11 = TX envoie vers RX du capteur

byte cmdReadCO2[9] = {0xFF, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79};
byte response[9];

void setup() {
  Serial.begin(9600);
  mhz19.begin(9600);

  Serial.println("Lecture capteur CO2 MH-Z19...");
  delay(3000); // temps de stabilisation
}

void loop() {
  int co2 = readCO2();

  if (co2 > 0) {
    Serial.print("CO2 : ");
    Serial.print(co2);
    Serial.println(" ppm");

    if (co2 > 1200) {
      Serial.println("Alerte : ventilation recommandee !");
    }
  } else {
    Serial.println("Erreur de lecture du capteur.");
  }

  delay(3000);
}

int readCO2() {
  mhz19.write(cmdReadCO2, 9);
  delay(100);

  if (mhz19.available() >= 9) {
    for (int i = 0; i < 9; i++) {
      response[i] = mhz19.read();
    }

    if (response[0] == 0xFF && response[1] == 0x86) {
      int ppm = response[2] * 256 + response[3];
      return ppm;
    }
  }

  return -1;
}

Code ESP32 avec UART matériel

Avec un ESP32, il est préférable d’utiliser un port série matériel. Cet exemple utilise les broches GPIO16 et GPIO17.

#define RXD2 16
#define TXD2 17

byte cmdReadCO2[9] = {0xFF, 0x01, 0x86, 0, 0, 0, 0, 0, 0x79};
byte response[9];

void setup() {
  Serial.begin(115200);
  Serial2.begin(9600, SERIAL_8N1, RXD2, TXD2);

  Serial.println("ESP32 + MH-Z19 pret");
  delay(3000);
}

void loop() {
  int co2 = readCO2();

  if (co2 > 0) {
    Serial.print("Taux CO2 : ");
    Serial.print(co2);
    Serial.println(" ppm");

    if (co2 < 800) {
      Serial.println("Qualite air : bonne");
    } else if (co2 < 1200) {
      Serial.println("Qualite air : moyenne");
    } else {
      Serial.println("Qualite air : ventilation conseillee");
    }
  }

  delay(3000);
}

int readCO2() {
  Serial2.write(cmdReadCO2, 9);
  delay(100);

  if (Serial2.available() >= 9) {
    for (int i = 0; i < 9; i++) {
      response[i] = Serial2.read();
    }

    if (response[0] == 0xFF && response[1] == 0x86) {
      return response[2] * 256 + response[3];
    }
  }

  return -1;
}

Code ESP32 avec relais de ventilation

Exemple pratique : si le CO₂ dépasse 1200 ppm, l’ESP32 active un relais pour démarrer un ventilateur.

#define RXD2 16
#define TXD2 17
#define RELAIS 23

byte cmdReadCO2[9] = {0xFF, 0x01, 0x86, 0, 0, 0, 0, 0, 0x79};
byte response[9];

void setup() {
  Serial.begin(115200);
  Serial2.begin(9600, SERIAL_8N1, RXD2, TXD2);

  pinMode(RELAIS, OUTPUT);
  digitalWrite(RELAIS, LOW);

  delay(3000);
}

void loop() {
  int co2 = readCO2();

  Serial.print("CO2 = ");
  Serial.print(co2);
  Serial.println(" ppm");

  if (co2 > 1200) {
    digitalWrite(RELAIS, HIGH);
    Serial.println("Ventilation activee");
  } else if (co2 > 0 && co2 < 900) {
    digitalWrite(RELAIS, LOW);
    Serial.println("Ventilation arretee");
  }

  delay(5000);
}

int readCO2() {
  Serial2.write(cmdReadCO2, 9);
  delay(100);

  if (Serial2.available() >= 9) {
    for (int i = 0; i < 9; i++) {
      response[i] = Serial2.read();
    }

    if (response[0] == 0xFF && response[1] == 0x86) {
      return response[2] * 256 + response[3];
    }
  }

  return -1;
}

Exemple Python Raspberry Pi

Sur Raspberry Pi, le capteur peut être lu via le port série UART avec Python. Cet exemple affiche la valeur CO₂ dans le terminal.

import serial
import time

ser = serial.Serial("/dev/serial0", 9600, timeout=1)

cmd = bytearray([0xFF, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79])

def read_co2():
    ser.write(cmd)
    time.sleep(0.1)
    response = ser.read(9)

    if len(response) == 9 and response[0] == 0xFF and response[1] == 0x86:
        co2 = response[2] * 256 + response[3]
        return co2

    return None

while True:
    co2 = read_co2()

    if co2:
        print(f"CO2 : {co2} ppm")
    else:
        print("Erreur de lecture")

    time.sleep(3)

Applications détaillées

1. Maison connectée

Le capteur peut être intégré dans une box domotique pour surveiller le CO₂ dans les chambres, salons, bureaux ou pièces fermées.
Il peut envoyer les données vers MQTT, Home Assistant ou un tableau de bord web.

2. Salle de classe et bureau

Dans les espaces occupés par plusieurs personnes, le taux de CO₂ augmente rapidement. Un affichage en temps réel permet de savoir
quand ouvrir les fenêtres ou activer la ventilation.

3. Serre intelligente

Dans l’agriculture connectée, le CO₂ est un paramètre important pour suivre l’environnement de culture.
Le module peut être associé à des capteurs de température, humidité, luminosité et humidité du sol.

4. Système HVAC

Le MH-Z19 peut servir de capteur de référence dans un système de ventilation automatique.
Un microcontrôleur peut déclencher un relais, une turbine, une VMC ou un extracteur selon le seuil programmé.

5. Station de qualité de l’air

Associé à un écran OLED, un ESP32 et une connexion WiFi, ce module permet de créer une station complète avec affichage CO₂,
température, humidité, historique et alertes.

Conseils d’installation

• Laisser le capteur chauffer quelques minutes avant d’interpréter les premières mesures.
• Éviter de placer le module directement devant un ventilateur ou une source de chaleur.
• Installer le capteur dans une zone représentative de l’air ambiant.
• Prévoir une alimentation stable, surtout avec ESP32 ou Raspberry Pi.
• Respecter le câblage TX/RX : le TX du capteur va vers le RX du microcontrôleur.

FAQ

Ce capteur mesure-t-il vraiment le CO₂ ?

Oui, la série MH-Z19 utilise une technologie NDIR, conçue pour détecter le dioxyde de carbone dans l’air.

Peut-on l’utiliser avec Arduino ?

Oui, il peut être utilisé avec Arduino via UART. Un exemple de code est fourni dans cette fiche.

Peut-on l’utiliser avec ESP32 ?

Oui, l’ESP32 est même très pratique grâce à ses ports série matériels et sa connectivité WiFi/Bluetooth.

Quelle variation choisir ?

Pour un projet simple Arduino, le MH-Z19 ou MH-Z19B suffit. Pour une station connectée, le MH-Z19B ou MH-Z19C est conseillé.
Pour une surveillance continue plus avancée, le MH-Z19E est un très bon choix.

Peut-on piloter une ventilation avec ce capteur ?

Oui, avec un microcontrôleur et un module relais, vous pouvez activer automatiquement un ventilateur selon un seuil CO₂.

Un capteur CO₂ complet pour vos projets électroniques et IoT

Le module MH-Z19 / MH-Z19B / MH-Z19C / MH-Z19E est une solution pratique, compacte et fiable pour mesurer le CO₂,
automatiser la ventilation et créer des systèmes intelligents de surveillance de la qualité de l’air.