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 energía doméstico simple Arduino


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

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

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

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

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

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

Cómo hacer el medidor de energía

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

Ensamblaje

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

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

energy-meter-wiring-diagram

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

Arduino home energy meter

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

current-sensor-connections

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

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

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

Elegir diferentes componentes

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

Elegir un transformador de corriente

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

Dimensionamiento de la resistencia de carga

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

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

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

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

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

firmware

#include <LiquidCrystal.h>

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

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

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

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

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

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

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

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

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

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

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

Actualización de código

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

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

Aquí está el código mejorado:

#include <LiquidCrystal.h>

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

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

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

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

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

Calibrar la lectura actual

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

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

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

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

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

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

arduino-energy-meter-low-consumption

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

arduino-energy-meter-high-consumption

Watimetro con Arduino


Realmente construir un watimetro no es demasiado  complejo cuando hablamos de corriente continua , por ejemplo pensando en una instalación fotovoltaica , pues basta  simplemente en recordar  la formula física de la  Potencia(P)   , la cual es el producto de la tensión instantánea(voltios) por la intensidad  (Amp ) , es decir  P = V x I ,  expresándose la unidad de potencia en  Watt o KW
Pero la potencia  en watios,  no expresa  ensimismo  potencia energética, por lo  que se recurre  al  producto de la potencia (vatios)  por el tiempo (en horas) , es  decir  E = P x t , expresándose  la unidad de energía que  todo conocemos como  vatios hora(Wh) o kilovatios hora (kWh).

Si unimos ambas formulas sustituyendo el valor de P obtenemos E =Px t= (V xI) x t , es decir  el producto de la tensión  e intensidad por el el tiempo

Precisamente pues de la ultima fórmula anterior queda claro que para medir la energía que necesitamos tres parámetros:

  1.  Tensión
  2.  Intensidad
  3.  Tiempo

Veamos pues como  obtener estas valores con un Arduino  para obtener en tiempo real en un display lcd  la potencia en kwh de un sistema en cc

En el siguiente  video podemos ver el proyecto funcionando, incluso enviando datos al IoT  con  Xively (esta opción ya no esta disponible para aficionados)

Medida de tensión

El voltaje se puede medir con la ayuda de un circuito divisor de tensión  formado  por dos resistencias iguales  . Como el  voltaje de entrada en cualquier pin analógico de ARDUINO esta limitado a 5V por se logica TTL , el  divisor de voltaje servirá para  que el voltaje de la salida de ella sea menor que 5V y no queme la electronica interior.

Por ejemplo para una batería  que se utilice para almacenar la energía de un  panel solar de  6v  y   5.5Ah  de capacidad , tendríamos que bajar la  tensión desde 6.5v a una tensión menor que 5V para no estropear el Arduino.

Si usamos R1 = 10k y R2 = 10K  nos da una corriente pequeña 6.5v/(10k+10K)=0,325mA .

Es cierto que se podrían  tomar valores de R1 y R2    inferiores, pero el problema es que cuando la resistencia es menor  mayor corriente  pasas  a través de ella generando como resultado gran cantidad de energía  disipada en forma de calor(recuerde  que P = I ^ 2R) . por tanto el valor de las resistencias  puede ser elegido diferente pero debe tenerse cuidado para reducir al mínimo la pérdida de energía a través de las resistencias.

El resultado de la tensión entre una de las resistencias y masa seria igual a R xI =10k  x 0.325mA=3.25v que es inferior a 5v y, tensión soportada sin problemas  para el pin analógico de  ARDUINO

Calibración de voltaje:

Cuando la batería está completamente cargada (6.5v) obtenemos una Vout = 3.25v y ese seria el valor  que iría al  convertidor analógico digital  de un puerto analógico  de  Arduino

Si tenemos que medir los 3.25v desde el divisor de tensión   obtendremos un valor aproximado de 696 en el monitor serial (  sample1 es el valor de ADC corresponde a 3.25v)  .

Precisamente con ese valor o tendremos que extrapolar  que 3.25v  es equivalente a 696,  1 es equivalente a 3.25/696=4.669mv    por lo que podemos usar  estas dos reglas:

Vout = (4.669 * sample1 ) / 1000 voltios
voltaje de la batería real = (2 * Vout) voltios

Con el siguiente código de Arduino  podemos obtener el valor de tensión:

/ / tomar 150 muestras de divisor de tensión con un intervalo de 2 segundos y medio samples data collected for(int i=0;i<150;i++)
{
sample1=sample1+analogRead(A2); //leer  el voltaje del circuito divisor
delay (2);
}
sample1=sample1/150;
voltage=4.669*2*sample1/1000;

Medición de intensidad

Para mediciones de intensidad  es típico usar una resistencia en serie  de poco  valor con la carga  y medir la diferencia de potencial entre los extremos   de esta  y luego calcular   la intensidad gracias a la la ley de ohm (I=V/R  ) donde como vemos   dividiríamos este valor por el valor en ohmios de la resistencia

El efecto Hall se basa en  la producción de una diferencia de potencial(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.

Afortunadamente actualmente existen CI especializados  como   son  los   sensores de corriente basados en efecto Hall ACS 712

Existen comercialmente  sensores de la gama ACS712  para  diferentes  rangos de corrientes máximas , así que se debe escoger este  según su requisito,como por ejemplo para una corriente máxima de 20 A.

ACS712.png

En el  esquema vemos un LED como una carga ( aunque  la carga real sera diferente) .

Tambien vemos el  ACS 712 (soporta  20Amps DC)  ofreciendo una una salida analógica 100mV/A

Tambien es destacar la alimentación del Arduino  cuya salida alimenta a través de la placa de prototipos a la ACS712

La calibración  es muy sencilla :
La lectura analógica  produce un valor de 0-1023, equiparando a 0v a 5v analógico .Leer 1 = (5/1024) V = 4.89mv
Valor = (4,89 * valor analógico leído) / 1000 V,  pero según hojas de datos offset 2.5V (cero corriente obtendrá 2.5V del sensor de salida)
valor Actual = (valor 2.5) V
corriente en amp = valor real * 10

Código de ARDUINO:

/ / tomando 150 ejemplos de sensores con un intervalo de 2 segundos y luego media de los datos de las muestras recogidos
for (int i = 0; i < 150; i ++)
{
+= sample2 analogRead(A3);  //  leer la corriente de sensor
delay(2);
}
sample2 = sample2/150;
=(5.0*sample2)/1024.0; 
actualval = val-2.5;  //tensión de offset es 2.5v
amperios = actualval * 10;

 Medición del tiempo

Para la medida del tiempo no se necesita ningún hardware externo, pues ARDUINO en sí mismo tiene contador de tiempo incorporado.

La función millis() devuelve el número de milisegundos desde que la placa Arduino comenzó a ejecutar el programa actual.

Código de ARDUINO:

long milisec = millis();  // calcular el tiempo en milisegundos
long time=milisec/1000; // convertir de milisegundos a segundos

 Calculo de la potencia y energía

Estas son las formulas basicas empleadas por el fw  en Arduino:
  • totamps = totamps + amperios;  //calcular amperios total
  • avgamps = totamps/tiempo;  // promedio de amps
  • amphr =(avgamps*time)/3600;  // Ah
  • Watts = voltaje * amperios;  //Potencia = Voltaje * corriente
  • energía =(watt*time)/3600;  // Vatios-seg vuelve a convertir en Watt-hora dividiendo 1hr(3600sec)
  •  energy=(watt*time)/(1000*3600); //para la lectura en kWh

completo.jpg

Todos los resultados se pueden visualizar en el monitor serial o mediante una pantalla LCD   de 16 x 2 caracteres para mostrar todos los resultados obtenidos en los pasos anteriores.

El conexionado del LCD sigue la conexión estandar de 4 pines para la linea de  datos mas las señales de control RS,RW  y Enable

Asimismo también es necesario un trimer de 10k  para el contraste de la pantalla

Resumidamente estas son pues las conexiones para el lcd

LCD -> Arduino
1. VSS -> GND de Arduino
2. VDD -> Arduino + 5v
3. VO -> Arduino GND pin + resistencia o potenciómetro
4. RS -> Arduino pin 8
5. RW -> Arduino pin 7
6. E -> pin Arduino 6
7. D0 -> Arduino – no conectado
8. D1 -> Arduino – no conectado
9. D2 -> Arduino – no conectado
10. D3 -> Arduino – no conectado
11. D4 -> Arduino pin 5
12. D5 -> Arduino pin 4
13. D6 -> Arduino pin 3
14. D7 -> pin Arduino 2
15. A -> Pin 13 de Arduino + resistencia (potencia de luz de fondo)
16. K -> Arduino GND (tierra de luz de fondo)

A continuación este es el  código de ejemplo para sacar por el monitor serie  los valores calculados

Serial.Print (“tensión:”);
Serial.print(voltage);
Serial.println(“Volt”);
Serial.print (“actual:”);
Serial.print(amps);
Serial.println(“Amps”);
Serial.print (“potencia:”);
Serial.print(watt);
Serial.println(“Watt”);
Serial.print (“energía consumida:”);
Serial.print(energy);
Serial.println(“Watt-Hour”);
Serial.println(“”);  //imprimir los siguiente conjuntos de parámetro después de una línea e
delay(2000);
Para manejar el  LCD tiene que primero importar la biblioteca de “LiquidCrystal” en el código.
A continuación este es el  código de ejemplo para sacar por el display  lcd  los valores calculados:
#include
lcd (8, 7, 6, 5, 4, 3, 2);
luz int = 9;
void setup()
{
pinMode (luz de fondo, salida); //set pin 9 como salida
analogWrite (contraluz, 150); //controls la intensidad de luz 0-254
lcd.begin(16,2); / / columnas, filas. tamaño de pantalla
LCD.Clear(); claro la pantalla
}
void loop()
{
lcd.setCursor(16,1); / / establecer el cursor fuera de la cuenta de pantalla
lcd.print(“”); imprimir carácter vacío
delay(600);
impresión de potencia y energía que un LCD / / /
lcd.setCursor(1,0); coloca el cursor en la columna 1 y fila 1

LCD.Print(Watt);
lcd.print (“W”);
lcd.print(voltage);
lcd.print(“V”);
lcd.setCursor(1,1); coloca el cursor en la fila 1 columna y 2 º
lcd.print(energy);
lcd.print (“WH”);
lcd.print(amps);
lcd.print(“A”);
}

 

Componentes

A continuación por ultimo algunos de los componentes necesarios para llevar a cabo este circuito:

 

1. ARDUINO UNO  (unos 9€ en Amazon)


3. Display LCD de 16 x 2 caracteres LCD (en Amazon con I2C  menos de 5€ )

4. ACS 712 SENSOR de corriente .Rango de corriente: 30A; Tamano: 31 x 13mm / 1.2 “x 0.5” (L * W) ( en Amazon unos 2€ )


Varios : resistencias de 10k v2,resistencia de 330ohm, POTENCIÓMETRO de 10K ,cables puente , placa de prototipos,etc

 

A %d blogueros les gusta esto: