Ejemplo del programa de interfaz con windows para PZEM-004T V3 V3.0 usando Arduino


En este post, discutiremos el uso o la utilización del módulo PZEM-004T V3.0 (del que hemos hablado en este blog en numerosas ocasiones), el cual se interconecta utilizando cualquier variante de Arduino (por ejemplo Arduino UNO o Arduino Mega2560).

A tener en cuenta que si se utiliza el programa de ejemplo con el Hardware Serial, se necesita el Arduino Mega2560 porque el Hardware Serial del Arduino UNO ya se utiliza para la comunicación con el Monitor Serial.

El módulo PZEM-004T V3.0 es una versión mejorada de PZEM-004T V2.0 y también el protocolo para comunicar la interfaz usado es diferente, es decir el programa de la biblioteca para PZEM-004T V2 no se puede utilizar para la interfaz con PZEM-004T V3.0.

Hardware requerido

En este ejemplo de programa de módulo PZEM-004T V3, se necesita algo de hardware, entre otros:

  • Módulo PZEM-004T V3.0
  • Arduino UNO o Arduino Mega2560
  • Algunos cables puente MF/FF
  • Carga (puede usar luces TL / bombilla / LED / taladro eléctrico)
  • USB a Serial TTL (opcional para probar funciones usando la aplicación Master PZEM-004T).

Diagrama de circuito/cableado

En la siguiente tabla se muestra la conexión o conexión entre el módulo PZEM-004T V3.0 y Arduino

PZEM-004T V3.0Arduino UNO/Mega2560
CCV+5V
TIERRATIERRA
TexasRX (serie de software/serie de hardware)
RXTX (serie de software/serie de hardware)

Para la conexión o conexión entre PZEM-004T V3.0 con Transformador de Corriente (CT), Carga y Arduino en su totalidad se puede ver en la siguiente imagen:

conexiones-pzem

Prueba de funcionamiento del módulo PZEM-004T V3.0

Hay ocasiones en las que hacemos un programa con Arduino y después de subirlo resulta que la salida no es la esperada, muchos se quejan de que el módulo PZEM-004T V3.0 está dañado o funciona mal.

Por esta razón, antes de interconectar el módulo PZEM-004T V3.0 con Arduino, le recomendamos que primero pruebe la función del módulo PZEM-004T V3.0 para asegurarse de que el módulo PZEM-004T V3.0 no esté dañado o funcionando. adecuadamente.

Descargue la aplicación para probar el módulo de función PZEM-004T V3.0 en el siguiente enlace: Software PZEM-004T Nueva versión

Antes de ejecutar el programa debemos descargar isAnalogLibrary.ocx, que es un archivo de componente de objeto ActiveX, es decir un tipo de archivo que se utiliza en sistemas operativos Windows para implementar funcionalidades de software reutilizables. Los componentes de objeto ActiveX se pueden utilizar en aplicaciones de Windows para añadir funcionalidades especiales, como controles de usuario personalizados, gráficos y animaciones, y para interactuar con otros programas o con el sistema operativo.

Los archivos con la extensión .ocx suelen ser archivos de biblioteca de enlace dinámico (DLL) que contienen código ejecutable y datos que se pueden utilizar en aplicaciones de Windows. Los archivos .ocx se pueden cargar en memoria y utilizar en tiempo de ejecución por varias aplicaciones, lo que permite ahorrar espacio en disco y memoria en el sistema.

A continuación, extraiga / descomprima el archivo que descargó anteriormente, luego registre el archivo: isAnalogLibrary.ocx en el sistema operativo Windows PC / Laptop de la siguiente manera:

  • Copie el archivo  isAnalogLibrary.ocx  a la carpeta:  Windows/System32/
  • Abra  el símbolo del sistema  o  cmd.exe
  • Escriba: Regsvr32.exe C:\Windows\System32\isAnalogLibrary.ocx
  • Si tiene éxito, aparecerá una notificación «Registrado con éxito»

Después de registrar correctamente el archivo: isAnalogLibrary.ocx , ejecute el archivo: PZEM004T-Master.exe para comprobar si el módulo PZEM-004T V3.0 funciona o no.

programa-windows-para-pzem

Tenga en cuenta que, para realizar pruebas con la aplicación, necesita un hardware USB a Serial TTL que está ampliamente disponible en el mercado, como: tipo CH340, tipo PL2303, etc., como se muestra a continuación.

adaptador-usb-serie


Un adaptador USB a Serial TTL es un dispositivo de hardware que se utiliza para convertir señales de transmisión en serie (TTL) en señales USB y viceversa. Los adaptadores de este tipo se utilizan a menudo para conectar dispositivos que utilizan señales de transmisión en serie, como microcontroladores y módems, a un puerto USB de un ordenador soliendo incluir un chip de conversión de señales que se encarga de realizar la conversión entre las señales USB y las señales TTL. Algunos adaptadores también incluyen una interfaz de programación en circuito (ICP) que se puede utilizar para programar microcontroladores o realizar otras tareas de depuración y diagnóstico.

Estos adaptadores suelen ser pequeños y portátiles, y se pueden utilizar para conectar dispositivos a un ordenador de escritorio o portátil mediante un cable USB. Algunos adaptadores también tienen opciones de montaje en panel, lo que los hace adecuados para su uso en equipos de automatización y sistemas de control.

Después de ensamblar el módulo PZEM-004T V3.0 con carga (puede ser una luz eléctrica/taladro) o con USB a Serial TTL y asegúrese de que el sistema operativo Windows haya reconocido/detectado el USB a Serial TTL, haga clic en Establecer COM Puerto y luego haga clic en Iniciar medida .

Después de probar o probar la función y confirmar que el módulo PZEM-004T V3.0 funciona correctamente, se puede continuar haciendo un programa con Arduino u otro microcontrolador.

Ejemplos de programas para el Arduino

Aparte de la instalacion del harware y del sw en nuestro pc con windows debemos instalar un firmaware en la placa arduino para qeu se comunique con el citado programa . En el programa de ejemplo para acceder o interactuar con el módulo PZEM-004T V3.0 usando este Arduino, usamos la siguiente biblioteca:PZEM-004T-v30  o  PZEM-004T-v30

Después de descargar e instalar la biblioteca, abra el programa de muestra existente de la biblioteca predeterminada o copie y pegue el siguiente boceto:

#include <PZEM004Tv30.h>

PZEM004Tv30 pzem(11, 12); // Software Pin serie 11 (RX) y 12 (TX)

void setup () {
   Serial.begin(115200);
}

void loop () {
   voltaje de flotación = pzem.voltage();
   if (voltaje! = NAN) {
       Serial.print("Voltaje: ");
       Serial.print(voltaje);
       Serial.println("V");
   } else {
       Serial.println("Error al leer el voltaje");
   }

   float current = pzem.current();
   if(current != NAN){
       Serial.print("Current: ");
       Serial.print(current);
       Serial.println("A");
   } else {
       Serial.println("Error al leer la corriente");
   }

   float power = pzem.power();
   if(current != NAN){
       Serial.print("Power: ");
       Serial.print(power);
       Serial.println("W");
   } else {
       Serial.println("Error al leer la potencia");
   }

   float energy = pzem.energy();
   if(current != NAN){
       Serial.print("Energy: ");
       Serial.print(energy,3);
       Serial.println("kWh");
   } else {
       Serial.println("Error al leer consumo");
   }

   float frequency = pzem.frequency();
   if(current != NAN){
       Serial.print("Frequency: ");
       Serial.print(frequency, 1);
       Serial.println("Hz");
   } else {
       Serial.println("Error al leer la frecuencia");
   }

   float pf = pzem.pf();
   if(current != NAN){
       Serial.print("PF: ");
       Serial.println(pf);
   } else {
       Serial.println("Error al leer el factor de potencia");
   }

   Serial.println();
   delay(2000);
}

Tambien podemos usar Serial Hardware de la siguiente manera:

#include <PZEM004Tv30.h>

PZEM004Tv30 pzem(&Serie3); // Hardware de Menggunakan Serie 3

void setup () {
   Serial.begin(115200);
}

void loop () {
     voltaje de flotación = pzem.voltage();
     if (voltaje! = NAN) {
         Serial.print("Voltaje: ");
         Serial.print(voltaje);
         Serial.println("V");
     } else {
         Serial.println("Error al leer el voltaje");
     }

     float current = pzem.current();
     if(current != NAN){
         Serial.print("Current: ");
         Serial.print(current);
         Serial.println("A");
     } else {
         Serial.println("Error reading current");
     }

     float power = pzem.power();
     if(current != NAN){
         Serial.print("Power: ");
         Serial.print(power);
         Serial.println("W");
     } else {
         Serial.println("Error al leer  potencia");
     }

     float energy = pzem.energy();
     if(current != NAN){
         Serial.print("Energy: ");
         Serial.print(energy,3);
         Serial.println("kWh");
     } else {
         Serial.println("Error al leer  energia");
     }

     float frequency = pzem.frequency();
     if(current != NAN){
         Serial.print("Frequency: ");
         Serial.print(frequency, 1);
         Serial.println("Hz");
     } else {
         Serial.println("Error al leer frequencia");
     }

     float pf = pzem.pf();
     if(current != NAN){
         Serial.print("PF: ");
         Serial.println(pf);
     } else {
         Serial.println("Error al leer el factor de potencia");
     }

     Serial.println();
     delay(2000);
 }

Después de cargar el programa de boceto anterior en la placa Arduino, abra el monitor serie a velocidad de transmisión: 115200. Si todo funciona bien, los datos de lectura del módulo PZEM-004T V3.0 se mostrarán en la ventana del monitor serie.

Anuncio publicitario

Usando una Raspberry Pi para obtener información de dos sensores PZEM004T que están conectados al microcontrolador Arduino Mega


El objetivo de este post es ver un ejemplo der cómo medir el voltaje, la corriente y la potencia con dos sensores PZEM 004T de una Raspberry Pi .

En el ejemplo los sensores no están conectados directamente a la Raspberry, pero están conectados a un microcontrolador Arduino (Mega 2560) y este se conecta a la Raspberry a través de un cable USB.

Primero obtenemos todos estos valores usando el microcontrolador Arduino con capacidad de dos puertos serie como podria ser también un ESP32 (NodeMCU) o por supuesto un Arduino Mega, y luego los enviamos a la Raspberry Pi.

Es interesante observar cómo al proporcionar los módulos PZEM004 una salida serie necesitamos usar ese protocolo para recepcionar los datos motivo por el cual precisamente utilizamos dos puertos serie del microcontrolador ( y no sería posible por tanto añadir más módulos PZEM004)

Gracias a la biblioteca PZEM-004T v3.0 para el monitor de energía Peacefair PZEM-004T-10A y PZEM-004T-100A v3.0 utilizando la interfaz ModBUS y un microcontrolador, podemos monitorizar el consumo eléctrico junto a otras variables eléctricas como la tensión , la frecuencia , el factor de potencia, etc.

Es interesante destacar que debemos usar la ultima version del modulo, pues la versión 3.0 PZEM es una versión mejorada del antiguo PZEM-004T 

Respecto a las conexiones eléctricas debemos tener especialmente cuidado en el conexionado de las clemas de BT , las cuales viene claramente especificadas en la hoja de característica del modulo PZEM que usemos, pues una parte es para la medida del voltaje ( la medición se hace en paralelo ) y la parte contigua es la parte de la medida de la Intensidad (la medida se toma en serie en versiones de menos intensidad maxima admisible, pero para la version de 100A se suele tomar con una bobina toroidal o con un pinza amperimétrica)

¡Asegúrese de que el dispositivo esté conectado a la alimentación de CA! Los 5V solo alimentan los optoacopladores, no el chip real. Además, tenga cuidado, ¡la corriente alterna es peligrosa! ¡Si no sabe lo que estás haciendo, puede morir ! Es usted responsable de su propia estupidez. Así que no sea estúpido

Peor tanto ,debemos extremar el cuidado especialmente en estas conexiones (las que van con tornillo).

Observe por ejemplo las conexiones del módulo de 100 Amp. usado para escribir este post:

Esta versión PZEM tiene una UART Serial que funciona a 5V, por lo que se debe realizar una simple modificación soldando una resistencia de 1K a 1/4W para permitir que la comunicación funcione a 3.3v en los casos de placas como Raspberry Pi, ESP32 y esp8266, con esta modificación la UART funcionará a 5v o 3.3v.

Nota: Esta es la manera más sencilla y económica si no tienen al alcance un convertidor TTL de 5 a 3.3v, pero no se garantiza que funcione en todos los casos y con todos los medidores (en el prototipo probado funciona sin problemas).

El circuito final para el montaje de los dos PZEM quedaría como se puede ver en la imagen donde vemos como los alimentamos a +5V DC desde el microcontrolador, usamos las lineas tx/rx de forma inversa hacia el microcontrolador y finalmente el microcontrolador lo comunicamos con la Raspberry pi mediante un cable USB

Como se indicó anteriormente, el primer paso es recopilar todos los valores del microcontrolador Arduino, por lo que para hacerlo debemos usar la biblioteca . Esta biblioteca se puede descargar desde la página web: https://github.com/olehs/PZEM004T como un paquete zip, luego se debe agregar dentro del IDE de Arduino

El siguiente paso es conectar los sensores al microcontrolador arduino. Usaremos la librería SoftwareSerial para permitir la comunicación serial en otros pines digitales del Arduino y poder leer más de un dispositivo serial. Entonces, los terminales RX y TX del primer sensor están conectados a los pines 11 y 10 del microcontrolador y los terminales RX y TX del segundo sensor están conectados a los pines 13 y 12 respectivamente.

Ahora es el momento de desarrollar el código en Arduino IDE de la siguiente manera:

///////////////////////////////////////////////////////// ///////////////////////////////////////////////// // /////////////////////////////////////////
 //* Código para obtener el voltaje, corriente y potencia de dos sensores AC PZEM conectados al microcontrolador Arduino Mega, luego todos los valores *//
 // se concatenan en una variable char para poder enviarla a través de comunicación serie //
 ///////////////////////////////////////////////////////// ///////////////////////////////////////////////// // ///////////////////////////////////////
  
 #include
           
 #include
           
            
  
 IPAddress ip(192,168,1,11);
 IPAddress ip1(192,168,1,10);
  
 charix[10];
 char iy[10];
 char iz[10];
 charconc[360];
  
 charix1[10];
 char iy1[10];
 char iz1[10];
  
 flotante V, V1;
 flotar i, i1;
 flotante p, p1;
  
 void setup () {
 Serial.begin(9600);
 }
  
 void loop () {
   
 PZEM004T pzem(10,11); //(RX TX)
 pzem.setAddress(ip);
 V=pzem.voltage(ip); //voltaje obtenido de la biblioteca pzem
 i = pzem.current(ip); // actual obtenido de la biblioteca pzem
 p = pzem.power(ip);//potencia obtenida de la biblioteca pzem
 dtostrf(V,7,3,ix); //función utilizada para almacenar el valor actual en la variable char ix, especificando 3 como el número de dígitos después del punto
 dtostrf(i,7,3,iy); //función utilizada para almacenar el valor actual en la variable char iy, especificando 3 como el número de dígitos después del punto
 dtostrf(p,7,3,iz); //función utilizada para almacenar el valor de potencia en la variable char iz, especificando 3 como el número de dígitos después del punto
 retraso (1000);
  
 PZEM004T pzem1(12,13); //(RX TX)
 pzem1.setAddress(ip1);
 V1=pzem1.voltage(ip1); //voltaje obtenido de la biblioteca pzem
 i1 = pzem1.current(ip1); // actual obtenido de la biblioteca pzem
 p1 = pzem1.power(ip1);//potencia obtenida de la biblioteca pzem
 dtostrf(V1,7,3,ix1);//función utilizada para almacenar el valor actual en la variable char ix1, especificando 3 como el número de dígitos después del punto
 dtostrf(i1,7,3,iy1); //función utilizada para almacenar el valor actual en la variable char iy1, especificando 3 como el número de dígitos después del punto
 dtostrf(p1,7,3,iz1); // función utilizada para almacenar el valor de potencia en la variable char iz1, especificando 3 como el número de dígitos después del punto
 retraso (1000);
  
 sprintf(conc,":%s,:%s,:%s,:%s,:%s,:%s,\n", ix,iy,iz,ix1,iy1,iz1); // función utilizada para concatenar todos los valores en una sola variable char
 Serial.write(conc);
  
 }  /////////////////////////
 

Observaciones:

  • Los sensores no se leen al mismo tiempo.
  • El tipo de los valores dados por el sensor es flotante.
  • Después de obtener todos los valores, estos se convierten de tipo flotante a char utilizando la función «dtostrf» en la que los lugares decimales se limitan a tres.
  • Los 6 valores se concatenan mediante la función «sprintf», en una única matriz de caracteres y luego se envían como datos en serie.
  • Además de poner todos los valores juntos en la matriz char, también ponemos los caracteres ‘:’ y ‘,’. Al final, la matriz de caracteres se ve así: “:val1,:val2,:val3,:val4,:val5,:val6,:”. Se hace con el fin de analizar y sacar los valores fácilmente en python.   

Después de cargar y probar el código en el microcontrolador, es hora de lidiar con el script de python. El microcontrolador Arduino debe conectarse a la Raspberry mediante un cable USB.

Antes de comenzar con el código, podría ser bueno saber cómo crear un archivo python desde la terminal de Linux. Se hace escribiendo la siguiente línea de comando:

toque PZEM_Sensors.py

Luego para abrir el archivo ya creado, debemos teclear la siguiente línea de comando:

nano PZEM_Sensores.py

import serial
 import time
 import re
  
 port = "/dev/ttyACM0"
 s1 = serial.Serial(port,9600)
  
 while True:
     if s1.inWaiting()>0:
         inputValue = s1.readline().decode() 
         m = re.search('.*:(.*),.*:(.*),.*:(.*),.*:(.*),.*:(.*),.*:(.*),',inputValue) # command used to read the information and split it between the charcaters ':' and ','
         v1 = m.group(1).replace(" ","") ## command used to saved the information splitted before in a the variable 
         i1 = m.group(2).replace(" ","")
         p1 = m.group(3).replace(" ","")
         v2 = m.group(4).replace(" ","")
         i2 = m.group(5).replace(" ","")
         p2 = m.group(6).replace(" ","")
         a = float(v1)
         b = float(i1)
         c = float(p1)
         d = float(v2)
         e = float(i2)
         f = float(p2)
         print("Voltage1:",+a)
         print("Current1:",+b)
         print("Power1:",+c)
         print("Voltage2:",+d)
         print("Current2:",+e)
         print("Power2:",+f)  


Observaciones:

  • Deberíamos especificar el puerto de la Raspberry donde está conectado el sensor. Para saberlo, solo debemos escribir el siguiente comando desde la ventana de la Terminal LX: ls /dev –> Los nombres de los dispositivos USB conectados comienzan con: “ttyUSBX”. Donde X indica el número de cada dispositivo USB conectado.
  • El puerto serie se lee y decodifica para asegurarse de que tenemos una cadena de caracteres. Se hace con la función readline() y decode() respectivamente.
  • Los seis valores se obtienen mediante el uso de expresiones regulares. Usando ‘.*:(.*),’, tomamos todos los caracteres que están entre ‘:’ y ‘,’ y luego los almacenamos en grupos.
  • Al final los valores se convierten de tipo char a tipo float.  

Después de escribir todo el código y presionar las teclas Ctrl + X, se le pedirá que lo guarde o no. Debe presionar la tecla y o n y luego Enter.

Para ejecutar el código, debemos escribir la siguiente línea de comando:

python PZEM_Sensores.py

Luego, todos los resultados y mensajes aparecerán en las ventanas de la Terminal o aparecerá un mensaje de error si hay algo incorrecto dentro del código.

La siguiente figura muestra todos los resultados obtenidos de los dos sensores PZEM. La corriente 1 es 0 debido a que no hay ningún sensor de corriente conectado y por eso la potencia 1 también es 0. Si hay algún problema de comunicación el valor que obtendremos es -1.

Mas información en https://miniprojets.net/index.php/2019/08/21/using-a-raspberry-pi-3-to-get-information-of-two-pzem004t-sensors-which-are-connected-to-the-arduino-mega-microcontroller/

Medidas eléctricas de +6canales ( software)


Ya se trató en este blog el hardware de EmonESP/EmonCMS ,una placa medidora de energía que usa tambien un ESP32 proporcionado 6 canales expandibles pudiendo leer 6 canales de corriente y 2 canales de voltaje a la vez. Para ello utiliza transformadores de corriente y un transformador de CA para medir el voltaje y alimentar la(s) placa(s)/ESP32. 

Estas son algunas de sus carastericticas

  • Muestras de 6 canales de corriente y 1 canal de voltaje (ampliable a 2 voltajes)
  • Las placas complementarias (hasta 6) pueden expandir el medidor hasta 42 canales de corriente y 8 canales de voltaje
  • Utiliza 2  Microchip ATM90E32AS – 3 canales de corriente y 1 voltaje por IC
  • Para cada canal, el medidor también puede calcular lo siguiente:
    • Poder activo
    • Poder reactivo
    • Poder aparente
    • Factor de potencia
    • Frecuencia
    • La temperatura
  • Utiliza abrazaderas de transformador de corriente estándar para probar la corriente
  • Resistencias de carga de 22 ohmios por canal de corriente
  • Incluye convertidor reductor incorporado para alimentar ESP32 y electrónica
  • 2 interrupciones IRQ y 1 salida de advertencia conectada a ESP32
  • Salidas de cruce por cero
  • Salidas de pulso de energía por IC (4 por IC x2)
  • Interfaz SPI
  • Error de medición IC: 0,1%
  • Rango dinámico IC: 6000:1
  • Selección de ganancia actual: hasta 4x
  • Deriva de referencia de voltaje típica (ppm/°C): 6
  • Resolución ADC (bits): 16

La placa principal cuyas medidas pueden ser bien MonofásicaTrifásicas incluye un convertidor reductor para alimentar la electrónica y la placa de desarrollo ESP32, que se conecta directamente a la placa. Se pueden apilar hasta 6 placas adicionales encima de la placa principal para permitirle monitorear hasta 42 canales actuales en resolución de 16 bits, en tiempo real, ¡todo a la vez!

La potencia se puede calcular en el software, pero el factor de potencia deberá estimarse ((voltaje*corriente)*power_factor)).

A continuación destacamos los elementos hardware necesarios para completar la instalación:

  • Transformadores de corriente (cualquier combinación de los siguientes, o cualquier transformador de corriente que no supere los 720 mV RMS o la salida de 33 mA)
    • SCT-006 20A/25mA Micro (apertura de 6 mm – conectores de 3,5 mm)
    • SCT-010 80A/26.6mA Mini (apertura 10mm – conectores 3.5mm)
    • SCT-013-000 100A/50mA (apertura 13mm – conectores 3.5mm)
    • SCT-016 120A/40mA (apertura 16mm – conectores 3.5mm)
    • Magnelab SCT-0750-100 (conectores de tornillo: debe cortar la conexión de la resistencia de carga en la parte posterior de la placa, ya que tienen una resistencia de carga incorporada).
    • SCT-024 200A/100mA (apertura 24mm – salida terminal)
    • También se pueden usar otros, siempre que estén clasificados para la cantidad de energía que desea medir y tengan una salida de corriente de no más de 720 mV RMS, o 33 mA en la salida máxima.
  • Transformador de CA (NO CC):
    • América del Norte: Jameco Reliapro 120V a 9V AC-AC o 12v. El pin positivo debe ser de 2,5 mm (algunos son de 2,1)
    • Europa: 240 V a 9 V o 12 V CA-CA al menos 500 mA
  • ESP32 (elija uno):
    • NodoMCU 32s
    • Espressif DevKitC
    • DevKitC-32U si necesita una mejor recepción wifi (no olvide la antena )
    • Cualquier otra cosa con los mismos pines que el anterior, que generalmente son 19 pines por lado con 3v3 en la parte superior izquierda y CLK en la parte inferior derecha
  • Software (elija uno):
Diagrama posterior del medidor de energía ESP32 de 6 canales expandible

Conectando el ESP32

El medidor de energía ESP32 de 6 canales expandible está hecho para que una placa de desarrollo ESP32 se pueda conectar directamente al medidor. Consulte la lista anterior para conocer las placas de desarrollo ESP32 compatibles. Siempre inserte el ESP32 con el pin 3V3 en la parte superior izquierda del medidor . Los pines inferiores se utilizan para conectar la señal de voltaje (del enchufe de alimentación) a las placas adicionales. Si el ESP32 se inserta en los pines inferiores, lo más probable es que haga un cortocircuito en el ESP32.

El medidor de energía ESP32 de 6 canales expandible utiliza SPI para comunicarse con el ESP32. Cada placa utiliza 2 pines CS.

La placa principal utiliza los siguientes pines SPI:

  • CLK – 18
  • miso – 19
  • MOSI – 23
  • CS1 – 5 (CT1-CT3 y voltaje 1)
  • CS2 – 4 (CT4-CT6 y voltaje 2)

El software EmonESP/EmonCMS

EmonESP se usa para enviar datos de medidores de energía a una instalación local de EmonCMS o emoncms.org . Los datos también se pueden enviar a un corredor MQTT a través de esto. EmonCMS tiene aplicaciones para Android e IOS. El software ESP32 para EmonESP se encuentra aquí , y se puede flashear a un ESP32 usando Arduino IDE o PlatformIO 

ESPHome/Asistente de hogar

ESPHome se puede cargar en un ESP32 para integrar sin problemas los datos de energía en Home Assistant . Los datos de energía se pueden guardar en InfluxDB y mostrar con Grafana. Al mismo tiempo, los datos de energía también se pueden usar para automatizaciones en Home Assistant.

Una nueva característica en Home Assistant le permite monitorear el uso de electricidad directamente en Home Assistant . ¡También puede rastrear el uso de dispositivos individuales y/o energía solar usando el medidor de 6 canales!

Intermitente ESPHome
  • Si tiene Home Assistant instalado, vaya a Supervisor en el menú de la izquierda, haga clic en Tienda de complementos en la parte superior, busque ESPHome – Haga clic en Instalar
  • Haga clic en Abrir interfaz de usuario web
Complemento ESPHome
  • Haga clic en el círculo verde + en la parte inferior derecha para agregar un nuevo nodo
  • Complete el nombre (por ejemplo, ‘energy_meter’ y el tipo de dispositivo como NodeMCU-32S o Generic ESP32
  • Agregue los detalles de su wifi y haga clic en Enviar para crear el nodo
  • ESPHome se compilará; cuando esté completo, haga clic en Descargar binario
ESPHome Descargar Binario
  • Descargue la herramienta intermitente ESPHome para su sistema operativo aquí
  • Conecte el ESP32 que pretende usar con su medidor a su computadora a través de USB (no es necesario que esté conectado al medidor en este punto, pero si lo está, no conecte el transformador de CA todavía para el medidor al mismo tiempo). vez que el ESP32 está conectado al USB)
  • En la luz intermitente de ESPHome, seleccione el puerto COM al que está conectado el ESP32
  • Seleccione el archivo .bin que acaba de descargar y haga clic en Flash ESP (si no se conecta, haga clic en ver registros para ver qué está pasando; probablemente tendrá que mantener presionado el botón de arranque derecho en el ESP32 después de hacer clic en Flash ESP)
  • ESPHome se cargará en el ESP32 con una configuración básica
ESPInicio Flasher
  • Suponiendo que el ESP32 esté lo suficientemente cerca del AP al que desea conectarse para WiFi, ahora debería estar disponible en ESPHome dentro de Home Assistant
  • En Home Assistant, vaya a Configuración > Integraciones y Configure para ESPHome. Debe estar resaltado como Descubierto
Cargando la configuración del medidor de energía
  • Elija una configuración de ejemplo que mejor se adapte a la configuración de su medidor de energía aquí en el sitio de ESPHome , y aquí para algunas configuraciones más avanzadas
  • En la interfaz de usuario web de Home Assistant/ESPHome, haga clic en Editar para el nodo Medidor de energía
  • Copie/pegue la configuración de ejemplo, cambie cualquier configuración aplicable, como las calibraciones actuales a los transformadores de corriente que utiliza, y haga clic en Guardar
edición de configuración de yaml
  • En este punto, es una buena idea cerrar el cuadro de diálogo de edición y hacer clic en Validar en la pantalla principal para asegurarse de que su archivo .yaml sea válido. Corrige los errores que puedan surgir.
  • Haga clic en Cargar para guardar su configuración en el ESP32. Tenga en cuenta que si tiene 4 o más placas adicionales, puede recibir un error y quedarse sin memoria en su ESP32 si tiene muchos sensores. 
nodo ESPHome
  • Para una mayor precisión, puede calibrar los sensores de corriente. 
  • Al actualizar los valores de los transformadores de corriente en la configuración de ESPHome, haga clic en Editar y luego en Cargar

Obtener datos en InfluxDB

  • Si aún no lo ha hecho, instale el complemento InfluxDB en Home Assistant a través de Supervisor > Tienda de complementos
  • Abra la interfaz de usuario web y haga clic en la pestaña Administrador de InfluxDB , agregue un asistente de base de datos
  • Haga clic en la pestaña Usuarios (en Bases de datos en la misma pantalla) y cree un nuevo usuario homeassistant con Todos los permisos
  • Edite su configuración .yaml y agregue los parámetros de InfluxDB enumerados en Supervisor > InfluxDB > Documentación (menú superior) > Integración en Home Assistant
  • Reiniciar Asistente de inicio
  • Los datos ahora deberían estar disponibles en Home Assistant y disponibles en http://homeassistant.local:8086 o la IP de Home Assistant

Obtener datos en el panel de energía de Home Assistant

Configuración de energía de Home Assistant

Para mostrar datos en el panel de energía de Home Assistant, debe usar ESPHome v1.20.4 o superior, y tener al menos una total_daily_energyplataforma configurada en su configuración de ESPHome. timetambién se necesita.

Para consumo total de energía
#Total kWh
  - platform: total_daily_energy
    name: ${disp_name} Total kWh
    power_id: totalWatts
    filters:
      - multiply: 0.001
    unit_of_measurement: kWh
time:
  - platform: sntp
    id: sntp_time 

¿Dónde totalWattsestá la suma de todos los cálculos de vatios en el medidor? Vea un ejemplo de esto aquí. En el ejemplo, esto se hizo con una plantilla lambda .

para paneles solares

Se puede hacer lo mismo que arriba para rastrear el uso y la exportación de paneles solares. Los canales actuales en el medidor que rastrean el uso solar deben tener su propio cálculo de plantilla lambda.

Vea este ejemplo para saber cómo puede configurar esto con el medidor de 6 canales.

Para dispositivo individual/seguimiento de circuito

Para hacer esto, debe tener la potencia calculada por el medidor, o una plantilla lambda que calcula los vatios por circuito. Luego puede usar una plataforma de kWh para cada uno de los canales actuales en el medidor de energía de 6 canales. Por ejemplo:

#CT1 kWh
  - platform: total_daily_energy
    name: ${disp_name} CT1 Watts Daily
    power_id: ct1Watts
    filters:
      - multiply: 0.001
    unit_of_measurement: kWh

ct1Wattshace referencia a la identificación del cálculo de vatios. En la configuración de ejemplo , esto es:

      power:
        name: ${disp_name} CT1 Watts
        id: ct1Watts
Configuración en Home Assistant
  • Vaya a Configuración > Energía
  • Para la energía total, haga clic en Agregar consumo en Red eléctrica
  • El nombre de la plataforma total_daily_energy, como 6C Total kWh, debería estar disponible para elegir
  • También puede establecer un costo estático por kWh o elegir una entidad que rastree el costo de su electricidad
  • Para Dispositivos individuales, elija el nombre de los circuitos individuales, como 6C CT1 Watts Daily
  • Si monitorea sus paneles solares con un medidor de 6 canales, también puede configurar esto aquí, pero no se registrará a menos que su casa consuma energía o fluya hacia la red.

Preguntas más frecuentes

 Obtengo una lectura baja o nada en absoluto para un CT. ¿Qué sucede? : A veces, el conector para el CT es un poco rígido y es posible que deba empujar el conector del CT en el conector de la placa hasta que haga clic. Si definitivamente está completamente adentro, es posible que el conector o algún otro lugar tenga una conexión suelta, y reemplazaremos el medidor de forma gratuita.

¿Funciona el medidor de energía de 6 canales en mi país?: ¡Sí! Hay una configuración para configurar el medidor a 50 Hz o 60 Hz de potencia. Deberá comprar un transformador de CA que reduzca el voltaje a entre 9 y 12 V CA. Los transformadores para EE. UU. están a la venta en la tienda circuitsetup.us.

 Obtengo un valor negativo en un canal actual. ¿Qué está pasando? Esto generalmente significa que el CT está en la parte posterior del cable, ¡simplemente gírelo!

 Obtengo un pequeño valor negativo cuando no hay ninguna carga, pero de lo contrario obtengo un valor positivo. ¿Qué está pasando?: Esto se debe a variaciones en las resistencias y los transformadores de corriente. Puede calibrar los transformadores de corriente al medidor o agregar esta sección lambda para permitir solo valores positivos para un canal de corriente:

  - platform: template
    name: ${disp_name} CT1 Watts Positive
    id: ct1WattsPositive
    lambda: |-
      if (id(ct1Watts).state < 0) {
        return 0;
      } else {
        return id(ct1Watts).state ;
      }
    accuracy_decimals: 2
    unit_of_measurement: W
    icon: "mdi:flash-circle"
    update_interval: ${update_time}

Luego, para su cálculo de vatios totales, use ct1WattsPositive

 Los cables del CT no son lo suficientemente largos. ¿Puedo extenderlos? ¡Sí, absolutamente puedes! Se puede usar algo como una extensión de auriculares o incluso un cable de ethernet (si no le importa hacer algo de cableado). Se recomienda calibrar los TC después de añadir cualquier extensión particularmente larga.

 ¿Puedo usar este CT con el medidor de 6 canales?: ¡Lo más probable es que sí! Siempre que la salida tenga una potencia nominal inferior a 720 mV RMS o 33 mA.

 ¿Puedo usar CT SCT-024 200A con el medidor de 6 canales?: Si necesita medir hasta 200 A, no se recomienda. A 200A, el SCT-024 emitirá 100mA. Eso significa que el máximo que debe medir con el SCT-024 conectado al medidor de 6 canales es 66A . En un entorno residencial con un servicio de 200 A, es muy poco probable que utilice más de 66 A por fase sostenida. De hecho, a menos que tenga su propio transformador dedicado y una casa muy grande, es imposible.

 ¿Cómo sé si mi CT tiene una resistencia de carga?: Hay una resistencia de carga incorporada si la salida está clasificada en voltios. En este caso, se debe cortar el puente correspondiente en la parte posterior del medidor.

Cuando se usan más de 3 tableros complementarios, ESPHome no funciona. ESPHome se quedará sin memoria de pila después de usar más de 15 sensores, más o menos. Deberá aumentar el tamaño de la memoria de pila antes de compilar. Ver detalles aquí.

ACTUALIZACIÓN: Puede reemplazar la definición esphome: en su configuración de ESPHome para resolver este problema con lo siguiente:

esphome:
  name: 6chan_energy_meter
  platformio_options:
    build_flags: 
      - -DCONFIG_ARDUINO_LOOP_STACK_SIZE=32768

esp32:
  board: nodemcu-32s
  variant: esp32
  framework:
    type: arduino
    version: 2.0.2
    source: https://github.com/espressif/arduino-esp32.git#2.0.2
    platform_version: https://github.com/platformio/platform-espressif32.git#feature/arduino-upstream

Fuente: https://github.com/CircuitSetup/Expandable-6-Channel-ESP32-Energy-Meter