Neste artigo, faremos um sistema de eletricidade pré-pago baseado em IoT e aprenderemos exatamente como isso funciona.
Criaremos um medidor que monitorará o uso de eletricidade e reportará a um servidor de monitoramento (que também criaremos) as contas. Em um sistema de eletricidade comum, as contas vêm depois do uso, e então pagamos a conta. Mas, neste sistema, você tem que primeiro pagar pela eletricidade por recarga. Quando seu uso de eletricidade ultrapassar o limite de sua recarga, você receberá avisos. Se a conta ainda não for paga, a energia cairá automaticamente.
Componentes necessários
Dependências
Sistema Operacional – Windows / Linux / MacOSx
Linguagens de programação utilizadas – Python 2.7
Meio de comunicação – GPRS
Tecnologia usada
- Protocolo MQTT (Message Queue Telemetry Transportation) – MQTT é um protocolo leve para transmissão de mensagens pela Internet. Ele funciona como uma arquitetura cliente-servidor. O servidor é chamado de broker.
- GPRS – serviço (General Packet Radio Service), que funciona com base no serviço de rádio por pacote e fornece conectividade de internet para dispositivos celulares.
Insights técnicos
Calcularemos o uso de energia usando alguns sensores ou circuitos. Em seguida, mapearemos o uso de energia em termos de dinheiro – ou seja, 500 W em 50 dólares. O medidor inteligente terá um interruptor para desligar/ligar a eletricidade e será controlado pelo servidor de monitoramento. Quando um usuário recarrega, a energia sobe e o servidor envia um comando ON para o medidor. Em seguida, ligará a energia e, quando a recarga terminar, o comando será desligar o medidor e colocá-lo em OFF.
Criar um sistema como esse terá alguns desafios, como:
Como o medidor calculará a potência?
Usaremos um sensor de calculadora de potência para obter os dados de potência e, em seguida, os dados serão enviados ao controlador principal do medidor inteligente.
Como a estação de abastecimento principal (estação de monitoramento) se comunicará com o medidor?
Para comunicação, usaremos um módulo GSM e tecnologia GPRS para conectividade de internet. Para sinalização, usaremos o protocolo MQTT.
Como será feita a fatura e recargas?
Construiremos um script Python no lado do servidor que cuidará de todas as operações, como calcular a energia em tempo real e compará-la com o plano de energia adquirido pelo usuário e enviar um sinal de LIGADO ou DESLIGADO para o medidor.
Desligar e ligar a energia para eventos específicos.
O medidor terá uma unidade microcontroladora para ligar ou desligar a alimentação principal e controlar todas as peças de controle.
Diagrama de bloco
Figura 1 Sistema elétrico pré-pago baseado em GPRS
- A unidade do medidor contém um microcontrolador e um módulo GSM para processamento e comunicação. O medidor possui um relé que controla a eletricidade da casa. Existe também um sensor que calcula a potência.
- O servidor de fornecimento de eletricidade é um script Python que mantém os registros do uso do fornecimento de energia e recebe esses dados do medidor via MQTT.
- O servidor de fornecimento de eletricidade pode enviar comandos ON e OFF para o medidor via MQTT.
Como é que o sistema funciona?
Quando os usuários recarregam para um plano de energia específico, o medidor começa a ler o uso de energia usando um sensor de energia. Neste caso, calculamos a diferença de tensão através de uma resistência, obtendo assim a potência utilizada por todos os aparelhos ligados ao medidor. O consumo de energia é enviado ao sistema de abastecimento (servidor/script Python) através do protocolo MQTT, e os cálculos de conta e energia são feitos no servidor. Depois de feitos todos os cálculos, podemos determinar os seguintes sinais que precisamos enviar ao medidor e ao usuário:
Sinais de alerta: Quando a recarga do medidor estiver prestes a terminar.
Medidor LIGADO/DESLIGADO: Desligar/Ligar a conexão de energia
Consumo total de energia: Quando o usuário solicita o uso de energia, os dados são enviados com um resumo de uso.
Para recarregar ainda mais a conexão, o usuário pode entrar em contato com a estação de abastecimento, alterando algumas variáveis.
Compreendendo o código fonte
Configurando variáveis de conexão de modem GSM e MQTT
Primeiro de tudo, configuramos nosso medidor para comunicação incluindo a biblioteca TinyGSM:
#incluir
Definimos nosso modem no topo do código, que estamos usando para fins GPRS.
#definir TINY_GSM_MODEM_SIM800
Em seguida, definimos nossa conexão do modem com nosso microcontrolador com os pinos seriais do software.
SoftwareSerial SerialAT(5, 6); //RX,TX
Agora informamos à nossa biblioteca de modem GSM quais pinos seriais vamos conectar.
Modem TinyGsm (SerialAT);
Em seguida, alteramos nosso APN (nome do ponto de acesso) para o APN do cartão SIM.
const char apn = “bsnllive”;
Neste ponto, nosso modem GSM está quase configurado. O resto pode ser autocompreendido a partir dos comentários do código.
Agora definimos nosso protocolo de comunicação “MQTT”, mas primeiro vamos importar a biblioteca pub-sub-client necessária para MQTT.
#incluir
Em seguida definimos o endereço da nossa corretora e os tópicos nos quais iremos nos inscrever, que podem ser qualquer coisa de acordo com os nomes dos medidores.
const char* corretor = “corretor.hivemq.com”;
const char* topicSub = “GsmClientTest/led”;
const char* topicInit = “GsmClientTest/init”;
const char* topicPub = “GsmClientTest/ledStatus”;
Agora é hora de configurar o modem e os clientes MQTT em nosso código.
Cliente TinyGsmClient (modem);
PubSubClientmqtt(cliente);
Função de configuração para iniciar tudo em ordem
Primeiro, iniciamos nossas conexões seriais e configuramos os pinos digitais OUTPUT e nosso pino de relé (interruptor de alimentação principal) OUPUT.
pinMode(Relay_PIN, SAÍDA);
Agora reiniciamos nosso modem para verificar se há algo acontecendo com ele anteriormente.
modem.restart ;
Em seguida, pegamos as informações do modem e imprimimos em um terminal serial.
String modemInfo = modem.getModemInfo ;
SerialMon.print(“Modem: “);
SerialMon.println(modemInfo);
Agora, como vamos enviar dados pela rede, não devemos prosseguir até que nosso modem esteja conectado à rede celular, então adicionamos uma condição de bloqueio.
if (!modem.waitForNetwork ) {
SerialMon.println(”falha”);
enquanto (verdadeiro);
}
SerialMon.println(”OK”);
Depois de nos conectarmos à rede, agora prosseguimos para a conexão ao serviço GPRS, isso também é feito em uma conexão de bloqueio.
if (!modem.gprsConnect(apn, usuário, senha)) {
SerialMon.println(” falha”);
enquanto (verdadeiro);
}
Nosso sistema está conectado à internet, temos IPs atribuídos e a conexão TCP está UP. Agora nos conectamos ao nosso servidor MQTT.
mqtt.setServer(corretor, 1883);
Como estamos usando MQTT, a biblioteca sempre envia sinais de ping para o corretor. Não queremos atrapalhar nada na biblioteca ou na nossa conexão principal. Portanto, para receber as mensagens do corretor, adicionamos um método de retorno de chamada.
mqtt.setCallback(mqttCallback);
Agora estamos conectados ao corretor MQTT e precisamos definir uma condição que determina que, se algum dia formos desconectados do servidor, nos reconectaremos automaticamente. Ou se estivermos conectados, mandamos nosso cliente para o loop.
if (mqtt.connected ) {
mqt.loop ;
}
Ou então apenas nos reconectamos conforme descrito abaixo.
outro {
// Reconecte a cada 10 segundos
não assinado longo t = milis ;
se (t – últimatentativa de reconexão > 10000L) {
últimaReconnectAttempt = t;
if (mqttConnect ) {
lastReconnectAttempt = 0;
}
}
Há alguns pontos sobre a função de conexão MQTT em relação ao recebimento de retornos de chamada.
mqttConnect : explicação da função
Nós nos conectamos ao corretor, fornecendo o nome do nosso cliente como um nome exclusivo.
mqtt.connect(“medidordeeletricidadeGSM”)
Em seguida, enviamos um sinal de confirmação para qualquer cliente sobre um tópico conectado ao corretor.
mqtt.publish(topicInit, “Medidor iniciado”);
Depois, inscrevemos nosso cliente com um tópico.
mqtt.subscribe(tópicoSub);
Por fim, retornamos se nosso cliente está conectado ou não.
retornar mqtt.connected ;
mqttCallback(char* topic, byte* payload, unsigned int len): explicação da função
Esta função recebe mensagens vindas do broker em algumas variáveis
Tema: Este é o tópico sobre o qual a mensagem está chegando; ele é necessário quando estamos inscritos em vários tópicos e determinamos qual mensagem está chegando.
Carga útil: Esta é a mensagem real que estamos recebendo do corretor em bytes
Len: Isso nos dá o comprimento total da mensagem recebida
Agora, usando essas variáveis, determinamos o que o servidor está tentando dizer ao medidor.
if(dados_r_in_string == “dados”){
Agora, se recebermos um comando do servidor dizendo “dados”, começamos a fazer leituras do sensor ou pino analógico e as enviamos para o servidor:
float v1 = analogRead(A0);
flutuar v2 = analogRead(A1);
Além disso, quando recebemos mensagens como ligar ou desligar o medidor / alimentação principal, também ligamos o relé
if(data_r_in_string == “ON”){
digitalWrite(Relay_PIN,ALTO);
mqtt.publish(topicPub, “o medidor está ligado”);
}
É assim que nossa unidade de medição funciona. Para obter informações sobre a unidade do servidor, leia abaixo.
Script do servidor
O script do servidor é totalmente baseado em Python, então começamos primeiro com o protocolo de comunicação MQTT. Então, a configuração da comunicação é dada abaixo.
Em seguida, importamos as bibliotecas necessárias para a comunicação com o broker MQTT.
Importar paho.mqtt.client como mqtt
importar paho.mqtt.publish como publicar
Em seguida atribuímos duas variáveis com tópicos do MQTT, uma para a qual enviaremos mensagens e outra para a qual receberemos mensagens.
subscription_topic = “ts/café/relatório”
publish_topic = “ts/café/máquina”
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. Fazendo algo na conexão bem-sucedida.
cliente.on_connect = on_connect
cliente.on_message=on_message
Por fim, nos conectaremos ao broker MQTT em uma porta e iniciaremos o cliente dentro de um loop não bloqueante.
cliente.conectar(“broker.hivemq.com”, 1883, 60)
cliente.loop_start
Após a conexão ser bem-sucedida, podemos enviar mensagens usando o seguinte:
publicar.single(tópico, dados_da_mensagem, nome_do_host=”broker.hivemq.com”)
Agora entramos em nossa função de retorno de chamada para analisar as mensagens recebidas.
Temos duas funções para receber dados. Uma é para o status inicial do medidor para verificar se ele foi iniciado ou não; a segunda é para receber os dados do medidor.
Em_mensagem : Recebe os dados do medidor, como leituras e estado
Iniciar : Obtém o status inicial do medidor se ele for iniciado
Agora exibimos todos os dados recebidos do medidor em uma linha como uma tela, como fizemos em um de nossos projetos de IoT “painel de IoT”
se(conectado == Verdadeiro):
print '\r' + “Status do Medidor:”,status, '\t', “Dados do Medidor:”,
dados, '\t', “Estado do medidor:”, estado,
Depois de começarmos a receber os dados, podemos planejar como responderemos ao medidor.
Aqui, estamos apenas recebendo duas voltagens, e se a condição de V1 for menor que V2, então o medidor desligará. Caso contrário, ele ligará quando ambas as voltagens forem iguais.
euf(“:” na mensagem):
dados = mensagem
v1,v2= mensagem.split(“:”)
#qualquer condição para ligar/desligar a energia
se(int(v1) < int(v2)):
enviar_sinais(“LIGADO”)
se(int(v1) == int(v2)):
enviar_sinais(“DESLIGADO”)
Código do medidor
