Caso práctico: protector 12 V con Arduino UNO

Objetivo y caso de uso

Qué construirás: Un controlador de desconexión de carga por batería baja de 12 V usando un Arduino UNO R3, divisor de voltaje, módulo de relé de 1 canal y LCD HD44780 de 16×2. Toma muestras continuas del voltaje de la batería, muestra la lectura en vivo en el LCD y corta la alimentación de la carga cuando la batería cae por debajo de un umbral seguro como 11.8 V, luego la reconecta solo después de la recuperación con histéresis.

Por qué importa / Casos de uso

Protege una pequeña batería de plomo-ácido de 12 V en un cobertizo solar, caja de iluminación o sistema de energía portátil desconectando cargas como tiras LED, un ventilador de 5–20 W o pequeños accesorios de CC antes de que ocurra una descarga profunda dañina.
Evita problemas de “batería misteriosamente agotada” en proyectos de hobby que funcionan durante la noche colocando el controlador entre la batería y la carga, preservando carga utilizable para el día siguiente.
Proporciona un monitor educativo de batería para laboratorios y talleres donde los estudiantes puedan observar actualizaciones de voltaje en vivo en el LCD, probar puntos de corte y ver cómo la histéresis evita el golpeteo rápido del relé cerca del umbral.

Resultado esperado

Medición de voltaje actualizada aproximadamente 2–5 veces por segundo en el LCD, con una latencia práctica de monitoreo inferior a 500 ms.
Corte automático por relé cuando el voltaje de la batería cae por debajo de un límite definido, por ejemplo 11.8 V, con reconexión por encima de un umbral mayor como 12.4 V.
Comportamiento de conmutación estable con carga mínima sobre el Arduino UNO, típicamente muy por debajo del 10% de uso de CPU y sin uso significativo de GPU.
Un módulo de protección reutilizable que puede reajustarse para distintos sistemas de 12 V ajustando la calibración del divisor y los umbrales de voltaje.

Audiencia: principiantes en Arduino, estudiantes y aficionados que construyen sistemas alimentados por batería; Nivel: principiante a intermedio

Arquitectura/flujo: batería de 12 V → divisor de voltaje → entrada analógica de Arduino para sensado escalado; Arduino → LCD 16×2 para mostrar voltaje/estado en vivo; salida digital de Arduino → módulo de relé de 1 canal → desconexión/reconexión de carga según lógica de umbral e histéresis.

Nota educativa de validación

Antes de publicar este caso, el contenido pasó la puerta automática de validación de Prometeo con estado PASS. El validador comprobó los bloques de código, la estructura del artículo, los comandos copiables y la coherencia con el catálogo de dispositivos soportados.

Evidencia de validación publicada

Resultado automático: PASS.
Estructura parseada: 3 apartados, 4 tablas y 3 bloques de código detectados antes de publicar.
Código comprobado: 1 Arduino/arduino-cli compile, 1 Bash/copy-paste checks.
Catálogo soportado: el texto se contrastó contra los perfiles de dispositivo validables de Prometeo y los stacks no soportados bloquean la publicación.
Hallazgos del informe: sin hallazgos bloqueantes.

Esta validación confirma compatibilidad sintáctica y de herramientas para el material publicado, pero no sustituye la prueba física sobre tu hardware, cableado y entorno exactos.

Nota educativa de seguridad

Este proyecto es un prototipo educativo de bajo voltaje, no un producto certificado de protección de batería. Sus límites deben entenderse con claridad.

Seguridad de la batería
Incluso a 12 V, las baterías pueden entregar corriente muy alta.
Un error de cableado puede sobrecalentar los cables, dañar la batería o causar chispas.
Usa un fusible en línea en el conductor positivo de la batería al pasar más allá de una demostración en protoboard.
Seguridad de los contactos del relé
El módulo de relé controla el camino de la carga, pero su capacidad nominal de contacto debe coincidir con la carga real.
No conmutar cargas que excedan la especificación de corriente o voltaje del módulo.
No asumir que el módulo de relé es adecuado para cargas inductivas, motores o cargas con altos picos sin la protección apropiada.
Sin voltaje de red
Este tutorial debe usarse solo para trabajo educativo de CC de bajo voltaje.
No uses el módulo de relé para conmutar la red eléctrica doméstica a menos que tengas formación formal, prácticas adecuadas de aislamiento y hardware conforme. Eso queda fuera del alcance de este tutorial básico.
Límites de la protoboard
Las protoboards son adecuadas para lógica y pruebas ligeras, pero no son ideales para caminos de batería/carga de corriente más alta.
Para un prototipo reutilizable real, lleva el cableado de la carga a terminales apropiados, cables más gruesos y una carcasa protegida.
Límites de la química de la batería
Los umbrales de ejemplo aquí son valores educativos por defecto para una demostración simple de 12 V.
Diferentes baterías requieren distintos límites de voltaje y reglas de carga/descarga.
Antes del uso práctico, establece umbrales adecuados para tu tipo de batería y caso de uso.
Límites del prototipo
Este proyecto es útil como herramienta de enseñanza y como protector simple de batería para hobby, pero no sustituye a un sistema de gestión de baterías diseñado profesionalmente.
No debe usarse para infraestructura crítica, vehículos, instalaciones desatendidas de alta potencia ni equipos críticos para la seguridad.

Diagrama de bloques conceptual

Vista de alto nivel: qué entra, qué procesa cada bloque y qué sale del sistema.

Arquitectura funcional

batería de 12 V

divisor de voltaje

entrada analógica de Arduino para sensado…

LCD 16×2 para mostrar voltaje/estado en v…

módulo de relé de 1 canal

desconexión/reconexión de carga según lóg…

Flujo conceptual de señales y responsabilidades entre bloques del dispositivo.

Ruta de validación

Sketch

arduino-cli compile

Upload

Prueba funcional

Resumen conceptual de las herramientas usadas para comprobar el material publicado.

Requisitos previos

Antes de comenzar, el estudiante debe sentirse cómodo con:

Subir un sketch a un Arduino UNO R3
Usar una protoboard y cables jumper
Medir voltaje de CC con un multímetro
Entender que:
los pines de entrada analógica miden solo de 0 a 5 V
se requiere un divisor de voltaje para una batería de 12 V
un relé es un interruptor controlado por el Arduino, no un regulador de potencia

Conocimientos de base recomendados:

Ley de Ohm a nivel básico
Salidas digitales (HIGH / LOW)
Lectura analógica con analogRead()

También prepara una fuente de batería segura de bajo voltaje, como:

una pequeña batería sellada de plomo-ácido de 12 V,
o una fuente de alimentación de banco con corriente limitada ajustada de 10.5 V a 13.5 V para pruebas.

Materiales

Usa exactamente este modelo y familia de dispositivo:

Arduino UNO R3 (ATmega328P) + divisor de voltaje + módulo de relé de 1 canal + LCD HD44780 de 16×2

Lista de piezas sugeridas:

Elemento	Especificación exacta / sugerida	Propósito
Controlador principal	Arduino UNO R3 (ATmega328P)	Lee el voltaje, controla el relé, actualiza el LCD
Pantalla	LCD compatible con HD44780 de 16×2, interfaz paralela	Muestra voltaje y estado de la carga
Placa de relé	Módulo de relé de 1 canal de 5 V	Conecta/desconecta la carga
Resistencia del divisor R1	30 kOhm, 1/4 W, 1% preferido	Resistencia superior para medición de batería
Resistencia del divisor R2	7.5 kOhm, 1/4 W, 1% preferido	Resistencia inferior para medición de batería
Capacitor de filtro opcional	Cerámico de 100 nF	Filtrado de ruido en la entrada analógica
Lado batería/carga	Batería de 12 V o fuente de banco con corriente limitada	Fuente de prueba
Carga de prueba	Lámpara de 12 V, ventilador pequeño, carga resistiva o segmento de tira LED	Demuestra la función de desconexión
Cables	Cables jumper y conductores de batería	Interconexión
Protoboard	Tamaño completo o medio tamaño	Montaje
Cable USB	USB A a B para UNO	Programación y alimentación
Multímetro	Multímetro digital	Verificación del divisor y del voltaje de batería

¿Por qué 30 kOhm y 7.5 kOhm?

Este divisor escala el voltaje de la batería por:

[
V_{A0} = V_{BAT} \times \frac{7.5}{30 + 7.5} = V_{BAT} \times 0.2
]

Entonces:

una batería de 12.0 V se convierte en aproximadamente 2.4 V en A0
una batería de 15.0 V se convierte en aproximadamente 3.0 V en A0

Eso permanece de forma segura por debajo del límite analógico de 5 V del Arduino.

Configuración/Conexión

Esta sección explica el cableado solo con texto y tablas, como se solicitó.

1) Disposición de alimentación

Para seguridad y claridad para principiantes:

Alimenta el Arduino UNO desde el cable USB
Alimenta el módulo de relé desde los 5 V y GND del Arduino
Usa la batería solo para:
la medición mediante el divisor de voltaje
y el camino de carga conmutado a través de los contactos del relé

Esto mantiene simple el lado lógico durante las pruebas.

2) Cableado del divisor de voltaje

Conecta el divisor de medición de batería así:

Positivo de batería -> R1 (30 kOhm) -> punto medio del divisor
Punto medio del divisor -> R2 (7.5 kOhm) -> negativo de batería
Punto medio del divisor -> Arduino A0
Negativo de batería -> Arduino GND

Reducción de ruido opcional:

Coloca un capacitor de 100 nF de A0 a GND

Importante:

El Arduino debe compartir tierra con el negativo de la batería para medir voltaje.
Nunca conectes el positivo de la batería directamente a A0.

3) Cableado del módulo de relé

La mayoría de los módulos de relé de 1 canal tienen estos pines de bajo voltaje:

VCC
GND
IN

Conecta:

Relé VCC -> Arduino 5V
Relé GND -> Arduino GND
Relé IN -> pin digital 8 del Arduino

Para los contactos conmutados de la carga, la mayoría de los módulos proporcionan:

COM
NO (normalmente abierto)
NC (normalmente cerrado)

Usa el relé para que la carga reciba alimentación solo cuando la batería esté en buen estado:

Positivo de batería -> relé COM
Relé NO -> positivo de carga
Negativo de carga -> negativo de batería

Esto significa:

cuando el relé está activado y el sistema permite la carga, COM se conecta a NO
cuando ocurre el corte, la conexión se abre y la carga se apaga

4) Cableado del LCD

Este tutorial usa el modo paralelo de 4 bits con la biblioteca estándar LiquidCrystal.

Conecta los pines del LCD de la siguiente manera:

LCD VSS -> GND
LCD VDD -> 5V
LCD VO -> control de contraste
Práctica recomendada: conectar al pin central de un potenciómetro de 10 kOhm
Otros extremos del potenciómetro -> 5V y GND
LCD RS -> pin 12 del Arduino
LCD RW -> GND
LCD E -> pin 11 del Arduino
LCD D4 -> pin 5 del Arduino
LCD D5 -> pin 4 del Arduino
LCD D6 -> pin 3 del Arduino
LCD D7 -> pin 2 del Arduino
LCD A (retroiluminación +) -> 5V a través de una resistencia adecuada si tu módulo lo requiere
LCD K (retroiluminación -) -> GND

5) Resumen completo de conexiones

Función	Pin del módulo	Conexión Arduino / batería
Entrada de medición de batería	Punto medio del divisor	A0
Parte inferior del divisor	Extremo inferior de R2	GND y negativo de batería
Control del relé	IN	D8
Alimentación del relé	VCC	5V
Tierra del relé	GND	GND
LCD RS	RS	D12
LCD Enable	E	D11
Datos LCD	D4	D5
Datos LCD	D5	D4
Datos LCD	D6	D3
Datos LCD	D7	D2
Alimentación LCD	VDD	5V
Tierra LCD	VSS	GND
LCD RW	RW	GND

6) Estrategia de umbrales

Para una demostración de batería de 12 V:

Umbral de desconexión: 11.80 V
Umbral de reconexión: 12.40 V

Esto crea histéresis. Sin histéresis, el relé podría vibrar alrededor de un solo umbral.

También es útil un breve retardo de corte. En este proyecto:

el voltaje debe permanecer por debajo del umbral de desconexión durante varios segundos antes de que el relé se abra

Eso ayuda a ignorar caídas temporales.

Código validado

`low_battery_load_disconnect.ino`

Vista pública parcial del archivo validado. El código completo se muestra a miembros y en PDF/Print.

#include <LiquidCrystal.h>

// LCD pins: RS, E, D4, D5, D6, D7
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// Pin assignments
const int PIN_BATTERY = A0;
const int PIN_RELAY = 8;

// Relay module behavior:
// Many modules are ACTIVE LOW.
// Set RELAY_ON_LEVEL and RELAY_OFF_LEVEL to match your hardware.
const int RELAY_ON_LEVEL = LOW;
const int RELAY_OFF_LEVEL = HIGH;

// Voltage divider values in ohms
const float R1 = 30000.0;  // battery+ to A0
const float R2 = 7500.0;   // A0 to GND

// ADC reference for standard UNO powered by USB
const float ADC_REF_VOLTAGE = 5.0;
const int ADC_MAX = 1023;

// Battery thresholds
const float DISCONNECT_VOLTAGE = 11.80;
const float RECONNECT_VOLTAGE  = 12.40;

// Timing
const unsigned long SAMPLE_INTERVAL_MS = 250;
const unsigned long LCD_INTERVAL_MS = 500;
const unsigned long SERIAL_INTERVAL_MS = 1000;
const unsigned long LOW_VOLTAGE_DELAY_MS = 5000;

// Averaging
const int NUM_SAMPLES = 20;

// State variables
bool loadConnected = true;
bool lowVoltagePending = false;
unsigned long lowVoltageStartMs = 0;
unsigned long lastSampleMs = 0;
unsigned long lastLcdMs = 0;
unsigned long lastSerialMs = 0;
float filteredBatteryVoltage = 0.0;

// Read battery voltage using averaging
float readBatteryVoltage() {
  long total = 0;

  for (int i = 0; i < NUM_SAMPLES; i++) {
    total += analogRead(PIN_BATTERY);
    delay(2);
  }

  float adc = total / (float)NUM_SAMPLES;
  float vA0 = adc * ADC_REF_VOLTAGE / ADC_MAX;
  float batteryVoltage = vA0 * ((R1 + R2) / R2);

  return batteryVoltage;
}

void setLoadConnected(bool enabled) {
  loadConnected = enabled;
  digitalWrite(PIN_RELAY, enabled ? RELAY_ON_LEVEL : RELAY_OFF_LEVEL);
}

void updateControlLogic(float vbat, unsigned long nowMs) {
  if (loadConnected) {
    if (vbat < DISCONNECT_VOLTAGE) {
      if (!lowVoltagePending) {
        lowVoltagePending = true;
        lowVoltageStartMs = nowMs;
      } else if ((nowMs - lowVoltageStartMs) >= LOW_VOLTAGE_DELAY_MS) {
        setLoadConnected(false);
        lowVoltagePending = false;
      }
    } else {
      lowVoltagePending = false;
    }
  } else {
    // Load is disconnected; reconnect only after voltage rises enough
    if (vbat > RECONNECT_VOLTAGE) {
      setLoadConnected(true);
      lowVoltagePending = false;
    }
// ...

  }
}

void updateLcd(float vbat, unsigned long nowMs) {
  if (nowMs - lastLcdMs < LCD_INTERVAL_MS) {
    return;
  }
  lastLcdMs = nowMs;

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Bat:");
  lcd.print(vbat, 2);
  lcd.print("V");

  lcd.setCursor(0, 1);

  if (loadConnected) {
    if (lowVoltagePending) {
      unsigned long elapsed = nowMs - lowVoltageStartMs;
      unsigned long remain = 0;
      if (elapsed < LOW_VOLTAGE_DELAY_MS) {
        remain = (LOW_VOLTAGE_DELAY_MS - elapsed + 999) / 1000;
      }
      lcd.print("LOW WAIT ");
      lcd.print(remain);
      lcd.print("s");
    } else {

🔒 Este contenido es premium. Con la suscripción mensual (7 días gratis) podrás desbloquear el material didáctico completo y el pack PDF listo para imprimir.🔓 Desbloquéalo — 7 días gratis

#include <LiquidCrystal.h>

// LCD pins: RS, E, D4, D5, D6, D7
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// Pin assignments
const int PIN_BATTERY = A0;
const int PIN_RELAY = 8;

// Relay module behavior:
// Many modules are ACTIVE LOW.
// Set RELAY_ON_LEVEL and RELAY_OFF_LEVEL to match your hardware.
const int RELAY_ON_LEVEL = LOW;
const int RELAY_OFF_LEVEL = HIGH;

// Voltage divider values in ohms
const float R1 = 30000.0;  // battery+ to A0
const float R2 = 7500.0;   // A0 to GND

// ADC reference for standard UNO powered by USB
const float ADC_REF_VOLTAGE = 5.0;
const int ADC_MAX = 1023;

// Battery thresholds
const float DISCONNECT_VOLTAGE = 11.80;
const float RECONNECT_VOLTAGE  = 12.40;

// Timing
const unsigned long SAMPLE_INTERVAL_MS = 250;
const unsigned long LCD_INTERVAL_MS = 500;
const unsigned long SERIAL_INTERVAL_MS = 1000;
const unsigned long LOW_VOLTAGE_DELAY_MS = 5000;

// Averaging
const int NUM_SAMPLES = 20;

// State variables
bool loadConnected = true;
bool lowVoltagePending = false;
unsigned long lowVoltageStartMs = 0;
unsigned long lastSampleMs = 0;
unsigned long lastLcdMs = 0;
unsigned long lastSerialMs = 0;
float filteredBatteryVoltage = 0.0;

// Read battery voltage using averaging
float readBatteryVoltage() {
  long total = 0;

  for (int i = 0; i < NUM_SAMPLES; i++) {
    total += analogRead(PIN_BATTERY);
    delay(2);
  }

  float adc = total / (float)NUM_SAMPLES;
  float vA0 = adc * ADC_REF_VOLTAGE / ADC_MAX;
  float batteryVoltage = vA0 * ((R1 + R2) / R2);

  return batteryVoltage;
}

void setLoadConnected(bool enabled) {
  loadConnected = enabled;
  digitalWrite(PIN_RELAY, enabled ? RELAY_ON_LEVEL : RELAY_OFF_LEVEL);
}

void updateControlLogic(float vbat, unsigned long nowMs) {
  if (loadConnected) {
    if (vbat < DISCONNECT_VOLTAGE) {
      if (!lowVoltagePending) {
        lowVoltagePending = true;
        lowVoltageStartMs = nowMs;
      } else if ((nowMs - lowVoltageStartMs) >= LOW_VOLTAGE_DELAY_MS) {
        setLoadConnected(false);
        lowVoltagePending = false;
      }
    } else {
      lowVoltagePending = false;
    }
  } else {
    // Load is disconnected; reconnect only after voltage rises enough
    if (vbat > RECONNECT_VOLTAGE) {
      setLoadConnected(true);
      lowVoltagePending = false;
    }
  }
}

void updateLcd(float vbat, unsigned long nowMs) {
  if (nowMs - lastLcdMs < LCD_INTERVAL_MS) {
    return;
  }
  lastLcdMs = nowMs;

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Bat:");
  lcd.print(vbat, 2);
  lcd.print("V");

  lcd.setCursor(0, 1);

  if (loadConnected) {
    if (lowVoltagePending) {
      unsigned long elapsed = nowMs - lowVoltageStartMs;
      unsigned long remain = 0;
      if (elapsed < LOW_VOLTAGE_DELAY_MS) {
        remain = (LOW_VOLTAGE_DELAY_MS - elapsed + 999) / 1000;
      }
      lcd.print("LOW WAIT ");
      lcd.print(remain);
      lcd.print("s");
    } else {
      lcd.print("LOAD ON");
    }
  } else {
    lcd.print("CUT OFF");
  }
}

void printSerialStatus(float vbat, unsigned long nowMs) {
  if (nowMs - lastSerialMs < SERIAL_INTERVAL_MS) {
    return;
  }
  lastSerialMs = nowMs;

  Serial.print("Vbat=");
  Serial.print(vbat, 3);
  Serial.print(" V, Load=");
  Serial.print(loadConnected ? "ON" : "OFF");
  Serial.print(", Pending=");
  Serial.println(lowVoltagePending ? "YES" : "NO");
}

void setup() {
  pinMode(PIN_RELAY, OUTPUT);
  setLoadConnected(true);

  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Battery Guard");
  lcd.setCursor(0, 1);
  lcd.print("Starting...");

  Serial.begin(9600);
  delay(1500);

  filteredBatteryVoltage = readBatteryVoltage();
}

void loop() {
  unsigned long nowMs = millis();

  if (nowMs - lastSampleMs >= SAMPLE_INTERVAL_MS) {
    lastSampleMs = nowMs;

    float rawV = readBatteryVoltage();

    // Light smoothing filter
    filteredBatteryVoltage = 0.8 * filteredBatteryVoltage + 0.2 * rawV;

    updateControlLogic(filteredBatteryVoltage, nowMs);
    updateLcd(filteredBatteryVoltage, nowMs);
    printSerialStatus(filteredBatteryVoltage, nowMs);
  }
}

Notas sobre el sketch

El código asume un módulo de relé activo en bajo común, donde llevar IN a nivel bajo activa el relé.
Si tu relé se comporta de la manera opuesta:
cambia:
- const int RELAY_ON_LEVEL = LOW;
- const int RELAY_OFF_LEVEL = HIGH;
por:
- const int RELAY_ON_LEVEL = HIGH;
- const int RELAY_OFF_LEVEL = LOW;

Salida de referencia opcional del monitor serie

Vbat=12.681 V, Load=ON, Pending=NO
Vbat=12.503 V, Load=ON, Pending=NO
Vbat=11.752 V, Load=ON, Pending=YES
Vbat=11.741 V, Load=ON, Pending=YES
Vbat=11.730 V, Load=OFF, Pending=NO
Vbat=12.452 V, Load=ON, Pending=NO

Comandos de compilación/carga/ejecución

Usa Arduino CLI exactamente como se requiere.

Tabla de comandos

Tarea	Comando
Actualizar índice de placas	`arduino-cli core update-index`
Instalar núcleo AVR	`arduino-cli core install arduino:avr`
Compilar sketch	`arduino-cli compile --fqbn arduino:avr:uno low_battery_load_disconnect`
Cargar sketch	`arduino-cli upload --fqbn arduino:avr:uno --port <PORT> low_battery_load_disconnect`

Ejemplo de sesión de terminal

arduino-cli core update-index
arduino-cli core install arduino:avr
arduino-cli compile --fqbn arduino:avr:uno low_battery_load_disconnect
arduino-cli upload --fqbn arduino:avr:uno --port <PORT> low_battery_load_disconnect

Flujo de trabajo corto

Crea una carpeta llamada low_battery_load_disconnect.
Guarda el sketch como low_battery_load_disconnect.ino dentro de esa carpeta.
Conecta el Arduino UNO R3 por USB.
Ejecuta el comando de compilación.
Reemplaza <PORT> por tu puerto serie real:
Ejemplo en Linux: /dev/ttyACM0
Ejemplo en Windows: COM4
Ejemplo en macOS: /dev/cu.usbmodem14101
Carga el sketch.
Abre un monitor serie a 9600 baud si quieres diagnósticos adicionales.

Validación paso a paso

El objetivo aquí es validar el proyecto como un prototipo práctico de desconexión de carga por batería baja, no solo verificar que el código se cargue.

1) Encendido y verificación de pantalla

Acción
– Conecta el Arduino por USB.
– Alimenta el lado de medición de batería y conecta la carga de prueba a través del camino del relé.
– Ajusta el potenciómetro de contraste del LCD hasta que el texto sea legible.

Observación esperada
– El LCD primero muestra texto de inicio como Battery Guard.
– Luego muestra una lectura de voltaje en la línea 1.
– La línea 2 muestra LOAD ON, LOW WAIT o CUT OFF.

Condición de aprobación
– El LCD es legible y se actualiza automáticamente.
– No hay bloques aleatorios ni pantalla en blanco después de ajustar el contraste.

2) Verificación del divisor y de la precisión de medición

Acción
– Mide el voltaje real de la batería con un multímetro directamente en los terminales de la batería.
– Compáralo con el voltaje mostrado en el LCD y, opcionalmente, en el monitor serie.

Observación esperada
– El voltaje en LCD/serie es cercano a la lectura del multímetro.
– Pequeñas diferencias son normales porque:
– los 5 V del USB pueden no ser exactamente 5.000 V
– las tolerancias de las resistencias afectan el escalado
– las lecturas del ADC tienen algo de ruido

Condición de aprobación
– La lectura sigue correctamente los cambios de voltaje y es razonablemente cercana al multímetro.
– Si está desviada de forma consistente, la calibración puede mejorarse después ajustando ADC_REF_VOLTAGE o los valores de las resistencias en el código.

3) Prueba del relé en funcionamiento normal

Acción
– Ajusta la batería o fuente de banco a un nivel saludable por encima de 12.40 V.
– Observa el estado del relé y el comportamiento de la carga de prueba.

Observación esperada
– El relé está energizado en el estado “carga habilitada”.
– El LCD muestra LOAD ON.
– La carga recibe alimentación de batería a través de COM a NO del relé.

Condición de aprobación
– La carga se enciende y permanece encendida de forma estable por encima del umbral de reconexión.

4) Prueba de espera por bajo voltaje y corte temporizado

Acción
– Baja lentamente la alimentación de la batería por debajo de 11.80 V.
– Mantenla por debajo del umbral durante más de 5 segundos.

Observación esperada
– El LCD cambia a LOW WAIT con una cuenta regresiva o una breve indicación del tiempo restante.
– Después del retardo, el relé cambia de estado y la carga se desconecta.
– Luego el LCD muestra CUT OFF.

Condición de aprobación
– El relé no se dispara inmediatamente ante una caída breve.
– El relé sí desconecta después de que el voltaje permanezca bajo durante todo el retardo.

5) Prueba de histéresis y recuperación

Acción
– Después del corte, vuelve a elevar la alimentación.
– Primero prueba un valor entre 11.80 V y 12.40 V, luego súbelo por encima de 12.40 V.

Observación esperada
– Entre los umbrales, el relé permanece apagado.
– Una vez que el voltaje supera el umbral de reconexión, el relé reconecta y el LCD vuelve a LOAD ON.

Condición de aprobación
– El relé no vibra cerca de un solo umbral.
– La reconexión ocurre solo por encima del umbral más alto.

Solución de problemas

Síntoma	Causa probable	Solución
El LCD enciende pero no se ve texto	Pin de contraste mal ajustado	Usa un potenciómetro de 10 kOhm en `VO` del LCD y ajústalo lentamente
El LCD muestra caracteres aleatorios	Cableado incorrecto de RS/E/D4-D7	Revisa de nuevo el mapeo de pines del LCD según el tutorial
El voltaje mostrado es demasiado alto o demasiado bajo	Valores del divisor incorrectos o falta tierra común	Verifica los valores de las resistencias con un multímetro y conecta el negativo de batería a GND del Arduino
La lectura analógica salta mucho	Cableado ruidoso o punto de medición flotante	Mantén los cables cortos, agrega 100 nF de A0 a GND y asegúrate de tener una tierra sólida
El relé nunca conmuta	Lógica de entrada del relé opuesta a la del código	Intercambia `RELAY_ON_LEVEL` y `RELAY_OFF_LEVEL`
El relé hace clic pero la carga sigue apagada	Se usó el terminal de contacto incorrecto	Usa `COM` y `NO` para el comportamiento normal de encendido cuando está saludable
La carga nunca se desconecta	Umbral demasiado bajo o calibración de medición incorrecta	Imprime valores por serie, compáralos con el multímetro, ajusta umbrales o `ADC_REF_VOLTAGE`
El Arduino se reinicia cuando conmuta el relé	Perturbación de alimentación o problema de cableado	Mantén ordenado el cableado lógico, alimenta el UNO por USB estable, evita alimentar cargas grandes desde los 5 V del Arduino
El voltaje de batería en el LCD es cero o casi cero	A0 no está conectado al punto medio del divisor	Revisa el cable de A0 y la continuidad del punto medio del divisor

Mejoras

Mejor calidad de medición

Reemplaza las suposiciones de referencia USB de 5 V por:
una constante de calibración medida,
o un método de referencia más avanzado si tu lección más adelante cubre calibración de ADC.
Usa resistencias del 1% para el divisor.
Agrega una ventana de promediado mayor o filtrado por mediana si tu fuente de batería es ruidosa.

Comportamiento de protección de batería más robusto

Agrega un zumbador para advertencia de batería baja antes del corte.
Agrega un botón de reinicio manual para que el usuario deba reconocer la desconexión antes de reconectar.
Guarda el último evento de corte en EEPROM para un seguimiento simple del uso.

Mejor carcasa y usabilidad en campo

Monta el Arduino, el relé y el LCD en una pequeña caja de proyecto.
Agrega terminales de tornillo para:
entrada de batería,
salida de carga,
y cableado con fusible.
Coloca etiquetas en:
BAT +
BAT -
LOAD +
LOAD -

Una mejora muy práctica para estudiantes es convertir esto en un módulo portátil de protección de batería para una caja de iluminación de camping, un pequeño demostrador solar o un paquete educativo de batería para alarma.

Lista de verificación final

[ ] Usé Arduino UNO R3 (ATmega328P).
[ ] Usé un divisor de voltaje y no conecté el voltaje de la batería directamente a A0.
[ ] Usé un módulo de relé de 1 canal con tierra compartida con el Arduino.
[ ] Cableé el LCD HD44780 de 16×2 en modo de 4 bits como se indicó.
[ ] Instalé el núcleo AVR de Arduino con Arduino CLI.
[ ] El sketch compiló con:
arduino-cli compile --fqbn arduino:avr:uno low_battery_load_disconnect
[ ] El sketch se cargó con:
arduino-cli upload --fqbn arduino:avr:uno --port <PORT> low_battery_load_disconnect
[ ] El LCD muestra el voltaje de batería en vivo.
[ ] El relé mantiene la carga encendida por encima del umbral de reconexión.
[ ] El relé desconecta la carga después de que el voltaje permanezca por debajo del umbral de desconexión durante el período de retardo.
[ ] La carga se reconecta solo después de que el voltaje sube por encima del umbral más alto.
[ ] Comparé la lectura con un multímetro.
[ ] Entiendo que esto es un prototipo educativo de bajo voltaje, no un dispositivo de protección certificado.

Encuentra este producto y/o libros sobre este tema en Amazon

Ir a Amazon

Como afiliado de Amazon, gano con las compras que cumplan los requisitos. Si compras a través de este enlace, ayudas a mantener este proyecto.

Carlos Núñez Zorrilla

Electronics & Computer Engineer

Ingeniero Superior en Electrónica de Telecomunicaciones e Ingeniero en Informática (titulaciones oficiales en España).

Sígueme:

¿Quiénes somos?