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.

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/