Monitorizar la caseta de jardín con microcontroladores y sensores - Parte 2

Estos valores se muestran en el navegador del PC o el smartphone (véase imagen) si se introduce la dirección IP del servidor web (en mi caso: http://192.168.178.100) en la línea de dirección.

El servidor web está programado para emitir la palabra "Alarm" cuando se supera una temperatura de 50°C o una concentración de gas de 100. Pero hay que mirar activamente en la página correspondiente para que se muestre todo. Eso no era suficiente para mí, también quería ser notificado con una señal acústica y visual. Así que tuve que evaluar la página web con un microcontrolador o microordenador, filtrar los valores medidos y, si era necesario, activar la alarma con un zumbador y LED.

Hardware requerido para la primera parte

Hardware requerido para la segunda parte

La solución evidente es utilizar un microcontrolador, ya que funciona "con un chasquido de dedos" tras el encendido. Sin embargo, al principio no conseguí utilizar mi placa D1 para la consulta. Sólo con la ayuda de un colega bloguero lo conseguí. Por lo tanto, primero presentaré la solución (para mí) más rápida con la Raspberry Pi y pospondré el sketch para la placa D1 como cliente web en la tercera parte de la serie de blogs.

A menudo he realizado la lectura de una página web basada en texto en relación con la descarga de controladores y bibliotecas de programas. Con curl ("Cliente for URLs" es una herramienta de línea de comandos para descargar o subir archivos a través de una dirección de Internet) puedo descargar el texto HTML completo desde el servidor web ESP con la dirección IP 192.168.178.100 en el terminal. (Por supuesto, debe aaptar la línea correspondiente en el programa con la dirección IP de su servidor web).

Después de muchas líneas con el formato, encontramos al final los valores medidos que buscamos para la temperatura, la humedad relativa del DHT22 y para la concentración de gas del MQ-2.

Con la redirección >text.txt puedo guardar todo el texto en un archivo para su posterior edición.

 rizo 192.168.178.100> text.txt

Utilizo un programa Python de desarrollo propio para filtrar los valores medidos, comprobar si se superan los valores límite y, en caso de que sea necesario, activar la alarma. Para la ejecución del comando de terminal que se acaba de mencionar, se necesita el módulo de programa OS, es decir

 importar OS

y luego

 OS.sistema('Curl 192.168.178.100> text.txt')

Para asignar el texto almacenado de la página web a una variable, se necesitan los siguientes comandos:

 F=abierto("Text.txt","R")
 datos = F.leyendo()
 F.cerrar

Con los métodos de cadena find (), slicing [from:to], split () y strip (), se filtran finalmente los valores medidos.

Este es el programa de Python con el cliente web y la alarma (Descargar):

 importar OS
 importar tiempo
 importar RPI.GPIO como GPIO
  
 zumbador=21
 GPIO.setwarings(Falso)
 GPIO.modo de ajuste(GPIO.bcm)
 GPIO.configurar(zumbador,GPIO.FUERA)
  
 def alarma():
     impresión("Alarma")
     por I en trinquete(2):
         GPIO.producción(zumbador,Cierto)
         tiempo.dormir(0.2)
         GPIO.producción(zumbador,Falso)
         tiempo.dormir(0.1)
         GPIO.producción(zumbador,Cierto)
         tiempo.dormir(0.2)
         GPIO.producción(zumbador,Falso)
         tiempo.dormir(1)
         
 Tiempo Cierto:
     tratar:
         OS.sistema('Curl 192.168.178.100> text.txt')
         F=abierto("Text.txt","R")
         datos = F.leyendo()
         F.cerrar
         #Print (datos)
         impresión()
         índice=datos.encontrar("Temperatura")
         #Print (índice)
         datos1=datos[índice:-23]
         impresión(datos1)
         valores=datos1.separar(":")
         impresión(valores)
         t=flotador(valores[1][0:6].banda())
         impresión("T =",t,"° C")
         H=En t(valores[2][1:3])
         impresión("H =",H," %")
         GRAMO=En t(valores[3][1:4])
         impresión("G =",GRAMO,"PPM")
         SI (t>25.0 O GRAMO>100):
             alarma()        
         tiempo.dormir(1)
  
     excepto:
         tiempo.dormir(10)

La salida de los datos se realiza en el terminal de Python, cuando se superan los valores límite, se activan el zumbador y el LED en GPIO21.

Para operar la Raspi en "Modo sin cabeza", es decir, sin el teclado ni monitor, tiene sentido integrar una pequeña pantalla OLED para la salida de datos en la disposición. La pantalla OLED I2C de 128 x 64 píxeles de 1,3 pulgadas se conforma con cuatro conexiones para 3,3 V (pin 1) y GND (pin 9) y así como SDA (pin 3) y SCL (pin 5). Para ello he descargado de github la librería del programa luma.core de RM Hull.
Si su sistema operativo Raspberry Pi no está actualizado, los siguientes comandos pueden ser necesarios:

  $ Sudo usermod -a -GRAMO I2C, SPI, GPIO PI
  $ Sudo APT Instalar build-essential python3-Dev python3-Pip-Dev Libreietype6 libjpeg-Dev
  $ Sudo APT Instalar libSDL-Dev LibportMidi-Dev-libSDL TTF2.0-Dev-libSDL Mixer1.2-DEV-libSDL Image1.2-Dev

La clonación del repositorio se realiza con:

   $ git clon https://github.com/rm-hull/luma.examples.git
   $ CD luma.examples
   $ Sudo -H pip instalar -ce .

En el directorio OLED con sus otros subdirectorios no tenemos inicialmente permisos de escritura. Sin embargo, debido a las dependencias internas del módulo de programa demo_opts.py y del subdirectorio fonts, tiene sentido escribir también nuestro programa en el subdirectorio examples. Obtenemos los permisos de escritura con:

 sudo chmod 777 -C -R / Inicio / pi / OLED

Aquí está el diagrama de circuito:

y el programa completo en Python usando partes del ejemplo luma.core terminal.py: (Descargar)

 #! / Usr / bin / env python
 # - * - Codificación: UTF-8 - * -
 # Web Client para leer datos del medio ambiente
 # Por Bernd Albrecht para AZ-Entrega
 # 
 # Luma.core: Copyright (C) 2014-2020 Richard Hull y colaboradores
 # Ver License.RST para más detalles.
  
 importar OS
 importar tiempo
 de pathlib importar Sendero
 de demo_opts importar get_device
 de luma.centro.virtual importar Terminal
 de Pila importar Imaginario
 importar RPI.GPIO como GPIO
  
 zumbador=21
 GPIO.setwarings(Falso)
 GPIO.modo de ajuste(GPIO.bcm)
 GPIO.configurar(zumbador,GPIO.FUERA)
  
 def make_font(Apellido, Talla):
     font_path = cuerda(Sendero(__Expediente__).resolver().padre.Joinpath(Fuentes '', Apellido))
     regreso Imaginario.tipo verdadero(font_path, Talla)
  
 def alarma():
     impresión("Alarma")
     por I en trinquete(2):
         GPIO.producción(zumbador,Cierto)
         tiempo.dormir(0.2)
         GPIO.producción(zumbador,Falso)
         tiempo.dormir(0.1)
         GPIO.producción(zumbador,Cierto)
         tiempo.dormir(0.2)
         GPIO.producción(zumbador,Falso)
         tiempo.dormir(1)
  
 def sensor():
     global t,H,GRAMO,Tiempo
     tratar:
         OS.sistema('Curl 192.168.178.100> text.txt') 
         F=abierto("Text.txt","R")
         datos = F.leyendo()
         F.cerrar
         
     excepto:
         t=H=GRAMO=0
         tiempo.dormir(10)
  
     #Print (datos)
     impresión()
     índice=datos.encontrar("Temperatura")
     #Print (índice)
     datos1=datos[índice:-23]
     impresión(datos1)
     valores=datos1.separar(":")
     impresión(valores)
     t=flotador(valores[1][0:6].banda())
     impresión("T =",t,"° C")
     h=En t(werte[2][1:3])
     impresión("H =",h," %")
     gramo=En t(werte[3][1:4])
     impresión("G =",gramo)
     si (t>25.0 o gramo>100):
         alarma()        
     tiempo.dormir(1)
  
 def principal():
     # Para FONTNAME, tamaño en [(Ninguno, Ninguno), ("proggytiny.ttf", 16), ('chikarego.ttf', 16)]:
     por nombre de la fuente, Talla en [("Proggytiny.ttf", 16)]:
         impresión()
         impresión(nombre de la fuente, Talla)
         fuente = make_font(nombre de la fuente, Talla) si nombre de la fuente demás Ninguno
         término = Terminal(dispositivo, fuente)
             
     tiempo Cierto:
             sensor()
  
             término.claro()
             término.animar = Falso
             término.claro()
             término.pone("Temperatura:")
             término.pone(str(t))
             término.pone("° C")
             término.prender()
             término.prender()
             término.pone("Humedad:")
             término.pone(str(h))
             término.pone(" %")
             término.prender()
             término.prender()
             término.pone("Gas:")
             término.pone(str(gramo))
             término.prender()           
             término.enjuagar()
             tiempo.dormir(2)
  
 si __nombre__ == "__principal__":
     tratar:
         dispositivo = get_device()
         principal()
     excepto Teclainterrupt:
         aprobar

Para iniciar el programa tiene básicamente tres posibilidades:

1. Comienzo normal con el teclado y el monitor, luego se "desengancha".
2. Inicie mediante SSH (shell seguro) desde el PC, por ejemplo, con el programa Putty.
3. Configue el Autostart (descrito en el blog Coche robot con Raspberry Pi)

Sin embargo, no es suficiente con cargar e iniciar el programa, ya que la configuración por defecto se establece para otra pantalla con el controlador SSD1306. Por lo tanto, para nuestra pantalla OLED I2C de 128 x 64 píxeles de 1,3 pulgadas hay que pasar el parámetro, --Display SH1106 al llamar al programa.

Los otros ajustes por defecto de la Interfaz: I2C y dimensiones: 128 x 64 son correctos. Si está utilizando una pantalla diferente, vale la pena echar un vistazo al archivo README.rst en el directorio luma.examples.

En la tercera parte presentaré la evaluación de los valores medidos con una placa D1 (o cualquier otro microcontrolador ESP8266).

Descargar en formato pdf