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.

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éristique | Valeur |
|---|---|
| Type de capteur | Oxyde métallique (MOX) avec microcontrôleur intégré |
| Sorties | eCO2 (400–8192 ppm), TVOC (0–1187 ppb), données de résistance brutes |
| Interface | I2C, adresse 0x5A (ADD au GND) ou 0x5B (ADD au VCC) |
| Alimentation | 1,8–3,6 V (alimente le module CJMCU-811 en 3,3 V) |
| Courant | Environ 30 mA en mode 1 seconde à cause de l'élément chauffant, bien moins en moyenne en mode 60 secondes |
| Modes de mesure | Mode 1 : 1 s, mode 2 : 10 s, mode 3 : 60 s, mode 4 : 250 ms (données brutes uniquement) |
| Chauffe | 20 minutes à chaque mise sous tension |
| Rodage initial (burn-in) | 48 heures pour un capteur neuf |
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 CCS811 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 3.3V | 3V3 | 3V3 (OUT) |
| GND | GND | GND | GND |
| SDA | A4 | GPIO 21 | GP4 |
| SCL | A5 | GPIO 22 | GP5 |
| WAK | GND | GND | GND |
| ADD | GND (0x5A) | GND (0x5A) | GND (0x5A) |
| INT | Non connectée (D2 en option) | Non connectée | Non connectée |
| RST | Non connectée | Non connectée | Non connectée |
Première mesure avec un Arduino Uno
- Ouvre le gestionnaire de bibliothèques de l'IDE Arduino, cherche Adafruit CCS811 et installe-la avec ses dépendances.
- Câble le module selon le tableau ci-dessus ; n'oublie pas de relier WAK et ADD au GND.
- Téléverse le sketch ci-dessous et ouvre le moniteur série à 9600 bauds.
- 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.
- 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.
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}| Fonction | Rô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) |
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ériode | Quand ? | Que faire ? |
|---|---|---|
| 48 premières heures (burn-in) | Une fois dans la vie du capteur | Laisse 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 alimentation | Affiche en chauffe, restaure le baseline sauvegardé à la fin de cette période |
| Après un changement de mode | En passant à un mode plus lent | Attends 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.

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}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ément | Broche ESP32 | Remarque |
|---|---|---|
| SDA du CCS811, du BME280 et de l'OLED | GPIO 21 | Les trois modules sur la même ligne |
| SCL du CCS811, du BME280 et de l'OLED | GPIO 22 | Les trois modules sur la même ligne |
| WAK et ADD du CCS811 | GND | Adresse 0x5A |
| LED verte | GPIO 25 | Avec une résistance de 220 Ω, eCO2 sous 800 ppm |
| LED jaune | GPIO 26 | Avec une résistance de 220 Ω, 800–1199 ppm |
| LED rouge | GPIO 27 | Avec une résistance de 220 Ω, 1200 ppm et plus |
| VCC de tous les modules | 3V3 | Masses communes |
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éciation | Que faire ? |
|---|---|---|---|
| 400–799 | 0–219 | Bonne | Rien à faire |
| 800–999 | 220–659 | Moyenne | Aère quand tu peux |
| 1000–1499 | 660–2199 | Mauvaise | Ouvre la fenêtre, cherche la source de COV |
| 1500 et plus | 2200 et plus | Très mauvaise | Aè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.
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.

| Caractéristique | CCS811 | MQ-135 |
|---|---|---|
| Sortie | Numérique I2C : eCO2 et TVOC | Tension analogique (et une broche numérique de seuil) |
| Alimentation | 3,3 V | 5 V |
| Courant | Environ 30 mA (mode 1 s), bien moins dans les modes lents | Environ 150 mA |
| Étalonnage | Algorithme intégré et baseline | Manuel, mesure de R0 en air propre |
| Chauffe | 20 min, 48 heures à la première utilisation | Quelques minutes, 24 à 48 heures à la première utilisation |
| Usage sur batterie | Adapté (mode 60 s) | Inadapté |
| Prix | Plus cher | Moins cher |
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| begin() renvoie false | Broche WAK en l'air ou mauvaise adresse | Relie WAK au GND, vérifie 0x5A ou 0x5B avec un scanner I2C |
| eCO2 toujours à 400, TVOC toujours à 0 | Chauffe en cours ou air vraiment propre | Attends 20 minutes, souffle sur le capteur pour tester |
| Les valeurs dérivent lentement | Le baseline est remis à zéro à chaque démarrage | Sauvegarde le baseline et restaure-le après 20 minutes |
| eCO2 à des milliers de ppm sans personne | Source de COV comme parfum, alcool ou peinture | Rappelle-toi que l'eCO2 est estimé à partir des COV, éloigne la source |
| readData() renvoie une erreur | Fil mal fixé, ligne I2C longue ou alimentation trop faible | Raccourcis 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é |
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é.
Projets à réaliser après cet article
Voir tous les projets
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…

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…

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.

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.

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().

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.

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.

É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).
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

