En este artículo te voy a explicar cómo podemos hacer un medidor de carga de baterías y pilas. Lo haremos a través del montaje de un circuito con Arduino.
Suele ser muy típico que tengamos por casa diferentes aparatos eléctricos que utilizan pilas o baterías. En ocasiones, dudamos si el dispositivo está roto o las pilas se han gastado.
Gracias a este proyecto esto ya no será un problema. El medidor de carga de baterías y pilas te dará la solución.
Indice de contenidos
Objetivo del medidor de carga de baterías y pilas con la placa de Arduino
Utilizaremos 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 ojo 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. Comprueba antes de conectar que realmente es menor o igual que 5V.
Medir más de 5V por alguna entrada analógica puede dañar la placa.
Componentes de Arduino que vamos a utilizar
Vamos a ver que tipo de componentes necesitamos para este circuito.
- Arduino UNO o cualquier placa de Arduino
- Protoboard donde conectaremos los componentes
- Cables para la conexión entre los componentes y la placa
- 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
Como ves se trata de un circuito muy simple. Con 3 LEDs y 4 resistencias es suficiente para construir un medidor de carga de baterías o pilas con Arduino.
Montando el circuito con Arduino
Una vez recopilada toda la información, pasamos al montaje. En la siguiente imagen te muestro cómo debes conectar los diferentes componentes. Presta atención sobre todo en las resistencias.
Vamos a ver como se han conectado los componentes. Lo primero son los LEDs. Cada uno está conectado en serie con una resistencia de 220 Ω para alargar 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 quitar 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. Por último, el polo negativo de la batería debemos conectarlo a la tierra de Arduino.
Cuidado con invertir las polaridades es decir, el positivo con negativo o viceversa.
Es más que aconsejable que todos los componentes tengan la misma referencia a tierra. Todos deben estar conectados al mismo pin GND de Arduino.
Programando el medidor de carga de baterías y pilas con Arduino
Ahora toca la parte de la lógica y la programación. Lo primero que debemos hacer, es plantear el problema o el algoritmo que queremos conseguir. Una vez que lo tengamos claro ya podemos empezar a programar. Como siempre digo, un algoritmo es una secuencia de pasos ordenados que debemos seguir para conseguir un objetivo. En este caso nuestro objetivo es medir la carga de de una pila o batería con Arduino.
Algoritmo
En esta sección voy a detallar los pasos que 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
- Si es mayor o igual que el umbral máximo
- 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.
Código nativo de Arduino
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.
|
1 2 3 4 5 |
// 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
|
1 2 3 4 5 6 7 8 9 |
// 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.
|
1 2 3 4 5 6 7 8 9 10 |
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.
|
1 2 3 |
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.
|
1 2 3 4 |
// 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.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
// 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.
|
1 2 3 4 5 |
// 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. Solo así, aprenderás a programar con Arduino.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
// 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); } |