Componentes · 10 min de lectura

CCS811 Arduino: sensor de calidad del aire con eCO2 y TVOC

CCS811 con Arduino: medir eCO2 y TVOC, I2C y pin WAK, 20 minutos de calentamiento y 48 horas de rodaje, guardar el baseline, compensación con BME280 y ESP32.

El CCS811 es un pequeño sensor de gas digital con interfaz I2C que se usa en proyectos con Arduino para medir la calidad del aire interior. Detecta los compuestos orgánicos volátiles (COV o VOC) de la habitación y da dos valores: TVOC (compuestos orgánicos volátiles totales) en ppb y eCO2 (dióxido de carbono equivalente) en ppm. El pequeño procesador interno controla el calentador, procesa la medida en bruto con su propio algoritmo y te entrega números listos. Así, a diferencia de los sensores analógicos de la serie MQ, puedes leer valores útiles con pocas líneas de código sin pelearte con fórmulas de calibración.

En esta guía explicaremos cómo funciona el CCS811, por qué el eCO2 no es CO2 real y el tropiezo más habitual: el pin WAK. Haremos la primera lectura con un Arduino Uno y veremos el calentamiento de 20 minutos, el rodaje inicial de 48 horas, cómo guardar el baseline y la compensación de temperatura y humedad con un BME280. Después montaremos con un ESP32 un indicador de calidad del aire interior con OLED y LED, escribiremos código MicroPython sin librerías para la Raspberry Pi Pico y compararemos el CCS811 con el MQ-135.

Módulo sensor de calidad del aire CJMCU-811 con CCS811
El módulo CJMCU-811: sensor CCS811 con pines VCC, GND, SCL, SDA, WAK, INT, RST y ADD.

¿Qué es el CCS811 y cómo funciona?

El CCS811 es un sensor de gas de óxido metálico (MOX). Dentro tiene un diminuto calentador con una capa sensible a los gases encima. Cuando en el aire aumentan el alcohol, la acetona, el formaldehído, el perfume, los productos de limpieza o los compuestos orgánicos del aliento humano, cambia la resistencia de esa capa. El microcontrolador interno mide esta resistencia, la corrige con datos de temperatura y humedad y calcula el resultado como TVOC. El eCO2, en cambio, no se mide sino que se estima: en una habitación cerrada las personas producen tanto CO2 como COV, y el algoritmo estima cuánto ha subido probablemente el CO2 a partir del aumento de COV. Los rangos son 400–8192 ppm para eCO2 y 0–1187 ppb para TVOC; el valor mínimo que muestra es 400 ppm, porque es el nivel medio de CO2 del aire exterior.

CaracterísticaValor
Tipo de sensorÓxido metálico (MOX) con microcontrolador integrado
SalidaseCO2 (400–8192 ppm), TVOC (0–1187 ppb), datos de resistencia en bruto
InterfazI2C, dirección 0x5A (ADD a GND) o 0x5B (ADD a VCC)
Alimentación1,8–3,6 V (alimenta el módulo CJMCU-811 con 3,3 V)
ConsumoUnos 30 mA en modo de 1 segundo por el calentador, mucho menos de media en modo de 60 segundos
Modos de medidaModo 1: 1 s, Modo 2: 10 s, Modo 3: 60 s, Modo 4: 250 ms (solo datos en bruto)
Calentamiento20 minutos en cada encendido
Rodaje inicial (burn-in)48 horas en un sensor nuevo
El eCO2 no es CO2 real. Si no hay fuentes de COV en la habitación (por ejemplo, cuando el CO2 se acumula en una sala vacía), el eCO2 puede seguir bajo; si echas perfume o usas alcohol, el eCO2 se dispara a miles de ppm aunque no haya nadie. Las decisiones de ventilación o el control de CO2 en lugares como las aulas tómalas con sensores NDIR que miden CO2 real (como el MH-Z19, el SCD30 o el SCD40). El CCS811 sirve para seguir los cambios de COV y la tendencia general de la calidad del aire.

Pines del CCS811 y conexión

La placa CCS811 más habitual es el módulo CJMCU-811. Tiene ocho pines, y cuatro de ellos, VCC, GND, SDA y SCL, se conectan como en cualquier sensor I2C. El pin que marca la diferencia es WAK (nWAKE). Mientras está en nivel bajo, el sensor escucha el bus I2C; si está en alto o al aire, se queda dormido y no te responde. En el módulo CJMCU-811 el pin WAK no está unido a GND en la placa, así que debes conectarlo tú a GND. El pin ADD elige la dirección: 0x5A si va a GND y 0x5B si va a VCC. INT avisa con una interrupción cuando hay datos nuevos y RST es un reset por hardware; puedes dejar ambos sin conectar en la primera prueba.

Pin del CCS811Arduino UnoESP32Raspberry Pi Pico
VCC3.3V3V33V3 (OUT)
GNDGNDGNDGND
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
WAKGNDGNDGND
ADDGND (0x5A)GND (0x5A)GND (0x5A)
INTSin conectar (opcional D2)Sin conectarSin conectar
RSTSin conectarSin conectarSin conectar
El chip CCS811 funciona como máximo a 3,6 V y la mayoría de los módulos CJMCU-811 no llevan regulador; no conectes VCC al pin 5V del Arduino. Las líneas I2C del Uno trabajan a 5 V, así que en un proyecto permanente lo más seguro es poner un conversor de nivel lógico en medio. El ESP32 y la Pico ya funcionan a 3,3 V y se conectan directamente. Explicamos las reglas generales del bus I2C en el artículo qué es I2C.

Primera lectura con Arduino Uno

  1. Abre el Gestor de Librerías del IDE de Arduino, busca Adafruit CCS811 e instálala con sus dependencias.
  2. Conecta el módulo según la tabla de arriba; no olvides llevar los pines WAK y ADD a GND.
  3. Carga el sketch de abajo y abre el Monitor Serie a 9600 baudios.
  4. Durante los primeros minutos el eCO2 puede quedarse en 400 y el TVOC en 0; los valores se estabilizan a medida que el sensor se calienta.
  5. Prueba cerca de un rotulador, gel hidroalcohólico o tu aliento; verás subir el TVOC y el eCO2 en pocos segundos.
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}
FunciónQué hace
ccs.begin(0x5A)Reinicia el sensor, comprueba su identificador (0x81) y arranca la aplicación; devuelve false si falla
setDriveMode()Elige la frecuencia de medida: 1SEC, 10SEC, 60SEC, 250MS o IDLE
available()Devuelve true cuando hay una medida nueva lista
readData()Lee el resultado; si devuelve 0 la lectura ha ido bien
geteCO2() / getTVOC()Los últimos valores leídos de eCO2 (ppm) y TVOC (ppb)
Si ccs.begin() devuelve false, comprueba primero que WAK está en GND. Luego verifica la dirección con un sketch escáner I2C: si el dispositivo aparece en 0x5B, ADD está unido a VCC y necesitas begin(0x5B). En algunas placas como el ESP8266, el clock stretching del I2C del CCS811 puede dar problemas; con el ESP32, el Uno y la Pico normalmente no hay ninguno.

20 minutos de calentamiento y 48 horas de rodaje

Un sensor MOX no mide bien hasta que su capa alcanza cierta temperatura y se estabiliza. El CCS811 tiene dos periodos distintos que a menudo se confunden. El calentamiento (run-in) es el periodo de unos 20 minutos necesario en cada encendido; los valores de ese tiempo no son realistas, así que conviene mostrar "calentando" en la pantalla. El rodaje inicial (burn-in) es el periodo de unas 48 horas que un sensor nuevo pasa una sola vez en su vida; durante ese tiempo la capa se asienta químicamente. Hacer funcionar un sensor recién comprado 48 horas sin parar antes de montarlo en tu proyecto mejora claramente la estabilidad de las medidas posteriores.

Periodo¿Cuándo?¿Qué hacer?
Primeras 48 horas (burn-in)Una vez en la vida del sensorMantén el sensor funcionando sin parar, no te fíes de los valores, no guardes el baseline
20 minutos en cada encendido (run-in)Cada vez que se alimentaMuestra calentando en la pantalla, restaura el baseline guardado al final de este periodo
Tras cambiar de modoAl pasar a un modo más lentoEspera a las primeras medidas del modo nuevo

¿Qué es el baseline y por qué guardarlo?

El CCS811 guarda un valor de referencia para el aire limpio llamado baseline. El algoritmo ajusta esta referencia por sí solo con el tiempo, según el aire más limpio que ha visto. El problema: cada vez que el sensor se queda sin alimentación, el baseline se reinicia y los valores pueden derivar hasta que el algoritmo lo vuelve a aprender. La solución es leer el baseline con getBaseline() cuando el sensor lleva mucho tiempo funcionando bien, guardarlo en memoria permanente y restaurarlo con setBaseline() tras los 20 minutos de calentamiento del siguiente encendido. El baseline es un número de dos bytes sin significado legible; solo lo guardas y lo devuelves. El fabricante recomienda guardarlo cada día durante la primera semana tras el rodaje y luego cada pocas semanas. En Arduino puedes escribirlo en la EEPROM y en el ESP32 en la flash con Preferences. Es importante que el sensor haya visto aire limpio antes de guardarlo; basta con unos minutos de ventilación.

Compensación de temperatura y humedad con BME280

El algoritmo del CCS811 supone por defecto que la habitación está a 25 °C y 50 por ciento de humedad. Cuanto más se alejan los valores reales, más se desvían los cálculos de TVOC y eCO2. Si le pasas los valores reales con setEnvironmentalData(humedad, temperatura), el algoritmo los tiene en cuenta. Fíjate en el orden: en la librería de Adafruit va primero la humedad y luego la temperatura. El sensor guarda la humedad en pasos de 1/512 %HR y la temperatura en pasos de 1/512 °C con un desplazamiento de -25 °C; la librería hace la conversión por ti. El sensor más adecuado para esto es un BME280 en el mismo bus I2C. Si nunca has usado un BME280, echa un vistazo al artículo sensor BME280 y BMP280.

Sensor de temperatura, humedad y presión BME280
El BME280 comparte el bus I2C con el CCS811 y aporta los datos para la compensación de temperatura y humedad.
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}
El calentador del CCS811 calienta el módulo unos grados. En módulos combinados donde el CCS811 y el BME280 están en la misma placa (como el CJMCU-8128), el BME280 puede marcar 2–5 °C por encima de la temperatura real. Si usas módulos separados, coloca el BME280 a unos centímetros del CCS811. La dirección de un módulo BME280 puede ser 0x76 o 0x77; si begin() falla, prueba la otra.

Indicador de calidad del aire interior con ESP32

Ahora lo juntamos todo: el ESP32 leerá eCO2 y TVOC cada dos segundos, compensará con el BME280, mostrará los resultados en una OLED de 0,96 pulgadas y usará tres LED para indicar el estado del aire por colores. Durante el calentamiento la pantalla muestra "Isiniyor" (calentando); a los 20 minutos restaura el baseline guardado y, cuando la placa lleva 48 horas funcionando, guarda el baseline en la flash una vez al día. Los cuatro dispositivos I2C comparten los mismos dos cables; como sus direcciones son distintas, no hay conflictos.

PiezaPin del ESP32Nota
SDA del CCS811, BME280 y OLEDGPIO 21Los tres módulos en la misma línea
SCL del CCS811, BME280 y OLEDGPIO 22Los tres módulos en la misma línea
WAK y ADD del CCS811GNDDirección 0x5A
LED verdeGPIO 25Con resistencia de 220 Ω, eCO2 por debajo de 800 ppm
LED amarilloGPIO 26Con resistencia de 220 Ω, 800–1199 ppm
LED rojoGPIO 27Con resistencia de 220 Ω, 1200 ppm o más
VCC de todos los módulos3V3Masas comunes
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}

En el código medimos el tiempo de funcionamiento con esp_timer_get_time() en lugar de millis(); devuelve microsegundos como número de 64 bits, así que no hay desbordamiento en un indicador que funcione durante meses. El baseline se escribe con la librería Preferences en un espacio llamado "ccs811" y sobrevive a los apagados. Para las librerías basta con instalar Adafruit CCS811, Adafruit BME280 y Adafruit SSD1306 con sus dependencias. Para los detalles de la OLED, consulta el artículo pantalla OLED SSD1306.

eCO2 (ppm)TVOC (ppb)Valoración¿Qué hacer?
400–7990–219BuenaNada
800–999220–659ModeradaVentila cuando puedas
1000–1499660–2199MalaAbre la ventana, busca la fuente de COV
1500 o más2200 o másMuy malaVentila ya, no te quedes mucho rato

Los límites de la tabla son valores orientativos muy usados en los indicadores de calidad del aire interior; no son límites legales, sino una escala que sirve de guía. Registrar datos unos días en casa y ver cómo cambian por la mañana, al cocinar y después de limpiar es la mejor forma de ajustar los umbrales a tu entorno.

CCS811 con Raspberry Pi Pico (MicroPython)

En la Pico puedes usar el CCS811 con MicroPython sin instalar ninguna librería, escribiendo directamente en sus registros. El proceso es el mismo que sigue la librería de Adafruit: primero se lee 0x81 del registro de identificación (0x20), se hace un reset por software, se arranca la aplicación (0xF4) y se elige el modo de medida (0x01). Después, cada vez que el bit DATA_READY del registro de estado vale 1, se leen cuatro bytes del registro de resultados (0x02). El código incluye además una pequeña función que escribe humedad y temperatura en el registro de entorno (0x05). Si eres nuevo en MicroPython, echa antes un vistazo al artículo fundamentos de MicroPython.

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

CCS811 frente a MQ-135

Los dos se venden como "sensor de calidad del aire", pero funcionan de forma muy distinta. El MQ-135 es analógico: su calentador, alimentado a 5 V, consume unos 150 mA, su salida es una tensión y tienes que calibrarlo tú para calcular ppm. El CCS811 es digital, consume poco y da valores de eCO2 y TVOC ya calculados. Encontrarás los pasos de calibración detallados en el artículo sensor de calidad del aire MQ135.

Sensor de calidad del aire MQ-135
El MQ-135 da una salida analógica y su calentador de 5 V consume mucha más corriente que el CCS811.
CaracterísticaCCS811MQ-135
SalidaDigital I2C: eCO2 y TVOCTensión analógica (y un pin digital de umbral)
Alimentación3,3 V5 V
ConsumoUnos 30 mA (modo 1 s), mucho menos en modos lentosUnos 150 mA
CalibraciónAlgoritmo integrado y baselineManual, midiendo R0 en aire limpio
Calentamiento20 min, 48 horas en el primer usoUnos minutos, 24–48 horas en el primer uso
Uso con bateríaAdecuado (modo 60 s)No adecuado
PrecioMás caroMás barato

Errores comunes y soluciones

SíntomaCausa probableSolución
begin() devuelve falsePin WAK al aire o dirección incorrectaConecta WAK a GND, comprueba 0x5A o 0x5B con un escáner I2C
eCO2 siempre 400, TVOC siempre 0Aún se está calentando o el aire está realmente limpioEspera 20 minutos, prueba echando el aliento al sensor
Los valores derivan poco a pocoEl baseline se reinicia en cada encendidoGuarda el baseline y restáuralo a los 20 minutos
eCO2 de miles de ppm sin nadie en la salaUna fuente de COV como perfume, alcohol o pinturaRecuerda que el eCO2 se estima a partir de los COV, aleja la fuente
readData() devuelve errorCable flojo, línea I2C larga o alimentación bajaAcorta los cables, mide los 3,3 V, mira el código con checkError()
Temperatura más alta que la realBME280 junto al calentadorAleja el BME280 del CCS811 o aplica una corrección fija en un módulo combinado
El fabricante recomienda ahora el sensor ENS160, más reciente, en lugar del CCS811. Si diseñas un proyecto nuevo puedes mirar también el ENS160; pero el CCS811 que ya tienes te servirá durante años siguiendo los pasos de esta guía.

Ideas de proyectos

  • Aviso de ventilación para aulas u oficinas: un LED rojo y un breve pitido de zumbador cuando el eCO2 pase de 1000 ppm.
  • Monitor de COV en la cocina: seguir la subida de TVOC al cocinar y encender la campana extractora automáticamente con un relé.
  • Registro en la nube: escribir las medidas en Google Sheets con un ESP32 y sacar gráficas diarias y semanales.
  • Integración domótica: enviar los valores a Home Assistant por MQTT y crear un aviso de ventana abierta o una ventilación automática.
  • Medidor portátil con batería: un aparato con el modo de medida de 60 segundos y una pequeña OLED para llevar de habitación en habitación.

Bien conectado y respetando las reglas de calentamiento y baseline, el CCS811 es un sensor práctico que muestra de forma fiable los cambios del aire interior. En la app BlueGrays encontrarás proyectos como un sensor de gas, una alarma de llama y gas, la medida de temperatura y humedad con DHT11 y DHT22 y una estación meteorológica con ESP32 y OLED, cada uno con esquema y código paso a paso; monta sobre ellos el indicador CCS811 de esta guía.

Preguntas frecuentes

¿Qué mide el sensor CCS811?

El CCS811 es un sensor de óxido metálico que mide los compuestos orgánicos volátiles (COV) del aire. Da el TVOC en ppb y el eCO2 en ppm. El eCO2 es un valor de dióxido de carbono equivalente estimado a partir de los COV.

¿El CCS811 mide CO2 real?

No. El eCO2 del CCS811 se estima a partir del aumento de COV y no mide directamente el CO2 real. Para medir CO2 real necesitas un sensor NDIR como el MH-Z19, el SCD30 o el SCD40.

¿Dónde se conecta el pin WAK del CCS811?

El pin WAK (nWAKE) debe ir a GND. Mientras está en nivel bajo, el sensor responde por I2C; si queda al aire o en alto, se queda dormido y el Arduino no lo encuentra. En los módulos CJMCU-811 tienes que hacer tú esta conexión.

¿Cuánto tarda en calentarse el CCS811?

El CCS811 necesita unos 20 minutos de calentamiento en cada encendido. Un sensor nuevo debe pasar además una vez en su vida un rodaje inicial de unas 48 horas. Los valores leídos en esos periodos no son fiables.

¿Qué es el baseline del CCS811?

El baseline es el valor de referencia que el sensor guarda para el aire limpio. Se pierde al cortar la alimentación, así que tras un uso prolongado hay que leerlo con getBaseline(), guardarlo y restaurarlo con setBaseline() después de los 20 minutos de calentamiento del siguiente encendido.

¿Funciona el CCS811 con Arduino a 5V?

El chip CCS811 funciona como máximo a 3,6 V y la mayoría de los módulos CJMCU-811 no tienen regulador. Alimenta el módulo desde el pin 3.3V del Arduino. Para un uso permanente con las líneas I2C de 5 V del Uno se recomienda un conversor de nivel lógico.

Ver todos los proyectos
Temperatura y humedad con DHT11
AR-55Intermedio

Temperatura y humedad con DHT11

¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

4.7(47)
83
Uso del sensor de gas
AR-51Principiante
Premium

Uso del sensor de gas

Un pequeño vigilante que detecta un escape de gas en la cocina antes que tú. El sensor de gas olfatea el aire sin parar; mientras todo va bien se enciende el LED verde, y cuando el gas del aire…

4.6(37)
50
Alarma con sensor de llama y gas
AR-52Avanzado
Premium

Alarma con sensor de llama y gas

Un pequeño vigilante que te avisa enseguida si hay una fuga de gas o aparece una llama en algún sitio.

4.8(52)
67
ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura y humedad (con pantalla LCD)

Se trata de un proyecto que mide la temperatura y la humedad ambientales mediante el sensor DHT22 y las muestra en tiempo real en una pantalla LCD I2C 16x2. Los datos del sensor se leen mediante el protocolo de un solo cable (one-wire) utilizando la biblioteca DHT de Adafruit. Este proyecto constituye la base para estaciones meteorológicas IoT, sistemas de automatización doméstica inteligente o sistemas de monitorización ambiental en invernaderos.

4.8(38)
57
Alarma de detector de gas/humo ESP32 MQ-2
ES-20Intermedio

Alarma de detector de gas/humo ESP32 MQ-2

En este proyecto, la detección de gases combustibles (GLP, metano, propano) y humo se realiza mediante un módulo sensor de gas MQ-2; al detectarlos, se emite un sonido de alarma similar a una sirena a través de un zumbador pasivo. La salida digital de umbral (DO) del sensor se conecta al GPIO 4 del ESP32; cuando el gas o el humo superan el umbral, DO pasa a LOW y se activa la alarma. La sensibilidad se ajusta con el potenciómetro del módulo. El zumbador se controla con tone().

4.7(29)
44
ESP32 HTTPClient + API del tiempo (con pantalla OLED SSD1306)
ES-32Avanzado
Premium

ESP32 HTTPClient + API del tiempo (con pantalla OLED SSD1306)

El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. A diferencia de la versión con LCD I2C, aquí usamos una pantalla OLED SSD1306 (128×64), con letra grande e iconos vectoriales para una vista más rica. Siete iconos del tiempo (soleado, lluvia, nieve y más) se dibujan al momento, sin archivos bitmap.

4.3(10)
22
Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzado
Premium

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

4.7(7)
12
Pantalla LCD I2C para ESP32 (16x2)
ES-17Intermedio
Premium

Pantalla LCD I2C para ESP32 (16x2)

En este proyecto conectamos una pantalla LCD de caracteres 16x2 al ESP32 por I2C para mostrar texto. Con I2C bastan 2 pines de datos (SDA y SCL), en lugar de los 6+ pines de una conexión paralela clásica. El código escribe un mensaje fijo en la primera línea y un contador que sube cada segundo en la segunda. Al arrancar, un escáner I2C muestra la dirección de la pantalla en el Serial Monitor (normalmente 0x27 o 0x3F).

4.9(23)
40