Comprueba la calidad del aire

Publicado por Loli Diéguez en

Alguna vez te has preguntado qué hay en el aire que estás respirando? En todo el mundo, cada vez están más contaminadas nuestras ciudades, es una pena pero es así. La contaminación del aire es un asesino invisible que se cobra más de 4 millones de vidas cada año.

Pero no es solo el aire exterior lo que puede ser dañino, actividades comunes como cocinar o encender velas junto con una mala ventilación pueden causar una mala calidad del aire interior. Esto se debe a que la quema de combustibles libera innumerables cantidades de partículas diminutas en el aire.

En el pasado, los sensores de calidad del aire eran costosos y poco accesibles. Pero ahora, con microcontroladores fácilmente disponibles como el Arduino y sensores de bricolaje asequibles, podemos hacer nuestro propio sensor de calidad del aire Arduino en menos de 15 minutos.

Video tutorial

Monitoreo de la calidad del aire

Los métodos específicos utilizados para medir la calidad del aire dependen de si estás pensando en medir la calidad del aire interior o exterior.

La calidad del aire interior se ve afectada por contaminantes como el polvo, el CO2 y los compuestos orgánicos volátiles (COV). Al medir uno o más de estas partículas, podemos tener una buena idea de la calidad del aire interior. Y para estp, se requieren diferentes sensores para cada uno de estos contaminantes.

La calidad del aire exterior generalmente depende de los contaminantes de los motores de combustión. La quema de combustible produce partículas diminutas llamadas material particulado (PM) que se clasifican según su tamaño.

Cuanto más pequeñas son las partículas, más peligrosas son. PM2.5 se refiere al material particulado atmosférico (PM) que tiene un diámetro de menos de 2.5 micrómetros. Esto es aproximadamente un 3% del diámetro de un cabello humano.

La exposición a partículas PM2.5 durante un período prolongado es perjudicial para la salud . La clave para manejar tu exposición a estas partículas dañinas es poder medirla.

Para este tutorial, nos centraremos en medir PM2.5 y sus primos cercanos, PM1.0 y PM10 (tamaño de partícula de 1 y 10 micrómetros respectivamente).

Estas cifras nos darán el Índice de Calidad del Aire, la métrica más utilizada para medir y comparar los niveles de calidad del aire de diferentes ciudades del mundo.

Podrás usar este monitor de calidad del aire Arduino en interiores para medir la contaminación al cocinar, fumar, etc., y en exteriores para medir la calidad del aire de tu vecindario.

Sensores de calidad del aire

El tipo más común de sensor de calidad del aire que mide PM2.5, usa un láser para detectar partículas. Hay dos tipos de estos sensores basados ​​en láser: los que no tienen ventilador como el Samyoung DSM501A y los que tienen un ventilador como el Plantower PMS5003.

Las versiones sin ventilador son más baratas pero también menos precisas. El Plantower PMS5003 que usaremos es el mejor modelo y sigue siendo bastante asequible.

Sensor de calidad del aire PMS5003

El sensor Plantower PMS5003 puede detectar partículas tan pequeñas como de 0,3 micrómetros. Es por eso, que el número de modelo del sensor termina con '003'. El 5 se refiere a la generación en serie.

plantower

Puedes ver el ventilador de entrada de aire en la parte posterior. Eso es lo que hace que este sensor sea más preciso que los diseños sin ventilador como el Samyoung DSM501A.

plantower

 

En realidad, el PMS5003 no es un modelo de la generación actual, el actual seria el PMS7003. Si puedes encontrar el PMS3003 o PMS7003 a un precio mejor que el PMS5003, te lo aconsejamos. Sin embargo, el código Arduino puede ser un poco diferente.

Principio de funcionamiento

El PMS5003 utiliza un láser para dispersar e irradiar partículas suspendidas en el aire. Luego analiza la luz dispersa para obtener la curva de cómo cambia la dispersión de la luz con el tiempo.

Luego, el sensor calcula el número de partículas de varios diámetros por unidad de 0.1L de volumen de aire.

El PMS5003 puede generar lo siguiente:

  • Concentración de PM1.0, PM2.5 y PM10.0 en unidades estándar y ambientales.
  • Material particulado por 0.1L de aire, categorizado por tamaños de 0.3um, 0.5um, 1.0um, 2.5um, 5.0um y 10um.

Conexión del PMS5003 a Arduino

El PMS5003 tiene un puerto JST de 8 pines y viene con un cable que se ajusta al puerto. Pero la forma más fácil de conectar el sensor al Arduino es obteniendo una placa adaptadora de espaciado estándar JST a DIP de 2.54 mm.

Esto hace que sea muy fácil conectar el sensor a tu Arduino.

Componentes necesarios

Si tienes un Arduino Starter Kit, lo único que necesitas es el sensor PM2.5.

Pero aquí te indicamos todos los componentes que necesitarías:

  1. Arduino Uno Rev3
  2. Plantower PMS5003
  3. Pantalla LCD 1602A : 2 filas, 16 caracteres por fila
  4. Tablero de circuitos
  5. Fuente de alimentación
  6. Conexión de cables

Diagrama de cableado

Sensor PMS5003

Conecta el PMS5003 como se indica en el diagrama si estás utilizando una placa adaptadora de espaciado estándar JST a DIP de 2,54 mm (recomendado):

  1. VCC a 5V (no uses Arduino para suministrar este voltaje)
  2. GND a terreno común con Arduino
  3. Pin Arduino # 8 al pin TX en el sensor (estos son datos entrantes del sensor)
  4. Deja el pin # 9 desconectado aunque esté definido en el siguiente código

Pantalla LCD 1602A

Recomiendo encarecidamente utilizar el método I2C para conectar la pantalla LCD 1602A a tu Arduino. Esto significa que necesitas usar solo 4 pines en lugar de más de 9 con el método tradicional.

Para ello obtén una versión de la pantalla LCD que ya viene soldada con un módulo I2C. La mayoría de los kits de inicio incluyen esta versión para que los principiantes no se sientan abrumados.

Así es como se conecta:

  1. VCC a 5V (no uses Arduino para suministrar este voltaje)
  2. GND a terreno común con Arduino
  3. SDA al pin A4
  4. SCL al pin A5

Código Arduino

A continuación te dejamos el código, lo copias en un nuevo archivo .ino, compílalo y cárgalo en tu Arduino. Y ya estará hecho!!!!

#include <SoftwareSerial.h>
SoftwareSerial pmsSerial(8, 9);

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
//declaracion de los pines I2C
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

unsigned long previousMillis = 0;
unsigned long interval = 1000; // Actualiza la pantalla LCD una vez cada 1000ms (1 segundo) sin sostener el procesador Arduino como lo hace delay (). Si usa un retraso (), el PMS5003 producirá errores de suma de comprobación

 setup() {
  
  Serial.begin(115200);
 
  
  pmsSerial.begin(9600);
  lcd.begin(16,2);
  lcd.backlight();
}
 
struct pms5003data {
  uint16_t framelen;
  uint16_t pm10_standard, pm25_standard, pm100_standard;
  uint16_t pm10_env, pm25_env, pm100_env;
  uint16_t particles_03um, particles_05um, particles_10um, particles_25um, particles_50um, particles_100um;
  uint16_t unused;
  uint16_t checksum;
};
 
struct pms5003data data;
    
void loop() {

if (readPMSdata(&pmsSerial))
  {
  
  Serial.println();
  Serial.println("---------------------------------------");
  Serial.println("Concentration Units (standard)");
  Serial.print("PM 1.0: "); Serial.print(data.pm10_standard);
  Serial.print("\t\tPM 2.5: "); Serial.print(data.pm25_standard);
  Serial.print("\t\tPM 10: "); Serial.println(data.pm100_standard);
  Serial.println("---------------------------------------");
  Serial.println("Concentration Units (environmental)");
  Serial.print("PM 1.0: "); Serial.print(data.pm10_env);
  Serial.print("\t\tPM 2.5: "); Serial.print(data.pm25_env);
  Serial.print("\t\tPM 10: "); Serial.println(data.pm100_env);
  Serial.println("---------------------------------------");
  Serial.print("Particles > 0.3um / 0.1L air:"); Serial.println(data.particles_03um);
  Serial.print("Particles > 0.5um / 0.1L air:"); Serial.println(data.particles_05um);
  Serial.print("Particles > 1.0um / 0.1L air:"); Serial.println(data.particles_10um);
  Serial.print("Particles > 2.5um / 0.1L air:"); Serial.println(data.particles_25um);
  Serial.print("Particles > 5.0um / 0.1L air:"); Serial.println(data.particles_50um);
  Serial.print("Particles > 10.0 um / 0.1L air:"); Serial.println(data.particles_100um);
  Serial.println("---------------------------------------");
  }


String pm1String = String(data.pm10_standard);
String pm25String = String(data.pm25_standard);
String pm100String = String(data.pm100_standard);


unsigned long currentMillis = millis();
if (currentMillis - previousMillis > interval) {
  previousMillis = currentMillis;
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("PM1  PM2.5  PM10");
  lcd.setCursor(0,1);
  lcd.print(pm1String);
  lcd.setCursor(5,1);
  lcd.print(pm25String);
  lcd.setCursor(12,1);
  lcd.print(pm100String);
  }
}


boolean readPMSdata(Stream *s) {
  if (! s->available()) {
    return false;
  }
  
  
  if (s->peek() != 0x42) {
    s->read();
    return false;
  }
 
  
  if (s->available() < 32) {
    return false;
  }
    
  uint8_t buffer[32];    
  uint16_t sum = 0;
  s->readBytes(buffer, 32);
 
  
  for (uint8_t i=0; i<30; i++) {
    sum += buffer[i];
  }
 
  
  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);
  }
 
  
  memcpy((void *)&data, (void *)buffer_u16, 30);
 
  if (sum != data.checksum) {
    Serial.println("Checksum failure");
    return false;
  }
  // success!
  return true;
}


 

Fuente del tutorial: VueVille.

SIGUE LEYENDO MÁS COSAS INTERESANTES AQUÍ


Compartir esta publicación



← Publicación más antigua Publicación más reciente →