Medidor de pilas luminoso - Blue Electron Labs

Después de encontrar varias pilas sueltas mientras organizaba unos cajones se me ocurrió que sería interesante construir un medidor de pilas luminoso, el cual muestre una animación con un determinado color dependiendo de la carga de la pila que se pretende medir.

Boceto del medidor

Las pilas que se quieren medir son AA y AAA. Dado que ambas tienen la misma forma (aunque diferente tamaño), será un buen detalle que el medidor tenga forma de pila. Así pues, el cuerpo del medidor tendrá tres alojamientos, uno central donde introducir la pila de 9 voltios con la que funcionará el sistema y los otros dos, uno para las pilas a medir y otro donde colocar un visor de metacrilato que habrá sido rayado para que refleje la luz y se vea mejor.

Por otro lado se tendrán dos tapas, la superior, donde colocar un interruptor con el que encender y apagar el medidor y una inferior donde colocar la electrónica que controlará un led RGB.

Diseño en tres dimensiones y fabricación en la impresora 3D

Después de hacer el diseño tridimensional del medidor, se ha impreso en la impresora 3D utilizando filamento de PLA con fibras de madera para darle un toque mas rústico. También se ha cortado el metacrilato haciéndole el rayado reflector.

Esquema electrónico

En el esquema electrónico se pueden ver los dos terminales de alimentación H1 y H2 a los que se conectará la pila de 9 voltios. Los terminales H3 y H4 se conectarán al interruptor para controlar el encendido y apagado del medidor.

La tensión de alimentación es de 9 voltios pero se reduce a 5V gracias a un regulador LM7805. Con esta tensión se alimentará un microcontrolador Attiny 84.

La pila a medir se conectará mediante los pines H5 y H6 a una entrada analógica del microcontrolador, mediante esta, el micro obtendrá el voltaje de la pila y utilizando tres salidas pwm se alimentarán los pines R, G y B del led, produciendo el color correspondiente al nivel de carga de la pila.

En paralelo con los pines H5 y H6 se coloca una resistencia para que haya consumo en la pila mientras se realiza la medición, de esta forma se obtiene el valor real de tensión de la pila.

PCB y vista en 3D de la placa de control

A partir del esquema electrónico se ha diseñado la PCB con la forma necesaria para encajarla en la tapa inferior del medidor. Se puede ver un modelo 3D de como quedaría y como ha quedado finalmente después de soldar los componentes.

Código fuente

const int lectorPila = A1; //pin de lectura de la pila
int pila; //valor leído de la pila
int pinR = 6; //pin conexión led R
int pinG = 7; //pin conexión led G
int pinB = 8; //pin conexión led B


void setup() {
  pinMode(pinR,OUTPUT);     //define pinR como salida
  pinMode(pinG,OUTPUT);     //define pinG como salida
  pinMode(pinB,OUTPUT);     //define pinB como salida
  analogReference(DEFAULT); //referenccia de las entradas analógicas por defecto (5V)
  ColorLed(0,0,0);          //led apagado
}

void loop() {

  pila = analogRead(lectorPila); //lectura analógica de la tensión en la pila

  if(pila>=286){PilaLlena();}               //pila llena con 1,4 voltios o más
  if(pila<286 and pila >=245){PilaMedia();} //pila media entre 1,4 y 1,2 voltios
  if(pila<245 and pila >=205){PilaBaja();}  //pila baja entre 1,2 y 1 voltio
  if(pila<205){PilaVacia();}                //pila vacía con menos de 1 voltio*/

}

void PilaLlena()  
{
  int r = 0;  //valor del color rojo
  int b = 0;  //valor del color azul

  while(b<255)  //azul ascendente
    {
      ColorLed(0,0,b);
      b++;
      delay(5);
    }
  while(1)
  {
    while(r<255)  //rojo ascendente
    {
      ColorLed(r,0,b);
      r++;
      delay(2);
    }
    while(r>0)  //rojo descendente
    {
      ColorLed(r,0,b);
      r--;
      delay(5);
    }
    //Si cambia el nivel de la pila se sale del bucle
    pila = analogRead(lectorPila);
    if(pila<286){break;}
  }
}

void PilaMedia()  
{
  int g = 0;  //valor del color verde

  while(1)
  {
    while(g<255)  //verde ascendente rápido
    {
      ColorLed(0,g,0);
      g++;
      delay(1);
    }
    delay(500);
    while(g>0)  //verde descendente lento
    {
      ColorLed(0,g,0);
      g--;
      delay(5);
    }
    //Si cambia el nivel de la pila se sale del bucle
    pila = analogRead(lectorPila);
    if(pila>286 or pila <245){break;}
  }
}

void PilaBaja() 
{
  int r = 0;  //valor del color rojo
  int g = 0;  //valor del color verde
  int b = 0;  //valor del color azul

  while(1)
  {
    while(r<200)  //naranja ascendente
    {
      ColorLed(r,g,0);
      r++;
      g=r/15;
      delay(10);
    }
    while(r>15) //naranja descendente
    {
      ColorLed(r,g,0);
      r--;
      g=r/15;
      delay(10);
    }
    //Si cambia el nivel de la pila se sale del bucle
    pila = analogRead(lectorPila);
    if(pila>245 or pila <205){break;}
  }
}

void PilaVacia()  
{
  while(1)
  {
    ColorLed(255,0,0);  //color rojo on
    delay(500);
    ColorLed(0,0,0);  //color rojo off
    delay(500);
    //Si cambia el nivel de la pila se sale del bucle
    pila = analogRead(lectorPila);
    if(pila>205){break;} 
  }
}

void ColorLed(byte para_R, byte para_G, byte para_B)
{
  analogWrite(pinR, para_R); //escritura del color rojo en el pinR
  analogWrite(pinG, para_G); //escritura del color verde en el pinG
  analogWrite(pinB, para_B); //escritura del color azul en el pinB
}

Montaje del medidor

Finalmente, con todos los componentes del medidor preparados se ha procedido a montarlo.

Se han encajado en el cuerpo los dos terminales en los que conectar las pilas a medir y se ha introducido el visor en su alojamiento.

Se ha colocado el botón en la tapa superior e introducido la pila en el cuerpo.

Por último, se han pasado todos los cables a la zona inferior y se han soldado a la placa, encajándola en la tapa inferior y terminando el montaje del medidor con el atornillado de las dos tapas.