Archivo de la etiqueta consumo electrico

El internet de las Cosas.

Arduino y las plataformas de software libre están permitiendo realizar proyectos electrónicos cada vez más complejos y sofisticados a un coste realmente asequible a nivel de hardware, y gracias a la colaboración y difusión de contenidos, con un menor tiempo de desarrollo. Como parte de un proyecto más complejo de monitorización a través de página web, tecnología conocida como ‘Internet de las cosas‘, hemos desarrollado, basándonos en Arduino y la plataforma libre Open Energy Monitor, un monitor de energía eléctrica no invasivo, empleando sensores tipo pinza que se abrazan a la fase a medir.

Descripción.

Vamos a desarrollar un monitor de energía eléctrica o medidor de consumo eléctrico (intensidad y potencia aparente) a tiempo real y a través de internet. Para ello emplearemos una tarjerta Arduino Mega (la placa Arduino Uno carece de memoria suficiente para trabajar con la librería GSM); dos sensores para medir intensidad eléctrica, que conectaremos a nuestro Arduino mediante una shield que acondiciona la señal de los sensores; y un módem GSM para conectarnos a internet y poder enviar las medidas.

Para almacenar datos en la nube necesitamos una plataforma especializada en ‘Internet of Things’ (iot), capaz de recibir y procesar los datos de nuestro nodo de monitorización. Existen en el mercado diversas plataformas para iot con distintas funcionalidades como Carriots o Xively (anteriormente Pachube). En este proyecto nos basaremos en la plataforma Emoncms, un proyecto OpenSource que proporciona almacenamiento limitado gratuito en sus servidores, y que permite descargar la plataforma y ejecutarla en un servidor propio. Incluye además tratamiento de datos y diversos formatos de visualización personalizables, que nos van a ayudar a desarrollar una completa interfaz de monitorización incluyendo seguridad de acceso.

Medida de consumo eléctrico.

Para la monitorización de consumo eléctrico uno de los métodos más empleados consiste en emplear sensores no invasivos de tipo pinza, que son básicamente transformadores de corriente (TC), especialmente indicados para medir corriente alterna.

Como cualquier transformador, están constituidos por un bobinado de primario, un bobinado de secundario, y un núcleo magnético.

La relación de transformación es el cociente entre entre el número de vueltas de bobinado entre primario y secundario, y la intensidad que fluye por el secundario es directamente proporcional a la relación de transformación:

RelacionTransformacion = nVueltasPrimario / nVueltasSecundario.
ISecundario = RelacionTransformacion * IPrimario

Habitualmente en este tipo de sensores, el número de vueltas de bobinado en el secundario es 2000, y el primario está constituido únicamente por la fase a medir, así que la relación de transformación es 1:2000, y la intensidad en el secundario es 1/2000 de la intensidad que fluye por el primario. Para un sensor de 100A como el que hemos adquirido, la intensidad del secundario será 100A/2000 = 0.05A, lo que suele escribirse en la forma 100:0.05.

Tal como hemos visto, el cable de fase a monitorizar constituye el primario del transformador, y al circular por él una corriente alterna, se induce una corriente proporcional en el secundario. Esta señal en forma de intensidad de corriente alterna debe ser acondicionada para poder medirse en una entrada analógica de nuestro Arduino, que es una entrada de tensión variable 0-5 V . Sobre la forma a realizar esta conversión eléctricamente hay amplia documentación en internet. Nosotros nos hemos decantado por adquirir una shield para Arduino realizada y distribuida por Open Energy Monitor, la Emon TX Arduino Shield  que incorpora 4 entradas para sensores de corriente configuradas con los componentes necesarios para medir en los canales análogicos de Arduino, y con conectores de 3.5mm para los sensores; además de dos entradas de temperatura para sensores digitales tipo DS18B20.

Mediante 4 entradas de 3.5mm se conectan a la shield, de forma simple, los equipos de medida que hemos adquirido también en la misma web: Yhdc SCT-013-000. Estos sensores están diseñados para medir una intensidad máxima de 100A. Es posible adquirirlos con una menor intensidad máxima, lo que aumenta la precisión de la medida a realizar.

Una vez la shield montada en la placa Arduino y conectados los sensores, estamos listos para comenzar a probar nuestro monitor de energía eléctrica. Únicamente necesitamos importar la librería EmonLib e incorporarla a nuestro proyecto. Hay que tener en cuenta  que los ejemplos incluidos en la instalación de la librería Emonlib no están desarrollados para la shield de Arduino, sino para otro dispositivo similar. Pare poder utilizar los ejemplos de la librería debemos modificar la línea en que se configura la instancia, introduciendo como constante el valor 60.606. Este valor es el cociente entre la relación de transformación (2000) y la resistencia de carga del circuito (33ohm).

Cte = RelacionTransformacion / ResistenciaCarga = 2000 / 33Ohm = 60.606
emon1.current(1, 60.606) //(pin analógico, cte configuración)

La shield EmonTx está preparada para realizar medidas de voltaje y potencia eléctrica, simplemente conectando una fuente de 9V alterna al conector de alimentación de la propia shield, para hacer de referencia. Si optamos por no incluir la fuente, sólo tenemos la posibilidad de medir intensidad. Para calcular la potencia aparente basta con multiplicar la intensidad medida por la tensión en línea, que debemos incluirla como una constante. En el caso de España, la tensión de suministro es de 230V, aunque este valor puede variar ligeramente en cada punto de suministro.

#include "EmonLib.h" // Incluye la libreria

EnergyMonitor emon1; // Crea una instancia 
void setup() 
{ 
  Serial.begin(9600); 
  emon1.current(1, 60.606); // Configuración: entrada Pin Analógico, calibracion. 
} 
void loop() 
{ 
  double Irms = emon1.calcIrms(1480); 
  Serial.print(Irms*230.0); // Potencia Aparente 
  Serial.print(" "); 
  Serial.println(Irms); // Irms 
}

Conexión de Arduino a Internet.

Aunque existen diversas alternativas para conectar Arduino a internet, nos decantamos por la shield oficial Arduino GSM Shield. Aunque la placa es compatible con nuestro Arduino Mega, es necesario, como se indica en la documentación oficial, realizar unas pequeñas modificaciones para hacerla funcionar:

• Puentear los canales digitales  2 y 10.
• Doblar la patilla del canal 2 para dejarlo sin conectar

Con estas sencillas modificaciones estamos listos para conectar nuestro Arduino Mega a internet, en este caso a la web de Emoncms. La mejor opción para enviar datos a un servidor web es realizar un enlace cliente-servidor, donde Arduino es el cliente web. Hay abundante documentación sobre el modo de realizar la conexión como cliente, tanto en internet como en los propios ejemplos de la librería GSM.

No debemos olvidar que para conectarnos a internet a través de la shield GSM, debemos tener contratada una tarifa de datos con algún operador móvil. Como en elpaquete de la shield oficial se incluye una tarjeta de Movistar activable vía web, para probar el prototipo hemos adquirido un bono de 10MB a través de la web M2M. Es necesario tener a mano los datos de conexión del operador a la hora de realizar el enlace web:

#include <GSM.h>

// PIN de la tarjeta, en el caso de M2M está vacío
#define PINNUMBER ""

//Operador
#define GPRS_APN       "sm2ms.movilforum.es"
#define GPRS_LOGIN     ""   
#define GPRS_PASSWORD  ""

GSMClient client;
GPRS gprs;
GSM gsmAccess;

void setup()
{ 
  Serial.println("Iniciando la conexion WEB.");

  boolean notConnected = true;
    // Inicia el acceso GSM
  while(notConnected)
  {
    if((gsmAccess.begin(PINNUMBER)==GSM_READY) &
        (gprs.attachGPRS(GPRS_APN, GPRS_LOGIN, GPRS_PASSWORD)==GPRS_READY))
      {
        notConnected = false;
        Serial.println("Conectado a red GSM");
      }
    else
    {
      Serial.println("No conectado");
      delay(1000);
    }
  }
}

Montaje del conjunto.

Ya tenemos todos los componentes del monitor de energía eléctrica probados por separado, es momento de ensamblar el conjunto y programar el código para comenzar a enviar datos al servidor web. El primer paso es montar las shields sobre la placa Arduino. Vamos a emplear dos sensores para tener medidas redundantes, en uno de ellos mediremos la intensidad del cable de fase, y en el otro la intensidad del neutro, ambas medidas deben coincidir.  

En el sketch añadimos el código para realizar la segunda medida y preparamos la cadena del envío. Para transmitir los datos al servidor de emoncms, empleamos una cadena json según se detalla en la información de la página sobre como transmitir datos, con el formato:

http://emoncms.org/input/post.json?json={power:200}

Debemos estar registrado en el servidor para poder operar en la aplicación. Una vez registrados, se nos asigna un APIKEY con permiso de escritura que es necesario reflejar en el sketch al enviar datos. Este valor indica al servidor emoncms qué usuario está enviando datos. Tambiés podemos incluir, en caso necesario, el número de nodo desde el que se envía, para distinguir en caso de disponer de distintos equipos, o querer monitorizar distintas zonas.

Empleamos el pin 12 como indicador de que hay una transacción de lectura-envío en marcha.

#include "EmonLib.h"
#include 

#define PINNUMBER ""
#define GPRS_APN       "sm2ms.movilforum.es" 
#define GPRS_LOGIN     ""    
#define GPRS_PASSWORD  "" 

//APIKEY para la conexion con Opencms
const String APIKEY = "xxxxxxxxxxxxxxxxxxxxxxxxxx";

char server[] = "emoncms.org"; 
const int port=80;
int node = 1;

unsigned long ultimoEnvio=0; 
const unsigned long intervaloEnvio = 10;  //periodo entre envios

String json;

// Inicialización de las librerías
GSMClient client;
GPRS gprs;
GSM gsmAccess;
EnergyMonitor emon1;
EnergyMonitor emon2;

void setup()
{  
  Serial.begin(9600);
  emon1.current(1, 60.606);
  emon2.current(2, 60.606);
  Serial.println("Iniciando la conexion WEB.");

  boolean notConnected = true;
    // Inicia el acceso GSM
  while(notConnected)
  {
    if((gsmAccess.begin(PINNUMBER)==GSM_READY) &
        (gprs.attachGPRS(GPRS_APN, GPRS_LOGIN, GPRS_PASSWORD)==GPRS_READY))
      {
        notConnected = false;
        Serial.println("Conectado a red GSM");
      }
    else
    {
      Serial.println("No conectado");
      delay(1000);
    }
  }
  pinMode(13, OUTPUT);
}

void loop()
{
  //Lectura de datos enviados por el servidor web
  if (client.available())
  {
     char c = client.read();
     Serial.print(c);
  }

  if (!client.connected() && ultimoEnvio)
  {
    client.stop();
  }
 //envio de datos
 if(((millis() - ultimoEnvio)/1000 > intervaloEnvio))
  {
    digitalWrite(13, HIGH);
    double Irms1 = emon1.calcIrms(1480);  // Calculate Irms only
    double PotAct1=Irms1*230.0;
    double Irms2 = emon2.calcIrms(1480);  // Calculate Irms only
    double PotAct2=Irms2*230.0;
    //preparamos el dato para enviar
    char aux_Irms1 [8];
    char aux_Pot1 [8];
    char aux_Irms2 [8];
    char aux_Pot2 [8];    
    dtostrf(Irms1, 4, 2, aux_Irms1);
    dtostrf(PotAct1, 4, 2, aux_Pot1);
    dtostrf(Irms2, 4, 2, aux_Irms2);
    dtostrf(PotAct2, 4, 2, aux_Pot2);
    //preparamos la cadena de envio
    json="{";
    //pasamos los datos a la cadena
    datosSerie(json, "Int1", aux_Irms1, true);
    datosSerie(json, "Pot1", aux_Pot1, false);
    datosSerie(json, "Int2", aux_Irms2, false);
    datosSerie(json, "Pot2", aux_Pot2, false);
    json += "}";
    Serial.println(json);
    sendData();
  }
}

void sendData()
{
  // Realizamos la conexión al servidor
 if (client.connect(server, port))
  {
    client.print("GET /api/post?apikey=");
    client.print(APIKEY);
    if (node > 0) {
      client.print("&node=");
      client.print(node);
    }
    client.print("&json=");
    client.print(json);
    client.println(" HTTP/1.1");
    client.println("Host:emoncms.org");
    client.println("User-Agent: Arduino-GSM");
    client.println("Connection: close");
    client.println();   
    Serial.println("Enviada con éxito");
  }
  else
  {
    // if you couldn't make a connection:
    Serial.println("Error en la Conexion.");
    Serial.println();
    Serial.println("desconectando.");
    client.stop();
  }
  // note the time that the connection was made or attempted
  digitalWrite(13, LOW);
  ultimoEnvio = millis();
}

void datosSerie(String &dataString, String Campo, String Valor, boolean Primero)
{
    if (Primero==false) {
      dataString += ",";
    }
      dataString += Campo+":";
      dataString += Valor;
}

Muy importante es recordar que debemos colocar el sensor alrededor de sólo uno de los dos hilos de alimentación, si medimos sobre un cable convencional donde están embutidos los dos hilos de alimentación, la medida será siempre cero, ya que a la intensidad que entra por un hilo es igual y de signo contrario a la que sale por el otro, para que fluya la intensidad.

En la próxima entrada, mostraremos como configurar el servidor Opencms para que almacene datos en forma histórica y cómo crear una pantalla de monitorización de datos amigable con gráficos.