Monitoreo de Calidad del Aire con Sensores de Bajo Costo: Tu Propia Estación Meteorológica Ambiental 🌬️🔬

Introducción al Monitoreo Ambiental Ciudadano 🌍

La calidad del aire es un factor crucial para nuestra salud y el bienestar del planeta. Las grandes estaciones de monitoreo son precisas, pero a menudo escasas y costosas. Aquí es donde entra en juego el monitoreo ciudadano: la capacidad de cualquier persona para recopilar datos ambientales con herramientas accesibles y contribuir a una visión más detallada de nuestro entorno.

Este tutorial te mostrará cómo construir tu propia estación de monitoreo de calidad del aire utilizando sensores de bajo costo. No solo aprenderás sobre electrónica y programación básica, sino que también obtendrás datos valiosos sobre el aire que respiras.

¿Por qué construir tu propia estación? 🤔

• Conciencia local: Entender la calidad del aire en tu entorno directo, no solo en la estación más cercana.
• Educación: Aprender sobre ciencia, electrónica, programación y medio ambiente de una manera práctica.
• Contribución: Tus datos pueden ser valiosos para investigadores y comunidades locales.
• Coste-efectividad: Una alternativa mucho más económica a las soluciones comerciales.

Componentes Necesarios para tu Estación 🛠️

Para construir nuestra estación, necesitaremos una serie de componentes electrónicos. Aquí tienes una lista detallada:

Lista de Materiales Esenciales

Componente	Descripción	Cantidad	Costo Estimado (USD)	Enlace de Compra (Ejemplo)
---	---	---	---	---
ESP32 DevKitC	Microcontrolador con Wi-Fi y Bluetooth	1	8-15	Amazon
Sensor PM2.5/PM10 (SDS011)	Mide partículas suspendidas	1	15-25	AliExpress
---	---	---	---	---
Sensor DHT22 (Temp/Hum)	Mide temperatura y humedad	1	5-10	Adafruit
Sensor MQ-135	Mide varios gases (CO2, NH3, benceno, etc.)	1	3-7	SparkFun
---	---	---	---	---
Protoboard	Para conectar componentes sin soldar	1	2-5	Elegoo
Cables Jumper M-M y M-F	Para interconexiones	1 set	5-10	Freenove
---	---	---	---	---
Cable Micro USB	Para alimentar el ESP32 y programar	1	2-5	Anker
Resistencias (10k Ohm)	Para pull-up en algunos sensores	1-2	<1	Componentes
---	---	---	---	---
Caja Protectora (opcional)	Impermeable, para exterior	1	10-30	Hammond

Herramientas Requeridas 🧰

• Computadora: Para programar el ESP32.
• Software Arduino IDE: Entorno de desarrollo para cargar el código.
• Soldador y estaño (opcional): Si deseas hacer conexiones permanentes y robustas en lugar de usar protoboard.
• Pelacables (opcional): Si usas cables de alambre sólido.

---

Preparación del Entorno de Desarrollo 💻

Antes de empezar a conectar los componentes, necesitamos configurar nuestro software.

1. Instalación del Arduino IDE

Descarga e instala la última versión del Arduino IDE desde la página oficial: arduino.cc/downloads.

2. Configuración del ESP32 en Arduino IDE

Para poder programar el ESP32, debemos añadir su soporte al Arduino IDE.

1. Abre el Arduino IDE.
2. Ve a Archivo > Preferencias.
3. En el campo URL de Gestor de Tarjetas Adicionales, añade la siguiente URL (si ya tienes otras, sepáralas con una coma): https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
4. Haz clic en OK.
5. Ve a Herramientas > Placa > Gestor de Tarjetas....
6. Busca esp32 e instala la placa esp32 by Espressif Systems.
7. Una vez instalado, ve a Herramientas > Placa y selecciona tu modelo de ESP32, por ejemplo, ESP32 Dev Module o ESP32 DevKitC. Si no estás seguro, ESP32 Dev Module suele funcionar bien.

3. Instalación de Librerías Necesarias 📚

Nuestros sensores requieren librerías específicas para comunicarse con el ESP32.

1. Librería para SDS011 (Sensor de Partículas):
   • Ve a Programa > Incluir Librería > Gestionar Librerías....
   • Busca SDS011 e instala la librería SDS011 de Chris Micro o similar.
2. Librería para DHT22 (Temperatura y Humedad):
   • Busca DHT sensor library e instala la librería DHT sensor library de Adafruit.
   • Busca también Adafruit Unified Sensor e instálala (es una dependencia de la anterior).
3. Librería para MQ-135 (Sensor de Gas):
   • Busca MQ135 e instala la librería MQ135 de Georg K .

---

Conexión de Componentes: El Cerebro de tu Estación 🧠

Ahora vamos a conectar los sensores al ESP32. Sigue estos esquemas de conexión cuidadosamente.

Diagrama de Conexión General

1. Conexión del Sensor SDS011 (Partículas PM2.5/PM10) ✨

Este sensor se comunica a través de UART (Serial).

Pin SDS011	Pin ESP32	Descripción	Notas
---	---	---	---
VCC	3.3V/5V	Alimentación	El SDS011 puede usar 5V. El ESP32 puede alimentarse con 5V a través de su puerto USB y tiene un pin de 5V.
GND	GND	Tierra	Siempre conecta las tierras.
---	---	---	---
TX	D16 (RX2)	Transmisión	TX del SDS011 va al RX del ESP32 (GPIO16).
RX	D17 (TX2)	Recepción	RX del SDS011 va al TX del ESP32 (GPIO17).

2. Conexión del Sensor DHT22 (Temperatura y Humedad) 🌡️💧

Este sensor utiliza un protocolo de un solo cable.

Pin DHT22	Pin ESP32	Descripción	Notas
---	---	---	---
VCC	3.3V	Alimentación	Conectar al pin 3.3V del ESP32.
DATA	D22	Datos	Conectar a un pin digital disponible (GPIO22).
---	---	---	---
GND	GND	Tierra	Siempre conecta las tierras.

3. Conexión del Sensor MQ-135 (Gases) 💨

Este sensor tiene una salida analógica (AO) y una digital (DO). Usaremos la analógica para una lectura más precisa.

Pin MQ-135	Pin ESP32	Descripción	Notas
---	---	---	---
VCC	3.3V	Alimentación	Conectar al pin 3.3V del ESP32.
GND	GND	Tierra	Siempre conecta las tierras.
---	---	---	---
AO	VP (ADC1_CH0)	Salida Analógica	Conectar al pin de entrada analógica del ESP32 (GPIO36).
DO	(Opcional)	Salida Digital	Se puede conectar a un pin digital si solo se necesita un umbral. No usaremos esta en este tutorial.

---

Programación del ESP32: El Código de tu Estación 📄

Ahora que los componentes están conectados, es hora de darles vida con código. Abriremos el Arduino IDE y escribiremos nuestro programa.

Estructura General del Código

Nuestro código tendrá las siguientes partes:

1. Inclusión de Librerías: Para los sensores y el Wi-Fi.
2. Definición de Pines: Asignación de los pines GPIO para cada sensor.
3. Configuración de Wi-Fi: Para conectar el ESP32 a internet y enviar datos.
4. Calibración de Sensores (MQ-135): Ajustes iniciales para el sensor de gas.
5. Lectura de Datos: Funciones para leer cada sensor.
6. Envío de Datos: Enviar los datos a un servidor (por ejemplo, ThingSpeak).

#include <WiFi.h>
#include <HardwareSerial.h>
#include <DHT.h>
#include "SDS011.h"
#include "MQ135.h"

// -----------------------------------------------------------------
//                         Configuración Wi-Fi
// -----------------------------------------------------------------
const char* ssid = "TU_NOMBRE_WIFI";
const char* password = "TU_CONTRASEÑA_WIFI";

// -----------------------------------------------------------------
//                       Configuración ThingSpeak
// -----------------------------------------------------------------
// Regístrate en thingspeak.com, crea un nuevo canal y copia estos valores
String apiKey = "TU_API_KEY_THINGSPEAK"; // API Key de escritura de tu canal
const char* server = "api.thingspeak.com";
WiFiClient client;

// -----------------------------------------------------------------
//                       Definición de Pines
// -----------------------------------------------------------------
// SDS011 (Sensor de Partículas)
// Usamos Serial2 en ESP32 (GPIO16 RX, GPIO17 TX)
SDS011 sds(Serial2);
const int SDS_RX_PIN = 16; // Pin RX del ESP32 (para TX del SDS011)
const int SDS_TX_PIN = 17; // Pin TX del ESP32 (para RX del SDS011)

// DHT22 (Temperatura y Humedad)
#define DHTPIN 22        // Pin digital donde conectamos el DHT22
#define DHTTYPE DHT22    // DHT 22 (AM2302)
DHT dht(DHTPIN, DHTTYPE);

// MQ-135 (Sensor de Gases)
const int MQ135_PIN = 36; // Pin analógico VP (GPIO36) en ESP32
MQ135 gasSensor = MQ135(MQ135_PIN); 

// Intervalo de lectura y envío de datos (en milisegundos)
unsigned long lastSendTime = 0;
const long sendInterval = 60000; // Enviar datos cada 60 segundos (1 minuto)

// -----------------------------------------------------------------
//                            Setup
// -----------------------------------------------------------------
void setup() {
  Serial.begin(115200);
  
  // Inicializar SDS011
  Serial2.begin(9600, SERIAL_8N1, SDS_RX_PIN, SDS_TX_PIN);
  sds.begin(SDS_RX_PIN, SDS_TX_PIN);
  Serial.println("SDS011 inicializado.");
  
  // Inicializar DHT22
  dht.begin();
  Serial.println("DHT22 inicializado.");

  // Calibrar MQ-135 (opcional, mejora la precisión)
  // Se recomienda ventilar el sensor durante 24-48h antes de calibrar.
  // Opcionalmente, puedes usar un valor de RO (Resistance at zero point) pre-calibrado
  // gasSensor.setR0(valor_de_calibracion_Ro);
  Serial.println("Calibrando MQ-135...");
  gasSensor.calibrate(); // Esto tarda un poco y necesita aire fresco
  Serial.print("MQ-135 R0: ");
  Serial.println(gasSensor.getR0());

  // Conectar a Wi-Fi
  Serial.print("Conectando a ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi conectado.");
  Serial.print("Dirección IP: ");
  Serial.println(WiFi.localIP());
}

// -----------------------------------------------------------------
//                            Loop
// -----------------------------------------------------------------
void loop() {
  if (millis() - lastSendTime > sendInterval) {
    lastSendTime = millis();

    // 1. Leer Sensor DHT22
    float h = dht.readHumidity();
    float t = dht.readTemperature();

    if (isnan(h) || isnan(t)) {
      Serial.println("Error al leer del sensor DHT22!");
      h = -999.0; // Valor para indicar error en ThingSpeak
      t = -999.0;
    }

    // 2. Leer Sensor SDS011
    float p25 = 0.0;
    float p10 = 0.0;
    int error = sds.read(&p25, &p10);

    if (!error) {
      Serial.print("PM2.5: "); Serial.print(p25); Serial.println(" ug/m3");
      Serial.print("PM10: "); Serial.print(p10); Serial.println(" ug/m3");
    } else {
      Serial.println("Error al leer del sensor SDS011.");
      p25 = -999.0;
      p10 = -999.0;
    }

    // 3. Leer Sensor MQ-135
    float resistance = gasSensor.getResistance();
    float ppmCO2 = gasSensor.getPPM(); // ppm de CO2 equivalente
    float r0 = gasSensor.getR0();

    Serial.print("Resistencia MQ-135: "); Serial.println(resistance);
    Serial.print("CO2eq (ppm): "); Serial.println(ppmCO2);
    Serial.print("MQ-135 R0: "); Serial.println(r0);

    // 4. Enviar datos a ThingSpeak
    if (WiFi.status() == WL_CONNECTED) {
      if (client.connect(server, 80)) {
        String postStr = apiKey;
        postStr += "&field1=";
        postStr += String(t);
        postStr += "&field2=";
        postStr += String(h);
        postStr += "&field3=";
        postStr += String(p25);
        postStr += "&field4=";
        postStr += String(p10);
        postStr += "&field5=";
        postStr += String(ppmCO2);
        postStr += "\r\n\r\n";

        client.print("POST /update HTTP/1.1\n");
        client.print("Host: ");
        client.print(server);
        client.print("\n");
        client.print("Connection: close\n");
        client.print("X-THINGSPEAKAPIKEY: " + apiKey + "\n");
        client.print("Content-Type: application/x-www-form-urlencoded\n");
        client.print("Content-Length: ");
        client.print(postStr.length());
        client.print("\n\n");
        client.print(postStr);

        Serial.println("Datos enviados a ThingSpeak.");
        client.stop();
      } else {
        Serial.println("Fallo la conexión a ThingSpeak.");
      }
    } else {
      Serial.println("WiFi no conectado. Reintentando...");
      WiFi.begin(ssid, password);
    }
  }
}

Calibración del Sensor MQ-135 💨

El sensor MQ-135 es sensible a una amplia gama de gases y requiere calibración para obtener lecturas más significativas. La calibración implica determinar el valor R0 (resistencia del sensor en aire limpio).

1. Exposición a aire limpio: Deja el sensor MQ-135 funcionando en un entorno con aire lo más limpio posible (idealmente exterior, lejos de fuentes de contaminación) durante 24-48 horas. Esto permite que el sensor se estabilice.
2. Método calibrate(): La librería MQ135 tiene un método calibrate() que se encarga de calcular R0. Llama a gasSensor.calibrate() en setup(), como se muestra en el código.
3. Ajuste manual: Si conoces un valor R0 de una calibración anterior o de un ambiente controlado, puedes usar gasSensor.setR0(valor_de_R0) para fijarlo. Esto evita la necesidad de calibrar cada vez.

---

Visualización de Datos con ThingSpeak 📊

ThingSpeak es una plataforma IoT gratuita que nos permite enviar, almacenar y visualizar datos de nuestros sensores en tiempo real.

1. Crear una Cuenta en ThingSpeak

Ve a thingspeak.com y regístrate para una cuenta gratuita.

2. Crear un Nuevo Canal

1. Haz clic en New Channel.
2. Name: Dale un nombre a tu estación (ej. "Mi Estación Ambiental Casa").
3. Description: Una breve descripción.
4. Fields: Define 5 campos para tus datos:
   • Field 1: Temperatura (°C)
   • Field 2: Humedad (%)
   • Field 3: PM2.5 (µg/m³)
   • Field 4: PM10 (µg/m³)
   • Field 5: CO2eq (ppm)
5. Puedes añadir unidades a cada campo.
6. Haz clic en Save Channel.

3. Obtener tu API Key de Escritura

Después de crear el canal, ve a la pestaña API Keys. Copia el Write API Key. Este es el que debes pegar en tu código Arduino.

4. Ver tus Datos en Tiempo Real

Una vez que hayas subido el código a tu ESP32 y se esté ejecutando, comenzará a enviar datos a ThingSpeak. Puedes ver los gráficos generados automáticamente en la pestaña Private View de tu canal.

---

Consideraciones para la Instalación Exterior 🏡

Si planeas instalar tu estación al aire libre para obtener datos más representativos, hay algunas consideraciones importantes.

1. Protección contra el Clima 🌧️☀️

• Caja Estanca: Es fundamental encerrar todos los componentes electrónicos en una caja estanca (IP65 o superior) para protegerlos de la lluvia, la humedad, el polvo y la luz solar directa. Las cajas de derivación eléctrica son una buena opción.
• Ventilación: Aunque necesites protección, los sensores (especialmente el SDS011 y el MQ-135) necesitan aire para funcionar. Puedes hacer pequeños orificios cubiertos con mallas finas o usar un diseño que permita el flujo de aire sin exponer directamente los componentes a los elementos.
• Ubicación: Coloca la estación en un lugar sombreado, lejos de fuentes directas de calor o frío, y a una altura adecuada (1.5 - 3 metros del suelo) para evitar la interferencia de fuentes terrestres y obtener una muestra de aire representativa.

2. Alimentación Eléctrica ⚡

• Adaptador de Corriente: Puedes usar un adaptador de corriente USB de 5V/1A o 5V/2A para alimentar el ESP32, asegurándote de que el cable USB esté protegido de la humedad.
• Energía Solar (Opcional): Para una solución completamente autónoma, puedes integrar un pequeño panel solar, un controlador de carga y una batería de litio. Esto añade complejidad, pero libera la estación de la necesidad de una toma de corriente.

3. Estabilidad y Fiabilidad 📈

• Conexiones Soldadas: Para una instalación permanente, se recomienda soldar todas las conexiones en lugar de usar una protoboard, que puede ser inestable con el tiempo y la exposición.
• Watchdog Timer: Implementar un Watchdog Timer en el código del ESP32 puede reiniciar automáticamente el microcontrolador si se bloquea, mejorando la fiabilidad de la estación.
• Actualizaciones OTA: Considera implementar actualizaciones Over-The-Air (OTA) para poder actualizar el firmware del ESP32 sin tener que desconectarlo y conectarlo físicamente a la computadora.

---

Mantenimiento y Mejora de tu Estación ✅

Una vez que tu estación esté funcionando, un buen mantenimiento y la búsqueda de mejoras garantizarán su longevidad y la precisión de los datos.

Mantenimiento Regular

• Limpieza de Sensores: El sensor SDS011 puede acumular polvo en su ventilador y entrada. Límpialo suavemente cada pocos meses. El DHT22 también puede requerir una limpieza ocasional si se ensucia.
• Revisión de Conexiones: Verifica periódicamente que todos los cables estén bien conectados y que no haya corrosión, especialmente en entornos húmedos.
• Calibración (MQ-135): Aunque el MQ-135 tiene una calibración inicial, su precisión puede beneficiarse de una re-calibración o ajuste de R0 si notas que sus lecturas se desvían con el tiempo o si el entorno cambia significativamente.

Posibles Mejoras y Expansión 🚀

• Almacenamiento Local de Datos: Además de ThingSpeak, puedes almacenar los datos en una tarjeta SD usando un módulo lector de tarjetas para el ESP32. Esto es útil si pierdes la conexión Wi-Fi temporalmente.
• Otros Sensores:
  • Sensor de Ruido (Módulo MAX9814): Mide los niveles de decibelios para un monitoreo de contaminación acústica.
  • Sensor UV (Módulo VEML6075): Mide la radiación ultravioleta.
  • Sensor de Lluvia: Para detectar precipitaciones.
• Servidor Local/Base de Datos: Para usuarios más avanzados, puedes configurar un servidor local (Raspberry Pi) o una base de datos para recopilar y analizar tus datos de manera más personalizada.
• Paneles Solares: Como se mencionó, una fuente de alimentación solar te dará más libertad en la ubicación.
• Comunicación LoRa/LoRaWAN: Si tu estación está en un área sin Wi-Fi, puedes usar módulos LoRa para enviar datos a distancias más largas, conectándote a una pasarela LoRaWAN.

¿Por qué es importante la precisión del sensor MQ-135?

El MQ-135 es un sensor de gas semiconductor de óxido metálico (MOS) de bajo costo. Su precisión varía y es más un indicador de *presencia* de gases contaminantes (CO2, NH3, benceno, alcohol, monóxido de carbono, etc.) que un medidor exacto de un gas específico. Para obtener mediciones precisas de CO2, por ejemplo, se necesitaría un sensor NDIR (Non-Dispersive Infrared) como el MH-Z19, que son más caros. La calibración en aire limpio y el uso de la fórmula de sensibilidad para el gas de interés pueden mejorar su utilidad como un índice de calidad del aire general.

Al construir y mantener tu propia estación de monitoreo ambiental, te conviertes en un científico ciudadano activo, contribuyendo a una mayor comprensión de nuestro entorno y fomentando la acción informada. ¡Felicidades por tu iniciativa! ✨