Tarea del TEMA 3: Estación Meteorológica
Este proyecto va a tratar de un montaje de una estación meteorológica
cuya pretensión será leer parámetros atmosféricos mediante un sensor BMP180.
Este sensor irá conectado a una placa reducida Raspberri Pi, el cual subirá los
datos a una plataforma IoT llamado ThingSpeak. Este proceso, deberá de cumplir algunos requisitos:
- Los canales se deben de crear automáticamente.
- El muestreo de datos se debe realizar cada 10 segundos.
- Los datos se deberán de subir a través de la red WiFi "eduroam.
Por último, se exportarán los datos obtenidos desde ThingSpeak y se realizara algún tipo de análisis con la ayuda de Matlab.
Todo el código utilizado está disponible en un repositorio en GitHub.
Todo el código utilizado está disponible en un repositorio en GitHub.
Sensor BMP180
Antes de empezar con la programación, se realizará una pequeña introducción del sensor de presión barométrica BMP180, el cual posee una alta precisión y un bajo consumo de energía. Aquí unas especificaciones técnicas:
- Voltaje de operación: 3.3V - 5V DC
- Interfaz de comunicación: I2C (3.3V)
- Rango de Precisión: 300 a 1100 hPa
- Resolución: 1 Pa
- Medición de temperatura incluida
- Resolución de temperatura: 0.1ºC
- Precisión de temperatura: 1ºC
Además de la lectura de la temperatura y de la presión, el sensor calcula la altitud basándose en la presión, pero, como se va a poder comprobar mas adelante, este dato que se obtiene del sensor no es nada preciso, por no decir que resulta inútil basarse en los datos de altitud proporcionados por el sensor.
Pasos a realizar en la práctica
Instalación del Sistema Operativo
Una vez se han introducido los objetivos y los materiales a utilizar en este proyecto, se dará paso a la realización de éste:
Primero, se deberá de poner a punto la Raspberry Pi, para ello se tendrá que descargar el sistema operativo Raspbian a una tarjeta micro SD y después instalarlo en la Raspberry Pi. Este proceso se puede llevar a cabo de una manera fácil y sencilla si se siguen todos y cada uno de los pasos explicados en la página oficial de Raspberry.
Conexiones del sensor con la Raspberry
Con el sistema operativo instalado, llega el punto más tedioso del proyecto, configurar el sensor para que la Raspberry pueda leerlo. Lo primero será conectar el sensor a la Raspberry, de la misma manera que se puede apreciar en la siguiente imagen.
Las versiones de Raspberry superiores al 2015 necesitan la activación del "Devietree", esto se puede realizar en las configuraciones de raspi:
La entrada Vcc del sensor se conectará con el Pin1 (3V3) de la Raspberry, el GND con el Pin 6 (GND), el SCL con el Pin 5 (SCL) y el SDA con el Pin 3 (SDA).
Configuración del sensor
Ya que el sensor trabaja con el bus I2C, habrá que habilitarlo dentro de las configuraciones de la Raspberry. Para ello se deberá de abrir el terminal e introducir los siguientes comandos:
sudo nano /etc/modules
Dentro de Modules, se insertan las siguientes líneas, se guardan con "CTRL+O" y se sale con "CTRL+X"
i2c-bcm2708 i2c-dev
sudo raspi-config
Dentro de "Interfacing Options" se podrá activar la carga automática del bus I2C. Después de reiniciar el sistema, se instalarán tres nuevas herramientas mediante el uso del siguiente comando:
sudo apt-get install python-smbus i2c-tools git
Y por último, se comprobará si la Raspberry es capaz de leer el sensor:
i2cdetect -y 1
Si todo va bien, se mostrará la siguiente tabla:
pi@raspberrypi ~ $ i2cdetect -y 1 0 1 2 3 4 5 6 7 8 9 a b c d e f 00: -- -- -- -- -- -- -- -- -- -- -- -- -- 10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 70: -- -- -- -- -- -- -- 77
Para poder utilizar el sensor, se descargará una librería en la cual ya existen todas las funciones a utilizar con el sensor:
git clone https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code.git cd Adafruit-Raspberry-Pi-Python-Code/ git checkout 9ff733d59242a02f7ccd0222001ce80f6090a978 cd Adafruit_BMP085
Una vez el sensor esta listo para su uso, se podrá hacer una pequeña prueba con un código tan sencillo como este:
Configuración WiFi de "eduroam"
Para la configuración WiFi de eduroam, primero se deberá de entrar a las configuraciones de "wpa_supplicant" mediante el uso del siguiente comando.
*Importante: Tener en cuenta que no se edita el archivo interfaces, al tener una nueva versión de Raspberry, no se debe de editar este archivo, el mero echo de sumarle cualquier línea de código puede resultar en problemas de conexión WiFi.
*Importante: Tener en cuenta que no se edita el archivo interfaces, al tener una nueva versión de Raspberry, no se debe de editar este archivo, el mero echo de sumarle cualquier línea de código puede resultar en problemas de conexión WiFi.
sudo nano /etc/wpa_supplicant/wpa_supplicant.conf
Dentro de las configuraciones se deberá de definir la network a la que se quiere conectar la Raspberry
# escuela
network={
ssid="eduroam"
key_mgmt=WPA-EAP
eap=TTLS
phase2="auth=PAP"
identity="agorrotxategi003"
password="xxxxxxxx"
}
Una vez se ha definido la network de "eduroam", al iniciar la Raspberry en un entorno en el cual tenga acceso a la conexión de eduroam, la Raspberry se conectará automáticamente a esta red. Para confirmar esta afirmación, se posee la siguiente imagen en la que se puede apreciar como se realiza la subida de datos (realizando peticiones HTTP) mediante la conexión eduroam.
Almacenamiento en ThingSpeak de los parámetros obtenidos
Como bien se ha dicho en la introducción del proyecto, el almacenamiento de los parámetros tiene que cumplir con algunos requisitos. Para cumplir los requisitos, el código representará la siguiente estructura.
Primero se importarán las librerías que se van a utilizar, después, se realizará la conexión TCP, se crearán dos canales (Se crean dos canales debido al requisito de actualizar los parámetros cada 10 segundos, como la cuenta gratuita permite una actualización de datos cada 15 segundos, se irán actualizando cada canal con una frecuencia de 20 segundos) y por último, se crea un bucle el cual leerá los datos del sensor y los subirá a los canales de ThingSpeak previamente creados. El programa saldrá del bucle al presionar "CTRL+ z". Además, se utilizará la librería time, para controlar el tiempo de subida de los datos a ThingSpeak. En el caso de este proyecto, como el sensor a utilizar presenta una frecuencia de lectura muy alta, se puede utilizar el comando "time.sleep()" para la sincronización de los canales.
A continuación se puede apreciar el código del proyecto junto a comentarios del mismo.
A continuación se puede apreciar el código del proyecto junto a comentarios del mismo.
Después de ejecutar el código, se pueden ver los resultados en el canal de ThingSpeak.
Se puede comprobar que la presión no cambia en intervalos de tiempo tan cortos, por lo que se obtiene el mismo valor de presión en todas las lecturas. Además, se confirma el hecho de que la altitud obtenida por este sensor no es la correcta, debido a que presenta valores aproximados a una altitud de -100.
Visualización de los parámetros en una página web mediante Google Charts
El siguiente requisito es visualizar los datos de temperatura y presión recogidos en una página web. Para ello se utiliza Google Charts. El objetivo, por lo tanto, es escribir un código html que lea los datos guardados en los dos canales de ThingSpeak y los represente en un gráfico en una página web.
Lo único destacable de este código html es que al tener que subir los datos en dos canales para cumplir el requisito de subir un dato cada 10 segundos, a la hora de representar gráficamente estos datos hay que reconstruirlos, ya que se han separado en dos canales. Así, se guardan los datos de cada canal en un variable diferente y luego se juntan en una única variable mediante un bucle for: los valores de índice par de esta nueva variable se cogen del canal 1 y los valores de índice impar del canal 2.
El código correspondiente a esta representación gráfica es el siguiente:
Lo único destacable de este código html es que al tener que subir los datos en dos canales para cumplir el requisito de subir un dato cada 10 segundos, a la hora de representar gráficamente estos datos hay que reconstruirlos, ya que se han separado en dos canales. Así, se guardan los datos de cada canal en un variable diferente y luego se juntan en una única variable mediante un bucle for: los valores de índice par de esta nueva variable se cogen del canal 1 y los valores de índice impar del canal 2.
El código correspondiente a esta representación gráfica es el siguiente:
Finalmente, este es el resultado:
Análisis de los parámetros mediante Matlab
Por último, se descargan los datos a Matlab y se utiliza una red neuronal NARX para crear un modelo que se explicará más adelante.
Los datos se descargan desde ThingSpeak mediante la herramienta Matlab Analysis. Es una interfaz online con apariencia y funciones similares a Matlab, desde la que se recogen los datos de los canales, se agrupan en una sola variable (por las mismas razones mencionadas anteriormente) y se escriben en un display como una tabla para poder copiarlos a Matlab.
El código utilizado es el siguiente:
Y lo que la interfaz devuelve es lo siguiente:
Estos datos simplemente se copian y pegan en Matlab.
Con estos datos, se realiza una prueba de concepto de modelado de una planta mediante redes neuronales. Los datos de temperatura y presión se han recogido en casa, pero con un equipamiento más adecuado, se podrían recoger estos mismos datos para un horno industrial. Así, se toma la temperatura como variable controlada y se quiere predecir que evolución tendrá la presión en función de la temperatura y de los estados anteriores.
Se utiliza la Toolbox de Redes Neuronales de Matlab y en este caso, se escoge la red neuronal no lineal autoregresiva con entradas externas (NARX), ya que tiene la planta tiene entradas externas (la temperatura) y es autoregresiva (también depende de los estados anteriores de la presión).
A continuación, se define como entrada la temperatura y como objetivo la presión:
Después, se define la arquitectura de la red neuronal, que en este caso se utiliza una arquitectura bastante simple ya que no se cuenta con demasiados datos. Hay que encontrar un equilibrio entre tener una red demasiado simple, que no recoge la complejidad del modelo, y una red demasiado compleja, que acaba estando sobreentrenada.
Por último, se entrena la red neuronal y ya se dispone de un modelo listo para ser utilizado en aplicaciones de control.
Para terminar, en este gráfico se observa el proceso de entrenamiento, en el que cuando el error en las muestras de validación empieza a aumentar, significa que se está empezando a sobreentrenar la red y se detiene el entrenamiento de la misma.
Comentarios
Publicar un comentario