Blog Image

e-@

BARÓMETRO GSM DE TELEFONÍA MOVIL

blog Posted on Sat, May 02, 2020 13:33:20

En este post se explica cómo construir un sencillo barómetro con conexión GSM que presenta las medidas de la presión, la temperatura y la humedad en un display LCD y que trasmite dichos datos, mediante un chip de telefonía móvil SIM800H de ARDAFRUIT , a un servidor donde un script PHP se encarga de salvarlos  en un fichero al que cualquiera   puede acceder remotamente, siempre   que  tenga los permisos requeridos. Este proyecto es por así decirlo una mezcla de dos proyectos presentados previamente, BAROMETRO WIFI ( https://blog.e-ao.org/?p=17 )  y  BAROMETRO SMS ( https://blog.e-ao.org/?p=15 ) donde a nivel de medida y display se usan los mismos recursos que en el caso del BAROMETRO WIFI y para la conexión a INTERNET se utiliza el mismo chip telefónico del proyecto BAROMETRO SMS, pero con la diferencia que en este caso el chip de telefonía móvil se va utilizar para llevar a  cabo una conexión internet.

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 microchip  BME280
  • Un display LCD de 4 líneas con conexión I2C
  • Un chip de telefonía móvil SIM800H

Como en  nuestro precedente 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.

La placa SIM800H la hemos conectado de la siguiente manera (https://learn.adafruit.com/adafruit-fona-mini-gsm-gprs-cellular-phone-module ), como ya se explicó en el proyecto Barómetro SMS.  

  • 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.

A diferencia del proyecto de Barómetro SMS, aquí el chip SIM800H, se utilizará para establecer una conexión internet a un servidor donde un programa desarrollado en el lenguaje PHP, similar al utilizado en el proyecto BAROMETRO WIFI. La figura 1 presenta una foto completa del dispositivo antes de su empaquetamiento en una caja.



Figura 1. Foto del dispositivo antes de su empaquetamiento en una caja

El conjunto de instrucciones ARDUINO necesarias para realizar los procesos requeridos en este barómtro ( lectura de datos , presentación de los mismos en el display y conexión al servidor) se pueden bajar de este link  ( http://e-ao.org/Apuntes/barometro_GSM.txt ).

El conjunto de instrucciones usadas para establecer la conexión internet mediante nuestro chip SIM800H se presentan a continuación:

AT

Instrucción para comprobar que el chip SIM800H está funcionando en una red de telefonía y que nos devolverá un OK si todo es correcto

AT+COPS?

Instrucción que nos responderá a que red se ha conectado la tarjeta SIM del SIM880H. Esta instrucción nos devuelve si todo es correcto +COPS:0,0, “RED_DE TELEFONIA MOVIL”

AT+SAPBR=0,1

Instrucción que cerrará la conexión internet. Nos devolverá un OK

AT+SAPBR=1,1

Instrucción que abrirá la conexión internet. Nos devolverá un OK

AT+SAPBR=2,1

Instrucción que nos devolverá la direccion ip de nuestro teléfono móvil con el texto +SAPBR=2,1,”DIRECCION IP”

AT+SAPBR=3,1,”APN”,”WWW”

Instruccíón que indicará el modo de conexión INTERNET, y que devuelve un OK

AT+HTTPINIT

Instrucción para inicializar .Aunque suele devolver ERROR es conveniente para iniciar el modo de transmisión INTERNET por si se hubiera desactivado

AT+HTTPPARA=”CID”,1

Instrucción que permite iniciar la conexión al programa instalado en el servidor. Nos devolverá un OK

AT+HTTPPARA=”URL”,”http://URL_DEL_SERVIDOR_DESTINO /posted_2.php?valor=DATA”

Instrucción para enviar el DATA correspondiente al programa PHP instalado en el servidor que lo guardará en un archivo del mismo

AT+HTTPACTION=1

Instrucción para comprobar que el envío ha sido correcto, devolverá un OK o un texto como +HTTPACTION=200,1 si el envío se ha ejecutado correctamente



LOS DATOS TAMBIEN SON MUSICA

blog Posted on Thu, February 27, 2020 19:44:53

Cualquier serie de datos puede convertirse en una melodía musical ya que cada nota musical de esa melodía puede identificarse con un número de una serie numérica concreta. En la actualidad los softwares y los instrumentos musicales comparten la codificación MIDI para poder emparejar música y números de una manera standard. En la figura 1 se puede ver la correspondencia entre números y notas musicales que se usa en dicha codificación MIDI.

Figura 1. Relación entre notas musicales y números en la codificación MIDI ( las notas  C, D, E…. se corresponden con las notas Do, Re, Mi…. Donde las primeras están en notación musical anglosajona y las segundas en notación latina)

Para poder convertir los datos en una pieza musical necesitamos un software con el que podamos programar la música correspondiente. En mi caso yo he usado Sonic Pi (https://sonic-pi.net/) con el que de manera muy sencilla podemos programar música mediante el uso de scripts que se pueden escribir en formato texto simple.   Un script básico para este software sería  por ejemplo  (https://sonic-pi.net/files/articles/Live-Coding-Education.pdf) :

play 70

sleep 1

play 75

sleep 0.5

play 82

sleep 1

Donde “play” es la instrucción con la que se toca una nota concreta cuyo número MIDI se escribe tras la instrucción y donde “sleep” es un tiempo de duración del mantenimiento de esa nota y que es proporcional   al “tempo” de la melodía (https://es.wikipedia.org/wiki/Tempo ), tempo  que se ajusta con la instrucción “use_bpm” .  El  tempo  representa la velocidad a la que se ejecutará la pieza musical  expresada en “beast per minute” . De esta manera, para crear una composición musical a partir de una serie de números o datos  con el software Sonic Pi, lo único que hay que hacer es convertir estos datos en los números MIDI  de las instrucciones play consecutivas de un script texto  que posteriormente el software Sonic Pi ejecutará.

Mis datos de partida fueron la serie de las medidas de temperaturas del aeropuerto de Vitoria que se pueden obtener en este link  http://weather.uwyo.edu/surface/meteorogram/europe.shtml  . Estos datos (http://e-ao.org/Apuntes/data_musica.xlsx  ) se corresponden con las medidas de temperatura tomadas cada media hora desde las 19:00 UTM del día 15 de noviembre de 2019 hasta las   19:30 UTM del día siguiente.

Para convertir en una melodía   cualquier serie de números o datos (como son en nuestro caso   la serie de los valores de temperaturas) es preciso utilizar algún algoritmo que transponga cada valor de temperatura (nuestros datos) en una nota MIDI. Este algoritmo debe tener en cuenta los valores máximos y mínimos de la serie, así como la elección de una octava musical adecuada para ejecutar la pieza musical resultante con un sonido que nos sea agradable (por  ejemplo  los de las  octavas centrales 5 o 6). El algoritmo usado en mi caso fue el siguiente:

                    Nota_musical= [(g/max-min)*(temp-min)]+cero                               (1)

Donde:

g= Factor para acomodar el máximo y el mínimo de las notas al máximo y el mínimo de las temperaturas (en nuestro caso g=9)

max y min : Temperaturas máxima y mínima de la serie

temp= Temperatura que se quiere convertir en una nota

cero= Valor MIDI de la nota musical de base que se corresponderá con la Temperatura mínima ( en nuestro caso se eligió 65 – nota F  de la octava 5 – )

Este algoritmo se construyó por tanteo tras varios ensayos previos. Evidentemente este algoritmo no puede ser usado de manera general ya que cada serie de datos particular debería ser convertida en una melodía mediante el uso de un algoritmo propio que consiga el mejor resultado musical posible. 

Para convertir la serie de temperaturas en la pieza musical final se ha usado un script desarrollado en R (https://www.r-project.org/) y que implementa el algoritmo (1) anteriormente descrito. Este script se puede obtener en http://e-ao.org/Apuntes/prog_datos_melod.txt

Mediante este programa en R se puede convertir la serie de valores de temperatura en un archivo texto simple  (script)  ejecutable desde Sonic Pi. Nuestro script de base era un conjunto de instrucciones play y sleep consecutivas en el que se habían  transformado   los números de la serie de temperaturas en una melodía escrita con el código numérico  MIDI. La figura 2 representa el inicio de este script Sonic Pi.

Figura 2. Parte inicial del script Sonic Pi obtenido con los datos de temperaturas y el programa R de transformación de números en notas MIDI

Este script, con la melodía básica,  se modificó añadiéndole algunos detalles rítmicos de sonidos de batería y  de bajos, para así obtener  un script final de Sonic Pi     que  sonara de manera  agradable    ( http://e-ao.org/Apuntes/musica_final3.txt ) . El resultado se grabó con el mismo software Sonic PI en formato WAV, formato que luego se convirtió a MP3. La pieza musical completa final se puede obtener en este link  http://e-ao.org/Apuntes/musica_final.mp3

Finalmente para editar un video donde se puedan ver los datos de manera animada junto a la música creada ( http://e-ao.org/Apuntes/video_datos_f.mp4 ) podremos usar PowerPoint para crear el video. A este video le añadiremos la música   mediante un editor de videos cualquiera (en mi caso yo usé Power Director) pero siempre teniendo en cuenta que hay que adecuar la duración de la animación a la duración de la música.

En PowerPoint la animación se consigue abriendo una diapositiva donde se pega la gráfica Excel correspondiente a los datos y luego se utiliza el menú de la pestaña de ANIMACIONES, donde tras marcar y señalar la gráfica insertada, se eligen las opciones adecuadas (Figura 3). Finalmente con el menú ARCHIVO del propio PowerPoint exportaremos el fichero a un formato MP4. El video así generado se puede editar con cualquier editor de videos y agregarle la música creada.

Figura 3.  En la pestaña ANIMACIONES   de   PowerPoint, y tras marcar la gráfica a animar proveniente de Excel, se pueden elegir las opciones que nos interesen (en nuestro caso Barrido y Duración 26.00 segundos) para obtener el video final.  El PowerPoint  de  esta  animación  se  encuentra  en este  link http://e-ao.org/Apuntes/animacion_datos.pptx



BARÓMETRO WIFI

blog Posted on Mon, July 08, 2019 19:46:30

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;
?>



USANDO IFTTT PARA SUBIR DATOS ARDUINO A LA NUBE

blog Posted on Wed, June 26, 2019 19:37:44

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
=====================================================



BARÓMETRO SMS

blog Posted on Fri, February 22, 2019 18:28:43

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.



MEDIDOR ARDUINO DE CONTAMINACIÓN ATMOSFÉRICA

blog Posted on Sun, April 15, 2018 18:14:47

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



MAPEO DE OBSERVACIONES USANDO GGMAP

blog Posted on Sat, March 17, 2018 11:03:11

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.