Monitorización de corriente continua


La medición de la Intensidad de la corriente siempre es un poco desafiante, ya que tenemos que medirla en un circuito en serie pues por lo general, la medición no es posible sin romper un circuito, insertando algunos cables para la medida.

Hay algunos métodos directos que utilizan una masa comun entre el dispositivo medido y el dispositivo de medición con la ayuda de un registro entre ellos. Pero tales métodos son nunca tan confiables debido al uso de una masa común, que puede hacer que los sistemas sean inestables.

Los sensores podrían ayudar a resolver este desafío. Los sensores como el INA219 de Texas Instruments operan en una configuración de bus I2C que hace posible medir la corriente viva.

  • El módulo del sensor de corriente está configurado para monitorear la caída de voltaje de los pines y el voltaje de alimentación del bus, tiempos de conversión y opciones de filtro.
  • El valor de calibración programado del módulo de corriente digital de alta precisión se combina con un multiplicador interno para admitir la lectura directa de corriente.
  • El INA219 es un monitor de alimentación y bypass que admite la interfaz I2C o SMBUS.
  • La función de consumo de energía ultrabajo del módulo del sensor de corriente de la interfaz I2C se puede utilizar de manera adecuada y adecuada en equipos que funcionan con baterías.
  • El módulo del sensor de corriente se caracteriza por una salida de señal I2C, que puede comunicarse directamente con el sistema principal.

ina219 Stromsensormodul

En este proyecto, la primera parte fue conectar este sensor con una MCU , que en este caso fue un ESP32 con Arduino IDE debido a su facilidad de uso y capacidad para monitoreo remoto a través de internet ,aunque también puede funcionar con una Raspberry Pi como vamos a ver.

INA219

En el caso de usar como MCU una Raspberry el desafío que se enfrentó el autor fue encender esta a través de GPIO usando un convertidor de USB a TTL. El Raspberry Pi no se inicia y las medidas tampoco aparecen ,pero el autor encontró una solución sobre la marcha.

Ahora, se tiene la solución para encender RaspberryPi a través de GPIO. El problema es que se requiere usar GPIO 2 y 4 para suministrar energía de 5V y GPIO 6 para suministrar tierra.

La siguiente imagen muestra el Pi en ejecución a través de Putty y sus actualizaciones, la imagen es el gráfico de la absorción de corriente en mAmps por Pi, alcanzando el máximo alrededor de 900 mAmps solo a veces.

Normalmente permanece alrededor de 500mAmps.

Cuando la RaspberryPi funciona con comandos sudo de apagado todavía hay algo de energía requerida por el LED de estado y otras funciones internas. Si desenchufamos el cable, el consumo de energía será cercano a cero, como en las siguientes capturas de pantalla.

Tambien se puede agregar una pequeña pantalla que pudiera mostrar los datos en vivo para el monitoreo de energía por ejemplo una pantalla LCD SSD1306 para que funcione.

Una idea más es que los datos de monitoreo de energía se pueden enviar a los ruidosos, como AWS IoT, donde los datos se manipulan de manera efectiva, pero eso es demasiado para un dispositivo tan pequeño. Además, no encaja con el proyecto.

Una cosa más interesante es que un PoE HaT para RaspberryPi (básicamente cualquier placa) podría tener capacidad de monitoreo actual con LCD. Sería interesante saber qué parte del software / hardware consume más energía.

A continuación el código del proyecto para Arduino con los comentarios en español;

    #include <Adafruit_GFX.h>  
    #include <Adafruit_SSD1306.h>  
    #include <Wire.h>  
    #include <Adafruit_INA219.h>  
      
      
    #define SCREEN_WIDTH 128 // Ancho de pantalla OLED, en píxeles  
    #define SCREEN_HEIGHT 32 // Altura de la pantalla OLED, en píxeles  
      
      
    #define OLED_RESET 4 // Restablecer el pin # (o -1 si se comparte el pin de restablecimiento de Arduino)  
    #define SCREEN_ADDRESS 0x3C /// <Consulte la hoja de datos para la dirección; 0x3D para 128x64, 0x3C para 128x32  
    Pantalla Adafruit_SSD1306 (SCREEN_WIDTH, SCREEN_HEIGHT, & Wire, OLED_RESET);  
      
      
    Adafruit_INA219 ina219;  
      
     void setup()   
    {  
      Serial.begin ( 115200 );  
      while  (! Serial) {  
          // pausará Zero, Leonardo, etc.hasta que se abra la consola serie  
       delay( 1 );  
      }  
      if (! display.begin (SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {  
        Serial.println (F ( "Falló la asignación SSD1306" ));  
       halt (;;); // No continúes, bucle para siempre  
      }  
      display.display ();  
      delay ( 2000 ); // Pausa por 2 segundos  
      display.clearDisplay ();  
        
      uint32_t currentFrequency;  
          
      Serial.println ( "¡Hola!" );  
        
      // Inicializa el INA219.  
      // Por defecto, la inicialización usará el rango más grande (32V, 2A). Sin embargo  
      // puede llamar a una función setCalibration para cambiar este rango (ver comentarios).  
      if  (! ina219.begin ()) {  
        Serial.println ( "No se pudo encontrar el chip INA219" );  
        while  ( 1 ) {retraso ( 10 ); }  
      }  
      // Para usar un rango de 32V, 1A ligeramente más bajo (mayor precisión en amperios):  
      //ina219.setCalibration_32V_1A();  
      // O para usar un rango más bajo de 16V, 400mA (mayor precisión en voltios y amperios):  
      //ina219.setCalibration_16V_400mA();  
      
      
      Serial.println ( "Medición de tensión y corriente con INA219 ..." );  
    }  
      
      
     void loop ()   
    {  
       tensión de derivación de flotación =  0 ;  
       voltaje del bus flotante =  0 ;  
      flotar  current_mA =  0 ;  
       voltaje de carga flotante =  0 ;  
      flotación  power_mW =  0 ;  
      
      
      shuntvoltage = ina219.getShuntVoltage_mV ();  
      busvoltage = ina219.getBusVoltage_V ();  
      current_mA = ina219.getCurrent_mA ();  
      power_mW = ina219.getPower_mW ();  
      tensión de carga = tensión de bus + (tensión de derivación /  1000 );  
        
      //Serial.print("Bus Voltage: "); Serial.print (busvoltage); Serial.println ("V");  
      //Serial.print("Shunt Voltage: "); Serial.print (shuntvoltage); Serial.println ("mV");  
      //Serial.print("Load Voltage: "); Serial.print (voltaje de carga); Serial.println ("V");  
      Serial.print ( "Actual:" ); Serial.print (current_mA); Serial.println ( "mA" );  
      //Serial.print("Power: "); Serial.print (potencia_mW); Serial.println ("mW");  
      Serial.println ( "" );  
      
      
      delay( 10 );  
        
      display.clearDisplay ();  
      display.setTextSize ( 2 );  
      display.setTextColor (SSD1306_WHITE);  
      display.setCursor ( 5 , 5 );  
      display.print (current_mA);  
      display.print ( "mA" );  
      
      
        
    // display.setCursor (0,0);  
    // display.print (power_mW);  
    // display.print ("mWatt");  
        
      display.display ();  
      delay( 100 );  
      display.clearDisplay ();  
            
    }  


Fuente :https://www.element14.com 

Arduino sobre Ubuntu


Arduino IDE no se encuentra en los repositorios oficiales de Ubuntu, al menos en su última versión, por lo que tenemos que utilizar la web oficial del Proyecto para conseguir este IDE.

Actualmente existen dos versiones de Arduino IDE, una versión que corresponde a la rama 1.8.x y otra rama que corresponde con la versión 1.0.x. La diferencia entre ambas versiones radica en los modelos de placas que soportan: si descargamos la versión 1.8.x de Arduino IDE podemos cambiar en cualquier momento de placa y esta versión lo soportará ( si escogemos la versión 1.0.x hemos de cambiar el programa si cambiamos a una placa moderna, pues la rama 1.0.6 no soporta las placas de Arduino más modernas).

Una vez que hemos descargado el paquete de Arduino IDE desde aquí, descomprimimos el archivo comprimido en cualquier carpeta de nuestra home (mejor hacerlo ena Home y no en Descargas para evitar problemas cuando realizamos limpiezas en el futuro).

En el paquete que hemos descomprimido aparecerán varios archivos e incluso dos ejecutables, uno de ellos llamado Arduino-Builder, pero estos archivos ejecutables no seráa necesario para instalar Arduino IDE en nuestro Ubuntu

Una vez descomprimidos los archivos necesitaremos abrir una terminal en la carpeta donde están todos estos archivos, y desde la consola escribimos lo siguiente:

sudo chmod +x install.sh

Esta orden hará que el archivo de instalación pueda ejecutarse sin tener que ser root. Ahora ejecutamos en la terminal lo siguiente:

./install.sh

Puede que tenga problemas para ejecutar el instalable por los permisos, por lo que si fuese el caso solo tiene que escribir

sudo ./install.sh

Esto hará finalmente que comience la instalación de Arduino IDE en nuestro Ubuntu.

Tras seguir las instrucciones tendremos Arduino IDE instalado en nuestro Ubuntu y unacceso directo en nuestro escritorio. En este caso da igual la versión de Ubuntu que tengamos pues funciona con las últimas 10 versiones de Ubuntu que han sido lanzadas (versiones LTS incluidas).

Problemas con los puertos

Para los que esten aconstumbrados a usar el ide de Arduino sobre Windows , puede que les resulte extraño en la combinación Arduino-Ubuntu donde los puertos virtuales no se muestran del mismo modo, y con esto se desembocan en nuevos problemas, que como vamos a vers son facilmente resolubles.

COM1 es una designación de Windows (TM): se verá como/dev/ttyACM0,/dev/ttyUSB0 o similar en Linux.

El puerto atenuado tiende a significar que no ha configurado primero el tipo de placa: revise la configuración en arduino Menú Herramientas y configure la placa en ‘Uno’, también debería ver la habilitación de ‘puerto’ y el autocompletado.

puerto

El primer problema puede ser que el puerto Serial se encontraba deshabilitado, al momento de ingresar al IDE Arduino no detecta el puerto a pesar de encontrarse conectada la placa a la PC.Al acceder a  Herramientas/ Puerto Serial aparece como deshabilitado y esto NO permitirá que descarguemos nuestro código a la placa. Esto es debido a que el sistema no tiene permisos suficientes para poder establecer una comunicación a travez del puerto USB.

En linux, al conectar un USB le asigna un formato del tipo ttyACM0 o similar y esto se encuentra en la ubicación /dev.

Lo primero que tenemos que hacer es revisar como asigna el sistema operativo los puertos.Vamos abrir una terminal de ubuntu y antes de conectar el Arduino ejecutaremos el siguiente comando.

ls -l /dev | grep ACM

Si no hay ningún dispositivo conectado, no aparecerá ningún resultado. En caso contrario aparecerá asignado con algún nombre.

Ahora conectamos el arduino a la placa y ejecutamos el mismo comando.

Deberá aparecer una linea similar a

crw-rw—- 1 root dialout 166, 0 sep 25 14:42 ttyACM0

En este caso dice que solo el usuario root puede acceder al puerto.

Por lo tanto procedemos a brindarle permisos para los usuarios normales del sistema, ejecutamos e lo siguiente:

sudo chmod 777 /dev/ttyACM0

Donde ttyACM0 es el nombre que nos dio en el primer comando, este puede ser ttyACM1. Al ejecutar este comando les pedirá la contraseña del sistema. Para asegurarnos que ha cambiado los permisos ejecutamos de nuevo:

ls -l /dev | grep ACM

El resultado debe ser similar a:

crwxrwxrwx 1 root dialout 166, 0 sep 25 14:42 ttyACM0

El cambio que notaremos esta en las primeras letras del mensaje de respuesta:

Antes: crw-rw—- 1 root dialout 166, 0 sep 25 14:42 ttyACM0

Ahora: crwxrwxrwx 1 root dialout 166, 0 sep 25 14:42 ttyACM0

Esto ya indica que los demas usuarios tienen acceso al puerto ttyACM0 y por tanto no deberia dar problemas el ide de Arduino para reconocer la placa por el puerto.

Comando dmesg

En el caso de que pueda intentar iniciar sesión en Tools-> Port si existe un puerto que no sea /dev/ttyS0. Intente jugar con estas opciones. Finalmente, buscando en dmesg también puede averiguar qué puerto se ha ubicado para arduino.

Finalmente, otro enfoque es desconectar su arduino, volver a enchufarlo y escribir el siguiente comando:

dmesg | tail

Para registrar el último evento como el que ocurre cuando arduino se conecta a un puerto usb. El comando anterior le mostrará el puerto correcto.

Para obtener mejores resultados, puede usar lo siguiente:

  dmesg | tail -f

Y conecte y desconecte continuamente el arduino del puerto usp hasta que vea cualquier mensaje relacionado con arduino. El parámetro -f permite mostrar en tiempo real los nuevos registros.

Si todo va mal

Si su cuenta de usuario probablemente no tiene permiso para usar el puerto serie y no consigue resolver el problema hay aun dos formas de abordar esto:

  • Más fácil, pero no aconsejable: Ejecute Arduino IDE como root (por ejemplo, inicie desde la línea de comando usando Sudo).
  • La segunda forma más recomendable de hacerlo es agregar su usuario al grupo dialout, que tiene permiso para usar el puerto serie. Use el comando Sudo adduser $USER dialout. Sin embargo, deberá cerrar sesión y volver a iniciarla para que surta efecto (o intente esto ). Para enumerar grupos de usuarios actuales, use groups o id -Gn.

Una vez hecho esto, cuando seleccione el puerto serie correcto (como otros han mencionado, tal vez /dev/ttyUSB0), debería poder escribir, permitiéndole programar el Arduino.

sudo chmod a+rw /dev/ttyACM0  

o

sudo chmod a+rw /dev/ttyUSB0

Espero que se ha de utilidad este post, si tienen algún comentario o duda pueden dejarlo en los comentarios.

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