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/

Adquisición de datos de tensión y corriente con RPICT7V1


Con la crisis actual energètica se hace imprescindible optimizar nuestro consumo de la forma más precisa posible, porque se puede llegar a reducir desde un 15% en adelante nuestro consumo global. Para hacer esto posible quizás lo más económico sea poner un pequeño HAT a la Raspberry del fabricante LeChacal del que ya hemos hablado eneste blog, pues cuenta con diferentes escudos con a posibilidad de apilar estos de modo que si queremos meter más de 8 sensores no intrusivos, montamos tantas placas como necesitemos una sobre otra!


La serie RPICT es una gama de escudo para la Raspberrypi como sensor de corriente CA (CT) y de temperatura. Todas las placas RPICT se conectan al conector GPIO y proporcionan datos a través del puerto serie . Un microcontrolador programable Arduino ( Atmega328 en el caso de la placa con 8 entradas) opera la placa. Es interesante destacar que el código fuente del microcontrolador está disponible gratuitamente.

Como hemos visto en este blogs hay varias opciones para registrar y ver los datos siendo los más utilizados Emoncms e Influxdb con Grafana aunque también es posible usar su propio script de Python. En este post vamos a ver un complemento RPICT7V1 que le permite recuperar las medidas de su tarjeta de la serie RPICT instalada como HAT en su Raspberry PI y mostrarlas en Jeedom.

Para recuperar la información de su tarjeta de la serie RPICT, primero debe conectar esta placa la a su Raspberry PI:

rpict7v1

Consulte la documentación completa aquí Adaptador de sensor de temperatura y corriente de Raspberrypi

RPICT7V1_v2.0

Compatibilidad

Versión¿Compatible?
Raspberrypi 1ANo
Raspberry pi 1 B+
Raspberry pi 2b
Raspberry pi 3B
Raspberry pi 3 B+
Raspberry pi 4B

Sensores recomendados

  • Sensor de corriente CA:
    • SCT-013-000
    • TBS-019
    • TBS-006
  • Sensor de voltaje CA:
    • Reino Unido: 77DB-06-09
    • UE: 77DE-06-09
    • EE. UU.: 77DA-10-09

LOS CT DE SALIDA DE VOLTAJE NO SON COMPATIBLES CON ESTA TARJETA.

sensores

Apilamiento de tarjetas RPICT en HAT en Raspberry PI

Las placas RPICT7V1 versión 2 se pueden apilar con otras placas RPICT7V1 o RPICT4V3 o RPICT8 para ampliar la cantidad de sensores admitidos. Atención, en el sitio web del fabricante, todas las unidades vendidas están preconfiguradas como MASTER. Consulte la wiki del fabricante para ver cómo configurarlos como esclavos. ApilamientoDocumentación

apilamiento1
apilamiento2

Configurando la tarjeta RPICT en su Raspberry

Su Raspberry se comunica con la tarjeta RPICT a través del puerto serie. Entonces, debe configurar Rapsberry para que funcione este puerto serie.Ver documentación completa del fabricante AQUÍ

Habilitar puerto serie

  • Ejecute la herramienta raspi-config,$ sudo raspi-config
  • Luego deshabilite el inicio de sesión de uart:5 Interfacing Options / P6 Serial
    • Seleccione No a la pregunta del shell de inicio de sesión.
    • Seleccione Sí a la pregunta de hardware del puerto serie que se habilitará.
    • Seleccione Ok en el resumen.
  • De vuelta en el menú, seleccione Finalizar.
    • Seleccione No a la pregunta de reinicio (lo haremos más adelante).

Configuración general de Raspberry

  • Edite el archivo /boot/config.txt$ sudo nano /boot/config.txt
  • Al final del archivo, agreguedtoverlay=pi3-disable-bt
  • Desactivar hciuartsudo systemctl disable hciuart
  • (!) OPCIONAL, Los dos comandos siguientes desactivan el bluetooth del RPI. Si se usa BT, omita este paso y use ttyS0 en lugar de ttyAMA0 en los siguientes pasos.
  • Reinicie la Raspberry Pi sudo reboot

Prueba de funcionalidad

Una vez que se inserta la tarjeta RPICT y se reinicia la Rpi, se puede hacer una prueba en la línea de comando para verificar que todo esté bien. Tienes que configurar el puerto y empezar a escuchar.

stty -F /dev/ttyAMA0 raw speed 38400

cat /dev/ttyAMA0

Instalación del complemento Jeedom

Instalaciones

Instale el complemento del mercado siguiendo las instrucciones: https://github.com/jeedom/documentation/blob/master/premiers-pas/es_ES/index.md

Configuración

Después de activar el complemento, debe elegir el puerto del módem:

rpict_configuration

Dependiendo de si ha dejado el Bluetooth activado o no (ver arriba), el puerto a utilizar puede ser uno de los dos siguientes:

  • /dev/ttyS0
  • /dev/ttyAMA0

Finalmente recuerda guardar.

Un nuevo protocolo está disponible en Complementos => Protocolo domótico => RPICT7V1

Configuración

El complemento ofrece la posibilidad de crear automáticamente pedidos recibidos. Para hacer esto, inicie el demonio, espere a que lleguen los primeros marcos, luego vaya a Complemento / Protocolos domóticos / RPICTV7.

Debes crear el objeto, darle un nombre y llegas a la página de configuración de la tarjeta RPICT.

Debe introducir el ID de nodo de la tarjeta RPICT (previamente programada al valor 11 al salir de fábrica). Seleccione «Creación automática de pedidos» en la parte superior derecha, finalmente guarde.

A partir de este momento se añadirán automáticamente todos los pedidos recibidos y no reconocidos.

objeto_pict
rpict_auto_commands

También puede crear pedidos manualmente:

  • Cree su nuevo dispositivo haciendo clic en Agregar
  • Añade los pedidos que quieras recuperar haciendo clic en el botón verde “Pedir”
  • Complete el nombre que se muestra en Jeedom, el Subtipo de acuerdo con la información que se recuperará, el canal en cuestión de la tarjeta y, finalmente, los parámetros asociados.
  • Clic en Guardar.

Las órdenes

Los comandos (Add data) corresponden a los datos enviados por la tarjeta RPICT.

El número de canales depende de la tarjeta de la serie RPICT que tenga.

El plugin gestiona un máximo de 15 canales.

Salud

Es posible verificar la recepción de los datos antes de su procesamiento.

Para hacer esto, vaya al objeto RPICT y luego haga clic en Salud

rpict_btsante

La ventana que se abre le permite verificar la correcta recepción de datos por NodeID para cada canal:

rpict_stante

API

El complemento RPICT proporciona una API para actualizar datos de otros sistemas. Esta es una URL de llamada de tipo GET. Para acceder a esta información se requiere:

URL=http://#IP_JEEDOM#:#PORT_JEEDOM#/jeedom/plugins/rpict/core/php/jeeRpict.php?api=#YOUR_API_JEEDOM#&nid=#NODE_ID_RPICT#

#IP_JEEDOM# corresponde a la dirección IP de su Jeedom #PORT_JEEDOM# corresponde al puerto de acceso a su Jeedom #YOUR_API_JEEDOM# es la clave API disponible en el menú General / Administración / Configuración

rpict_api

#NODE_ID_RPICT# corresponde al NodeID de la tarjeta RPICT. Esta información es necesariamente transmitida por la tarjeta RPICT cuando recibe una trama.

Tenga en cuenta que /jeedom puede ser diferente si está en una instalación de bricolaje u OEM. Por lo general, tienes que agregarlo.

A esta url de llamada se le pueden agregar los diferentes valores según el formato: &#NAME_DE_LA_VALEUR#=#VALEUR#

Por ejemplo para el canal 1 equivalente a 123456789:

&ch1=123456789

Por lo tanto, la URL se sobrecargará con toda la información útil.

Por ejemplo :

IP_JEEDOM : 192.168.1.15
PORT_JEEDOM : 80
VOTRE_API_JEEDOM : zertyuiolkjhgfdsxc
NODE_ID_RPICT : 11
Channel1 : 123456789

Dará URL : http://192.168.1.15:80/jeedom/plugins/rpict/core/php/jeeRpict.php?api=zertyuiolkjhgfdsxc&nid=11&ch1=123456789

Mas información en https://tlierdotfr.github.io/jeedom-plugin-rpict/fr_FR/

Medidas sincronizadas mediante un GPS


Un equipo del Instituto de Automatización de Sistemas Eléctricos Complejos (ACS) de la Universidad RWTH de Aquisgrán lleva un tiempo trabajando en el análisis de sistemas eléctricos ampliamente distribuidos. En su afán por alejarse de las plataformas electrónicas altamente especializadas (y costosas), han producido una instrumentación diseñada para funcionar con la plataforma Raspberry Pi y una pila de software de código abierto. La plataforma se llama SMU (Unidad de Medición Sincronizada) y consiste en un HAT situado en una RPi3, dentro de una caja impresa en 3D que está pensada para fijarse a un carril DIN (al fin y al cabo, se supone que es una plataforma industrial) .

Por supuesto el proyecto es abierto , tanto es asi que incluso está disponible los ficheros para imprimir en 3d la caja en https://git.rwth-aachen.de/acs/public/automation/smu

La tendencia al alza de los ordenadores de placa única (SBC), baratos y de alto rendimiento, ofrece cada vez más oportunidades sin precedentes en diversos ámbitos, aprovechando el amplio soporte y la flexibilidad que ofrece un entorno de sistema operativo (SO). Lamentablemente, los sistemas de adquisición de datos implementados en un entorno de SO se consideran tradicionalmente no adecuados para aplicaciones industriales fiables. Esta posición se apoya en la falta de manejo de interrupciones por hardware y de control determinista de las operaciones temporizadas. En este trabajo los autores llenan este vacío proponiendo una innovadora y versátil plataforma de código abierto basada en SBC para la adquisición de datos independiente de la CPU. La unidad de medida sincronizada (SMU) es un dispositivo de alta precisión capaz de realizar un muestreo simultáneo multicanal de hasta 200 kS/s con una precisión de sincronización de sub-microsegundos con una referencia de tiempo GPS. Presenta errores de offset y ganancia muy bajos, con un ancho de banda mínimo superior a 20 kHz, niveles de SNR superiores a 90 dB y THD tan bajos como -110 dB. Estas características hacen que la SMU sea especialmente atractiva para el ámbito de los sistemas de energía, en el que cada vez se requieren más mediciones sincronizadas para la supervisión geográficamente distribuida de las condiciones de funcionamiento de la red y los fenómenos de calidad de la energía. Presentamos la caracterización de la SMU en términos de precisión de las medidas y de la sincronización temporal, demostrando que este dispositivo, a pesar de su bajo coste, garantiza unas prestaciones que cumplen los requisitos de las aplicaciones basadas en sincrofasores en los sistemas de potencia.

En cuanto al hardware, la estrella del espectáculo es el ADS8588S de Texas Instruments, que es un ADC de 16 bits y 8 canales de muestreo simultáneo. Es un dispositivo bastante bueno, con un rendimiento de 200 kSPS y un frontal programable por canal, empaquetado en un QFP de 64 pines fácil de usar. Sin embargo, lo que hace que este proyecto sea interesante es cómo han resuelto el problema de controlar la adquisición de datos muestreados y la sincronización.

Programando el ADC en modo byte-paralelo y utilizando el bloque de interfaz de memoria secundaria (SMI) del BCM2837 junto con el DMA, las muestras se transfieren a la memoria con una sobrecarga mínima de la CPU. Un módulo GNSS U-Blox Max-M8 integrado proporciona una señal de 1PPS (pulso superior al segundo), que se combina con la señal de ocupación del ADC de forma muy sencilla, lo que permite tanto el control de la velocidad de muestreo como la sincronización entre múltiples unidades repartidas en una instalación. Calculan que pueden conseguir una sincronización con una precisión de 180 ns de la parte superior del segundo, lo que debería ser suficiente para medir sistemas de potencia que cambian con relativa lentitud. La placa de circuito impreso del HAT se creó en KiCAD y se puede encontrar en la sección de hardware de SMU GitHub, lo que hace que sea fácil de modificar según tus necesidades, o al menos ajustar el diseño para que coincida con las piezas que puedes conseguir.

En cuanto al software, la pila completa se proporciona desde el módulo del kernel que se ocupa de las cosas de bajo nivel, ofreciendo /dev/SMU, hasta el demonio de gestión y una interfaz gráfica de usuario basada en QT. Se puede encontrar una descripción completa del sistema en el artículo de acceso abierto asociado.