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.

¿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ística | Valor |
|---|---|
| Tipo de sensor | Óxido metálico (MOX) con microcontrolador integrado |
| Salidas | eCO2 (400–8192 ppm), TVOC (0–1187 ppb), datos de resistencia en bruto |
| Interfaz | I2C, dirección 0x5A (ADD a GND) o 0x5B (ADD a VCC) |
| Alimentación | 1,8–3,6 V (alimenta el módulo CJMCU-811 con 3,3 V) |
| Consumo | Unos 30 mA en modo de 1 segundo por el calentador, mucho menos de media en modo de 60 segundos |
| Modos de medida | Modo 1: 1 s, Modo 2: 10 s, Modo 3: 60 s, Modo 4: 250 ms (solo datos en bruto) |
| Calentamiento | 20 minutos en cada encendido |
| Rodaje inicial (burn-in) | 48 horas en un sensor nuevo |
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 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 | Sin conectar (opcional D2) | Sin conectar | Sin conectar |
| RST | Sin conectar | Sin conectar | Sin conectar |
Primera lectura con Arduino Uno
- Abre el Gestor de Librerías del IDE de Arduino, busca Adafruit CCS811 e instálala con sus dependencias.
- Conecta el módulo según la tabla de arriba; no olvides llevar los pines WAK y ADD a GND.
- Carga el sketch de abajo y abre el Monitor Serie a 9600 baudios.
- 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.
- Prueba cerca de un rotulador, gel hidroalcohólico o tu aliento; verás subir el TVOC y el eCO2 en pocos 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}| Función | Qué 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) |
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 sensor | Manté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 alimenta | Muestra calentando en la pantalla, restaura el baseline guardado al final de este periodo |
| Tras cambiar de modo | Al pasar a un modo más lento | Espera 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.

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 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.
| Pieza | Pin del ESP32 | Nota |
|---|---|---|
| SDA del CCS811, BME280 y OLED | GPIO 21 | Los tres módulos en la misma línea |
| SCL del CCS811, BME280 y OLED | GPIO 22 | Los tres módulos en la misma línea |
| WAK y ADD del CCS811 | GND | Dirección 0x5A |
| LED verde | GPIO 25 | Con resistencia de 220 Ω, eCO2 por debajo de 800 ppm |
| LED amarillo | GPIO 26 | Con resistencia de 220 Ω, 800–1199 ppm |
| LED rojo | GPIO 27 | Con resistencia de 220 Ω, 1200 ppm o más |
| VCC de todos los módulos | 3V3 | Masas comunes |
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–799 | 0–219 | Buena | Nada |
| 800–999 | 220–659 | Moderada | Ventila cuando puedas |
| 1000–1499 | 660–2199 | Mala | Abre la ventana, busca la fuente de COV |
| 1500 o más | 2200 o más | Muy mala | Ventila 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.
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.

| Característica | CCS811 | MQ-135 |
|---|---|---|
| Salida | Digital I2C: eCO2 y TVOC | Tensión analógica (y un pin digital de umbral) |
| Alimentación | 3,3 V | 5 V |
| Consumo | Unos 30 mA (modo 1 s), mucho menos en modos lentos | Unos 150 mA |
| Calibración | Algoritmo integrado y baseline | Manual, midiendo R0 en aire limpio |
| Calentamiento | 20 min, 48 horas en el primer uso | Unos minutos, 24–48 horas en el primer uso |
| Uso con batería | Adecuado (modo 60 s) | No adecuado |
| Precio | Más caro | Más barato |
Errores comunes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| begin() devuelve false | Pin WAK al aire o dirección incorrecta | Conecta WAK a GND, comprueba 0x5A o 0x5B con un escáner I2C |
| eCO2 siempre 400, TVOC siempre 0 | Aún se está calentando o el aire está realmente limpio | Espera 20 minutos, prueba echando el aliento al sensor |
| Los valores derivan poco a poco | El baseline se reinicia en cada encendido | Guarda el baseline y restáuralo a los 20 minutos |
| eCO2 de miles de ppm sin nadie en la sala | Una fuente de COV como perfume, alcohol o pintura | Recuerda que el eCO2 se estima a partir de los COV, aleja la fuente |
| readData() devuelve error | Cable flojo, línea I2C larga o alimentación baja | Acorta los cables, mide los 3,3 V, mira el código con checkError() |
| Temperatura más alta que la real | BME280 junto al calentador | Aleja el BME280 del CCS811 o aplica una corrección fija en un módulo combinado |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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…

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…

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.

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.

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

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.

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.

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).
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

