Medidor de energía doméstico simple Arduino

julio 16, 2021soloelectronicosDeja un comentario

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:

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:

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.

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.

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.

Instalación del Nilmtk

julio 2, 2021marzo 24, 2024soloelectronicosDeja un comentario

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 .

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

Observe que el signo igual no lleva espacios(piense estamos usando Python.

La ejecución del comando puede tardar un rato. Mientras tanto, consulte otros paquetes en Forge de NILMTK .

Como puede experimentar algunos problemas posteriores a la instalación con NILMTK y Matplotlib., para s olucionarlos, aplique el comando:

conda install matplotlib=3.3.2

Agregar un kernel de Jupyter

Básicamente, NILMTK ahora está instalado en su ordenador. 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