Medidor de energia con Arduino


El autor de esta idea perteneze a un pueblo de Odisha, India, donde los cortes de energía frecuentes son muy comunes. Obstaculiza la vida de todos. Durante su de infancia, continuar con los estudios después del anochecer fue un verdadero desafío. Debido a este problema diseño un sistema solar para su casa de forma experimental. Uso un panel solar de 10 Watt, 6V para iluminar algunos LED brillantes. Después de enfrentar muchas dificultades, el proyecto tuvo éxito. Luego decidio 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. Uso 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.

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

Piezas necesarias:

Piezas necesarias:

Potencia y energía

  1. ARDUINO UNO
  2. ARDUINO ETHERNET SHIELD
  3. LCD DE CARACTERES 16×2
  4. SENSOR DE CORRIENTE ACS 712
  5. RESISTENCIAS (10k, 330ohm)
  6. POTENCIOMETRO 10K
  7. CABLES DE PUENTE
  8. CABLE ETHERNET
  9. PANEL DE PAN

Potencia:
potencia es el producto del voltaje (voltios) y la corriente (Amp).P = VxI La unidad de potencia es Watt o KW

Energía:
Energía es producto de la potencia (Watt) y el tiempo (Hora) E = Pxt
Unidad de energía es Watt Hora o Kilovatios 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

Medición de voltaje

Medida 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ño el divisor de voltaje de tal manera que el voltaje de salida debería ser inferior a 5V.Labatería utilizada para almacenar la potencia del panel solar es de 6 V, 5,5 Ah, por lo que tenemps que reducir este 6,5 V a un voltaje inferior a 5 V.
Usaremos 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) se disipa 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 inferior a 5v y adecuado para el pin analógico ARDUINO

NOTA
Hemos mostrado que la batería de 9 voltios en el circuito de la placa desnuda es solo por ejemplo para conectar los cables. Se utiliza una batería de plomo-ácido de 6 voltios y 5,5 Ah.

Calibración de voltaje:
Cuando la batería está completamente cargada (6.5v) obtendremos un Vout = 3.25v y un valor más bajo para otro voltaje de batería más bajo.

ARDUINO 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 del circuito 123D 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 volt
Voltaje real de la batería = (2 * Vout) volt

CÓDIGO ARDUINO:

// tomando 150 muestras del divisor de voltaje con un intervalo de 2seg y luego promediar los datos de muestras

for (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;


Medición de corriente

Medida de corriente
Medida 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 de 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 saber más sobre el sensor de efecto Hall, haga clic aquí.
La hoja de datos del sensor ACS 712 se encuentra aquí.

De la hoja de datos
1. El ACS 712 mide 20 amperios positivos y negativos, correspondientes a la salida analógica 100 mV / A
2. Ninguna corriente de prueba a través del voltaje de salida es 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 Por lo que la lectura analógica 1 = (5/1024) V = 4.89. Valor mv = (4.89 * Valor de lectura analógica) / 1000 V. Pero según las hojas de datos, la compensación es 2.5V (Cuando la corriente es cero, obtendrá 2.5V de la salida del sensor)
Valor real = (valor-2.5) V Corriente en amperios = real valor * 10

CÓDIGO ARDUINO:

// tomar 150 muestras de sensores con un intervalo de 2 segundos y luego promediar los datos de muestras recolectados
for (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;

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 ARDUINO:

milisec largo = milis (); // calcula el tiempo en milisegundos
long time = milisec / 1000; // convierte milisegundos a segundos



Cómo ARDUINO calcula la potencia y la e


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-sec se convierte nuevamente a Watt-Hr dividiendo 1 hora (3600 segundos)
// energía = (vatio * tiempo) / (1000 * 3600); para leer en kWhA

Salida visual

Todos los resultados se pueden visualizar en el monitor en serie o utilizando una pantalla LCD.
Utilicé una pantalla LCD de 16×2 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 -> Arduino GND pin + Resistencia o potenciómetro
4. RS -> Arduino pin 8
5. RW -> Pin 7 de Arduino
6. E -> Pin 6 de 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 aquí

El siguiente código es un formato para mostrar en LCD todo el cálculo de potencia y energía

#include <LiquidCrystal.h>
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ª filalcd.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");
}

Carga de datos a Xively.com

Carga de datos a Xively.com
Carga de datos a Xively.com

Elija un nombre de usuario, contraseña, establezca su dirección 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 correctamente la cuenta, será redirigido a la página de dispositivos de desarrollo .Haga clic en el cuadro + Agregar dispositivo .Dé 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, Feed URL, API End Point (Feed ID se usa en el código ARDUINO)


Agregar canales (elijo ENERGÍA y POTENCIA, pero puede elegir según su elección) Proporcione la unidad y el símbolo para el parámetro·Agrega tu 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 supera un cierto límite)

Código Xively y ARDUINO

Archivos adjuntos

Registro de datos en una tarjeta SD

Para almacenar datos en una tarjeta SD, debe importar la biblioteca SD.


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 de escribir el código para la pantalla LCD y cargar los 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 funciones (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.


/*
  SD card datalogger
 
 This example shows how to log data from three analog sensors 
 to an SD card using the SD library.
 	
 The circuit:
 * SD card attached to SPI bus as follows:
 ** UNO:  MOSI - pin 11, MISO - pin 12, CLK - pin 13, CS - pin 4 (CS pin can be changed)
  and pin #10 (SS) must be an output
 ** Mega:  MOSI - pin 51, MISO - pin 50, CLK - pin 52, CS - pin 4 (CS pin can be changed)
  and pin #52 (SS) must be an output
 ** Leonardo: Connect to hardware SPI via the ICSP header
 		Pin 4 used here for consistency with other Arduino examples
 
original code was created on 24 Nov 2010 and  modified 9 Apr 2012 by Tom Igoe
I (Debasish Dutta) was again modified for my energy monitoring requirement on 14/01/14
podermos 
 
 This example code is in the public domain.
 	 
 */

#include <SD.h>

// On the Ethernet Shield, CS is pin 4. Note that even if it's not
// used as the CS pin, the hardware CS pin (10 on most Arduino boards,
// 53 on the Mega) must be left as an output or the SD library
// functions will not work.
const int chipSelect = 4;

File dataFile;


float sample1=0; // for voltage
float sample2=0; // for current
float voltage=0.0;
float val; // current callibration
float actualval; // read the actual current from ACS 712
float amps=0.0;
float totamps=0.0; 
float avgamps=0.0;
float amphr=0.0;
float watt=0.0;
float energy=0.0; 

void setup()
{
 // Open serial communications and wait for port to open:
  Serial.begin(9600);
   while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }


  Serial.print("Initializing SD card...");
  // make sure that the default chip select pin is set to
  // output, even if you don't use it:
  pinMode(SS, OUTPUT);
  
  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    while (1) ;
  }
  Serial.println("card initialized.");
  
  // Open up the file we're going to log to!
  dataFile = SD.open("energy.txt", FILE_WRITE);
  if (! dataFile) {
    Serial.println("error opening energy.txt");
    // Wait forever since we cant write data
    while (1) ;
  }
}

void loop()

{
   
 long milisec = millis(); // calculate time in milisec
 long time=milisec/1000; // convert time to sec

 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
                      /// taking 150 samples from sensors with a inerval of 2sec and then average the samples data collected
  for(int i=0;i<150;i++)
  {
    sample1+=analogRead(A2);  //read the voltage from the sensor
    sample2+=analogRead(A3); //read the current from sensor
    delay(2);
  }
   sample1=sample1/150; 
   sample2=sample2/150;
   
  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
                                                 /////voltage calculation//////////////////////
  
   voltage=4.669*2*sample1/1000; //  callibration // 3.25 from voltage div is eqv 696 in A0 reading 
                                 // multiply 2 to get actual voltage//  I used two 1k resistor to read 6.36v battery volt
                                 
    //////////////////////////////////////////////// current calculation //////////////////////
 val =(5.0*sample2)/1024.0; 
 actualval =val-2.5; // offset voltage is 2.5v 
 amps =actualval*10;// 10 is multiplied as 100mv/A ( from data sheet )
 totamps=totamps+amps; // total amperes 
 avgamps=totamps/time; // average amperess
 amphr=(avgamps*time);  // ampere hour
 watt =voltage*amps;    // power=voltage*current
 energy=(watt*time)/3600;      // energy = power*timein Watt-sec ///again convert to Watt-Hr by dividing 3600sec
 
  ////////////////////////////////////////////////////////
  // make a string for assembling the data to log:
String dataString = "";
int parameter[4]={voltage,amps,watt,energy}; // here parameters are power,energy,watt-hour and current
  // read 4 parameters and append to the string:
  for (int i = 0; i < 4; i++) 
  {
    int sensor = parameter[i];
    dataString += String(sensor);
    if (i < 4) 
    {
      dataString += ","; 
    }
  }

  dataFile.println(dataString);

  // print to the serial port too:
  Serial.println(dataString);
  
  // The following line will 'save' the file to the SD card after every
  // line of data - this will use more power and slow down how much data
  // you can read but it's safer! 
  // If you want to speed up the system, remove the call to flush() and it
  // will save the file only every 512 bytes - every time a sector on the 
  // SD card is filled with data.
  dataFile.flush();
  
  // Take 1 measurement every 500 milliseconds
  delay(500);
}





Fuente https://www.instructables.com/ARDUINO-ENERGY-METER/