Composants · 10 min de lecture

CCS811 Arduino : capteur de qualité de l'air eCO2 et TVOC

CCS811 avec Arduino : mesurer eCO2 et TVOC, I2C et broche WAK, 20 min de chauffe et 48 h de rodage, sauvegarde du baseline, compensation BME280 et écran ESP32.

Le CCS811 est un petit capteur de gaz numérique à interface I2C utilisé dans les projets Arduino pour mesurer la qualité de l'air intérieur. Il détecte les composés organiques volatils (COV) de la pièce et fournit deux valeurs : le TVOC (composés organiques volatils totaux) en ppb et l'eCO2 (équivalent dioxyde de carbone) en ppm. Le petit processeur intégré gère l'élément chauffant, traite la mesure brute avec son propre algorithme et te donne des chiffres prêts à l'emploi. Contrairement aux capteurs analogiques de la série MQ, tu obtiens donc des valeurs utiles en quelques lignes de code sans te battre avec des formules d'étalonnage.

Dans ce guide, on explique comment fonctionne le CCS811, pourquoi l'eCO2 n'est pas du vrai CO2 et le piège le plus fréquent : la broche WAK. On fera une première mesure avec un Arduino Uno, puis on verra la chauffe de 20 minutes, le rodage initial de 48 heures, la sauvegarde du baseline et la compensation de température et d'humidité avec un BME280. Ensuite, on construira avec un ESP32 un indicateur de qualité de l'air intérieur avec écran OLED et LED, on écrira un code MicroPython sans bibliothèque pour le Raspberry Pi Pico et on comparera le CCS811 au MQ-135.

Module capteur de qualité de l'air CJMCU-811 avec CCS811
Le module CJMCU-811 : capteur CCS811 avec les broches VCC, GND, SCL, SDA, WAK, INT, RST et ADD.

Qu'est-ce que le CCS811 et comment fonctionne-t-il ?

Le CCS811 est un capteur de gaz à oxyde métallique (MOX). Il contient un minuscule élément chauffant surmonté d'une couche sensible aux gaz. Quand l'alcool, l'acétone, le formaldéhyde, le parfum, les produits ménagers ou les composés organiques de l'haleine augmentent dans l'air, la résistance de cette couche change. Le microcontrôleur du capteur mesure cette résistance, la corrige avec les données de température et d'humidité et en déduit le TVOC. L'eCO2, lui, n'est pas mesuré mais estimé : dans une pièce fermée, les personnes produisent à la fois du CO2 et des COV, et l'algorithme estime de combien le CO2 a probablement augmenté à partir de la hausse des COV. Les plages vont de 400 à 8192 ppm pour l'eCO2 et de 0 à 1187 ppb pour le TVOC ; la valeur la plus basse affichée est 400 ppm, car c'est le niveau moyen de CO2 de l'air extérieur.

CaractéristiqueValeur
Type de capteurOxyde métallique (MOX) avec microcontrôleur intégré
SortieseCO2 (400–8192 ppm), TVOC (0–1187 ppb), données de résistance brutes
InterfaceI2C, adresse 0x5A (ADD au GND) ou 0x5B (ADD au VCC)
Alimentation1,8–3,6 V (alimente le module CJMCU-811 en 3,3 V)
CourantEnviron 30 mA en mode 1 seconde à cause de l'élément chauffant, bien moins en moyenne en mode 60 secondes
Modes de mesureMode 1 : 1 s, mode 2 : 10 s, mode 3 : 60 s, mode 4 : 250 ms (données brutes uniquement)
Chauffe20 minutes à chaque mise sous tension
Rodage initial (burn-in)48 heures pour un capteur neuf
L'eCO2 n'est pas du vrai CO2. S'il n'y a pas de source de COV dans la pièce (par exemple quand le CO2 s'accumule dans une pièce vide), l'eCO2 peut rester bas ; si tu vaporises du parfum ou utilises de l'alcool, l'eCO2 grimpe à des milliers de ppm même sans personne dans la pièce. Pour décider d'aérer ou surveiller le CO2 dans une salle de classe, utilise plutôt des capteurs NDIR qui mesurent le vrai CO2 (comme le MH-Z19, le SCD30 ou le SCD40). Le CCS811 est bien adapté pour suivre les variations de COV et la tendance générale de la qualité de l'air.

Brochage du CCS811 et câblage

La carte CCS811 la plus courante est le module CJMCU-811. Il a huit broches, et quatre d'entre elles, VCC, GND, SDA et SCL, se câblent comme sur n'importe quel capteur I2C. La broche qui fait la différence est WAK (nWAKE). Tant qu'elle est à l'état bas, le capteur écoute le bus I2C ; à l'état haut ou en l'air, il reste endormi et ne te répond pas. Sur le module CJMCU-811, WAK n'est pas reliée au GND sur la carte, tu dois donc la relier toi-même au GND. La broche ADD choisit l'adresse : 0x5A au GND, 0x5B au VCC. INT signale par interruption qu'une nouvelle donnée est prête et RST sert au reset matériel ; tu peux laisser les deux non connectées pour ton premier essai.

Broche CCS811Arduino UnoESP32Raspberry Pi Pico
VCC3.3V3V33V3 (OUT)
GNDGNDGNDGND
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
WAKGNDGNDGND
ADDGND (0x5A)GND (0x5A)GND (0x5A)
INTNon connectée (D2 en option)Non connectéeNon connectée
RSTNon connectéeNon connectéeNon connectée
La puce CCS811 accepte au maximum 3,6 V et la plupart des modules CJMCU-811 n'ont pas de régulateur ; ne relie pas VCC à la broche 5V de l'Arduino. Les lignes I2C de l'Uno sont en 5 V : dans un projet définitif, le plus sûr est d'intercaler un convertisseur de niveau logique. L'ESP32 et le Pico fonctionnent déjà en 3,3 V et se branchent directement. Les règles générales du bus I2C sont expliquées dans l'article qu'est-ce que l'I2C.

Première mesure avec un Arduino Uno

  1. Ouvre le gestionnaire de bibliothèques de l'IDE Arduino, cherche Adafruit CCS811 et installe-la avec ses dépendances.
  2. Câble le module selon le tableau ci-dessus ; n'oublie pas de relier WAK et ADD au GND.
  3. Téléverse le sketch ci-dessous et ouvre le moniteur série à 9600 bauds.
  4. Pendant les premières minutes, l'eCO2 peut rester vers 400 et le TVOC vers 0 ; les valeurs se stabilisent à mesure que le capteur chauffe.
  5. Fais un essai près d'un feutre, de gel hydroalcoolique ou de ton haleine ; tu verras le TVOC et l'eCO2 monter en quelques secondes.
C++ (Arduino IDE)
1// CCS811 ile eCO2 ve TVOC okuma (Arduino Uno) / reading eCO2 and TVOC with CCS811
2// Bağlantı: VCC-3.3V, GND-GND, SDA-A4, SCL-A5, WAK-GND, ADD-GND (0x5A)
3#include <Wire.h>
4#include <Adafruit_CCS811.h>
5
6Adafruit_CCS811 ccs;
7
8void setup() {
9  Serial.begin(9600);
10  if (!ccs.begin(0x5A)) {                    // ADD GND'de ise 0x5A / 0x5A when ADD is low
11    Serial.println(F("CCS811 bulunamadi, WAK ve kablolari kontrol et"));
12    while (true) {}
13  }
14  ccs.setDriveMode(CCS811_DRIVE_MODE_1SEC);  // saniyede bir ölçüm / one reading per second
15  while (!ccs.available()) {}                // ilk veriyi bekle / wait for the first data
16}
17
18void loop() {
19  if (ccs.available()) {
20    if (ccs.readData() == 0) {               // 0 = başarılı / 0 = success
21      Serial.print(F("eCO2: "));
22      Serial.print(ccs.geteCO2());
23      Serial.print(F(" ppm  TVOC: "));
24      Serial.print(ccs.getTVOC());
25      Serial.println(F(" ppb"));
26    } else {
27      Serial.println(F("Okuma hatasi / read error"));
28    }
29  }
30  delay(1000);
31}
FonctionRôle
ccs.begin(0x5A)Réinitialise le capteur, vérifie son identifiant (0x81) et démarre l'application ; renvoie false en cas d'échec
setDriveMode()Choisit la cadence de mesure : 1SEC, 10SEC, 60SEC, 250MS ou IDLE
available()Renvoie true quand une nouvelle mesure est prête
readData()Lit le résultat ; la valeur 0 signifie que la lecture a réussi
geteCO2() / getTVOC()Les dernières valeurs lues d'eCO2 (ppm) et de TVOC (ppb)
Si ccs.begin() renvoie false, vérifie d'abord que WAK est bien au GND. Contrôle ensuite l'adresse avec un sketch scanner I2C : si le composant apparaît en 0x5B, ADD est reliée au VCC et il te faut begin(0x5B). Sur certaines cartes comme l'ESP8266, l'étirement d'horloge (clock stretching) I2C du CCS811 pose problème ; avec l'ESP32, l'Uno et le Pico, ça se passe en général sans souci.

20 minutes de chauffe et 48 heures de rodage

Un capteur MOX ne mesure correctement qu'une fois que sa couche a atteint une certaine température et s'est stabilisée. Le CCS811 a deux périodes distinctes souvent confondues. La chauffe (run-in) est la période d'environ 20 minutes nécessaire à chaque mise sous tension ; les valeurs lues pendant ce temps ne sont pas réalistes, et il est logique d'afficher « en chauffe ». Le rodage initial (burn-in) est la période d'environ 48 heures qu'un capteur neuf traverse une seule fois dans sa vie ; la couche s'y stabilise chimiquement. Faire tourner un capteur tout juste acheté 48 heures sans interruption avant de l'intégrer à ton projet améliore nettement la stabilité des mesures suivantes.

PériodeQuand ?Que faire ?
48 premières heures (burn-in)Une fois dans la vie du capteurLaisse tourner le capteur en continu, ne te fie pas aux valeurs, ne sauvegarde pas le baseline
20 minutes à chaque mise sous tension (run-in)À chaque alimentationAffiche en chauffe, restaure le baseline sauvegardé à la fin de cette période
Après un changement de modeEn passant à un mode plus lentAttends les premières mesures du nouveau mode

Qu'est-ce que le baseline et pourquoi le sauvegarder ?

Le CCS811 conserve une valeur de référence pour l'air propre appelée baseline. L'algorithme ajuste lui-même cette référence au fil du temps, d'après l'air le plus propre qu'il a vu. Le problème : chaque coupure d'alimentation remet le baseline à zéro, et les valeurs peuvent dériver jusqu'à ce que l'algorithme le réapprenne. La solution : lire le baseline avec getBaseline() une fois que le capteur a longtemps bien fonctionné, l'écrire en mémoire permanente et le restaurer avec setBaseline() après les 20 minutes de chauffe à la mise sous tension suivante. Le baseline est un nombre de deux octets sans signification lisible ; tu te contentes de le stocker et de le rendre. Le fabricant conseille de le sauvegarder chaque jour pendant la première semaine après le rodage, puis toutes les quelques semaines. Sur Arduino, tu peux l'écrire dans l'EEPROM ; sur ESP32, en flash avec Preferences. Il est important que le capteur ait vu de l'air propre avant la sauvegarde ; quelques minutes d'aération suffisent.

Compensation de température et d'humidité avec un BME280

Par défaut, l'algorithme du CCS811 suppose que la pièce est à 25 °C et 50 pour cent d'humidité. Plus les valeurs réelles s'en écartent, plus les calculs de TVOC et d'eCO2 dérivent. Si tu transmets les vraies valeurs au capteur avec setEnvironmentalData(humidité, température), l'algorithme en tient compte. Attention à l'ordre : dans la bibliothèque Adafruit, l'humidité vient d'abord, puis la température. Le capteur stocke l'humidité par pas de 1/512 %HR et la température par pas de 1/512 °C avec un décalage de -25 °C ; la bibliothèque fait la conversion pour toi. Le capteur idéal pour ça est un BME280 sur le même bus I2C. Si tu n'as jamais utilisé de BME280, jette un œil à l'article capteur BME280 et BMP280.

Capteur de température, d'humidité et de pression BME280
Le BME280 partage le bus I2C avec le CCS811 et fournit les données nécessaires à la compensation de température et d'humidité.
C++ (Arduino IDE)
1// CCS811 + BME280: sıcaklık ve nem düzeltmesi / temperature and humidity compensation
2// İkisi de aynı I2C hattında: CCS811 0x5A, BME280 0x76 / both on the same I2C bus
3#include <Wire.h>
4#include <Adafruit_CCS811.h>
5#include <Adafruit_BME280.h>
6
7Adafruit_CCS811 ccs;
8Adafruit_BME280 bme;
9unsigned long sonBaseline = 0;
10
11void setup() {
12  Serial.begin(9600);
13  if (!ccs.begin(0x5A)) { Serial.println(F("CCS811 yok")); while (true) {} }
14  if (!bme.begin(0x76)) { Serial.println(F("BME280 yok (0x77 dene)")); while (true) {} }
15  ccs.setDriveMode(CCS811_DRIVE_MODE_1SEC);
16}
17
18void loop() {
19  float sicaklik = bme.readTemperature();    // °C
20  float nem = bme.readHumidity();            // %RH
21  ccs.setEnvironmentalData(nem, sicaklik);   // önce nem, sonra sıcaklık / humidity first
22
23  if (ccs.available() && ccs.readData() == 0) {
24    Serial.print(sicaklik, 1); Serial.print(F(" C  "));
25    Serial.print(nem, 0);      Serial.print(F(" %  eCO2: "));
26    Serial.print(ccs.geteCO2()); Serial.print(F(" ppm  TVOC: "));
27    Serial.print(ccs.getTVOC()); Serial.println(F(" ppb"));
28  }
29
30  if (millis() - sonBaseline > 60000UL) {    // dakikada bir baseline'ı göster / show baseline every minute
31    sonBaseline = millis();
32    Serial.print(F("Baseline: 0x"));
33    Serial.println(ccs.getBaseline(), HEX);
34  }
35  delay(2000);
36}
L'élément chauffant du CCS811 réchauffe le module de quelques degrés. Sur les modules combinés où le CCS811 et le BME280 partagent la même carte (comme le CJMCU-8128), le BME280 peut afficher 2 à 5 °C de plus que la vraie température de la pièce. Avec des modules séparés, place le BME280 à quelques centimètres du CCS811. Un module BME280 peut avoir l'adresse 0x76 ou 0x77 ; si begin() échoue, essaie l'autre.

Indicateur de qualité de l'air intérieur avec un ESP32

On assemble maintenant le tout : l'ESP32 lira l'eCO2 et le TVOC toutes les deux secondes, compensera avec le BME280, affichera les résultats sur un écran OLED de 0,96 pouce et indiquera l'état de l'air en couleur avec trois LED. Pendant la chauffe, l'écran affiche « Isiniyor » (en chauffe) ; au bout de 20 minutes, le code restaure le baseline sauvegardé, et une fois que la carte a tourné 48 heures, il sauvegarde le baseline en flash une fois par jour. Les quatre composants I2C partagent les deux mêmes fils ; leurs adresses étant différentes, il n'y a pas de conflit.

ÉlémentBroche ESP32Remarque
SDA du CCS811, du BME280 et de l'OLEDGPIO 21Les trois modules sur la même ligne
SCL du CCS811, du BME280 et de l'OLEDGPIO 22Les trois modules sur la même ligne
WAK et ADD du CCS811GNDAdresse 0x5A
LED verteGPIO 25Avec une résistance de 220 Ω, eCO2 sous 800 ppm
LED jauneGPIO 26Avec une résistance de 220 Ω, 800–1199 ppm
LED rougeGPIO 27Avec une résistance de 220 Ω, 1200 ppm et plus
VCC de tous les modules3V3Masses communes
C++ (Arduino IDE)
1// ESP32 iç mekân hava kalitesi göstergesi / ESP32 indoor air quality indicator
2// CCS811 + BME280 + SSD1306 OLED (I2C: SDA 21, SCL 22) + 3 LED (25, 26, 27)
3#include <Wire.h>
4#include <Preferences.h>
5#include <Adafruit_CCS811.h>
6#include <Adafruit_BME280.h>
7#include <Adafruit_GFX.h>
8#include <Adafruit_SSD1306.h>
9
10Adafruit_CCS811 ccs;
11Adafruit_BME280 bme;
12Adafruit_SSD1306 ekran(128, 64, &Wire, -1);
13Preferences ayarlar;                          // baseline kalıcı bellekte / baseline in flash
14
15const int YESIL = 25, SARI = 26, KIRMIZI = 27;
16const uint64_t ISINMA_SN = 20 * 60;           // 20 dakika ısınma / 20-minute warm-up
17const uint64_t ILK_KAYIT_SN = 48 * 3600;      // ilk kayıt 48 saat sonra / first save after 48 h
18const uint64_t KAYIT_ARALIK_SN = 24 * 3600;   // sonra günde bir / then once a day
19bool baselineYuklendi = false;
20uint64_t sonKayitSn = 0;
21
22uint64_t calismaSn() {
23  return esp_timer_get_time() / 1000000ULL;   // taşmayan çalışma süresi / non-overflowing uptime
24}
25
26void setup() {
27  Serial.begin(115200);
28  Wire.begin(21, 22);
29  pinMode(YESIL, OUTPUT);
30  pinMode(SARI, OUTPUT);
31  pinMode(KIRMIZI, OUTPUT);
32
33  if (!ccs.begin(0x5A)) { Serial.println("CCS811 yok"); while (true) delay(1000); }
34  if (!bme.begin(0x76)) { Serial.println("BME280 yok"); while (true) delay(1000); }
35  if (!ekran.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { Serial.println("OLED yok"); }
36  ccs.setDriveMode(CCS811_DRIVE_MODE_1SEC);
37  ayarlar.begin("ccs811", false);
38}
39
40void loop() {
41  static unsigned long sonOkuma = 0;
42  if (millis() - sonOkuma < 2000) return;     // 2 saniyede bir / every 2 seconds
43  sonOkuma = millis();
44
45  float sicaklik = bme.readTemperature();
46  float nem = bme.readHumidity();
47  ccs.setEnvironmentalData(nem, sicaklik);
48  if (!ccs.available() || ccs.readData() != 0) return;
49
50  uint16_t eco2 = ccs.geteCO2();
51  uint16_t tvoc = ccs.getTVOC();
52  uint64_t sn = calismaSn();
53
54  // 20 dakika sonra kayıtlı baseline'ı geri yükle / restore the saved baseline after 20 min
55  if (!baselineYuklendi && sn > ISINMA_SN) {
56    uint16_t kayitli = ayarlar.getUShort("baseline", 0);
57    if (kayitli != 0) ccs.setBaseline(kayitli);
58    baselineYuklendi = true;
59  }
60  // 48 saatten sonra günde bir baseline'ı kaydet / save the baseline daily after 48 h
61  if (sn > ILK_KAYIT_SN && sn - sonKayitSn > KAYIT_ARALIK_SN) {
62    ayarlar.putUShort("baseline", ccs.getBaseline());
63    sonKayitSn = sn;
64  }
65
66  // LED: yeşil < 800, sarı 800-1199, kırmızı >= 1200 ppm / LED thresholds
67  digitalWrite(YESIL, eco2 < 800);
68  digitalWrite(SARI, eco2 >= 800 && eco2 < 1200);
69  digitalWrite(KIRMIZI, eco2 >= 1200);
70
71  ekran.clearDisplay();
72  ekran.setTextColor(SSD1306_WHITE);
73  ekran.setTextSize(1);
74  ekran.setCursor(0, 0);
75  ekran.print(sn < ISINMA_SN ? "Isiniyor..." : "Hava kalitesi");
76  ekran.setTextSize(2);
77  ekran.setCursor(0, 14);
78  ekran.print(eco2);
79  ekran.setTextSize(1);
80  ekran.print(" ppm eCO2");
81  ekran.setCursor(0, 36);
82  ekran.printf("TVOC: %u ppb", tvoc);
83  ekran.setCursor(0, 50);
84  ekran.printf("%.1f C  %.0f %%", sicaklik, nem);
85  ekran.display();
86
87  Serial.printf("eCO2 %u ppm  TVOC %u ppb  %.1f C  %.0f %%\n", eco2, tvoc, sicaklik, nem);
88}

Dans le code, on mesure le temps de fonctionnement avec esp_timer_get_time() plutôt qu'avec millis() ; cette fonction renvoie des microsecondes sur 64 bits, donc aucun débordement pour un indicateur qui tourne des mois. Le baseline est écrit avec la bibliothèque Preferences dans un espace nommé « ccs811 » et survit aux coupures. Côté bibliothèques, installe simplement Adafruit CCS811, Adafruit BME280 et Adafruit SSD1306 avec leurs dépendances. Pour les détails de l'OLED, consulte l'article écran OLED SSD1306.

eCO2 (ppm)TVOC (ppb)AppréciationQue faire ?
400–7990–219BonneRien à faire
800–999220–659MoyenneAère quand tu peux
1000–1499660–2199MauvaiseOuvre la fenêtre, cherche la source de COV
1500 et plus2200 et plusTrès mauvaiseAère tout de suite, ne reste pas longtemps

Les limites du tableau sont des valeurs indicatives couramment utilisées par les indicateurs de qualité de l'air intérieur ; ce ne sont pas des seuils légaux mais une échelle pour s'orienter. Enregistrer quelques jours chez toi et observer comment les valeurs changent le matin, pendant la cuisine et après le ménage est le meilleur moyen d'adapter les seuils à ton environnement.

CCS811 avec le Raspberry Pi Pico (MicroPython)

Sur le Pico, tu peux utiliser le CCS811 en MicroPython sans installer de bibliothèque, en écrivant directement dans ses registres. Le déroulement est le même que celui de la bibliothèque Adafruit : on lit d'abord 0x81 dans le registre d'identification (0x20), on fait un reset logiciel, on démarre l'application (0xF4) et on choisit le mode de mesure (0x01). Ensuite, chaque fois que le bit DATA_READY du registre d'état vaut 1, on lit quatre octets dans le registre de résultats (0x02). Le code contient aussi une petite fonction qui écrit l'humidité et la température dans le registre d'environnement (0x05). Si tu débutes avec MicroPython, lis d'abord l'article les bases de MicroPython.

MicroPython
1# Raspberry Pi Pico MicroPython: kütüphanesiz CCS811 / CCS811 without a library
2# Bağlantı: SDA GP4, SCL GP5, VCC 3V3, WAK GND, ADD GND (0x5A)
3from machine import I2C, Pin
4import time
5
6i2c = I2C(0, scl=Pin(5), sda=Pin(4), freq=100000)
7ADR = 0x5A
8
9def oku(reg, n):
10    return i2c.readfrom_mem(ADR, reg, n)
11
12if oku(0x20, 1)[0] != 0x81:                              # HW_ID 0x81 olmalı / must be 0x81
13    raise OSError("CCS811 bulunamadi")
14i2c.writeto(ADR, bytes([0xFF, 0x11, 0xE5, 0x72, 0x8A]))  # yazılım reseti / software reset
15time.sleep_ms(100)
16if not oku(0x00, 1)[0] & 0x10:                           # APP_VALID biti / APP_VALID bit
17    raise OSError("Uygulama gecersiz")
18i2c.writeto(ADR, bytes([0xF4]))                          # APP_START
19time.sleep_ms(100)
20i2c.writeto_mem(ADR, 0x01, bytes([0x10]))                # MEAS_MODE: mod 1, saniyede bir
21
22def ortam(nem, sicaklik):
23    # Nem 1/512 %RH, sıcaklık 1/512 °C ve -25 °C kaydırmalı / ENV_DATA format
24    h = int(nem * 512 + 0.5)
25    t = int((sicaklik + 25) * 512 + 0.5)
26    i2c.writeto_mem(ADR, 0x05, bytes([h >> 8, h & 0xFF, t >> 8, t & 0xFF]))
27
28ortam(45.0, 23.5)   # BME280 varsa gerçek değerlerle güncelle / use real BME280 values if you have one
29
30while True:
31    durum = oku(0x00, 1)[0]
32    if durum & 0x01:                                     # ERROR biti / ERROR bit
33        print("hata kodu:", oku(0xE0, 1)[0])
34    elif durum & 0x08:                                   # DATA_READY biti / DATA_READY bit
35        d = oku(0x02, 4)
36        eco2 = (d[0] << 8) | d[1]
37        tvoc = (d[2] << 8) | d[3]
38        print("eCO2:", eco2, "ppm  TVOC:", tvoc, "ppb")
39    time.sleep(1)

CCS811 ou MQ-135 ?

Les deux capteurs sont vendus comme « capteur de qualité de l'air », mais fonctionnent très différemment. Le MQ-135 est analogique : son élément chauffant alimenté en 5 V consomme environ 150 mA, sa sortie est une tension et tu dois faire ton propre étalonnage pour calculer des ppm. Le CCS811 est numérique, consomme peu et fournit directement l'eCO2 et le TVOC. Tu trouveras les étapes d'étalonnage détaillées dans l'article capteur de qualité de l'air MQ135.

Capteur de qualité de l'air MQ-135
Le MQ-135 fournit une sortie analogique et son élément chauffant en 5 V consomme bien plus de courant que le CCS811.
CaractéristiqueCCS811MQ-135
SortieNumérique I2C : eCO2 et TVOCTension analogique (et une broche numérique de seuil)
Alimentation3,3 V5 V
CourantEnviron 30 mA (mode 1 s), bien moins dans les modes lentsEnviron 150 mA
ÉtalonnageAlgorithme intégré et baselineManuel, mesure de R0 en air propre
Chauffe20 min, 48 heures à la première utilisationQuelques minutes, 24 à 48 heures à la première utilisation
Usage sur batterieAdapté (mode 60 s)Inadapté
PrixPlus cherMoins cher

Erreurs fréquentes et solutions

SymptômeCause probableSolution
begin() renvoie falseBroche WAK en l'air ou mauvaise adresseRelie WAK au GND, vérifie 0x5A ou 0x5B avec un scanner I2C
eCO2 toujours à 400, TVOC toujours à 0Chauffe en cours ou air vraiment propreAttends 20 minutes, souffle sur le capteur pour tester
Les valeurs dérivent lentementLe baseline est remis à zéro à chaque démarrageSauvegarde le baseline et restaure-le après 20 minutes
eCO2 à des milliers de ppm sans personneSource de COV comme parfum, alcool ou peintureRappelle-toi que l'eCO2 est estimé à partir des COV, éloigne la source
readData() renvoie une erreurFil mal fixé, ligne I2C longue ou alimentation trop faibleRaccourcis les fils, mesure le 3,3 V, lis le code avec checkError()
Température plus haute que la réalitéBME280 près de l'élément chauffantÉloigne le BME280 du CCS811 ou applique une correction fixe sur un module combiné
Le fabricant recommande désormais le capteur ENS160, plus récent, à la place du CCS811. Si tu conçois un nouveau projet, tu peux aussi regarder l'ENS160 ; mais le CCS811 que tu as servira encore des années avec les étapes de ce guide.

Idées de projets

  • Alerte d'aération pour classe ou bureau : une LED rouge et un bref bip de buzzer quand l'eCO2 dépasse 1000 ppm.
  • Surveillance des COV en cuisine : suivre la hausse du TVOC pendant la cuisson et allumer automatiquement la hotte avec un relais.
  • Enregistrement dans le cloud : écrire les mesures dans Google Sheets avec un ESP32 et tracer des courbes journalières et hebdomadaires.
  • Intégration domotique : envoyer les valeurs à Home Assistant en MQTT et créer une alerte fenêtre ouverte ou une ventilation automatique.
  • Mesureur portable sur batterie : un appareil en mode de mesure 60 secondes avec un petit écran OLED, à emporter de pièce en pièce.

Bien câblé et en respectant les règles de chauffe et de baseline, le CCS811 est un capteur pratique qui montre de façon fiable les variations de l'air intérieur. Dans l'application BlueGrays, tu trouveras des projets comme un capteur de gaz, une alarme flamme et gaz, la mesure de température et d'humidité avec DHT11 et DHT22 et une station météo ESP32 avec écran OLED, chacun avec schéma et code pas à pas ; construis par-dessus l'indicateur CCS811 de ce guide.

Questions fréquentes

Que mesure le capteur CCS811 ?

Le CCS811 est un capteur à oxyde métallique qui mesure les composés organiques volatils (COV) de l'air. Il fournit le TVOC en ppb et l'eCO2 en ppm. L'eCO2 est un équivalent dioxyde de carbone estimé à partir des COV.

Le CCS811 mesure-t-il le vrai CO2 ?

Non. L'eCO2 du CCS811 est estimé à partir de la hausse des COV et ne mesure pas directement le vrai CO2. Pour mesurer le CO2 réel, il faut un capteur NDIR comme le MH-Z19, le SCD30 ou le SCD40.

Où brancher la broche WAK du CCS811 ?

La broche WAK (nWAKE) doit être reliée au GND. Tant qu'elle est à l'état bas, le capteur répond sur le bus I2C ; si elle reste en l'air ou à l'état haut, il reste endormi et l'Arduino ne le trouve pas. Sur les modules CJMCU-811, tu dois faire ce branchement toi-même.

Combien de temps le CCS811 met-il à chauffer ?

Le CCS811 a besoin d'environ 20 minutes de chauffe à chaque mise sous tension. Un capteur neuf doit aussi passer une fois dans sa vie par un rodage initial d'environ 48 heures. Les valeurs lues pendant ces périodes ne sont pas fiables.

Qu'est-ce que le baseline du CCS811 ?

Le baseline est la valeur de référence que le capteur garde pour l'air propre. Il est perdu à chaque coupure, il faut donc le lire avec getBaseline() après un long fonctionnement, le sauvegarder et le restaurer avec setBaseline() après les 20 minutes de chauffe du démarrage suivant.

Le CCS811 fonctionne-t-il avec un Arduino en 5V ?

La puce CCS811 accepte au maximum 3,6 V et la plupart des modules CJMCU-811 n'ont pas de régulateur. Alimente le module par la broche 3.3V de l'Arduino. Pour un usage durable avec les lignes I2C en 5 V de l'Uno, un convertisseur de niveau logique est recommandé.

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 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
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
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
Écran LCD I2C ESP32 (16x2)
ES-17Intermédiaire
Premium

Écran LCD I2C ESP32 (16x2)

Dans ce projet, on relie un écran LCD 16x2 caractères à l'ESP32 en I2C pour afficher du texte. Grâce à l'I2C, 2 broches de données (SDA et SCL) suffisent, au lieu des 6+ broches d'un branchement parallèle classique. Le code affiche un message fixe sur la première ligne et un compteur qui augmente chaque seconde sur la deuxième. Au démarrage, un scanner I2C écrit l'adresse de l'écran dans le Serial Monitor (souvent 0x27 ou 0x3F).

4.9(23)
40