From 1097586c68c6b2303ade718916dd2fb03ecc7591 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 7 Dec 2025 04:16:04 +0000
Subject: [PATCH 1/4] Initial plan


From 3e633b2941e9b9e0beb99a2d1519f9553a9fc267 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 7 Dec 2025 04:25:28 +0000
Subject: [PATCH 2/4] Add air quality system and update documentation for 4
 systems with platform segmentation

Co-authored-by: xtatikmel <8581177+xtatikmel@users.noreply.github.com>
---
 LIBRARIES.md                           | 117 +++++--
 QUICKSTART.md                          |  55 ++-
 README.md                              |  83 ++++-
 air_quality/README.md                  | 467 +++++++++++++++++++++++++
 air_quality/air_quality_monitor.ino    | 395 +++++++++++++++++++++
 air_quality/sensors/ccs811_sensor.ino  | 115 ++++++
 air_quality/sensors/mhz19_sensor.ino   |  88 +++++
 air_quality/sensors/mq135_sensor.ino   | 154 ++++++++
 air_quality/sensors/pms5003_sensor.ino |  78 +++++
 9 files changed, 1510 insertions(+), 42 deletions(-)
 create mode 100644 air_quality/README.md
 create mode 100644 air_quality/air_quality_monitor.ino
 create mode 100644 air_quality/sensors/ccs811_sensor.ino
 create mode 100644 air_quality/sensors/mhz19_sensor.ino
 create mode 100644 air_quality/sensors/mq135_sensor.ino
 create mode 100644 air_quality/sensors/pms5003_sensor.ino

diff --git a/LIBRARIES.md b/LIBRARIES.md
index 18d0fcc..91e8071 100644
--- a/LIBRARIES.md
+++ b/LIBRARIES.md
@@ -131,45 +131,102 @@ arduino-cli lib install "Adafruit BME280 Library"
 
 ---
 
-## 📊 Tabla de Compatibilidad de Librerías
+## 💨 Sistema de Medición de Calidad del Aire
+
+### Librerías Específicas
+- **PMS Library** - Sensores de partículas Plantower PMS5003/PMS7003
+  - Versión recomendada: 1.1.0 o superior
+  - Repositorio: https://github.com/fu-hsi/pms
+  - Uso: Medición de PM1.0, PM2.5, PM10
+
+- **MH-Z19** - Sensor de CO₂ NDIR MH-Z19B
+  - Versión recomendada: 1.5.4 o superior
+  - Repositorio: https://github.com/WifWaf/MH-Z19
+  - Uso: Medición precisa de CO₂ (400-5000 ppm)
+
+- **Adafruit CCS811 Library** - Sensor eCO₂ y TVOC
+  - Versión recomendada: 1.1.0 o superior
+  - Repositorio: https://github.com/adafruit/Adafruit_CCS811
+  - Uso: eCO₂ y compuestos orgánicos volátiles
+  - **Dependencia**: Adafruit Unified Sensor
+
+- **Adafruit BME280 Library** - Sensor ambiental
+  - Compartido con Estación Meteorológica
+  - Uso: Temperatura, humedad, presión para calibración
+
+### Librerías de Comunicación
+- **Wire** - I2C (incluida con Arduino IDE)
+- **SoftwareSerial** - UART para sensores (incluida)
+
+### Instalación
+```bash
+arduino-cli lib install "PMS Library"
+arduino-cli lib install "MH-Z19"
+arduino-cli lib install "Adafruit CCS811 Library"
+arduino-cli lib install "Adafruit BME280 Library"
+arduino-cli lib install "Adafruit Unified Sensor"
+```
+
+### Sketches
+- `air_quality/air_quality_monitor.ino` - Monitor completo
+- `air_quality/sensors/pms5003_sensor.ino` - Ejemplo PMS5003
+- `air_quality/sensors/mhz19_sensor.ino` - Ejemplo MH-Z19B
+- `air_quality/sensors/ccs811_sensor.ino` - Ejemplo CCS811
+- `air_quality/sensors/mq135_sensor.ino` - Ejemplo MQ-135 (analógico)
+
+---
 
-| Librería | Sistema Solar | Invernadero | Meteorológica | Versión Mínima |
-|----------|--------------|-------------|---------------|----------------|
-| ACS712 | ✅ | ❌ | ❌ | 0.2.0 |
-| DHT sensor library | ❌ | ✅ | ✅ | 1.3.0 |
-| Adafruit Unified Sensor | ❌ | ✅ | ✅ | 1.1.0 |
-| BH1750 | ✅ | ✅ | ✅ | 1.1.0 |
-| BMP180I2C | ❌ | ❌ | ✅ | - |
-| Wire (I2C) | ✅ | ✅ | ✅ | - |
-| SPI | ✅ | ❌ | ❌ | - |
-| Ethernet | ✅ | ❌* | ❌* | 2.0.0 |
-| SD | ✅ | ❌* | ❌* | 1.2.0 |
+## 📊 Tabla de Compatibilidad de Librerías
 
-*Opcional según implementación
+| Librería | Panel Solar | Invernadero | Meteorológica | Calidad Aire | Versión Mínima |
+|----------|-------------|-------------|---------------|--------------|----------------|
+| ACS712 | ✅ | ❌ | ❌ | ❌ | 0.2.0 |
+| DHT sensor library | ❌ | ✅ | ✅ | ❌ | 1.3.0 |
+| Adafruit Unified Sensor | ❌ | ✅ | ✅ | ✅ | 1.1.0 |
+| BH1750 | ✅ | ✅ | ✅ | ❌ | 1.1.0 |
+| BMP180I2C | ❌ | ❌ | ✅ | ❌ | - |
+| PMS Library | ❌ | ❌ | ❌ | ✅ | 1.1.0 |
+| MH-Z19 | ❌ | ❌ | ❌ | ✅ | 1.5.4 |
+| Adafruit CCS811 | ❌ | ❌ | ❌ | ✅ | 1.1.0 |
+| Adafruit BME280 | ❌ | ❌ | ✅ | ✅* | 2.0.0 |
+| Wire (I2C) | ✅ | ✅ | ✅ | ✅ | - |
+| SoftwareSerial | ❌ | ❌ | ❌ | ✅ | - |
+| SPI | ✅ | ❌ | ❌ | ❌ | - |
+| Ethernet | ✅ | ❌** | ❌** | ❌** | 2.0.0 |
+| SD | ✅ | ❌** | ❌** | ❌** | 1.2.0 |
+
+*Opcional para calibración ambiental
+**Opcional según implementación
 
 ---
 
+## 🔧 Compatibilidad por Plataforma
 
 ### ESP8266
-- Todas las librerías listadas son compatibles
+- Compatible con: Panel Solar, Invernadero, Estación Meteorológica
+- Librerías soportadas: Todas excepto las específicas de calidad del aire
 - Board Manager URL: `http://arduino.esp8266.com/stable/package_esp8266com_index.json`
 - Instalación: Tools → Board → Boards Manager → buscar "ESP8266"
-- Recomendado para: Todos los sistemas (WiFi integrado)
+- Ventaja: WiFi integrado, ideal para IoT
 
 ### ESP32
-- Todas las librerías listadas son compatibles
+- Compatible con: Invernadero, Estación Meteorológica
+- Librerías soportadas: Todas las de ESP8266 + más memoria/procesamiento
 - Board Manager URL: `https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json`
-- Recomendado para: Sistemas que requieren más potencia o Bluetooth
+- Ventaja: Mayor potencia, Bluetooth, dual-core
 
 ### Arduino (Uno, Mega, Nano)
-- Compatible con todas las librerías
-- Arduino Mega: Usado en ejemplos con Ethernet/SD
-- Limitación: Sin WiFi integrado (usar módulo externo)
-- Recomendado para: Sistema solar con Ethernet
+- Compatible con: Invernadero, Estación Meteorológica, Calidad del Aire
+- Librerías soportadas: Todas
+- Arduino Mega: Recomendado para proyectos con muchos sensores (más pines y memoria)
+- Limitación: Sin WiFi integrado (usar módulo ESP8266/ESP32 externo o Ethernet)
+- Ventaja: Estándar, económico, amplia compatibilidad
 
 ### Raspberry Pi
-- Usar librerías Python equivalentes (futuro)
-- Recomendado para: Procesamiento avanzado y servidor
+- Compatible con: Estación Meteorológica, Calidad del Aire
+- Librerías: Usar equivalentes en Python (RPi.GPIO, smbus, pyserial)
+- Ventaja: Procesamiento avanzado, Linux completo, múltiples interfaces
+- Recomendado para: Servidor de datos, procesamiento ML, dashboard local
 
 ---
 
@@ -236,6 +293,17 @@ arduino-cli lib install "BH1750"
 arduino-cli lib install "Adafruit BME280 Library"
 ```
 
+### Para Sistema de Calidad del Aire
+```bash
+arduino-cli lib update-index
+arduino-cli lib install "PMS Library"
+arduino-cli lib install "MH-Z19"
+arduino-cli lib install "Adafruit CCS811 Library"
+arduino-cli lib install "Adafruit BME280 Library"
+arduino-cli lib install "Adafruit Unified Sensor"
+```
+
+
 ### Para Todos los Sistemas (Completo)
 ```bash
 arduino-cli lib update-index
@@ -244,6 +312,9 @@ arduino-cli lib install "DHT sensor library"
 arduino-cli lib install "Adafruit Unified Sensor"
 arduino-cli lib install "BH1750"
 arduino-cli lib install "Adafruit BME280 Library"
+arduino-cli lib install "PMS Library"
+arduino-cli lib install "MH-Z19"
+arduino-cli lib install "Adafruit CCS811 Library"
 ```
 
 ---
diff --git a/QUICKSTART.md b/QUICKSTART.md
index 56fc613..1bfcda9 100644
--- a/QUICKSTART.md
+++ b/QUICKSTART.md
@@ -2,11 +2,12 @@
 
 ## 🎯 Descripción
 
-Bienvenido a Ornidia, un proyecto de sistemas de monitoreo con microcontroladores dividido en tres áreas:
+Bienvenido a Ornidia, un proyecto de sistemas de monitoreo con microcontroladores dividido en cuatro áreas:
 
-1. **🔆 Panel Solar** - Monitoreo de energía solar
-2. **🌱 Invernadero** - Control ambiental para cultivos
-3. **🌤️ Estación Meteorológica** - Medición atmosférica
+1. **🔆 Panel Solar** - Monitoreo de energía solar (ESP8266)
+2. **🌱 Invernadero** - Control ambiental para cultivos (ESP32, ESP8266, Arduino)
+3. **🌤️ Estación Meteorológica** - Medición atmosférica (ESP32, ESP8266, Arduino Mega, Raspberry Pi)
+4. **💨 Calidad del Aire** - Monitoreo de contaminantes (Arduino, Raspberry Pi)
 
 Esta guía te ayudará a comenzar rápidamente con cualquiera de los sistemas.
 
@@ -15,13 +16,14 @@ Esta guía te ayudará a comenzar rápidamente con cualquiera de los sistemas.
 ## 📋 Requisitos Previos
 
 ### Hardware Mínimo
-- Microcontrolador: ESP8266, ESP32, o Arduino
+- Microcontrolador: ESP8266, ESP32, Arduino, o Raspberry Pi (según sistema)
 - Cable USB para programación
 - Sensores según el sistema elegido (ver secciones específicas)
 
 ### Software
 - Arduino IDE (1.8.x o superior) o arduino-cli
 - Git (opcional, para clonar el repositorio)
+- Para Raspberry Pi: Python 3.x y librerías GPIO
 
 ---
 
@@ -117,6 +119,42 @@ cd weather_station/
 
 ---
 
+### 4️⃣ Sistema de Calidad del Aire
+
+**Hardware necesario:**
+- Arduino (Uno, Mega, Nano) o Raspberry Pi
+- PMS5003 o SDS011 (sensor de partículas)
+- MH-Z19B (sensor CO₂ NDIR)
+- CCS811 (sensor eCO₂/TVOC) - opcional
+- BME280 (temp/humedad/presión) - opcional
+- MQ-135 (sensor calidad aire) - opcional
+
+**Instalación de librerías:**
+```bash
+arduino-cli lib install "PMS Library"
+arduino-cli lib install "MH-Z19"
+arduino-cli lib install "Adafruit CCS811 Library"
+arduino-cli lib install "Adafruit BME280 Library"
+```
+
+**Cargar sketch:**
+```bash
+cd air_quality/
+# Abrir air_quality_monitor.ino en Arduino IDE
+# Seleccionar placa Arduino apropiada
+# Configurar sensores habilitados en el código
+# Compilar y cargar
+```
+
+**IMPORTANTE:**
+- Sensores MQ requieren 24-48h de pre-calentamiento
+- MH-Z19B necesita 3 minutos de warm-up
+- CCS811 requiere 48h de burn-in para precisión
+
+**[Documentación completa →](air_quality/README.md)**
+
+---
+
 ## 🔧 Configuración del Arduino IDE
 
 ### 1. Instalar soporte para ESP8266/ESP32
@@ -221,6 +259,13 @@ Para ver los datos en tiempo real:
 3. Instalar sensores en carcasa exterior
 4. Configurar envío a servicios meteorológicos
 
+### Para Sistema de Calidad del Aire
+1. Pre-calentar sensores MQ (24-48h)
+2. Calibrar MH-Z19B en aire exterior
+3. Configurar umbrales de alerta
+4. Integrar con sistema de ventilación (opcional)
+5. Enviar datos a Sensor.Community o AirGradient
+
 ---
 
 ## 🐛 Solución Rápida de Problemas
diff --git a/README.md b/README.md
index 36708f8..7936a14 100644
--- a/README.md
+++ b/README.md
@@ -3,11 +3,12 @@ Proyecto de Sistemas de Monitoreo con Microcontroladores
 
 ## 🎯 Descripción
 
-Ornidia es un proyecto integral de monitoreo y control basado en microcontroladores (PIC, Arduino, ESP32, ESP8266, Raspberry Pi, etc.) dividido en tres sistemas principales:
+Ornidia es un proyecto integral de monitoreo y control basado en microcontroladores (Arduino, ESP32, ESP8266, Raspberry Pi, etc.) dividido en cuatro sistemas principales:
 
-1. **🔆 Monitoreo de Panel Solar** - Sistema de monitoreo de energía solar
-2. **🌱 Monitoreo de Invernadero** - Sistema de control ambiental para cultivos
-3. **🌤️ Estación Meteorológica** - Sistema de medición de parámetros atmosféricos
+1. **🔆 Monitoreo de Panel Solar** - Sistema de monitoreo de energía solar (ESP8266)
+2. **🌱 Invernadero Inteligente** - Sistema de control ambiental para cultivos (ESP32, ESP8266, Arduino)
+3. **🌤️ Estación Meteorológica** - Sistema de medición de parámetros atmosféricos (ESP32, ESP8266, Arduino Mega, Raspberry Pi)
+4. **💨 Medidor de Calidad del Aire** - Sistema de monitoreo de contaminantes y partículas (Arduino, Raspberry Pi)
 
 Cada sistema utiliza diversos sensores y actuadores para obtener datos y almacenarlos en servidores caseros y/o cloud.
 
@@ -36,6 +37,13 @@ Ornidia/
 │   ├── examples/         # Ejemplos de configuración
 │   └── docs/             # Guías de instalación y calibración
 │
+├── air_quality/          # Medidor de calidad del aire
+│   ├── README.md         # Documentación del sistema
+│   ├── air_quality_monitor.ino # Sketch principal
+│   ├── sensors/          # Sensores (PMS5003, MH-Z19B, CCS811, MQ-135)
+│   ├── examples/         # Ejemplos de configuración
+│   └── docs/             # Guías de interpretación y salud
+│
 ├── LIBRARIES.md          # Dependencias de librerías
 ├── TESTING.md            # Guía de pruebas
 ├── QUICKSTART.md         # Inicio rápido
@@ -116,15 +124,55 @@ Sistema completo de medición de parámetros atmosféricos.
 
 ---
 
-## 🔧 Plataformas Soportadas
+## 💨 Sistema de Medición de Calidad del Aire
+
+Sistema completo de monitoreo de contaminantes atmosféricos y calidad del aire.
+
+### Hardware
+- Arduino (Uno, Mega, Nano) / Raspberry Pi
+- Sensores de partículas: PMS5003, SDS011
+- Sensores de gases: MH-Z19B (CO₂), CCS811 (eCO₂/TVOC), MQ-135
+- Sensores ambientales: BME280, DHT22
+
+### Parámetros Monitoreados
+- 🔬 PM1.0, PM2.5, PM10 (partículas)
+- ☁️ CO₂ y eCO₂ (dióxido de carbono)
+- 🏭 TVOC (compuestos orgánicos volátiles)
+- ⚠️ CO (monóxido de carbono)
+- 🌡️ Temperatura, humedad, presión
+
+### Índices Calculados
+- AQI (Air Quality Index)
+- IAQ (Indoor Air Quality Index)
+- Alertas por umbrales de salud
 
-El proyecto es compatible con múltiples microcontroladores:
+### Aplicaciones
+- Monitoreo de calidad del aire interior
+- Estaciones de monitoreo ambiental urbano
+- Control de ventilación automático
+- Alertas de salud para grupos sensibles
 
-- ✅ **ESP8266** - WiFi integrado, ideal para IoT
-- ✅ **ESP32** - Mayor potencia y conectividad
-- ✅ **Arduino** (Uno, Mega, Nano) - Plataforma estándar
-- 🔄 **Raspberry Pi** - Para procesamiento avanzado
-- 🔄 **PIC** - Microcontroladores Microchip (en desarrollo)
+**[Ver documentación completa →](air_quality/README.md)**
+
+---
+
+## 🔧 Plataformas Soportadas por Sistema
+
+El proyecto está segmentado por plataformas según las necesidades de cada sistema:
+
+### Por Sistema
+| Sistema | ESP8266 | ESP32 | Arduino | Raspberry Pi |
+|---------|---------|-------|---------|--------------|
+| 🔆 **Panel Solar** | ✅ Principal | ⚪ | ⚪ | ⚪ |
+| 🌱 **Invernadero** | ✅ | ✅ | ✅ | ⚪ |
+| 🌤️ **Meteorológica** | ✅ | ✅ | ✅ Mega | ✅ |
+| 💨 **Calidad Aire** | ⚪ | ⚪ | ✅ | ✅ |
+
+### Características por Plataforma
+- ✅ **ESP8266** - WiFi integrado, ideal para IoT (Panel Solar, Invernadero, Meteorológica)
+- ✅ **ESP32** - Mayor potencia, Bluetooth (Invernadero, Meteorológica)
+- ✅ **Arduino** (Uno, Mega, Nano) - Estándar, económico (Invernadero, Meteorológica, Calidad Aire)
+- ✅ **Raspberry Pi** - Procesamiento avanzado, Linux (Meteorológica, Calidad Aire)
 
 ---
 
@@ -150,11 +198,17 @@ Todos los sistemas soportan múltiples opciones de almacenamiento:
 
 ### Sensores Principales
 ```bash
+# Panel Solar y Meteorológica
 arduino-cli lib install "ACS712"
 arduino-cli lib install "DHT sensor library"
 arduino-cli lib install "Adafruit Unified Sensor"
 arduino-cli lib install "BH1750"
 arduino-cli lib install "Adafruit BME280 Library"
+
+# Calidad del Aire
+arduino-cli lib install "PMS Library"
+arduino-cli lib install "MH-Z19"
+arduino-cli lib install "Adafruit CCS811 Library"
 ```
 
 ### Comunicación
@@ -177,9 +231,10 @@ cd Ornidia
 
 ### 2. Seleccionar el sistema
 Navega al directorio del sistema que deseas usar:
-- `cd solar_panel/` para monitoreo solar
-- `cd greenhouse/` para invernadero
-- `cd weather_station/` para estación meteorológica
+- `cd solar_panel/` para monitoreo solar (ESP8266)
+- `cd greenhouse/` para invernadero (ESP32/ESP8266/Arduino)
+- `cd weather_station/` para estación meteorológica (ESP32/ESP8266/Arduino Mega/Raspberry Pi)
+- `cd air_quality/` para calidad del aire (Arduino/Raspberry Pi)
 
 ### 3. Instalar librerías
 ```bash
diff --git a/air_quality/README.md b/air_quality/README.md
new file mode 100644
index 0000000..4d2fe00
--- /dev/null
+++ b/air_quality/README.md
@@ -0,0 +1,467 @@
+# Sistema de Medición de Calidad del Aire
+
+## Descripción
+Sistema completo de monitoreo de calidad del aire basado en microcontroladores (Arduino, Raspberry Pi) para medición de partículas, gases contaminantes y parámetros ambientales que afectan la salud respiratoria.
+
+## Hardware Requerido
+
+### Componentes Principales
+- **Arduino** (Uno, Mega, Nano) - Microcontrolador
+- **Raspberry Pi** (opcional) - Para procesamiento avanzado y servidor
+- **Fuente de alimentación** - 5V DC o USB
+- **Carcasa ventilada** - Protección con flujo de aire
+
+### Sensores de Calidad del Aire
+
+#### Partículas (Material Particulado)
+- **PMS5003 / PMS7003** - Sensor láser PM1.0, PM2.5, PM10
+- **SDS011** - Sensor láser PM2.5, PM10
+- **GP2Y1010AU0F** - Sensor óptico básico de polvo
+- **PPD42NS** - Detector de partículas
+
+#### Gases Contaminantes
+- **MQ-135** - Calidad del aire (NH3, NOx, alcohol, benzeno, humo, CO2)
+- **MQ-7** - Monóxido de carbono (CO)
+- **MQ-2** - Gas LP, propano, metano, humo
+- **MQ-9** - CO y gases combustibles
+- **MH-Z19B** - CO₂ infrarrojo (NDIR) de alta precisión
+- **CCS811** - eCO₂ y eTVOC (compuestos orgánicos volátiles)
+
+#### Sensores Ambientales
+- **DHT22** - Temperatura y humedad (±0.5°C, ±2% RH)
+- **BME280** - Temp, humedad y presión barométrica
+- **BMP180** - Presión y temperatura
+
+#### Otros
+- **BH1750** - Luz ambiente (para correlación solar)
+
+## Parámetros Medidos
+
+### Partículas (PM - Particulate Matter)
+- 🔬 **PM1.0** - Partículas ≤ 1.0 μm (ultra finas)
+- 🔬 **PM2.5** - Partículas ≤ 2.5 μm (respirables)
+- 🔬 **PM10** - Partículas ≤ 10 μm (inhalables)
+
+### Gases
+- ☁️ **CO₂** - Dióxido de carbono (ppm)
+- ⚠️ **CO** - Monóxido de carbono (ppm)
+- 🏭 **VOC/TVOC** - Compuestos orgánicos volátiles totales (ppb)
+- 💨 **NH₃** - Amoníaco
+- 🚗 **NOx** - Óxidos de nitrógeno
+
+### Ambientales
+- 🌡️ **Temperatura** - °C
+- 💧 **Humedad** - % RH
+- 🏔️ **Presión** - hPa
+
+### Índices Calculados
+- 📊 **AQI** - Índice de Calidad del Aire (Air Quality Index)
+- 🎯 **IAQ** - Índice de Calidad del Aire Interior (Indoor Air Quality)
+- 🌡️ **Índice de confort** - Basado en temp/humedad
+
+## Arquitectura del Sistema
+
+```
+┌──────────────────────────────────────────┐
+│         Microcontrolador                 │
+│          (Arduino/Raspberry Pi)          │
+│                                          │
+│  ┌────────────────────────────────────┐  │
+│  │   Sensores de Partículas           │  │
+│  │  - PMS5003 (UART) [PM1.0/2.5/10]  │  │
+│  │  - SDS011 (UART) [PM2.5/10]       │  │
+│  │  - GP2Y1010AU0F (Analógico)       │  │
+│  └────────────────────────────────────┘  │
+│                                          │
+│  ┌────────────────────────────────────┐  │
+│  │   Sensores de Gases (I2C)          │  │
+│  │  - MH-Z19B (CO₂ NDIR) [UART]      │  │
+│  │  - CCS811 (eCO₂/TVOC) [0x5A]      │  │
+│  │  - BME280 (Temp/Hum/Pre) [0x76]   │  │
+│  └────────────────────────────────────┘  │
+│                                          │
+│  ┌────────────────────────────────────┐  │
+│  │   Sensores MQ (Analógicos)         │  │
+│  │  - MQ-135 (Calidad aire)           │  │
+│  │  - MQ-7 (CO)                       │  │
+│  │  - MQ-2 (Gases combustibles)       │  │
+│  └────────────────────────────────────┘  │
+│                                          │
+│  ┌────────────────────────────────────┐  │
+│  │   Procesamiento                    │  │
+│  │  - Cálculo de AQI                  │  │
+│  │  - Promedios móviles               │  │
+│  │  - Alertas por umbrales            │  │
+│  └────────────────────────────────────┘  │
+└──────────────────────────────────────────┘
+              │
+              ▼
+   ┌──────────────────────┐
+   │   Almacenamiento     │
+   │  - Tarjeta SD        │
+   │  - MQTT Broker       │
+   │  - ThingSpeak        │
+   │  - AirGradient       │
+   │  - PurpleAir         │
+   │  - Servidor local    │
+   └──────────────────────┘
+```
+
+## Conexiones
+
+### PMS5003 / PMS7003 (UART)
+| Pin PMS | Conexión Arduino | Descripción |
+|---------|------------------|-------------|
+| VCC | 5V | Alimentación |
+| GND | GND | Tierra |
+| TX | RX (D10 SoftSerial) | Transmisión de datos |
+| RX | TX (D11 SoftSerial) | Recepción (opcional) |
+| SET | D12 | Sleep/Wake (opcional) |
+
+### MH-Z19B (UART - CO₂)
+| Pin MH-Z19B | Conexión Arduino | Descripción |
+|-------------|------------------|-------------|
+| VIN | 5V | Alimentación (4.5-5.5V) |
+| GND | GND | Tierra |
+| TX | RX (D2 SoftSerial) | Transmisión |
+| RX | TX (D3 SoftSerial) | Recepción |
+
+### CCS811 (I2C - eCO₂/TVOC)
+| Pin CCS811 | Conexión Arduino | Descripción |
+|------------|------------------|-------------|
+| VCC | 3.3V | Alimentación |
+| GND | GND | Tierra |
+| SDA | A4 (SDA) | Datos I2C |
+| SCL | A5 (SCL) | Clock I2C |
+| WAK | GND | Wake (activo bajo) |
+
+### BME280 (I2C)
+| Pin BME280 | Conexión Arduino | Descripción |
+|------------|------------------|-------------|
+| VCC | 3.3V | Alimentación |
+| GND | GND | Tierra |
+| SDA | A4 (SDA) | Datos I2C |
+| SCL | A5 (SCL) | Clock I2C |
+
+### MQ-135 (Analógico)
+| Pin MQ-135 | Conexión Arduino | Descripción |
+|------------|------------------|-------------|
+| VCC | 5V | Alimentación |
+| GND | GND | Tierra |
+| AOUT | A0 | Salida analógica |
+| DOUT | D8 | Salida digital (opcional) |
+
+### GP2Y1010AU0F (Sensor óptico de polvo)
+| Pin GP2Y | Conexión Arduino | Descripción |
+|----------|------------------|-------------|
+| VCC | 5V | Alimentación |
+| GND | GND | Tierra |
+| LED | D7 | Control LED |
+| VOUT | A1 | Salida analógica |
+
+## Estructura de Archivos
+
+```
+air_quality/
+├── README.md                    # Este archivo
+├── air_quality_monitor.ino      # Sketch principal
+├── sensors/                     # Código de sensores
+│   ├── pms5003_sensor.ino       # Sensor de partículas láser
+│   ├── mhz19_sensor.ino         # Sensor CO₂ NDIR
+│   ├── ccs811_sensor.ino        # Sensor eCO₂/TVOC
+│   ├── mq135_sensor.ino         # Sensor calidad aire
+│   └── gp2y_sensor.ino          # Sensor óptico polvo
+├── examples/                    # Ejemplos
+│   ├── basic_monitor.ino        # Monitor básico PM + CO₂
+│   ├── complete_monitor.ino     # Monitor completo
+│   └── outdoor_monitor.ino      # Monitor exterior
+└── docs/                        # Documentación
+    ├── aqi_calculation.md       # Cálculo del AQI
+    ├── calibration.md           # Calibración de sensores
+    └── health_guidelines.md     # Guías de salud
+```
+
+## Librerías Requeridas
+
+```cpp
+#include <Wire.h>              // I2C (incluida)
+#include <SoftwareSerial.h>    // UART para sensores (incluida)
+#include <Adafruit_BME280.h>   // Sensor ambiental
+#include <Adafruit_CCS811.h>   // Sensor eCO₂/TVOC
+#include <PMS.h>               // Sensor PMS5003/7003
+#include <MHZ19.h>             // Sensor MH-Z19B CO₂
+```
+
+### Instalación
+```bash
+arduino-cli lib install "Adafruit BME280 Library"
+arduino-cli lib install "Adafruit CCS811 Library"
+arduino-cli lib install "PMS Library"
+arduino-cli lib install "MH-Z19"
+```
+
+## Cálculo del AQI (Air Quality Index)
+
+### Escala AQI (EPA - USA)
+| AQI | Nivel | Color | PM2.5 (μg/m³) | Descripción |
+|-----|-------|-------|---------------|-------------|
+| 0-50 | Bueno | Verde | 0-12.0 | Calidad del aire satisfactoria |
+| 51-100 | Moderado | Amarillo | 12.1-35.4 | Aceptable, grupos sensibles con precaución |
+| 101-150 | Dañino (GS) | Naranja | 35.5-55.4 | Grupos sensibles afectados |
+| 151-200 | Dañino | Rojo | 55.5-150.4 | Todos pueden experimentar efectos |
+| 201-300 | Muy dañino | Púrpura | 150.5-250.4 | Alerta de salud |
+| 301+ | Peligroso | Granate | 250.5+ | Emergencia de salud |
+
+### Fórmula de Cálculo
+```cpp
+int calculateAQI(float pm25) {
+    // Breakpoints para PM2.5
+    float cLow, cHigh;
+    int iLow, iHigh;
+    
+    if (pm25 <= 12.0) {
+        cLow = 0.0; cHigh = 12.0;
+        iLow = 0; iHigh = 50;
+    } else if (pm25 <= 35.4) {
+        cLow = 12.1; cHigh = 35.4;
+        iLow = 51; iHigh = 100;
+    } 
+    // ... más rangos
+    
+    // Fórmula AQI
+    float aqi = ((iHigh - iLow) / (cHigh - cLow)) * (pm25 - cLow) + iLow;
+    return round(aqi);
+}
+```
+
+## Umbrales y Alertas
+
+### PM2.5
+- ✅ **0-12 μg/m³** - Bueno
+- ⚠️ **12-35 μg/m³** - Moderado
+- 🔶 **35-55 μg/m³** - Dañino para grupos sensibles
+- 🔴 **>55 μg/m³** - Dañino para todos
+
+### CO₂ (Interior)
+- ✅ **<400 ppm** - Exterior (referencia)
+- ✅ **400-1000 ppm** - Bueno
+- ⚠️ **1000-2000 ppm** - Ventilación recomendada
+- 🔶 **2000-5000 ppm** - Aire viciado, somnolencia
+- 🔴 **>5000 ppm** - Peligroso, problemas de salud
+
+### TVOC
+- ✅ **0-220 ppb** - Excelente
+- ⚠️ **220-660 ppb** - Bueno
+- 🔶 **660-2200 ppb** - Moderado
+- 🔴 **>2200 ppb** - Pobre
+
+## Almacenamiento de Datos
+
+### Formato de Datos
+```json
+{
+    "timestamp": "2025-10-27T12:00:00Z",
+    "pm1_0": 5.2,
+    "pm2_5": 12.3,
+    "pm10": 18.5,
+    "co2": 450,
+    "tvoc": 125,
+    "temperature": 22.5,
+    "humidity": 55.0,
+    "pressure": 1013.25,
+    "aqi": 48,
+    "aqi_level": "Good"
+}
+```
+
+### Destinos de Datos
+1. **Tarjeta SD** - CSV o JSON
+2. **MQTT** - Broker local o cloud
+3. **ThingSpeak** - Plataforma IoT
+4. **AirGradient** - Red de sensores de calidad del aire
+5. **PurpleAir** - Red comunitaria de monitoreo
+6. **Sensor.Community** - Proyecto open data
+7. **Servidor propio** - Base de datos
+
+## Intervalos de Lectura Recomendados
+
+- **PM2.5/PM10**: 60 segundos (alta energía del sensor)
+- **CO₂**: 5 segundos
+- **TVOC/eCO₂**: 1-10 segundos
+- **Temperatura/Humedad**: 30-60 segundos
+- **Promedio móvil**: 5-15 minutos para reportes
+
+## Instalación
+
+### Interior
+- ✅ Altura 1.0-1.5 metros (zona de respiración)
+- ✅ Alejado de ventanas y puertas
+- ✅ No cerca de cocinas o fuentes de contaminación
+- ✅ Circulación de aire natural
+- ❌ No en luz solar directa
+- ❌ No cerca de ventiladores o AC
+
+### Exterior
+- ✅ Carcasa protegida con ventilación
+- ✅ Protección contra lluvia
+- ✅ Altura 2-3 metros
+- ✅ Alejado de tráfico directo (>3m de vía)
+- ✅ No obstruido por edificios
+
+## Calibración de Sensores
+
+### Sensores de Partículas (PMS5003)
+- No requieren calibración de fábrica
+- Limpieza periódica (cada 6-12 meses)
+- Comparar con estación oficial cercana
+
+### MH-Z19B (CO₂)
+- Auto-calibración ABC habilitada (400 ppm baseline)
+- Calibración manual: exponer a aire exterior limpio
+- Comando: `sensor.calibrateZero()`
+
+### CCS811 (TVOC/eCO₂)
+- Requiere 48 horas de burn-in
+- Calibración automática con lecturas BME280
+- Mejorar precisión con temperatura/humedad real
+
+### Sensores MQ
+- Pre-calentamiento: 24-48 horas primera vez
+- Calibración en aire limpio
+- Factor de corrección por temperatura/humedad
+
+## Mantenimiento
+
+### Mensual
+- Verificar lecturas vs. datos oficiales
+- Limpiar carcasa externa
+
+### Trimestral
+- Revisar conexiones
+- Actualizar firmware si aplica
+
+### Semestral
+- Limpiar sensor de partículas (aire comprimido)
+- Verificar calibración de CO₂
+
+### Anual
+- Reemplazo de sensores MQ si degradación
+- Limpieza profunda de todos los sensores
+
+## Ejemplos de Uso
+
+### Monitor Básico
+PM2.5 + CO₂ + Temperatura/Humedad. Ideal para interior.
+
+### Monitor Completo
+Todos los sensores con cálculo de AQI y envío a cloud.
+
+### Monitor Exterior
+PM2.5 + PM10 para monitoreo ambiental urbano.
+
+## Integración con Servicios
+
+### Sensor.Community (ex-Luftdaten)
+```cpp
+// Enviar datos a Sensor.Community
+String url = "https://api.sensor.community/v1/push-sensor-data/";
+// JSON con mediciones
+```
+
+### ThingSpeak
+```cpp
+ThingSpeak.setField(1, pm25);
+ThingSpeak.setField(2, pm10);
+ThingSpeak.setField(3, co2);
+ThingSpeak.writeFields(channelID, apiKey);
+```
+
+### AirGradient
+Compatible con protocolo AirGradient para visualización en dashboard.
+
+## Visualización de Datos
+
+- **Dashboard web local** - HTML/CSS/JavaScript
+- **Grafana** - Visualización avanzada
+- **Node-RED** - Flujos y automatización
+- **Home Assistant** - Integración domótica
+- **Display OLED local** - SSD1306 para lecturas en tiempo real
+
+## Expansiones Futuras
+
+- 📱 App móvil con alertas push
+- 🌐 Red de sensores comunitarios
+- 🔋 Versión con batería y solar
+- 📡 Transmisión LoRa/LoRaWAN
+- 🤖 Machine Learning para predicciones
+- 🌡️ Integración con HVAC para control automático
+
+## Soporte para Plataformas
+
+- Arduino (Uno, Mega, Nano) ✅
+- Raspberry Pi ✅
+- ESP32 (futuro) 🔄
+- ESP8266 (futuro) 🔄
+
+## Consideraciones de Salud
+
+### Efectos de PM2.5
+- Irritación respiratoria
+- Agravamiento de asma
+- Enfermedades cardiovasculares (exposición prolongada)
+- Reducción de la función pulmonar
+
+### Grupos Sensibles
+- Niños
+- Adultos mayores
+- Personas con asma o EPOC
+- Enfermedades cardiovasculares
+
+### Recomendaciones por AQI
+- **0-50**: Sin restricciones
+- **51-100**: Sensibles: reducir actividad exterior prolongada
+- **101-150**: Sensibles: evitar actividad exterior prolongada
+- **151-200**: Todos: reducir actividad exterior
+- **201+**: Todos: permanecer en interior
+
+## Troubleshooting
+
+### PMS5003 no responde
+- Verificar conexión UART (TX/RX cruzados)
+- Alimentación 5V estable (>1A)
+- Comprobar baudrate (9600)
+
+### MH-Z19B lecturas incorrectas
+- Esperar warm-up (3 minutos)
+- Verificar calibración ABC
+- No obstruir entrada/salida de aire
+
+### CCS811 error de lectura
+- Completar burn-in de 48 horas
+- Verificar dirección I2C (0x5A o 0x5B)
+- Proporcionar datos de temp/humedad
+
+### Sensores MQ lecturas erráticas
+- Pre-calentamiento insuficiente (24-48h)
+- Calibración en aire limpio necesaria
+- Verificar alimentación estable 5V
+
+## Referencias
+
+- [EPA AQI](https://www.airnow.gov/aqi/)
+- [WHO Air Quality Guidelines](https://www.who.int/news-room/fact-sheets/detail/ambient-(outdoor)-air-quality-and-health)
+- [Sensor.Community](https://sensor.community/)
+- [AirGradient](https://www.airgradient.com/)
+- [PurpleAir](https://www2.purpleair.com/)
+
+## Normativas
+
+- **EPA (USA)**: National Ambient Air Quality Standards
+- **WHO**: Air Quality Guidelines
+- **EU**: Air Quality Directive 2008/50/EC
+- **China**: GB 3095-2012
+
+---
+
+**Última actualización**: 2025-10-27
+**Plataformas**: Arduino, Raspberry Pi
diff --git a/air_quality/air_quality_monitor.ino b/air_quality/air_quality_monitor.ino
new file mode 100644
index 0000000..a58814a
--- /dev/null
+++ b/air_quality/air_quality_monitor.ino
@@ -0,0 +1,395 @@
+/*
+ * Ornidia - Sistema de Medición de Calidad del Aire
+ * 
+ * Monitor completo de calidad del aire con soporte para múltiples sensores:
+ * - PMS5003/PMS7003: Partículas PM1.0, PM2.5, PM10
+ * - MH-Z19B: CO₂ (NDIR)
+ * - CCS811: eCO₂ y TVOC
+ * - BME280: Temperatura, humedad, presión
+ * - MQ-135: Calidad del aire general
+ * 
+ * Plataformas: Arduino Uno/Mega/Nano, Raspberry Pi (con adaptación)
+ * 
+ * Autor: Ornidia Project
+ * Fecha: 2025-10-27
+ * Versión: 1.0
+ */
+
+#include <Wire.h>
+#include <SoftwareSerial.h>
+
+// Configuración de sensores (comentar los que no se usen)
+#define USE_PMS5003      // Sensor de partículas láser
+#define USE_MHZ19B       // Sensor CO₂ NDIR
+#define USE_CCS811       // Sensor eCO₂/TVOC
+#define USE_BME280       // Sensor temp/hum/presión
+#define USE_MQ135        // Sensor calidad aire analógico
+
+// Librerías de sensores (instalar según sensores usados)
+#ifdef USE_PMS5003
+  // #include <PMS.h>
+  // PMS pms(Serial1);  // Para Arduino Mega (Hardware Serial)
+  // Para Arduino Uno/Nano usar SoftwareSerial
+  SoftwareSerial pmsSerial(10, 11); // RX, TX
+#endif
+
+#ifdef USE_MHZ19B
+  // #include <MHZ19.h>
+  SoftwareSerial mhz19Serial(2, 3); // RX, TX
+  // MHZ19 mhz19;
+#endif
+
+#ifdef USE_CCS811
+  // #include <Adafruit_CCS811.h>
+  // Adafruit_CCS811 ccs;
+#endif
+
+#ifdef USE_BME280
+  // #include <Adafruit_BME280.h>
+  // Adafruit_BME280 bme;
+#endif
+
+#ifdef USE_MQ135
+  const int MQ135_PIN = A0;
+  const int RL_VALUE = 10;  // kOhm - resistencia de carga
+  const float RO_CLEAN_AIR = 3.6; // kOhm - R0 en aire limpio (calibrar)
+#endif
+
+// Pines de configuración
+const int LED_STATUS = 13;
+
+// Variables de medición
+struct AirQualityData {
+  // Partículas (μg/m³)
+  float pm1_0;
+  float pm2_5;
+  float pm10;
+  
+  // Gases
+  int co2;          // ppm
+  int tvoc;         // ppb
+  int eco2;         // ppm (estimado)
+  
+  // Ambientales
+  float temperature;  // °C
+  float humidity;     // %
+  float pressure;     // hPa
+  
+  // Índices calculados
+  int aqi;            // Air Quality Index
+  String aqi_level;   // Nivel de calidad
+};
+
+AirQualityData airData;
+
+// Timing
+unsigned long lastReadPM = 0;
+unsigned long lastReadGas = 0;
+unsigned long lastReadEnv = 0;
+const unsigned long PM_INTERVAL = 60000;    // 60 segundos
+const unsigned long GAS_INTERVAL = 5000;    // 5 segundos
+const unsigned long ENV_INTERVAL = 30000;   // 30 segundos
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial) delay(10);
+  
+  pinMode(LED_STATUS, OUTPUT);
+  
+  Serial.println(F("================================="));
+  Serial.println(F("  Ornidia Air Quality Monitor"));
+  Serial.println(F("================================="));
+  Serial.println();
+  
+  // Inicializar I2C
+  Wire.begin();
+  
+  // Inicializar sensores
+  initializeSensors();
+  
+  Serial.println(F("Sistema iniciado correctamente"));
+  Serial.println(F("Esperando lecturas estables..."));
+  Serial.println();
+  
+  delay(2000);
+}
+
+void loop() {
+  unsigned long currentMillis = millis();
+  
+  // Leer sensores de partículas (cada 60 segundos)
+  if (currentMillis - lastReadPM >= PM_INTERVAL) {
+    lastReadPM = currentMillis;
+    readPMSensor();
+  }
+  
+  // Leer sensores de gases (cada 5 segundos)
+  if (currentMillis - lastReadGas >= GAS_INTERVAL) {
+    lastReadGas = currentMillis;
+    readGasSensors();
+  }
+  
+  // Leer sensores ambientales (cada 30 segundos)
+  if (currentMillis - lastReadEnv >= ENV_INTERVAL) {
+    lastReadEnv = currentMillis;
+    readEnvironmentalSensors();
+  }
+  
+  // Calcular AQI
+  calculateAQI();
+  
+  // Mostrar datos
+  displayData();
+  
+  // Verificar alertas
+  checkAlerts();
+  
+  delay(1000);
+}
+
+void initializeSensors() {
+  Serial.println(F("Inicializando sensores..."));
+  
+  #ifdef USE_PMS5003
+    pmsSerial.begin(9600);
+    Serial.println(F("  [OK] PMS5003 inicializado"));
+  #endif
+  
+  #ifdef USE_MHZ19B
+    mhz19Serial.begin(9600);
+    // mhz19.begin(mhz19Serial);
+    // mhz19.autoCalibration(true);
+    Serial.println(F("  [OK] MH-Z19B inicializado"));
+  #endif
+  
+  #ifdef USE_CCS811
+    // if (!ccs.begin()) {
+    //   Serial.println(F("  [ERROR] CCS811 no detectado"));
+    // } else {
+    //   Serial.println(F("  [OK] CCS811 inicializado"));
+    //   while (!ccs.available());
+    // }
+    Serial.println(F("  [OK] CCS811 inicializado (simulado)"));
+  #endif
+  
+  #ifdef USE_BME280
+    // if (!bme.begin(0x76)) {
+    //   Serial.println(F("  [ERROR] BME280 no detectado"));
+    // } else {
+    //   Serial.println(F("  [OK] BME280 inicializado"));
+    // }
+    Serial.println(F("  [OK] BME280 inicializado (simulado)"));
+  #endif
+  
+  #ifdef USE_MQ135
+    pinMode(MQ135_PIN, INPUT);
+    Serial.println(F("  [OK] MQ-135 configurado"));
+    Serial.println(F("  [INFO] MQ-135 requiere 24-48h de pre-calentamiento"));
+  #endif
+  
+  Serial.println();
+}
+
+void readPMSensor() {
+  #ifdef USE_PMS5003
+    // PMS::DATA data;
+    // if (pms.readUntil(data)) {
+    //   airData.pm1_0 = data.PM_AE_UG_1_0;
+    //   airData.pm2_5 = data.PM_AE_UG_2_5;
+    //   airData.pm10 = data.PM_AE_UG_10_0;
+    // }
+    
+    // Valores simulados para ejemplo
+    airData.pm1_0 = random(0, 15) + random(0, 100) / 100.0;
+    airData.pm2_5 = random(5, 25) + random(0, 100) / 100.0;
+    airData.pm10 = random(10, 40) + random(0, 100) / 100.0;
+  #else
+    airData.pm1_0 = 0;
+    airData.pm2_5 = 0;
+    airData.pm10 = 0;
+  #endif
+}
+
+void readGasSensors() {
+  #ifdef USE_MHZ19B
+    // int co2 = mhz19.getCO2();
+    // if (co2 > 0) {
+    //   airData.co2 = co2;
+    // }
+    
+    // Valor simulado
+    airData.co2 = random(400, 800);
+  #else
+    airData.co2 = 0;
+  #endif
+  
+  #ifdef USE_CCS811
+    // if (ccs.available()) {
+    //   if (!ccs.readData()) {
+    //     airData.eco2 = ccs.geteCO2();
+    //     airData.tvoc = ccs.getTVOC();
+    //   }
+    // }
+    
+    // Valores simulados
+    airData.eco2 = random(400, 1000);
+    airData.tvoc = random(0, 300);
+  #else
+    airData.eco2 = 0;
+    airData.tvoc = 0;
+  #endif
+  
+  #ifdef USE_MQ135
+    // Leer sensor analógico MQ-135
+    int sensorValue = analogRead(MQ135_PIN);
+    float voltage = sensorValue * (5.0 / 1023.0);
+    // Cálculo simplificado (requiere calibración)
+    float rs = ((5.0 * RL_VALUE) / voltage) - RL_VALUE;
+    float ratio = rs / RO_CLEAN_AIR;
+    // Conversión a ppm (fórmula aproximada)
+    // float ppm = pow(10, ((log10(ratio) - 0.76) / -0.33));
+  #endif
+}
+
+void readEnvironmentalSensors() {
+  #ifdef USE_BME280
+    // airData.temperature = bme.readTemperature();
+    // airData.humidity = bme.readHumidity();
+    // airData.pressure = bme.readPressure() / 100.0;
+    
+    // Valores simulados
+    airData.temperature = 22.0 + random(-20, 50) / 10.0;
+    airData.humidity = 50.0 + random(-100, 200) / 10.0;
+    airData.pressure = 1013.25 + random(-50, 50) / 10.0;
+  #else
+    airData.temperature = 0;
+    airData.humidity = 0;
+    airData.pressure = 0;
+  #endif
+}
+
+void calculateAQI() {
+  // Cálculo AQI basado en PM2.5 (EPA standard)
+  float pm25 = airData.pm2_5;
+  
+  float cLow, cHigh;
+  int iLow, iHigh;
+  
+  if (pm25 <= 12.0) {
+    cLow = 0.0; cHigh = 12.0;
+    iLow = 0; iHigh = 50;
+    airData.aqi_level = "Good";
+  } else if (pm25 <= 35.4) {
+    cLow = 12.1; cHigh = 35.4;
+    iLow = 51; iHigh = 100;
+    airData.aqi_level = "Moderate";
+  } else if (pm25 <= 55.4) {
+    cLow = 35.5; cHigh = 55.4;
+    iLow = 101; iHigh = 150;
+    airData.aqi_level = "Unhealthy (SG)";
+  } else if (pm25 <= 150.4) {
+    cLow = 55.5; cHigh = 150.4;
+    iLow = 151; iHigh = 200;
+    airData.aqi_level = "Unhealthy";
+  } else if (pm25 <= 250.4) {
+    cLow = 150.5; cHigh = 250.4;
+    iLow = 201; iHigh = 300;
+    airData.aqi_level = "Very Unhealthy";
+  } else {
+    cLow = 250.5; cHigh = 500.4;
+    iLow = 301; iHigh = 500;
+    airData.aqi_level = "Hazardous";
+  }
+  
+  // Fórmula AQI
+  float aqi = ((iHigh - iLow) / (cHigh - cLow)) * (pm25 - cLow) + iLow;
+  airData.aqi = round(aqi);
+}
+
+void displayData() {
+  static unsigned long lastDisplay = 0;
+  if (millis() - lastDisplay < 10000) return;  // Mostrar cada 10 segundos
+  lastDisplay = millis();
+  
+  Serial.println(F("========== Air Quality Data =========="));
+  
+  #ifdef USE_PMS5003
+    Serial.println(F("--- Partículas ---"));
+    Serial.print(F("PM1.0:  ")); Serial.print(airData.pm1_0); Serial.println(F(" μg/m³"));
+    Serial.print(F("PM2.5:  ")); Serial.print(airData.pm2_5); Serial.println(F(" μg/m³"));
+    Serial.print(F("PM10:   ")); Serial.print(airData.pm10); Serial.println(F(" μg/m³"));
+    Serial.println();
+  #endif
+  
+  #ifdef USE_MHZ19B
+    Serial.println(F("--- Gases ---"));
+    Serial.print(F("CO₂:    ")); Serial.print(airData.co2); Serial.println(F(" ppm"));
+  #endif
+  
+  #ifdef USE_CCS811
+    Serial.print(F("eCO₂:   ")); Serial.print(airData.eco2); Serial.println(F(" ppm"));
+    Serial.print(F("TVOC:   ")); Serial.print(airData.tvoc); Serial.println(F(" ppb"));
+    Serial.println();
+  #endif
+  
+  #ifdef USE_BME280
+    Serial.println(F("--- Ambiente ---"));
+    Serial.print(F("Temp:   ")); Serial.print(airData.temperature); Serial.println(F(" °C"));
+    Serial.print(F("Hum:    ")); Serial.print(airData.humidity); Serial.println(F(" %"));
+    Serial.print(F("Pres:   ")); Serial.print(airData.pressure); Serial.println(F(" hPa"));
+    Serial.println();
+  #endif
+  
+  Serial.println(F("--- Índice de Calidad ---"));
+  Serial.print(F("AQI:    ")); Serial.print(airData.aqi);
+  Serial.print(F(" (")); Serial.print(airData.aqi_level); Serial.println(F(")"));
+  
+  Serial.println(F("======================================"));
+  Serial.println();
+}
+
+void checkAlerts() {
+  static bool alertActive = false;
+  
+  // Alertas por PM2.5
+  if (airData.pm2_5 > 55.4) {
+    if (!alertActive) {
+      Serial.println(F("⚠️  ALERTA: PM2.5 en nivel dañino!"));
+      alertActive = true;
+      digitalWrite(LED_STATUS, HIGH);
+    }
+  } else if (airData.pm2_5 > 35.4) {
+    if (!alertActive) {
+      Serial.println(F("⚠️  PRECAUCIÓN: PM2.5 en nivel dañino para grupos sensibles"));
+      alertActive = true;
+      digitalWrite(LED_STATUS, HIGH);
+    }
+  } else {
+    alertActive = false;
+    digitalWrite(LED_STATUS, LOW);
+  }
+  
+  // Alertas por CO₂ (interior)
+  if (airData.co2 > 2000) {
+    Serial.println(F("⚠️  ALERTA: CO₂ alto - Ventilar inmediatamente!"));
+  } else if (airData.co2 > 1000) {
+    Serial.println(F("⚠️  ADVERTENCIA: CO₂ elevado - Recomienda ventilación"));
+  }
+  
+  // Alertas por TVOC
+  if (airData.tvoc > 2200) {
+    Serial.println(F("⚠️  ALERTA: TVOC alto - Calidad del aire pobre"));
+  }
+}
+
+/*
+ * Funciones adicionales para implementar:
+ * 
+ * - sendToCloud(): Enviar datos a ThingSpeak, Sensor.Community, etc.
+ * - saveToSD(): Almacenar datos en tarjeta SD
+ * - displayOLED(): Mostrar en pantalla OLED local
+ * - webServer(): Servidor web para dashboard local
+ * - mqttPublish(): Publicar a broker MQTT
+ * - calculateIAQ(): Calcular Indoor Air Quality Index
+ * - historicalAverage(): Promedios móviles de 1h, 24h
+ */
diff --git a/air_quality/sensors/ccs811_sensor.ino b/air_quality/sensors/ccs811_sensor.ino
new file mode 100644
index 0000000..4f76d9c
--- /dev/null
+++ b/air_quality/sensors/ccs811_sensor.ino
@@ -0,0 +1,115 @@
+/*
+ * Ornidia - Sensor CCS811
+ * 
+ * Ejemplo de uso del sensor CCS811
+ * Mide: eCO₂ (equivalente CO₂) y TVOC (compuestos orgánicos volátiles)
+ * 
+ * Conexiones:
+ * CCS811 VCC -> 3.3V
+ * CCS811 GND -> GND
+ * CCS811 SDA -> A4 (SDA)
+ * CCS811 SCL -> A5 (SCL)
+ * CCS811 WAK -> GND (wake - activo bajo)
+ * 
+ * Librería requerida: Adafruit CCS811 Library
+ * arduino-cli lib install "Adafruit CCS811 Library"
+ */
+
+#include <Wire.h>
+// #include <Adafruit_CCS811.h>
+
+// Adafruit_CCS811 ccs;
+
+void setup() {
+  Serial.begin(115200);
+  
+  Serial.println("CCS811 eCO₂/TVOC Sensor");
+  Serial.println("=======================");
+  
+  // if (!ccs.begin()) {
+  //   Serial.println("ERROR: Sensor CCS811 no detectado!");
+  //   Serial.println("Verificar conexiones I2C");
+  //   while (1) delay(10);
+  // }
+  
+  Serial.println("Sensor CCS811 inicializado");
+  Serial.println("IMPORTANTE: Requiere 48 horas de burn-in para lecturas precisas");
+  Serial.println("Las lecturas mejorarán con el tiempo de uso");
+  
+  // Esperar a que el sensor esté listo
+  // while (!ccs.available()) delay(10);
+  
+  delay(1000);
+}
+
+void loop() {
+  // if (ccs.available()) {
+  //   if (!ccs.readData()) {
+  //     int eco2 = ccs.geteCO2();
+  //     int tvoc = ccs.getTVOC();
+  //     
+  //     Serial.print("eCO₂: ");
+  //     Serial.print(eco2);
+  //     Serial.println(" ppm");
+  //     
+  //     Serial.print("TVOC: ");
+  //     Serial.print(tvoc);
+  //     Serial.println(" ppb");
+  //     
+  //     interpretarNiveles(eco2, tvoc);
+  //   } else {
+  //     Serial.println("ERROR: No se pudo leer del sensor");
+  //   }
+  // }
+  
+  // Valores simulados (descomentar arriba para sensor real)
+  int eco2 = random(400, 1500);
+  int tvoc = random(0, 500);
+  
+  Serial.print("eCO₂: ");
+  Serial.print(eco2);
+  Serial.println(" ppm");
+  
+  Serial.print("TVOC: ");
+  Serial.print(tvoc);
+  Serial.println(" ppb");
+  
+  interpretarNiveles(eco2, tvoc);
+  
+  delay(2000);
+}
+
+void interpretarNiveles(int eco2, int tvoc) {
+  // Interpretar eCO₂
+  Serial.print("CO₂: ");
+  if (eco2 < 600) {
+    Serial.println("Excelente ✓✓✓");
+  } else if (eco2 < 1000) {
+    Serial.println("Bueno ✓✓");
+  } else if (eco2 < 1500) {
+    Serial.println("Moderado ✓");
+  } else if (eco2 < 2500) {
+    Serial.println("Pobre ⚠");
+  } else {
+    Serial.println("Muy pobre ⚠⚠");
+  }
+  
+  // Interpretar TVOC
+  Serial.print("TVOC: ");
+  if (tvoc < 220) {
+    Serial.println("Excelente ✓✓✓");
+  } else if (tvoc < 660) {
+    Serial.println("Bueno ✓✓");
+  } else if (tvoc < 2200) {
+    Serial.println("Moderado ✓");
+  } else {
+    Serial.println("Pobre ⚠");
+  }
+  
+  Serial.println("--------------------------------");
+}
+
+// Función para calibración con datos ambientales reales
+// void calibrateWithEnvironment(float temp, float humidity) {
+//   ccs.setEnvironmentalData(humidity, temp);
+// }
diff --git a/air_quality/sensors/mhz19_sensor.ino b/air_quality/sensors/mhz19_sensor.ino
new file mode 100644
index 0000000..8d6ada1
--- /dev/null
+++ b/air_quality/sensors/mhz19_sensor.ino
@@ -0,0 +1,88 @@
+/*
+ * Ornidia - Sensor MH-Z19B
+ * 
+ * Ejemplo de uso del sensor de CO₂ NDIR MH-Z19B
+ * Mide: CO₂ (400-5000 ppm)
+ * 
+ * Conexiones:
+ * MH-Z19B VIN -> 5V (4.5-5.5V)
+ * MH-Z19B GND -> GND
+ * MH-Z19B TX  -> Arduino RX (Pin 2 SoftwareSerial)
+ * MH-Z19B RX  -> Arduino TX (Pin 3 SoftwareSerial)
+ * 
+ * Librería requerida: MH-Z19
+ * arduino-cli lib install "MH-Z19"
+ */
+
+#include <SoftwareSerial.h>
+// #include <MHZ19.h>
+
+SoftwareSerial mhz19Serial(2, 3); // RX, TX
+// MHZ19 mhz19;
+
+unsigned long getDataTimer = 0;
+
+void setup() {
+  Serial.begin(115200);
+  mhz19Serial.begin(9600);
+  
+  // mhz19.begin(mhz19Serial);
+  // mhz19.autoCalibration(true); // Auto-calibración en aire exterior (400ppm)
+  
+  Serial.println("MH-Z19B CO₂ Sensor");
+  Serial.println("==================");
+  Serial.println("Esperando 3 minutos para warm-up...");
+  
+  delay(3000);  // En producción: delay(180000) para 3 minutos
+}
+
+void loop() {
+  if (millis() - getDataTimer >= 5000) {
+    // int co2 = mhz19.getCO2();
+    // int temp = mhz19.getTemperature();
+    
+    // Valores simulados (descomentar arriba para sensor real)
+    int co2 = random(400, 1200);
+    int temp = random(20, 25);
+    
+    Serial.print("CO₂: ");
+    Serial.print(co2);
+    Serial.println(" ppm");
+    
+    Serial.print("Temperatura: ");
+    Serial.print(temp);
+    Serial.println(" °C");
+    
+    // Interpretar nivel de CO₂
+    if (co2 < 400) {
+      Serial.println("Estado: Exterior/Referencia");
+    } else if (co2 < 1000) {
+      Serial.println("Estado: Bueno ✓");
+    } else if (co2 < 2000) {
+      Serial.println("Estado: Ventilación recomendada ⚠");
+    } else if (co2 < 5000) {
+      Serial.println("Estado: Aire viciado - Ventilar! ⚠⚠");
+    } else {
+      Serial.println("Estado: PELIGROSO ⚠⚠⚠");
+    }
+    
+    Serial.println("--------------------------------");
+    
+    getDataTimer = millis();
+  }
+}
+
+// Calibración manual a 400ppm (ejecutar en aire exterior limpio)
+void calibrateTo400ppm() {
+  Serial.println("Iniciando calibración a 400ppm...");
+  // mhz19.calibrate();
+  Serial.println("Calibración completada!");
+}
+
+// Obtener rango de medición
+void getRange() {
+  // int range = mhz19.getRange();
+  // Serial.print("Rango: 0-");
+  // Serial.print(range);
+  // Serial.println(" ppm");
+}
diff --git a/air_quality/sensors/mq135_sensor.ino b/air_quality/sensors/mq135_sensor.ino
new file mode 100644
index 0000000..9db180f
--- /dev/null
+++ b/air_quality/sensors/mq135_sensor.ino
@@ -0,0 +1,154 @@
+/*
+ * Ornidia - Sensor MQ-135
+ * 
+ * Ejemplo de uso del sensor de calidad del aire MQ-135
+ * Detecta: NH3, NOx, alcohol, benzeno, humo, CO₂
+ * 
+ * Conexiones:
+ * MQ-135 VCC  -> 5V
+ * MQ-135 GND  -> GND
+ * MQ-135 AOUT -> A0 (salida analógica)
+ * MQ-135 DOUT -> D8 (salida digital - opcional)
+ * 
+ * IMPORTANTE: Requiere pre-calentamiento de 24-48 horas para lecturas estables
+ */
+
+const int MQ135_APIN = A0;
+const int MQ135_DPIN = 8;
+
+// Constantes de calibración (ajustar según calibración en aire limpio)
+const float RL_VALUE = 10.0;        // Resistencia de carga en kOhm
+const float RO_CLEAN_AIR = 3.6;     // Resistencia del sensor en aire limpio (kOhm)
+const float ATMOCO2 = 400.0;        // Concentración atmosférica de CO₂ (ppm)
+
+// Parámetros de la curva de CO₂ (datasheet MQ-135)
+const float PARA = 116.6020682;
+const float PARB = 2.769034857;
+
+// Variables para promedio móvil
+const int NUM_READINGS = 10;
+int readings[NUM_READINGS];
+int readIndex = 0;
+int total = 0;
+int average = 0;
+
+void setup() {
+  Serial.begin(115200);
+  pinMode(MQ135_DPIN, INPUT);
+  
+  Serial.println("Sensor MQ-135 - Calidad del Aire");
+  Serial.println("=================================");
+  Serial.println();
+  Serial.println("ADVERTENCIA:");
+  Serial.println("- Requiere 24-48h de pre-calentamiento inicial");
+  Serial.println("- Las lecturas se estabilizan después del warm-up");
+  Serial.println("- Calibrar R0 en aire limpio para mejor precisión");
+  Serial.println();
+  
+  // Inicializar array de lecturas
+  for (int i = 0; i < NUM_READINGS; i++) {
+    readings[i] = 0;
+  }
+  
+  delay(2000);
+}
+
+void loop() {
+  // Leer valor analógico
+  int sensorValue = analogRead(MQ135_APIN);
+  
+  // Promedio móvil
+  total = total - readings[readIndex];
+  readings[readIndex] = sensorValue;
+  total = total + readings[readIndex];
+  readIndex = (readIndex + 1) % NUM_READINGS;
+  average = total / NUM_READINGS;
+  
+  // Convertir a voltaje
+  float voltage = average * (5.0 / 1023.0);
+  
+  // Calcular resistencia del sensor (Rs)
+  float rs = ((5.0 * RL_VALUE) / voltage) - RL_VALUE;
+  
+  // Calcular ratio Rs/R0
+  float ratio = rs / RO_CLEAN_AIR;
+  
+  // Calcular concentración de CO₂ (ppm)
+  float ppm = PARA * pow(ratio, -PARB);
+  
+  // Mostrar resultados
+  Serial.println("=== Lectura MQ-135 ===");
+  Serial.print("Valor ADC: ");
+  Serial.println(average);
+  
+  Serial.print("Voltaje: ");
+  Serial.print(voltage);
+  Serial.println(" V");
+  
+  Serial.print("Rs: ");
+  Serial.print(rs);
+  Serial.println(" kΩ");
+  
+  Serial.print("Rs/R0: ");
+  Serial.println(ratio);
+  
+  Serial.print("CO₂ estimado: ");
+  Serial.print(ppm);
+  Serial.println(" ppm");
+  
+  // Leer salida digital (umbral)
+  int digitalValue = digitalRead(MQ135_DPIN);
+  Serial.print("Umbral digital: ");
+  Serial.println(digitalValue == HIGH ? "NO SUPERADO" : "SUPERADO ⚠");
+  
+  // Interpretación de calidad
+  interpretarCalidad(ppm);
+  
+  Serial.println("======================\n");
+  
+  delay(2000);
+}
+
+void interpretarCalidad(float co2_ppm) {
+  Serial.print("Calidad del aire: ");
+  
+  if (co2_ppm < 600) {
+    Serial.println("Excelente ✓✓✓");
+  } else if (co2_ppm < 1000) {
+    Serial.println("Bueno ✓✓");
+  } else if (co2_ppm < 1500) {
+    Serial.println("Aceptable ✓");
+  } else if (co2_ppm < 2000) {
+    Serial.println("Moderado - Ventilar ⚠");
+  } else if (co2_ppm < 5000) {
+    Serial.println("Pobre - Ventilar inmediatamente ⚠⚠");
+  } else {
+    Serial.println("Peligroso ⚠⚠⚠");
+  }
+}
+
+// Función de calibración en aire limpio
+float calibrateR0() {
+  Serial.println("Iniciando calibración...");
+  Serial.println("Asegúrese de estar en aire limpio");
+  Serial.println("Leyendo 50 muestras...");
+  
+  float rs_sum = 0;
+  for (int i = 0; i < 50; i++) {
+    int sensorValue = analogRead(MQ135_APIN);
+    float voltage = sensorValue * (5.0 / 1023.0);
+    float rs = ((5.0 * RL_VALUE) / voltage) - RL_VALUE;
+    rs_sum += rs;
+    delay(100);
+  }
+  
+  float rs_avg = rs_sum / 50.0;
+  float r0 = rs_avg / pow(ATMOCO2 / PARA, 1.0 / PARB);
+  
+  Serial.print("R0 calibrado: ");
+  Serial.print(r0);
+  Serial.println(" kΩ");
+  Serial.println("Actualizar RO_CLEAN_AIR en el código con este valor");
+  
+  return r0;
+}
diff --git a/air_quality/sensors/pms5003_sensor.ino b/air_quality/sensors/pms5003_sensor.ino
new file mode 100644
index 0000000..b8d1b4f
--- /dev/null
+++ b/air_quality/sensors/pms5003_sensor.ino
@@ -0,0 +1,78 @@
+/*
+ * Ornidia - Sensor PMS5003/PMS7003
+ * 
+ * Ejemplo de uso del sensor láser de partículas Plantower PMS5003/PMS7003
+ * Mide: PM1.0, PM2.5, PM10
+ * 
+ * Conexiones:
+ * PMS5003 VCC -> 5V
+ * PMS5003 GND -> GND
+ * PMS5003 TX  -> Arduino RX (Pin 10 SoftwareSerial)
+ * PMS5003 RX  -> Arduino TX (Pin 11 SoftwareSerial - opcional)
+ * PMS5003 SET -> Pin 12 (Sleep/Wake - opcional)
+ * 
+ * Librería requerida: PMS Library
+ * arduino-cli lib install "PMS Library"
+ */
+
+#include <SoftwareSerial.h>
+// #include <PMS.h>
+
+// Configuración SoftwareSerial para PMS5003
+SoftwareSerial pmsSerial(10, 11); // RX, TX
+// PMS pms(pmsSerial);
+// PMS::DATA data;
+
+const int PMS_SET_PIN = 12;  // Pin para sleep/wake (opcional)
+
+void setup() {
+  Serial.begin(115200);
+  pmsSerial.begin(9600);
+  
+  pinMode(PMS_SET_PIN, OUTPUT);
+  digitalWrite(PMS_SET_PIN, HIGH); // Wake up sensor
+  
+  Serial.println("PMS5003 Particle Sensor");
+  Serial.println("=======================");
+  
+  // Esperar estabilización del sensor
+  Serial.println("Esperando 30 segundos para estabilización...");
+  delay(30000);
+}
+
+void loop() {
+  // Leer datos del sensor
+  // if (pms.readUntil(data)) {
+  //   Serial.println("=== Concentración Estándar (CF=1) ===");
+  //   Serial.print("PM1.0: "); Serial.print(data.PM_SP_UG_1_0); Serial.println(" μg/m³");
+  //   Serial.print("PM2.5: "); Serial.print(data.PM_SP_UG_2_5); Serial.println(" μg/m³");
+  //   Serial.print("PM10:  "); Serial.print(data.PM_SP_UG_10_0); Serial.println(" μg/m³");
+  //   
+  //   Serial.println("\n=== Concentración Atmosférica ===");
+  //   Serial.print("PM1.0: "); Serial.print(data.PM_AE_UG_1_0); Serial.println(" μg/m³");
+  //   Serial.print("PM2.5: "); Serial.print(data.PM_AE_UG_2_5); Serial.println(" μg/m³");
+  //   Serial.print("PM10:  "); Serial.print(data.PM_AE_UG_10_0); Serial.println(" μg/m³");
+  //   Serial.println("=====================================\n");
+  // }
+  
+  // Ejemplo con valores simulados (descomentar líneas arriba para usar sensor real)
+  Serial.println("=== PMS5003 Reading (Simulated) ===");
+  Serial.print("PM1.0: "); Serial.print(random(0, 15)); Serial.println(" μg/m³");
+  Serial.print("PM2.5: "); Serial.print(random(5, 25)); Serial.println(" μg/m³");
+  Serial.print("PM10:  "); Serial.print(random(10, 40)); Serial.println(" μg/m³");
+  Serial.println("====================================\n");
+  
+  delay(2000);  // Leer cada 2 segundos (recomendado: 60s para ahorro de energía)
+}
+
+// Función para activar modo sleep (ahorro de energía)
+void pmsSleep() {
+  digitalWrite(PMS_SET_PIN, LOW);
+  delay(100);
+}
+
+// Función para despertar sensor
+void pmsWake() {
+  digitalWrite(PMS_SET_PIN, HIGH);
+  delay(30000);  // Esperar 30s para estabilización
+}

From 7b350435844f802fab27f7314911589b3a87d8ad Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 7 Dec 2025 04:28:55 +0000
Subject: [PATCH 3/4] Add PLATFORMS.md guide and air quality examples, all
 systems documented

Co-authored-by: xtatikmel <8581177+xtatikmel@users.noreply.github.com>
---
 PLATFORMS.md                             | 340 +++++++++++++++++++++++
 QUICKSTART.md                            |   2 +
 README.md                                |   1 +
 air_quality/examples/basic_monitor.ino   | 164 +++++++++++
 air_quality/examples/outdoor_monitor.ino | 217 +++++++++++++++
 5 files changed, 724 insertions(+)
 create mode 100644 PLATFORMS.md
 create mode 100644 air_quality/examples/basic_monitor.ino
 create mode 100644 air_quality/examples/outdoor_monitor.ino

diff --git a/PLATFORMS.md b/PLATFORMS.md
new file mode 100644
index 0000000..579f19c
--- /dev/null
+++ b/PLATFORMS.md
@@ -0,0 +1,340 @@
+# Ornidia - Guía de Plataformas
+
+Esta guía detalla qué plataforma usar para cada sistema del proyecto Ornidia y sus ventajas específicas.
+
+## 📋 Resumen de Compatibilidad
+
+| Sistema | ESP8266 | ESP32 | Arduino | Raspberry Pi |
+|---------|---------|-------|---------|--------------|
+| 🔆 **Panel Solar** | ✅ **Recomendado** | ⚪ No necesario | ⚪ No WiFi | ⚪ Excesivo |
+| 🌱 **Invernadero** | ✅ Recomendado | ✅ Avanzado | ✅ Básico | ⚪ Opcional |
+| 🌤️ **Meteorológica** | ✅ Básico | ✅ Recomendado | ✅ Con Ethernet | ✅ Servidor |
+| 💨 **Calidad Aire** | ⚪ Futuro | ⚪ Futuro | ✅ **Recomendado** | ✅ Avanzado |
+
+---
+
+## 🔆 Sistema de Panel Solar
+
+### Plataforma Recomendada: **ESP8266**
+
+#### ¿Por qué ESP8266?
+- ✅ WiFi integrado para envío de datos a cloud
+- ✅ Bajo consumo energético (importante para sistema solar)
+- ✅ Suficiente memoria para sensores y web server
+- ✅ Económico (~$3-5 USD)
+- ✅ 1 ADC analógico suficiente (con multiplexor CD4052B)
+
+#### Configuración Típica
+```
+ESP8266 + ACS712 (×3) + CD4052B + BH1750
+```
+
+#### Alternativas
+- **Arduino Mega + Ethernet Shield**: Si requieres conexión cableada
+- **ESP32**: Si necesitas más pines o procesamiento (no necesario para este sistema)
+
+---
+
+## 🌱 Sistema de Invernadero
+
+### Plataformas Recomendadas: **ESP8266** / **ESP32** / **Arduino**
+
+### Opción 1: ESP8266 (Básico con WiFi)
+#### Ideal para:
+- Invernadero pequeño a mediano
+- Monitoreo remoto vía WiFi
+- Control básico de relés
+- Presupuesto limitado
+
+#### Configuración
+```
+ESP8266 + DHT22 + BH1750 + Sensor humedad suelo + 2-4 relés
+```
+
+### Opción 2: ESP32 (Avanzado)
+#### Ideal para:
+- Invernadero grande
+- Múltiples zonas de control
+- Cámara ESP32-CAM
+- Bluetooth para configuración local
+
+#### Ventajas sobre ESP8266
+- ✅ Más pines GPIO (control de más actuadores)
+- ✅ Dual-core (multitarea real)
+- ✅ Bluetooth integrado
+- ✅ Mayor velocidad de procesamiento
+- ✅ Compatible con cámaras
+
+#### Configuración
+```
+ESP32 + DHT22 (×2-3) + BH1750 + BME280 + Múltiples sensores suelo + 8+ relés
+```
+
+### Opción 3: Arduino Uno/Nano (Sin WiFi)
+#### Ideal para:
+- Primer proyecto / aprendizaje
+- Sin necesidad de conectividad
+- Almacenamiento local en SD
+- Máxima simplicidad
+
+#### Configuración
+```
+Arduino Uno + DHT11 + Sensor humedad suelo + 2 relés + SD card
+```
+
+---
+
+## 🌤️ Estación Meteorológica
+
+### Plataformas Recomendadas: **ESP32** / **Arduino Mega** / **Raspberry Pi**
+
+### Opción 1: ESP32 (Recomendado para uso general)
+#### Ideal para:
+- Estación completa con WiFi
+- Envío a servicios cloud (Weather Underground, ThingSpeak)
+- Múltiples sensores simultáneos
+- Dashboard web embebido
+
+#### Ventajas
+- ✅ WiFi y Bluetooth
+- ✅ Suficientes pines para todos los sensores
+- ✅ Procesamiento rápido para cálculos meteorológicos
+- ✅ Deep sleep para ahorro con panel solar
+
+#### Configuración
+```
+ESP32 + BMP280 + DHT22 + BH1750 + Anemómetro + Pluviómetro + UV sensor
+```
+
+### Opción 2: ESP8266 (Básico)
+#### Ideal para:
+- Estación simple (temp, hum, presión, luz)
+- Sin sensores de viento/lluvia
+- Presupuesto muy limitado
+
+#### Limitaciones
+- Pocos pines GPIO (máximo 4-5 sensores)
+- Sin hardware interrupts confiables para pluviómetro
+
+### Opción 3: Arduino Mega + Ethernet/WiFi Shield
+#### Ideal para:
+- Máxima cantidad de sensores
+- Conexión Ethernet cableada
+- Sin depender de WiFi
+- Estación profesional fija
+
+#### Ventajas
+- ✅ 54 pines digitales + 16 analógicos
+- ✅ Ethernet confiable (cable UTP)
+- ✅ Mayor estabilidad para exteriores
+- ✅ Sin interferencias WiFi
+
+#### Configuración
+```
+Arduino Mega + Ethernet Shield + BME280 + BH1750 + DHT22 + 
+Anemómetro + Veleta + Pluviómetro + UV + Detector rayos
+```
+
+### Opción 4: Raspberry Pi (Servidor + Adquisición)
+#### Ideal para:
+- Estación meteorológica profesional
+- Procesamiento avanzado de datos
+- Servidor web local con Grafana
+- Machine Learning para predicción
+- Múltiples estaciones remotas
+
+#### Ventajas
+- ✅ Linux completo
+- ✅ Python para análisis avanzado
+- ✅ Base de datos local (MySQL/PostgreSQL/InfluxDB)
+- ✅ Almacenamiento masivo (SD grande o SSD)
+- ✅ Servidor web completo
+
+#### Configuración
+```
+Raspberry Pi 4 + Sensores I2C/SPI + Arduino como ADC externo + 
+Base de datos + Grafana + Node-RED + Servidor web
+```
+
+---
+
+## 💨 Sistema de Calidad del Aire
+
+### Plataformas Recomendadas: **Arduino Uno/Mega** / **Raspberry Pi**
+
+### Opción 1: Arduino Uno/Mega (Recomendado)
+#### Ideal para:
+- Monitor de calidad del aire interior
+- Uso en escuelas, oficinas, hogares
+- Presupuesto limitado
+- Simplicidad y confiabilidad
+
+#### ¿Por qué Arduino y no ESP?
+- ✅ Voltaje 5V nativo (sensores como PMS5003 requieren 5V)
+- ✅ SoftwareSerial confiable para múltiples UART
+- ✅ No sobrecalentamiento (sensores funcionan 24/7)
+- ✅ Más pines analógicos para sensores MQ
+- ✅ Económico
+
+#### Arduino Uno
+Para monitor básico:
+```
+Arduino Uno + PMS5003 + MH-Z19B + (opcional: BME280)
+```
+
+#### Arduino Mega
+Para monitor completo:
+```
+Arduino Mega + PMS5003 + MH-Z19B + CCS811 + BME280 + MQ-135 + MQ-7 + SD card
+```
+
+### Opción 2: Raspberry Pi (Avanzado)
+#### Ideal para:
+- Monitor exterior urbano
+- Integración con redes comunitarias (Sensor.Community, PurpleAir)
+- Procesamiento de datos en tiempo real
+- Múltiples sensores + cámara
+
+#### Ventajas
+- ✅ Conectividad WiFi/Ethernet integrada
+- ✅ Python para fácil integración con APIs
+- ✅ Almacenamiento masivo de datos
+- ✅ Dashboard web local
+- ✅ Envío automático a múltiples plataformas
+
+#### Configuración
+```
+Raspberry Pi 3/4 + PMS5003 (USB Serial) + MH-Z19B (USB Serial) + 
+BME280 (I2C) + Base de datos + Dashboard + Envío a cloud
+```
+
+### ¿Por qué NO ESP8266/ESP32 (por ahora)?
+- ⚠️ Voltaje 3.3V requiere conversores de nivel
+- ⚠️ PMS5003 requiere 5V (consume ~100mA)
+- ⚠️ SoftwareSerial limitado en ESP
+- ⚠️ Múltiples UART dificultan conexión simultánea
+- ⚠️ ESP puede sobrecalentarse con sensores 24/7
+
+**Nota**: Soporte para ESP en desarrollo con conversores de nivel.
+
+---
+
+## 📊 Comparativa de Características
+
+| Característica | ESP8266 | ESP32 | Arduino | Raspberry Pi |
+|---------------|---------|-------|---------|--------------|
+| **Precio** | $3-5 | $6-10 | $5-15 | $35-75 |
+| **WiFi** | ✅ | ✅ | ❌* | ✅ |
+| **Bluetooth** | ❌ | ✅ | ❌ | ✅ |
+| **Voltaje I/O** | 3.3V | 3.3V | 5V | 3.3V |
+| **Pines GPIO** | ~11 | ~34 | 14-54 | 40 |
+| **Pines ADC** | 1 | 18 | 6-16 | ❌** |
+| **RAM** | 80KB | 520KB | 2-8KB | 1-8GB |
+| **Procesamiento** | 80MHz | 240MHz | 16MHz | 1.5GHz |
+| **Consumo** | Bajo | Medio | Muy bajo | Alto |
+| **SO/Linux** | ❌ | ❌ | ❌ | ✅ |
+
+*Con módulo externo
+**Requiere ADC externo (MCP3008)
+
+---
+
+## 🔋 Consideraciones de Energía
+
+### Para Sistemas con Panel Solar
+
+#### Mejor opción: ESP8266
+- Consumo activo: ~70mA
+- Deep sleep: ~20μA
+- WiFi: ~170mA (transmisión corta)
+
+#### ESP32 Deep Sleep
+- Consumo activo: ~160mA
+- Deep sleep: ~10μA
+- Ideal para envío cada 5-15 minutos
+
+#### Arduino + Shield Ethernet
+- Consumo constante: ~200mA
+- No tiene deep sleep eficiente
+- Requiere panel solar más grande
+
+---
+
+## 🌐 Conectividad Requerida
+
+### WiFi (ESP8266/ESP32)
+- ✅ Panel Solar: Envío a cloud
+- ✅ Invernadero: Control remoto
+- ✅ Meteorológica: Weather Underground
+- ❌ Calidad Aire: No prioritario (uso local)
+
+### Ethernet (Arduino Mega)
+- ✅ Meteorológica: Instalación fija
+- ⚪ Panel Solar: Alternativa sin WiFi
+- ❌ Invernadero: Cable limitante
+- ❌ Calidad Aire: No necesario
+
+### Sin Conectividad (Arduino Uno + SD)
+- ⚪ Cualquier sistema puede funcionar sin conexión
+- Almacenamiento local en tarjeta SD
+- Lectura por puerto serial
+
+---
+
+## 💡 Recomendaciones por Caso de Uso
+
+### 1. "Quiero empezar con lo más simple"
+→ **Arduino Uno** + Sensores básicos + Monitor Serial
+
+### 2. "Necesito monitoreo remoto WiFi económico"
+→ **ESP8266** (Panel Solar, Invernadero básico)
+
+### 3. "Proyecto profesional con múltiples sensores"
+→ **ESP32** o **Arduino Mega** (Meteorológica, Invernadero grande)
+
+### 4. "Servidor local con procesamiento avanzado"
+→ **Raspberry Pi** (Meteorológica central, Calidad aire urbano)
+
+### 5. "Máxima autonomía con panel solar"
+→ **ESP8266 con deep sleep** (Panel Solar, Meteorológica simple)
+
+### 6. "Calidad del aire en casa/escuela"
+→ **Arduino Uno/Mega** (Calidad Aire interior)
+
+### 7. "Red de sensores comunitarios"
+→ **Raspberry Pi** (Múltiples nodos de Calidad Aire)
+
+---
+
+## 🔄 Migración entre Plataformas
+
+El código de Ornidia está diseñado para ser portable:
+
+1. **Librerías estándar**: Wire, SoftwareSerial, etc.
+2. **Abstracción de hardware**: Fácil cambio de pines
+3. **Código modular**: Sensores independientes
+
+### Ejemplo de migración:
+```cpp
+// ESP8266
+#define DHT_PIN D7
+
+// Arduino
+#define DHT_PIN 7
+
+// Mismo código de lectura
+dht.begin(DHT_PIN);
+```
+
+---
+
+## 📚 Recursos Adicionales
+
+- [Pinout ESP8266](https://randomnerdtutorials.com/esp8266-pinout-reference-gpios/)
+- [Pinout ESP32](https://randomnerdtutorials.com/esp32-pinout-reference-gpios/)
+- [Arduino Mega Pinout](https://www.arduino.cc/en/Hacking/PinMapping2560)
+- [Raspberry Pi GPIO](https://pinout.xyz/)
+
+---
+
+**Última actualización**: 2025-10-27
diff --git a/QUICKSTART.md b/QUICKSTART.md
index 1bfcda9..c56e1f6 100644
--- a/QUICKSTART.md
+++ b/QUICKSTART.md
@@ -300,11 +300,13 @@ chmod +x verify_integrity.sh
 ## 📚 Documentación Completa
 
 - **[README.md](README.md)** - Descripción general del proyecto
+- **[PLATFORMS.md](PLATFORMS.md)** - Guía de plataformas y compatibilidad
 - **[LIBRARIES.md](LIBRARIES.md)** - Dependencias de librerías
 - **[TESTING.md](TESTING.md)** - Guía completa de pruebas
 - **[solar_panel/README.md](solar_panel/README.md)** - Sistema solar
 - **[greenhouse/README.md](greenhouse/README.md)** - Sistema de invernadero
 - **[weather_station/README.md](weather_station/README.md)** - Estación meteorológica
+- **[air_quality/README.md](air_quality/README.md)** - Sistema de calidad del aire
 
 ---
 
diff --git a/README.md b/README.md
index 7936a14..f6ee3e0 100644
--- a/README.md
+++ b/README.md
@@ -287,6 +287,7 @@ Failed: 0
 - 📘 **[TESTING.md](TESTING.md)** - Guía completa de pruebas y verificación
 - 📗 **[LIBRARIES.md](LIBRARIES.md)** - Dependencias y librerías requeridas
 - 📙 **[QUICKSTART.md](QUICKSTART.md)** - Guía rápida de inicio
+- 📋 **[PLATFORMS.md](PLATFORMS.md)** - Guía de plataformas y compatibilidad
 
 ### CI/CD
 
diff --git a/air_quality/examples/basic_monitor.ino b/air_quality/examples/basic_monitor.ino
new file mode 100644
index 0000000..c69c6e9
--- /dev/null
+++ b/air_quality/examples/basic_monitor.ino
@@ -0,0 +1,164 @@
+/*
+ * Ornidia - Monitor Básico de Calidad del Aire
+ * 
+ * Monitor simple con sensor de partículas PMS5003 y sensor CO₂ MH-Z19B
+ * Ideal para principiantes y monitoreo básico de interior
+ * 
+ * Hardware:
+ * - Arduino Uno/Nano
+ * - PMS5003 (PM2.5 y PM10)
+ * - MH-Z19B (CO₂)
+ * 
+ * Conexiones:
+ * PMS5003:
+ *   VCC -> 5V
+ *   GND -> GND
+ *   TX  -> D10 (SoftwareSerial RX)
+ * 
+ * MH-Z19B:
+ *   VIN -> 5V
+ *   GND -> GND
+ *   TX  -> D2 (SoftwareSerial RX)
+ *   RX  -> D3 (SoftwareSerial TX)
+ */
+
+#include <SoftwareSerial.h>
+
+// Configuración PMS5003
+SoftwareSerial pmsSerial(10, 11); // RX, TX
+
+// Configuración MH-Z19B
+SoftwareSerial co2Serial(2, 3);   // RX, TX
+
+// Variables de medición
+struct {
+  float pm25;
+  float pm10;
+  int co2;
+  int aqi;
+  String status;
+} airData;
+
+unsigned long lastRead = 0;
+const unsigned long READ_INTERVAL = 60000; // 60 segundos
+
+void setup() {
+  Serial.begin(115200);
+  pmsSerial.begin(9600);
+  co2Serial.begin(9600);
+  
+  Serial.println(F("======================================"));
+  Serial.println(F("  Monitor Básico de Calidad del Aire"));
+  Serial.println(F("======================================"));
+  Serial.println();
+  Serial.println(F("Sensores:"));
+  Serial.println(F("  - PMS5003 (PM2.5, PM10)"));
+  Serial.println(F("  - MH-Z19B (CO₂)"));
+  Serial.println();
+  Serial.println(F("Inicializando..."));
+  
+  delay(3000); // Esperar estabilización
+  Serial.println(F("Listo!"));
+  Serial.println();
+}
+
+void loop() {
+  unsigned long currentMillis = millis();
+  
+  if (currentMillis - lastRead >= READ_INTERVAL) {
+    lastRead = currentMillis;
+    
+    // Leer sensores
+    readPM();
+    readCO2();
+    
+    // Calcular AQI
+    calculateAQI();
+    
+    // Mostrar datos
+    displayData();
+    
+    // Verificar alertas
+    checkAlerts();
+  }
+  
+  delay(1000);
+}
+
+void readPM() {
+  // Simulación de lectura (reemplazar con lectura real)
+  airData.pm25 = random(5, 35) + random(0, 100) / 100.0;
+  airData.pm10 = random(10, 50) + random(0, 100) / 100.0;
+  
+  // Para implementación real, descomentar:
+  // byte buffer[32];
+  // if (pmsSerial.available() >= 32) {
+  //   pmsSerial.readBytes(buffer, 32);
+  //   if (buffer[0] == 0x42 && buffer[1] == 0x4D) {
+  //     airData.pm25 = (buffer[12] << 8) | buffer[13];
+  //     airData.pm10 = (buffer[14] << 8) | buffer[15];
+  //   }
+  // }
+}
+
+void readCO2() {
+  // Simulación de lectura
+  airData.co2 = random(400, 1200);
+  
+  // Para implementación real con librería MH-Z19:
+  // airData.co2 = mhz19.getCO2();
+}
+
+void calculateAQI() {
+  float pm25 = airData.pm25;
+  
+  if (pm25 <= 12.0) {
+    airData.aqi = map(pm25 * 10, 0, 120, 0, 50);
+    airData.status = "Good";
+  } else if (pm25 <= 35.4) {
+    airData.aqi = map(pm25 * 10, 121, 354, 51, 100);
+    airData.status = "Moderate";
+  } else if (pm25 <= 55.4) {
+    airData.aqi = map(pm25 * 10, 355, 554, 101, 150);
+    airData.status = "Unhealthy (SG)";
+  } else {
+    airData.aqi = 151;
+    airData.status = "Unhealthy";
+  }
+}
+
+void displayData() {
+  Serial.println(F("========== Calidad del Aire =========="));
+  Serial.print(F("PM2.5:  "));
+  Serial.print(airData.pm25);
+  Serial.println(F(" μg/m³"));
+  
+  Serial.print(F("PM10:   "));
+  Serial.print(airData.pm10);
+  Serial.println(F(" μg/m³"));
+  
+  Serial.print(F("CO₂:    "));
+  Serial.print(airData.co2);
+  Serial.println(F(" ppm"));
+  
+  Serial.println();
+  Serial.print(F("AQI:    "));
+  Serial.print(airData.aqi);
+  Serial.print(F(" ("));
+  Serial.print(airData.status);
+  Serial.println(F(")"));
+  Serial.println(F("======================================"));
+  Serial.println();
+}
+
+void checkAlerts() {
+  // Alerta PM2.5
+  if (airData.pm25 > 35.4) {
+    Serial.println(F("⚠️  ALERTA: PM2.5 alto - Reducir actividad exterior"));
+  }
+  
+  // Alerta CO₂
+  if (airData.co2 > 1000) {
+    Serial.println(F("⚠️  ALERTA: CO₂ elevado - Ventilar ambiente"));
+  }
+}
diff --git a/air_quality/examples/outdoor_monitor.ino b/air_quality/examples/outdoor_monitor.ino
new file mode 100644
index 0000000..212a22a
--- /dev/null
+++ b/air_quality/examples/outdoor_monitor.ino
@@ -0,0 +1,217 @@
+/*
+ * Ornidia - Monitor Exterior de Calidad del Aire
+ * 
+ * Sistema para monitoreo ambiental urbano con múltiples sensores de partículas
+ * Compatible con redes comunitarias como Sensor.Community
+ * 
+ * Hardware:
+ * - Arduino Mega (más pines y memoria)
+ * - PMS5003 (partículas PM)
+ * - BME280 (temp/humedad/presión)
+ * - Carcasa ventilada IP65
+ * 
+ * Conexiones:
+ * PMS5003:
+ *   VCC -> 5V
+ *   GND -> GND
+ *   TX  -> Serial1 RX (Pin 19)
+ * 
+ * BME280 (I2C):
+ *   VCC -> 3.3V
+ *   GND -> GND
+ *   SDA -> Pin 20 (SDA)
+ *   SCL -> Pin 21 (SCL)
+ */
+
+#include <Wire.h>
+// #include <Adafruit_BME280.h>
+
+// Adafruit_BME280 bme;
+
+// Estructura de datos
+struct AirQualityData {
+  // Partículas
+  float pm1_0;
+  float pm2_5;
+  float pm10;
+  
+  // Ambiente
+  float temperature;
+  float humidity;
+  float pressure;
+  
+  // Calculados
+  int aqi;
+  String aqi_level;
+  
+  // Timestamp
+  unsigned long timestamp;
+} currentData;
+
+// Promedios móviles (para envío cada 2.5 minutos)
+const int AVG_SAMPLES = 5;
+float pm25_avg[AVG_SAMPLES];
+float pm10_avg[AVG_SAMPLES];
+int avgIndex = 0;
+
+unsigned long lastRead = 0;
+unsigned long lastSend = 0;
+const unsigned long READ_INTERVAL = 30000;  // 30 segundos
+const unsigned long SEND_INTERVAL = 150000; // 2.5 minutos
+
+void setup() {
+  Serial.begin(115200);
+  Serial1.begin(9600); // PMS5003 en Serial1
+  Wire.begin();
+  
+  Serial.println(F("=========================================="));
+  Serial.println(F("  Monitor Exterior de Calidad del Aire"));
+  Serial.println(F("=========================================="));
+  Serial.println();
+  
+  // Inicializar BME280
+  // if (!bme.begin(0x76)) {
+  //   Serial.println(F("ERROR: BME280 no detectado!"));
+  //   while (1) delay(10);
+  // }
+  Serial.println(F("BME280 inicializado (simulado)"));
+  
+  // Inicializar arrays
+  for (int i = 0; i < AVG_SAMPLES; i++) {
+    pm25_avg[i] = 0;
+    pm10_avg[i] = 0;
+  }
+  
+  Serial.println(F("Sistema listo para monitoreo exterior"));
+  Serial.println();
+}
+
+void loop() {
+  unsigned long currentMillis = millis();
+  
+  // Leer sensores cada 30 segundos
+  if (currentMillis - lastRead >= READ_INTERVAL) {
+    lastRead = currentMillis;
+    
+    readPMS();
+    readBME();
+    calculateAQI();
+    
+    // Guardar en promedio móvil
+    pm25_avg[avgIndex] = currentData.pm2_5;
+    pm10_avg[avgIndex] = currentData.pm10;
+    avgIndex = (avgIndex + 1) % AVG_SAMPLES;
+    
+    displayData();
+  }
+  
+  // Enviar datos cada 2.5 minutos
+  if (currentMillis - lastSend >= SEND_INTERVAL) {
+    lastSend = currentMillis;
+    sendToSensorCommunity();
+  }
+  
+  delay(1000);
+}
+
+void readPMS() {
+  // Valores simulados
+  currentData.pm1_0 = random(0, 20) + random(0, 100) / 100.0;
+  currentData.pm2_5 = random(5, 40) + random(0, 100) / 100.0;
+  currentData.pm10 = random(10, 60) + random(0, 100) / 100.0;
+  
+  // Implementación real con Serial1
+  // byte buffer[32];
+  // if (Serial1.available() >= 32) {
+  //   Serial1.readBytes(buffer, 32);
+  //   if (buffer[0] == 0x42 && buffer[1] == 0x4D) {
+  //     currentData.pm1_0 = ((buffer[10] << 8) | buffer[11]) / 1.0;
+  //     currentData.pm2_5 = ((buffer[12] << 8) | buffer[13]) / 1.0;
+  //     currentData.pm10 = ((buffer[14] << 8) | buffer[15]) / 1.0;
+  //   }
+  // }
+}
+
+void readBME() {
+  // Valores simulados
+  currentData.temperature = 20.0 + random(-50, 100) / 10.0;
+  currentData.humidity = 50.0 + random(-200, 200) / 10.0;
+  currentData.pressure = 1013.25 + random(-100, 100) / 10.0;
+  
+  // Implementación real
+  // currentData.temperature = bme.readTemperature();
+  // currentData.humidity = bme.readHumidity();
+  // currentData.pressure = bme.readPressure() / 100.0;
+}
+
+void calculateAQI() {
+  float pm25 = currentData.pm2_5;
+  
+  if (pm25 <= 12.0) {
+    currentData.aqi = ((50 - 0) / (12.0 - 0)) * (pm25 - 0) + 0;
+    currentData.aqi_level = "Good";
+  } else if (pm25 <= 35.4) {
+    currentData.aqi = ((100 - 51) / (35.4 - 12.1)) * (pm25 - 12.1) + 51;
+    currentData.aqi_level = "Moderate";
+  } else if (pm25 <= 55.4) {
+    currentData.aqi = ((150 - 101) / (55.4 - 35.5)) * (pm25 - 35.5) + 101;
+    currentData.aqi_level = "Unhealthy (SG)";
+  } else {
+    currentData.aqi = 151;
+    currentData.aqi_level = "Unhealthy";
+  }
+}
+
+void displayData() {
+  Serial.println(F("========== Lectura de Sensores =========="));
+  Serial.print(F("PM1.0:  ")); Serial.print(currentData.pm1_0, 1); Serial.println(F(" μg/m³"));
+  Serial.print(F("PM2.5:  ")); Serial.print(currentData.pm2_5, 1); Serial.println(F(" μg/m³"));
+  Serial.print(F("PM10:   ")); Serial.print(currentData.pm10, 1); Serial.println(F(" μg/m³"));
+  Serial.print(F("Temp:   ")); Serial.print(currentData.temperature, 1); Serial.println(F(" °C"));
+  Serial.print(F("Hum:    ")); Serial.print(currentData.humidity, 1); Serial.println(F(" %"));
+  Serial.print(F("Pres:   ")); Serial.print(currentData.pressure, 1); Serial.println(F(" hPa"));
+  Serial.print(F("AQI:    ")); Serial.print(currentData.aqi); 
+  Serial.print(F(" (")); Serial.print(currentData.aqi_level); Serial.println(F(")"));
+  Serial.println(F("========================================="));
+  Serial.println();
+}
+
+void sendToSensorCommunity() {
+  // Calcular promedios
+  float pm25_mean = 0;
+  float pm10_mean = 0;
+  
+  for (int i = 0; i < AVG_SAMPLES; i++) {
+    pm25_mean += pm25_avg[i];
+    pm10_mean += pm10_avg[i];
+  }
+  pm25_mean /= AVG_SAMPLES;
+  pm10_mean /= AVG_SAMPLES;
+  
+  Serial.println(F("========== Enviando a Sensor.Community =========="));
+  Serial.print(F("PM2.5 (promedio 2.5min): ")); Serial.println(pm25_mean, 1);
+  Serial.print(F("PM10 (promedio 2.5min):  ")); Serial.println(pm10_mean, 1);
+  
+  // Formato JSON para Sensor.Community
+  Serial.println(F("JSON:"));
+  Serial.println(F("{"));
+  Serial.print(F("  \"software_version\": \"Ornidia-1.0\",\n"));
+  Serial.print(F("  \"sensordatavalues\": [\n"));
+  Serial.print(F("    {\"value_type\": \"P1\", \"value\": \"")); 
+  Serial.print(pm10_mean, 2); Serial.println(F("\"},"));
+  Serial.print(F("    {\"value_type\": \"P2\", \"value\": \"")); 
+  Serial.print(pm25_mean, 2); Serial.println(F("\"},"));
+  Serial.print(F("    {\"value_type\": \"temperature\", \"value\": \"")); 
+  Serial.print(currentData.temperature, 2); Serial.println(F("\"},"));
+  Serial.print(F("    {\"value_type\": \"humidity\", \"value\": \"")); 
+  Serial.print(currentData.humidity, 2); Serial.println(F("\"},"));
+  Serial.print(F("    {\"value_type\": \"pressure\", \"value\": \"")); 
+  Serial.print(currentData.pressure * 100, 2); Serial.println(F("\"}"));
+  Serial.println(F("  ]"));
+  Serial.println(F("}"));
+  Serial.println(F("================================================="));
+  Serial.println();
+  
+  // Aquí se enviaría via WiFi/Ethernet a:
+  // POST https://api.sensor.community/v1/push-sensor-data/
+}

From 25ed84fec890db86f2cb81c23c89a1bc987229f1 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 7 Dec 2025 04:31:03 +0000
Subject: [PATCH 4/4] Add explanatory comments to all commented library
 includes per code review

Co-authored-by: xtatikmel <8581177+xtatikmel@users.noreply.github.com>
---
 air_quality/air_quality_monitor.ino      | 4 ++++
 air_quality/examples/outdoor_monitor.ino | 5 +++++
 air_quality/sensors/ccs811_sensor.ino    | 7 +++++++
 air_quality/sensors/mhz19_sensor.ino     | 7 +++++++
 air_quality/sensors/pms5003_sensor.ino   | 7 +++++++
 5 files changed, 30 insertions(+)

diff --git a/air_quality/air_quality_monitor.ino b/air_quality/air_quality_monitor.ino
index a58814a..40b8725 100644
--- a/air_quality/air_quality_monitor.ino
+++ b/air_quality/air_quality_monitor.ino
@@ -27,6 +27,7 @@
 
 // Librerías de sensores (instalar según sensores usados)
 #ifdef USE_PMS5003
+  // Descomentar las siguientes líneas si tienes instalada la librería PMS
   // #include <PMS.h>
   // PMS pms(Serial1);  // Para Arduino Mega (Hardware Serial)
   // Para Arduino Uno/Nano usar SoftwareSerial
@@ -34,17 +35,20 @@
 #endif
 
 #ifdef USE_MHZ19B
+  // Descomentar si tienes la librería MH-Z19 instalada
   // #include <MHZ19.h>
   SoftwareSerial mhz19Serial(2, 3); // RX, TX
   // MHZ19 mhz19;
 #endif
 
 #ifdef USE_CCS811
+  // Descomentar si tienes la librería Adafruit CCS811 instalada
   // #include <Adafruit_CCS811.h>
   // Adafruit_CCS811 ccs;
 #endif
 
 #ifdef USE_BME280
+  // Descomentar si tienes la librería Adafruit BME280 instalada
   // #include <Adafruit_BME280.h>
   // Adafruit_BME280 bme;
 #endif
diff --git a/air_quality/examples/outdoor_monitor.ino b/air_quality/examples/outdoor_monitor.ino
index 212a22a..f4f0ae9 100644
--- a/air_quality/examples/outdoor_monitor.ino
+++ b/air_quality/examples/outdoor_monitor.ino
@@ -10,6 +10,11 @@
  * - BME280 (temp/humedad/presión)
  * - Carcasa ventilada IP65
  * 
+ * Librerías requeridas:
+ * arduino-cli lib install "Adafruit BME280 Library"
+ * 
+ * Descomentar las siguientes líneas después de instalar las librerías
+ * 
  * Conexiones:
  * PMS5003:
  *   VCC -> 5V
diff --git a/air_quality/sensors/ccs811_sensor.ino b/air_quality/sensors/ccs811_sensor.ino
index 4f76d9c..b84bb43 100644
--- a/air_quality/sensors/ccs811_sensor.ino
+++ b/air_quality/sensors/ccs811_sensor.ino
@@ -15,6 +15,13 @@
  * arduino-cli lib install "Adafruit CCS811 Library"
  */
 
+/*
+ * Librería requerida: Adafruit CCS811 Library
+ * arduino-cli lib install "Adafruit CCS811 Library"
+ * 
+ * Descomentar las siguientes líneas después de instalar la librería
+ */
+
 #include <Wire.h>
 // #include <Adafruit_CCS811.h>
 
diff --git a/air_quality/sensors/mhz19_sensor.ino b/air_quality/sensors/mhz19_sensor.ino
index 8d6ada1..ba00902 100644
--- a/air_quality/sensors/mhz19_sensor.ino
+++ b/air_quality/sensors/mhz19_sensor.ino
@@ -14,6 +14,13 @@
  * arduino-cli lib install "MH-Z19"
  */
 
+/*
+ * Librería requerida: MH-Z19
+ * arduino-cli lib install "MH-Z19"
+ * 
+ * Descomentar las siguientes líneas después de instalar la librería
+ */
+
 #include <SoftwareSerial.h>
 // #include <MHZ19.h>
 
diff --git a/air_quality/sensors/pms5003_sensor.ino b/air_quality/sensors/pms5003_sensor.ino
index b8d1b4f..97f245c 100644
--- a/air_quality/sensors/pms5003_sensor.ino
+++ b/air_quality/sensors/pms5003_sensor.ino
@@ -15,6 +15,13 @@
  * arduino-cli lib install "PMS Library"
  */
 
+/*
+ * Librería requerida: PMS Library
+ * arduino-cli lib install "PMS Library"
+ * 
+ * Descomentar las siguientes líneas después de instalar la librería
+ */
+
 #include <SoftwareSerial.h>
 // #include <PMS.h>