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/

Midiendo nuestro consumo eléctrico con una Raspberry Pi


Con la crisis actual energètica se hace imprescindible optimizar nuestro consumo de la forma más precisa posible, y desde luego no se puede monitorizar nada que no se pueda medir. Además es interesante saber que muchos analistas opinan que se puede llegar a reducir desde un 15% en adelante nuestro consumo global, así que lo primero es obtener el hardware necesario para monitorizar nuestro consumo.

¿Y qué necesitamos para monitorizar dando un toque de domótica a nuestro Hogar? Quizás lo más económico sea poner un pequeño HAT a la Raspberry del fabricante LeChacal (por cierto con domicilio en Edimburgo), pues cuenta con diferentes escudos que cumplirán cualesquiera sean nuestras necesidades, ya que a ellos podremos conectarles desde 1 sensor no intrusivo hasta 8, dependiendo del HAT que queramos cuanto más sensores acepte dicho escudo mayor será su coste (pero adelantamos que el precio es más que asumible). Además este fabricante no ofrece la posibilidad de apilar de modo que si queremos meter más sensores no intrusivos, montamos tantas HAT como necesitemos una sobre otra! Así que recomendamos repasar esta lista de sensores para que cada cual escoja el que más le interese: http://lechacal.com/wiki/index.php/Main_Page siendo el más barato apto para 3 sensores y cuesta unas 12 librashttp://lechacal.com/wiki/index.php/RPICT7V1_v2.0 y luego ya sería adquirir tantos sensores no intrusivos como necesitemos ( SCT-013-000). Los tenemos en la misma web o en Amazon o eBay por unos 4€ cada uno.

El hardware

La serie RPICT es una gama de escudo (o también llamados sombreros ) 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 (ATtiny84 o Atmega328) opera la placa. El código fuente del microcontrolador está disponible gratuitamente.

Como veremos hay varias opciones para registrar y ver los datos. Los más utilizados son Emoncms e Influxdb con Grafana. También es posible usar su propio script de Python. Algunas de las aplicaciones de este hw: Medidor inteligente Raspberrypi, Internet de las Cosas, Registro de datos, Monitoreo en tiempo real, Automatización del hogar, Rpi,

Los escudos disponibles son:

  • RPICT3T1 – 3 CT 1 Temperatura.
  • RPICT3V1 – 3 CT 1 Voltaje CA.
  • RPICT4T4 – 4 CT 4 Temperatura.

Placas apilables Raspberrypi V 2 y 3

  • RPICT4V3 versión 2 y 3 – 4 CT 3 Voltaje CA.
  • PICT7V1 Versión 4
  • RPICT7V1 Versión 5
  • RPICT4V3 Versión 5
  • RPICT8 Versión 5
  • RPICT4T4 Versión 5
  • RPICT4W3T1

Solo temperatura : RPI_T8 – 8 temperaturas.
Raspberrypi para TC de salida 5A

  • RPI LCT3V1 – 3CT 1 Tensión para TC grandes.
  • RPI LCT4V3 – 3CT 3 Voltaje para TC grandes.
  • RPI_LCT8 – 8CT para CT grandes.

Raspberry pi cero

  • RPIZ_CT3V1 – 3 CT 1 Voltaje CA. Raspberrypi Cero.
  • RPIZ_CT3T1 – 3 CT 1 Temperatura. Raspberrypi Cero.
  • RPIZCT4V3T2 – Rpi Cero 4 CT 3 Voltaje CA 2 Temperatura (RTD y DS18B20)

con relés

  • RPICT3T1_RLY2 – 3 TI 1 Temperatura 2 Relés
  • RPICT3V1_RLY2 – 3 CT 1 Voltaje CA 2 Relés

Este es el resumen del hw disponible por este fabricante:

Model#CT#Volt*#TempStackable
RPICT3T131No
RPICT3V131No
RPICT4T444No
RPICT4V3_v2.043Yes
RPICT7V1_v2.071Yes
RPICT88Yes
RPIZCT4V3T1431n/a
RPI_T88Slave 1 only
RPI_LCT4V343One board stack only
RPI_LCT88One board stack only

Uso por primera vez

Inserte la placa RPICT en Raspberrypi GPIO como se muestra arriba. La imagen es una RPI3B pero todas las demás Raspberrypi también son compatibles (las placas RPICT obtienen energía de Raspberrypi). Simplemente conecte el adaptador de corriente USB a la Raspberrypi como de costumbre.

Estas placas se venden lista para funcionar con el firmware y la configuración ya cargados. Asegúrese de probar todos los sensores con el comando cat antes de cambiar la configuración.

Primera configuración RPICT

Cualquier sensor de corriente con salida de corriente es compatible. Tenga en cuenta que hay consideraciones para la resistencia de carga que escala el rango de corriente medida. Estos son algunos de los sensores recomendados con conector de 3,5 mm que podemos usar según la corriente que vaya a circular por el circuito a medir:

  • SCT-013-000 100A/50mA
  • SCT-019 200A/33mA
  • SCT-006 20A/25mA
  • SCT-024 400A/100mA
  • SCT-031 600A/100mA

El rango está determinado por la resistencia de carga instalada en la unidad RPICT. En el momento de la compra, esto se selecciona utilizando la calificación del parámetro en la tienda. El rango predeterminado es de 100 A en todas las series RPICT, lo que corresponde a una resistencia de carga de 24 o 27 ohmios. Se pueden seleccionar otras clasificaciones (o rangos) en el momento de la compra.

En los enlaces a continuación se proporcionan más detalles sobre el rango de entrada y la resistencia de carga:

  • Para RPICT3T1 RPICT3V1 RPICT4T4v2.5 y RPICT8/RPICT7V1/RPICT4V3 en versión 3

Gen3 Passive Component Setup

  • Para RPICT7V1 RPICT8 and RPICT4V3 en versión 4

Gen4 Passive Component Setup

  • Para RPICT7V1 RPICT8 RPICT4V3 en version 5

Gen5 Passive Component Setup

Los sensores CT solo miden corrientes alternas (CA). Consulte el sensor ACS715 para la corriente CC.

Solo RPICT7V1 versión 4 y RPI_DCV8 pueden admitir CT de salida de voltaje. SCT-013-xxx que no sea SCT-013-000 y cualquier CT de salida de voltaje no son compatibles con todas las demás placas .

Sensor de voltaje
Para evaluar la potencia de una instalación no es estrictamente necesario un sensor de tensión. La potencia se puede estimar utilizando un voltaje fijo estimado (generalmente 240 o 110 V). El sensor de voltaje se vuelve necesario si desea medir con mayor precisión la potencia real, la potencia aparente y el factor de potencia. La combinación de un sensor de voltaje con un sensor CT también proporcionará la dirección de la energía (importación/exportación).

En cualquier caso, las lecturas de potencia con sensor de voltaje son más precisas y consistentes. También tienen mucho menos ruido y son mejores para lecturas de baja potencia.

La serie RPICT se envía con una calibración básica para el puerto de voltaje. Sería necesaria una calibración si cree que el voltaje medido no es lo suficientemente preciso en comparación con otro dispositivo de medición confiable (alcance, multímetro).

Sensor de voltaje CA/CA
Ofrecen un conjunto de transformadores AC/AC para medir voltaje. Estas unidades se pueden enchufar fácilmente en un enchufe de pared principal. No se requiere cableado.

Los tres modelos diferentes que recomiendan son:

Sensor ZMPT

Módulo ZMPT101B :El módulo ZMPT101B es un módulo de tensión para cablear. Mide voltajes hasta 250V y se puede montar en carriles DIN.

No utilice estos módulos ZMPT vendidos en el mercado. No escalan contra las unidades RPICT y la presencia de un potenciómetro los hace poco confiables.

Sensor de temperatura
El sensor de temperatura que se usa s el DS18B20.Los sensores de temperatura vienen con varios conectores:

  • Molex de 3 pines :Esto aplica para la placa RPIZCT4V3T1 y RPIZCT4V3T2.
  • Cables desnudos: Esto aplica para las placas RPICT3T1 RPICT4T4 y RPIZ_CT3T1. Los conectores son terminales de tornillo. La sonda de temperatura debe presentar cables desnudos para la conexión.

Fuente de alimentación
El raspberrypi debe usar la fuente de alimentación micro-usb habitual. La serie RPICT no necesita ninguna fuente de alimentación adicional. La energía para el RPICT se toma del Raspberrypi GPIO.

PUESTA EN MARCHA

Conectaremos pues el HAT a la Raspberry Pi y los sensores que tengamos; en las pinzas de los sensores tendremos en cuenta de pasar únicamente un cable, eh! Y nada, con eso podremos saber el consumo en Vatios (W) que hace cada ‘cosa’ que tengamos pinzada. Podremos medir de cualquier aparato eléctrico, así como lo dicho, poner esto en el cuadro eléctrico de casa y medir los consumos desde ahí, si lo tenemos bien etiquetado, no nos costará medir el consumo General o el del Alumbrado, consumos de los enchufes, de la nevera, horno, lavadora, etc.

En el uso más básico, la serie RPICT solo genera una cadena en serie. Depende del usuario recopilar esta cadena de datos y registrar/ver según sea necesario. Hay varias formas de lograr esto.

  • Usando el comando cat.
  • Usando Influxdb y Grafana.
  • Usando una solicitud Json.
  • Usando la herramienta Emonhub de Emoncms.
  • Usando un script de Python.

Nota: Este es el uso más básico. Recomendamos encarecidamente hacer uso de esto primero antes que cualquier otra cosa.

De antemano , asegúrese de haber seguido esta guía si está utilizando la imagen de Rasbian.
Usemos el RPICT3T1 como ejemplo. El formato de la salida es como se muestra a continuación. Potencias en W. Temperatura en grados Celsius. Para cualquier otra unidad RPICT, consulte su página específica para conocer el formato de salida predeterminado.

nodeid power1 power2 power3 temperature

Inicie sesión en Raspberrypi usando ssh y emita los comandos

stty -echo -F /dev/ttyAMA0 raw speed 38400
cat /dev/ttyAMA0

El terminal debería mostrar algo como esto a continuación

[email protected] ~ $ cat /dev/ttyAMA0
11 46.23 52.25 126.56 19.46
11 47.43 52.28 129.60 19.54
11 48.90 53.88 131.22 19.89


Para averiguar qué canal corresponde a qué valor medido, consulte la página dedicada a la placa específica.

Nota. Si usa la imagen emonpi, ejecute el siguiente comando antes del comando stty.

sudo /etc/init.d/emonhub stop

Con este comando podremos conectarnos por serie al HAT y ver qué escupe. Verá que dependiendo del HAT que haya adquirido podrà ver la corriente, el voltaje o la temperatura, que es lo que os escupirá este comando separado en comas.

1stty -F /dev/ttyAMA0 raw speed 38400
cat /dev/ttyAMA0

Ahora, lo que haremos será tratar esa salida en formato CSV. En el ejemplo de Hector devuelve la potencia de 7 sensores no intrusivos, cada uno de ellos conectado a un cable del cuadro de distribucion de ca (General, Enchufes de unas estufas, el Lavavajillas y la Lavadora, el Alumbrado, el Horno y la Vitrocerámica y enchufes)

Después podemos exportar dicha información a una tabla que hemos creado previamente en MySQL de modo quenecesitaremos tener MySQL instalado en alguna máquina (o lo instalamos en la propia Pi) y crearemos ahí la BD y la Tabla que queramos.

Por deferencia de Héctor (del blog bujarra.com) , él nos muestra un ejemplo de las sentencias SQL para ejecutar desde la consola de Mysql para crear dicha tabla que tiene una columna por cada sensor:

CREATE TABLE `corriente` (
`general` FLOAT NULL DEFAULT NULL,
`estufas` FLOAT NULL DEFAULT NULL,
`lavavajillas_lavadora` FLOAT NULL DEFAULT NULL,
`alumbrado` FLOAT NULL DEFAULT NULL,
`horno_vitro` FLOAT NULL DEFAULT NULL,
`enchufes` FLOAT NULL DEFAULT NULL,
`fecha` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
)
COLLATE='latin1_swedish_ci'
ENGINE=InnoDB
;
 

Y nada, ya sólo nos queda tener este maravilloso script en python que nos va a ir llenando la Tabla ‘corriente’ de nuestra Base de datos!

Creamos dicho script corriente.py:

#!/usr/bin/python
import serial
import urllib
import json
import MySQLdb
 
ser = serial.Serial('/dev/ttyAMA0', 38400)
 
response = ser.readline()
z = response.split(",")
if len(z)>=7:
 print "General: %s Watts" % z[0]
 print "Estufas: %s Watts" % z[1]
 print "Lavavajillas y Lavadora: %s Watts" % z[2]
 print "Alumbrado: %s Watts" % z[3]
 print "Horno y vitro: %s Watts" % z[4]
 print "Enchufes: %s Watts" % z[5]
 
general_valor=z[0]
estufas_valor=z[1]
lavavajillas_lavadora_valor=z[2]
alumbrado_valor=z[3]
horno_vitro_valor=z[4]
enchufes_valor=z[5]
 
db = MySQLdb.connect("localhost","root","xxxxxx","NOMBRE_BASE_DATOS")
cursor = db.cursor()
 
cursor.execute("""INSERT INTO corriente (general,estufas,lavavajillas_lavadora,alumbrado,horno_vitro,enchufes) VALUES (%s,%s,%s,%s,%s,%s) """, (general_valor,estufas_valor,lavavajillas_lavadora_valor,alumbrado_valor,horno_vitro_valor,enchufes_valor))
db.commit()

Y listo! Lo que nos queda es programar que se ejecute este script con el intervalo que nos interese, ejecutamos ‘crontab -e‘ y añadimos lo siguiente para que se ejecute por ejemplo cada minuto:

1* * * * * python /home/pi/corriente.py

¿Que sería lo perfecto para acabar? Pues lo de siempre, gracias a Grafana, podremos de una manera super sencilla y rápida trabajar cualquier dato, como en este ejemplo una tabla de MySQL.

Aqui algunos ejemplos:

Gráfica donde añadimos la metrica y nos la pinte, en este caso el consumo de los enchufes:

1SELECT enchufes as value, "Enchufes" as metric, UNIX_TIMESTAMP(fecha) as time_sec FROM corriente  WHERE $__timeFilter(fecha) order by time_sec asc

Gráfica donde añadimos la métrica del consumo del Alumbrado:

1SELECT alumbrado as value, "Alumbrado" as metric, UNIX_TIMESTAMP(fecha) as time_sec FROM corriente  WHERE $__timeFilter(fecha) order by time_sec asc

Con el plugin Singlestat podremos mostrar por ejemplo el gasto actual de la General:

1SELECT general FROM corriente order by fecha desc limit 1