Su monitor de factura de energía: 4 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:41

ACERCA DE ESTE PROYECTO

Si realmente desea que su hogar sea más inteligente, probablemente querrá comenzar con sus facturas mensuales (es decir, energía, gas, etc.). Como dicen algunos, Good for Planet, The Wallet y The Bottom Line. El hardware de código abierto es nuestra forma de alcanzar la sostenibilidad en el entorno doméstico. Esta idea nos llevó a construir una solución simple y segura, fácil de integrar con cualquier software de domótica ya que expone datos sobre MQTT (en nuestro caso te mostraremos cómo integrarlo en Home Assistant).

Visión general

Para medir el consumo de energía eléctrica, optamos por utilizar el Finder Energy Meter, ya que está diseñado para uso en carril DIN y encaja perfectamente en el armario principal de nuestra casa. Lo bueno de este producto es que tiene una interfaz RS485 Modbus, un protocolo de comunicación estándar industrial que hace que hablar con un Arduino sea realmente fácil. De hecho, Arduino ha lanzado un escudo oficial, el MKR485 y dos librerías para decodificar el protocolo. Como placa base, elegimos el Arduino MKR WiFi 1010, ya que comparte el factor de forma MKR y tiene conectividad WiFi.

Configuración ¡Advertencia! Verifique las regulaciones de su país sobre el manejo del sistema eléctrico de su casa y tenga mucho cuidado porque puede ser mortal. Si no sabe cómo hacerlo, llame a un electricista. El primer paso es instalar el medidor en su armario eléctrico. Para asegurarse de que está trabajando en un entorno seguro, apague la alimentación del terminal eléctrico delante de su sistema y verifique con el multímetro que no haya voltaje entre los terminales. Luego coloque el medidor de energía dentro de su gabinete y conecte los cables vivos y neutros desde el interruptor principal a la entrada del medidor, recuerde usar la convención de color (azul para neutro y marrón / negro / gris para vivo en la UE). La salida debe estar conectada al resto del sistema.

Conexiones de tensión principal. Los cables de arriba son de entrada, los cables de más allá son de salida.

Paso 1: Piezas necesarias

Paso 2: software necesario

Software

Inicie su computadora y abra su IDE. Puede utilizar Arduino IDE o Arduino Create Editor. El código cumple con las siguientes solicitudes: comunicación Modbus, gestión WiFi Protocolo MQTT Modbus es un protocolo de código abierto para sensores y máquinas industriales. Para hacer que Arduino hable Modbus, usaremos la biblioteca Arduino Modbus. Esta biblioteca incluye todos los controladores y hace que la conexión de cualquier dispositivo Modbus sea realmente rápida. Como vamos a leer registros, siguiendo la hoja de datos del medidor, podemos encontrar toda la información que necesitamos como códigos de función, dirección del registro y tamaño del registro en palabras. Pero para que quede más claro, expliquemos cómo funciona Modbus: Los mensajes Modbus siguen una estructura simple: 01 03 04 00 16 00 02 25 C7 0x01 es la dirección del dispositivo 0x03 es el código de función que le dice al dispositivo si queremos leer o escribir datos *, en este caso, leer registros de retención 0x04 para Byte Count 00 16 - Enviamos 4 bytes de dirección de registro (00 16) que le dice al dispositivo lo que queremos leer 00 02 - luego el tamaño del registro (00 02) en palabras (cada palabra tiene 2 bytes de longitud) Los últimos 4 bytes son código CRC. Este código se genera a partir de una función matemática sobre bytes anteriores, esto asegura que el mensaje se haya recibido correctamente.

Integración de Home Assistant Agregar el medidor a Home Assistant es bastante sencillo. Suponiendo que tiene un agente MQTT configurado (aquí está la guía), todo lo que necesita hacer es agregar nuevas definiciones en el archivo configuration.yaml. sensor: - plataforma: mqtt nombre: "Tensión principal" state_topic: "energía / principal / tensión" unidad_de_medida: "V" Aquí tienes que poner el nombre de la medida, el tema MQTT a leer y la unidad de medida de la cantidad. Guarde el archivo, verifique la configuración y vuelva a cargar Home Assistant, ahora las medidas aparecerán en la página principal.

Panel de consumo de Home Assistant que muestra las lecturas actuales

Home Assistant se encargará de crear gráficos y automatizar los procesos desencadenados por sus lecturas. Este tutorial ha finalizado, ahora depende de usted agregar funciones y personalizarlo para sus propios fines.

Paso 3: ensamblar

¿Hecho? ¡Es hora de atornillar la conexión RS485! Usaremos cable trenzado de un solo par con el suelo, generalmente utilizado para líneas telefónicas. Con este cable, puede transmitir a larga distancia (1,2 km). Sin embargo, solo usamos un cable lo suficientemente largo para salir del gabinete y colocar el Arduino en un lugar accesible.

Conexión Finder RS485

La interfaz RS485 nombra sus terminales A, B y COM. Un estándar común de facto es el uso de TX + / RX + o D + como alternativa para B (alto para MARK, es decir, inactivo), TX- / RX- o D- como una alternativa para A (bajo para MARK, es decir, inactivo). El blindaje MKR también admite Full Duplex, verá otros dos terminales, Y y Z. Aquí vamos a atornillar el otro extremo del cable ya que sabemos por la hoja de datos que la comunicación semidúplex ocurre solo en los terminales Y y Z. El terminal COM debe estar conectado a ISOGND. Como usamos una conexión semidúplex y el cableado es de igual a igual, tenemos que configurar los interruptores en el blindaje MKR485 para que coincidan con nuestra configuración: configuramos HALF (2 en apagado) y terminación en YZ (3 en SOBRE); el primero no importa. La terminación es una resistencia que conecta los dos terminales de datos, para amortiguar las interferencias.

Eso es todo. ¡Ahora puede cerrar el gabinete y concentrarse en el lado del software!

Paso 4: Código

#incluir

#include #include #include // tus credenciales de wifi const char ssid = "**********"; const char pass = "**********";

Red WiFiClient; Cliente MQTTClient; tasa larga sin firmar = 60000; // frecuencia de actualización predeterminada en ms unsigned long lastMillis = 0;

// función de conexión void connect () {Serial.print ("comprobando wifi…"); while (WiFi.status ()! = WL_CONNECTED) {Serial.print ("."); retraso (1000); } Serial.print ("\ nconectando …"); while (! client.connect ("nombre_dispositivo", "nombre_usuario", "pw_usuario")) {// CAMBIAR PARA COINCIDIR CON SU CONFIGURACIÓN Serial.print ("."); retraso (1000); } Serial.println ("\ nconectado!"); client.subscribe ("energía / principal / tasa de actualización"); // tema para establecer la frecuencia de actualización de forma remota} // mqtt recibe la función de devolución de llamada void messageReceived (String & topic, String & payload) {Serial.println ("entrante:" + tema + "-" + payload); if (topic == "energy / main / refreshrate") {// controlador de frecuencia de actualización rate = payload.toInt () * 1000; Serial.println ("nueva tasa" + Cadena (tasa)); }}

configuración vacía () {Serial.begin (115200); WiFi.begin (ssid, pase); mientras (! Serial); client.begin ("broker_ip", neto); // CAMBIAR PARA COINCIDIR CON SU CONFIGURACIÓN client.onMessage (messageReceived); // iniciar el cliente Modbus RTU if (! ModbusRTUClient.begin (9600)) {Serial.println ("¡Error al iniciar el cliente Modbus RTU!"); mientras (1); }}

bucle vacío () {cliente.loop (); if (! client.connected ()) {// comprobar la conexión de red connect (); } // publicar un mensaje después de que transcurra la actualización (rutina sin bloqueo) if (millis () - lastMillis> rate) {lastMillis = millis (); // hacer que todas las llamadas de lectura floten volt = readVoltage (); retraso (100); float amp = readCurrent (); retraso (100); vatio doble = readPower (); retraso (100); float hz = readFreq (); retraso (100); doble wh = readEnergy (); // publicar resultados en temas relacionados client.publish ("energía / principal / voltaje", String (volt, 3)); client.publish ("energía / principal / actual", String (amp, 3)); client.publish ("energía / principal / potencia", Cadena (vatios, 3)); client.publish ("energía / principal / frecuencia", String (hz, 3)); client.publish ("energía / principal / energía", String (wh, 3)); Serial.print (String (voltios, 3) + "V" + String (amp, 3) + "A" + String (vatios, 3) + "W"); Serial.println (Cadena (hz, 3) + "Hz" + Cadena (wh, 3) + "kWh"); retraso (100); }}

/ * Funciones para leer los registros del medidor de energía del Finder * * Consulte el manual del protocolo modbus para comprender el código * https://gfinder.findernet.com/public/attachments/7E/EN/PRT_Modbus_7E_64_68_78_86EN.pdf * / float readVoltage () {float voltio = 0.; if (! ModbusRTUClient.requestFrom (0x01, HOLDING_REGISTERS, 0x000C, 2)) {// realiza la llamada al registro Serial.print ("¡no se pudo leer el voltaje!"); Serial.println (ModbusRTUClient.lastError ()); // controlador de errores} else {uint16_t word1 = ModbusRTUClient.read (); // lee datos del búfer uint16_t word2 = ModbusRTUClient.read (); uint32_t milivoltio = palabra1 << 16 | palabra2; // bit matemático voltio = milivoltio / 1000.0; } return voltio; } float readCurrent () {float ampere = 0.; if (! ModbusRTUClient.requestFrom (0x01, HOLDING_REGISTERS, 0x0016, 2)) {Serial.print ("¡no se pudo leer la corriente!"); Serial.println (ModbusRTUClient.lastError ()); } else {uint16_t palabra1 = ModbusRTUClient.read (); uint16_t palabra2 = ModbusRTUClient.read (); int32_t miliamperios = palabra1 << 16 | palabra2; amperio = miliamperios / 1000,0; } devolver amperios; }

double readPower () {doble vatio = 0.; if (! ModbusRTUClient.requestFrom (0x01, HOLDING_REGISTERS, 0x0025, 3)) {Serial.print ("¡no se pudo leer la energía!"); Serial.println (ModbusRTUClient.lastError ()); } else {uint16_t palabra1 = ModbusRTUClient.read (); uint16_t palabra2 = ModbusRTUClient.read (); uint16_t palabra3 = ModbusRTUClient.read (); uint64_t milivatios; si (palabra1 >> 7 == 0) {milivatio = palabra1