MEDIDOR DE ENERGÍA ARDUINO: 10 pasos (con imágenes)

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

[Reproduce el video]

Pertenezco a una aldea de Odisha, India, donde los cortes de energía frecuentes son muy comunes. Obstaculiza la vida de todos. Durante los días de mi infancia, continuar con los estudios después del anochecer fue un verdadero desafío. Debido a este problema diseñé un sistema solar para mi casa de forma experimental. Usé un panel solar de 10 Watt, 6V para iluminar algunos LED brillantes. Después de enfrentar muchas dificultades, el proyecto tuvo éxito. Luego decidí monitorear el voltaje, la corriente, la potencia y la energía involucradas en el sistema. Esto trajo la idea de diseñar un MEDIDOR DE ENERGÍA. Usé ARDUINO como el corazón de este proyecto porque es muy fácil escribir código en su IDE y hay una gran cantidad de bibliotecas de código abierto disponibles en Internet que se pueden usar de acuerdo con el Requisito He experimentado el proyecto para un sistema solar de clasificación muy pequeña (10 vatios), pero esto se puede modificar fácilmente para usarlo en un sistema de clasificación más alta.

Puedes encontrar todos mis proyectos en:

Característica: Monitoreo de energía por pantalla 1. LCD 2. a través de Internet (carga Xively) 3. Registro de datos en una tarjeta SD

Puede ver mi nuevo CONTROLADOR DE CARGA SOLAR ARDUINO MPPT instructable (Versión-3.0)

También puedes ver mis otros instructivos en

CONTROLADOR DE CARGA SOLAR ARDUINO (Versión 2.0)

CONTROLADOR DE CARGA SOLAR ARDUINO (Versión-1)

Paso 1: Piezas necesarias:

1. ARDUINO UNO (Amazon) 2. ESCUDO ARDUINO ETHERNET (Amazon)

3. LCD DE CARACTERES 16x2 (Amazon)

4. SENSOR DE CORRIENTE ACS 712 (Amazon) 4. RESISTENCIAS (10k, 330ohm) (Amazon) 5. POTENCIÓMETRO 10K (Amazon) 6. CABLES DE PUENTE (Amazon) 7. CABLE ETHERNET (Amazon) 8. TABLA DE PAN (Amazon)

Paso 2: potencia y energía

Potencia: La potencia es producto del voltaje (voltios) y la corriente (Amp) P = VxI La unidad de potencia es Watt o KW Energía: La energía es producto de la potencia (Watt) y el tiempo (Hora) E = Pxt Unidad de energía es Watt Hora o Kilovatio Hora (kWh) De la fórmula anterior queda claro que para medir la energía necesitamos tres parámetros 1. Voltaje 2. Corriente 3. Tiempo

Paso 3: medición de voltaje

El voltaje se mide con la ayuda de un circuito divisor de voltaje. Como el voltaje de entrada del pin analógico ARDUINO está restringido a 5V, diseñé el divisor de voltaje de tal manera que el voltaje de salida debería ser inferior a 5V. Mi batería utilizada para almacenar el La potencia del panel solar es de 6 V, 5,5 Ah, por lo que tengo que reducir este 6,5 V a un voltaje inferior a 5 V. Usé R1 = 10k y R2 = 10K. El valor de R1 y R2 puede ser menor, pero el problema es que cuando la resistencia es baja, el flujo de corriente más alto lo atraviesa como resultado una gran cantidad de energía (P = I ^ 2R) disipada en forma de calor. Por lo tanto, se pueden elegir diferentes valores de resistencia, pero se debe tener cuidado para minimizar la pérdida de potencia a través de la resistencia. Vout = R2 / (R1 + R2) * Vbat Vbat = 6.5 cuando está completamente cargado R1 = 10k y R2 = 10k Vout = 10 / (10 + 10) * 6.5 = 3.25v que es menor que 5v y adecuado para pin analógico ARDUINO NOTA I han mostrado que la batería de 9 voltios en el circuito de placa desnuda es solo por ejemplo para conectar los cables. pero la batería real que utilicé es una batería de plomo-ácido de 6 voltios, 5.5Ah. Calibración de voltaje: cuando la batería esté completamente cargada (6.5v) obtendremos a Vout = 3.25v y un valor más bajo para otro voltaje de batería más bajo. AEDUINO ADC convierte la señal analógica a la correspondiente aproximación digital. Cuando el voltaje de la batería es de 6.5v, obtuve 3.25v del divisor de voltaje y sample1 = 696 en el monitor en serie, donde sample1 es el valor ADC corresponde a 3.25v Para una mejor comprensión, he adjuntado la simulación en tiempo real por 123D.circuit para la calibración de medición de voltaje: 3.25v equivalente a 696 1 es equivalente a 3.25 / 696 = 4.669mv Vout = (4.669 * sample1) / 1000 voltios Voltaje real de la batería = (2 * Vout) volt CÓDIGO DE TARDUINO: // tomando 150 muestras del divisor de voltaje con un intervalo de 2 segundos y luego promediar los datos de las muestras recopilados para (int i = 0; i <150; i ++) {sample1 = sample1 + analogRead (A2); // lee el voltaje del circuito divisor delay (2); } muestra1 = muestra1 / 150; voltaje = 4.669 * 2 * muestra1 / 1000;

Paso 4: medición de corriente

Para la medición de corriente utilicé un sensor de corriente de efecto Hall ACS 712 (20 A). Hay diferentes sensores de rango de corriente ACS712 disponibles en el mercado, así que elija según sus necesidades. En el diagrama de la placa de pruebas, he mostrado el LED como una carga, pero la carga real es diferente. PRINCIPIO DE FUNCIONAMIENTO: El efecto Hall es la producción de una diferencia de voltaje (el voltaje Hall) a través de un conductor eléctrico, transversal a una corriente eléctrica en el conductor y un campo magnético perpendicular a la corriente. Para obtener más información sobre el sensor de efecto Hall, haga clic aquí. La hoja de datos del sensor ACS 712 se encuentra aquí. VCC / 2 = 5v / 2 = 2.5V Calibración: La lectura analógica produce un valor de 0-1023, lo que equivale a 0v a 5v Entonces, lectura analógica 1 = (5/1024) V = 4.89mv Valor = (4.89 * Valor de lectura analógica) / 1000 V Pero según las hojas de datos, el desplazamiento es de 2,5 V (cuando la corriente es cero, obtendrá 2,5 V de la salida del sensor) Valor real = (valor-2,5) V Corriente en amperios = valor real * 10 CÓDIGO DEARDUINO: // tomando 150 muestras de sensores con un intervalo de 2 segundos y luego promediar los datos de las muestras recopilados para (int i = 0; i <150; i ++) {sample2 + = analogRead (A3); // lee la corriente del sensor delay (2); } muestra2 = muestra2 / 150; val = (5.0 * muestra2) /1024.0; actualval = val-2.5; // el voltaje de compensación es 2.5v amps = actualval * 10;

Paso 5: medición del tiempo

Para la medición del tiempo no se necesita ningún hardware externo, ya que ARDUINO tiene un temporizador incorporado. La función millis () devuelve el número de milisegundos desde que la placa Arduino comenzó a ejecutar el programa actual. CÓDIGO DEARDUINO: long milisec = millis (); // calcula el tiempo en milisegundos long time = milisec / 1000; // convierte milisegundos a segundos

Paso 6: Cómo ARDUINO calcula la potencia y la energía

totamps = totamps + amperios; // calcular amperios totales avgamps = totamps / time; // amperios promedio amphr = (avgamps * tiempo) / 3600; // amperio-hora vatio = voltaje * amperios; // potencia = voltaje * energía actual = (vatios * tiempo) / 3600; Watt-seg se convierte nuevamente a Watt-Hr dividiendo 1 hora (3600 segundos) // energía = (vatio * tiempo) / (1000 * 3600); para leer en kWh

Paso 7: Salida visual

Todos los resultados se pueden visualizar en el monitor en serie o utilizando una pantalla LCD. Utilicé una pantalla LCD de 16x2 caracteres para mostrar todos los resultados obtenidos en los pasos anteriores. Para los esquemas, consulte el circuito de la placa de pan que se muestra arriba. Conecte la pantalla LCD con ARDUINO como se indica a continuación: LCD -> Arduino 1. VSS -> Arduino GND 2. VDD - > Arduino + 5v 3. VO -> Pin Arduino GND + Resistencia o Potenciómetro 4. RS -> Pin 8 Arduino 5. RW -> Pin 7 Arduino 6. E -> Pin 6 Arduino 7. D0 -> Arduino - No conectado 8. D1 -> Arduino - No conectado 9. D2 -> Arduino - No conectado 10. D3 -> Arduino - No conectado 11. D4 -> Pin 5 de Arduino 12. D5 -> Pin 4 de Arduino 13. D6 -> Pin 3 de Arduino 14. D7 -> Pin 2 de Arduino 15. A -> Pin 13 de Arduino + Resistencia (potencia de luz de fondo) 16. K -> Arduino GND (tierra de luz de fondo) CÓDIGO ARDUINO: Para monitor serie:

Serial.print ("VOLTAJE:"); Serial.print (voltaje); Serial.println ("Volt"); Serial.print ("ACTUAL:"); Serial.print (amperios); Serial.println ("Amperios"); Serial.print ("POWER:"); Serial.print (vatios); Serial.println ("Watt"); Serial.print ("ENERGÍA CONSUMIDA:"); Serial.print (energía); Serial.println ("Watt-Hora"); Serial.println (""); // imprime los siguientes conjuntos de parámetros después de un retraso de línea en blanco (2000); Para LCD: Para la pantalla LCD, primero debe importar la biblioteca "LiquidCrystal" en el código. Para saber más sobre la biblioteca LequidCrystal, haga clic aquí. Para obtener un tutorial sobre LCD, haga clic aquí. El siguiente código es un formato para mostrar en LCD todos los cálculos de potencia y energía. #Incluye lcd (8, 7, 6, 5, 4, 3, 2); int backLight = 9; configuración vacía () {pinMode (luz de fondo, SALIDA); // establece el pin 9 como salida analogWrite (backLight, 150); // controla la intensidad de la luz de fondo 0-254 lcd.begin (16, 2); // columnas filas. tamaño de la pantalla lcd.clear (); // limpia la pantalla} void loop () {lcd.setCursor (16, 1); // coloca el cursor fuera del recuento de la pantalla lcd.print (""); // imprime un carácter vacío delay (600); ////////////////////////////////////////// Imprime potencia y energía en una pantalla LCD / ///////////////////////////////////////////////// lcd.setCursor (1, 0); // coloca el cursor en la 1ª columna y la 1ª fila lcd.print (vatios); lcd.print ("W"); lcd.print (voltaje); lcd.print ("V"); lcd.setCursor (1, 1); // coloca el cursor en la 1ª columna y la 2ª fila lcd.print (energía); lcd.print ("WH"); lcd.print (amperios); lcd.print ("A"); }

Paso 8: Carga de datos a Xively.com

Consulte las capturas de pantalla anteriores para una mejor comprensión. Para cargar datos en xively.com, la siguiente biblioteca debe descargarse primero HttpClient: haga clic aquí Xively: haga clic aquí SPI: Importar desde arduino IDE (boceto -> Importar biblioteca…..) Ethernet: Importar desde arduino IDE ((sketch -> Importar biblioteca…..) Abra una cuenta con https://xively.com (anteriormente pachube.com y cosm.com) Regístrese para obtener una cuenta de desarrollador gratuita en

Elija un nombre de usuario, contraseña, establezca su dirección y zona horaria, etc. Recibirá un correo electrónico de confirmación;

luego haga clic en el enlace de activación para activar su cuenta. Después de abrir con éxito la cuenta, será redirigido a la página de Dispositivos de desarrollo.

• Haga clic en el cuadro + Agregar dispositivo
• Asigne un nombre a su dispositivo y una descripción (por ejemplo, MONITOREO DE ENERGÍA) ·
• Elija datos privados o públicos (elijo privados) ·
• Haga clic en Agregar dispositivo

Después de agregar el dispositivo, se le redirige a una nueva página donde hay mucha información importante.

• ID de producto, secreto de producto, número de serie, código de activación ·
• Feed ID, FeedURL, API End Point (Feed ID se usa en el código ARDUINO)
• Agregar canales (Elija ENERGÍA y POTENCIA, pero puede elegir según su elección) Proporcione unidad y símbolo para el parámetro ·
• Agregue su ubicación ·
• Claves API (utilizadas en el código ARDUINO, evite compartir este número) ·
• Disparadores (hacer ping a una página web cuando ocurre un evento, como cuando el consumo de energía excede un cierto límite)

Paso 9: Código Xively y ARDUINO

Aquí adjunto el código completo (versión beta) para el medidor de energía, excluyendo el registro de datos de la tarjeta SD, que se adjunta por separado en el siguiente paso. / ** Carga de datos de monitoreo de energía a xively ** / #include #include #include #include #define API_KEY "xxxxxxxx" // Ingrese su clave de API de Xively #define FEED_ID xxxxxxxxx // Ingrese su ID de alimentación de Xively // Dirección MAC para su Byte de protección de Ethernet mac = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED}; // Pin analógico que estamos monitoreando (0 y 1 son usados por el escudo de Ethernet) int sensorPin = 2; unsigned long lastConnectionTime = 0; // la última vez que nos conectamos a Cosm const unsigned long connectionInterval = 15000; // retraso entre la conexión a Cosm en milisegundos // Inicializar la biblioteca de Cosm // Definir la cadena para nuestro ID de flujo de datos char sensorId = "POWER"; char sensorId2 = "ENERGÍA"; XivelyDatastream datastreams = {XivelyDatastream (sensorId, strlen (sensorId), DATASTREAM_FLOAT), XivelyDatastream (sensorId2, strlen (sensorId2), DATASTREAM_FLOAT), DATASTREAM_FLOAT),}; // Envuelve el flujo de datos en un feed XivelyFeed feed (FEED_ID, datastreams, 2 / * número de datastreams * /); Cliente EthernetClient; XivelyClient xivelyclient (cliente); configuración vacía () {Serial.begin (9600); Serial.println ("Inicializando red"); while (Ethernet.begin (mac)! = 1) {Serial.println ("Error al obtener la dirección IP a través de DHCP, intentando de nuevo …"); retraso (15000); } Serial.println ("Red inicializada"); Serial.println (); } bucle vacío () {if (millis () - lastConnectionTime> connectionInterval) {sendData (); // enviar datos a xively getData (); // leer el flujo de datos desde xively lastConnectionTime = millis (); // Actualizamos el tiempo de conexión para que esperemos antes de volver a conectarnos}} void sendData () {int sensor1 = watt; int sensor2 = energía; flujos de datos [0].setFloat (sensor1); // flujos de datos de valor de potencia [1].setFloat (sensor2); // valor energético Serial.print ("Leer potencia"); Serial.println (flujos de datos [0].getFloat ()); Serial.print ("Leer energía"); Serial.println (flujos de datos [1].getFloat ()); Serial.println ("Subiendo a Xively"); int ret = xivelyclient.put (alimentación, API_KEY); Serial.print ("Código de retorno PUT:"); Serial.println (ret); Serial.println (); } // obtenemos el valor del flujo de datos de xively, imprimiendo el valor que recibimos void getData () {Serial.println ("Leyendo datos de Xively"); int ret = xivelyclient.get (feed, API_KEY); Serial.print ("OBTENER código de retorno:"); Serial.println (ret); if (ret> 0) {Serial.print ("El flujo de datos es:"); Serial.println (alimentación [0]); Serial.print ("El valor de potencia es:"); Serial.println (alimentar [0].getFloat ()); Serial.print ("El flujo de datos es:"); Serial.println (alimentación [1]); Serial.print ("El valor energético es:"); Serial.println (alimentar [1].getFloat ()); } Serial.println ();

Paso 10: registro de datos en una tarjeta SD

Para almacenar datos en una tarjeta SD, debe importar la biblioteca SD Para obtener un tutorial, haga clic aquí Para saber más sobre la biblioteca SD, haga clic aquí El código para almacenar datos en una tarjeta SD se escribe por separado ya que no tengo suficiente memoria en mi ARDUINO UNO después código de escritura para pantalla LCD y carga de datos xively.com. Pero estoy tratando de mejorar el código de la versión beta para que un solo código pueda contener todas las características (pantalla LCD, carga de datos Xively y almacenamiento de datos en una tarjeta SD). El código para el registro de datos se adjunta a continuación. mejor código modificando mi código por favor comparta conmigo. Este es mi primer instructivo técnico, si alguien encuentra algún error en él, no dude en comentar.. para que yo pueda mejorar. Si encuentra áreas de mejora en este proyecto por favor comente o envíame un mensaje, para que el proyecto sea más poderoso. Creo que será útil tanto para los demás como para mí.

Tercer premio en el concurso 123D Circuits