Tras describir en el post anterior ( http://blog.e-ao.org/#post10 ) cómo utilizar un sensor PMS5003 conectado a un Arduino para medir la contaminación por partículas (aerosoles), en este post describiré cómo llevar a cabo un medidor autónomo de contaminación atmosférica por aerosoles que además permita geolocalizar la medida llevada a cabo. Para ello se utilizarán los siguientes elementos (figura 1):

– Sensor PMS5003
– GPS NEO6MV2
– MicroSD
– Sensor de Humedad y Temperatura SHT15
– Power Bank de 15000 mAh
– Tarjeta Arduino MEGA


Figura 1. Elementos constructivos que conforman nuestro medidor

La idea es usar un Power Bank de 5V y 2.1 A (de los que se usan con los teléfonos móviles) para alimentar el sistema que vamos a construir y donde grabaremos en una tarjeta microSD, que actuará como data logger, los datos servidos por el GPS para la posición, fecha y hora, así como la concentración de partículas medidas con el sensor PMS5003 y el valor de la temperatura y la humedad dada por el sensor SHT15. En la medida de aerosoles mediante laser (tal como lo hace el sensor PMS5003) o con cualquier otro método óptico, la valoración de la humedad ambiental es necesaria ya que los contenidos de humedad de la atmósfera cambian el volumen de las partículas y sus características ópticas por lo que se modifican los resultados de su medida según el ambiente donde se realicen.

La forma de conectar el sensor PMS5003 a la tarjeta ARDUINO MEGA ya fue explicada previamente. Tras recordar que este sensor PMS5003 necesitaba un conversor de niveles TTL a 5V ya que el sistema de fábrica los genera a 3.3 V, sólo nos quedaría por identificar la manera de conectar el resto de elementos a la tarjeta ARDUINO.

El sensor SHT15 es un sensor que mide la temperatura y la humedad mediante una conexión similar a la I2C empleando dos pines para comunicar los datos y otros dos como alimentación. Una forma de conectar este dispositivo a una tarjeta Arduino es usar los pines A2, A3, A4, A5 para poder leer los datos mediantes los pines A4 y A5, mientras que con los pines A3 y A2 alimentaríamos el sensor activando estos pines en forma HIGH y LOWER respectivamente para así conseguir los 5V y GND que el dispositivo necesita. En este enlace ( https://learn.sparkfun.com/tutorials/sht15-humidity-and-temperature-sensor-hookup-guide ) encontraréis más información sobre este sensor. Para poder utilizar este sensor necesitamos incluir la librería <SHT1x.h> con la que podremos llamar los procedimientos de lectura sht15.readTemperatureC() y sht15.readHumidity() con los que tendremos acceso a los valores de la temperatura y la humedad.

Las tarjetas microSD son un elementos sencillos que permiten construir un data logger que puede ser usado para almacenar datos numéricos que posteriormente serán leídos y tratados en un PC. Las conexiones de estas tarjetas , que se alimentadas con 5V o 3.3.V, son ,en el caso de las tarjetas Arduino MEGA, las siguientes: los pines MOSI, CSK y MISO del microSD deben ir conectados respectivamente a los pines 51 , 52 y 50 de la tarjeta Arduino MEGA , mientras que el pin CS del microSD deberá conectarse a un pin cualquiera PWM de la trajeta Arduino (en nuestro caso se ha elegido el pin 7). Para utilizar este tipo de tarjetas microSD con Arduino deberemos incluir la librería <SD.h> con las que podremos manejarlas fácilmente. Para saber más sobre estos dispositivos y su uso, podéis ir a esta dirección( http://www.naylampmechatronics.com/blog/38_Tutorial-Arduino-y-memoria-SD-y-micro-SD-.html ).

El GPS utilizado en nuestro equipo es el GPS modelo NEO6MV2. Para conectar este GPS a nuestra tarjeta Arduino seguiremos el esquema presentado en la figura (2) donde deberemos hacer atención al hecho de que necesitaremos un par de resistencias para poder conectar adecuadamente nuestro GPS a nuestra placa Arduino. Señalar que este GPS estará alimentado por una tensión de 3.3 V. En este enlace ( http://www.leantec.es/blog/54_Tutorial-Arduino–Modulo-GPS-GPS6MV2.html ) encontraréis más información sobre este sensor y su conexión a un equipo Arduino aunque en él no se dice nada sobre el uso de ese par de resistencias en el montaje final. En nuestro caso concreto hemos activado y usado la conexión SERIAL3 de la placa Arduino MEGA para comunicarnos con este dispositivo. La gestión de la lectura de los datos servidos por este GPS se lleva acabo con la librería <TinyGPS.h> que nos facilitará la lectura de las diferentes variables mediante dos procedimientos sencillos que son gps.get_position(&lat, &lon, &age) y gps.get_datetime(&date, &time, &age).

Figura 2. Conexiones de un GPS NEO6MV2 a una placa Arduino UNO

Para llevar a cabo la programación de la placa Arduino tras el montaje de sus diversos elementos debemos tener en cuenta que el GPS puede sufrir un retraso de tiempo para iniciar la adquisición de datos desde que se arranca el sistema y que además, en algunas ocasiones, el GPS podría perder señal con lo que dejaría de adquirir datos. Por este motivo se ha decidido abrir dos ficheros diferentes en el microSD. Un primer fichero para guardar los datos del sensor de partículas y el sensor SHT15, y otro fichero donde se irán grabando las posiciones y el tiempo dado por el GPS. Para sincronizar ambas observaciones se usará la función time_t t=now() de la librería <Time(h)> de Arduino que nos permitirá saber el tiempo t que ha pasado desde el encendido del sistema. Ese tiempo t se grabará en ambos ficheros cada vez que se tome y grabe una medida con cada sistema, dato que posteriormente nos permitirá sincronizar las observaciones.

Señalar finalmente que el sistema construido consume cerca de 250 mA (consumo que se ha evaluado utilizando el propio POWER BANK que nos iba presentando en su dispaly los valores del gasto realizado). De esta manera con un POWER BANK como el empleado (15000 mAh) podríamos mantener la medida durante un total de cerca de 60 h. Para conectar el POWER BANK a la placa Arduino se ha construido un cable de conexión con los dos tipos de toma USB necesarios (figura 3).

Figura 3. Cable de conexión entre el POWER BANK y la placa Arduino

El programa Arduino empleado se presenta a continuación

// librerías a incluir
///////////////////////
#include <Arduino.h>
#include <SHT1x.h>
#include <SD.h>
#include <TinyGPS.h>
#include <SoftwareSerial.h>
#include <SPI.h>
#include <Time.h>

// variables para capturar los datos del sensor PMS5003
//////////////////////////////////////////////////////
#define LENG 31 //0x42 + 31 bytes equal to 32 bytes
unsigned char buf[LENG];

int PM01Value=0; //define PM1.0 value of the air detector module
int PM2_5Value=0; //define PM2.5 value of the air detector module
int PM10Value=0; //define PM10 value of the air detector module

//variables for storing values sensor SHT15
/////////////////////////////////////////////
float tempC = 0;
float tempF = 0;
float humidity = 0;

//declara output pins for powering the sensor SHT15
///////////////////////////////////////////////////
int power = A3;
int gnd = A2;

//declara variables para el gps
///////////////////////////////////////
const int grPIN=0;
float gr;
String data;

//declara los dos ficheros que se van a usar
/////////////////////////////////////////////
File myFile;
File Archivo;

//Create an instance of the SHT15 sensor
//////////////////////////////////////////
SHT1x sht15(A4, A5);//Data, SCK

// crea el gps y su subrutina
////////////////////////////////
TinyGPS gps;
void gpsdump(TinyGPS &gps);

void setup()
{
Serial.begin(9600);
Serial1.begin(9600); //use serial0
Serial1.setTimeout(1500); //longer than the data transmission periodic time of the sensor
Serial3.begin(9600);

pinMode(power, OUTPUT);
pinMode(gnd, OUTPUT);

digitalWrite(power, HIGH);
digitalWrite(gnd, LOW);

delay (2000);

// Se activa el micro SD
////////////////////////////////////////////
Serial.print(“Iniciando SD …”);
if (!SD.begin(7)) {
Serial.println(“No se pudo inicializar”);
return;
}
Serial.println(“inicializacion exitosa”);
// Se botrran los ficheros creados en cualquier medida anterior
/////////////////////////////////////////////////////////////////
SD.remove(“gps_1.txt”);
SD.remove(“data_1.txt”);
}

void loop()
{
if(Serial1.find(0x42)){ //start to read when detect 0x42
Serial1.readBytes(buf,LENG);

if(buf[0] == 0x4d){
if(checkValue(buf,LENG)){
PM01Value=transmitPM01(buf); //count PM1.0 value of the air detector module
PM2_5Value=transmitPM2_5(buf);//count PM2.5 value of the air detector module
PM10Value=transmitPM10(buf); //count PM10 value of the air detector module
}
}
}

static unsigned long OledTimer=millis();
if (millis() – OledTimer >=1000)
{
OledTimer=millis();

Serial.print(“PM1.0: “);
Serial.print(PM01Value);
Serial.println(” ug/m3″);

Serial.print(“PM2.5: “);
Serial.print(PM2_5Value);
Serial.println(” ug/m3″);

Serial.print(“PM10: “);
Serial.print(PM10Value);
Serial.println(” ug/m3″);
Serial.println();

tempC = sht15.readTemperatureC();
humidity = sht15.readHumidity();
Serial.print(“Temp = “);
Serial.print(tempC);
Serial.println(“C”);
Serial.print(“Humidity = “);
Serial.print(humidity);
Serial.println(“%”);

// leidos los datos del sensor PMS5003 y SHT15 se graban en el fichero data_1.txt
///////////////////////////////////////////////////////////////////////////////////

myFile = SD.open(“data_1.txt”, FILE_WRITE);//abrimos el archivo

if (myFile)
{
Serial.println(“Escribiendo SD: “);
time_t t=now();
myFile.println(humidity);
myFile.println(tempC);
myFile.println(PM01Value);
myFile.println(PM2_5Value);
myFile.println(PM10Value);
myFile.println(String(hour(t))+” “+String(minute(t))+” “+String(second(t)));
myFile.println(“”);
myFile.close(); //cerramos el archivo
}
else
{Serial.println(“Error al abrir el archivo”);}

// Every 5 seconds we print an update
bool newdata = false;
unsigned long start = millis();
delay(3000);
while (millis() – start < 5000)
{
if (Serial3.available())
{
char c = Serial3.read();
//Serial.print (c);

if (gps.encode(c)) {newdata = true;}
}
}

if (newdata)
{
// se lanza la medida del GPS con gpsdump(gps)
////////////////////////////////////////////////////

{
Serial.println(“Acquired Data”);
Serial.println(“————-“);
gpsdump(gps);
Serial.println(“————-“);
Serial.println();
}
}
}
}

char checkValue(unsigned char *thebuf, char leng)
{
char receiveflag=0;
int receiveSum=0;

for(int i=0; i<(leng-2); i++){
receiveSum=receiveSum+thebuf[i];
}
receiveSum=receiveSum + 0x42;

if(receiveSum == ((thebuf[leng-2]<<8)+thebuf[leng-1])) //check the serial data
{
receiveSum = 0;
receiveflag = 1;
}
return receiveflag;
}

int transmitPM01(unsigned char *thebuf)
{
int PM01Val;
PM01Val=((thebuf[3]<<8) + thebuf[4]); //count PM1.0 value of the air detector module
return PM01Val;
}

//transmit PM Value to PC
int transmitPM2_5(unsigned char *thebuf)
{
int PM2_5Val;
PM2_5Val=((thebuf[5]<<8) + thebuf[6]);//count PM2.5 value of the air detector module
return PM2_5Val;
}

//transmit PM Value to PC
int transmitPM10(unsigned char *thebuf)
{
int PM10Val;
PM10Val=((thebuf[7]<<8) + thebuf[8]); //count PM10 value of the air detector module
return PM10Val;
}

//——————————————————————————————-
void readSensor()
{
// Read values from the sensor
tempC = sht15.readTemperatureC();
tempF = sht15.readTemperatureF();
humidity = sht15.readHumidity();
}
//——————————————————————————————-

//——————————————————
void gpsdump(TinyGPS &gps)
{
long lat, lon;
unsigned long age, date, time, chars;
File Archivo;
String data;

time_t t=now();
gps.get_position(&lat, &lon, &age);

gps.get_datetime(&date, &time, &age);

data=(String(lat)+” “+String(lon)+ ” “+String(date)+” “+String(time)+ ” “+String (gps.altitude()));
gr=analogRead(1);

data=data+” “+String(int(gr));
data=data+” “+String(hour(t))+” “+String(minute(t))+” “+String(second(t));
Serial.println(data);

// leidos los datos del GPS se graban en su fichero correspondiente gps_1.txt
//////////////////////////////////////////////////////////////////////////////
Archivo=SD.open(“gps_1.txt”,FILE_WRITE);
Archivo.println (data);
Archivo.close();
}
//——————————————————–