Componenti · 9 min di lettura

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.

Modulo sensore di qualità dell'aria CJMCU-811 con CCS811
Il modulo CJMCU-811: sensore CCS811 con i pin VCC, GND, SCL, SDA, WAK, INT, RST e ADD.

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.

CaratteristicaValore
Tipo di sensoreOssido metallico (MOX) con microcontrollore integrato
UsciteeCO2 (400–8192 ppm), TVOC (0–1187 ppb), dati grezzi di resistenza
InterfacciaI2C, indirizzo 0x5A (ADD a GND) o 0x5B (ADD a VCC)
Alimentazione1,8–3,6 V (alimenta il modulo CJMCU-811 a 3,3 V)
CorrenteCirca 30 mA in modalità 1 secondo per il riscaldatore, molto meno in media in modalità 60 secondi
Modalità di misuraModo 1: 1 s, Modo 2: 10 s, Modo 3: 60 s, Modo 4: 250 ms (solo dati grezzi)
Riscaldamento20 minuti a ogni accensione
Rodaggio iniziale (burn-in)48 ore per un sensore nuovo
L'eCO2 non è vera CO2. Se nella stanza non ci sono fonti di COV (per esempio quando la CO2 si accumula in una stanza vuota), l'eCO2 può restare bassa; se spruzzi un profumo o usi alcol, l'eCO2 schizza a migliaia di ppm anche se nella stanza non c'è nessuno. Le decisioni sulla ventilazione o il controllo della CO2 in luoghi come le aule vanno prese con sensori NDIR che misurano la CO2 reale (come MH-Z19, SCD30 o SCD40). Il CCS811 è adatto a seguire le variazioni dei COV e l'andamento generale della qualità dell'aria.

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 CCS811Arduino UnoESP32Raspberry Pi Pico
VCC3.3V3V33V3 (OUT)
GNDGNDGNDGND
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
WAKGNDGNDGND
ADDGND (0x5A)GND (0x5A)GND (0x5A)
INTScollegato (opzionale D2)ScollegatoScollegato
RSTScollegatoScollegatoScollegato
Il chip CCS811 lavora al massimo a 3,6 V e la maggior parte dei moduli CJMCU-811 non ha regolatore; non collegare VCC al pin 5V di Arduino. Le linee I2C dell'Uno sono a 5 V, quindi in un progetto definitivo la via più sicura è inserire un convertitore di livello logico. ESP32 e Pico lavorano già a 3,3 V e si collegano direttamente. Le regole generali del bus I2C sono spiegate nell'articolo cos'è l'I2C.

Prima lettura con Arduino Uno

  1. Apri il Gestore librerie dell'IDE Arduino, cerca Adafruit CCS811 e installala con le sue dipendenze.
  2. Collega il modulo secondo la tabella qui sopra; non dimenticare di portare WAK e ADD a GND.
  3. Carica lo sketch qui sotto e apri il Monitor seriale a 9600 baud.
  4. 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.
  5. Fai una prova vicino a un pennarello, a un gel igienizzante o al tuo respiro; vedrai salire TVOC ed eCO2 in pochi secondi.
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}
FunzioneCompito
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)
Se ccs.begin() restituisce false, controlla prima che WAK sia a GND. Poi verifica l'indirizzo con uno sketch scanner I2C: se il dispositivo compare a 0x5B, ADD è collegato a VCC e ti serve begin(0x5B). Su alcune schede come l'ESP8266 il clock stretching I2C del CCS811 può creare problemi; con ESP32, Uno e Pico di solito va tutto liscio.

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.

PeriodoQuando?Cosa fare?
Prime 48 ore (burn-in)Una volta nella vita del sensoreTieni il sensore sempre acceso, non fidarti dei valori, non salvare il baseline
20 minuti a ogni accensione (run-in)Ogni volta che viene alimentatoMostra in riscaldamento sul display, ripristina il baseline salvato alla fine di questo periodo
Dopo un cambio di modalitàPassando a una modalità più lentaAttendi 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.

Sensore di temperatura, umidità e pressione BME280
Il BME280 condivide il bus I2C con il CCS811 e fornisce i dati per la compensazione di temperatura e umidità.
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}
Il riscaldatore del CCS811 scalda il modulo di qualche grado. Nei moduli combinati in cui CCS811 e BME280 stanno sulla stessa scheda (come il CJMCU-8128), il BME280 può leggere 2–5 °C in più della temperatura reale della stanza. Se usi moduli separati, metti il BME280 a qualche centimetro dal CCS811. L'indirizzo di un modulo BME280 può essere 0x76 o 0x77; se begin() fallisce, prova l'altro.

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.

PartePin ESP32Nota
SDA di CCS811, BME280 e OLEDGPIO 21Tutti e tre i moduli sulla stessa linea
SCL di CCS811, BME280 e OLEDGPIO 22Tutti e tre i moduli sulla stessa linea
WAK e ADD del CCS811GNDIndirizzo 0x5A
LED verdeGPIO 25Con resistenza da 220 Ω, eCO2 sotto 800 ppm
LED gialloGPIO 26Con resistenza da 220 Ω, 800–1199 ppm
LED rossoGPIO 27Con resistenza da 220 Ω, da 1200 ppm in su
VCC di tutti i moduli3V3Masse in comune
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}

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)GiudizioCosa fare?
400–7990–219BuonaNiente
800–999220–659DiscretaArieggia quando puoi
1000–1499660–2199ScarsaApri la finestra, trova la fonte di COV
1500 e oltre2200 e oltrePessimaArieggia 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.

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.

Sensore di qualità dell'aria MQ-135
L'MQ-135 fornisce un'uscita analogica e il suo riscaldatore a 5 V assorbe molta più corrente del CCS811.
CaratteristicaCCS811MQ-135
UscitaDigitale I2C: eCO2 e TVOCTensione analogica (e un pin digitale di soglia)
Alimentazione3,3 V5 V
CorrenteCirca 30 mA (modo 1 s), molto meno nelle modalità lenteCirca 150 mA
CalibrazioneAlgoritmo integrato e baselineManuale, misurando R0 in aria pulita
Riscaldamento20 min, 48 ore al primo utilizzoPochi minuti, 24–48 ore al primo utilizzo
Uso a batteriaAdatto (modo 60 s)Non adatto
PrezzoPiù caroPiù economico

Errori comuni e soluzioni

SintomoCausa probabileSoluzione
begin() restituisce falsePin WAK scollegato o indirizzo sbagliatoCollega WAK a GND, controlla 0x5A o 0x5B con uno scanner I2C
eCO2 sempre 400, TVOC sempre 0Riscaldamento in corso o aria davvero pulitaAspetta 20 minuti, prova soffiando sul sensore
I valori derivano lentamenteIl baseline si azzera a ogni accensioneSalva il baseline e ripristinalo dopo 20 minuti
eCO2 a migliaia di ppm senza nessuno nella stanzaFonte di COV come profumo, alcol o verniceRicorda che l'eCO2 è stimata dai COV, allontana la fonte
readData() restituisce un erroreFilo allentato, linea I2C lunga o alimentazione bassaAccorcia i fili, misura i 3,3 V, leggi il codice con checkError()
Temperatura più alta del realeBME280 vicino al riscaldatoreAllontana il BME280 dal CCS811 o applica una correzione fissa sul modulo combinato
Il produttore oggi consiglia al posto del CCS811 il più recente ENS160. Se stai progettando un nuovo progetto puoi valutare anche l'ENS160; ma il CCS811 che hai già ti servirà per anni seguendo i passaggi di questa guida.

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.

Vedi tutti i progetti
Temperatura e umidità con DHT11
AR-55Intermedio

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…

4.7(47)
83
Utilizzo del sensore di gas
AR-51Principiante
Premium

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…

4.6(37)
50
Allarme del sensore di fiamma e gas
AR-52Avanzato
Premium

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.

4.8(52)
67
ESP32 DHT22 Temperatura e umidità (con display LCD)
ES-15Intermedio

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.

4.8(38)
57
Allarme rilevatore di gas/fumo ESP32 MQ-2
ES-20Intermedio

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

4.7(29)
44
ESP32 HTTPClient + API meteo (con display OLED SSD1306)
ES-32Avanzato
Premium

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.

4.3(10)
22
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

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.

4.7(7)
12
Schermo LCD I2C per ESP32 (16x2)
ES-17Intermedio
Premium

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

4.9(23)
40