Puede parecer  extraño , pero cada vez tenemos dispositivos  conectados a nuestro TV  que  suelen ser  el origen de  vídeo  por defecto  como pueden ser dispositivos Android   TV, reproductores blueray, etc.  o   sobre todo descodificadores de TV  

En este sentido  podría ser interesante  supeditar  automáticamente el  encendido  de la TV  al de la fuente de vídeo ( normalmente un descodificador de TV) , para lo cual   vamos a intentar implementar una solución que lo automatice

Pensando en una solución , una aproximación  podría ser basarse en  las señales de infrarrojos entre el TV  y la fuente de vídeo ,pero esto conlleva mucha complejidad pues en el mercado existe una infinidad de marcas  y modelos de  dispositivos diferentes , que haría  muy difícil  contemplar un método practico para resolverlo , así  que debemos pensar en otra solución …

Pensando  en la variación del consumo de un dispositivo  ,una solución puede pasar por detectar  esa variación  de consumo   y con ello  sabremos si debemos o no activar la TV , para lo cual nos puede basta el sensor   ACS712    , un  Modulo Sensor de corriente para Arduino con un rango de medida máximo de 5 Amperios ( suficiente para la mayoría de los dispositivos  que conectaremos al TV) 

Este sensor esta basado  en efecto Hall   que detecta el campo magnético que se produce por inducción de la corriente que circula por la línea que se está midiendo , por lo que no hay disipación de potencia a través de este como ocurriría  con soluciones clásicas  que  usarían una resistencia de valor bajo  en serie  para medir la corriente que circula por ella  y el circuito (pero  con el consiguiente disipación  de potencia en esta )

Concretamente  en las pruebas  junto a un Arduino UNO , usaremos el  chip sensor  ACS712ELC-05A  alimentado  con  5V a través del propio Arduino ( lleva un led a bordo como e indicador de energia) 

El modulo puede medir los positivos y negativos de máximo 5 amperios, correspondiente a la salida analógica 185mV / A   entregando una salida de voltaje proporcional a la corriente, Dependiendo la aplicación podemos usar otros módulos  como el ACS712-05A, ACS712-20A o el ACS712-30A, para rangos de 5, 20 o 30 amperios respectivamente

El  ACS712  podemos encontrarlo en módulos, los cuales nos facilitan sus conexiones, Este modulo  trae una bornera para conectar la línea que queremos medir ( el descodificador)  y 3 pines por el otro extremo: dos para conectar la alimentación y un pin para la salida analógica.

Para las conexiones en el módulo debe  guiarse por los nombres de los pines, en algunos modelos vienen en diferente orden pero marcados en la serigrafia como Gnd,Out  y Vcc . En nuestro caso Vcc ira al pin +5V de Arduino, GND al GND del Arduino y  Out lo conectaremos al pin analógico de Arduino  A0 

En los terminales opuestos del  ACS712  conectaremos  en serie la alimentación del Descodificador ,o dispositivo que  vaya a controlar  la TV . Para medir la corriente se  debe conectar en serie con el dispositivo o carga, nunca conectar en paralelo a la fuente de voltaje.

El rango de corriente que podemos medir y sensibilidad varían dependiendo del modelo del integrado, existen tres modelos los cuales detallamos a continuación:

El sensor  ACS712  nos entrega un valor de 2.5 voltios para una corriente de 0A y a partir de allí incrementa proporcionalmente de acuerdo a la sensibilidad, teniendo una relación lineal entre la salida de voltaje del sensor y la corriente. Dicha relación es una línea recta en una gráfica Voltaje vs Corriente donde la pendiente es la sensibilidad y la intersección en el eje Y es 2.5 voltios. La ecuación de la recta seria la siguiente

Donde la pendiente es m y equivale a la Sensibilidad

Despejando tendremos la ecuación para hallar la corriente a partir de la lectura del sensor:

Para realizar la lectura de corriente simplemente se necesita leer la entrada analógica y con la formula antes expuesta obtener la corriente.

A continuación se muestra el código para un realizar la lectura de corriente:

float Sensibilidad=0.185; 
//sensibilidad en Voltios
/Amperio para sensor de 5A void setup()
 {      Serial.begin(9600); } 
void loop()
 {      float voltajeSensor= analogRead(A0)*(5.0 / 1023.0);
 //lectura del sensor   
   float I=(voltajeSensor-2.5)/Sensibilidad; 
//Ecuación  para obtener la corriente  
 Serial.print("Corriente: "); 
  Serial.println(I,3); 
   delay(200);     
 } 

En nuestro caso estamos trabajando con un sensor de 5A ( ACS712  )  por eso usamos el valor de sensibilidad de 0.185V/A que es el equivalente 185mV/A que nos da el fabricante, si están trabajando con el sensor de 20A, reemplazar el valor de la sensibilidad por 0.100 V/A.

Existen varios tipos de filtros, que dependiendo de la complejidad pueden consumir recursos en la programación de nuestro Arduino, en nuestro caso  simplemente usaremos la media aritmética de varias lecturas consecutivas, implementar el promedio de las lecturas en Arduino es sencillo y fácil de entender, simplemente hay que sumar las lecturas y dividirlas en un  número de muestras suficiente.
La cantidad de muestras para calcular el promedio depende del nivel de ruido que tengan .En nuestro ejemplo con 200.000 son un valor lo suficiente bueno  para que nos de un resultado bastante preciso

El programa mejorado  seria el siguiente:

float Sensibilidad=0.185; 
//sensibilidad en Voltios/Amperio para sensor de 5A void setup() 
{      Serial.begin(9600); 
} 
void loop() 
{ 
  float I=get_corriente(200000);//obtenemos la corriente promedio de 200.00 muestras  
  Serial.print("Corriente: "); 
  Serial.println(I,3); 
   delay(100);     
 } 
float get_corriente(int n_muestras) 
{ 
  float voltajeSensor;  
 float corriente=0;  
 for(int i=0;i<n_muestras;i++) 
  {     voltajeSensor = analogRead(A0) * (5.0 / 1023.0);
////lectura del sensor    
 corriente=corriente+(voltajeSensor-2.5)/Sensibilidad;
 //Ecuación  para obtener la corriente   
}  
 corriente=corriente/n_muestras; 
  return(corriente);
 } 

Como  el error que obtenemos  aun con el numero tan elevado de muestras es grande, debemos de recalibrar y hallar los valores reales puesto que los valores que nos da el fabricante no son exactos.

Recordemos la ecuación que usamos para hallar la corriente:

En esta ecuación solo tenemos dos constantes: los 2.5 que es el voltaje del sensor cuando la corriente es 0V y la sensibilidad, que equivale a la pendiente de la recta Voltaje Vs Corriente; tenemos que calcular los valores reales de estas dos constantes. Al ser una recta, basta con obtener dos puntos y con estos podemos calcular constantes.

Para esto necesitamos un polimetro en la escala de Intensidad   ( debe ser de buena precisión, ya que este será la herramienta para calibrar)  . El polimetro, el ACS712  y la carga deben de conectarse en serie. 

Después de conectar el aparato de medida y el  sensor, debemos de tomar lecturas de voltaje del sensor, esto se hace con el siguiente programa.

void setup() 
{     
 Serial.begin(9600);
 } void loop()
 {     
 float voltajeSensor =get_voltage(10000);
//obtenemos voltaje del sensor(10000 muestras) 
   Serial.print("Voltaje del sensor: ");  
 Serial.println(voltajeSensor ,3);
      } 
float get_voltage(int n_muestras) 
{   float voltage=0;   
   for(int i=0;i<n_muestras;i++) 
  {     
voltage =voltage+analogRead(A0) * (5.0 / 1023.0);     
  }   voltage=voltage/n_muestras;   return(voltage); 
} 

El primer punto que debemos medir es para una corriente de 0 amperios: esta es una de las constantes, en nuestro caso 2.527, que corresponde al punto P1(2.527,0)

Para hallar la segunda constante necesitamos una segunda medida, se recomienda que no sea cercano al valor de la primera medida, en nuestro caso usaremos una carga cuya corriente es superior a 1 amperio.Como se observa en el sensor  un voltaje de 2.687, y en el amperímetro medimos 1.155A, este sería nuestro segundo punto P2(2.687,1.155) ,

Para calcular la sensibilidad simplemente calculamos la pendiente.

Teniendo estos dos valores la ecuación para calcular la corriente es:

Donde sensibilidad=0.139 V/A

Con estos nuevos valores debemos trabajar los ejemplos anteriores

Tener en cuenta que cada sensor tiene su propia característica

Otra forma puede ser en tomar varios puntos y al final aplicar regresión y hallara la ecuación de la recta.

Con estos dos valores  contemplados en el programa, toca  ejecutar el programa  y observar la salida  del monitor serie    en función de cuando activamos el descodificador  y lo apaguemos . En nuestro caso , las lecturas son inferiores a 0.207 cuando esta en stand-bye    , superando este valor  cuando esta encendido

Estos valores   son precisamente  los que podemos usar como umbral  para activar o desactivar un pin de salida  por ejemplo para activar/desactivar  un rele que  a su vez alimente  al TV

Con todos estos cambios , el código final del programa que detecta  si se enciende o no el descodificador es el siguiente:

const int sensorPin = A0; // seleccionar la entrada para el sensor
int sensorValue; // variable que almacena el valor raw (0 a 1023)
float value;
float Sensibilidad=0.185; //sensibilidad en Voltios/Amperio para sensor de 5A

void setup() {

// Iniciamos comunicacion serie
Serial.begin(9600);
}

void loop() {

float I=get_corriente(200000);//obtenemos la corriente promedio de 500 muestras

if (I<0.207)
{Serial.print(«Apagado: «);  // aqui podemos desactivar un pin binario de salida  para deactivar  un rel
Serial.println(I,3);
delay(100);
}
else
{Serial.print(«Encendido: «);// aquí podemos activar un pin binario de salida  para activar  un relé
Serial.println(I,3);
delay(100);
}


}

float get_corriente(int n_muestras)
{
float voltajeSensor;
float corriente=0;
for(int i=0;i
{
voltajeSensor = analogRead(sensorPin) * (5.0 / 1023.0);////lectura del sensor
corriente=corriente+(voltajeSensor-2.5)/Sensibilidad; //Ecuación para obtener la corriente
}
corriente=corriente/n_muestras;
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;
}