Medidor de carga de baterías y pilas con Arduino paso a paso

 

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

• 1 Objetivo del medidor de carga de baterías y pilas con la placa de Arduino
• 2 Componentes de Arduino que vamos a utilizar
• 3 Montando el circuito con Arduino
• 4 Programando el medidor de carga de baterías y pilas con Arduino
• 5 Código nativo de Arduino

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.

1. Leer el pin analógico donde tenemos conectada la pila
2. Calculamos el voltaje para el valor que nos ha dado
3. Evaluamos el voltaje
   1. Si es mayor o igual que el umbral máximo
      1. Encendemos LED verde
   2. Si es menor que el umbral máximo y mayor que el umbral medio
      1. Encendemos LED amarillo
   3. Si es menor que el umbral medio y mayor que el umbral mínimo
      1. Encendemos LED rojo
   4. El resto de los casos
      1. No enciende ningún LED
4. 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.

// 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.

160 // 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. Solo así, aprenderás a programar con Arduino.

// 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);

}

 

Fuente:

https://programarfacil.com/blog/arduino-blog/medidor-de-carga-de-baterias-pilas-arduino/

¿Es posible actualizar el procesador de una Game Boy?

 

Una modificación más para la inagotable portátil de Nintendo

 

La familia Game Boy no necesita ninguna clase de introducción a esta altura, pero lo que realmente nos sorprende es la cantidad de mods y hacks disponibles para cada modelo. Desde backlights y pantallas de reemplazo hasta PCBs nuevos que permiten crear consolas desde cero, hoy es posible reparar y transformar a cualquier Game Boy por completo. Sin embargo, Elliot del canal The Retro Future decidió compartir un mod muy singular: La actualización del procesador en una consola Game Boy. La pregunta es… ¿actualización a qué?

---

Si tienes una consola Game Boy dañada o con alguna falla específica, no te preocupes: Lo más probable es que puedas obtener piezas de repuesto (ya sean de otra consola o reproducciones modernas) con relativa facilidad. Al mismo tiempo, la familia Game Boy presenta una oportunidad fabulosa para todo aquel que desee mojarse los pies en las aguas del modding. Desde carcasas metálicas hasta reemplazos de alta definición para la pantalla LCD, crear la Game Boy de nuestros sueños no es imposible.

Ahora, ¿qué sucede con la velocidad? En la Web existen muchas guías para hacer overclocking en la Game Boy, algo bastante útil si consideramos que el grind en ciertos juegos es eterno (buena suerte encontrando ese shiny en Pokémon), pero Elliot del canal The Retro Future decidió jugar con el procesador de otra forma: Reemplazándolo con una actualización.

---

Actualizando el procesador de una consola Game Boy

 

---

La primera duda es: ¿De dónde sale el procesador actualizado? Su donante es nada menos que un Super Game Boy, adaptador que llegó a las estanterías en junio de 1994. Básicamente se trata de una Game Boy en formato de cartucho para Super Nintendo, que permite al usuario disfrutar de los juegos de Game Boy en el televisor, con controles de SNES y paletas de color adicionales.

---

El Super Game Boy, versión estadounidense

---

Una búsqueda rápida por eBay confirma que el Super Game Boy no es un dispositivo raro. Por otro lado, su modelo original tiene la característica (a veces deseada, a veces no) de acelerar los juegos de Game Boy en un 2.41 por ciento, debido al divisor de frecuencia utilizado por la SNES. La versión 2 del Super Game Boy corrige ese detalle, al igual que el Game Boy Player para GameCube.

---

Retirando el chip original

---

La buena noticia es que la instalación del chip es drop-in, por lo que no requiere ninguna modificación. La mala es que se necesita aire caliente para retirar y reinstalar ambos chips sin causar daño. Una estación normal como la que compró Elliot es más que suficiente. El resto es cuestión de practicar un poco, tener paciencia y no desesperar.

---

El procesador del Super Game Boy, junto al DMG-CPU original. El «nuevo» chip es compatible pin por pin.

---

¿Cuáles son las ventajas de actualizar el procesador en una Game Boy? En una consola Game Boy estándar, los juegos tardan 5.7 segundos en cargar, combinando inicialización y animación de Nintendo. Después del mod, los juegos se cargan de forma instantánea… y nada más que eso. La frecuencia sigue gobernada por el reloj interno de la consola, y no hay cambios generales de velocidad. Alguno podrá pensar que se trata de una broma, pero es bueno saber que el procesador en una Game Boy puede ser reemplazado de este modo.

Fuente:

https://www.neoteo.com/es-posible-actualizar-el-procesador-de-una-game-boy/