Calidad del Aire: Tutorial de uso de PMS5003 con arduino

Introducción

Hoy, mostraremos cómo puedes construir tu propio monitor de calidad del aire utilizando el sensor de partículas PMS5003 y Arduino.

Conociendo el PMS5003

Antes de sumergirnos en el montaje y programación, proporcionaremos una introducción sobre el sensor PMS5003, explicando qué es, cómo funciona y por qué es una opción ideal para medir la calidad del aire.

El PMS5003 es un sensor de calidad del aire de bajo costo producido por Plantower. Está diseñado para medir las partículas en suspensión en el aire, proporcionando información sobre su concentración en tiempo real.

El sensor es capaz de detectar partículas finas con tamaños que varían desde 0.3 µm hasta 10 µm, lo que incluye muchos tipos comunes de polvo, polen, esporas de moho, humo y otras partículas suspendidas en el aire. Se mide la concentración de estas partículas en microgramos (µg) por metro cúbico de aire.

El PMS5003 utiliza un láser interno y un fotodiodo para medir la cantidad de luz dispersada por las partículas en el aire, lo que le permite calcular su concentración. Esto se conoce como detección de la dispersión de luz y es un método muy eficaz para medir la calidad del aire.

Este sensor cuenta con una interfaz de comunicación serie para conectarse a microcontroladores como Arduino. También cuenta con un ventilador interno que ayuda a atraer el aire hacia el sensor de forma activa.

El PMS5003 es un dispositivo ideal para proyectos de calidad del aire de bricolaje, ya que es relativamente económico y fácil de usar, pero también ofrece un rendimiento razonablemente bueno y mediciones precisas de partículas en suspensión. Aquí puedes ver el manual.

PMS5003

El Índice de Calidad del Aire (ICA)

El Índice de Calidad del Aire (ICA), también conocido como Air Quality Index (AQI) en inglés, es una medida estándar que se utiliza en todo el mundo para dar a conocer de manera consistente y comprensible el nivel de contaminación del aire en un área específica.

El propósito principal del ICA es informar al público sobre si el aire en un lugar determinado es saludable o no. Esto es especialmente importante para las personas que son sensibles a la contaminación del aire, como los niños, los ancianos y las personas con enfermedades respiratorias.

El ICA se basa en los niveles de varios contaminantes presentes en el aire, como las partículas finas (PM2.5 y PM10), el ozono, el dióxido de nitrógeno, el dióxido de azufre y el monóxido de carbono. Cada uno de estos contaminantes tiene un efecto sobre la salud humana, por lo que sus niveles se miden y se utilizan para calcular el ICA.

Montaje del Circuito

El sensor PMS5003 tiene un conector de 8 pines para la conexión a otros dispositivos. 

  1. Pin 1 (VCC): Aquí es donde se suministra la alimentación conecta al pin 5V de Arduino.

  2. Pin 2 (GND): Este es el pin de tierra conecta al pin GND de Arduino.

  3. Pin 3 (SET): Este pin se usa para cambiar el modo del sensor. Si se deja en alto (5v), el sensor funcionará en modo activo en el que el sensor envía datos automáticamente. Si se pone a bajo (0v), el sensor entra en modo pasivo donde necesita comandos para enviar datos.

  4. Pin 4 (RX): Este es el pin de recepción de datos del sensor. Se debe conectar a un pin de transmisión (TX) en el microcontrolador.

  5. Pin 5 (TX): Este es el pin de transmisión de datos del sensor. Se debe conectar a un pin de recepción (RX) en el microcontrolador.

  6. Pin 6 (RESET): Este pin se utiliza para reiniciar el sensor. Un pulso bajo en este pin reiniciará el sensor.

  7. Pin 7 y 8 (NC): Sin conexión.

 

Programación con Arduino

El PMS5003 usa comunicación serial y su trama de datos tiene la siguiente estructura:

  • Byte de cabecera (2 bytes): Siempre comienza con los valores hexadecimales '42' y '4D'. Estos sirven como señal de inicio de la trama de datos.

  • Longitud de trama (2 bytes): Indica la longitud de la trama, que es siempre 2x13 + 2 (para la suma de comprobación) = 28 bytes.

  • Datos de concentración de partículas (12 bytes): Proporciona información sobre la concentración de partículas en el aire, tanto en condiciones estándar (CF=1) como bajo condiciones ambientales. Los datos están divididos en PM1.0, PM2.5 y PM10.

  • Cantidad de partículas por 0.1L de aire (12 bytes): Proporciona información sobre el número de partículas detectadas en 0.1L de aire, dividido en diferentes tamaños de partículas (0.3um, 0.5um, 1.0um, 2.5um, 5.0um, 10um).

  • Datos reservados (1 byte): Un byte de datos reservados, generalmente sin uso.

  • Suma de comprobación (2 bytes): Proporciona una suma de comprobación que se puede usar para verificar la integridad de la trama de datos.

Por lo tanto, los datos completos de la trama constan de 32 bytes en total. Es importante notar que los valores transmitidos por el sensor son en formato de bytes altos primero (Big-endian).

Código

Primero se incluye la librería SoftwareSerial  la cual permite la comunicación serial en otros pines digitales.

       #include <SoftwareSerial.h>

Se crea una instancia de SoftwareSerial llamada pmsSerial en los pines 2 (RX) y 3 (TX).

       SoftwareSerial pmsSerial(2, 3);
Inicia la comunicación serial con la computadora a través del puerto USB y con el sensor PMS5003.
       void setup() {
         Serial.begin(115200);
         pmsSerial.begin(9600);
              }
Declara una estructura personalizada llamada pms5003data que contiene todas las mediciones que se van a obtener del sensor PMS5003. Luego, crea una variable data de este tipo struct.

 

       struct pms5003data {
         uint16_t framelen;
         uint16_t pm10_estandar, pm25_estandar, pm100_estandar;
         uint16_t pm10_env, pm25_env, pm100_env;
         uint16_t particulas_03um, particulas_05um, particulas_10um,                                    particulas_25um, particulas_50um, particulas_100um;
         uint16_t unused;
         uint16_t checksum;
       };

       struct pms5003data data;
Se crea una función readPMSdata(Stream *s) para leer los datos del sensor y dentro se realiza lo siguiente:
Se  comprueba si hay datos disponibles para leer desde el sensor. Si no hay datos disponibles, la función retorna false y termina.
         if (!s->available()) { 
           return false;
         }
Verifica el próximo byte en la secuencia de entrada sin eliminarlo. Si este próximo byte no es 0x42, el cual indica el inicio de un paquete de datos desde el PMS5003, lee el byte erróneo (usando s->read()) y retorna false.
           if (s->peek() != 0x42) {
             s->read();
             return false;
           }
Comprueba si hay al menos 32 bytes disponibles para leer.
        if (s->available() < 32) {
           return false;
         }
Declara un array de bytes llamado buffer y luego lee 32 bytes de la secuencia de entrada en buffer.
         uint8_t buffer[32];
         uint16_t sum = 0;
         s->readBytes(buffer, 32);
Calcula la suma de comprobación sumando los primeros 30 bytes del buffer.
         for (uint8_t i = 0; i < 30; i++) {
           sum += buffer[i];
         }
Declara un array de palabras de 16 bits (2 bytes) y luego coloca cada par de bytes del buffer en buffer_u16. Esto es necesario porque los datos del PMS5003 se envían en formato Big-endian (byte más significativo primero).
         uint16_t buffer_u16[15];
         for (uint8_t i = 0; i < 15; i++) {
           buffer_u16[i] = buffer[2 + i * 2 + 1];
           buffer_u16[i] += (buffer[2 + i * 2] << 8);
          }
Copia los datos del array buffer_u16 en la estructura de datos.
       memcpy((void *)&data, (void *)buffer_u16, 30);
 Comprueba si la suma de comprobación calculada coincide con la suma de comprobación en la trama de datos.
       if (sum != data.checksum) {
          Serial.println("Checksum failure");
          return false;
        }
En el void loop() se comprueba si se pueden leer los datos del sensor PMS5003. Si se pueden leer, los datos se imprimen en el Monitor Serial en diferentes categorías como concentraciones estándar de PM, concentraciones ambientales de PM y conteos de partículas para diferentes tamaños de partículas. Además, se evalúan los datos del sensor y se clasifican en categorías de calidad del aire, que luego se imprimen en el Monitor Serial.

El código completo queda de la siguiente forma:

Resultados

Ya subido el sketch al Arduino abrimos el monitor serial y los resultados son los siguientes:
Cabe resaltar que para medir la calidad del aire con base en PM 2.5 Y PM 10 se tomo como referencia un convertidor de escala de la EPA (Agencia de Protección Ambiental de los Estados Unidos).

Conclusión

En este tutorial, te mostramos cómo puedes convertirte en un defensor de la calidad del aire en tu propia casa. Esperamos que este proyecto inspire aún más ideas y contribuya a un entorno más saludable. Recuerda, este es solo el principio de lo que puedes lograr con Arduino y un poco de creatividad. ¡Sigue explorando y diviértete!

 

 

AireArduinoPms5003

Deja un comentario