En este artículo controlaremos dispositivos que no son compatibles con WhatsApp, pero sí con otros protocolos de comunicación como MQTT, TCP, IMAP, etc. Si en una casa se instalan dispositivos domóticos que no son compatibles con Whatsapp, nos comunicaremos con estos dispositivos (controladores) utilizando protocolos compatibles con estos dispositivos.
De esta forma podremos controlar los electrodomésticos conectados a estos dispositivos.
Componentes necesarios
Herramientas requeridas/bibliotecas requeridas
API de WhatsApp basada en Python – yowsup
Biblioteca MQTT – paho
ID de Python
IDE de Arduino
Informaciones técnicas
El puente de protocolo también puede controlar dispositivos que no son compatibles con la API de WhatsApp. Esto significa que simplemente enviaremos datos de un protocolo a otro. Este artículo demostrará MQTT y WhatsApp Bridge para controlar dispositivos.
Diagrama de bloques
Figura 1 Puente entre los protocolos WhatsApp y MQTT
Toda la comunicación se realizará a través de un script Python, que se instala en un sistema basado en Linux. El script Python tendrá la API de WhatsApp y la biblioteca MQTT para comunicarse con ambos protocolos.
El script puede enviar y recibir mensajes en WhatsApp y MQTT.
Un microcontrolador (ATmega 328p) está conectado a los electrodomésticos a través de circuitos de relé. Para fines de comunicación, el ESP está conectado al microcontrolador.
ESP se instala con un código que recibe mensajes sobre un tema específico y envía comandos al microcontrolador a través de UART serie.
Entonces, ahora cuando un usuario envía un mensaje en WhatsApp, va al microcontrolador a través de nuestro script Python.
Diagrama de circuito
Esta placa está conectada a un interruptor de luz con un circuito de relé. También podemos utilizar la placa Arduino Uno en lugar de la placa 328 personalizada.
Cómo funciona el sistema
Cuando un usuario envía un mensaje a nuestro sistema Linux en WhatsApp, el script lee el mensaje. El dispositivo IoT, que admite el protocolo MQTT, escucha mensajes sobre un tema específico. Estos mensajes ordenan al dispositivo que encienda y apague un dispositivo.
Así que ahora los mensajes leídos por el script Python se analizan en busca de comandos, si se encuentran. Se envían comandos específicos al dispositivo en el protocolo MQTT. Cuando el dispositivo lee estos comandos, actúa sobre ellos girando los pines ALTO (ON), LOW (OFF)
Entendiendo el código fuente
Disponemos de dos tipos de código fuente, uno para Arduino + ESP y otro para script Python instalado en Linux.
Código para Arduino
El Arduino se instala con un código que recibe datos en serie. Cuando una cadena específica se recibe como "ON", el pin del relé estará ENCENDIDO (ALTO) y al recibir "OFF", el relé se apagará.
si (rec == “ENCENDIDO”) {
escritura digital (relé, ALTA);
Serial.print(“Relé activado”);
rec = “”;
}
si (rec == “APAGADO”) {
escritura digital (relé, BAJO);
Serial.print(“Relé desactivado”);
rec = “”;
}
Código para ESP
El ESP está conectado al Arduino en un puerto serie y también está suscrito a un tema MQTT para recibir datos del mismo. Básicamente, envía los datos recibidos en el tema MQTT al puerto serie y los datos del serie al tema MQTT.
Para obtener más información sobre ESP y MQTT, consulte nuestros artículos anteriores.
Código para secuencia de comandos Python
El script Python se instala con la API “Yowsup” de WhatsApp para leer y enviar mensajes de WhatsApp. Hay dos archivos en este script run.py y Layer.py .
Comprender el archivo Run.py
Llamaremos a nuestras bibliotecas en la parte superior del archivo.
desde yowsup.stacks importe YowStackBuilder
de yowsup.layers.auth importar AuthError
desde yowsup.layers importa YowLayerEvent
desde yowsup.layers.network importe YowNetworkLayer
desde yowsup.env importar YowsupEnv
También adjuntaremos el archivo de capa en la parte superior porque la clase principal "Ecolayer" existe dentro de este archivo.
desde la importación de la capa EchoLayer
Podemos nombrar cualquier archivo de capa, pero tenemos que poner el mismo nombre aquí.
Dentro de py, declararemos nuestra variable principal para la contraseña y los eventos que queremos que ocurran.
credenciales = (“91xxxxxxxxxx”, “HkhWVW5/Wnr493HXK8NKl/htpno=”)
Ahora pasamos a la capa y construimos la pila. Además, se llama al bucle que mantendrá viva la conexión.
pila.setCredentials(credenciales)
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT)) #enviando la señal de conexión
stack.loop #este es el programa del bucle principal
Comprender el archivo Layer.py
Este archivo contiene la biblioteca de protocolos para MQTT y es capaz de recibir mensajes de WhatsApp.
Comprender cómo se reciben los mensajes de WhatsApp
Este archivo contiene la clase que recibirá todos los mensajes entrantes para este número y que será una entidad de devolución de llamada para que se puedan ejecutar otros bucles dentro del archivo.
@ProtocolEntityCallback(“mensaje”)
def onMessage(self, mensajeProtocolEntity):
si es verdad:
Los datos del mensaje y la forma del número del que procede el mensaje se pueden obtener a continuación.
incomming_message_data = mensajeProtocolEntity.getBody
Esto obtendrá el cuerpo del mensaje, que es el mensaje real. Se almacenará en una variable de cadena "incomming_message_data"
incomming_message_sender = mensajeProtocolEntity.getFrom
Esta línea almacenará el número de contacto del mensaje recibido en la variable de cadena “incomming_message_sender”
Comprender las capas MQTT para enviar y recibir
En primer lugar, importaremos las bibliotecas necesarias para MQTT.
importar paho.mqtt.client como MQTT
importar paho.mqtt.publish cómo publicar
Ahora declararemos una variable llamada cliente con cliente mqtt.
cliente = mqtt.Cliente
Ahora haremos dos devoluciones de llamada de funciones: 1. Para recibir mensajes, 2. Haga algo en caso de una conexión exitosa.
client.on_connect=on_connect
client.on_message=on_message
Finalmente, 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)
cliente.loop_start
Una vez que la conexión sea exitosa, podemos enviar mensajes usando este
publicar.single(tema, datos_mensaje, nombre de host =”broker.hivemq.com”)
Cuando se recibe un mensaje en WhatsApp, se almacena en una cadena y luego esa cadena se escanea en busca de algunas palabras clave que definan ese mensaje como un comando para encender/apagar la luz.
elif(“luces encendidas” en incomming_msg): #Haz algo en el partido
Si se cumple la condición, enviamos el comando de control al corredor MQTT.
publicar.single(“ts/light”, “ON”, nombre de host=”broker.hivemq.com”)
Cuando se recibe algún mensaje no reconocido, el mensaje en WhatsApp responde que no es válido.
Y así es como podemos utilizar el puente de protocolo para controlar dispositivos con WhatsApp.