Neste artigo estaremos controlando dispositivos que não suportam WhatsApp, mas suportam outros protocolos de comunicação como MQTT, TCP, IMAP, etc. Se uma casa estiver instalada com dispositivos de automação residencial que não suportam Whatsapp, nos comunicaremos com esses dispositivos ( controladores) usando protocolos suportados por esses dispositivos.
Assim, poderemos controlar os eletrodomésticos conectados a esses dispositivos.
Componentes necessários
Ferramentas necessárias/bibliotecas necessárias
API do WhatsApp baseada em Python – yowsup
Biblioteca MQTT – paho
ID do Python
IDE do Arduino
Informações Técnicas
A ponte de protocolo também pode controlar dispositivos que não suportam a API do WhatsApp. Isso significa que simplesmente enviaremos os dados de um protocolo para outro. Este artigo demonstrará o MQTT e o WhatsApp Bridge para controlar os dispositivos.
Diagrama de bloco
Figura 1 Ponte entre protocolos WhatsApp e MQTT
Toda a comunicação será através de um script Python, que é instalado em sistema baseado em Linux. O script Python terá API WhatsApp e biblioteca MQTT para se comunicar com ambos os protocolos.
O script pode enviar e receber mensagens no WhatsApp e MQTT.
Um microcontrolador (ATmega 328p) é conectado aos eletrodomésticos através de circuitos de relé. Para fins de comunicação, o ESP está conectado ao microcontrolador.
O ESP é instalado com código que recebe mensagens sobre um tema específico e envia comandos ao microcontrolador através de UART serial.
Então, agora quando algum usuário envia mensagem no WhatsApp, ela vai para o microcontrolador através do nosso script Python.
Diagrama de circuito
Esta placa está conectada a um interruptor de luz com um circuito de relé. Também podemos usar a placa Arduino Uno em vez da placa 328 personalizada.
Como funciona o sistema
Quando um usuário envia uma mensagem para nosso sistema Linux no WhatsApp, o script lê a mensagem. O dispositivo IoT, que suporta o protocolo MQTT, escuta as mensagens sobre um tópico específico. Essas mensagens comandam o dispositivo para LIGAR e DESLIGAR um aparelho.
Portanto, agora as mensagens lidas pelo script Python são verificadas em busca de comandos, se encontradas. Comandos específicos são enviados ao dispositivo no protocolo MQTT. Quando o dispositivo lê esses comandos, ele atua sobre eles girando os pinos HIGH (ON), LOW (OFF)
Entendendo o código-fonte
Temos dois tipos de código fonte, um para Arduino + ESP e outro para script Python instalado no Linux.
Código para Arduino
O Arduino é instalado com um código que recebe dados em série. Quando uma string específica é recebida como “ON”, o pino do relé será LIGADO (ALTO) e ao receber “DESLIGADO”, o relé será DESLIGADO.
if (rec == “ON”) {
digitalWrite(relé, ALTO);
Serial.print(“Relé ligado”);
rec = “”;
}
if (rec == “DESLIGADO”) {
digitalWrite(relé, BAIXO);
Serial.print(“Relé desligado”);
rec = “”;
}
Código para ESP
O ESP está conectado ao Arduino em uma porta serial e também inscrito em um tópico MQTT para receber dados dele. Basicamente, ele envia os dados recebidos no tópico MQTT para a porta serial e os dados da serial para o tópico MQTT.
Para saber mais sobre ESP e MQTT, consulte nossos artigos anteriores.
Código para script Python
O script Python é instalado com a API “Yowsup” do WhatsApp para ler e enviar mensagens do WhatsApp. Existem dois arquivos neste script run.py e camada.py.
Compreendendo o arquivo Run.py
Chamaremos nossas bibliotecas no topo do arquivo
de yowsup.stacks importar YowStackBuilder
de yowsup.layers.auth importar AuthError
de yowsup.layers importar YowLayerEvent
de yowsup.layers.network importar YowNetworkLayer
de yowsup.env importar YowsupEnv
Também anexaremos o arquivo da camada no topo porque a classe principal “Ecocamada” existe dentro desse arquivo.
da importação de camada EchoLayer
Podemos nomear qualquer arquivo de camada, mas temos que colocar o mesmo nome aqui.
Dentro de py, declararemos nossa variável principal para senha e eventos que queremos que ocorram.
credenciais = (“91xxxxxxxxxx”, “HkhWVW5/Wnr493HXK8NKl/htpno=”)
Agora passamos para a camada e construímos a pilha. Além disso, o loop que manterá a conexão ativa é chamado.
stack.setCredentials(credenciais)
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT)) #enviando o sinal de conexão
stack.loop #este é o programa mainloop
Compreendendo o arquivo layer.py
Este arquivo contém a biblioteca de protocolos para MQTT e é capaz de receber mensagens do WhatsApp.
Entendendo como as mensagens são recebidas do WhatsApp
Este arquivo contém a classe que receberá todas as mensagens recebidas para este número, e que será uma entidade de retorno de chamada para que qualquer outro loop possa ser executado dentro do arquivo.
@ProtocolEntityCallback(“mensagem”)
def onMessage(self, messageProtocolEntity):
se for verdade:
Os dados da mensagem e a forma do número de onde veio a mensagem podem ser obtidos abaixo.
incomming_message_data = mensagemProtocolEntity.getBody
Isso obterá o corpo da mensagem, que é a mensagem real. Ele será armazenado em uma variável string “incomming_message_data”
incomming_message_sender = mensagemProtocolEntity.getFrom
Esta linha irá armazenar o número de contato da mensagem recebida na variável string “incomming_message_sender”
Compreendendo as camadas MQTT para envio e recebimento
Em primeiro lugar, importaremos as bibliotecas necessárias para o MQTT.
importar paho.mqtt.client como MQTT
importar paho.mqtt.publish como publicar
agora iremos declarar uma variável chamada client com mqtt client.
cliente = mqtt.Cliente
Agora faremos dois retornos de chamada de função 1. Para receber mensagens, 2. Fazer algo na conexão bem-sucedida.
cliente.on_connect=on_connect
cliente.on_message=on_message
Finalmente, nos conectaremos ao broker MQTT em uma porta e iniciaremos o cliente dentro de um loop sem bloqueio
cliente.connect(“corretor.hivemq.com”, 1883, 60)
cliente.loop_start
Depois que a conexão for bem-sucedida, podemos enviar mensagens usando este
publicar.single(tópico, message_data, hostname=”broker.hivemq.com”)
Quando qualquer mensagem é recebida no WhatsApp, ela é armazenada em uma string, e então essa string é escaneada em busca de algumas palavras-chave que definam aquela mensagem como um comando para ligar/desligar a luz.
elif(“luzes acesas” em incomming_msg): #Faça algo na partida
Se a condição for atendida, enviamos o comando de controle ao corretor MQTT.
publicar.single(“ts/light”, “ON”, hostname=”broker.hivemq.com”)
Quando alguma mensagem não reconhecida é recebida, a mensagem no WhatsApp responde que é inválida.
E é assim que podemos usar a ponte de protocolo para controlar dispositivos com WhatsApp.
