Sensor de lluvia para control climático

Titulo

Sensor de lluvia para control climático

Participantes

Laura Liseth Barrera Camero
María Alejandra Garzón Blanco
Maira Alejandra Salazar Polania

Abstract

This project involves the installation of a rain monitoring system. The system consists of a rain sensor, a beaglebone card and the ubidots platform. The data thrown by the sensor are loaded and monitored from the cloud in real time, making the system an Internet application of things. The system allows physically visualizing three categories of rainfall intensity by turning on an LED for each level. The system has several applications, mostly focused on intelligent cities.

Problema

En la actualidad aunque algunos carros cuentan con sensores que regulan la velocidad de los para-brisas, la información generada por estos sensores no es utilizada posteriormente aunque esta permita junto con la información gps llevar un control en tiempo real de las precipitaciones en distintas zonas de la ciudad, este proyecto busca poder hacer uso de esta información como se muestra en los siguientes apartados.

Diseño (Arquitectura HW)

HW.png

Desarrollo

A continuación se presenta, la implementación de un sistema que permite analizar los datos arrojados por un sensor de lluvia en tiempo real. El sensor de lluvia detecta la presencia de agua, gracias a la variación de conductividad al ponerse en contacto con agua. La salida digital del sensor se conecta a la entrada digital de la tarjeta arduino. La tarjeta arduino envía un valor, el cual es recibido por la tarjeta Beaglebone. La tarjeta Beaglebone utiliza este dato, mediante un archivo de python. En el archivo de python se realizan diversos procesos, uno de ellos es verificar la conexión a internet, y en el caso de que no exista conexión a Internet, se escribe un archivo de texto con los valores recolectados. Por otro lado de haber conexión a internet se ejecutan 3 scripts .sh, los cuales son llamados desde el archivo principal con extensión .py. El primero lee el archivo escrito mientras no había conexión a internet y envía estos datos a la plataforma Ubidots. El segundo envía inmediatamente los datos recolectados mientras exista conexión a internet a la plataforma ubidots. Por último, el tercero recupera el último dato subido a la plataforma Ubidots, y lo escribe en un archivo .txt, el archivo se lee dentro del programa principal y con el valor que tenga se realiza una condición para encender alguno los tres diferentes leds. Los leds corresponden a distintos niveles de intensidad de lluvia, paralelamente en la plataforma Ubidots, se puede observar la misma información por medio de una tabla y un indicador.

Descripción del sensor

sensor-detector-de-lluvia.jpg1

El sensor utilizado detecta la presencia de lluvia por la variación de conductividad del sensor al entrar en contacto con el agua. Se dispone de dos contactos, unidos a unas pistas conductoras entrelazadas entre sí a una pequeña distancia, sin existir contacto entre ambas. Al depositarse agua sobre la superficie, se pone en contacto eléctrico ambos conductores, lo que puede ser detectado por un sensor enviando con una placa de medición estándar con el comparador LM393, que permite obtener la lectura tanto como un valor analógico como de forma digital cuando se supera un cierto umbral, que se regula a través de un potenciómetro ubicado en la propia placa.
Este sensor no dispone de la precisión necesaria para medir la cantidad de agua acumulada lo que no permite realizar una medición de litros hora por lo que las aplicaciones propuestas para el sistema no incluyen las que necesiten este tipo de información.

Esquemático del montaje

subirrr.png

Imagen de la implementación

La implementación se hizo en una baquelita universal, conectando los diferentes componentes de hardware:

FOTO%201.pngFOTO%202%20NUEVO.png

Posibles aplicaciones

• Activación de limpia brisas del carro y regulación de su velocidad; aplicado en ciudades inteligentes y suponiendo que todos los carros lo poseen junto a información gps podría tenerse un control en tiempo real de las precipitaciones en todas las zonas de la ciudad.
• Despliegue de toldo para protección de espacios al aire libre como patios o estadios; su utilización se daría en ciudades inteligentes, dándole la capacidad de responder adecuadamente ante la presencia de lluvia.
• Control de las precipitaciones en diferentes zonas de la ciudad; dentro de las diferentes ciudades existen zonas en las que se tiene mayor riesgo al presentarse precipitaciones fuertes por medio de este sistema se lograría dar alertas remotas para una pronta atención en caso de emergencia.
• Si el sensor está ubicado al nivel del suelo puede utilizarse el sistema para detectar inundaciones; su aplicación se daría en espacios como sótanos en los que dado el cableado o la presencia de equipos eléctricos la presencia de agua puede conllevar a un accidente.
• Detectar cuando el agua de contenedores alcance su máximo nivel; aplicación del internet de las cosas permitiendo la conexión y el monitoreo remoto de contenedores de agua u otros elementos que contengan líquidos.

Dificultades encontradas

• Para lograr subir los datos a la plataforma Ubidots, es necesario utilizar el comando curl, pero Python no permite la utilización de este comando, por lo que fue necesario la creación de un script que fuera ejecutado dentro del código Python.

• El valor recolectado por el sensor debió ser declarado como una variable de ambiente, para poder utilizarlo en el script antes mencionado.

• Inicialmente se había propuesto que la tarjeta accediera a internet por medio de un adaptador USB wirelees, pero la tarjeta con la que se contaba no tenía dicha funcionalidad.

Configuración - paso a paso

Configuración en Beaglebone

1. En la terminal nueva donde se ejecutó el comando, que conecta con la Beaglebone, se pondrá:

login: ubuntu
password: temppwd

2. Se configura una ruta estática:

sudo route add default gw 192.168.7.1

3. Se deshabilita la red:

sudo /etc/init.d/networking stop

4. Se agrega un servidor dns, editando la plantilla /etc/resolv.conf y agregando la línea:

nameserver 8.8.8.8

5. Se rehabilita la red:

sudo /etc/init.d/networking restart

6. Se verifica la conexión:

ping 192.168.7.1
ping 8.8.8.8
ping www.google.com

7. Se instala python, mediante:

sudo apt-get install python-pip
sudo pip install --upgrade Adafruit_BBIO

8. Se instala una versión de kernel, mediante:

sudo apt-get install linux-headers-3.8.13-bone80
sudo apt-get install linux-image-3.8.13-bone80

9. Se crea un script con extensión .py, para poder recibir los datos de la tarjeta Beaglebone, provenientes del sensor, así como también enviar los datos a la plataforma Ubidots, y así poder analizarlos.

#script analogIn1.py
import os
ubuntu@arm:~$ more analogIn1.py
import os
import sys
from subprocess import call
import Adafruit_BBIO.ADC as ADC
import Adafruit_BBIO.GPIO as GPIO
ADC.setup()
from time import sleep
analogPin="P9_36"
h=0
pf=open("si1.txt","r+")

while(1):
        potVal=ADC.read(analogPin)
        potVolt=potVal*1.8
        os.environ["potVolt"]=str(potVolt)
        fo=open("get.txt","w")
        a=call(['ping','8.8.8.8','-c','4'])
        os.environ["ewifi"]=str(a)
        os.environ["h"]=str(h)
        print potVolt
        if a==0:
           pf=open("si1.txt","r+")
           call(['sh','prueb2.sh'])
           call(['sh','prueb.sh'])
           os.environ["h"]=str(h)
           h=0
           pf=open("si1.txt","w")
           call(['sh','prueb3.sh'])
           fo = open("get.txt")
           cond = fo.read();
           print "esto lei del archivo"
           print  cond
           m=float(cond)         
           if m<1.26:
             GPIO.cleanup()
             print "potVolt<1.26"
             GPIO.setup("P9_23", GPIO.OUT)
             GPIO.output("P9_23", GPIO.HIGH)
           elif m>=1.26 and potVolt<=1.4:
GPIO.cleanup()
             print "potVolt>=1.26 and potVolt<=1.4"
             GPIO.setup("P9_25", GPIO.OUT)
             GPIO.output("P9_25", GPIO.HIGH)
           else:
             GPIO.cleanup() 
             print "potVolt>1.6"
             GPIO.setup("P9_27", GPIO.OUT)
             GPIO.output("P9_27", GPIO.HIGH)
        else: 
           h=h+1
           os.environ["h"]=str(h)
           print h
           pf.write(str(potVolt))
           pf.write(' \n')

sleep(.9)
pf.close()

10. Dentro del script analogIn1.py, se llama a otro script, con extensión .sh, llamado prueb.sh, el cual tiene como objetivo, enviar los datos recibidos del sensor a la plataforma Ubidots, siempre y cuando haya conexión a internet, pues para realizar este proceso, se debe ejecutar el comando curl desde la terminal de linux, pero python no acepta comandos de la shell, por ello se realiza esta acción. A continuación se muestra el script.

# scrpt prueb.sh
a=$potVolt
b=$ewifi
echo $vect
if [ $b -eq 0 ]; then
echo "si hay wifii"
curl -X POST -H "Content-Type: application/json" -d '{"value":'$a'}' https://thi
ngs.ubidots.com/api/v1.6/variables/580f9b33762542684822ffd8/values/?token=eJLFxZ
o6DCWZ3fvZeRhIhmfBziHM4g
else
echo "no hay wifi"
i=$((i+1))
echo $i
valor[i]=$potVolt
echo ${valor[i]}
fi

11. El script analogIn1.py también llama a otro script con extensión .sh, llamado prueb2.sh, el cual tiene como objetivo, guardar los datos recibidos del sensor, cuando no hay internet, y enviarlos a un archivo llamado si1.txt, el cual, en el momento que se conecte de nuevo a la red, se leerá línea por línea, y los datos serán enviados a la plataforma Ubidots. Nota: Al archivo si1.txt, se le borra el contenido una vez ha enviados todos los valores guardados en él, mientras se presentó la desconexión a internet.

# script prueb2.sh
contar=$h
more si1.txt
echo "contar $contar"
i=0
until [ $contar -eq $i ]; do
i=$((i+1))
export L=`awk NR=="$i" si1.txt`
echo leer $L
echo ii $i
echo contarr $contar
curl -X POST -H "Content-Type: application/json" -d '{"value":'$L'}' https://thi
ngs.ubidots.com/api/v1.6/variables/580f9b33762542684822ffd8/values/?token=eJLFxZ
o6DCWZ3fvZeRhIhmfBziHM4g
done
i=0

12. Se crea un script .sh llamado prueb3.sh, el cual recibe valores enviados por la plataforma Ubidots, después de haber analizado los recibidos anteriormente en la plataforma Ubidots, mediante los scripts prueb.sh y prueb2.sh, dichos valores son guardados en un .txt, llamado get.txt, con el fin de, luego poder tomar solo el valor que tenga la variable en dicho momento, sin cabecera ni textos de demás.

# script prueb3.sh
export vg=`curl -X GET https://things.ubidots.com/api/v1.6/variables/580f9b33762
542684822ffd8/values/?token=eJLFxZo6DCWZ3fvZeRhIhmfBziHM4g |cut -d ":" -f 8 |cut
 -d " " -f 2 |cut -d "," -f 1`
echo $vg
echo "$vg" >> get.txt

13. El archivo se ejecuta mediante:

sudo python analogIn1.py

Configuración en PC

1. Descargar la imagen .iso de ubuntu (http://elinux.org/BeagleBoardUbuntu#BeagleBone_White.2FBlack.2FGreen)
2. Descargar e instalar 7-zip
3. Descomprimir la imagen con el programa instalado anteriormente.
4. Descargar e instalar “image writer” para windows
5. Conectar la microSD por medio de un adaptador al computador.
6. Escribir la imagen en la microSD.
7. Insertar la microSD en la Beaglebone.
8. En una terminal de linux, descargo e instalo udev rules:

http://beagleboard.org/static/Drivers/Linux/FTDI/mkudevrule.sh

9. Se instaló “screen” en la terminal de linux, una aplicación de consola que permite tener sesiones de terminal en una simple ventana:

sudo apt-get install screen

10. Para conectarse a la tarjeta Beaglebone, se ejecuta lo siguiente, en una terminal nueva, donde se procederá a realizar las configuraciones propias de la tarjeta.

sudo screen /dev/ttyUSB0 115200

11. En la terminal que no conecta a la Beaglebone, se configura una dirección ip en el computador:

sudo ifconfig enx1cba8ca2ed6a 192.168.7.1/30 broadcast 192.168.7.3

12. Se verifica la conexión entre la Beaglebone y el computador:

ping 192.168.7.1

13. Para compartir la conexión a internet entre la Beaglebone y el computador:

sudo ip addr add 192.168.7.1/24 dev enx1cba8ca2ed6a
    sudo iptables -A FORWARD -o  wlp6s0 -i enx1cba8ca2ed6a -s  192.168.0.0/24 -m    conntrack  --ctstate NEW-      j ACCEPT
    sudo iptables -A FORWARD -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
    sudo iptables -t nat -F POSTROUTING
    sudo iptables -t nat -A POSTROUTING -o wlp6s0 -j MASQUERADE
    sudo iptables-save | sudo tee /etc/iptables.sav

Nota: Los elementos en negrilla, se deben verificar, mirando los nombres de la interfaces en el computador.

14.Para mayor comodidad, se crea un script con la extensión .sh, para que sea posible correrlo cada vez que se conecte la Beaglebone, con los pasos 11,12 y 13, y queda de la forma:

#script pccb.sh
    sudo ifconfig enx1cba8ca2ed6a 192.168.7.1/30 broadcast 192.168.7.3
    ping 192.168.7.1 -c 4
    sudo ip addr add 192.168.7.1/24 dev enx1cba8ca2ed6a
    sudo iptables -A FORWARD -o wlp6s0 -i enx1cba8ca2ed6a -s 192.168.0.0/24 -m connt
    rack --ctstate NEW -j ACCEPT
    sudo iptables -A FORWARD -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
    sudo iptables -t nat -F POSTROUTING
    sudo iptables -t nat -A POSTROUTING -o wlp6s0 -j MASQUERADE
    sudo iptables-save | sudo tee /etc/iptables.sav

Configuración en Ubidots

1. Se creó una cuenta en la plataforma ubidots.

2. Una vez en la cuenta se crea una fuente

UBI1.png

3. Dentro de la fuente se crea una variable con el nombre "lluvia"

UBI2.png

4. Ingresando a la variable, se puede observar una gráfica en donde el eje y corresponde al valor recolectado, y el eje x al tiempo.

UBI3.png

5. Para monitorear de forma mas fácil el comportamiento del sensor, se creó un dashboard:

UBI4.png
UBI5.png
UBI6.png

6. Se eligen los rangos que se van a mostrar y se procede a crear

UBI7.png

Código fuente

1. Código fuente, para correr en la terminal de Ubuntu.

pccb.sh

2. Códigos con extensión .sh, complementarios del código principal con extensión .py, ejecutados en la tarjeta Beaglebone.

prueb.sh
prueb2.sh
prueb3.sh

3. Código principal: analogIn1.py.
Nota: El código fuente: analogIn1.py en esta wiki, se encuentra con extensión .txt, por lo que se debe ingresar a la Beaglebone, crear un archivo .py, con el nombre: analogIn1 y copiar su contenido.

analogIn1.py.txt

Versión en PDF de esta wiki

Sensor_lluvia_usta.pdf

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License