Medidor de energía doméstico simple Arduino


Michaele Klements nos apunta que para obtener mediciones perfectamente precisas, necesitamos monitorear tanto el voltaje de suministro como la corriente, pero para un monitoreo doméstico simple que brinde estimaciones de costos al mínimo de centavos, ¿por qué no simplificar las cosas?

Entonces, este simple medidor propuesto por Michaele mide la corriente de suministro a su hogar a través de un CT (transformador de corriente) y luego hace un par de cálculos para darle su corriente, potencia, potencia máxima y kilovatios hora consumidos. También es muy fácil agregar su tarifa local y mostrar el costo de la electricidad utilizada hasta la fecha.

Es evidente además que este circuito puede ser la base para volcar los datos a una BBDD o simplemente usando una plataforma de IoT como por ejemplo Cayenne , poder consultas las medidas online , obtener el histórico, realizar acciones correctoras , etc

Los mínimos componentes que necesitará para un medidor de energía doméstico de este tipo son los siguientes:

  • Arduino Uno ( o similar ) 
  • Pantalla LCD (o pantalla LCD-  
  • CT – Talema AC1030
  • Resistencia de carga de 56Ω
  • Condensador de 10 µF
  • 2 resistencias divisoras de 100K

En el siguiente video podemos ver el montaje del circuito así como una pequeña demostración del proyecto en funcionamiento

Cómo hacer el medidor de energía

Primero, debe comenzar ensamblando los componentes en el CT o en su placa de pruebas para crear su sensor actual que produce una señal que su Arduino puede entender. Un Arduino solo tiene entradas de voltaje analógicas que miden 0-5 V CC, por lo que debe convertir la salida de corriente del CT en una referencia de voltaje y luego escalar la referencia de voltaje en un rango de 0-5 V.

Ensamblaje

Si va a instalar su medidor de potencia en algún lugar de forma permanente, es posible que desee soldar las resistencias y el condensador directamente en el TC para que no se suelten. Si simplemente está probando este proyecto por diversión, entonces una placa de pruebas es perfecta.

El circuito básico para la conexión del CT al Arduino se muestra en el siguiente diagrama:

energy-meter-wiring-diagram

A continuación se muestra un diseño de circuito de tablero. Tenga en cuenta que TinkerCAD no es compatible con un transformador de corriente. Por tanto, se ha utilizado un generador de señales para generar una señal de ejemplo:

Arduino home energy meter

El blindaje de la pantalla LCD ya se activa en las entradas analógicas, pero el blindaje solo utiliza A0. Simplemente suelde los tres cables de su sensor de corriente en los encabezados de los pines en el escudo y use A1 como su entrada de sensor como se muestra a continuación.

current-sensor-connections

Una vez que haya conectado todos sus componentes, debe conectar su sensor a lo que desea monitorear. Si desea monitorear un par de aparatos, entonces debe conectar el CT al cable de entrada de un enchufe múltiple, todo lo que conecte al enchufe múltiple luego se contará.

Alternativamente, puede conectar el CT directamente a la red eléctrica de su hogar y monitorear el uso de toda la casa como se ha hecho aquí. De cualquier manera, debe colocar el CT alrededor de uno de los cables de suministro, preferiblemente el cable rojo “vivo”. Asegúrese de ponerlo solo alrededor de 1, ya que no funcionará si está alrededor de ambos y no se puede conectar alrededor del cable de tierra (cable amarillo, verde pelado) ya que la energía no se extrae a través de este cable. Si lo está conectando a la red, conéctelo a uno de los cables de salida después del interruptor principal como se muestra a continuación.

NB: tenga cuidado al conectar el medidor de potencia a la red eléctrica de su hogar y asegúrese de que la alimentación de su placa esté apagada antes de hacer nada en la caja de red. No retire ningún cable ni quite ningún tornillo antes de consultar con su autoridad local, puede requerir que un electricista certificado le instale el CT.

Elegir diferentes componentes

Básicamente, hay cuatro componentes que deben elegirse o dimensionarse correctamente para su medidor de energía.

Elegir un transformador de corriente

El primero es el CT o transformador de corriente. El que se utiliza aquí es el Talema AC1030 que puede detectar una corriente nominal de 30 A y una corriente máxima de 75 A. A 220 VCA, teóricamente puede detectar hasta 16,5 kW durante cortos períodos de tiempo, pero está dimensionado para detectar continuamente 6,6 kW, lo que es adecuado para un hogar pequeño. Para calcular cuántos amperios necesita detectar el suyo, tome la potencia continua máxima que espera detectar y divídala por su voltaje (generalmente 110 V o 220 V según su país).

Dimensionamiento de la resistencia de carga

A continuación, debe dimensionar su resistencia de carga R3, esto convierte su corriente CT en una referencia de voltaje. Comience dividiendo su corriente primaria (el máximo como se usó anteriormente) por la relación de vueltas de su CT (disponible en la hoja de datos). Esto debería estar alrededor de 500-5000 a 1. Este artículo trabajó en 42A con una relación de vueltas de 1000: 1 dando una corriente secundaria de 0.042A o 42mA. Su voltaje de referencia analógica para el Arduino es de 2.5V, por lo que para determinar la resistencia usa R = V / I – R = 2.5 / 0.042 = 59.5Ω. El valor de resistencia estándar más cercano es 56 Ω, por lo que se utilizó este.

Aquí hay algunas opciones en diferentes TC y sus resistencias de carga ideales (en tamaños estándar):

  • Murata 56050C – 10A – 50: 1 – 13Ω
  • Talema AS-103 – 15A – 300: 1 – 51Ω
  • Talema AC-1020 – 20A – 1000: 1 – 130Ω
  • Alttec L01-6215 – 30A – 1000: 1 – 82Ω
  • Alttec L01-6216 – 40A – 1000: 1 – 62Ω
  • Talema ACX-1050 – 50A – 2500: 1 – 130Ω
  • Alttec L01-6218 – 60A – 1000: 1 – 43Ω
  • Talema AC-1060 – 60A – 1000: 1 – 43Ω
  • Alttec L01-6219 – 75A – 1000: 1 – 33Ω
  • Alttec L01-6221 – 150A – 1000: 1 – 18Ω
  • CTYRZCH SCT-013-000 – 100A – Resistencia de carga incorporada – 
  • TOOGOO SCT-013-000 – 100A – 

El condensador utilizado es de 10 µF, que debería ser suficiente para la mayoría de los rangos de TC para aplicaciones domésticas.

Finalmente, necesita dos resistencias divisorias para obtener el voltaje de referencia de 2.5V del Arduino. Deben tener el mismo valor, por lo que R1 = R2 y no necesitamos mucha corriente, por lo que este artículo usa dos resistencias de 100K.

firmware

#include <LiquidCrystal.h>

int currentPin = 1; // Asignar entrada CT al pin 1
doubles kilos= 0;
int PeakPower = 0;
LiquidCrystal lcd (8, 9, 4, 5, 6, 7); // Asignar pines de pantalla LCD, según los requisitos de pantalla LCD

void setup () 
{ 
  lcd.begin (16,2); // columnas filas. utilice 16,2 para una pantalla LCD de 16x2, etc.
  lcd.clear ();
  lcd.setCursor (0,0); // coloca el cursor en la columna 0, fila 0 (la primera fila)
  lcd.print ("En ejecución");
}

void loop () 
{ 
  int actual = 0;
  int maxCurrent = 0;
  int minCurrent = 1000;
  for (int i = 0; i <= 200; i ++) // Supervisa y registra la entrada de corriente durante 200 ciclos para determinar                                                                     la corriente máxima y mínima
  {
    current = analogRead (currentPin); // Lee la entrada actual y registra la corriente máxima y mínima
    if(actual> = maxCurrent)
      maxCurrent = actual;
    else if (actual <= minCurrent)
      minCurrent = actual;
  }
  if (maxCurrent <= 517)
  {
    maxCurrent = 516;
  }
  doble RMSCurrent = ((maxCurrent - 516) * 0,707) /11,8337; // Calcula la corriente RMS según el valor máximo
  int RMSPower = 220 * RMSCurrent; // Calcula la potencia RMS asumiendo un voltaje de 220 VCA, cambie a 110 VCA en consecuencia
  if (RMSPower> peakPower)
  {
    PeakPower = RMSPower;
  }
  kilos = kilos + (RMSPower * (2.05 / 60/60/1000)); // Calcule los kilovatios hora utilizados
  delay (2000);
  lcd.clear ();
  lcd.setCursor (0,0); // Muestra todos los datos actuales
  lcd.print (RMSCurrent);
  lcd.print ("A");
  lcd.setCursor (10,0);
  lcd.print (RMSPower);
  lcd.print ("W");
  lcd.setCursor (0,1);
  lcd.print (kilos);
  lcd.print ("kWh");
  lcd.setCursor (10,1);
  lcd.print (PeakPower);
  lcd.print ("W");
}

Aquí está el enlace para descargar el  código del medidor .

Debido a que su configuración, CT, resistencias y voltaje de entrada pueden ser diferentes, hay un factor de escala en el esquema que deberá cambiar antes de obtener resultados precisos; consulte la calibración a continuación. Si su pantalla LCD está conectada a los mismos pines que se utilizan aquí y su CT está conectado al mismo pin de entrada, al menos debería llenar la pantalla con algunas cifras, aunque lo más probable es que sean incorrectas y algunas pueden ser negativas.

Si no desea usar o no tiene una pantalla LCD, también puede modificar el boceto para enviarlo a la ventana serial del Arduino IDE como se muestra a continuación.

// Michael Klements
// La vida del bricolaje
// 27 de octubre de 2014

int currentPin = 1; // Asignar entrada CT al pin 1
double kilos  = 0;
int PeakPower = 0;

void setup () 
{ 
  Serial.begin (9600); // Iniciar la comunicación en serie
  Serial.println ("En ejecución");
}

void loop () 
{ 
  int actual = 0;
  int maxCurrent = 0;
  int minCurrent = 1000;
  for (int i = 0; i <= 200; i ++) // Supervisa y registra la entrada de corriente durante 200 ciclos para determinar la corriente máxima y mínima
  {
    current = analogRead (currentPin); // Lee la entrada actual y registra la corriente máxima y mínima
    if (actual> = maxCurrent)
      maxCurrent = actual;
    else if (actual <= minCurrent)
      minCurrent = actual;
  }
  if (maxCurrent <= 517)
  {
    maxCurrent = 516;
  }
  double RMSCurrent = ((maxCurrent - 516) * 0,707) /11,8337; // Calcula la corriente RMS según el valor máximo
  int RMSPower = 220 * RMSCurrent; // Calcula la potencia RMS asumiendo un voltaje de 220 VCA, cambie a 110 VCA en consecuencia
  if (RMSPower> peakPower)
  {
    PeakPower = RMSPower;
  }
  kilos = kilos + (RMSPower * (2.05 / 60/60/1000)); // Calcule los kilovatios hora utilizados
  delay (2000);
  Serial.print (RMSCurrent);
  Serial.println ("A");
  Serial.print (RMSPower);
  Serial.println ("W");
  Serial.print (kilos);
  Serial.println ("kWh");
  Serial.print (peakPower);
  Serial.println ("W");
}

Aquí está el enlace para descargar el código de salida serial del medidor .

Actualización de código

El código original del Energy Meter hacía uso de un período de tiempo fijo para calcular los kilovatios hora consumidos, esto se basaba en un tiempo de ciclo de 2050 ms y era bastante preciso.

Desde entonces, el código ha sido modificado para hacer uso de la función millis () incorporada que calcula el tiempo de ciclo exacto para cada ciclo con el fin de mejorar la precisión. Solo mejora alrededor del medio por ciento en la precisión del cálculo, pero es la mejor manera de hacerlo.

Aquí está el código mejorado:

#include <LiquidCrystal.h>

int currentPin = 1; // Asignar entrada CT al pin 1
duobles kilos = 0;
int PeakPower = 0;
unsigned long startMillis;
unsigned long endMillis;
LiquidCrystal lcd (8, 9, 4, 5, 6, 7); // Asignar pines de pantalla LCD, según los requisitos de pantalla LCD

void setup () 
{ 
  lcd.begin (16,2); // columnas filas. utilice 16,2 para una pantalla LCD de 16x2, etc.
  lcd.clear ();
  lcd.setCursor (0,0); // coloca el cursor en la columna 0, fila 0 (la primera fila)
  lcd.print ("Arduino");
  lcd.setCursor (0,1); // coloca el cursor en la columna 0, fila 1 (la segunda fila)
  lcd.print ("Medidor de energía");
  startMillis = millis ();
}

void loop () 
{ 
  int actual = 0;
  int maxCurrent = 0;
  int minCurrent = 1000;
  for (int i = 0; i <= 200; i ++) // Supervisa y registra la entrada de corriente durante 200 ciclos para determinar la corriente máxima y mínima
  {
    current = analogRead (currentPin); // Lee la entrada actual y registra la corriente máxima y mínima
    if (actual> = maxCurrent)
      maxCurrent = actual;
    else if (actual <= minCurrent)
      minCurrent = actual;
  }
  if (maxCurrent <= 517)
  {
    maxCurrent = 516;
  }
  double RMSCurrent = ((maxCurrent - 516) * 0,707) /11,8337; // Calcula la corriente RMS según el valor máximo
  int RMSPower = 220 * RMSCurrent; // Calcula la potencia RMS asumiendo un voltaje de 220 VCA, cambie a 110 VCA en consecuencia
  if (RMSPower> peakPower)
  {
    PeakPower = RMSPower;
  }
  endMillis = millis ();
  tiempo_largo_sin_firmar = endMillis - startMillis;
  kilos = kilos + ((doble) RMSPower * ((doble) tiempo / 60/60/1000000)); // Calcule los kilovatios hora utilizados
  startMillis = millis ();
  delay (2000);
  lcd.clear ();
  lcd.setCursor (0,0); // Muestra todos los datos actuales
  lcd.print (RMSCurrent);
  lcd.print ("A");
  lcd.setCursor (10,0);
  lcd.print (RMSPower);
  lcd.print ("W");
  lcd.setCursor (0,1);
  lcd.print (kilos);
  lcd.print ("kWh");
  lcd.setCursor (10,1);
  lcd.print (PeakPower);
  lcd.print ("W");
}

Aquí está el enlace para descargar el  código actualizado de  Millis Meter .

Para aquellos de ustedes que han leído que la función millis () se desborda después de aproximadamente 49 días, el código trata el rollover automáticamente haciendo uso de la variable larga sin firmar. Por ejemplo, si el desbordamiento ocurre en 10000, el milis inicial fue 9987 y el milis final fue 2031, la diferencia sería 2031-9987 = -7956 pero el valor no puede ser negativo ya que no está firmado, por lo que se convierte en -7956+ 10000 = 2044 que es la duración correcta.

Calibrar la lectura actual

Como se mencionó anteriormente, debido a que su configuración, CT, resistencias y voltaje de entrada pueden ser diferentes, hay un factor de escala en el esquema que deberá cambiar antes de obtener resultados precisos.

Para calibrar su medidor de energía, debe estar seguro de que la corriente que su medidor dice que se está extrayendo es la que espera que realmente se extraiga. Para hacer esto con precisión, necesita encontrar una carga calibrada. Estos no son fáciles de conseguir en un hogar normal, por lo que deberá encontrar algo que use una cantidad de energía establecida y constante. Usé un par de bombillas incandescentes y focos, estos vienen en una variedad de tamaños y su consumo es bastante cercano a lo que se indica en la etiqueta, es decir, una bombilla de 100W usa muy cerca de 100W de potencia real, ya que es casi completamente una carga puramente resistiva.

Enchufe una bombilla pequeña (100 W más o menos) y vea qué carga se muestra. Ahora deberá ajustar los usos del factor de escala en la línea de cálculo:

doble RMSCurrent = ((maxCurrent – 516) * 0,707) / 11,8337

En este caso fue 11.8337, puede ser mayor o menor dependiendo de su aplicación. Utilice una escala lineal para calcular esta cifra o, si no es bueno con las matemáticas, juegue con diferentes valores hasta que la carga que ha conectado se muestre en la pantalla del medidor de energía.

Una vez que haya calibrado su medidor de energía, lo reinicia y deja que haga su trabajo. A continuación se muestran dos imágenes en uso, ambas con una entrada de baja potencia y una entrada de alta potencia.

arduino-energy-meter-low-consumption

El primer número que se muestra es la corriente instantánea seguida de la potencia instantánea. En la línea inferior, los kilovatios hora utilizados desde el reinicio y luego la potencia máxima registrada desde el reinicio.

arduino-energy-meter-high-consumption