Neste projeto, criaremos um único centro de controle para todos os nossos dispositivos IoT. Controlaremos todos os nossos dispositivos IoT com apenas uma ferramenta e obteremos o status de todos eles ao vivo em uma única tela.
Podemos implementar esses tipos de centros de controle para a maior parte do protocolo. Neste artigo, usaremos MQTT para controlar e monitorar.
Ferramentas necessárias/bibliotecas necessárias
Phyton 2.7
Biblioteca Python para MQTT – paho
Informações Técnicas
Basicamente, trabalharemos com protocolo MQTT e métodos python para criar nosso dashboard.
Neste projeto, criaremos um sistema de controle para controlar nossos dispositivos IoT usando python e MQTT. A configuração de dispositivos IoT pode ser fácil se forem configurados de maneira controlada. Todos os dispositivos precisam de uma estação de controle.
Diagrama de bloco
Figura 1 Diagrama de comunicação do sistema
Todos os sensores e dispositivos IoT estão conectados a um corretor, “broker.hivemq.com” em tópicos diferentes e exclusivos.
O painel IoT também está conectado ao mesmo corretor, mas está inscrito em todos os tópicos nos quais os dispositivos estão inscritos.
Como funciona o sistema
- Todos os dispositivos estão inscritos em alguns tópicos. Fazemos entradas desses dispositivos em um arquivo python “dispositivos.py”.
- Desse arquivo, nosso código principal importa os nomes e tópicos dos dispositivos.
- Em seguida, ele assina nosso script para receber mensagens sobre esses tópicos
- Agora adicionamos retornos de chamada para cada tópico com seus nomes; deve ser feito manualmente, então o método também precisa ser feito.
- Após adicionar callbacks e escrever as definições da função (fn_callbacks.py), enviamos os dados de cada dispositivo para a função display, que mostra os dados na tela.
- Executando o script do painel “py” também lança um script para envio dos comandos aos dispositivos chamado “Comando_control.py” usando este script, podemos enviar dados para esses dispositivos.
- O script de controle nos dá acesso total a esses dispositivos e também importa as informações do dispositivo do arquivo “py”.
- Assim, podemos selecionar o dispositivo com seu número de identificação e interagir com ele na tela.
Compreendendo o código-fonte:
Para entender o código python, devemos primeiro entender como o MQTT é implementado em python para receber e publicar os dados de e para o corretor.
- Implementação MQTT
- Criando entradas de dispositivos
- Criando múltiplas assinaturas
- Exibindo os dados
- Enviando os dados para dispositivos
- Salvando dados no banco de dados
Implementação MQTT
Em primeiro lugar, importaremos as bibliotecas necessárias para a comunicação MQTT.
importar paho.mqtt.client como mqtt
importar paho.mqtt.publish como publicar
agora iremos declarar uma variável chamada client com a entidade cliente mqtt.
cliente = mqtt.Cliente
Iremos nos conectar ao broker MQTT em uma porta e iniciar o cliente dentro de um loop sem bloqueio
cliente.connect(“corretor.hivemq.com”, 1883, 60)
O MQTT conecta o corretor e, para recebimento, nos dá uma maneira pela qual podemos adicionar uma função de retorno de chamada para um tópico de recebimento.
cliente.on_message=on_message
client.message_callback_add(“tópico”,nome_método)
Além disso, se quisermos enviar uma mensagem para qualquer cliente, podemos fazer isso chamando o método de publicação em qualquer lugar do código.
publicar.single(topic_pub, comando, hostname=broker)
Então, tratava-se de MQTT e dos recursos que usaremos neste código.
Agora vamos aprender como adicionar entradas de dispositivos ao painel e assinar tópicos dinamicamente.
Criando entradas de dispositivos
Primeiramente, criaremos um arquivo chamado devices.py e declararemos nossos dispositivos como variáveis e, em seguida, faremos uma lista dessas variáveis.
dispositivo_1 = “Dispositivo_1”
dispositivo_2 = “Dispositivo_2”
nomes_de dispositivos = (dispositivo_1, dispositivo_2)
Esta é a única maneira de adicionar facilmente nomes de dispositivos ao código. Eles devem ser adicionados antes de executarmos o código.
Criando múltiplas assinaturas
A assinatura pode ser feita a qualquer momento do processo, mas fazemos dentro do método que alcançamos logo após a conexão ser feita.
Lá executamos um loop até que os dispositivos estejam presentes
para tópico em devices_names:
cliente.subscribe(tópico)
Depois de nos inscrevermos no tópico de cada dispositivo, precisamos adicionar uma função de retorno de chamada para cada dispositivo para receber dados de cada dispositivo.
cliente.message_callback_add(nomes_de_dispositivos(0),Dispositivo_1)
cliente.message_callback_add(nomes_de_dispositivos(1),Dispositivo_2)
A definição de cada função é adicionada em um arquivo chamado “py”, Que está ouvindo três tipos de mensagens.
- Mensagens contendo a string “debug:” no início da mensagem: Isto é para mensagens de depuração de dispositivos.
- Mensagens contendo string “sensor” no ponto inicial: Isto ocorre se o sensor de um dispositivo estiver enviando alguns dados.
- O terceiro tipo de mensagem é apenas uma mensagem ON ou OFF que informa se o dispositivo está ONLINE ou OFFLINE.
Agora, neste ponto, habilitamos nosso script para escutar mensagens para cada dispositivo. Agora vamos ver como mostraremos esses dados em massa de forma organizada na tela.
Exibindo os dados
Para exibir os dados na tela, criamos uma função dinâmica que pega o id do dispositivo e a variável de dados do dispositivo, que contém os dados sobre cada dispositivo.
A instrução print acima em python sempre imprime os dados nos locais definidos.
Chamamos essa função em nosso loop while principal para exibir informações sobre cada dispositivo.
para eu em devices_names:
número_do_dispositivo global
status (i, número_do_dispositivo)
O descanso é autoexplicado no código.
Depois disso, começamos a receber os dados do sensor e agora precisamos enviar os dados para eles.
Enviando os dados para dispositivos
Para enviar os dados aos dispositivos, criamos um arquivo separado que é executado com dashboard.py. O arquivo é “command_control.py”
Neste arquivo, pedimos continuamente ao usuário para selecionar um dispositivo e, em seguida, enviar o comando para esse dispositivo em um loop while.
send_command(input_cmd,devices_names(i-1))
Agora também podemos manter registros de qual comando enviamos.
Salvando dados no banco de dados
Criamos uma função que pega uma string de dados e os salva um por um em um arquivo chamado database.txt
Após enviarmos o comando, criamos uma string que armazena o comando com os dados enviados a ele, e isso é mostrado no comando.
Dessa forma, aprendemos como criar um painel para nossos dispositivos IoT usando python. Também podemos usar qualquer outro protocolo nele.
