Objetivo y caso de uso
Qué construirás: Un prototipo de controlador de bomba de sumidero de doble flotador que automatiza un relé de 5V según los niveles de agua y activa una alarma de zumbador piezoeléctrico si el agua permanece peligrosamente alta.
Por qué es importante / Casos de uso
- Prevención de inundaciones en sótanos: Enciende automáticamente una bomba antes de que el agua desborde el pozo del sumidero, previniendo costosos daños por agua.
- Monitorización de tanques industriales: Mantiene los niveles de fluido dentro de una banda de operación segura específica sin que el hardware de la bomba haga ciclos cortos.
- Riego agrícola: Automatiza el llenado o vaciado de abrevaderos de ganado o depósitos hidropónicos.
- Teoría de control educativa: Introduce la histéresis de hardware, utilizando dos umbrales diferentes para prevenir una conmutación mecánica rápida y dañina, y extender la vida útil del relé.
Resultado esperado
- El relé de 5V se activa (bomba ENCENDIDA) solo cuando el agua levanta el interruptor de flotador Alto.
- El relé permanece activo incluso cuando el agua cae por debajo del flotador Alto, desactivándose solo cuando el flotador Bajo cae (bomba APAGADA).
- Si el flotador Alto permanece activado durante más de 5 segundos, un zumbador piezoeléctrico emite una alarma audible que indica un posible fallo en la bomba.
Audiencia: Desarrolladores de IoT, creadores de hardware y entusiastas de la domótica; Nivel: Intermedio
Arquitectura/flujo: Interruptores de flotador dobles (Entradas digitales) → Microcontrolador (Lógica de histéresis & Temporizador de 5s) → Relé de 5V (Control de bomba) & Zumbador piezoeléctrico (Alarma)
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, 3 tablas y 2 bloques de código detectados antes de publicar.
- Código comprobado: 2 Arduino/arduino-cli compile.
- 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. Antes de encender la configuración, verifique el cableado de su Arduino UNO R3, evite cortocircuitar 5 V, GND o los pines digitales, desconecte la alimentación antes de cambiar las conexiones y use módulos de interfaz adecuados para relés, motores o cargas externas.
Diagrama de bloques conceptual
Vista de alto nivel: qué entra, qué procesa cada bloque y qué sale del sistema.
Arquitectura funcional
Flujo conceptual de señales y responsabilidades entre bloques del dispositivo.
Ruta de validación
Resumen conceptual de las herramientas usadas para comprobar el material publicado.
Requisitos previos
Antes de comenzar este tutorial, debes tener:
* Una comprensión básica de la lógica digital (estados HIGH/LOW).
* Familiaridad con el concepto de resistencias pull-up (específicamente el INPUT_PULLUP interno del Arduino).
* Un ordenador con la interfaz de línea de comandos (Terminal/Símbolo del sistema) disponible.
* Arduino CLI instalado y añadido al PATH de tu sistema.
Materiales
Para construir este prototipo específico, necesitarás los siguientes componentes exactos:
* Microcontrolador: Arduino UNO R3 (ATmega328P)
* Sensores: 2x Interruptores mecánicos de flotador (verticales u horizontales, tipo interruptor de láminas magnético estándar)
* Actuador: 1x Módulo de relé de 5 V (estándar de 1 canal, optoaislado)
* Alarma: 1x Zumbador piezoeléctrico (se prefiere un zumbador activo de 5V, aunque el pasivo funciona con la función tone() utilizada en este código)
* Prototipado: 1x Placa de pruebas (breadboard) sin soldadura
* Cableado: Surtido de cables puente macho-macho y macho-hembra
* Alimentación: Cable USB estándar A a B para programar y alimentar el Arduino
Configuración/Conexión
Este proyecto se basa en las resistencias pull-up internas del Arduino para los interruptores de flotador. Esto simplifica el cableado al eliminar la necesidad de resistencias externas. Cuando el interruptor de flotador está abierto, el pin del Arduino lee HIGH. Cuando el agua sube y cierra el interruptor de flotador, conecta el pin a Tierra (Ground), y el Arduino lee LOW.
La mayoría de los módulos de relé estándar de 5 V son «Activos en BAJO» (Active LOW), lo que significa que llevar el pin de señal a LOW energiza la bobina del relé, y ponerlo en HIGH lo apaga. El código proporcionado tiene en cuenta este comportamiento común.
Tabla de asignación de pines
| Componente | Pin Arduino UNO R3 | Conexión del componente | Notas |
|---|---|---|---|
| Interruptor de flotador Bajo | Pin digital 2 | Cable 1 | El cable 2 va al GND del Arduino |
| Interruptor de flotador Alto | Pin digital 3 | Cable 1 | El cable 2 va al GND del Arduino |
| Módulo de relé de 5 V | Pin digital 4 | IN / Señal | VCC a 5V, GND a GND |
| Zumbador piezoeléctrico | Pin digital 5 | Positivo (+) | Negativo (-) al GND del Arduino |
Nota sobre la orientación del interruptor de flotador: Los interruptores mecánicos de flotador generalmente contienen un interruptor de láminas magnético y un anillo flotante. A menudo puedes quitar el clip en C en la parte inferior para voltear el anillo del flotador. Para este proyecto, configura ambos interruptores para que estén Abiertos en reposo (abajo) y Cerrados cuando floten (arriba).
Código validado
El proyecto utiliza dos archivos de código separados. El primero es una prueba de hardware para asegurar que tu relé y zumbador estén cableados correctamente. El segundo es la lógica principal del controlador.
Sketch de prueba de hardware (hardware_test.ino)
Crea un directorio llamado hardware_test y guarda el siguiente código como hardware_test.ino dentro de él. Este sketch alterna el relé y el zumbador secuencialmente para que puedas verificar tu cableado antes de añadir la complejidad de los sensores de flotador.
/*
* hardware_test.ino
* Basic validation sketch to verify Relay and Buzzer connections.
*/
const int RELAY_PIN = 4;
const int BUZZER_PIN = 5;
// Most 5V relay modules are Active LOW.
const int RELAY_ON = LOW;
const int RELAY_OFF = HIGH;
void setup() {
Serial.begin(9600);
Serial.println("Starting Hardware Test...");
pinMode(RELAY_PIN, OUTPUT);
pinMode(BUZZER_PIN, OUTPUT);
// Ensure relay and buzzer are OFF initially
digitalWrite(RELAY_PIN, RELAY_OFF);
digitalWrite(BUZZER_PIN, LOW);
}
void loop() {
Serial.println("Testing Relay: ON");
digitalWrite(RELAY_PIN, RELAY_ON);
delay(2000);
Serial.println("Testing Relay: OFF");
digitalWrite(RELAY_PIN, RELAY_OFF);
delay(2000);
Serial.println("Testing Buzzer: ON");
tone(BUZZER_PIN, 1000); // Play 1kHz tone
delay(1000);
Serial.println("Testing Buzzer: OFF");
noTone(BUZZER_PIN);
delay(2000);
Serial.println("Hardware test cycle complete. Repeating...");
Serial.println("----------------------------------------");
}
Lógica principal del controlador (sump_controller.ino)
Crea un directorio llamado sump_controller y guarda el siguiente código como sump_controller.ino. Este código implementa la lógica de histéresis y el temporizador de alarma sin bloqueo.
Vista pública parcial del archivo validado. El código completo se muestra a miembros y en PDF/Print.
/*
* sump_controller.ino
* Dual-float sump pump controller with hysteresis and high-water alarm.
* Target: Arduino UNO R3 (ATmega328P)
*/
// --- Pin Definitions ---
const int LOW_FLOAT_PIN = 2;
const int HIGH_FLOAT_PIN = 3;
const int RELAY_PIN = 4;
const int BUZZER_PIN = 5;
// --- Logic Definitions ---
// Using INPUT_PULLUP: Switch closed (floating up) connects to GND (LOW)
const int FLOAT_TRIGGERED = LOW;
const int FLOAT_RESTING = HIGH;
// Standard 5V relay modules are typically Active LOW
const int RELAY_ON = LOW;
const int RELAY_OFF = HIGH;
// --- Alarm Configuration ---
// Time in milliseconds before triggering alarm if High Float stays triggered
const unsigned long ALARM_DELAY_MS = 5000;
// --- State Variables ---
bool pumpIsActive = false;
bool alarmIsActive = false;
unsigned long highFloatStartTime = 0;
void setup() {
Serial.begin(9600);
while (!Serial) { ; } // Wait for serial port to connect
Serial.println("Initializing Sump Pump Controller...");
// Configure float switch pins with internal pull-ups
pinMode(LOW_FLOAT_PIN, INPUT_PULLUP);
pinMode(HIGH_FLOAT_PIN, INPUT_PULLUP);
// Configure output pins
pinMode(RELAY_PIN, OUTPUT);
pinMode(BUZZER_PIN, OUTPUT);
// Set initial safe states
digitalWrite(RELAY_PIN, RELAY_OFF);
noTone(BUZZER_PIN);
Serial.println("System Ready.");
Serial.println("-----------------------------------");
}
// .../*
* sump_controller.ino
* Dual-float sump pump controller with hysteresis and high-water alarm.
* Target: Arduino UNO R3 (ATmega328P)
*/
// --- Pin Definitions ---
const int LOW_FLOAT_PIN = 2;
const int HIGH_FLOAT_PIN = 3;
const int RELAY_PIN = 4;
const int BUZZER_PIN = 5;
// --- Logic Definitions ---
// Using INPUT_PULLUP: Switch closed (floating up) connects to GND (LOW)
const int FLOAT_TRIGGERED = LOW;
const int FLOAT_RESTING = HIGH;
// Standard 5V relay modules are typically Active LOW
const int RELAY_ON = LOW;
const int RELAY_OFF = HIGH;
// --- Alarm Configuration ---
// Time in milliseconds before triggering alarm if High Float stays triggered
const unsigned long ALARM_DELAY_MS = 5000;
// --- State Variables ---
bool pumpIsActive = false;
bool alarmIsActive = false;
unsigned long highFloatStartTime = 0;
void setup() {
Serial.begin(9600);
while (!Serial) { ; } // Wait for serial port to connect
Serial.println("Initializing Sump Pump Controller...");
// Configure float switch pins with internal pull-ups
pinMode(LOW_FLOAT_PIN, INPUT_PULLUP);
pinMode(HIGH_FLOAT_PIN, INPUT_PULLUP);
// Configure output pins
pinMode(RELAY_PIN, OUTPUT);
pinMode(BUZZER_PIN, OUTPUT);
// Set initial safe states
digitalWrite(RELAY_PIN, RELAY_OFF);
noTone(BUZZER_PIN);
Serial.println("System Ready.");
Serial.println("-----------------------------------");
}
void loop() {
// 1. Read the current state of both float switches
int lowFloatState = digitalRead(LOW_FLOAT_PIN);
int highFloatState = digitalRead(HIGH_FLOAT_PIN);
// 2. Evaluate Hysteresis Logic for the Pump
if (highFloatState == FLOAT_TRIGGERED) {
// Water has reached the top float. Turn pump ON.
if (!pumpIsActive) {
pumpIsActive = true;
digitalWrite(RELAY_PIN, RELAY_ON);
Serial.println("ACTION: High level reached. Pump turned ON.");
}
}
else if (lowFloatState == FLOAT_RESTING) {
// Water has dropped below the bottom float. Turn pump OFF.
if (pumpIsActive) {
pumpIsActive = false;
digitalWrite(RELAY_PIN, RELAY_OFF);
Serial.println("ACTION: Low level cleared. Pump turned OFF.");
}
}
// Note: If water is between the two floats, pumpIsActive retains its previous state.
// This is the core of hysteresis.
// 3. Evaluate Alarm Logic (Non-blocking timer)
if (highFloatState == FLOAT_TRIGGERED) {
// If this is the first moment we see the high float triggered, record the time
if (highFloatStartTime == 0) {
highFloatStartTime = millis();
}
// Check if the high float has been triggered longer than the allowed delay
if ((millis() - highFloatStartTime >= ALARM_DELAY_MS) && !alarmIsActive) {
alarmIsActive = true;
tone(BUZZER_PIN, 2000); // 2kHz warning tone
Serial.println("ALARM: Water level critically high! Pump may be failing.");
}
} else {
// Water is no longer at the high float. Reset alarm states.
if (highFloatStartTime != 0 || alarmIsActive) {
highFloatStartTime = 0;
alarmIsActive = false;
noTone(BUZZER_PIN);
Serial.println("STATUS: High water condition cleared. Alarm reset.");
}
}
// Small delay to debounce switch chattering from simulated water ripples
delay(100);
}
Entendiendo la lógica del código
El sketch del controlador principal se basa en dos conceptos fundamentales de ingeniería:
- Histéresis: Si solo usáramos un interruptor de flotador, las ondulaciones en el agua harían que el interruptor rebotara rápidamente entre ENCENDIDO y APAGADO. Este «ciclo corto» destruye los relés mecánicos y los motores de las bombas. Al usar un flotador Alto para encender la bomba y un flotador Bajo completamente separado para apagar la bomba, el nivel del agua debe recorrer la distancia física entre los dos interruptores antes de que el estado cambie.
- Temporizadores sin bloqueo: En lugar de usar
delay(5000)para la alarma —lo cual congelaría todo el Arduino y detendría la comprobación de los flotadores—, el código usamillis(). Registra una marca de tiempo cuando se activa el flotador alto (highFloatStartTime) y la resta continuamente del tiempo actual. Si la diferencia supera los 5000 milisegundos, suena la alarma, todo mientras el Arduino continúa evaluando la lógica de la bomba 10 veces por segundo.
Comandos de Compilación/Flasheo/Ejecución
Usa Arduino CLI para compilar y subir el código a tu Arduino UNO R3.
Tabla de referencia de comandos
| Tarea | Comando |
|---|---|
| Actualizar índice | arduino-cli core update-index |
| Instalar núcleo AVR | arduino-cli core install arduino:avr |
| Compilar código | arduino-cli compile --fqbn arduino:avr:uno sump_controller |
| Subir a la placa | arduino-cli upload --fqbn arduino:avr:uno --port <PORT> sump_controller |
| Monitor serie | arduino-cli monitor --port <PORT> --config baudrate=9600 |
Nota: Reemplaza <PORT> con tu puerto serie real (por ejemplo, COM3 en Windows, /dev/ttyACM0 en Linux, o /dev/cu.usbmodem14101 en macOS).
Flujo de ejecución
- Abre tu terminal y navega hasta el directorio que contiene tu carpeta
sump_controller. - Actualiza tu índice de núcleos y asegúrate de que la arquitectura AVR esté instalada (los dos primeros comandos de la tabla).
- Compila el sketch para verificar que no haya errores de sintaxis.
- Conecta tu Arduino UNO R3 vía USB.
- Sube el código compilado a la placa.
- Inicia el monitor serie para ver los registros del sistema y comenzar la validación física.
Validación paso a paso
Con el monitor serie abierto, manipula manualmente los interruptores de flotador físicos para simular la subida y bajada del agua.
- Estado inicial (Pozo vacío)
- Acción: Deja ambos flotadores colgando hacia abajo (en reposo/abiertos).
- Observación esperada: El monitor serie muestra «System Ready.» El relé está en silencio. El zumbador está en silencio.
- Condición de aprobación: El pin 4 está en HIGH (Relé APAGADO), el pin 5 está en LOW.
- Agua subiendo (Nivel medio)
- Acción: Levanta el flotador Bajo (cerrado). Deja el flotador Alto abajo.
- Observación esperada: No hay cambios en el relé ni en el zumbador.
- Condición de aprobación: El sistema espera al flotador Alto. La histéresis previene la activación prematura.
- Agua subiendo (Nivel alto / Activación de la bomba)
- Acción: Mantén el flotador Bajo arriba y levanta el flotador Alto.
- Observación esperada: Un «clic» distintivo del módulo de relé. El monitor serie registra «ACTION: High level reached. Pump turned ON.»
- Condición de aprobación: El LED indicador del relé se enciende. La lógica de la bomba se activa con éxito.
- Disparador de alarma (Simulación de fallo de la bomba)
- Acción: Mantén ambos flotadores arriba durante más de 5 segundos.
- Observación esperada: Después de exactamente 5 segundos, el zumbador piezoeléctrico emite un tono fuerte de 2kHz. El monitor serie registra «ALARM: Water level critically high!».
- Condición de aprobación: El temporizador sin bloqueo evalúa con éxito el tiempo transcurrido y activa la advertencia.
- Agua retrocediendo (Nivel medio)
- Acción: Deja caer el flotador Alto (abierto). Mantén el flotador Bajo arriba.
- Observación esperada: El zumbador se detiene inmediatamente. El monitor serie registra «STATUS: High water condition cleared.» Crucialmente, el relé permanece ENCENDIDO (con clic).
- Condición de aprobación: La lógica de histéresis mantiene la bomba activa para continuar drenando el pozo.
- Agua retrocediendo (Pozo vacío)
- Acción: Deja caer el flotador Bajo (abierto).
- Observación esperada: El relé hace «clic» para apagarse. El monitor serie registra «ACTION: Low level cleared. Pump turned OFF.»
- Condición de aprobación: El sistema regresa al estado seguro inicial.
Solución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| El relé se enciende cuando los flotadores están ABAJO, y se apaga cuando están ARRIBA | El clip en C del interruptor de flotador está invertido (Normalmente Cerrado en lugar de Normalmente Abierto). | Quita el clip en C inferior del flotador, voltea el anillo magnético al revés y vuelve a colocar el clip. |
| El LED del relé se enciende, pero no se escucha ningún «clic» | Energía insuficiente para la bobina del relé. | Asegúrate de que el VCC del módulo de relé esté conectado al pin de 5V del Arduino, no al pin de 3.3V. |
| La bomba hace ciclos cortos rápidamente (El relé repiquetea) | Los interruptores de flotador están cableados al revés en los pines del Arduino. | Intercambia los cables en los pines D |
Encuentra este producto y/o libros sobre este tema en 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.
Quiz rápido
Ingeniero Superior en Electrónica de Telecomunicaciones e Ingeniero en Informática (titulaciones oficiales en España).
