Primeros pasos con ESP32


El famoso fabricante aleman AZDelivery en efecto nos pone disponible el ESP32 ESP-WROOM-32 NodeMCU Modulo WiFi + Bluetooth Dev Kit C Placa de Desarrollo 2.4 GHz Dual Core con Chip CP2102 , lo cual para muchos expertos es el sucesor del ESP8266 a un precio muy parecido ( unos 10€ en Amazon)

Este módulo AZ-Delivery , desarrollado por la empresa Espressif tiene el potente Microcontrolador ESP32 instalado siendo por tanto ideal para prototipos rápidos ya que esta placa de desarrollo ESP32 permite la dinámica creación de prototipos con una sencilla programación a través de un script Lua o en la construcción compatible con Arduino-IDE y Breadboard. Integra funciones Wi-Fi y Bluetooth.

Destaca además el consumo ultra bajo de energía ideal para poderlo alimentarlo con baterías. Asimismo cuenta con chips Bluetooth Wi-Fi de modo dual de 2,4 GHz y TSMC, así como tecnología de bajo consumo de 40 nm.

Esta versión tiene 38 pines y ofrece más funciones que un módulo de 30 pines y es más pequeño y más conveniente de usar.

De igual manera que en el modelo predecesor ESP8266, la funcionalidad WLAN está implementada directamente en el SoC, pero con funcionalidad Bluetooth adicional (incl. BLE).


El procesador ESP32 es mucho más potente que el ESP8266 pues combina una CPU con 2 núcleos Tensilica LX6, con una frecuencia de hasta 240 MHz, y 512 Kilobytes de SRAM en un único chip microcontrolador. Además, integra una unidad de radio para WLAN (según 802.11bgn) y Bluetooth (Classic y LE) , esta conectividad que por cierto no posee el ESP8266.

La función WLAN soporta todos los métodos de encriptación habituales, como WPA2. También puede actuar en la WLAN como punto de acceso o Sniffer en modo pasivo.

A través de los 32 pines están disponibles, entre otros, UART, I2C, SPI, DAC, ADC (12 bits) y todos los pines GPIO pueden utilizarse como entrada o salida.

Información Técnica

Voltaje de alimentación5V
Voltaje de entrada / salida3.3V
Corriente de Funcionamientomin. 500mA
SoCESP32-WROOM 32
Frecuencia de Reloj80MHz / 240MHz
RAM512kB
Memoria Flash externa4MB
Pines I / O34
InterfacesSPI, I2C, I2S, CAN, UART
Protocolos Wi-Fi802.11 b/g/n (802.11n hasta 150 Mbps)
Frecuencia Wi-Fi2.4 GHz – 2.5 GHz
BluetoothV4.2 – BLE y Bluetooth clásico
Antena inalámbricaPCB
Dimensiones56x28x13mm


Hay un complemento para el IDE de Arduino que le permite programar el ESP32 utilizando el IDE de Arduino y su lenguaje de programación. En este post, le mostraremos cómo instalar la placa ESP32 en Arduino IDE, ya sea que esté usando Windows, Mac OS X o Linux..

Antes de comenzar este procedimiento de instalación, asegúrese de tener instalada la última versión del IDE de Arduino en su computadora. Si no lo hace, desinstálelo e instálelo de nuevo. De lo contrario, es posible que no funcione.

Con el último software Arduino IDE instalado desde arduino.cc/en/Main/Software , continúe con este post.

Para instalar la placa ESP32 en su Arduino IDE, siga las siguientes instrucciones:

  1. En tu IDE de Arduino, ve a Archivo > Preferencias Instalación del complemento ESP32 en Arduino IDE Preferencias abiertas de Windows, Mac OS X y Linux
  2. Ingrese lo siguiente en el campo «URL adicionales del administrador de la junta»:https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json .
  3. Luego, haga clic en el botón «Aceptar»:Instalación del complemento ESP32 en Arduino IDE Windows, Mac OS X, Linux ingrese las URLNota: si ya tiene la URL de los tableros ESP8266, puede separar las URL con una coma de la siguiente manera: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json, http://arduino.esp8266.com/stable/package_esp8266com_index.json
  4. Abra el Administrador de tableros. Vaya a Herramientas > Tablero > Administrador de tableros…Instalación del complemento ESP32 en Arduino IDE Windows, Mac OS X, administrador de tableros abiertos de Linux
  5. Busque ESP32 y presione el botón de instalación para » ESP32 by Espressif Systems «:Complemento ESP32 en Arduino IDE Windows, Mac OS X, Linux instalado
  6. Eso es todo. Debe instalarse después de unos segundos.

Prueba de la instalación

Conecte la placa ESP32 a su ordenador mediante un cable USB. Lo más sencillo seria probar a hacer parpadear el led interno , pero realmente si queremos probar la conectividad wifi es mejor probar esto con un codigo mas elaborado. Afortunadamente no tenemos que buscar mucho porque el propio IDE de Arduino incluye los ejemplos .

Con su Arduino IDE abierto, siga estos pasos:

1. Seleccione su placa en el   menú  Herramientas  >  Placa (en el ejemplo es un  DOIT ESP32 DEVKIT V1 pero si compra el AZDelivery ESP32 ESP-WROOM-32 NodeMCU Modulo WiFi + Bluetooth Dev Kit C Placa de Desarrollo 2.4 GHz Dual Core con Chip CP2102 deberemos poner ESP32Dev Module )

Arduino IDE seleccione la placa ESP32 en el menú Herramientas

2. Seleccione el puerto (si no ve el puerto COM en su IDE de Arduino, debe instalar los  controladores CP210x USB to UART Bridge VCP ):

Arduino IDE seleccione el puerto ESP32 en el menú Herramientas

3. Abra el siguiente ejemplo en Archivo > Ejemplos > WiFi (ESP32) > WiFiScan

Ejemplo de Arduino IDE open WiFiScan para ESP32

4. Se abre un nuevo boceto en su IDE de Arduino:

Arduino IDE cargando WiFiScan ejemplo a ESP32

5. Presione el  botón Cargar  en el IDE de Arduino. Espere unos segundos mientras el código se compila y carga en su placa.

6. Si todo salió como se esperaba, debería ver un mensaje » Terminó de cargar». » mensaje.

Arduino IDE terminó de cargar ESP32 WiFiScan sketch

7. Abra el monitor serie Arduino IDE a una velocidad de transmisión de 115200:

8. Presione el botón Habilitar integrado de ESP32   y debería ver las redes disponibles cerca de su ESP32:

Instalación del complemento de prueba ESP32 en PC con Windows, Max OS X y computadora con Linux

Solución de problemas más comunes

Si intenta cargar un nuevo boceto a su ESP32 y recibe este mensaje de error » Se produjo un error fatal: no se pudo conectar a ESP32: se agotó el tiempo de espera… Conectando… «. Significa que su ESP32 no está en modo de carga/parpadeo.

Con el nombre de la placa y el puerto COM seleccionados, siga estos pasos:

  • Mantenga presionado el botón » BOOT » en su tablero ESP32
Resuelto Ocurrió un error fatal: No se pudo conectar a ESP32: Se agotó el tiempo de espera... Conectando...
  • Presione el botón » Cargar » en el IDE de Arduino para cargar su boceto:
  • Después de ver el mensaje “ Conectando…. ” en su IDE de Arduino, suelte el dedo del botón “ BOOT ”:
Arduino IDE terminó de cargar ESP32 WiFiScan sketch
  • Después de eso, debería ver el mensaje » Terminó de cargar «.

Eso es todo. Su ESP32 debería tener el nuevo boceto ejecutándose. Presione el botón » HABILITAR » para reiniciar el ESP32 y ejecutar el nuevo boceto cargado.

Solución de otros problemas

Los problemas de parpadeo pueden ser complicados de solucionar. Pruebe las sugerencias aquí si tiene problemas:

El gestor de arranque no responde

Si ve errores como «Error al conectar», es probable que su chip no esté ingresando correctamente al gestor de arranque:

  • Compruebe que está pasando el puerto serie correcto en la línea de comandos.
  • Verifique que tenga permisos para acceder al puerto serie y que otro software (como el administrador de módem en Linux) no esté tratando de interactuar con él. Un error común es dejar un terminal serial accediendo a este puerto abierto en otra ventana y olvidarse de él.
  • Compruebe que el chip esté recibiendo 3,3 V de una fuente de alimentación estable (consulte Alimentación insuficiente para obtener más detalles).
  • Verifique que todos los pines estén conectados como se describe en Selección del modo de inicio . Verifique los voltajes en cada pin con un multímetro, los pines «altos» deben estar cerca de 3.3V y los pines «bajos» deben estar cerca de 0V.
  • Si ha conectado otros dispositivos a los pines GPIO, intente eliminarlos y vea si esptool comienza a funcionar.
  • Intente usar una tasa de baudios más lenta ( es un valor muy lento que puede usar para verificar que no es un problema de tasa de baudios).-b 9600

Escribir en Flash falla a mitad de camino

Si el parpadeo falla con errores aleatorios en la mitad, vuelva a intentarlo con una velocidad en baudios más baja.

Los problemas de estabilidad de energía también pueden causar esto (consulte Energía insuficiente ).

La escritura en Flash se realiza correctamente, pero el programa no se ejecuta

Si esptool puede actualizar su módulo write_flashpero su programa no se ejecuta, verifique lo siguiente:

Modo de flash incorrecto

Algunos dispositivos solo admiten el diomodo flash. Escribir en flash con qioel modo tendrá éxito, pero el chip no puede volver a leer el flash para ejecutarlo, por lo que no sucede nada en el arranque. Prueba a pasar la opción a .-fm diowrite_flash

Consulte la página Modos de flash SPI para obtener una descripción completa de los modos de flash y cómo determinar cuáles son compatibles con su dispositivo.

Poder insuficiente

La fuente de alimentación de 3,3 V para el chip ESP tiene que suministrar grandes cantidades de corriente (hasta 70 mA continuos, pico de 200-300 mA, puede ser un poco más alto). También necesita suficiente capacitancia en el circuito de alimentación para satisfacer grandes picos de demanda de energía.

Capacitancia insuficiente

Si está utilizando una placa o módulo de desarrollo prefabricado, el regulador de potencia y los condensadores incorporados suelen ser lo suficientemente buenos, siempre que la fuente de alimentación de entrada sea adecuada.

Nota

Esto no es cierto para algunos módulos de ruptura de pines muy simples, similar a este . Estos desgloses no integran suficiente capacitancia para funcionar de manera confiable sin componentes adicionales. Los módulos OEM de montaje en superficie como ESP-WROOM02 y ESP-WROOM32 requieren un condensador volumétrico externo en la PCB para ser confiables, consulte la hoja de datos del módulo.

Clasificación de la fuente de alimentación

Es posible tener una fuente de alimentación que suministre suficiente corriente para la etapa del cargador de arranque en serie con esptool, pero no lo suficiente para el funcionamiento normal del firmware. Es posible que vea que el voltaje VCC de 3,3 V cae si lo mide con un multímetro, pero puede tener problemas incluso si esto no sucede.

Intente cambiar un suministro de 3,3 V con una clasificación de corriente más alta, agregue condensadores a la línea de alimentación y/o acorte los cables de alimentación de 3,3 V.

La salida de 3,3 V de los chips/adaptadores FTDI FT232R o las placas Arduino no suministran suficiente corriente para alimentar un chip ESP (a veces puede parecer que funciona, pero no funcionará de manera confiable). Otros adaptadores USB TTL/serie también pueden ser marginales.

Falta el cargador de arranque

ESP-IDF y utiliza un pequeño programa cargador de arranque de firmware. El cargador de arranque de hardware en ROM carga este cargador de arranque de firmware desde flash y luego ejecuta el programa. En ESP32, la imagen del cargador de arranque debe ser flasheada por ESP-IDF en el desplazamiento 0x1000.

Consulte la documentación de ESP-IDF para obtener detalles sobre qué binarios deben actualizarse en qué compensaciones.

Pines SPI que deben desconectarse

En comparación con el cargador de arranque ROM con el que habla esptool, un firmware en ejecución usa más pines del chip para acceder al flash SPI.

Si configura el modo «Quad I/O» ( , el valor predeterminado de esptool), los GPIO 7, 8, 9 y 10 se utilizan para leer el flash SPI y, de lo contrario, deben desconectarse.-fm qio

Si configura el modo «Dual I/O» ( ), los GPIO 7 y 8 se utilizan para leer el flash SPI y, de lo contrario, deben desconectarse.-fm dio

Intente desconectar cualquier cosa de esos pines (y/o cambie al modo de E/S dual si anteriormente estaba usando el modo de E/S cuádruple pero desea conectar cosas a los GPIO 9 y 10). Tenga en cuenta que si los GPIO 9 y 10 también están conectados a los pines de entrada en el chip flash SPI, aún pueden no ser adecuados para su uso como E/S de propósito general.

Además de estos pines, los GPIO 6 y 11 también se utilizan para acceder al flash SPI (en todos los modos). Sin embargo, el parpadeo generalmente fallará por completo si estos pines están conectados incorrectamente.

Accidente de etapa temprana

Utilice cualquiera de los programas de terminal serie para ver el registro de arranque. (La tasa de baudios ESP32 es 115200bps). Vea si el programa se bloquea durante el inicio temprano o si muestra un mensaje de error.

Programas de terminal serie

Hay muchos programas de terminal en serie adecuados para la depuración y la interacción en serie. El módulo pySerial (que se requiere para esptool) incluye uno de esos programas de terminal de línea de comandos: miniterm.py. Para obtener más detalles, consulte la documentación relacionada con pySerial o ejecute . Para conocer los valores exactos de configuración del puerto serie, consulte Configuración del puerto serie .miniterm -h

Seguimiento de las interacciones de Esptool

La ejecución volcará todas las interacciones en serie a la salida estándar (esto es una gran cantidad de salida). Esto puede ser útil al depurar problemas con la conexión en serie o al proporcionar información para informes de errores.esptool.py --trace

Errores comunes

Esta es una lista no exhaustiva de los errores de esptool más comunes junto con explicaciones de posibles causas y soluciones. Antes de leer cualquier consejo específico de error, se recomienda encarecidamente que revise primero toda la sección de Solución de problemas.

No se recibieron datos seriales.

Esptool no recibió ningún byte de datos o un paquete de deslizamiento exitoso . Este error generalmente implica algún tipo de problema de hardware. Esto puede deberse a que el hardware no funciona correctamente, las líneas seriales RX/TX no están conectadas o porque hay algún problema al restablecer el modo de descarga .

¡Modo de arranque incorrecto detectado (0xXX)! El chip debe estar en modo de descarga.

La comunicación con el chip funciona (se detecta el registro de arranque de la ROM), pero no se restablece automáticamente al modo de descarga.

Para resolver esto, verifique el circuito de restablecimiento automático (si su placa lo tiene), o intente restablecer el modo de descarga manualmente. Consulte Cargador de arranque manual para obtener instrucciones.

El modo de descarga se detectó correctamente, pero no se obtuvo respuesta de sincronización: la ruta de transmisión en serie parece estar inactiva.

El chip se restablece con éxito en el modo de descarga y envía datos a la computadora host, pero no recibe ninguna respuesta enviada por correo electrónico esptool. Esto implica un problema con la línea TX que se ejecuta desde el host hasta el dispositivo ESP. Verifique dos veces su placa o circuito de placa de prueba para ver si hay algún problema.

Encabezado de paquete no válido (0xXX): posible corrupción o ruido en serie.

Este error suele ser causado por una de las siguientes razones:

  • Usando un cable USB de mala calidad.
  • A veces, las placas de prueba pueden acortar los pines flash SPI en la placa y causar este tipo de problema. Intente quitar su placa de desarrollo de la placa de pruebas.
  • El chip podría estar oscureciéndose durante el flasheo. El regulador interno de 3,3 V de los chips FTDI no es suficiente para alimentar un ESP, consulte Alimentación insuficiente .

Otras cosas para probar:

  • Intente sincronizar y comunicarse a una velocidad en baudios mucho más baja, p .esptool.py --baud 9600 ...
  • Intente rastrear las interacciones en curso y vea si se recibe algo.esptool.py --trace ...
  • Intente omitir la detección automática de chips especificando el tipo de chip, ejecute .esptool.py --chip ESP32 ...

Si ninguna de las soluciones mencionadas anteriormente ayuda y su problema persiste, abra un nuevo problema .

Se produjo un error de excepción en serie

esptool.pyutiliza el módulo pySerial Python para acceder al puerto serie. Si pySerial no puede funcionar normalmente, genera un error y finaliza. Algunas de las causas de error de pySerial más comunes son:

  • No tienes permiso para acceder al puerto.
  • El puerto ya está siendo utilizado por otro software.
  • El puerto no existe.
  • El dispositivo se desconecta inesperadamente.
  • Los controladores de puerto serie necesarios no están instalados o están defectuosos.

Un ejemplo de un error pySerial:

A serial exception error occurred: read failed: [Errno 6] Device not configured

Los errores que se originan en pySerial, por lo tanto, no son un problema con esptool.py, pero generalmente son causados ​​por un problema con el hardware o los controladores.

Mas información en https://docs.espressif.com/projects/esptool/en/latest/esp32/troubleshooting.html

Por cierto, una forma rapida de conseguir el ESP32 es Amazon porque por unos 10€ podemos tenerlo en casa y empezar a experimentar porque además regalan un ebook

Medidor de energía IoT con Cayenne Dashboard usando PZEM-004T v3 y ESP8266


Debido al aumento de los costos de energía, las personas están encontrando formas de monitorear su consumo de energía para tomar medidas de ahorro de energía para su hogar. El objetivo de este proyecto es hacer un medidor de energía de bricolaje usando el PZEM-004T v3 para monitorear su consumo de energía, y dado que IoT es la nueva norma para el monitoreo remoto, también podemos conectar el medidor de energía con un tablero de IoT a través de Wi-Fi.

Esta conexión la haremos usando el mini microcontrolador ESP8266 para visualizar las lecturas del medidor en línea donde puede acceder usando su ordenador o teléfono inteligente a traves de la app de Cayenne.

Componentes de hardware y software:

Hardware:

  • Medidor de energía PZEM-004T-100A v3
  • ESP8266 con cable ( también nos sirve cualquier controlador de la família ESP8266 como Wemos D1 Mini)
  • Cables de puente macho – hembra
  • Tablero de circuitos

Software:

  • IDE de Arduino

Plataforma en línea:

  • Cayenne IoT

El medidor de energía PZEM-004T-100A v3

  • Rango de medida de 100A utilizando un transformador externo
  • Se utiliza principalmente para medir voltaje CA, corriente, potencia, energía, frecuencia y factor de potencia
  • Sin función de visualización
  • La capa física utiliza la interfaz de comunicación UART a RS485
  • La capa de aplicación utiliza el protocolo Modbus-RTU para comunicarse
  • Los datos se leen a través de la interfaz TTL que se puede conectar directamente con microcontroladores basados ​​en Arduino o ESP sin necesidad de ningún convertidor adicional

CARASTERICTICAS FUNDAMENTALES:

Tipo de producto:Módulo de comunicación AC

Modelo de producto:PZEM-004T

Función del producto:

Este documento describe la especificación del módulo de comunicación de CA PZEM-004T, el módulo se utiliza principalmente para medir la tensión de CA, la corriente, la potencia activa, la frecuencia, el factor de potencia y la energía activa, el módulo es sin función de visualización, los datos se leen a través de la interfaz TTL.

PZEM-004T-10A: Rango de medición 10A (Shunt incorporado)

PZEM-004T-100A: Rango de medición 100A (transformador externo)

Rango de medición:

Tensión
Rango de medición:80~260V
Resolución: 0.1V
Precisión de medición: 0,5%.
Corriente
Rango de medición: 0~10A(PZEM-004T-10A); 0~100A(PZEM-004T-100A)
Corriente de medición inicial: 0,01A(PZEM-004T-10A); 0,02A(PZEM-004T-100A)
Resolución: 0.001A
Precisión de medición: 0,5%.
Potencia activa
Rango de medición: 0~2.3kW(PZEM-004T-10A); 0~23kW(PZEM-004T-100A)
Potencia de medición inicial: 0,4W
Resolución: 0.1W
Formato de visualización:
<1000W, muestra un decimal, como: 999.9W

≥1000W, muestra sólo números enteros, como: 1000W

Precisión de medición: 0,5%.
Factor de potencia
Rango de medición: 0.00~1.00
Resolución: 0.01
Precisión de medición: 1%.
Frecuencia
Rango de medición: 45Hz~65Hz
Resolución: 0,1Hz
Precisión de medición: 0,5%.
Energía activa
Rango de medición: 0~9999.99kWh
Resolución: 1Wh
Precisión de medición: 0,5%.
Formato de visualización:
<10kWh, la unidad de visualización es Wh(1kWh=1000Wh), como: 9999Wh

≥10kWh, la unidad de visualización es kWh, como por ejemplo 9999.99kWh

Restablecimiento de la energía: utilice el software para restablecer.
Alarma de sobre potencia
El umbral de potencia activa se puede establecer, cuando la potencia activa medida supera el umbral, puede alarmar

Interfaz de comunicación
Interfaz TTL。

Protocolo de la capa física
La capa física utiliza la interfaz de comunicación UART a TTL

La velocidad de transmisión es de 9600, 8 bits de datos, 1 bit de parada, sin paridad

¿Cómo mide?

El medidor utiliza un transformador de corriente para medir la corriente. Está diseñado para producir una corriente alterna en su devanado secundario que es proporcional a la corriente que se mide en su primario. Reduce las corrientes de alto voltaje a un valor mucho más bajo y proporciona una forma conveniente de monitorear de manera segura la corriente eléctrica real que fluye en una línea de transmisión de CA.

INSTALAR ESP8266 EN IDE ARDUINO

Actualmente configurar el entorno de Arduino para funcionar con las placas de desarrollo de ESP8266 es muy sencillo,gracias al soporte que ha recibido de la comunidad, que hace que lo tengamos disponible como un paquete que podemos descargar y añadir al gestor de placas.

Para poder programar las placas de desarrollo basadas en el ESP8266 simplemente tendremos que configurar la URL del paquete para que podamos agregarlas al gestor de placas del IDE de Arduino.

Para ello accedemos al menú de configuración y en “Gestor de URLs adicionales de tarjeta” hacemos click en el pequeño botón de la derecha.

En la ventana que aparece, añadimos esta la siguiente URL.

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Si teníamos otras direcciones, dejamos cada una de ellas en una línea.

Ahora entramos en el gestor de tarjetas del IDE de Arduino.

Buscamos el paquete de placas de desarrollo basadas en el ESP8266 y lo instalamos.

Ya tenemos disponibles las placas de desarrollo basadas en el ESP8266 para programarlas con el IDE de Arduino. ¡Así de fácil!

En la próxima entrada profundizaremos en cómo programar ESP8266 con el IDE de Arduino, y veremos las similitudes y diferencias entre programar un Arduino convencional y una placa basada en el ESP8266.

Plataforma en línea:

  •  Cayenne IoT
  • Cayenne es el primer generador de proyectos de IoT de arrastrar y soltar del mundo que permite a los desarrolladores, diseñadores e ingenieros crear rápidamente prototipos y compartir sus proyectos de dispositivos conectados.
  • Cayenne se diseñó para ayudar a los usuarios a crear prototipos de Internet de las cosas y luego llevarlos a producción
  • Cayenne es un producto de myDevices que le permite no solo mostrar datos, sino también configurar disparadores, monitorear dispositivos, controlar dispositivos, etc.
  • La API de Cayenne MQTT se utiliza para conectar cualquier dispositivo que tenga con Cayenne Cloud

¿Qué es MQTT?MQTT significa 

transporte de telemetría de Message Queue Server. Es un protocolo de mensajería extremadamente simple y liviano (suscripción y publicación) diseñado para dispositivos limitados y redes con alta latencia, bajo ancho de banda o redes poco confiables. Con MQTT, los dispositivos IoT con recursos limitados pueden enviar o publicar información sobre un tema específico a un servidor que actúa como 

intermediario de mensajes MQTT. Luego, el corredor transmite la información a aquellos clientes que se han suscrito previamente al tema del cliente. Para este proyecto, 

Cayenne Dashboard actúa como intermediario de mensajes MQTT.

Configuración de hardware:

 Diagrama esquemático:

Conexiones:

  • PZEM-004T-100A v3
    • Conexión de carga
      • Transformador de corriente (CT) Cable VCC conectado a PZEM-004T v3 Live (+) Terminal 
      • Transformador de corriente (CT) Cable GND conectado al terminal neutro (-) PZEM-004T v3 
      • Cable de carga viva (+) conectado al terminal de carga viva (+) PZEM-004T v3 
      • Cable de carga neutra (-) conectado a la terminal de carga  neutra  (-)  PZEM-004T v3 
    • Conexión ESP8266
      • Cable VCC conectado al pin 3.3v
      • Cable GND conectado al pin GND
      • El cable TX (transmisión) está conectado al pin D7
      • El cable RX (recepción) está conectado al pin D8
  • ESP8266
    • Pin VCC conectado al cable PZEM-004T v3 VCC
    • Pin GND conectado al cable PZEM-004T v3 GND
    • Pin D7 (RX) conectado al cable PZEM-004T v3 TX
    • Pin D8 (TX) conectado al cable PZEM-004T v3  RX

Configuración del programa:

Antes de configurar el código Arduino, debemos instalar la placa ESP8266 en el IDE de Arduino.

Instalación de soporte de placa ESP8266:

  • Haga clic en la  sección Preferencias en el IDE
  • Descarga el paquete esp8266 en el Board Manager
  • Después de agregar la placa ESP8266, debe conectarse con el panel Cayenne.

Cayenne Dashboard ESP8266 Configuración + Conexión: 

  • Después del registro de la cuenta (ES GRATUITO ), agregue un nuevo dispositivo para conectarse al tablero 
  • Elija Generic ESP8266  en la sección de Microcontroladores
  • Antes de conectar debemos descargar la  librería Cayenne MQTT ESP  en Github
  • Haga clic en el  boceto ESP8266  en el ejemplo Cayenne MQTT ESP 
  •  Antes de ejecutar el boceto, copie las credenciales de Cayenne MQTT proporcionadas
  • Edite las credenciales de Cayenne junto con las credenciales de Wi-Fi en el boceto
  • Ejecute el boceto y espere hasta que ESP8266 esté conectado a Cayenne
  • El ESP8266 por fin está conectado al salpicadero 
  • Después de configurar el tablero Cayenne, debemos probar el medidor PZEM-004T V3 antes de interactuar con el tablero.
  • Cargar el siguiente código en el IDE de Arduino  y desplegarlo sobre el ESP8266

//Libraries
#include <Arduino.h>
#include <PZEM004Tv30.h>

//PZEM object constructor
PZEM004Tv30 pzem(D7,D8);
//PZEM004Tv30 pzem(1,3);
void setup() {
  Serial.begin(115200);

  while(!Serial); 
  delay(100);
  
  Serial.println("PZEM-004T con NodeMcu 1.0 (Esp-12e Module)Test"); 
}

void loop() {
  Serial.println("Midiendo...");
  //Result Variables
  float volts = pzem.voltage();
  float amps = pzem.current();
  float watts = pzem.power();
  float kiloWatts = pzem.energy();
  float hertz = pzem.frequency();
  float factor = pzem.pf();

  delay(2000);

  Serial.println("");

  Serial.println("Resultados:");
  Serial.println("");

  Serial.print("Voltaje: "); Serial.print(volts,3); Serial.println("V");
  Serial.print("Corriente: "); Serial.print(amps,3); Serial.println("A");
  Serial.print("Potencia: "); Serial.print(watts,3); Serial.println("W");
  Serial.print("Energia: "); Serial.print(kiloWatts,3); Serial.println("kWh");
  Serial.print("Frequencia: "); Serial.print(hertz,2); Serial.println("Hz");
  Serial.print("Factor de potencia: "); Serial.println(factor,3);

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







Desglose del código:

Bibliotecas :

  • Arduino.h
    • El soporte ESP8266 para Arduino 
    • Capaz de escribir bocetos, usar funciones y bibliotecas de Arduino
    • Ejecute bocetos sin necesidad de un microcontrolador externo
    • Biblioteca integrada en el IDE
    • Más información sobre la biblioteca, junto con la configuración de ESP8266 Arduino en Github 
  • PZEM004Tv30.h
    • Biblioteca de medidores de energía Peacefair (PZEM-004T v3)
    • Versión actualizada de la biblioteca PZEM-004T anterior para admitir versiones más nuevas
    • Proporciona funciones completas del monitor de energía PZEM-004T v3
    • Más información sobre la biblioteca y enlace de descarga en Github 
    • También se puede descargar en Arduino Library Manager

Variables:

  • PZEM004Tv30 pzem(D7,D8)
    • El constructor de objetos para el medidor de energía junto con las conexiones de pin
  • Voltaje
    • Valor del sensor de tensión en voltios (V)
  • Actual
    • Valor del sensor de corriente en amperios (A)
  • Energía
    • Valor del sensor de potencia en vatios (W)
  • Energía
    • Valor del sensor de energía en kilovatios hora (kWh)
  • Frecuencia
    • Valor del sensor de frecuencia en hercios (Hz)
  • Factor de potencia
    • Resultado calculado basado en los valores del sensor

Funciones:

  • pzem.voltaje()
    • obtener valor de voltaje
  • pzem.actual()
    • obtener el valor actual
  • pzem.power()
    • obtener valor de potencia
  • pzem.energy()
    • obtener valor de energía
  • pzem.frecuencia()
    • recuperar valor de frecuencia
  • pzem.pf()
    • obtener el valor del factor de potencia

Después de probar el sensor SIN CONEXION , ahora podemos conectarlo con el tablero de Cayenne para cargar lecturas de energía en línea.

Con el siguiente código que subiremos al ESP8266 si lo personalizamos con nuestras propias claves (estan marcadas tachadas) podemos probar

Code (PZEM-004T V3 with Cayenne Dashboard): 
//Libraries
#include <Arduino.h>
#include <CayenneMQTTESP8266.h>
#include <PZEM004Tv30.h>

//Debug Cayenne Connection
#define CAYENNE_DEBUG

//Enable Serial Print
#define CAYYENE_PRINT Serial

//Canales de Cayenne para mostrar los datos
#define VOLTAGE_CHANNEL 1 //voltage
#define CURRENT_CHANNEL 2 //current
#define POWER_CHANNEL 3 //power
#define ENERGY_CHANNEL 4 //energy
#define FREQUENCY_CHANNEL 5 //frequency
#define POWERFACTOR_CHANNEL 6 //power factor

//RX pin = D7 connected to the TX pin of PZEM-004T v3
//TX pin = D8 connected to the RX pin of PZEM-004T v3

//Constructor del dispositivo  Peacefair 
PZEM004Tv30 pzem(D7,D8); 

//Credencial de la WiFi a la que se conectara para el envio. 
char ssid[] = "HOTSPOTniKOYA";
char wifiPassword[] = "09771665851";

//ESP8266 Información para la autenticacion de Cayenne obtenida de Cayenne Dashboard.

char username[] = "439049b0-0660-11ed-8df2-dd50487e509b";
char password[] = "1f5cf9c47e9fc2b28eaa1ffb054b62003a71127a";
char clientID[] = "349a2920-1bf1-11ed-baf6-35fab7fd0ac8";

//Meter values
float Voltage;
float Current;
float Power;
float Energy;
float Frequency;
float PowerFactor;

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

  //Esperar a que  Serial Monitor se abra antes de proceder
  while(!Serial);
  delay(100);
  
  //Start Cayenne connection 
  Cayenne.begin(username, password, clientID, ssid, wifiPassword);

  Serial.println("PZEM-004T-100A Energy Meter Cayenne Interface using ESP8266 ( o un Wemos D1 Mini)");
  Serial.println("");
}

void loop() {
  //get meter values
  Voltage = pzem.voltage();
  Current = pzem.current();
  Power = pzem.power();
  Energy = pzem.energy();
  Frequency = pzem.frequency();
  PowerFactor = pzem.pf();
  
  Cayenne.loop();
}

//Display Voltage Value
CAYENNE_OUT(VOLTAGE_CHANNEL)
{ 
  Serial.println("Resultados de las medidas: ");  
  Cayenne.virtualWrite(VOLTAGE_CHANNEL, Voltage);
  Serial.print("Voltaje: "); Serial.print(Voltage,3); Serial.println("V");
}

//Display Current Value
CAYENNE_OUT(CURRENT_CHANNEL)
{   
  Cayenne.virtualWrite(CURRENT_CHANNEL, Current);
  Serial.print("Corriente: "); Serial.print(Current,3); Serial.println("A");
}

//Display Power Value
CAYENNE_OUT(POWER_CHANNEL)
{   
  Cayenne.virtualWrite(POWER_CHANNEL, Power);
  Serial.print("Potencia: "); Serial.print(Power,3); Serial.println("W");
}

//Display Energy Value
CAYENNE_OUT(ENERGY_CHANNEL)
{   
  Cayenne.virtualWrite(ENERGY_CHANNEL, Energy);
  Serial.print("Energia: "); Serial.print(Energy,3); Serial.println("kWh");
}

//Display Frequency Value
CAYENNE_OUT(FREQUENCY_CHANNEL)
{   
  Cayenne.virtualWrite(FREQUENCY_CHANNEL, Frequency);
  Serial.print("Frequencia: "); Serial.print(Frequency,2); Serial.println("Hz");
}

//Display Power Factor Value
CAYENNE_OUT(POWERFACTOR_CHANNEL)
{   
  Cayenne.virtualWrite(POWERFACTOR_CHANNEL, PowerFactor);
  Serial.print("Factor de Potencia: "); Serial.println(PowerFactor,3);
  Serial.println("");
}

Desglose del código:

Bibliotecas:

  • Arduino.h
    • El soporte ESP8266 para Arduino 
    • Capaz de escribir bocetos, usar funciones y bibliotecas de Arduino
    • Ejecute bocetos sin necesidad de un microcontrolador externo
    • Biblioteca integrada en el IDE
    • Más información sobre la biblioteca, junto con la configuración de ESP8266 Arduino en Github 
  • CayenneMQTTESP8266.h
    • Biblioteca Cayenne MQTT ESP para la conexión del generador de proyectos Cayenne IoT
    • Admite módulos Wi-Fi ESP8266 y ESP32
    • Leer y enviar datos a Cayenne Dashboard
    • Más información sobre la biblioteca y enlace de descarga en Github
  • PZEM004Tv30.h
    • Biblioteca de medidores de energía Peacefair (PZEM-004T v3)
    • Versión actualizada de la biblioteca PZEM-004T anterior para admitir versiones más nuevas
    • Proporciona funciones completas del monitor de energía PZEM-004T v3
    • Más información sobre la biblioteca y enlace de descarga en Github
    • También se puede descargar en Arduino Library Manager

Variables:
@PZEM-004T v3

  • PZEM004Tv30 pzem(D7,D8)
    • El constructor de objetos para el medidor de energía junto con las conexiones de pin
  • Voltaje
    • Valor del sensor de tensión en voltios (V)
  • Actual
    • Valor del sensor de corriente en amperios (A)
  • Energía
    • Valor del sensor de potencia en vatios (W)
  • Energía
    • Valor del sensor de energía en kilovatios hora (kWh)
  • Frecuencia
    • Valor del sensor de frecuencia en hercios (Hz)
  • Factor de potencia
    • Resultado calculado basado en los valores del sensor

@Cayenne

  • CAYENNE_DEBUG
    • Habilita la impresión en serie de Cayenne
  • Serie CAYENNE_PRINT
    • Habilita el monitor serie para imprimir datos
  • VOLTAJE_CANAL 1
    • El canal Cayenne asignado para proyectar lecturas de voltaje del medidor
  • CANAL_ACTUAL 2
    • El canal Cayenne asignado para proyectar lecturas actuales del medidor
  • POTENCIA_CANAL 3
    • El canal Cayenne asignado para proyectar lecturas de energía del medidor
  • ENERGÍA_CANAL 4
    • El canal Cayenne asignado para proyectar lecturas de energía del medidor
  • FRECUENCIA_CANAL 5
    • El canal Cayenne asignado para proyectar lecturas de frecuencia del medidor
  • FACTOR DE POTENCIA_CANAL 6
    • El canal Cayenne asignado para proyectar lecturas de factor de potencia del medidor
  • sid[]
    • El nombre de la conexión Wi-Fi para conectar el Wemos D1 mini
  • Contraseña de wifi[]
    • La contraseña de conexión Wi-Fi para conectar el Wemos D1 mini
  • nombre de usuario char[]
    • Nombre de usuario de Cayenne del dispositivo (proporcionado en el código de enlace de Cayenne)
  • contraseña de char[]
    • Contraseña de Cayenne del dispositivo (proporcionada en el código de enlace de Cayenne)
  • ID de cliente char[]
    • ID de cliente de Cayenne del dispositivo (proporcionado en el código de enlace de Cayenne)

Funciones:
@PZEM-004T V3

  • pzem.voltaje()
    • obtener valor de voltaje
  • pzem.actual()
    • obtener el valor actual
  • pzem.power()
    • obtener valor de potencia
  • pzem.energy()
    • obtener valor de energía
  • pzem.frecuencia()
    • recuperar valor de frecuencia
  • pzem.pf()
    • obtener el valor del factor de potencia

@Cayenne

  • Cayenne.begin(nombre de usuario, contraseña, ID de cliente)
    • Inicia la conexión de cayena
    • Muestra el estado de la conexión en el monitor serie
  • Cayenne.loop()
    • Llama a la clase CAYENNE_OUT(VIRTUAL_CHANNEL) 
  • Cayenne.virtualWrite(Canal, Salida)
    • Mostrar los valores del medidor en el monitor serial
    • Sube los valores de salida al canal virtual del tablero

Y una vez que llevamos un rato con el montaje funcionando este es el resultado

NOTAS IMPORTANTES:

  • Si conectamos el PZEM004 a un ESP8266, la tension de alimentación para la sincronizacion del canal de comunicaciones es 3,3V (en caso de un Wemos seria de 5v)
  • Para que las medidas sean correctas los leds TX y RX del PZEM004 deben parpadear rápido y con luz tenue. Si alguno de los leds TX o RX se queda fijo esto significa que o bien alguna conexión es incorrecta o no se ha actualizado el firmware del controlador , de modo que si consultamos la consola serie veremos que las medidas no son correctas ( el IDE de Arduino las pinta como nan). Ver la imagen de abajo donde se aprecia este error.
  • En caso de que no se pueda programar el controlador ESP8266 desde el IDE de Arduino un truco consiste en desconectar la línea de 3.3V hacia la salida RS425 antes de compilar el código.
  • A veces es necesario reiniciar tanto el PZEM004 como el ESP8266 si no hay resultados correctos .
  • Si no tenemos la consola serie para saber si está sacando datos correctos ( es decir que no saca los valores nan) una buena referencia son los dos leds (tX y RX) del PZEM004 qeu deben lucir a la vez a intervalos regulares ( según el delay definido en el bucle principal)
  • Debemos programar el controlador antes de conectar la salida RS425 del PZEM004 para evitar problemas
  • Se ha usado un ESP8266 ( aunque se puede usar cualquiera similar que pertenezca a esta familia) para que no de problemas el api de Cayenne . Para usar un ESP32 se debe seleccionar en el interfaz el Esp826 pues funciona también con la familia del ESP32 , si bien la llibreria es CayenneMQTTESP32.h

Más información en

Más información en https://cayenne.mydevices.com/

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/