Medidor de voltaje y corriente Wifi multicanal: 11 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:41

Al hacer una placa de pruebas, a menudo es necesario monitorear diferentes partes del circuito a la vez.

Para evitar el dolor de tener que pegar las sondas del multímetro de un lugar a otro, quería diseñar un medidor de voltaje y corriente multicanal.

La tabla Ina260 de Adafruit proporciona una forma muy eficaz y eficiente de hacerlo. Contiene un medidor de voltaje y corriente muy preciso con un puente I2C integrado (¡ahorra muchos pines al combinar 3 de ellos!).

Lo único que faltaba era una pantalla. De ahí la decisión de conectar las placas a una placa de desarrollo ESP32, que puede transportar fácilmente un servidor web para presentar los elementos medidos en una pantalla de PC / móvil.

Suministros

3 x tablero de adafruit Ina260

3 x pines de cabecera con pines largos

Mínimo 6 cables de puente

1 x ESP32 Wrover-B (o cualquier otra placa Wifi con soporte I2C)

Cabezal de 2 x 19 pines (si corresponde)

1 x placa de circuito impreso o placa perfilada

1 x fuente de alimentación de 3,3 V

Paso 1: suelde las tres placas INA

El primer paso es montar las tres placas INA260.

Se puede encontrar una muy buena instrucción en el sitio web de Adafruit. Siga las instrucciones de montaje de Adafruit.

Para poder apilarlos uno encima del otro, use los encabezados de pines largos en lugar de las tiras de pines suministradas.

Paso 2: configurar tres direcciones I2C diferentes

I2C es un protocolo en serie para una interfaz de dos cables para conectar dispositivos de baja velocidad en distancias cortas. Se pueden conectar hasta 127 esclavos. En un bus, cada dispositivo debe identificarse mediante una dirección I2C única. La dirección I2C de un dispositivo a menudo está cableada en el chip de un dispositivo. Para conectar los mismos dispositivos en un bus, el fabricante a menudo deja la posibilidad de cambiar la dirección I2C soldando una configuración de pines juntos.

Este también es el caso de las tres placas INA260. El dispositivo tiene dos pines de dirección, A0 y A1 que se pueden conectar a GND, VS, SCL o SDA para establecer la dirección deseada. En la hoja de datos del chip INA260 de texas instruments, se puede encontrar la lista de conexiones de pines para cada una de las 16 direcciones posibles.

El tablero de adafruit limita esto a 4 tableros al exponer dos almohadillas que se pueden usar para tirar del A0 y / o A1 a VS. La dirección predeterminada de la placa INA260 es 0x40.

Complete este paso asignando direcciones diferentes a las otras dos placas:

Al soldar la almohadilla A0 de la segunda placa, establece su dirección en: 0x41 (o 1000001 BIN)

Al soldar la almohadilla A1 de la tercera placa, asigna la dirección a: 0x44 (o 1000100 BIN)

Paso 3: conecte las placas Ina al ESP32

Ahora que hemos asignado diferentes direcciones I2C a cada una de las placas INA, ¡es hora de conectarlas a la placa ESP32!

Según la imagen de arriba, conecte

1) el pin VCC al pin de 3.3V

2) el pin GND al pin GND

3) el pin SDA al pin 21 de GPIO

4) el pin SCL al pin 22 de GPIO

He usado un diseño de PCB para hacer las conexiones, ya que es parte de un proyecto más grande (un suministro de voltaje ajustable WiFi con limitación de corriente ajustable; espero hacer un instructivo para este también).

Puede usar cualquier otra forma de conexión, esto podría ser una placa de perforación que suelde o usando una placa de pruebas. Ambos funcionarán bien también.

Paso 4: Instale la placa ESP32 en el IDE de Arduino

Ahora que hemos conectado las placas entre sí, es hora de comprobar la conexión.

Lo haremos recopilando las direcciones I2C de las placas Ina.

La placa ESP32 funciona perfectamente con Arduino IDE.

Así que instalemos la placa ESP32 en Arduino usando el administrador de la placa.

Paso 5: Verifique la conexión Ina a ESP32 usando el escáner I2C

Usaremos un simple escáner de direcciones I2C para asegurar la conectividad entre las placas ESP32 e Ina260.

El código del escáner de direcciones I2C se puede copiar y pegar en un proyecto Arduino vacío.

El código se ha tomado del sitio web de Arduino cc:

// -------------------------------------- // i2c_scanner // // Versión 1 / / Este programa (o código que se parece a él) // se puede encontrar en muchos lugares. // Por ejemplo en el foro Arduino.cc. // El autor original no se conoce. // Versión 2, junio de 2012, usando Arduino 1.0.1 // Adaptado para ser lo más simple posible por el usuario de Arduino.cc Krodal // Versión 3, 26 de febrero de 2013 // V3 por louarnold // Versión 4, 3 de marzo de 2013, Usando Arduino 1.0.3 // por el usuario de Arduino.cc Krodal. // Se han eliminado los cambios de Louarnold. // Las direcciones de escaneo cambiaron de 0… 127 a 1… 119, // según el escáner i2c de Nick Gammon // https://www.gammon.com.au/forum/?id=10896 // Versión 5, marzo 28, 2013 // Como la versión 4, pero la dirección escanea ahora a 127. // Un sensor parece usar la dirección 120. // Versión 6, 27 de noviembre de 2015. // Se agregó esperando la comunicación serial de Leonardo. // // // Este esquema prueba las direcciones estándar de 7 bits // Es posible que los dispositivos con una dirección de bits superior no se vean correctamente. // #incluye void setup () {Wire.begin (); Serial.begin (9600); mientras (! Serial); // Leonardo: espera al monitor serial Serial.println ("\ nI2C Scanner"); } bucle vacío () {error de byte, dirección; int nDevices; Serial.println ("Escaneando …"); nDevices = 0; for (address = 1; address <127; address ++) {// El i2c_scanner usa el valor de retorno de // Write.endTransmisstion para ver si // un dispositivo reconoció la dirección. Wire.beginTransmission (dirección); error = Wire.endTransmission (); if (error == 0) {Serial.print ("Dispositivo I2C encontrado en la dirección 0x"); if (dirección <16) Serial.print ("0"); Serial.print (dirección, HEX); Serial.println ("!"); nDevices ++; } else if (error == 4) {Serial.print ("Error desconocido en la dirección 0x"); if (dirección <16) Serial.print ("0"); Serial.println (dirección, HEX); }} if (nDevices == 0) Serial.println ("No se encontraron dispositivos I2C / n"); else Serial.println ("hecho / n"); retraso (5000); // espera 5 segundos para el siguiente escaneo}

Paso 6: Creación de la carpeta del servidor web HTML

El ESP32 ofrece la posibilidad de ejecutar un servidor web. También proporciona una memoria RAM bastante grande para albergar algunas páginas web. (Comprime automáticamente los archivos de la página web).

El IDE de Arduino proporciona la funcionalidad para cargar las páginas web creadas a la RAM del ESP32 directamente.

Para hacer esto, necesita crear una carpeta 'datos' debajo de la carpeta del proyecto Arduino. En mi caso, esto es / Arduino / esp32_Power_supply_v1_implemented / data.

Es importante nombrar la carpeta exactamente como "datos", ya que es el nombre de la carpeta que Arduino buscará cuando cargue los archivos de la página web en el ESP.

Paso 7: Cree la página web de Power Monitor

HMTL es un lenguaje que permite presentar un texto en un navegador web. Un archivo HTML se guarda con la extensión htm (l). El formato de una página web generalmente se coloca en un archivo separado (por ejemplo, archivo css). La funcionalidad del programa que una página web debe ofrecer normalmente se coloca en otro archivo (por ejemplo, archivo js, para javascript).

En mi documento HTML incluí el texto, el formato y Javascript en un archivo. Por lo tanto, no es un buen ejemplo de cómo hacer una página web, pero sirve para los propósitos. Llamé al documento HTML 'Index.htm'.

Un segundo archivo está incluido en mi carpeta de datos, es decir. PicoGraph.js. La biblioteca PicoGraph es proporcionada por Vishnu Shankar B de RainingComputers y permite una forma muy simple, pero efectiva y flexible de presentar gráficos en una página web. Modifiqué ligeramente el código para que sirviera mejor a mi propósito.

Notará que la página web HTML también incluye el código para controlar los suministros de voltaje en mi placa PCB. El código de suministro de voltaje controla el nivel de voltaje de 5 pines de E / S. Puede cambiar el código para excluir esto o puede dejarlo si no tiene ningún impacto.

El código html se adjunta a este paso como un archivo txt (ya que las instrucciones no permiten cargar código htm).

Para usar el código HTML, lo copie y pegue en un editor de texto (yo uso Notepad ++) y guárdelo como 'Index.htm' en la carpeta 'Datos'. Haz lo mismo para el archivo picograph.txt pero cámbiale el nombre a picograph.js

Con respecto al archivo HTML:

Se utiliza una función SndUpdate para enviar mensajes hacia atrás y hacia adelante desde el ESP a la página web.

Los mensajes enviados desde el ESP sirven a la funcionalidad de la fuente de alimentación y están fuera del alcance de este instructable. los mensajes al ESP están sirviendo las medidas de la placa Ina260.

var Msg = JSON.parse (xh.responseText); PG1_yrand0 = Msg. PG1_yrand0; PG2_yrand0 = Msg. PG2_yrand0; PG3_yrand0 = Msg. PG3_yrand0; PG4_yrand0 = Msg. PG4_yrand0; PG5_yrand0 = Msg. PG5_yrand0; PG6_yrand0 = Msg. PG6_yrand0;

El código anterior lee 6 números de la placa ESP32, es decir. la medición de voltaje, la medición de corriente de la primera placa, seguida de las dos mediciones de la segunda y así sucesivamente.

Los gráficos están incrustados en los llamados contenedores flexibles, que permiten un cambio de tamaño flexible de la página web.

.flex-container {pantalla: flex; color de fondo: cadetblue; envoltura flexible: envoltura; }.flex-container> div {background-color: # f1f1f1; margen: 10px; relleno: 20px; tamaño de fuente: 20px; familia de fuentes: "Siete segmentos"; font-weight: negrita; }

El contenido de cada uno de los contenedores flexibles se compone de la siguiente manera, incluidos los gráficos incrustados.

(tenga en cuenta que donde se eliminó)

div label for = "PG1_scale" Scale: / label input name = "PG1_scale" value = "10" brbr! - Lienzo para el gráfico thr - canvas style = "height: 100px; border: 2px solid # 000000; background-color: #fafafa; " /lienzo

! - div para leyendas / etiquetas -

div / div div / div / div

La última sección de importancia en el archivo HTML trabaja con la biblioteca PicoGraph para presentar los números:

var PG1_demograph = createGraph ("PG1_graphDemo", ["Ch1"], "V", "PG1_graphLabels", 20, 11, falso, falso, 11, "# e52b50"); var PG2_demograph = createGraph ("PG2_graphDemo", ["Ch1"], "mA", "PG2_graphLabels", 20, 11, falso, falso, 11, "# e52b50"); var PG3_demograph = createGraph ("PG3_graphDemo", ["Ch2"], "V", "PG3_graphLabels", 20, 11, falso, falso, 11, "# 008000"); var PG4_demograph = createGraph ("PG4_graphDemo", ["Ch2"], "mA", "PG4_graphLabels", 20, 11, falso, falso, 11, "# 008000"); // var PG5_demograph = createGraph ("PG5_graphDemo", ["Ch3"], "V", "PG5_graphLabels", 20, 11, falso, falso, 11, "# 0000ff"); var PG6_demograph = createGraph ("PG6_graphDemo", ["Ch3"], "mA", "PG6_graphLabels", 20, 11, falso, falso, 11, "# 0000ff"); / * Actualizar valores cada segundo * / setInterval (updateEverySecond, 1000); function updateEverySecond () {/ * Obtener nuevos valores * / SndUpdate ();

/ * Actualizar gráfico * / PG1_demograph.update ([PG1_yrand0], parseInt (byID ("PG1_scale"). Value) + parseInt (byID ("PG1_scale"). Value) / 10, "# e52b50"); PG2_demograph.update ([PG2_yrand0], parseInt (byID ("PG2_scale"). Valor) + parseInt (byID ("PG2_scale"). Value) / 10, "# e52b50"); PG3_demograph.update ([PG3_yrand0], parseInt (byID ("PG3_scale"). Valor) + parseInt (byID ("PG3_scale"). Value) / 10, "# 008000"); PG4_demograph.update ([PG4_yrand0], parseInt (byID ("PG4_scale"). Valor) + parseInt (byID ("PG4_scale"). Value) / 10, "# 008000"); // PG5_demograph.update ([PG5_yrand0], parseInt (byID ("PG5_scale"). Value) + // parseInt (byID ("PG5_scale"). Value) / 10, "# 0000ff"); PG6_demograph.update ([PG6_yrand0], parseInt (byID ("PG6_scale"). Valor) + parseInt (byID ("PG6_scale"). Value) / 10, "# 0000ff"); var Watts = Math.round (PG1_yrand0 * PG2_yrand0 * 100) / 100; byID ("PG1_wattLabel"). innerHTML = `WATT: $ {Watts} mW`; var Watts = Math.round (PG3_yrand0 * PG4_yrand0 * 100) / 100; byID ("PG3_wattLabel"). innerHTML = `WATT: $ {Watts} mW`; // var Watts = Math.round (PG5_yrand0 * PG6_yrand0 * 100) / 100; // byID ("PG5_wattLabel"). innerHTML = `WATT: $ {Watts} mW`; byID ("PG1_scale"). value = Math.floor (parseInt (byID ("PG1_scale"). value) / 2 + PG1_yrand0); byID ("PG2_scale"). value = Math.floor (parseInt (byID ("PG2_scale"). value) / 2 + PG2_yrand0); byID ("PG3_scale"). value = Math.floor (parseInt (byID ("PG3_scale"). value) / 2 + PG3_yrand0); byID ("PG4_scale"). value = Math.floor (parseInt (byID ("PG4_scale"). value) / 2 + PG4_yrand0); // byID ("PG5_scale"). value = Math.floor (parseInt (byID ("PG5_scale"). value) / 2 + PG5_yrand0); byID ("PG6_scale"). value = Math.floor (parseInt (byID ("PG6_scale"). value) / 2 + PG6_yrand0);

Al estudiar el código, notará que solo estoy usando 5 gráficos de los 6 para mi propósito. Si quita los comentarios de las líneas de la derecha, se habilitará el sexto gráfico.

Para aquellos que no tienen experiencia con html, este paso puede resultar complicado. Sin embargo, puede servir como una buena introducción al mundo de HTML. Lo sé porque esta fue la primera página que creé. Así que no tengas miedo. Para aquellos experimentados debajo de nosotros, perdonen.

El resultado de su trabajo en la página web se puede revisar abriendo su html, se cargará en su navegador y mostrará su apariencia. Puede verificar posibles errores presionando la tecla F12 en su navegador, se mostrará la ventana de depuración. La explicación completa de cómo depurar está fuera del alcance de este instructivo, pero la página web puede ser útil como primer paso para la depuración de la página web / javascript.

El siguiente paso es cargar las páginas web creadas en el ESP32.

Paso 8: Cargue la página web en el ESP32

Después de obtener un resultado satisfactorio, es el momento de cargar la página web en el ESP32.

Para hacer esto, guarde el 'Index.htm' (su página web) y el 'PicoGraph.js' en la carpeta 'datos' debajo de su proyecto Arduino.

El siguiente paso es conectar la placa ESP32 a la computadora. Después de haber seleccionado la placa correcta y el puerto COM, seleccione la carga de datos de boceto ESP32 en el menú Herramientas en el IDE de Arduino.

Verá que el IDE comenzará su proceso de carga, lo que debería conducir a una carga exitosa.

El siguiente paso es configurar el microcontrolador ESP32 como servidor web.

Paso 9: configurar el ESP32 como servidor web

Adjunto encontrará el boceto de Arduino Ino que configurará el ESP32 como servidor web.

Deberá reemplazar el SSID y la contraseña relacionada con la contraseña de su enrutador.

Como ya se mencionó, este boceto también contiene el código para configurar la página web como un controlador para el lado de la fuente de alimentación de la PCB (de hecho, configurar 5 pines IO como pines PWM y controlarlos a través del flujo de mensajes desde la página web).

El boceto se basa en el boceto estándar del servidor web desarrollado por Hristo Gochkov.

Alguna explicación sobre el código.

Las siguientes funciones están relacionadas con la configuración del servidor web.

String formatBytes (size_t bytes) String getContentType (String filename) bool existe (String path) bool handleFileRead (String path) void handleFileUpload () void handleFileDelete () void handleFileCreate () void handleFileList ()

Además, el primer código de la función setup () está relacionado con la configuración del servidor web y PWM.

El siguiente código establece la función de interrupción que sirve a los flujos de mensajes hacia y desde la página web:

(debe reconocer los identificadores de la creación de la página web)

server.on ("/ SndUpdate", HTTP_GET, () {

String Msg = "{"; Msg + = "\" PG1_yrand0 / ":" + (Cadena) Vina [1]; Msj + = ", \" PG2_yrand0 / ":" + (Cadena) Iina [1]; Msj + = ", \" PG3_yrand0 / ":" + (Cadena) Vina [0]; Msj + = ", \" PG4_yrand0 / ":" + (Cadena) Iina [0]; Msj + = ", \" PG5_yrand0 / ":" + (Cadena) Vina [2]; Msj + = ", \" PG6_yrand0 / ":" + (Cadena) Iina [2]; Msj + = "}";

server.send (200, "texto / json", Msj);

Esto inicia el servidor:

server.begin ();

El siguiente bloque de código, inicializa las placas INA260:

// Inicialización de INA260 if (! Ina260_0x40.begin (0x40)) {Serial.println (F ("No se pudo encontrar el chip INA260 0x40")); // mientras (1); } Serial.println (F ("Se encontró el chip INA260 0x40")); if (! ina260_0x41.begin (0x41)) {Serial.println (F ("No se pudo encontrar el chip 0x41 INA260")); // mientras (1); } Serial.println (F ("Se encontró el chip INA260 0x41")); if (! ina260_0x44.begin (0x44)) {Serial.println (F ("No se pudo encontrar el chip INA260 0x44")); // mientras (1); } Serial.println (F ("Se encontró el chip INA260 0x44"));

ina260_0x40.setAveragingCount (INA260_COUNT_256);

ina260_0x40.setVoltageConversionTime (INA260_TIME_1_1_ms); ina260_0x40.setCurrentConversionTime (INA260_TIME_1_1_ms); ina260_0x40.setMode (INA260_MODE_CONTINUOUS); ina260_0x41.setAveragingCount (INA260_COUNT_256); ina260_0x41.setVoltageConversionTime (INA260_TIME_1_1_ms); ina260_0x41.setCurrentConversionTime (INA260_TIME_1_1_ms); ina260_0x41.setMode (INA260_MODE_CONTINUOUS); ina260_0x44.setAveragingCount (INA260_COUNT_256); ina260_0x44.setVoltageConversionTime (INA260_TIME_1_1_ms); ina260_0x44.setCurrentConversionTime (INA260_TIME_1_1_ms); ina260_0x44.setMode (INA260_MODE_CONTINUOUS);

En el código de bucle, la siguiente declaración asegura el manejo del código de interrupción:

server.handleClient ();

El siguiente código en la declaración de bucle está relacionado con la funcionalidad de la fuente de alimentación.

El siguiente código en el loop () es interesante nuevamente:

Vina [0] = ina260_0x40.readBusVoltage () / 1000.0f; Iina [0] = ina260_0x40.readCurrent (); Vina [1] = ina260_0x41.readBusVoltage () / 1000.0f; Iina [1] = ina260_0x41.readCurrent (); Vina [2] = ina260_0x44.readBusVoltage () / 1000.0f; Iina [2] = ina260_0x44.readCurrent ();

Estas declaraciones recopilan y preparan las medidas para transferirlas a la página web a través del servidor. En llamadas de interrupción (que ocurren cada 1000 ms, configuradas en el script java html de la página web).

Paso 10: ¡Listo

¡Al cargar el boceto en la placa ESP32, debería finalizar la configuración y su monitor de energía debería ser definitivo!

Es posible que haya notado que la alimentación del ESP32 ahora se realiza a través del puerto USB, esto eleva una gran parte de las ventajas de la conexión basada en WiFi con sus medidores de voltaje / corriente. Por lo tanto, he creado una fuente de alimentación regulada por voltaje basada en LM317 simple para el ESP32. Lo mantuve fuera del alcance de este instructable, pero si hay interés, podría convertirse en el próximo instructable.

En el siguiente paso, ya proporcioné el circuito electrónico para la fuente de alimentación que podría servir de inspiración.

Paso 11: Encendido del ESP32

A continuación se incluye una inspiración para construir una fuente de alimentación independiente para su ESP32, si no tiene una disponible.

El circuito de alimentación funciona con una fuente de alimentación de portátil de 19 V. Esto requiere una reducción de voltaje de dos fases para mantener bajo control la disipación de energía de los LM317. (¡Incluso con disipadores de calor!). Además, no olvide incluir un condensador de 100 uF frente a la línea VCC_ESP, ya que esos microcontroladores tienen grandes oscilaciones de corriente al iniciar la conexión WiFi.

¡Tenga en cuenta que no debe alimentar el ESP32 con más de una fuente de alimentación a la vez!

Además de las exenciones de responsabilidad habituales, pero sobre todo

¡Divertirse!

Todos los archivos se pueden encontrar en mi GitHub: