Como podemos hacer un medidor de carga de baterías y pilas. Lo haremos a través usando un circuito con Arduino. Es común que tengamos por casa diferentes artefactos eléctricos que utilizan pilas o baterías. Muchas veces, dudamos si el dispositivo está roto o las pilas se han gastado.
Usaremos Arduino para leer a través de una entrada analógica el voltaje que suministra una pila. Dependiendo de este voltaje, encenderemos un LED de un color. Si la pila está nueva, se encenderá un LED verde. Si la pila no es nueva pero se ha consumido parte de su energía encenderemos un LED amarillo. Por último, si la pila está gastada o no suministra el suficiente voltaje, encenderemos un LED rojo.
Debemos de tener mucho cuidado con el tipo de pila y de batería que vamos a medir. Es muy peligroso suministrar más de 5V a los pines analógicos de Arduino. Si lo que queremos es medir pilas, lo más típico, solo podremos hacerlo con pilas AA, AAA, C y D. Son las que se utilizan en los mandos de la televisión, en juguetes e incluso para alimentar Arduino.
Mucho cuidado con una pila de 9V, las cuadradas. Como bien he dicho antes, estas pilas superan con creces el límite de 5V. También debemos de llevar cuidado con las baterías ya que dependerá del voltaje que suministren. Fijate en la etiqueta de la pila antes de conectar que realmente es menor o igual que 5V.
Elementos necesarios
- Arduino UNO.
- Protoboard.
- Cables para la conexión.
- 3 resistencias de 220 Ω
- 1 resistencia de 10 kΩ
- 1 LED rojo de 5 mm
- 1 LED amarillo de 5 mm
- 1 LED verde de 5 mm
Con 3 LEDs y 4 resistencias es suficiente para construir un medidor de carga de baterías o pilas con Arduino.
Conexiones
Lo primero que veremos son los LEDs. Cada uno está conectado en serie con una resistencia de 220 Ω para extender la vida útil de los mismos. El LED verde está conectado al pin 2, el LED amarillo está conectado al pin 3 y LED rojo está conectado al pin 4. Esto es importante recordarlo para cuando veamos la programación.
Para medir la batería he colocado una resistencia pull-down. Este tipo de resistencia lo que hace es mantener un estado lógico bajo es decir, a 0V. Es importante utilizar este tipo de resistencias ya que, cuando no tengamos la batería o pila conectada para medir, tenemos un estado indeterminado a la entrada del pin analógico, lo que hace que oscile y puede que hasta que se encienda algún LED. Puedes probar a sacar esta resistencia y verás el resultado.
El polo positivo de la batería lo conectamos a la resistencia de pull-down y a la entrada analógica A0. El otro extremo de la resistencia a tierra. Finalmente, el polo negativo de la batería debemos conectarlo a la tierra de Arduino.
Algoritmo
En este paso debemos seguir sin escribir ni una línea de código, eso lo haremos luego cuando tengamos claro lo que tenemos que hacer.
Leer el pin analógico donde tenemos conectada la pila
Calculamos el voltaje para el valor que nos ha dado
Evaluamos el voltaje
Si es mayor o igual que el umbral máximo
Encendemos LED verde
Si es menor que el umbral máximo y mayor que el umbral medio
Encendemos LED amarillo
Si es menor que el umbral medio y mayor que el umbral mínimo
Encendemos LED rojo
El resto de los casos
No enciende ningún LED
Apagamos todos los LEDs
Analizando el algoritmo que vamos a implementar, sacamos como conclusión que vamos a utilizar 3 umbrales:
Umbral máximo: indicará que la pila está totalmente cargada.
Umbral medio: de este umbral al umbral máximo la pila se ha usado pero todavía tiene energía.
Umbral mínimo: de este umbral al umbral medio la pila no suministra suficiente energía. Por debajo de este umbral interpretamos que no hay una pila conectada.
Explicación del Código
Vamos a ir viendo por partes el código del medidor de carga de baterías con Arduino.
Variables y constantes
Las constantes las vamos a utilizar para almacenar los pines donde conectaremos los LEDs y el pin analógico donde conectaremos la pila. Los umbrales serán variables aunque podríamos utilizar también constantes. Por último declararemos 3 variables para almacenar el valor que nos devuelve el pin analógico, el voltaje en ese pin y el tiempo de espera para el parpadeo de los LEDs.
Declaramos las constantes con los pines donde conectamos los LEDs y el pin analógico.
// Pines para los LEDs #define LEDVERDE 2 #define LEDAMARILLO 3 #define LEDROJO 4 #define ANALOGPILA 0
Lo siguiente es declarar las variables y los umbrales. Estos últimos dependerán del tipo de pila. En este caso yo voy a hacer las pruebas con una pila AA .
// Variables int analogValor = 0; float voltaje = 0; int ledDelay = 800; // Umbrales float maximo = 1.6; float medio = 1.4; float minimo = 0.3;
Función setup
En la función setup inicializamos el monitor serie y ponemos los pines de los LEDs en modo salida.
void setup() {
// Iniciamos el monitor serie
Serial.begin(9600);
// Los pines de LED en modo salida
pinMode(LEDVERDE, OUTPUT);
pinMode(LEDAMARILLO, OUTPUT);
pinMode(LEDROJO, OUTPUT);
}Función loop
Comenzamos la función loop que se repetirá continuamente. Lo primero es leer el pin analógico y almacenarlo en la variable analogValor.
void loop() {
// Leemos valor de la entrada analógica
analogValor = analogRead(ANALOGPILA);Calculamos el voltaje. Es una simple regla de 3. Si 5V es 1024, con dividir 5 entre 1024 y multiplicarlo por el valor que nos da el pin analógico, ya tenemos el voltaje. Así de sencillo. Para comprobar que todo está bien lo mostramos por el monitor serie.
// Obtenemos el voltaje
voltaje = 0.0048 * analogValor;
Serial.print("Voltaje: ");
Serial.println(voltaje);En la siguiente parte vamos a decidir que LEDs debemos de encender. Esto lo hacemos a través de las estructuras condicionales if.
// Dependiendo del voltaje mostramos un LED u otro
if (voltaje >= maximo)
{
digitalWrite(LEDVERDE, HIGH);
delay(ledDelay);
digitalWrite(LEDVERDE, LOW);
}
else if (voltaje < maximo && voltaje > medio)
{
digitalWrite(LEDAMARILLO, HIGH);
delay(ledDelay);
digitalWrite(LEDAMARILLO, LOW);
}
else if (voltaje < medio && voltaje > minimo)
{
digitalWrite(LEDROJO, HIGH);
delay(ledDelay);
digitalWrite(LEDROJO, LOW);
}Por último, apagamos todos los LEDs. Así comenzamos en la siguiente iteración con el estado inicial todos apagados. Como estamos hablando de muy poco tiempo, microsegundos, esto no afectará al funcionamiento.
// Apagamos todos los LEDs digitalWrite(LEDVERDE, LOW); digitalWrite(LEDAMARILLO, LOW); digitalWrite(LEDROJO, LOW); }
Código completo
A continuación te dejo el código completo para que no tengas que ir copiando parte por parte. No es muy buena práctica copiar y pegar sin leer lo anterior. Si realmente quieres aprender, sigue todos los pasos e intenta tu mismo escribir el código.
// Pines para los LEDs
#define LEDVERDE 2
#define LEDAMARILLO 3
#define LEDROJO 4
#define ANALOGPILA 0
// Variables
int analogValor = 0;
float voltaje = 0;
int ledDelay = 800;
// Umbrales
float maximo = 1.6;
float medio = 1.4;
float minimo = 0.3;
void setup() {
// Iniciamos el monitor serie
Serial.begin(9600);
// Los pines de LED en modo salida
pinMode(LEDVERDE, OUTPUT);
pinMode(LEDAMARILLO, OUTPUT);
pinMode(LEDROJO, OUTPUT);
}
void loop() {
// Leemos valor de la entrada analógica
analogValor = analogRead(ANALOGPILA);
// Obtenemos el voltaje
voltaje = 0.0048 * analogValor;
Serial.print("Voltaje: ");
Serial.println(voltaje);
// Dependiendo del voltaje mostramos un LED u otro
if (voltaje >= maximo)
{
digitalWrite(LEDVERDE, HIGH);
delay(ledDelay);
digitalWrite(LEDVERDE, LOW);
}
else if (voltaje < maximo && voltaje > medio)
{
digitalWrite(LEDAMARILLO, HIGH);
delay(ledDelay);
digitalWrite(LEDAMARILLO, LOW);
}
else if (voltaje < medio && voltaje > minimo)
{
digitalWrite(LEDROJO, HIGH);
delay(ledDelay);
digitalWrite(LEDROJO, LOW);
}
// Apagamos todos los LEDs
digitalWrite(LEDVERDE, LOW);
digitalWrite(LEDAMARILLO, LOW);
digitalWrite(LEDROJO, LOW);
}Hasta el próximo articulo Comunidad . Saludos Peter
Etiquetas:
- arduino
Publicación by Peter is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 Internacional
