Este es un proyecto basado en una placa Arduino que puede medir el consumo de energía de los dispositivos. Cuando conectamos este vatímetro a un dispositivo que está en funcionamiento, la pantalla LCD de 16*2 muestra su valor de consumo de energía en Watts. El proyecto utiliza una Miniplaca Arduino Pro cuya función ADC se utiliza junto con el concepto de la ley de Ohm y el circuito divisor de voltaje para desarrollar este Vatímetro.
Figura 1: Prototipo de vatímetro basado en Arduino
Descripción
Todo el proyecto se puede dividir en tres bloques básicos;
1) Unidad de detección de energía
2) Unidad de procesamiento
3) Unidad de visualización
Figura 2: Diagrama de bloques del vatímetro basado en Arduino
La unidad de detección de energía permite que la corriente fluya a través de un dispositivo cuyo consumo de energía debe medirse. La unidad de detección produce dos voltajes, uno es el voltaje de salida de la fuente de alimentación y el otro es un voltaje que varía de 0 a 5 V. La diferencia entre estos dos voltajes es proporcional a la cantidad de corriente que fluye a través de la unidad del sensor.
La Unidad Procesadora puede aceptar dos voltajes de entrada, ambos en el rango de 0 a 5V. Esta unidad considera la salida de la unidad del sensor como voltajes de entrada y utiliza el ADC para leer estos voltajes. Luego se aplica un algoritmo para calcular el consumo de energía del dispositivo. Luego, la unidad envía datos de 4 bits a la unidad de visualización para mostrar el consumo de energía en vatios.
La unidad de visualización toma los datos de 4 bits de la unidad procesadora y produce una visualización de 16*2 para el consumo actual del dispositivo.
1) Unidad de detección de energía
El sensor de potencia en este proyecto es una resistencia única de bajo valor a través de la cual fluye corriente hacia el dispositivo de carga. El voltaje a través de la resistencia y el flujo de corriente a través de la resistencia se miden para calcular el consumo de energía del dispositivo.
En nuestro proyecto hemos implementado la resistencia 'R' en la ruta del flujo de corriente cuyo valor de resistencia se conoce. Luego medimos el voltaje en ambos extremos de la resistencia para calcular el flujo de corriente con la ayuda de la siguiente ecuación.
Yo = (V2 – V1) /R
Figura 3: Diagrama de circuito del circuito de detección de energía.
Hemos seleccionado un valor de R = 10 ohmios, ahora tenemos la ecuación para calcular la potencia;
Yo = V2 – V1/10
Una vez obtenido el valor actual 'I', la potencia consumida por el dispositivo 'P' se puede calcular mediante la siguiente ecuación;
P = V2 * I
2) Unidad de procesamiento
La unidad procesadora en este proyecto es la placa Arduino y utiliza el módulo ADC para leer los voltajes de salida V1 y V2 de la unidad sensora. En la placa Arduino estamos usando un ADC de 10 bits de 8 canales con el pin de voltaje de referencia conectado a 5 V. El ADC lee el voltaje V1, V2 y genera un valor equivalente 'Valor ADC ' en el registro ADC. A partir de este valor, el algoritmo calcula las tensiones V1 y V2 y luego el consumo de energía.
Una vez obtenidos los valores de V1 y V2, se calcula el valor del flujo de corriente 'I' utilizando los valores conocidos de R = 10 ohmios, con ayuda de la ecuación;
Yo = (V2 – V1) / 10
Luego se calcula el consumo de energía mediante la ecuación;
P = V2 * I
El siguiente código calcula la potencia y la muestra en la pantalla LCD.
potencia_CC = corriente_CC_I0 * voltaje_CC_V1;
lcd.claro;
lcd.setCursor(0, 0);
lcd.print(dc_power);
lcd.print(”mW CC”);
Unidad de visualización y explicación del código.
3) Unidad de visualización
La unidad de visualización utiliza una pantalla LCD estándar de 16*2 en la que Arduino muestra el valor del consumo de energía. La pantalla LCD se conectó en modo de cuatro bits para reducir la cantidad de pines de salida de la placa Arduino que se utilizarán.
Figura 4: Imagen que muestra el módulo LCD utilizado para mostrar la resistencia
Descripción del código
El código lee continuamente los canales ADC A0 y A2 uno tras otro, calculando cada vez los valores de V1 y V2. Cuando se obtienen los valores V1 y V2, el código calcula el valor de consumo de energía del dispositivo y ese valor se muestra en la pantalla LCD de 16*2.
El código que se ejecuta en Arduino utilizó la función de biblioteca analogRead para obtener el valor de ADC y lcd.print para mostrar los datos en la pantalla LCD de 16*2.
Figura 5: Diagrama de flujo del código Arduino para medición de potencia
Limitaciones:
La resistencia de 10 ohmios es un valor alto en comparación con la resistencia de precisión de 0,05 ohmios dentro de un multímetro. Más flujo de corriente, más caída de voltaje a través de la resistencia, y esta caída de voltaje es proporcional al valor de la resistencia. Para valores de corriente superiores a 500 mA, cree una resistencia baja conectando tantas resistencias en paralelo como sea posible. Dado que el Arduino ADC solo puede leer un máximo de 5 V, no utilice una fuente de corriente con un voltaje superior a 5 V.
Código fuente del proyecto
###
// incluye código de biblioteca:
#incluir
// inicializa la biblioteca con los números pin de la interfaz
LCD de cristal líquido (12, 11, 5, 4, 3, 2);
int valor_adc = 0;
int voltaje_pico_valor = 0;
valor_promedio_voltaje flotante = 0;
voltaje flotante_cc_V0 = 0;
voltaje flotante_ac_V0 = 0;
flotador dc_voltage_V1 = 0;
voltaje flotante_ac_V1 = 0;
flotador dc_current_I0 = 0;
flotador ac_current_I0 = 0;
flotador dc_power = 0;
flotador ac_power = 0;
larga resistencia sin firmar;
cuenta_muestra larga sin firmar = 0;
configuración nula
{
// configura el número de columnas y líneas de la pantalla LCD:
lcd.comenzar(16, 2);
// Imprime un mensaje en la pantalla LCD.
lcd.print("EG LABORATORIOS");
pinMode(13, SALIDA);
}
bucle vacío
{
// Serial.println("=============================== VOLTAJE ============ ===============================");
valor_pico_voltaje = 0;
para(recuento_muestra = 0; recuento_muestra < 5000; recuento_muestra ++)
{
adc_value = analogRead(A0);
if(valor_pico_voltaje <valor_adc)
valor_pico_voltaje = valor_adc;
otro;
retrasoMicrosegundos(10);
}
dc_voltage_V0 = voltaje_pico_valor * 0,00488;
voltaje_ac_V0 = voltaje_cc_V0 / 1.414;
// Serial.println("================================ ACTUAL ========== ===============================");
valor_pico_voltaje = 0;
para(recuento_muestra = 0; recuento_muestra < 5000; recuento_muestra ++)
{
adc_value = analogRead(A2);
if(valor_pico_voltaje <valor_adc)
valor_pico_voltaje = valor_adc;
otro;
retrasoMicrosegundos(10);
}
dc_voltage_V1 = valor_pico_voltaje * 0,00488;
voltaje_ac_V1 = voltaje_cc_V1 / 1.414;
dc_current_I0 = (dc_voltage_V1 - dc_voltage_V0) * 100;
corriente_ac_I0 = (voltaje_ac_V1 - voltaje_ac_V0) * 100;
//================================ ENERGÍA =============== ============= ===========================
potencia_CC = corriente_CC_I0 * voltaje_CC_V1;
potencia_ac = corriente_ac_I0 * voltaje_ac_V1;
lcd.claro;
lcd.setCursor(0, 0);
lcd.print(dc_power);
lcd.print("mW");
//================================================== ========= == ================================
retraso(1000);
}
###
Diagramas de circuito
| Diagrama de circuito-Arduino-vatímetro |  |
