En este proyecto, crearemos un centro de control único para todos nuestros dispositivos IoT. Controlaremos todos nuestros dispositivos IoT con una sola herramienta y obtendremos el estado de todos ellos en directo en una única pantalla.
Podemos implementar este tipo de centros de control para la mayor parte del protocolo. En este artículo, usaremos MQTT para controlar y monitorear.
Herramientas requeridas/bibliotecas requeridas
Pitón 2.7
Biblioteca Python para MQTT – paho
Informaciones técnicas
Básicamente, trabajaremos con el protocolo MQTT y los métodos de Python para crear nuestro panel.
En este proyecto, crearemos un sistema de control para controlar nuestros dispositivos IoT usando Python y MQTT. Configurar dispositivos IoT puede ser fácil si se configuran de forma controlada. Todos los dispositivos necesitan una estación de control.
Diagrama de bloques
Figura 1 Diagrama de comunicación del sistema
Todos los sensores y dispositivos de IoT están conectados a un corredor, "broker.hivemq.com", sobre temas diferentes y únicos.
El panel de IoT también está conectado al mismo corredor, pero está suscrito a todos los temas a los que están suscritos los dispositivos.
Cómo funciona el sistema
- Todos los dispositivos están suscritos a algunos temas. Realizamos entradas de estos dispositivos en un archivo de Python "devices.py".
- Desde este archivo, nuestro código principal importa los nombres y temas de los dispositivos.
- Luego se suscribe a nuestro script para recibir mensajes sobre esos temas.
- Ahora agregamos devoluciones de llamada para cada tema con sus nombres; debe hacerse manualmente, por lo que el método también debe realizarse.
- Después de agregar devoluciones de llamada y escribir definiciones de funciones (fn_callbacks.py), enviamos los datos de cada dispositivo a la función de visualización, que muestra los datos en la pantalla.
- Al ejecutar el script desde el panel " py" también se inicia un script para enviar comandos a dispositivos llamado " Command_control.py". Usando este script, podemos enviar datos a estos dispositivos.
- El script de control nos brinda acceso completo a estos dispositivos y también importa la información del dispositivo desde el archivo " py ".
- Así podremos seleccionar el dispositivo con su número de identificación e interactuar con él en la pantalla.
Comprensión del código fuente:
Para comprender el código Python, primero debemos comprender cómo se implementa MQTT en Python para recibir y publicar los datos hacia y desde el corredor.
- Implementación MQTT
- Crear entradas de dispositivos
- Creando múltiples suscripciones
- Mostrando los datos
- Envío de datos a dispositivos
- Guardar datos en la base de datos.
Implementación MQTT
En primer lugar, importaremos las bibliotecas necesarias para la comunicación MQTT.
importar paho.mqtt.client como mqtt
importar paho.mqtt.publish cómo publicar
Ahora declararemos una variable llamada cliente con la entidad cliente mqtt.
cliente = mqtt.Cliente
Nos conectaremos al broker MQTT en un puerto e iniciaremos el cliente dentro de un bucle sin bloqueo.
cliente.connect(“corretor.hivemq.com”, 1883, 60)
MQTT conecta al corredor y para la recepción nos brinda una forma en la que podemos agregar una función de devolución de llamada para un tema de recepción.
client.on_message=on_message
client.message_callback_add(“tema”, nombre_método)
Además, si queremos enviar un mensaje a cualquier cliente, podemos hacerlo llamando al método de publicación en cualquier parte del código.
publicar.single(topic_pub, comando, nombre de host=broker)
Entonces, se trataba de MQTT y las funciones que usaremos en este código.
Ahora aprendamos cómo agregar entradas de dispositivos al panel y suscribirnos a temas de forma dinámica.
Crear entradas de dispositivos
En primer lugar, crearemos un archivo llamado devices.py y declararemos nuestros dispositivos como variables y luego haremos una lista de estas variables.
dispositivo_1 = “Dispositivo_1”
dispositivo_2 = “Dispositivo_2”
nombres_dispositivo = (dispositivo_1, dispositivo_2)
Esta es la única manera de agregar fácilmente nombres de dispositivos al código. Deben agregarse antes de ejecutar el código.
Creando múltiples suscripciones
La suscripción se puede realizar en cualquier momento del proceso, pero la hacemos dentro del método que alcanzamos justo después de realizar la conexión.
Allí ejecutamos un bucle hasta que los dispositivos estén presentes.
para el tema en nombres_dispositivos:
cliente.suscribirse(tema)
Después de suscribirnos al tema de cada dispositivo, debemos agregar una función de devolución de llamada para que cada dispositivo reciba datos de cada dispositivo.
client.message_callback_add(nombres_de_dispositivos(0),Dispositivo_1)
client.message_callback_add(nombres_de_dispositivos(1),Dispositivo_2)
La definición de cada función se agrega en un archivo llamado " py ", que escucha tres tipos de mensajes.
- Mensajes que contienen la cadena "debug:" al principio del mensaje: esto es para mensajes de depuración del dispositivo.
- Mensajes que contienen la cadena "sensor" en el punto de inicio: esto ocurre si el sensor de un dispositivo está enviando algunos datos.
- El tercer tipo de mensaje es simplemente un mensaje de ENCENDIDO o APAGADO que le indica si el dispositivo está EN LÍNEA o FUERA DE LÍNEA.
Ahora, en este punto, hemos habilitado nuestro script para escuchar mensajes para cada dispositivo. Ahora veamos cómo mostraremos estos datos de forma masiva y organizada en la pantalla.
Mostrando los datos
Para mostrar los datos en la pantalla, creamos una función dinámica que toma la identificación del dispositivo y la variable de datos del dispositivo, que contiene datos sobre cada dispositivo.
La declaración de impresión anterior en Python siempre imprime los datos en las ubicaciones definidas.
Llamamos a esta función en nuestro bucle while principal para mostrar información sobre cada dispositivo.
para mí en nombres_dispositivos:
número de dispositivo global
estado (i, número_dispositivo)
El descanso se explica por sí mismo en el código.
Después de eso, comenzamos a recibir datos del sensor y ahora necesitamos enviárselos.
Envío de datos a dispositivos
Para enviar datos a dispositivos, creamos un archivo separado que se ejecuta con Dashboard.py. El archivo es “command_control.py”
En este archivo, continuamente le pedimos al usuario que seleccione un dispositivo y luego envíe el comando a ese dispositivo en un bucle while.
enviar_comando (input_cmd, nombres_de_dispositivos (i-1))
Ahora también podemos mantener registros de qué comando enviamos.
Guardar datos en la base de datos.
Creamos una función que toma una cadena de datos y los guarda uno por uno en un archivo llamado base de datos.txt.
Después de enviar el comando, creamos una cadena que almacena el comando con los datos que se le envían, y esto se muestra en el comando.
De esta manera, aprendimos cómo crear un panel para nuestros dispositivos IoT usando Python. También podemos utilizar cualquier otro protocolo en el mismo.