Cargador inteligente de baterías avanzado con multiplexación y display digital

Componentes y suministros

• Arduino UNO × 1
• Proto Shield para Arduino × 1
• Sensor ultrasónico HC-SR04 × 1
• ADC MCP3008 8 canales 10-bit (Adafruit) × 1
• Relé 5V 2 canales optoacoplado × 3
• Módulo buck LM2596 3A ajustable × 1
• Resistencias 1kΩ × 12
• Tira de terminales 6 posiciones × 1

Herramientas necesarias

• Soldador (genérico)

Sobre el proyecto

Este cargador inteligente multiplexado permite mantener hasta 6 baterías de 12V (coches, barcos, generadores) usando un solo cargador inteligente. El Arduino conmuta el cargador entre baterías automáticamente, monitorizando voltajes y ciclos de carga.

Motivación: El autor tiene 5 vehículos/baterías y los cargadores inteligentes individuales cuestan ~$29 cada uno. La solución: un cargador compartido que rota entre baterías.

Funcionamiento

• Soporta 1-6 baterías. La batería 1 alimenta al Arduino (regulador de voltaje).
• Detección automática: si voltaje >8V, se añade al ciclo de carga.
• MCP3008 expande entradas analógicas (A4/A5 usados por LCD I2C). Divisor de tensión 2×1kΩ por canal.
• Ciclo de carga configurable (default: 1 hora por batería).
• Display LCD I2C 16x2 muestra voltajes de 2-2 baterías alternando.
• Sensor HC-SR04 apaga display tras inactividad; pasa mano → enciende.
• Modo test: mano sostenida sobre HC-SR04 acelera ciclo a segundos para ver conmutación relés.

Funciones principales

1. read_show_volts(): Lee voltajes (canales 0-2 del MCP3008), actualiza LCD, detecta baterías conectadas (>1V), actualiza array de relés activos.
2. checkRelays(): Temporizador rota al siguiente relé activo al alcanzar charge_time_max.
3. toggle_relays(): Apaga todos, enciende el actual, muestra número en LCD.
4. read_distance(): HC-SR04 gestiona encendido/apagado LCD por proximidad.

Variables clave

• chargeTime = 10*1000 ms (10 seg en código, 1 hora en producción)
• charge_time_max = 60 ciclos
• volts_update = 500 ms
• time_on_count = 100 seg display encendido

Código

#include <Wire.h>
#include <LiquidCrystal_I2C.h> // v1.2.1
#include <timer.h>
#include <HCSR04.h>

auto timer = timer_create_default();
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

int chargeTime = (10 * 1000);
int charge_time_counter = 59;
int charge_time_max = 60;
int relay1 = 3, relay2 = 4, relay3 = 5;
int current_relay = 0;
int max_relays = 3;
float volts1, volts2, volts3;
int min_volts = 1;
int volts_update_count = 5;
int volts_update_counter = 0;
int volts_update = 500;
int read_distance_update = 500;
int time_on_counter = 0;
int time_on_count = 100;
int heart_beat = 0;
UltraSonicDistanceSensor distanceSensor(11, 12);
int distance;
int relays[] = { relay1, relay2, relay3 };
int is_live[] = { 0, 0, 0 };
int debug = 5;

void all_change_to(int which) {
  digitalWrite(relay1, which);
  digitalWrite(relay2, which);
  digitalWrite(relay3, which);
}

void toggle_relays(int whichOne) {
  lcd.setCursor(0, 0);
  lcd.print("Relay on:");
  lcd.print(current_relay + 1);
  all_change_to(HIGH);
  digitalWrite(relays[current_relay], LOW);
  acnt++;
  lcd.print(" ");
  lcd.print(acnt);
}

void checkRelays() {
  charge_time_counter++;
  if (charge_time_counter >= charge_time_max) {
    current_relay++;
    if (current_relay >= max_relays) current_relay = 0;
    toggle_relays(current_relay);
    charge_time_counter = 0;
  }
}

void read_distance() {
  distance = distanceSensor.measureDistanceCm();
  if (distance < 80) {
    lcd.backlight();
    time_on_counter = 0;
  } else {
    time_on_counter++;
    if (time_on_counter > time_on_count) {
      time_on_counter = 0;
      lcd.noBacklight();
    }
  }
}

void read_show_volts() {
  volts1 = analogRead(0) * 0.016;
  lcd.setCursor(11, 0);
  lcd.print(volts1);

  volts2 = analogRead(1) * 0.0164;
  lcd.setCursor(4, 1);
  lcd.print(volts2);

  volts3 = analogRead(2) * 0.0166;
  lcd.setCursor(11, 1);
  lcd.print(volts3);

  int temp_cnt = 0;
  relays[0] = relays[1] = relays[2] = 0;
  if (volts1 > min_volts) { relays[temp_cnt] = relay1; temp_cnt++; }
  if (volts2 > min_volts) { relays[temp_cnt] = relay2; temp_cnt++; }
  if (volts3 > min_volts) { relays[temp_cnt] = relay3; temp_cnt++; }
  max_relays = temp_cnt;

  lcd.setCursor(0, 1);
  lcd.print(heart_beat == 1 ? "<>" : "><");
  heart_beat = 1 - heart_beat;
  lcd.print(charge_time_counter);
  read_distance();
}

void setup() {
  Serial.begin(19200);
  Serial.println("Starting");
  lcd.begin(16, 2);
  lcd.backlight();
  pinMode(relay1, OUTPUT);
  pinMode(relay2, OUTPUT);
  pinMode(relay3, OUTPUT);
  all_change_to(HIGH);
  read_show_volts();
  checkRelays();
  timer.every(chargeTime, checkRelays);
  timer.every(volts_update, read_show_volts);
}

void loop() {
  timer.tick();
}

Esquemático

Esquema del multiplexor disponible en el proyecto original. Incluye: Arduino UNO, MCP3008 (SPI), 3 relés, divisores de tensión, LCD I2C, HC-SR04, LM2596 para alimentación.