CCS811 Arduino: sensore di qualità dell'aria con eCO2 e TVOC
CCS811 con Arduino: misurare eCO2 e TVOC, I2C e pin WAK, 20 minuti di riscaldamento e 48 ore di rodaggio, salvare il baseline, compensazione BME280 ed ESP32.
Il CCS811 è un piccolo sensore di gas digitale con interfaccia I2C che si usa nei progetti Arduino per misurare la qualità dell'aria interna. Rileva i composti organici volatili (COV o VOC) nella stanza e fornisce due valori: il TVOC (composti organici volatili totali) in ppb e l'eCO2 (anidride carbonica equivalente) in ppm. Il piccolo processore interno gestisce il riscaldatore, elabora la misura grezza con un proprio algoritmo e ti restituisce numeri già pronti. Così, a differenza dei sensori analogici della serie MQ, leggi valori sensati con poche righe di codice senza lottare con formule di calibrazione.
In questa guida spiegheremo come funziona il CCS811, perché l'eCO2 non è vera CO2 e l'ostacolo più comune: il pin WAK. Faremo la prima lettura con un Arduino Uno e vedremo il riscaldamento di 20 minuti, il rodaggio iniziale di 48 ore, il salvataggio del baseline e la compensazione di temperatura e umidità con un BME280. Poi costruiremo con un ESP32 un indicatore della qualità dell'aria interna con OLED e LED, scriveremo codice MicroPython senza librerie per il Raspberry Pi Pico e confronteremo il CCS811 con l'MQ-135.

Cos'è il CCS811 e come funziona?
Il CCS811 è un sensore di gas a ossido metallico (MOX). Al suo interno c'è un minuscolo riscaldatore con sopra uno strato sensibile ai gas. Quando nell'aria aumentano alcol, acetone, formaldeide, profumi, detergenti o i composti organici del respiro umano, la resistenza di questo strato cambia. Il microcontrollore interno misura questa resistenza, la corregge con i dati di temperatura e umidità e calcola il risultato come TVOC. L'eCO2 invece non viene misurata ma stimata: in una stanza chiusa le persone producono sia CO2 sia COV, e l'algoritmo stima di quanto è probabilmente salita la CO2 a partire dall'aumento dei COV. Gli intervalli sono 400–8192 ppm per l'eCO2 e 0–1187 ppb per il TVOC; il valore minimo mostrato è 400 ppm, perché è il livello medio di CO2 dell'aria esterna.
| Caratteristica | Valore |
|---|---|
| Tipo di sensore | Ossido metallico (MOX) con microcontrollore integrato |
| Uscite | eCO2 (400–8192 ppm), TVOC (0–1187 ppb), dati grezzi di resistenza |
| Interfaccia | I2C, indirizzo 0x5A (ADD a GND) o 0x5B (ADD a VCC) |
| Alimentazione | 1,8–3,6 V (alimenta il modulo CJMCU-811 a 3,3 V) |
| Corrente | Circa 30 mA in modalità 1 secondo per il riscaldatore, molto meno in media in modalità 60 secondi |
| Modalità di misura | Modo 1: 1 s, Modo 2: 10 s, Modo 3: 60 s, Modo 4: 250 ms (solo dati grezzi) |
| Riscaldamento | 20 minuti a ogni accensione |
| Rodaggio iniziale (burn-in) | 48 ore per un sensore nuovo |
Pinout del CCS811 e collegamento
La scheda CCS811 più diffusa è il modulo CJMCU-811. Ha otto pin, e quattro di questi, VCC, GND, SDA e SCL, si collegano come in qualsiasi sensore I2C. Il pin che fa la differenza è WAK (nWAKE). Finché è a livello basso il sensore ascolta il bus I2C; se è alto o scollegato resta addormentato e non ti risponde. Sul modulo CJMCU-811 il pin WAK non è collegato a GND sulla scheda, quindi devi collegarlo tu a GND. Il pin ADD sceglie l'indirizzo: 0x5A se è a GND, 0x5B se è a VCC. INT segnala con un interrupt che ci sono nuovi dati e RST serve per il reset hardware; nella prima prova puoi lasciarli entrambi scollegati.
| Pin del 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 | Scollegato (opzionale D2) | Scollegato | Scollegato |
| RST | Scollegato | Scollegato | Scollegato |
Prima lettura con Arduino Uno
- Apri il Gestore librerie dell'IDE Arduino, cerca Adafruit CCS811 e installala con le sue dipendenze.
- Collega il modulo secondo la tabella qui sopra; non dimenticare di portare WAK e ADD a GND.
- Carica lo sketch qui sotto e apri il Monitor seriale a 9600 baud.
- Nei primi minuti l'eCO2 può restare intorno a 400 e il TVOC intorno a 0; i valori si assestano man mano che il sensore si scalda.
- Fai una prova vicino a un pennarello, a un gel igienizzante o al tuo respiro; vedrai salire TVOC ed eCO2 in pochi secondi.
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}| Funzione | Compito |
|---|---|
| ccs.begin(0x5A) | Resetta il sensore, verifica il suo ID (0x81) e avvia l'applicazione; restituisce false in caso di errore |
| setDriveMode() | Sceglie la frequenza di misura: 1SEC, 10SEC, 60SEC, 250MS o IDLE |
| available() | Restituisce true quando è pronta una nuova misura |
| readData() | Legge il risultato; se restituisce 0 la lettura è andata a buon fine |
| geteCO2() / getTVOC() | Gli ultimi valori letti di eCO2 (ppm) e TVOC (ppb) |
20 minuti di riscaldamento e 48 ore di rodaggio
Un sensore MOX non misura correttamente finché il suo strato non raggiunge una certa temperatura e si stabilizza. Il CCS811 ha due periodi distinti che spesso si confondono. Il riscaldamento (run-in) è il periodo di circa 20 minuti necessario a ogni accensione; i valori letti in questo tempo non sono realistici ed è giusto mostrare "in riscaldamento" sul display. Il rodaggio iniziale (burn-in) è il periodo di circa 48 ore che un sensore nuovo attraversa una sola volta nella vita; in questo tempo lo strato si assesta chimicamente. Far funzionare un sensore appena acquistato per 48 ore senza interruzioni prima di montarlo nel progetto migliora sensibilmente la stabilità delle misure successive.
| Periodo | Quando? | Cosa fare? |
|---|---|---|
| Prime 48 ore (burn-in) | Una volta nella vita del sensore | Tieni il sensore sempre acceso, non fidarti dei valori, non salvare il baseline |
| 20 minuti a ogni accensione (run-in) | Ogni volta che viene alimentato | Mostra in riscaldamento sul display, ripristina il baseline salvato alla fine di questo periodo |
| Dopo un cambio di modalità | Passando a una modalità più lenta | Attendi le prime misure della nuova modalità |
Cos'è il baseline e perché salvarlo?
Il CCS811 conserva un valore di riferimento per l'aria pulita chiamato baseline. L'algoritmo regola da solo questo riferimento nel tempo, in base all'aria più pulita che ha visto. Il problema: ogni volta che il sensore resta senza alimentazione il baseline si azzera e i valori possono derivare finché l'algoritmo non lo reimpara. La soluzione è leggere il baseline con getBaseline() quando il sensore funziona bene da molto tempo, scriverlo in una memoria permanente e ripristinarlo con setBaseline() dopo i 20 minuti di riscaldamento all'accensione successiva. Il baseline è un numero di due byte senza un significato leggibile; lo salvi e lo restituisci soltanto. Il produttore consiglia di salvarlo ogni giorno nella prima settimana dopo il rodaggio e poi ogni qualche settimana. Su Arduino puoi scriverlo nella EEPROM, sull'ESP32 nella flash con Preferences. È importante che il sensore abbia visto aria pulita prima del salvataggio; bastano pochi minuti di ricambio d'aria.
Compensazione di temperatura e umidità con BME280
Per impostazione predefinita l'algoritmo del CCS811 presume che la stanza sia a 25 °C e al 50 per cento di umidità. Più i valori reali se ne allontanano, più i calcoli di TVOC ed eCO2 deviano. Se comunichi al sensore i valori reali con setEnvironmentalData(umidità, temperatura), l'algoritmo ne tiene conto. Fai attenzione all'ordine: nella libreria Adafruit viene prima l'umidità e poi la temperatura. Il sensore memorizza l'umidità a passi di 1/512 %UR e la temperatura a passi di 1/512 °C con uno scostamento di -25 °C; la libreria fa la conversione per te. Il sensore più adatto è un BME280 sullo stesso bus I2C. Se non hai mai usato un BME280, dai un'occhiata all'articolo sensore BME280 e 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}Indicatore della qualità dell'aria interna con ESP32
Ora mettiamo tutto insieme: l'ESP32 leggerà eCO2 e TVOC ogni due secondi, compenserà con il BME280, mostrerà i risultati su un OLED da 0,96 pollici e indicherà lo stato dell'aria a colori con tre LED. Durante il riscaldamento il display mostra "Isiniyor" (in riscaldamento); dopo 20 minuti il codice ripristina il baseline salvato e, quando la scheda ha funzionato per 48 ore, salva il baseline nella flash una volta al giorno. I quattro dispositivi I2C condividono gli stessi due fili; avendo indirizzi diversi, non ci sono conflitti.
| Parte | Pin ESP32 | Nota |
|---|---|---|
| SDA di CCS811, BME280 e OLED | GPIO 21 | Tutti e tre i moduli sulla stessa linea |
| SCL di CCS811, BME280 e OLED | GPIO 22 | Tutti e tre i moduli sulla stessa linea |
| WAK e ADD del CCS811 | GND | Indirizzo 0x5A |
| LED verde | GPIO 25 | Con resistenza da 220 Ω, eCO2 sotto 800 ppm |
| LED giallo | GPIO 26 | Con resistenza da 220 Ω, 800–1199 ppm |
| LED rosso | GPIO 27 | Con resistenza da 220 Ω, da 1200 ppm in su |
| VCC di tutti i moduli | 3V3 | Masse in comune |
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}Nel codice misuriamo il tempo di funzionamento con esp_timer_get_time() invece di millis(); restituisce i microsecondi come numero a 64 bit, quindi non c'è overflow in un indicatore che funziona per mesi. Il baseline viene scritto con la libreria Preferences in uno spazio chiamato "ccs811" e sopravvive agli spegnimenti. Per le librerie basta installare Adafruit CCS811, Adafruit BME280 e Adafruit SSD1306 con le loro dipendenze. Per i dettagli dell'OLED, guarda l'articolo display OLED SSD1306.
| eCO2 (ppm) | TVOC (ppb) | Giudizio | Cosa fare? |
|---|---|---|---|
| 400–799 | 0–219 | Buona | Niente |
| 800–999 | 220–659 | Discreta | Arieggia quando puoi |
| 1000–1499 | 660–2199 | Scarsa | Apri la finestra, trova la fonte di COV |
| 1500 e oltre | 2200 e oltre | Pessima | Arieggia subito, non restare a lungo |
I limiti della tabella sono valori indicativi molto usati negli indicatori della qualità dell'aria interna; non sono limiti di legge, ma una scala di orientamento. Registrare i dati a casa per qualche giorno e osservare come cambiano al mattino, mentre cucini e dopo le pulizie è il modo migliore per adattare le soglie al tuo ambiente.
CCS811 con Raspberry Pi Pico (MicroPython)
Sul Pico puoi usare il CCS811 in MicroPython senza installare librerie, scrivendo direttamente nei suoi registri. Il flusso è lo stesso della libreria Adafruit: prima si legge 0x81 dal registro di identificazione (0x20), si esegue un reset software, si avvia l'applicazione (0xF4) e si sceglie la modalità di misura (0x01). Poi, ogni volta che il bit DATA_READY del registro di stato vale 1, si leggono quattro byte dal registro dei risultati (0x02). Il codice contiene anche una piccola funzione che scrive umidità e temperatura nel registro ambientale (0x05). Se sei alle prime armi con MicroPython, leggi prima l'articolo basi di 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 o MQ-135?
Entrambi sono venduti come "sensore di qualità dell'aria", ma funzionano in modo molto diverso. L'MQ-135 è analogico: il suo riscaldatore alimentato a 5 V assorbe circa 150 mA, l'uscita è una tensione e per calcolare i ppm devi fare tu la calibrazione. Il CCS811 è digitale, consuma poco e fornisce valori di eCO2 e TVOC già pronti. Trovi i passaggi dettagliati di calibrazione nell'articolo sensore di qualità dell'aria MQ135.

| Caratteristica | CCS811 | MQ-135 |
|---|---|---|
| Uscita | Digitale I2C: eCO2 e TVOC | Tensione analogica (e un pin digitale di soglia) |
| Alimentazione | 3,3 V | 5 V |
| Corrente | Circa 30 mA (modo 1 s), molto meno nelle modalità lente | Circa 150 mA |
| Calibrazione | Algoritmo integrato e baseline | Manuale, misurando R0 in aria pulita |
| Riscaldamento | 20 min, 48 ore al primo utilizzo | Pochi minuti, 24–48 ore al primo utilizzo |
| Uso a batteria | Adatto (modo 60 s) | Non adatto |
| Prezzo | Più caro | Più economico |
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| begin() restituisce false | Pin WAK scollegato o indirizzo sbagliato | Collega WAK a GND, controlla 0x5A o 0x5B con uno scanner I2C |
| eCO2 sempre 400, TVOC sempre 0 | Riscaldamento in corso o aria davvero pulita | Aspetta 20 minuti, prova soffiando sul sensore |
| I valori derivano lentamente | Il baseline si azzera a ogni accensione | Salva il baseline e ripristinalo dopo 20 minuti |
| eCO2 a migliaia di ppm senza nessuno nella stanza | Fonte di COV come profumo, alcol o vernice | Ricorda che l'eCO2 è stimata dai COV, allontana la fonte |
| readData() restituisce un errore | Filo allentato, linea I2C lunga o alimentazione bassa | Accorcia i fili, misura i 3,3 V, leggi il codice con checkError() |
| Temperatura più alta del reale | BME280 vicino al riscaldatore | Allontana il BME280 dal CCS811 o applica una correzione fissa sul modulo combinato |
Idee di progetto
- Avviso di ricambio d'aria per aula o ufficio: un LED rosso e un breve bip del buzzer quando l'eCO2 supera 1000 ppm.
- Monitor dei COV in cucina: seguire l'aumento del TVOC mentre cucini e accendere automaticamente la cappa con un relè.
- Registrazione nel cloud: scrivere le misure su Google Sheets con un ESP32 e ottenere grafici giornalieri e settimanali.
- Integrazione domotica: inviare i valori a Home Assistant via MQTT e creare un avviso di finestra aperta o una ventilazione automatica.
- Misuratore portatile a batteria: un dispositivo con modalità di misura a 60 secondi e un piccolo OLED da portare di stanza in stanza.
Collegato correttamente e rispettando le regole di riscaldamento e baseline, il CCS811 è un sensore pratico che mostra in modo affidabile le variazioni dell'aria interna. Nell'app BlueGrays trovi progetti come un sensore di gas, un allarme fiamma e gas, la misura di temperatura e umidità con DHT11 e DHT22 e una stazione meteo con ESP32 e OLED, ognuno con schema e codice passo per passo; costruisci sopra di essi l'indicatore CCS811 di questa guida.
Domande frequenti
Cosa misura il sensore CCS811?
Il CCS811 è un sensore a ossido metallico che misura i composti organici volatili (COV) nell'aria. Fornisce il TVOC in ppb e l'eCO2 in ppm. L'eCO2 è un valore di anidride carbonica equivalente stimato a partire dai COV.
Il CCS811 misura la vera CO2?
No. L'eCO2 del CCS811 è stimata dall'aumento dei COV e non misura direttamente la CO2 reale. Per la CO2 reale serve un sensore NDIR come MH-Z19, SCD30 o SCD40.
Dove si collega il pin WAK del CCS811?
Il pin WAK (nWAKE) va collegato a GND. Finché è basso, il sensore risponde sul bus I2C; se resta scollegato o alto, il sensore dorme e Arduino non lo trova. Sui moduli CJMCU-811 questo collegamento devi farlo tu.
Quanto tempo impiega il CCS811 a scaldarsi?
Il CCS811 ha bisogno di circa 20 minuti di riscaldamento a ogni accensione. Un sensore nuovo deve inoltre passare una volta nella vita un rodaggio iniziale di circa 48 ore. I valori letti in questi periodi non sono affidabili.
Cos'è il baseline del CCS811?
Il baseline è il valore di riferimento che il sensore conserva per l'aria pulita. Si perde a ogni interruzione di alimentazione, quindi dopo un lungo funzionamento va letto con getBaseline(), salvato e ripristinato con setBaseline() dopo i 20 minuti di riscaldamento all'accensione successiva.
Il CCS811 funziona con Arduino a 5V?
Il chip CCS811 lavora al massimo a 3,6 V e la maggior parte dei moduli CJMCU-811 non ha regolatore. Alimenta il modulo dal pin 3.3V di Arduino. Per un uso permanente con le linee I2C a 5 V dell'Uno è consigliato un convertitore di livello logico.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Temperatura e umidità con DHT11
Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

Utilizzo del sensore di gas
Un piccolo guardiano che si accorge di una fuga di gas in cucina prima di te. Il sensore di gas annusa l'aria di continuo; finché va tutto bene resta acceso il LED verde, e quando il gas nell'aria…

Allarme del sensore di fiamma e gas
Un piccolo guardiano che ti avvisa subito se c'è una fuga di gas o compare una fiamma da qualche parte.

ESP32 DHT22 Temperatura e umidità (con display LCD)
Si tratta di un progetto che misura la temperatura e l'umidità dell'ambiente tramite il sensore DHT22 e le visualizza in tempo reale su un display LCD I2C 16x2. I dati vengono letti dal sensore utilizzando il protocollo one-wire tramite la libreria Adafruit DHT. Questo progetto costituisce la base per stazioni meteorologiche IoT, sistemi di automazione domestica intelligente o sistemi di monitoraggio ambientale nelle serre. La comunicazione con il DHT22 avviene tramite il pin GPIO 4 dell'ESP32.

Allarme rilevatore di gas/fumo ESP32 MQ-2
In questo progetto, il rilevamento di gas combustibili (GPL, metano, propano) e fumo viene effettuato tramite un modulo sensore di gas MQ-2; al rilevamento viene emesso un segnale acustico simile a una sirena tramite un cicalino passivo. L'uscita digitale di soglia (DO) del sensore viene collegata al GPIO 4 dell'ESP32; quando gas o fumo superano la soglia, DO passa a LOW e l'allarme si attiva. La sensibilità si regola tramite il potenziometro del modulo. Il cicalino è pilotato con tone().

ESP32 HTTPClient + API meteo (con display OLED SSD1306)
L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. A differenza della versione con LCD I2C, qui usiamo un display OLED SSD1306 (128×64), con testo grande e icone vettoriali per una resa più ricca. Sette icone meteo (sole, pioggia, neve e altre) vengono disegnate al volo, senza file bitmap.

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

Schermo LCD I2C per ESP32 (16x2)
In questo progetto colleghiamo un display LCD 16x2 a caratteri all'ESP32 tramite I2C per mostrare del testo. Con l'I2C bastano 2 pin dati (SDA e SCL) invece dei 6+ pin di un collegamento parallelo classico. Il codice scrive un messaggio fisso sulla prima riga e un contatore che sale ogni secondo sulla seconda. All'avvio uno scanner I2C stampa l'indirizzo del display sul Serial Monitor (di solito 0x27 o 0x3F).
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

