e-@

Los microchips ESP8266, que se puede conectar a una red WIFI, pueden programarse mediante el IDE de Arduino para controlar su conexión serie y sus dos tomas GPIO. Además estos chips aceptan comandos AT a través de su conexión serie, comandos con los que se pueden ejecutar ciertas operaciones para que este chip actúe como servidor o como cliente a través de una conexión WIFI ( https://en.wikipedia.org/wiki/ESP8266 , https://programarfacil.com/podcast/como-configurar-esp01-wifi-esp8266/ ).

El microchip más sencillo de esta familia de chips es el ESP-01 que a pesar de su sencillez y pequeño tamaño nos va permitir desarrollar equipos de gran interés para el INTERNET DE LAS COSAS.

En este post se explica cómo construir un sencillo barómetro con conexión WIFI que presenta las medidas de la presión, la temperatura y la humedad en un display LCD y que trasmite dichas medidas a un servidor donde un script PHP se encarga de guardar esos datos en un fichero al que cualquiera puede acceder remotamente, siempre que tenga los permisos requeridos.

Para la realización de este proyecto (que montaremos sobre una placa de prueba PROTOBOARD ) utilizaremos los siguientes dispositivos (figura 1):
– Una placa ARDUINO MEGA 2560
– Un micrichip BME280
– Un display LCD de 4 líneas con conexión I2C
– Un microchip ESP8266 ( ESP-O1)

Figura 1. Elementos utilizados en nuestro proyecto

Tanto el display LCD como el chip barométrico BME280 tienen conexión I2C y tras ser alimentados con 5 V deberán conectarse a los PINES 20 y 21 ( SDA y SCL ) de la placa ARDUINO. Para saber en qué dirección concreta cada uno de estos dos dispositivos se conecta, usaremos el programa “I2C_scanner” para ARDUINO, programa que podremos encontrar por ejemplo en esta dirección: https://github.com/todbot/arduino-i2c-scanner.

En nuestro caso el LCD se instala en la dirección “0x27” y el chip BME280 en la dirección “0x76” de la conexión I2C .

El microchip ESP-01 debe alimentarse a 3.5 V y a cualquiera de las pines serie (TX y RX) de los que cuenta la placa ARDUINO MEGA. En nuestro caso hemos usado la conexión Serial-3 de los pines 14 y 15 (figura 2).

Figura 2. Pines Serial-3 e I2C de la placa ARDUINO MEGA

A la hora de programar nuestro ARDUINO para ejecutar los comandos AT en el chip ESP-01 debemos recordar que usualmente estos chips utilizan una comunicación en serie con una velocidad de 115200.

Para comprobar que nuestro chip ESP-01 funciona correctamente podemos usar el siguiente programa ARDUINO:

======================================================================
void setup() {
//Begin serial comunication with Arduino and Arduino IDE (Serial Monitor)
Serial.begin(115200);
Serial3.begin(115200);
delay(1000);
Serial.println(“Setup Complete!”);
}
void loop()
{
//Read Arduino IDE Serial Monitor
If (Serial3.available()) {
Serial.write(Serial3.read());
}
//Read Arduino IDE Serial Monitor inputs
if(Serial.available()){
Serial3.write(Serial.read());
}
}
==============================================================================

Este programa nos permitirá comunicarnos con el chip ESP-01 mediante los comandos AT usando el monitor serie de la herramienta de programación de ARDUINO. En estos tutoriales https://www.prometec.net/arduino-wifi/ podemos ver cómo realizar estas comprobaciones. La única diferencia que encontraremos con nuestro caso es que en estos tutoriales se usa un ARDUINO UNO en vez de ARDUINO MEGA. Para saber más de estos comandos podemos ir al siguiente link https://hetpro-store.com/comandos-at-esp8266-esp8266ex/ .

Tras hacer el montaje y establecer todas las conexiones estaremos en condiciones de podar enviar nuestros datos del sensor BME280 tanto a nuestro LCD , para visualizarlos, así como a un servidor mediante la conexión WIFI proporciona por el chip ESP8266.

Para controlar todo el proceso usaremos las siguientes LIBRERÍAS:
– <Wire.h>
– <cactus_io_BME280_I2C.h>
– <LCD.h>
– <LiquidCrystal_I2C.h>
– <TimeLib.h>

Y para trabajar con el chip ESP8266 loa siguientes comandos AT:
– AT+CWJAP (con el que nos conectaremos a la red WIFI)
– AT+CWMODE=3 ( para establecer el tipo de conexión)
– AT+CIPSERVER=1,80 (para conectarnos al servidor)
– AT+CIPSTART=0,\”TCP\”,\”IP_o_NOMBRE_del_SERVIDOR\”,80″ (para iniciar el envío de datos)

Y a partir de aquí el proceso se basa en construir una variable llamada data que contienes las observaciones y medir la longitud del texto que se envía , dato que en nuestro caso va determinado en la variable l. El procedimiento de envío de datos se presenta en las siguientes líneas de programa donde la variable valor es la que identifica en el servidor los datos enviados.

================================================================================
Serial.println(“Sending out data…”);
String a=”GET /posted_2.php?valor=”+data+” “;
String l=String(a.length());
Serial3.println(“AT+CIPSEND=0,”+l);
Serial.println(“AT+CIPSEND=0,”+l);
delay(2000);
do{Serial.write(Serial3.read());} while (Serial3.available());
String b=”GET /posted_2.php?valor=”+data;
Serial3.println(b);
Serial.println(b);
delay(2000);
================================================================================

En el servidor deberemos tener alojado un script que en nuestro caso se llama posted_2.php que es el que se encarga de recoger los datos mediante un procedimiento GET. También usamos un script time.php que nos da el contenido del reloj del servidor y con el que sincronizamos los tiempos de ambos dispositivos.

En la figura 3 y 4 se presenta una foto del montaje de los elementos y su aspecto final.

Figura 3. Conexiones de todos los elementos de nuestro barómetro

Figura4. Aspecto final del BARÓMETRO WIFI

El programa ARDUINO completo lo podemos bajar de http://e-ao.org/Apuntes/bme_wifi_5.txt y nuestros scripts PHP son los siguientes:

posted_2.php
<?php
$fp = fopen(“posted_2.txt”,”a”);
$currentDateTime = date(‘Y-m-d H:i:s’);
$var=$_GET[‘valor’];
$currentDateTime = date(‘Y-m-d H:i:s’);
$b=$var . ” “;
$b=$b. $currentDateTime;
fwrite($fp,$b);
fwrite($fp,”\r”);
fwrite($fp,”\n”);
fclose($fp);
echo $currentDateTime;
?>

time.php
<?php
$var=$_GET[‘valor’];
$currentDateTime = date(‘Y-m-d H:i:s’);
echo $currentDateTime;
?>

La aplicación IFTTT (de las siglas de IFTTT significan “IF This, Then That”, lo que traducido al español significaría “Si esto, entonces aquello”) permite interconectar aplicaciones diferentes entre sí, así como con dispositivos del Internet de las Cosas.

Puedes dirigirte a estos links si quieres saber más sobre esta aplicación:

–https://www.xataka.com/basics/que-ifttt-como-puedes-utilizar-para-crear-automatismos-tus-aplicaciones

–https://www.ticbeat.com/tecnologias/guia-ifttt-que-es-como-funciona-15-recetas-utiles/

En este documento yo me voy a centrar en dos de los posibles usos de esta aplicación para conectar sistemas de medida construidos con dispositivos Arduino y/o Arduino WIFI.

En cuanto que tengas instalada la aplicación IFTTT en tu móvil y estés registrado en ella, ya podrás crear las “Applets” que serán las encargadas de ejecutar las conexiones que te interesen.

La primera rutina que describiré será una Applet que reenviará el contenido de todos los SMS que recibas procedentes de un teléfono móvil concreto (o también el contenido de cualquier SMS que recibas) a un HOJA de CÁLCULO de GOOGLE. Este tipo de servicio nos permitiría, por ejemplo, archivar los datos medidos por nuestro Barómetro SMS ( http://blog.e-ao.org/#post15 ) en la nube de Google, o de cualquier dispositivo Arduino que cuente con una tarjeta SIM y pueda enviar mensajes a nuestro móvil.

Si nuestro dispositivo Arduino estuviera programado para enviar un SMS cada cierto tiempo, o tuviéramos varios dispositivos enviándonos SMSs, crearíamos una base de datos, que tras las suficientes medidas constituiría un archivo de datos en la nube que podría ser consultado en tiempo real de manera compartida.

Para generar esta Applet simplemente seguiremos la secuencia de acciones de la figura 1 en la pantalla de nuestro móvil.

Figura 1. Secuencia de pantallas a seguir para crear la Applet IFTTT que rellena una Hoja de Cálculo GOOGLE con el contenido de los mensaje SMS recibidos desde un teléfono ( desde cualquier teléfono si no indicamos uno de referencia)

Es decir:

a) Creamos nueva Applet (icono abajo a la derecha de la primera pantalla de la aplicación IFFT) y luego arriba a la derecha el símbolo (+) de crear nueva Applet.

b) Pulsamos el IF THIS de la siguiente pantalla

c) Buscamos el servicio que nos interesa (que es en nuestro caso es la recepción de un SMS desde un teléfono concreto).

d) Pulsamos CREAR TRIGGER

e) En la siguiente pantalla pulsamos THEN THAT

f) Elegimos de nuevo el servicio (Google Sheets)

g) Seleccionamos que se añada una fila nueva (ADD ROW TO…)

h) Terminamos la creación de la subrutina selección CREATE ACTION

Con este simple proceso, ya queda programado el jecjo de que cada vez que recibamos en nuestro móvil un SMS, el día, la hora, el nº de teléfono que lo envía y el contenido del mismo (cuarta columna), se añada a una fila de nuestra hoja de cálculo tal como se puede ver en la figura 2.

Figura 2. Hoja de cálculo con los datos enviados por el Barómetro SMS. Esa hoja GOOGLE recibe como nombre el nombre de contacto de tu agenda con su número de teléfono correspondiente. En la primera fila se apunta el día y hora del envío, y en la cuarta columna el contenido del SMS.

Si en vez de una conexión telefónica, tuviéramos una conexión WIFI o 4G-INTERNET, otro procedimiento para realizar este tipo de creación de bases de datos de observación con IFTTT, sería el uso del servicio WEBHOOK ( https://es.wikipedia.org/wiki/Webhook ) que te ofrece IFTTT.

El procedimiento a seguir sería similar al que hemos seguido para los SMSs, pero esta vez elegiríamos el Servicio WEBHOOK como TRIGGER de nuestra Applet (figura 3).

Figura 3. Secuencia a seguir para crear el Applet con un Webhook

Lo que haremos es:

– Ir a nuestras Applets y pulsar (+) para crear una nueva

– Elegir el Servicio Webhook tras pulsar “IF THIS”

– Nombrar el evento disparador y pulsar “CREATE TRIGGER”

– Pulsar “THEN THAT”

– Elegir de nuevo un “GOOGLE SHEETS”

– Nombrar la hoja de cálculo que queremos crear, definir el número de celdas que queremos crear (máximo 5, con tres celdas de valores y dos iniciales que serán día-hora y una segunda con el nombre del evento). Tras esto pulsaremos “CREATE ACTION”

Y ya en la pantalla final

– Pulsar “FINISH”

Ahora es importante entender que hace el WebHook y en que consiste el TRIGGER
Para ello, vamos de nuevo a nuestros Applets en la aplicación IFTTT y buscamos arriba a la derecha de la pantalla Servicios, luego pulsamos WEBHOOK y después DOCUMENTATION (figura 4) para así obtener la pantalla copiada en la parte inferior de esa misma figura 4.

Figura 4. Documentación sobre el SERVICIO WEBHOOK

Esta documentación nos explica que el WEBHOOH es un servicio que lanza una petición POST o GET (ambas son similares) a una URL concreta que queda identificada por una llave KEY que es personal para cada usuario de IFTTT. Los métodos POST y GET (https://diego.com.es/get-y-post-en-php) son procedimientos que permiten enviar datos a un servidor desde un ordenador cliente.

Un ejemplo del método POST lo tenéis en este link (http://e-ao.org/Apuntes/BT-BMP_f12.txt). Este software escrito para un teléfono Android en el lenguaje RFO BASIC¡ permite al teléfono, tras leer vía BT los datos medidos por el Barómetro descrito en este blog (http://blog.e-ao.org/#post3), conectarse a un servidor para enviar los datos leídos a dicho servidor donde una script PHP (http://e-ao.org/Apuntes/posted.txt) los procesa creando un fichero de datos.

Para mejor entender este tipo de transferencias de datos simplemente hay que saber que cuando escribimos una cierta dirección en nuestro navegador, en realidad estamos haciendo una petición GET a un servidor concreto y a un archivo concreto. Si este archivo es un script de algún tipo, el script en el servidor se activará y ejecutará su proceso.

En el caso que nos ocupa, ya que estamos enviando datos, simplemente hay que recordar que es preciso añadir una estructura particular a esa petición al servidor y que consiste en colocar al final de la dirección URL lo siguiente:

? Value1=<secuencia de caracteres de lo que queramos enviar>

Ya que en nuestro hemos seleccionado que sólo se enviará 1 dato a la HOJA DE CALCULO GOOGLE.

En forma más clara. Si en “cualquier navegador” escribimos en la línea que nos permite conectar con cierta URL

https://maker.ifttt.com/trigger/prueba_readings/with/KEY/nXSXc…?value1=25 (1)

Donde:

– “prueba_readings” es el nombre del <EVENT> que hemos seleccionado al crear el TRIGGER (figura3)

– “NXSXc.. “es la KEY personal que aparecerá en nuestra aplicación IFTTT cuando miramos en la documentación del servicio WEBHOOK (figura 4)

– “value1=25” indica que añadiremos 25 a la tercera celda de la hoja de cálculo que estamos generando tal como hemos seleccionado durante la creación de la APPLET.

Entonces al ejecutar la expresión (1) en el navegador, el servidor correspondiente nos responderá indicando que la petición se ha procesado y casi inmediatamente la GOOGLE SHEET creada por IFTTT recibirá una nueva fila donde las dos primeras columnas presentan el día y la hora de la petición, la segunda el nombre del evento y la tercera el valor de 25 o la secuencia de caracteres que se hubiera enviado. Un ejemplo de este tipo de conexión a la nube de GOOGLE lo tenemos en la figura 5 donde los valores que se envían son la (longitud)_(latitud)_(Intensidad luminosa en luxes medida por un teléfono móvil). Esta misma petición al servidor, puede ser realizada con cualquier dispositivo Arduino que esté conectado a una red WIFI o de manera general a INTERNET

Figura 5. WEBHOOK ejemplo de la GOOGLE SHEET creada con los datos en la tercera celda de longitud_latitud_IntensidadLuminosa.

El ejemplo de la figura 5 se ha desarrollado escribiéndolo con BASIC MINTORIS para ser utilizado en un teléfono móvil SAMSUNG ANDROID. En el programa, que se presenta continuación, la instrucción HtmlLoadUrl ejecuta la petición GET a la dirección URL indicada, recargando los datos presentes en af$

====================================================
rem PROGRAMA RED MEDIDAS
rem ILUMINACION
====================================================
ao$=”https:”
a1$=”//maker.ifttt.com/trigger/prueba_readings/with/key/”
a2$=”nXSXc……?value1=”
sensors on
luz = GetLight()
luz$=str$(luz)
gps on
Latitude = GetLatitude()
Longitude = GetLongitude()
lon$=str$(Longitude)
lat$=str$(Latitude)
a3$=lon$+”_”+lat$+”_”+luz$
af$=ao$+a1$+a2$+a3$
HtmlBrowser On
HtmlLoadUrl af$
Wait 1000
HtmlBrowser Off
sensors off
gps off
print “ejecutado”
wait 1000
cls
=====================================================

En este post explicaremos como
desarrollar con una placa ARDUINO un sistema que nos envíe la información
meteorológica capturada por un sensor mediante
un mensaje texto a nuestro
teléfono móvil.

Usaremos para este proyecto una
placa ARDUINO MEGA donde conectaremos dos elementos cuyas imágenes pueden verse
en la figura 1

–
Un sensor BME280 de ADAFRUIT (que medirá
temperatura, presión y humedad relativa)

–
La placa SIM800H de ADAFRUIT (que albergará la tarjeta
SIM telefónica con la que realizaremos nuestras comunicaciones) con su
respectiva antena

Figura 1. Sensor
BME280 (izquierda) y placa SIM800H
(derecha)

El sensor BME280 puede conectarse
a la placa Arduino a través de la interface
I2C. De esta manera deberemos realizar las siguientes conexiones pare la caso
de un ARDUINO MEGA (https://learn.adafruit.com/adafruit-bme280-humidity-barometric-pressure-temperature-sensor-breakout/arduino-test)

– Conectamos el pin VIN del sensor a 5V en la
placa ARDUINO y GND al GND de la placa ARDUINO

– Conectamos el pin SCK del sensor al pin digital 21 del placa ARDUINO
y el pin SDI al pin digital 20

La placa SIM800H la hemos conectado de la siguiente manera (https://learn.adafruit.com/adafruit-fona-mini-gsm-gprs-cellular-phone-module
)

–
La toma Vin
de la placa SIM800H a 5V de la
placa ARDUINO MEGA y su GND al GND del ARDUINO MEGA

–
Las conexiones TX y RX del SIM800H se han
conectado respectivamente al RX y TX del Serial3 de la placa ARDUINO MEGA
(pines 14 y 15 marcados en la placa ARDUINO como TX3 y RX3 respectivamente )

Se ha conectado así mismo un batería de 3,7 voltios
(del mismo tipo de las que usan en
un teléfono móvil) a la toma marcada
como TOMA 1 en la figura 1. Esta batería se puede recargar mediante el conector
micro-USB de la misma placa (TOMA 2 de la figura 1)

Antes de empezar a funcionar con
el prototipo (Figura 2) debemos verificar el correcto
funcionamiento del SIM800H en dos pasos.

Figura 2. Fotografía del prototipo conectado

En un primer paso verificaremos que la placa SIM800H responde
adecuadamente tras instalar en ella una tarjeta SIM de un teléfono móvil
mediante el siguiente software que
subiremos a la placa Arduino:

void setup() {

//Begin serial comunication with Arduino and
Arduino IDE (Serial Monitor)

Serial.begin(9600);

Serial3.begin(9600);

delay(1000);

Serial.println(“Setup Complete!”);

}

void loop() {

//Read SIM800 output (if available) and print
it in Arduino IDE Serial Monitor

if(Serial3.available()){

Serial.write(Serial3.read());

}

//Read Arduino IDE Serial Monitor inputs (if
available) and send them to SIM800

if(Serial.available()){

Serial3.write(Serial.read());

}

}

Mediante este sencillo sketch
estaremos en condiciones de comunicarnos con la placa SIM800H a través del
monitor serie del IDE de ARDUINO utilizando los comandos AT (http://zonabot.com/index.php/es/2-uncategorised/28-comandos-at-para-telefonos-moviles
) ,básicamente deberemos verificar que el sistema responde , responderá OK al envío de un comando simple AT, y de que el sistema está conectado a alguna
red telefónica mediante el comando AT+COPS?
, al que contestará indicando a qué red de telefonía móvil está el sistema conectado.

Una segunda verificación que
debemos hacer es la comprobación de que nuestro sistema puede enviar mensajes
SMS de texto. Para ello instalaremos el siguiente sketch en la placa Arduino:

void setup()

{

//Being serial
communication with Arduino and SIM800

Serial.begin(9600);

Serial3.begin(9600);

delay(1000);

Serial.println(“Setup Complete!”);

Serial.println(“Sending SMS…”);

//Set SMS format to ASCII

Serial3.write(“AT+CMGF=1\r\n”);

delay(1000);

//Send new SMS command and message number

Serial3.write(“AT+CMGS=\”606******\”\r\n”);

delay(1000);

//Send SMS content

Serial3.write(“TEST”);

delay(1000);

//Send Ctrl+Z / ESC to denote SMS message is
complete

Serial3.write((char)26);

delay(1000);

Serial.println(“SMS Sent!”);

}

void loop()

{

}

En el teléfono móvil indicado en la instrucción – Serial3.write(“AT+CMGS=\”606******\”\r\n”);
– deberemos recibir un mensaje con
el contenido TEST . Una posible causa de que no recibamos el mensaje es que el
número de teléfono del centro de mensajes no está previamente inscrito en la
tarjeta SIM instalada en la placa SIM800H. Si no lo estuviera, recurriríamos al
comando AT correspondiente usando el script
anterior. Debemos señalar que ADAFRUIT tiene una librería para manejar esta
placa SIM800H , pero de ella nos ocuparemos más adelante.

Si toda ha funcionado correctamente estaremos en condiciones de poder subir
a nuestra placa ARDUINO el código del software que nos permite recibir en
nuestro teléfono móvil un mensaje de
texto con los datos meteorológicos capturados mediante el sensor BME280. Este
sketch lo podéis obtener e la dirección: http://e-ao.org/Apuntes/sim800_sms_f.ino o http://e-ao.org/Apuntes/sim800_sms_f.txt
. Recordar que para hacer funcionar este script deberemos incluir las librerías
<SPI.h> , <Adafruit_Sensor.h> y <Adafruit_BME280.h>. Este
programa simplemente lo que hace es leer los datos meteorológicos y escuchar en
la puerta SERIE- 3 de la placa ARDUINO MEGA si hay una llamada entrante desde un número de
teléfono concreto (el teléfono 606******). Al leerse la puerta, se busca
si el número en cuestión ha llamado, mediante la instrucción

– if
((comando.indexOf(“606******”)>0)) –

Si esa
condición se cumple, inmediatamente se
ejecuta la opción de enviar un mensaje de texto a dicho teléfono.

La contaminación del aire, que básicamente está causada por el incremento del uso de automóviles para el transporte personal o de mercancías, afecta los interiores de nuestras casas así como las calles de nuestras ciudades y es un problema en alza en el mundo entero que paulatinamente ha ido afectando también las zonas más remotas de nuestro planeta.

Esta contaminación tiene dos componentes, las partículas o aerosoles y los gases. Dado el origen de la contaminación, los gases más característicos de las zonas contaminadas son el NOx (óxidos de nitrógeno) y el O3 (ozono). El primero de estos gases se produce directamente en los motores de combustión de gasolina o gasoil, mientras que el segundo se produce como consecuencia de complejas reacciones en la propia atmósfera en las que precisamente son los óxidos de nitrógeno uno de los reactivos principales que finalmente crean el ozono como un producto secundario final. Ambos gases (NOx y O3 ) se detectan tanto en las zonas de emisión (principalmente núcleos urbanos donde es el automóvil la base del transporte de personas y mercancías) como en zonas muy alejadas de las mismas hacia donde estos contaminantes atmosféricos son transportados empujados por el viento. Esta contaminación de fondo que afecta zonas de la Tierra supuestamente limpias ha ido aumentando de manera significativa en las últimas décadas tal como se ha observado en numerosas investigaciones llevadas a cabo en diferentes puntos de nuestro planeta.

La contaminación por gases y partículas tiene efectos indeseables en la salud ya que aumenta el riesgo de padecer enfermedades respiratorias, mentales, coronarias y cancerosas. Por esta razón la observación y medida de los niveles de contaminación es conveniente realizarla de manera sistemática como un medio para conocer la calidad medioambiental del aire de los entornos donde vivimos.

La medida de la contaminación con sencillos equipos electrónicos no ha sido una tarea sencilla hasta ahora. Sin embargo en los últimos años han ido apareciendo en el mercado sencillos equipos dotados de sensores electroquímicos sensibles a la presencia de diferentes gases atmosféricos en bajas concentraciones. Estos sensores electroquímicos se pueden controlar mediante tarjetas de fácil programación, como por ejemplo lo es la tarjeta ARDUINO, permitiéndonos así la construcción DIY de equipos electrónicos que pueden ser usados para monitorizar la calidad ambiental del aire que respiramos.

En este post vamos a describir como llevar a cabo la construcción de una ESTACION ARDUINO DE MEDIDA DE LA CONTAMINACIÓN capaz de medir los niveles de contaminación de NO2 y O3, así como los de los niveles de concentración de aerosoles.

Para construir este equipo de medida hemos utilizado los siguientes elementos (Figura 1):
-1 Tarjeta ARDUINO MEGA
-1 SENSOR NO2 Alphasense (Sensor NO2-B43F más su placa de control 000-OISB-O2)
-1 SENSOR O3 Alphasense (Sensor OX-B431 más su placa de control 000-OISB-O3)
-1 Medidor de partículas DSM501
-1 Sensor SHT15 de temperatura y humedad
-1 CI LM358 (Amplificador OPERACIONAL)
-1 Módulo Lector/Grabador micro SD para Arduino
-1 BT HC05
-1 Tarjeta de RELOJ DS1307 para Arduino
-2 POWER BANK de 3000 mAh
-Cables y conectores

Figura 1. Montaje de todos los elementos del medidor de contaminación y su empaquetamiento final en una caja realizada con impresora 3D

En este link

http://e-ao.org/Apuntes/ozonometro.pdf

tenéis una documentación más completa que os permitirá poder construir este equipo.

Finalmente señalaremos que las comparaciones de las medidas realizadas con el sistema construido y las observadas con equipos calibrados presentan una buena correlación como se muestra en la figura 2. Para ello hay que desarrollar unas expresiones lineales que liguen los datos medidos por el ARDUINO y los observados por un equipo calibrado, especialmente para el caso del ozono y el medidor de partículas, ya que tanto el sensor alfasense de ozono y el medidor de partículas DMS501, se ven afectados por la humedad y la temperatura e incluso, en el caso del medidor de ozono, por las propias concentraciones de dióxidos de nitrógeno.

Figura 2. Comparación de medidas del equipo ARDUINO y un medidor calibrado de ozono

En muchos de los estudios que se realizan sobre el medio físico, los resultados de los trabajos realizados deben ser finalmente plasmados en un mapa. Para poder dibujar estos mapas podemos utilizar en R la librería ggmap que tienen como objetivo recrear a partir de los mapas de Google, otros nuevos mapas donde podemos hacer isocontornos, colocar textos o geolocalizar los valores de las observaciones llevadas a cabo en una zona de una variable concreta.

El script básico para obtener un mapa de estas características es el siguiente que utiliza la librería ggmap sería el siguiente:

library(ggmap)
mapa=get_map(location=c(lon=-2.658,lat=42.85),zoom=13,maptype=”satellite”)
mapa_1=ggmap(mapa)
ggsave(mapa_1,file=”file_destinacion.png”)

Lo que hacemos en este script es básicamente llamar la librería ggmap, crear el objeto mapa mediante la instrucción get_map (donde indicamos el centro de la imagen, el tipo de mapa google que queremos y el tipo de zoom a usar) y ya finalmente creamos el objeto gráfico correspondiente mediante ggmap de nuevo, objeto que salvamos mediante ggsave en un fichero en el lugar que nos convenga. Si sólo queremos ver el mapa en la pantalla de trabajo R, sólo deberemos escribr en la línea de comandos el nombre del mapa creado con ggmap y pulsar intro. El resultado del script anterior es la imagen presentada en la figura 1.