Seu monitor de conta de energia: 4 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:36

SOBRE ESTE PROJETO

Se você realmente deseja tornar sua casa mais inteligente, provavelmente vai querer começar com suas contas mensais (ou seja, energia, gás, etc …). Como alguns dizem, Good for Planet, The Wallet and The Bottom Line. O hardware de código aberto é a nossa maneira de alcançar a sustentabilidade no ambiente doméstico! Esta ideia nos levou a construir uma solução simples e segura, fácil de integrar com qualquer software de automação residencial, pois expõe dados sobre MQTT (no nosso caso mostraremos como integrá-lo ao Home Assistant).

Visão geral

Para medir o consumo de energia elétrica, optou-se pelo uso do Finder Energy Meter, pois é projetado para uso em trilho DIN e se encaixa perfeitamente no gabinete principal de nossa casa. O legal deste produto é que ele possui uma interface Modbus RS485, um protocolo de comunicação padrão industrial que torna muito fácil falar com um Arduino. Na verdade, o Arduino lançou um escudo oficial, o MKR485 e duas bibliotecas para decodificar o protocolo. Como placa-mãe, escolhemos o Arduino MKR WiFi 1010, já que ele compartilha o formato MKR e possui conectividade wi-fi.

SetupWarning! Verifique os regulamentos do seu país sobre como lidar com o sistema elétrico de sua casa e seja extremamente cuidadoso porque pode ser mortal! Se você não souber como fazer, chame um eletricista. O primeiro passo é instalar o medidor em seu quadro elétrico. Para garantir que você esteja trabalhando em um ambiente seguro, desligue a alimentação do terminal elétrico antes do sistema e verifique novamente com o multímetro se não há tensão entre os terminais. Em seguida, coloque o medidor de energia dentro de seu gabinete e conecte os fios vivo e neutro do disjuntor principal à entrada do medidor, lembre-se de usar a convenção de cores (azul para neutro e marrom / preto / cinza para vivo na UE). A saída deve ser conectada ao resto do sistema.

Conexões de tensão principal. Os fios acima são entradas, os fios além são saídas.

Etapa 1: peças necessárias

Etapa 2: necessidades de software

Programas

Inicie o seu computador e abra o seu IDE. Você pode usar o Arduino IDE ou o Arduino Create Editor. O código atende às seguintes solicitações: comunicação Modbus, gerenciamento WiFi protocolo MQTT Modbus é um protocolo open-source para sensores e máquinas industriais. Para fazer o Arduino falar Modbus, vamos usar a biblioteca Arduino Modbus. Esta biblioteca reúne todos os manipuladores e torna a conexão de qualquer dispositivo Modbus muito rápida. Como vamos ler os registros, seguindo o datasheet do medidor, podemos encontrar todas as informações que precisamos como códigos de função, endereço do registro e tamanho do registro em palavras. Mas para ficar mais claro, vamos explicar como funciona o Modbus: As mensagens do Modbus seguem uma estrutura simples: 01 03 04 00 16 00 02 25 C7 0x01 é o endereço do dispositivo 0x03 é o código de função que diz ao dispositivo se queremos ler ou gravar dados *, neste caso, ler os registros de retenção 0x04 para Contagem de bytes00 16 - Enviamos 4 bytes do endereço do registro (00 16) que informa ao dispositivo o que queremos ler 00 02- então o tamanho do registro (00 02) em palavras (cada palavra tem 2 bytes de comprimento) Os últimos 4 bytes são código CRC. Este código é gerado a partir de uma função matemática sobre os bytes anteriores, o que garante que a mensagem foi recebida corretamente.

Integração com o Home Assistant Adicionar o medidor ao Home Assistant é bastante simples. Supondo que você tenha um broker MQTT configurado (aqui está o guia), tudo o que você precisa fazer é incluir novas definições no arquivo configuration.yaml. sensor: - plataforma: mqtt nome: "Main Voltage" state_topic: "energy / main / voltage" unit_of_measurement: "V" Aqui você deve colocar o nome da medição, o tópico MQTT a ser lido e a unidade de medição da grandeza. Salve o arquivo, verifique a configuração e recarregue o Home Assistant, agora as medidas aparecerão na página principal.

Painel de consumo do Home Assistant mostrando as leituras atuais

O Home Assistant se encarregará de criar gráficos e automatizar processos acionados por suas leituras. Este tutorial terminou, agora cabe a você adicionar recursos e personalizá-lo para seus próprios fins!

Etapa 3: montar

Feito? É hora de parafusar a conexão RS485! Usaremos cabo de par simples trançado com o aterramento, normalmente usado para linhas telefônicas. Com este cabo, você pode transmitir em longa distância (1,2 km). No entanto, usamos apenas um cabo longo o suficiente para sair do gabinete e colocar o Arduino em um local acessível.

Conexão Finder RS485

A interface RS485 denomina seus terminais A, B e COM. Um padrão comum de fato é o uso de TX + / RX + ou D + como alternativa para B (alto para MARK, ou seja, inativo), TX- / RX- ou D- como alternativa para A (baixo para MARK, ou seja, inativo). A blindagem MKR também suporta Full Duplex, você verá dois outros terminais, Y e Z. Aqui vamos aparafusar a outra extremidade do cabo, pois sabemos pela ficha técnica que a comunicação half-duplex ocorre apenas nos terminais Y e Z. O terminal COM deve ser conectado ao ISOGND. Como usamos uma conexão half-duplex e como o cabeamento é ponto a ponto, temos que configurar os interruptores na blindagem MKR485 para corresponder à nossa configuração: definimos HALF (2 para desligado) e terminação em YZ (3 para SOBRE); o primeiro não importa. A terminação é uma resistência conectando os dois terminais de dados, para amortecimento de interferências.

É isso. Agora você pode fechar o gabinete e se concentrar no lado do software!

Etapa 4: Código

#incluir

#include #include #include // suas credenciais wi-fi const char ssid = "**********"; const char pass = "**********";

Rede WiFiClient; Cliente MQTTClient; taxa longa sem sinal = 60.000; // taxa de atualização padrão em ms unsigned long lastMillis = 0;

// função de conexão void connect () {Serial.print ("verificação de wi-fi…"); while (WiFi.status ()! = WL_CONNECTED) {Serial.print ("."); atraso (1000); } Serial.print ("\ nconectando…"); while (! client.connect ("device_name", "user_name", "user_pw")) {// ALTERAR PARA CORRESPONDER À SUA CONFIGURAÇÃO Serial.print ("."); atraso (1000); } Serial.println ("\ nconectado!"); client.subscribe ("energia / principal / taxa de atualização"); // tópico para definir a taxa de atualização remotamente} // mqtt recebe função de retorno de chamada void messageReceived (String & topic, String & carga útil) {Serial.println ("entrando:" + tópico + "-" + carga útil); if (topic == "energy / main / refreshrate") {// refresh rate handler rate = payload.toInt () * 1000; Serial.println ("nova taxa" + String (taxa)); }}

void setup () {Serial.begin (115200); WiFi.begin (SSID, aprovação); while (! Serial); client.begin ("broker_ip", net); // ALTERE PARA CORRESPONDER À SUA CONFIGURAÇÃO client.onMessage (messageReceived); // iniciar o cliente Modbus RTU if (! ModbusRTUClient.begin (9600)) {Serial.println ("Falha ao iniciar o cliente Modbus RTU!"); enquanto (1); }}

void loop () {client.loop (); if (! client.connected ()) {// verificar a conexão de rede connect (); } // publica uma mensagem após a atualização decorrida (rotina sem bloqueio) if (millis () - lastMillis> taxa) {lastMillis = millis (); // faz todas as chamadas de leitura float volt = readVoltage (); atraso (100); float amp = readCurrent (); atraso (100); watt duplo = readPower (); atraso (100); float hz = readFreq (); atraso (100); double wh = readEnergy (); // publica resultados em tópicos relacionados client.publish ("energy / main / voltage", String (volt, 3)); client.publish ("energia / principal / corrente", String (amp, 3)); client.publish ("energia / principal / potência", String (watt, 3)); client.publish ("energia / principal / frequência", String (hz, 3)); client.publish ("energia / principal / energia", String (wh, 3)); Serial.print (String (volt, 3) + "V" + String (amp, 3) + "A" + String (watt, 3) + "W"); Serial.println (String (hz, 3) + "Hz" + String (wh, 3) + "kWh"); atraso (100); }}

/ * Funções para ler os registros do medidor de energia do Finder * * Verifique o manual do protocolo modbus para entender o código * https://gfinder.findernet.com/public/attachments/7E/EN/PRT_Modbus_7E_64_68_78_86EN.pdf * / float readVoltage () {float volt = 0.; if (! ModbusRTUClient.requestFrom (0x01, HOLDING_REGISTERS, 0x000C, 2)) {// faz a chamada para o registrador Serial.print ("falha ao ler a tensão!"); Serial.println (ModbusRTUClient.lastError ()); // manipulador de erros} else {uint16_t word1 = ModbusRTUClient.read (); // lê os dados do buffer uint16_t word2 = ModbusRTUClient.read (); uint32_t milivolt = palavra1 << 16 | palavra2; // bit matemático volt = milivolt / 1000,0; } retorno volt; } float readCurrent () {float ampere = 0.; if (! ModbusRTUClient.requestFrom (0x01, HOLDING_REGISTERS, 0x0016, 2)) {Serial.print ("falha ao ler a corrente!"); Serial.println (ModbusRTUClient.lastError ()); } else {uint16_t word1 = ModbusRTUClient.read (); uint16_t word2 = ModbusRTUClient.read (); int32_t miliampère = palavra1 << 16 | palavra2; ampere = miliamperes / 1000,0; } return ampere; }

double readPower () {double watt = 0.; if (! ModbusRTUClient.requestFrom (0x01, HOLDING_REGISTERS, 0x0025, 3)) {Serial.print ("falha ao ler energia!"); Serial.println (ModbusRTUClient.lastError ()); } else {uint16_t word1 = ModbusRTUClient.read (); uint16_t word2 = ModbusRTUClient.read (); uint16_t word3 = ModbusRTUClient.read (); uint64_t milliwatt; if (palavra1 >> 7 == 0) {miliwatt = palavra1