CCS811 com Arduino: guia do sensor de qualidade do ar com eCO2 e TVOC
Guia do CCS811 com Arduino: leituras de eCO2 e TVOC, I2C e pino WAK, aquecimento de 20 minutos e burn-in de 48 horas, como salvar o baseline, compensação com BME280 e ESP32.
Em projetos com CCS811 e Arduino, este pequeno sensor de gás digital com interface I2C é usado para medir a qualidade do ar em ambientes internos. Ele detecta os compostos orgânicos voláteis (VOCs) do ambiente e fornece dois valores: TVOC (compostos orgânicos voláteis totais) em ppb e eCO2 (dióxido de carbono equivalente) em ppm. O pequeno processador interno controla o aquecedor, processa a medição bruta com seu próprio algoritmo e entrega números prontos. Por isso, ao contrário dos sensores analógicos da série MQ, você consegue ler valores com significado em poucas linhas de código, sem brigar com fórmulas de calibração.
Neste guia vamos explicar como o CCS811 funciona, por que o eCO2 não é CO2 real e o ponto onde mais gente trava: o pino WAK. Vamos fazer a primeira leitura com um Arduino Uno, ver o aquecimento de 20 minutos e o burn-in inicial de 48 horas, como salvar o baseline e a compensação de temperatura e umidade com um BME280. Depois vamos montar um indicador de qualidade do ar interno com display OLED e LEDs no ESP32, escrever um código MicroPython sem biblioteca para o Raspberry Pi Pico e comparar o CCS811 com o MQ-135.

O que é o CCS811 e como ele funciona?
O CCS811 é um sensor de gás de óxido metálico (MOX). Dentro dele há um minúsculo aquecedor com uma camada sensível a gases por cima. Conforme aumentam no ar álcool, acetona, formaldeído, perfume, produtos de limpeza ou os compostos orgânicos da respiração humana, a resistência dessa camada muda. O microcontrolador interno do sensor mede essa resistência, corrige com as informações de temperatura e umidade e calcula o resultado como TVOC. Já o eCO2 não é medido, e sim estimado: em um ambiente fechado as pessoas produzem tanto CO2 quanto VOCs, e o algoritmo estima quanto o CO2 provavelmente subiu a partir do aumento de VOCs. As faixas são 400–8192 ppm para eCO2 e 0–1187 ppb para TVOC; o menor valor que o sensor mostra é 400 ppm, porque esse é o nível médio de CO2 do ar externo.
| Característica | Valor |
|---|---|
| Tipo de sensor | Óxido metálico (MOX) com microcontrolador integrado |
| Saídas | eCO2 (400–8192 ppm), TVOC (0–1187 ppb), dados brutos de resistência |
| Interface | I2C, endereço 0x5A (ADD no GND) ou 0x5B (ADD no VCC) |
| Alimentação | 1,8–3,6 V (alimente o módulo CJMCU-811 com 3,3 V) |
| Corrente | Cerca de 30 mA no modo de 1 segundo por causa do aquecedor, bem menos em média no modo de 60 segundos |
| Modos de medição | Modo 1: 1 s, Modo 2: 10 s, Modo 3: 60 s, Modo 4: 250 ms (só dados brutos) |
| Aquecimento | 20 minutos a cada vez que é ligado |
| Burn-in inicial | 48 horas em um sensor novo |
Pinagem e ligação do CCS811
A placa de CCS811 mais comum é o módulo CJMCU-811. Ele tem oito pinos, e quatro deles, VCC, GND, SDA e SCL, são ligados como em qualquer sensor I2C. O pino que faz a diferença é o WAK (nWAKE). Enquanto esse pino está em nível baixo, o sensor escuta o I2C; quando está em nível alto ou solto, o sensor fica dormindo e não responde. No módulo CJMCU-811 o WAK não está ligado ao GND na placa, então você precisa ligá-lo ao GND por conta própria. O pino ADD escolhe o endereço: 0x5A quando ligado ao GND, 0x5B quando ligado ao VCC. O INT gera uma interrupção quando há dados novos prontos e o RST é um reset por hardware; você pode deixar os dois desconectados no primeiro teste.
| Pino do 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 | Não conectado (opcionalmente D2) | Não conectado | Não conectado |
| RST | Não conectado | Não conectado | Não conectado |
Primeira leitura com um Arduino Uno
- Abra o Gerenciador de Bibliotecas na Arduino IDE, busque Adafruit CCS811 e instale-a com as dependências.
- Ligue o módulo conforme a tabela acima; não se esqueça de ligar os pinos WAK e ADD ao GND.
- Carregue o sketch abaixo e abra o Monitor Serial em 9600 baud.
- Nos primeiros minutos o eCO2 pode ficar perto de 400 e o TVOC perto de 0; os valores se estabilizam conforme o sensor aquece.
- Teste perto de uma caneta marca-texto, álcool em gel ou da sua respiração; você verá o TVOC e o eCO2 subirem em poucos segundos.
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}| Função | O que faz |
|---|---|
| ccs.begin(0x5A) (inicialização) | Reinicia o sensor, confere o ID (0x81) e inicia a aplicação; retorna false em caso de falha |
| setDriveMode() (modo de medição) | Escolhe a frequência de medição: 1SEC, 10SEC, 60SEC, 250MS ou IDLE |
| available() (dado novo) | Retorna true quando há uma nova medição pronta |
| readData() (leitura) | Lê o resultado; retorno 0 significa sucesso |
| geteCO2() / getTVOC() (valores) | Os últimos valores lidos de eCO2 (ppm) e TVOC (ppb) |
Aquecimento de 20 minutos e burn-in de 48 horas
Um sensor MOX não mede corretamente até que sua camada chegue a uma certa temperatura e fique estável. O CCS811 tem dois períodos distintos que costumam ser confundidos. O aquecimento (run-in) é o período de cerca de 20 minutos necessário a cada vez que ele é ligado; os valores lidos nesse tempo não são realistas, então o certo é mostrar “aquecendo” no display. O burn-in inicial é o período de cerca de 48 horas pelo qual um sensor novo passa uma única vez na vida; nesse tempo a camada se estabiliza quimicamente. Deixar um sensor recém-comprado funcionando 48 horas sem interrupção antes de colocá-lo no projeto melhora bastante a estabilidade das leituras seguintes.
| Período | Quando? | O que fazer |
|---|---|---|
| Primeiras 48 horas (burn-in) | Uma vez na vida útil do sensor | Deixe o sensor funcionando sem parar, não confie nos valores, não salve o baseline |
| 20 minutos a cada vez que liga (run-in) | Sempre que recebe alimentação | Mostre aquecendo no display, restaure o baseline salvo no fim desse período |
| Depois de trocar de modo | Ao mudar para um modo mais lento | Aguarde as primeiras leituras depois que o novo modo começar |
O que é o baseline e por que salvá-lo?
O CCS811 guarda um valor de referência para ar limpo chamado baseline. O algoritmo ajusta essa referência sozinho ao longo do tempo, com base no ar mais limpo que já viu. O problema: toda vez que o sensor perde a alimentação, o baseline é zerado e os valores podem desviar até o algoritmo aprendê-lo de novo. A solução é ler o baseline com getBaseline() depois que o sensor estiver funcionando bem por bastante tempo, gravá-lo em memória permanente e restaurá-lo com setBaseline() após o aquecimento de 20 minutos na próxima vez que ligar. O baseline é um número de dois bytes sem significado para leitura humana; você só o guarda e devolve. O fabricante recomenda salvá-lo todos os dias na primeira semana após o burn-in e a cada poucas semanas depois disso. No Arduino você pode gravá-lo na EEPROM; no ESP32, na flash com Preferences. É importante que o sensor tenha visto ar limpo antes de salvar; alguns minutos de ventilação bastam.
Compensação de temperatura e umidade com BME280
Por padrão, o algoritmo do CCS811 considera que o ambiente está a 25 °C e 50% de umidade. Quanto mais os valores reais se afastam disso, mais os cálculos de TVOC e eCO2 desviam. Se você informar os valores reais ao sensor com setEnvironmentalData(umidade, temperatura), o algoritmo passa a considerá-los. Atenção à ordem: na biblioteca da Adafruit vem primeiro a umidade, depois a temperatura. O sensor guarda a umidade em passos de 1/512 %RH e a temperatura em passos de 1/512 °C com offset de -25 °C; a biblioteca faz essa conversão para você. O melhor sensor para isso é o BME280 no mesmo barramento I2C. Se você nunca usou um BME280, dê uma olhada no artigo sensor 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}Indicador de qualidade do ar interno com ESP32
Agora vamos juntar tudo: o ESP32 vai ler eCO2 e TVOC a cada dois segundos, compensar com o BME280, mostrar os resultados em um display OLED de 0,96 polegada e usar três LEDs para indicar a condição do ar por cor. Durante o aquecimento o display mostra "Isiniyor" (aquecendo, em turco); depois de 20 minutos ele restaura o baseline salvo e, quando a placa já tiver funcionado por 48 horas, salva o baseline na flash uma vez por dia. Os quatro dispositivos I2C dividem os mesmos dois fios; como os endereços são diferentes, não há conflito.
| Componente | Pino do ESP32 | Observação |
|---|---|---|
| SDA do CCS811, BME280 e OLED | GPIO 21 | Os três módulos na mesma linha |
| SCL do CCS811, BME280 e OLED | GPIO 22 | Os três módulos na mesma linha |
| WAK e ADD do CCS811 | GND | Endereço 0x5A |
| LED verde | GPIO 25 | Com resistor de 220 Ω, eCO2 abaixo de 800 ppm |
| LED amarelo | GPIO 26 | Com resistor de 220 Ω, 800–1199 ppm |
| LED vermelho | GPIO 27 | Com resistor de 220 Ω, 1200 ppm ou mais |
| VCC de todos os módulos | 3V3 | GND comum |
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}No código medimos o tempo de funcionamento com esp_timer_get_time() em vez de millis(); ela retorna microssegundos como um número de 64 bits, então não há estouro em um indicador que fica ligado por meses. O baseline é gravado com a biblioteca Preferences em um namespace chamado "ccs811" e sobrevive quando a placa é desligada e ligada. Na hora de instalar as bibliotecas, basta instalar Adafruit CCS811, Adafruit BME280 e Adafruit SSD1306 com as dependências. Para os detalhes do OLED, veja o artigo display OLED de 0,96 polegada (SSD1306).
| eCO2 (ppm) | TVOC (ppb) | Avaliação | O que fazer |
|---|---|---|---|
| 400–799 | 0–219 | Bom | Nada a fazer |
| 800–999 | 220–659 | Moderado | Ventile quando puder |
| 1000–1499 | 660–2199 | Ruim | Abra uma janela, encontre a fonte de VOC |
| 1500 ou mais | 2200 ou mais | Muito ruim | Ventile já, não fique muito tempo no local |
Os limites da tabela são valores de referência comuns em indicadores de qualidade do ar interno; não são limites legais, apenas uma escala que serve de orientação. Registrar os dados por alguns dias em casa e observar como os valores mudam de manhã, enquanto você cozinha e depois da limpeza é a melhor forma de ajustar os limites ao seu próprio ambiente.
CCS811 com o Raspberry Pi Pico (MicroPython)
No Pico você pode usar o CCS811 com MicroPython sem instalar biblioteca nenhuma, escrevendo direto nos registradores. O fluxo é o mesmo da biblioteca da Adafruit: primeiro lê-se 0x81 no registrador de ID (0x20), faz-se um reset por software, inicia-se a aplicação (0xF4) e escolhe-se o modo de medição (0x01). Depois, sempre que o bit DATA_READY do registrador de status estiver em 1, leem-se quatro bytes do registrador de resultado (0x02). O código também inclui uma pequena função que escreve umidade e temperatura no registrador de ambiente (0x05). Se você é novo no MicroPython, dê uma olhada primeiro no artigo fundamentos 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 x MQ-135
Os dois sensores são vendidos como “sensor de qualidade do ar”, mas funcionam de formas bem diferentes. O MQ-135 é analógico: seu aquecedor, alimentado com 5 V, consome cerca de 150 mA, a saída é uma tensão e você mesmo precisa fazer a calibração para calcular ppm. O CCS811 é digital, consome pouca energia e entrega valores prontos de eCO2 e TVOC. Os passos detalhados de calibração estão no artigo sensor de qualidade do ar MQ135.

| Característica | CCS811 | MQ-135 |
|---|---|---|
| Saída | I2C digital: eCO2 e TVOC | Tensão analógica (e um pino digital para limite) |
| Alimentação | 3,3 V | 5 V |
| Corrente | Cerca de 30 mA (modo de 1 s), bem menos nos modos lentos | Cerca de 150 mA |
| Calibração | Algoritmo integrado e baseline | Manual, R0 medido em ar limpo |
| Aquecimento | 20 min, 48 horas no primeiro uso | Alguns minutos, 24–48 horas no primeiro uso |
| Uso com bateria | Adequado (modo de 60 s) | Não adequado |
| Preço | Mais caro | Mais barato |
Erros comuns e soluções
| Sintoma | Causa provável | Solução |
|---|---|---|
| begin() retorna false | Pino WAK solto ou endereço errado | Ligue o WAK ao GND, confira 0x5A ou 0x5B com um scanner I2C |
| eCO2 sempre 400, TVOC sempre 0 | Ainda aquecendo, ou o ar está mesmo limpo | Aguarde 20 minutos, teste soprando no sensor |
| Valores desviam aos poucos | O baseline é zerado a cada vez que liga | Salve o baseline e restaure-o depois de 20 minutos |
| eCO2 na casa dos milhares sem ninguém por perto | Uma fonte de VOC, como perfume, álcool ou tinta | Lembre que o eCO2 é estimado a partir dos VOCs, afaste a fonte |
| readData() retorna erro | Fio frouxo, linha I2C longa ou alimentação baixa | Encurte os fios, meça a alimentação de 3,3 V, leia o erro com checkError() |
| Temperatura acima da real | BME280 ao lado do aquecedor | Afaste o BME280 do CCS811 ou aplique uma correção fixa de temperatura no módulo combinado |
Ideias de projetos
- Alerta de ventilação para sala de aula ou escritório: LED vermelho e um bipe curto de buzzer quando o eCO2 passar de 1000 ppm.
- Monitor de VOC na cozinha: acompanhe o aumento de TVOC enquanto cozinha e ligue a coifa automaticamente com um relé.
- Registro na nuvem: grave as leituras no Google Sheets com um ESP32 e faça gráficos diários e semanais.
- Integração com casa inteligente: envie os valores ao Home Assistant via MQTT e crie um alerta de janela aberta ou uma automação de ventilação.
- Medidor portátil a bateria: um aparelho para levar de cômodo em cômodo, com o modo de medição de 60 segundos e um pequeno display OLED.
Bem ligado e seguindo as regras de aquecimento e baseline, o CCS811 é um sensor prático que mostra com confiança as mudanças no ar interno. No app BlueGrays você encontra projetos como sensor de gás, alarme de chama e gás, temperatura e umidade com DHT11 e DHT22 e estação meteorológica com ESP32 e display OLED, cada um com esquema do circuito e código passo a passo; monte o indicador com CCS811 deste guia em cima deles.
Perguntas frequentes
O que o sensor CCS811 mede?
O CCS811 é um sensor de óxido metálico que mede os compostos orgânicos voláteis (VOCs) do ar. Ele informa TVOC em ppb e eCO2 em ppm. O eCO2 é um valor de dióxido de carbono equivalente estimado a partir da leitura de VOC.
O CCS811 mede CO2 real?
Não. O eCO2 do CCS811 é estimado a partir do aumento de VOCs e não mede o CO2 real diretamente. Para CO2 real você precisa de um sensor NDIR como MH-Z19, SCD30 ou SCD40.
Onde liga o pino WAK do CCS811?
O pino WAK (nWAKE) deve ser ligado ao GND. Enquanto ele está em nível baixo, o sensor responde pelo I2C; se ficar solto ou em nível alto, o sensor continua dormindo e o Arduino não o encontra. Nos módulos CJMCU-811 você mesmo precisa fazer essa ligação.
Quanto tempo o CCS811 leva para aquecer?
O CCS811 precisa de cerca de 20 minutos de aquecimento a cada vez que é ligado. Um sensor novo também deve passar uma vez na vida por um burn-in inicial de cerca de 48 horas. Os valores lidos nesses períodos não são confiáveis.
O que é o baseline do CCS811?
O baseline é o valor de referência que o sensor guarda para ar limpo. Ele é zerado quando a alimentação cai, então, depois de bastante tempo funcionando, deve ser lido com getBaseline() e salvo, e depois restaurado com setBaseline() após o aquecimento de 20 minutos na próxima vez que ligar.
O CCS811 funciona com Arduino em 5V?
O chip CCS811 funciona com no máximo 3,6 V e a maioria dos módulos CJMCU-811 não tem regulador. Alimente o módulo pelo pino 3.3V do Arduino. Para uso permanente com as linhas I2C de 5 V do Uno, recomenda-se um conversor de nível lógico.
Projetos para montar depois desta leitura
Ver todos os projetos
Temperatura e umidade com DHT11
Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

Uso de um sensor de gás
Um pequeno guardião que percebe um vazamento de gás na cozinha antes de você. O sensor de gás monitora o ar continuamente; enquanto está tudo bem, o LED verde fica aceso e, quando o gás no ar…

Alarme com sensores de chama e gás
Um pequeno guardião que avisa você imediatamente quando há um vazamento de gás ou surge uma chama.

Temperatura e umidade com ESP32 e DHT22 (com display LCD)
Este projeto mede a temperatura e a umidade do ambiente com um sensor DHT22 e exibe os dados em tempo real em um LCD I2C 16x2. Os dados são lidos do sensor pelo protocolo de um fio (one-wire) com a biblioteca Adafruit DHT. Este projeto serve de base para estações meteorológicas IoT, automação residencial ou sistemas de monitoramento ambiental em estufas. A comunicação com o DHT22 é feita pelo pino GPIO 4 do ESP32.

Alarme detector de gás e fumaça com ESP32 e MQ-2
Neste projeto, um módulo sensor de gás MQ-2 detecta gases combustíveis (LPG, metano e propano) e fumaça, acionando um alarme tipo sirene em um buzzer passivo. A saída digital de limiar (DO) do sensor é conectada ao GPIO 4 do ESP32. Quando a concentração de gás ou fumaça ultrapassa o limiar, DO passa para LOW e o alarme é acionado. A sensibilidade é ajustada pelo potenciômetro do módulo. O buzzer passivo é acionado com tone() para criar um efeito de sirene que alterna entre duas frequências.

ESP32 HTTPClient + API de clima (com display OLED SSD1306)
Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Diferentemente da versão anterior com LCD I2C, aqui usamos um display OLED SSD1306 (128×64), que permite usar fontes grandes, ícones vetoriais e uma apresentação visual rica em uma única tela. Sete ícones vetoriais de condições do tempo (ensolarado, parcialmente nublado, nublado, chuvoso, com neve, com tempestade e com neblina) são desenhados durante a execução, sem arquivos bitmap.

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.

Display LCD I2C com ESP32 (16x2)
Neste projeto, exibimos texto conectando um display LCD de 16x2 caracteres ao ESP32 pelo protocolo I2C. Com o I2C, controlamos o display usando apenas dois pinos de dados (SDA e SCL), dispensando o uso de seis ou mais pinos da conexão paralela tradicional. O código mostra uma mensagem fixa na primeira linha e um contador que aumenta a cada segundo na segunda linha. Na inicialização, também executamos um scanner I2C para mostrar o endereço do display no Monitor Serial (geralmente 0x27 ou 0x3F).
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

