Aplicaciones del SCT-013


 El sensor SCT-013 es un sensor de corriente no invasivo cuya principal utilidad es medir la intensidad en corriente alterna que atraviesa un conductor sin necesidad de interconectarlo en serie. Podemos emplear estos sensores con un microcontrolador como Arduino para medir la intensidad o potencia consumida por una carga.

Una de las ventajas más interesantes es su precio, pero sin duda  otra facilidad innegable es que no tenemos que manipular el cable ya que se trata de un sensor de corriente alterna no invasivo.

La precisión del sensor puede ser de 1-2%, pero para ello es muy importante que el núcleo ferromagnético se cierre adecuadamente. Hasta un pequeño hueco de aire puede introducir desviaciones del 10%.

Como desventaja, al ser una carga inductiva, el SCT-013 introduce una variación del ángulo de fase cuyo valor es función de la carga que lo atraviesa, pudiendo llegar a ser de hasta 3º.

SCT-013 principio de funcionamiento

Un factor importante dentro de los transformadores de corriente es el número de espiras o número de vueltas que da el cable al núcleo ferromagnético. Conociendo estos datos y la corriente que circula por uno de los devanados podemos calcular la corriente por el otro devanado.

Esto es debido a que guardan la siguiente relación:

\frac{N_p}{N_s}=\frac{I_s}{I_p}=\frac{V_p}{V_s}

A esta fórmula se le llama relación de transformación porque relaciona el número de espiras del primario (Np), del secundario (Ns), las intensidades del primario (Ip), del secundario (Is), el voltaje del primario (Vp) y del secundario (Vs).

En el caso del sensor de corriente alterna SCT-013 el devanado primario es el cable del aparato que queremos medir y el número de vueltas sería uno. El devanado secundario tiene 2.000 vueltas.

Si aplicamos la relación de transformación a esta situación y suponiendo que queremos medir una intensidad de 10 Amperios, el resultado sería el siguiente.

\frac{N_p}{N_s}=\frac{I_s}{I_p}\Rightarrow I_s=\frac{N_p\times I_p}{N_s}=\frac{1\times 10}{2000}=0,005 A

Como se puede comprobar se produce una transformación de energía pues hemos bajado de 10 A (imposible de medir esta corriente con Arduino) hasta los 0,005 A

Ahora nos faltaría conocer cómo medir la intensidad con Arduino a través de una resistencia de carga o resistencia burden (su función es convertir la corriente en un voltaje limitado que podamos medir, por ejemplo, con Arduino.).

Pero antes de meternos en ello, vamos a ver los tipos de sensores de corriente alterna SCT-013 que podemos encontrar.

Podemos comprar diferentes tipos de sensores de corriente alterna SCT-013 que se pueden organizar en dos grupos. Los que proporcionan una corriente o los que proporcionan un voltaje. La gran diferencia entre ellos es que en los primeros no viene incluida una resistencia de carga y en los segundos sí. Solo el SCT-013-000 es que nos proporciona una corriente y no tiene resistencia de carga. pudiendo medir una corriente de entre 50 mA y 100 A.

El resto de la familia de sensores SCT-013 si que tienen incluida la resistencia de carga. Podemos encontrar varios modelos pero todos tienen un voltaje de salida entre 0V y 1V y por tanto elegir uno u otro sensor SCT-013 dependerá de las necesidades según la intensidad de corriente del circuito a medir.

Con Arduino y otra placas como NodeMCU, solo podemos medir voltajes. Si además ese voltaje varía entre un mínimo y un máximo, solo podremos hacerlo a través de una entrada analógica. Por otro lado, en estos cálculos debemos conocer el consumo aproximado del aparato que vamos a medir. Esto nos permitirá ajustar la precisión. El SCT-013-000 puede medir desde 50 mA hasta los 100 A. El objetivo de calcular la resistencia de carga es obtener un valor de resistencia que nos permita leer el voltaje de la corriente que pasa por el sensor SCT-013-000. Debemos de conseguir la máxima resolución posible y para ello debemos conocer la potencia aproximada del aparato o electrodoméstico que vamos a medir.

El consumo aproximado en vatios deberemos sacarlo de las características técnicas del electrodoméstico o aparato que quiera medir. Como ejemplo hagamos los calculos para una carga de 1kw :

  • Calculo de la corriente :Para una carga de 1kw hacemos los cálculos para 1.000W y un voltaje típico, 220V, calculamos la corriente.
P=V\times I_{RMS}\Rightarrow I_{RMS}=\frac{P}{V}=\frac{1000}{220}=4,54A
  • Convertir la corriente máxima eficaz en corriente de pico.La corriente que hemos obtenido en el paso anterior es corriente eficaz. Ahora hay que convertirla en corriente de pico con la siguiente fórmula.
I_{RMS}=\frac{I_{pico}}{\sqrt{2}}\Rightarrow I_{pico}=I_{RMS}\times \sqrt{2}=4,54\times \sqrt{2}=6,42A
  • Calcular la corriente de pico en el devanado secundario. Con la fórmula de relación de transformación que hemos visto antes, podemos calcular la corriente de pico en el devanado secundario.
\frac{N_p}{N_s}=\frac{I_s}{I_p}\Rightarrow I_s=\frac{N_p\times I_p}{N_s}=\frac{1\times 6,42}{2000}=0,00321 A
  • Maximizar la resolución con el máximo valor de la entrada analógica.En este punto entra en juego la placa que estés utilizando ya que depende de cada placa la referencia interna de la entrada analógica. Esta referencia se llama AREF y nos informa del voltaje máximo que podemos medir en una entrada analógica. Por ejemplo, NodeMCU y Arduino MKR1000 utilizan 3,3V y Arduino UNO utiliza 5V. En este ejemplo vamos a utilizar el AREF de Arduino UNO, 5V. La idea es aplicar la Ley de Ohm pero utilizando la mitad de voltaje. Lo que hemos hecho en los pasos anteriores es calcular la corriente de pico lo que significa que todavía tenemos una onda sinusoidal que varía de positivo a negativo. El objetivo es ajustar la resistencia para que se cumpla la Ley de Ohm y tengamos un voltaje entre 2,5V y -2,5V ya que la corriente la tenemos fija. Por eso, como veremos ahora en la fórmula, debemos dividir AREF entre dos.
R_{carga}=\frac{\frac{AREF}{2}}{I_{pico}}=\frac{\frac{5}{2}}{0,00321}=778\Omega
  • Obteniendo un valor coherente para la resistencia de carga.El valor que nos ha dado para la resistencia de carga es de 778Ω. Este valor no es un valor que podamos encontrar fácilmente. Por eso debemos utilizar varias resistencias en serie que sean más comunes para conseguir un valor aproximado .También se podría hacer con resistencias en paralelo: por ejemplo, podemos poner en serie dos resistencias de 330Ω y una de 100Ω. Esto nos daría un valor de 760Ω más o menos aproximado al que habíamos calculado. Siempre que lo hagas quédate por debajo del valor calculado. Esto evitará que nos salgamos del límite de voltaje establecido por AREF ya que podemos llegar a dañar la placa de desarrollo con el sensor SCT-013.

RESUMEN: Excepto el modelo SCT-013-100, todos los demás modelos tienen una resistencia de burden interna para que la salida sea una señal de tensión de 1V, por lo tanto si elegimos el adecuado ni siquiera tendremos que preocuparnos por ello. Únicamente en el caso del SCT-013-100, carece de resistencia burden interna, por lo que la salida es una señal de ±50mA aunque a efectos prácticos una resistencia de 33Ω en paralelo con el sensor será suficiente.

Offset

En la resistencia de carga vamos a tener un voltaje que varía de 2,5V a -2,5V que sigue siendo una señal sinusoidal por lo que el problema que existe es que ni Arduino ni NodeMCU leen voltajes negativos. Así que tenemos que modificar la señal para que pase a estar en el rango de 0V a 5V.

Eso se hace añadiendo un offset en DC a nuestra señal bastando con sumar 2,5V y estaría resuelto. Esto lo haremos a través de un circuito conocido como circuito offset en DC que básicamente consiste en poner un divisor de tensión y un condensador. El condensador tiene que ser de 10μF y unos pocos cientos de voltios. Esto hace que la reactancia sea baja y la corriente alterna evite la resistencia.

El valor de las resistencias del divisor de tensión puede ser 10kΩ siempre y cuando lo alimentemos a través de la red eléctrica. Si su dispositivo va a funcionar con pilas utilize unas resistencias de 470kΩ para que el consumo sea mínimo.

El circuito

Con todo lo que hemos visto, ya podemos montar el circuito eléctrico donde conectemos el SCT-013 y Arduino.

Antes de ver como conectar los componentes vamos a echar un vistazo al conector que viene incluido en toda la familia SCT-013. Se trata del típico conector de audio que tenemos en todos los auriculares, conocido como jack. Cada tipo de jack hembra es diferente. Deberemos investigar como se hacen las conexiones o bien cortar el cable; encontrará dos cables, uno rojo y otro blanco. Estos colores pueden variar dependiendo del fabricante y del modelo.

En el siguiente esquema vemos el montaje del circuito de offset y la resistencia de carga con un sensor SCR-013-000. Obviamente si usamos otro sensor podemos eliminar la resistencia de carga , y por tanto haciendo mas sencillo el circuito al estar dicha resistencia integrada y calibrada en el propio sensor

SCT-013 ARDUINO-UNO

Por último vamos a ver cómo tenemos que abrazar los cables de alta tensión con el sensor de corriente alterna SCT-013. No vale de cualquier forma, hay que hacerlo de una manera determinada ya que de lo contrario, no estaremos midiendo correctamente el consumo.

Lo más importante es que tenemos que abrazar solo uno de estos cables, en caso contrario la medición será cero. Esto es debido a que por uno de los cables la corriente fluye en un sentido y por el otro cable fluye en sentido contrario. Si abrazamos los dos cables un flujo magnético compensará al otro flujo magnético y se anulará.

Es importante utilizar cables de buena calidad. Por tu seguridad y para conseguir una buena precisión.

Seguramente encuentre tres cables cuando quites la funda que cubre todo. Los colores de la fase suelen ser azul o negro y para el neutro marrón. En uno de estos cables es donde tienes que abrazar el sensor SCT-013(no el de masa) . El tercer cable suele ser de color verde y amarillo y sirve para la toma de tierra por lo que no daría ninguna lectura en caso de abrazar este cable.

Calibración del sensor de corriente alterna SCT-013

Debemos partir del concepto de que nuestros aparatos no son perfectos. Es imposible fabricar cualquier cosa con absoluta precisión. Hay una relación directamente proporcional (incluso exponencial) entre precisión y precio. Cuanto más preciso más caro es el aparato.

Hay tres factores importantes a tener en cuenta y que influyen en la precisión (fuente Open Energy Monitor):

  • La relación de transferencia del transformador
  • El valor de la resistencia de carga y su tolerancia
  • La precisión del ADC a la hora de medir el voltaje en la resistencia de carga

La idea es empezar con la teórica y luego corregir ese valor con la fase experimental. Mucho ojo en la parte experimental. Vamos a trabajar con alto voltaje y puede ser muy peligroso. SI NO ESTÁ SEGURO NO HAGA LA PARTE EXPERIMENTAL.

Proceso de calibración

El proceso de calibración es sencillo. Solo tenemos que aplicar la siguiente fórmula.

F_{calibracion}=\frac{\frac{I_{2RMS}}{I_{1RMS}}}{R_{carga}}

Lo que hacemos es calcular el factor de calibración dividiendo el factor de transformación (corriente máxima eficaz dividida entre la corriente mínima eficaz) entre la resistencia de carga.

El valor que nos da sería el valor que tenemos que poner en el sketch del SCT-013. Si sustituimos los valores para la resistencia de carga que hemos calculado quedaría de la siguiente manera.

F_{calibracion}=\frac{\frac{I_{2RMS}}{I_{1RMS}}}{R_{carga}}=\frac{\frac{100}{0.05}}{760}=2,63

Este sería el valor teórico. Ya tendríamos algo por donde empezar. Para asegurarnos de que realmente este factor de calibración es bueno sería interesante conectar un aparato del cual sepamos su consumo aproximado.Por ejemplo, podemos utilizar una bombilla incandescente. Se recomienda una con bastante potencia para no perder resolución. El sensor SCT-013 nos dará una resolución de 2 decimales por lo tanto, si queremos calibrar bien este sensor debemos utilizar un aparato que consuma más de 20W.

A efectos prácticos tenemos que medir la corriente real con la corriente que está dando el sensor SCT-013 para lo cual podemos usar diferentes métodos.

  • Midiendo el voltaje de la red eléctrica :Para medir el voltaje necesitarás un multímetro. Lo primero es configurar el aparato correctamente. Tienes que seleccionar voltaje en alterna y el rango correspondiente a 220V. Además tienes que conectar el cable rojo (suele ser de este color) en voltios y el cable negro en COM. Una vez configurado debes meter las dos puntas en un enchufe. Cada una en un agujero. Da lo mismo en que agujero metas la punta. La diferencia es que te dará o positivo o negativo. Esto te dará un valor de voltaje y es el que tienes que apuntar y actualizar en el sketch.Las mediciones en este punto dependen mucho de la calidad del multímetro. Este es otro caso claro donde el precio tiene que ver mucho con la precisión.
  • Midiendo la corriente alterna con el multímetro: La corriente es algo más complicado ya que tenemos que cortar el cable y poner el mutímetro en serie con el cable, como si fuera una resistencia. En estos casos es interesante tener una clema, bornera o ficha de empalme. Eso sí, que soporte la corriente que va a pasar por la bornera. No pongas una de electrónica porque puedes dañar la instalación. Antes de nada vamos a ver cómo configurar el multímetro para medir una corriente alterna. Es diferente a la configuración de voltaje en alterna. Es importante que también tengas conectado el sensor de corriente alterna SCT-013 para poder comparar una medida y otra. Cuando mido con el multímetro obtengo el siguiente resultado. ida de 0,33A. Si hacemos los cálculos para obtener la potencia se obtiene lo siguiente P=V x I=230v x 0,33a=75,9w. Con los datos obtenidos anteriormente donde teníamos una potencia de unos 120W, comprobamos que este factor de calibración hay que ajustarlo. Por lo tanto, el factor de calibración está mal. Hay que corregirlo. Pero ahora que tenemos los datos experimentales resulta sencillo. Si el valor obtenido a través del sensor de corriente alterna SCT-013 es mayor, baja el factor de corrección. Ajusta dicho valor hasta conseguir un dato aproximado al que has obtenido en el multímetro. Solo es cuestión de ir modificando y cargando el código en la placa hasta que tener un valor correcto. No te olvides de modificar también el valor del voltaje obtenido. Al final con un factor de calibración de 1.6 y un voltaje de 230V consigo ajustarme a la corriente que nos mostraba el multímetro.

Código final para obtener la potencia con el sensor SCT-013

Gracias a Emonlib no tenemos que hacer cálculos complejos pues podemos ayudarnos en esta tarea de una librería. En concreto vamos a utilizar Emonlib creado por el proyecto Open Energy Monitor. Open Energy Monitor es un proyecto que nos proporciona diferente hardware para medir el consumo en multitud de dispositivos y aparatos. Han creado sus propias placas compatibles con Arduino. Para inlcuir esta libreria Abra el gestor de librería y busque Emonlib. También puede descargarlo desde el repositorio en GitHub.Con unas pocas líneas de código obtendremos de una forma muy sencilla la potencia que está consumiendo el aparato. Lo primero es el voltaje de tu red eléctrica.

En la función setup() iniciamos la comunicación serie para poder mostrar los datos a través del monitor serie.

Luego iniciamos el objeto que hemos creado de la clase EnergyMonitor con la función current(pinAnalogico, factorCalibracion). Esta función admite dos parámetros:

  • pinAnalogico: es el pin analógico donde hemos conectado el sensor de corriente alterna SCT-013.
  • factorCalibracion: es un valor que tenemos que calcular para corregir errores de diferentes tipos como la tolerancia de la resistencia de carga o del propio sensor SCT-013.

El pin analógico no tiene duda. Según el esquema mostrado más arriba vamos a utilizar el A0 así que pasamos como argumento un 0. El factor de corrección de momento lo dejamos a 2,6. En el siguiente apartado veremos como se calcula.

Por último en la función loop() obtenemos la corriente eficaz llamando a la función calcIrms(numMuestras). Esta función admite un parámetro:

  • numMuestras: indica cuantas muestras tiene que tomar para calcular la corriente eficaz.

El número de muestras es importante. Como hemos estado hablando a lo largo de todo este artículo, estamos trabajando con una señal sinusoidal. Esto quiere decir que tiene ciclos que se van repitiendo en el tiempo.

El número de muestras indica el número de veces que se va a leer la señal para obtener el valor de la corriente eficaz. Es interesante que estas muestras sean en ciclos completos. Según la velocidad de acceso a los pines analógicos con Arduino UNO, aproximadamente podemos medir 106 muestras en cada ciclo. Si está utilizando otro microcontrolador este valor puede variar.

Si queremos medir 14 ciclos (un valor recomendado por el proyecto Open Energy Monitor), tendremos que medir 14\times 106 = 1484 muestras . De aquí viene el valor que se pasa a la función calcIrms().

Por último mostramos toda esta información a través del monitor serie.

// Include Emon Library
#include "EmonLib.h"
 
// Crear una instancia EnergyMonitor
EnergyMonitor energyMonitor;
 
// Voltaje de nuestra red eléctrica
float voltajeRed = 230.0;
 
void setup()
{
  Serial.begin(9600);
 
  // Iniciamos la clase indicando
  // Número de pin: donde tenemos conectado el SCT-013
  // Valor de calibración: valor obtenido de la calibración teórica
  energyMonitor.current(0, 1.6);
}
 
void loop()
{
  // Obtenemos el valor de la corriente eficaz
  // Pasamos el número de muestras que queremos tomar
  double Irms = energyMonitor.calcIrms(1484);
 
  // Calculamos la potencia aparente
  double potencia =  Irms * voltajeRed;
 
  // Mostramos la información por el monitor serie
  Serial.print("Potencia = ");
  Serial.print(potencia);
  Serial.print("    Irms = ");
  Serial.println(Irms);
}

Si no deseamos usar la librería también podemos realizar los cálculos internos nosotros mismos, si bien el código ahora ya no queda tan claro como la version anterior:

const float FACTOR = 30; //30A/1V

const float VMIN = 1.08;
const float VMAX = 3.92;

const float ADCV = 5.0;  //Para Vcc
//const float ADCV = 1.1; //Para referencia interna  


void setup()
{
   Serial.begin(9600);
   //analogReference(INTERNAL);
}

void printMeasure(String prefix, float value, String postfix)
{
   Serial.print(prefix);
   Serial.print(value, 3);
   Serial.println(postfix);
}

void loop()
{
   float currentRMS = getCorriente();
   float power = 230.0 * currentRMS;

   printMeasure("Irms: ", currentRMS, "A ,");
   printMeasure("Potencia: ", power, "W");
   delay(1000);
}

float getCorriente()
{
   float voltage;
   float corriente;
   float sum = 0;
   long tiempo = millis();
   int counter = 0;

   while (millis() - tiempo < 500)
   {
      voltage = analogRead(A0) * ADCV / 1023.0;
      corriente = fmap(voltage, VMIN, VMAX, -FACTOR, FACTOR);

      sum += sq(corriente);
      counter = counter + 1;
      delay(1);
   }

   corriente = sqrt(sum / counter);
   return(corriente);
}

// cambio de escala entre floats
float fmap(float x, float in_min, float in_max, float out_min, float out_max)
{
 return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

Mejora

Añadir un ADC con entrada diferencial, nos permite realizar mediciones de tensiones positivas y negativas, como el ADS1115. Esta es la opción que vamos a comentar como mejora.

  •  Este convertidor analógico digital tiene una resolución de 16 bits y una interfaz I2C para un control cómodo.
  • El módulo es adecuado para todos los microcontroladores actuales con 2.0V – 5.5V, el uso con Raspberry es posible sin problemas.
  • La frecuencia de muestro del módulo es programable hasta 860/s.
  • Gracias a la PGA interna, es posible amplificar hasta 16 veces la señal analógica.

Ajustando la ganancia del ADS1115 a 2.048V estaremos dentro del rango de ±1.414V. En el caso de un sensor de 30A tendremos una precisión de 1.87mA, y 6,25 mA para un sensor de 100A.

Si usáis un SCT-013-100 con salida de ±50mA, tendremos que añadir una resistencia burden externa de 33Ω y subir la ganancia del ADS1115 a 4.096V para cumplir con el rango de ±2.33V.

Si no queréis usar un ADC externo, podéis usar la solución más convencional, que es añadir un circuito que nos permita añadir un offset central como vimos al principio del post.

Si habéis usado el montaje con un SCT-013 con salida de ±1V RMS y ADS1115, el código necesario es similar al que vimos en la entrada sobre el ADS1115. Necesitarémios la librería de Adafruit para el ADS1115.

Para que el ADS1115 muestree a una velocidad superior, deberemos modificar la siguiente línea del fichero ‘Adafruit_ADS1015.h’

#define ADS1115_CONVERSIONDELAY

Por,

#define ADS1115_CONVERSIONDELAY

Con esto conseguiremos bajar el tiempo de muestreo de unos 8-9 ms (unos 100 Hz) a 1.8 aprox (unos 500 Hz). Con eso nos alejamos de la frecuencia de Nyquist, y mejoramos el comportamiento de la medición.

#include <Wire.h>
#include <Adafruit_ADS1015.h>
 
Adafruit_ADS1115 ads;
  
const float FACTOR = 30; //30A/1V

const float multiplier = 0.0625F;
 
void setup()
{
  Serial.begin(9600);
 
  ads.setGain(GAIN_TWO);        // ±2.048V  1 bit = 0.0625mV
  ads.begin();
}

void printMeasure(String prefix, float value, String postfix)
{
 Serial.print(prefix);
 Serial.print(value, 3);
 Serial.println(postfix);
}
 
void loop()
{
 float currentRMS = getCorriente();
 float power = 230.0 * currentRMS;
 
 printMeasure("Irms: ", currentRMS, "A ,");
 printMeasure("Potencia: ", power, "W");
 delay(1000);
}
 
float getCorriente()
{
 float voltage;
 float corriente;
 float sum = 0;
 long tiempo = millis();
 int counter = 0;
 
 while (millis() - tiempo < 1000)
 {
   voltage = ads.readADC_Differential_0_1() * multiplier;
   corriente = voltage * FACTOR;
   corriente /= 1000.0;
 
   sum += sq(corriente);
   counter = counter + 1;
  }
 
 corriente = sqrt(sum / counter);
 return(corriente);
}

Otra versión es emplear el máximo y el mínimo de la medición, y calcular la medición a partir del valor de pico. Los resultados deberían ser similares a los vistos en el ejemplo con la suma al cuadrado. Para ello, podéis sustituir la función por la siguiente.

float getCorriente()
{
 long tiempo = millis();
 long rawAdc = ads.readADC_Differential_0_1();
 long minRaw = rawAdc;
 long maxRaw = rawAdc;
 while (millis() - tiempo < 1000)
 {
   rawAdc = ads.readADC_Differential_0_1();
   maxRaw = maxRaw > rawAdc ? maxRaw : rawAdc;
   minRaw = minRaw < rawAdc ? minRaw : rawAdc;
 }

  maxRaw = maxRaw > -minRaw ? maxRaw : -minRaw;
  float voltagePeak = maxRaw * multiplier / 1000;
  float voltageRMS = voltagePeak * 0.70710678118;
  float currentRMS = voltageRMS * FACTOR;
  return(currentRMS);
}

Otros sensores diferentes al SCT-013

Aunque depende mucho de las necesidades del aparato que quieras medir, estos sensores invasivos (debes alterar el cable que conecta el aparato) pueden ser una buena alternativa.

  • Interruptor Sonoff WiFi y medidor de corriente de Itead
  • ACS712
  • Pololu ACS714

Cualquiera de estos sensores puede hacer la misma función. Solo tendrás que elegir aquel que se amolde mejor a las necesidades de corriente.

Fuentes: https://adafruit.com, http:// opennergymonitor.com, http:// luisllamas.es,http:// programarfacil.es

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/







Instalación del Nilmtk


EL NILM o Non-Intrusive Load Monitoring, es decir la desagregación no intrusiva de la demanda . es una técnica computacional para la estimación del consumo individual de diversos dispositivos utilizando para ello la lectura agregada de un único medidor de energía (Smart Meter, SM).

Gracias a las ventajas en cuanto instalación , coste e implementación, éste concepto ha tomado relevancia en los últimos años en el ámbito de las Smart Grids, al aportar una estimación de los hábitos de consumo de los clientes sin la necesidad de un despliegue masivo de contadores inteligentes en cada punto de consumo.

Tal es el interés por esta técnica que desde el 2010 , el número de publicaciones científicas referentes al NILM se ha incrementado exponencialmente sin duda condicionado por los beneficios de esta técnica en el marco de las redes inteligentes de energía como por ejemplo la posibilidad de generar facturas de electricidad que muestren en detalle el consumo de los electrodomésticos utilizando solamente las lecturas de un SM

Asimismo, existen aplicaciones de Energy Management System (EMS) en conjunto con NILM, las cuales pueden ser compatible con los programas de respuesta a la demanda o Demand Response (DR) de las compañías de electricidad.

Por otro lado, algunos plantean la posibilidad de usar NILM para detectar averías en los dispositivos cuando se presenta un comportamiento anómalo en las mediciones desagregadas.
Es así como NILM se presenta como una valiosa herramienta para reducir el consumo de energía, tanto así que algunos afirman que es el “santo grial de la eficiencia energética”.

En este contexto vamos a ver una herramienta o toolkit open software llamado NILMTK que nos va a ayudar a comparar algoritmos para implementar la desagregación ( ademas particularmente no contempla un uso diferente a este)

Para el análisis de la desagregación , necesitamos recolectar datos del consumo centralizado , lo cual nos va permitir a creación de un nuevo dataset el cual puede ser analizado usando las funciones de NILMTK lo que permite, por ejemplo, visualizar los datos de potencia en un determinado periodo u obtener estadísticas de energía del dataset.

Posteriormente, en la etapa de preprocesamiento se toman decisiones en línea con los análisis realizados, con el objetivo de preparar correctamente los datos para del entrenamiento de los modelos de desagregación. Básicamente, el entrenamiento de un modelo consiste en enseñarle a reconocer por separado las características de los dispositivos para luego identificarlos dentro de una señal agregada. El entrenamiento contempla el uso de los algoritmos Combinatorial Optimization (CO) y Factorial Hidden Markov Model (FHMM).

HDF5

HDF5 es un formato de datos jerárquico que se usar en el NILMTK como fuente datos basado en HDF4 y NetCDF (otros dos formatos de datos jerárquicos).El formato de datos jerárquico, versión 5 (HDF5), es un formato de archivo de código abierto que admite datos grandes, complejos y heterogéneos. HDF5 utiliza una estructura similar a un “directorio de archivos” que le permite organizar los datos dentro del archivo de muchas formas estructuradas diferentes, como lo haría con los archivos en su computadora. El formato HDF5 también permite la incrustación de metadatos, lo que lo hace autodescriptivo .

Las organizaciones utilizan HDF5 para diversas necesidades de datos, acceso, informática y redes.

Estructura jerárquica: un directorio de archivos dentro de un archivo

El formato HDF5 se puede considerar como un sistema de archivos contenido y descrito en un solo archivo. Piense en los archivos y carpetas almacenados en su computadora. Es posible que tenga un directorio de datos con algunos datos de temperatura para varios sitios de campo. Estos datos de temperatura se recopilan cada minuto y se resumen cada hora, día y semana. Dentro de un archivo HDF5, puede almacenar un conjunto de datos similar organizado de la misma manera que podría organizar archivos y carpetas en su computadora. Sin embargo, en un archivo HDF5, lo que llamamos “directorios” o “carpetas” en nuestras computadoras, se llaman groupsy lo que llamamos archivos en nuestra computadora datasets.

2 Términos importantes de HDF5

  • Grupo: un elemento similar a una carpeta dentro de un archivo HDF5 que puede contener otros grupos O conjuntos de datos dentro de él.
  • Conjunto de datos: los datos reales contenidos en el archivo HDF5. Los conjuntos de datos se almacenan a menudo (pero no es necesario) dentro de grupos en el archivo.
Una ilustración de una estructura de archivo HDF5 que contiene grupos, conjuntos de datos y metadatos asociados
Un ejemplo de estructura de archivo HDF5 que contiene grupos, conjuntos de datos y metadatos asociados.

Un archivo HDF5 que contiene conjuntos de datos podría estructurarse así:

La ilustración HDF5 de arriba, pero los grupos son sitios NEON y los tipos de sensores y conjuntos de datos se incluyen en los tipos de sensores.
Un ejemplo de estructura de archivo HDF5 que contiene datos para varios sitios de campo y también contiene varios conjuntos de datos (promediados en diferentes intervalos de tiempo).

HDF5 es un formato autodescriptivo

El formato HDF5 es autodescriptivo. Esto significa que cada archivo, grupo y conjunto de datos puede tener metadatos asociados que describen exactamente cuáles son los datos. Siguiendo el ejemplo anterior, podemos incrustar información sobre cada sitio en el archivo, como por ejemplo:

  • El nombre completo y la ubicación X, Y del sitio.
  • Descripción del sitio.
  • Cualquier documentación de interés.

De manera similar, podríamos agregar información sobre cómo se recopilaron los datos en el conjunto de datos, como descripciones del sensor utilizado para recopilar los datos de temperatura. También podemos adjuntar información, a cada conjunto de datos dentro del grupo de sitios, sobre cómo se realizó el promedio y durante qué período de tiempo están disponibles los datos.

Un beneficio clave de tener metadatos adjuntos a cada archivo, grupo y conjunto de datos es que esto facilita la automatización sin la necesidad de un documento de metadatos separado (y adicional). Usando un lenguaje de programación, como R o Python, podemos obtener información de los metadatos que ya están asociados con el conjunto de datos y que podríamos necesitar para procesar el conjunto de datos.

Una ilustración de una estructura de archivos HDF5 con un grupo que contiene dos conjuntos de datos y todos los metadatos asociados
Los archivos HDF5 son autodescriptivos, lo que significa que todos los elementos (el archivo en sí, los grupos y los conjuntos de datos) pueden tener metadatos asociados que describen la información contenida en el elemento.

Subconjunto comprimido y eficiente

El formato HDF5 es un formato comprimido. El tamaño de todos los datos contenidos en HDF5 está optimizado, lo que reduce el tamaño general del archivo. Sin embargo, incluso cuando están comprimidos, los archivos HDF5 a menudo contienen grandes volúmenes de datos y, por lo tanto, pueden ser bastante grandes. Un atributo poderoso de HDF5 es data slicingmediante el cual se puede extraer un subconjunto particular de un conjunto de datos para su procesamiento. Esto significa que no es necesario leer el conjunto de datos completo en la memoria (RAM); muy útil para permitirnos trabajar de manera más eficiente con conjuntos de datos muy grandes (gigabytes o más).

Almacenamiento de datos heterogéneos

Los archivos HDF5 pueden almacenar muchos tipos diferentes de datos dentro del mismo archivo. Por ejemplo, un grupo puede contener un conjunto de conjuntos de datos para contener datos enteros (numéricos) y de texto (cadenas). O bien, un conjunto de datos puede contener tipos de datos heterogéneos (por ejemplo, tanto texto como datos numéricos en un conjunto de datos). Esto significa que HDF5 puede almacenar cualquiera de los siguientes (y más) en un archivo:

  • Datos de temperatura, precipitación y PAR (radiación fotosintética activa) para un sitio o para muchos sitios
  • Un conjunto de imágenes que cubren una o más áreas (cada imagen puede tener asociada información espacial específica, todo en el mismo archivo)
  • Un conjunto de datos espaciales multi o hiperespectral que contiene cientos de bandas.
  • Datos de campo para varios sitios que caracterizan insectos, mamíferos, vegetación y clima.
  • Un conjunto de imágenes que cubren una o más áreas (cada imagen puede tener asociada información espacial única)
  • ¡Y mucho más!

Formato abierto

El formato HDF5 es abierto y de uso gratuito. Las bibliotecas de apoyo (y un visor gratuito) se pueden descargar desde el sitio web de HDF Group . Como tal, HDF5 es ampliamente compatible con una gran cantidad de programas, incluidos lenguajes de programación de código abierto como R y Python, y herramientas de programación comerciales como Matlaby IDL. Los datos espaciales que se almacenan en formato HDF5 se pueden utilizar en los programas de SIG y de imagen que incluyen QGIS, ArcGISy ENVI.

Beneficios de HDF5

  • Autodescripción Los conjuntos de datos con un archivo HDF5 son autodescriptivos. Esto nos permite extraer metadatos de manera eficiente sin necesidad de un documento de metadatos adicional.
  • Admite datos heterogéneos : un archivo HDF5 puede contener diferentes tipos de conjuntos de datos.
  • Admite datos grandes y complejos : HDF5 es un formato comprimido que está diseñado para admitir conjuntos de datos grandes, heterogéneos y complejos.
  • Admite la división de datos: la “división de datos”, o la extracción de partes del conjunto de datos según sea necesario para el análisis, significa que los archivos grandes no necesitan leerse por completo en la memoria o RAM de la computadora.
  • Formato abierto: soporte amplio en las muchas herramientas : debido a que el formato HDF5 es abierto, es compatible con una gran cantidad de lenguajes y herramientas de programación, incluidos lenguajes de código abierto como R y Pythonherramientas SIG abiertas como QGIS.E

Instalación del NILTK

Descargue e instale Conda

Los entornos virtuales hacen que la organización de paquetes de Python sea pan comido. Además, el proyecto NILMTK ofrece varias versiones de Conda Forge. Primero, consiga Anaconda aquí. Luego, abra una ventana de terminal e inicie la instalación desde la línea de comando:

Dowloads cd / 
bash Anaconda3-2020.11-Linux-x86_64.sh -u

Se le guiará a través de varios pasos. Instale Conda y pruebe la instalación ejecutando el comando conda en el símbolo del sistema:

conda

En caso de que el comando conda resulte en “un error de intérprete incorrecto” (es decir, no existe tal error de archivo o directorio), aplique la siguiente solución:

cd / inicio / usuario / 
nano .bashrc

agregue la línea:

export PATH = ~ / anaconda3 / bin: $ PATH

Guarde los cambios en el archivo y, finalmente, ejecute el comando:

source .bashrc

Felicidades, acaba de instalar Conda.

Instalación de NILMTK

Abra una ventana de terminal, cree un nuevo entorno de Conda y actívelo:

conda create --name nilmtk-env 
conda activate nilmtk-env

Si aún no está presente en su instalación de Conda, agregue el conda-forge a la lista de canales:

conda config --add channels conda-forge

Finalmente, instale la última versión de NILMTK de conda-forge :

conda install -c nilmtk nilmtk = 0.4.3

Esto puede tardar un rato. Mientras tanto, consulte otros paquetes en Forge de NILMTK .

Actualización 22 de febrero: He experimentado algunos problemas posteriores a la instalación con NILMTK y Matplotlib. Para solucionarlos, aplique el comando:

conda install matplotlib = 3.3.2

Agregar un kernel de Jupyter

Básicamente, NILMTK ahora está instalado en su computadora. El siguiente paso involucra los cuadernos de Jupyter. Trabajar con Jupyter abre muchas posibilidades y se dice que es una herramienta imprescindible. Por lo tanto, agregue el entorno NILMTK a Jupyter:

python -m ipykernel install --user --name nilmtk-env --display-name "Python (nilmtk-env)"

Prueba de la instalación

Ha llegado el momento de comprobar su instalación. Antes que nada, cree una nueva carpeta y descargue el conjunto de prueba aleatorio de Github:

mkdir nilmtk_test / 
cd nilmtk_test /
wget https://raw.githubusercontent.com/nilmtk/nilmtk/master/data/random.h5

Como puede comprobar random.h5 es el fichero de de datos en en formato hdf5 .A continuación, levante Jupyter:

notebook jupyter

Para probar su instalación, intente importar el conjunto de datos aleatorio usando NILMTK y trazar todos los medidores:https://klemenjak.medium.com/media/9ba2be16d331653a7b4093a0fe412434

La salida debe ser:

MeterGroup (metros = 
ElecMeter (instancia = 1, edificio = 1, conjunto de datos = Ninguno, electrodomésticos = [])
ElecMeter (instancia = 2, edificio = 1, conjunto de datos = Ninguno, electrodomésticos = [])
ElecMeter (instancia = 3, edificio = 1, conjunto de datos = Ninguno, electrodomésticos = [])
ElecMeter (instancia = 4, edificio = 1, conjunto de datos = Ninguno, electrodomésticos = [])
ElecMeter (instancia = 5, edificio = 1, conjunto de datos = Ninguno, electrodomésticos = [])
)

¡Felicitaciones! Lo ha logrado. ¡NILMTK parece funcionar según lo previsto! La próxima vez, discutiremos cómo usar la API de NILMTK para una experimentación rápida y conveniente.

Mas información en https://github.com/nilmtk/nilmtk