1.
OBJETIVO:
1. Desarrollar y simular un sistema de control de dos bombas de agua utilizando potenciómetros y LEDs como
indicadores de estado, garantizando que la lógica de operación sea funcional antes de la implementación física.
2. Implementar físicamente el sistema en una protoboard, asegurando que el control de los motores a través de los
potenciómetros funcione correctamente y que los LEDs representen visualmente el estado de cada bomba.
3. Optimizar la lógica de control y la respuesta del sistema, garantizando que los cambios en los niveles del
potenciómetro reflejen correctamente los estados de llenado y operación del motor en la simulación y en la
implementación real.
2. FUNDAMENTO TEORICO:
Los microcontroladores se programan en Assembler y cada microcontrolador varía su conjunto de instrucciones de
acuerdo a su fabricante y modelo. De acuerdo al número de instrucciones que el microcontrolador maneja se le denomina
de arquitectura RISC (reducido) o CISC (complejo).
Los microcontroladores poseen principalmente una ALU (Unidad Lógica Aritmética), memoria del programa, memoria de
registros, y pines I/O (entrada y/o salida). La ALU es la encargada de procesar los datos dependiendo de las instrucciones
que se ejecuten (ADD, OR, AND), mientras que los pines son los que se encargan de comunicar al microcontrolador con
el medio externo; la función de los pines puede ser de transmisión de datos, alimentación de corriente para el
funcionamiento de este o pines de control especifico.
Un micro controlador posee en su interior todos los elementos con los que interactúa una computadora, como ser:
Procesador.
Memorias ROM y RAM.
Líneas de Entrada y Salida.
Generador de impulsos de reloj
Recursos auxiliares.
Los sistemas micro procesados pueden disponer de dos arquitecturas fundamentales, que se dividen en Arquitectura
Harvard y la Arquitectura Von Neumann.
Para la realización del laboratorio se implementará el siguiente sistema de tanques con un pulsador para activarlo y
desactivarlo una bomba de agua controlado mediante un contactor y una válvula de drenaje y para detectar los niveles se
dispone de sensores de nivel, en la parte superior y en la parte inferior tal como se muestra en los gráficos.
3. MATERIALES Y COMPONENTES
1.- Arduino uno.
2.- Resistencia de ½ Watts. 330 Ohm. Para limitar la corriente en los leds.
3.- Relay electromecánico con 5v. en su bobina y 250/1amp en sus terminales
4.- Chicotillos.
4 PROCEDIMIENTO
4.1. Implementar el circuito en el simulador (WOKWI)
4.2. Lógica de programación en DFD
4.3. Código en Arduino
/*
* CONTROL DE 2 MOTORES CON POTENCIÓMETROS Y LEDS
* - Cada motor tiene su propio potenciómetro para simular nivel de agua
* - 3 LEDs por motor indican estado del tanque
* - Variable 'estadoMotor' evita encendidos innecesarios de la bomba
*/
// ===== PINES ===== //
// Motor 1
const int potMotor1 = A0; // Potenciómetro para Motor 1 (nivel de agua)
const int ledLleno1 = 2; // LED Verde: indica tanque lleno (nivel >= 90%)
const int ledBomba1 = 3; // LED Azul: indica bomba activa
const int ledAlerta1 = 4; // LED Rojo: indica tanque vacío (nivel <= 10%)
// Motor 2
const int potMotor2 = A1; // Potenciómetro para Motor 2
const int ledLleno2 = 5; // LED Verde Motor 2
const int ledBomba2 = 6; // LED Azul Motor 2
const int ledAlerta2 = 7; // LED Rojo Motor 2
// ===== UMBRALES ===== //
const int umbralLleno = 90; // Cuando el nivel >= 90%, tanque está lleno
const int umbralVacio = 10; // Cuando el nivel <= 10%, tanque está vacío
// ===== VARIABLES DE ESTADO ===== //
/*
* estadoMotor1/estadoMotor2:
* - 0 = Tanque NO ha alcanzado nivel lleno recientemente
* - 1 = Tanque SÍ ha alcanzado nivel lleno
*
* IMPORTANTE: Estas variables evitan que la bomba se encienda
* innecesariamente cuando el nivel está entre 10% y 90%
*/
int estadoMotor1 = 0; // Estado inicial Motor 1
int estadoMotor2 = 0; // Estado inicial Motor 2
void setup() {
// Configurar pines como salidas
// Motor 1
pinMode(ledLleno1, OUTPUT);
pinMode(ledBomba1, OUTPUT);
pinMode(ledAlerta1, OUTPUT);
// Motor 2
pinMode(ledLleno2, OUTPUT);
pinMode(ledBomba2, OUTPUT);
pinMode(ledAlerta2, OUTPUT);
[Link](9600); // Para monitoreo
}
void loop() {
// Leer y escalar valores de potenciómetros (0-100%)
int nivel1 = map(analogRead(potMotor1), 0, 1023, 0, 100);
int nivel2 = map(analogRead(potMotor2), 0, 1023, 0, 100);
// ===== CONTROL MOTOR 1 ===== //
if (nivel1 <= umbralVacio) {
// CASO 1: Tanque VACÍO (<= 10%)
digitalWrite(ledBomba1, HIGH); // Activar bomba
digitalWrite(ledAlerta1, HIGH); // Encender alerta
digitalWrite(ledLleno1, LOW); // Apagar indicador lleno
estadoMotor1 = 0; // Resetear estado (no está lleno)
} else if (nivel1 >= umbralLleno) {
// CASO 2: Tanque LLENO (>= 90%)
digitalWrite(ledBomba1, LOW); // Apagar bomba
digitalWrite(ledAlerta1, LOW); // Apagar alerta
digitalWrite(ledLleno1, HIGH); // Indicar tanque lleno
estadoMotor1 = 1; // Marcar como lleno
} else {
// CASO 3: Nivel INTERMEDIO (10% < nivel < 90%)
if (estadoMotor1 == 1) {
/*
* Si el tanque YA ESTUVO LLENO (estadoMotor1=1):
* - Mantener todo apagado aunque el nivel esté en 50%
* - Esto evita que la bomba se active innecesariamente
*/
digitalWrite(ledBomba1, LOW);
digitalWrite(ledAlerta1, LOW);
digitalWrite(ledLleno1, LOW);
} else {
/*
* Si el tanque NUNCA ha estado lleno (estadoMotor1=0):
* - Activar bomba para seguir llenando
*/
digitalWrite(ledBomba1, HIGH);
digitalWrite(ledAlerta1, LOW);
digitalWrite(ledLleno1, LOW);
}
}
// ===== CONTROL MOTOR 2 (Misma lógica) ===== //
if (nivel2 <= umbralVacio) {
digitalWrite(ledBomba2, HIGH);
digitalWrite(ledAlerta2, HIGH);
digitalWrite(ledLleno2, LOW);
estadoMotor2 = 0;
} else if (nivel2 >= umbralLleno) {
digitalWrite(ledBomba2, LOW);
digitalWrite(ledAlerta2, LOW);
digitalWrite(ledLleno2, HIGH);
estadoMotor2 = 1;
} else {
if (estadoMotor2 == 1) {
digitalWrite(ledBomba2, LOW);
digitalWrite(ledAlerta2, LOW);
digitalWrite(ledLleno2, LOW);
} else {
digitalWrite(ledBomba2, HIGH);
digitalWrite(ledAlerta2, LOW);
digitalWrite(ledLleno2, LOW);
}
}
delay(100); // Pequeña pausa para estabilidad
}
}
4.4. Control de Bombas con Potenciómetros e Indicadores LED
El sistema utiliza un potenciómetro (mapeado de 0 a 100%) para simular el nivel de agua en un tanque, controlando una
bomba y tres LEDs según los siguientes rangos:
4.4.1. Estado Bajo (0-10%):
- LED Rojo: Encendido (indica tanque vacío).
- Bomba (LED Azul): Se enciende para iniciar el llenado.
4.4.2. Estado de Llenado (11-89%):
- Bomba (LED Azul): Permanece encendida (llenando el tanque).
- LED Rojo: Apagado.
4.4.3. Estado Alto (90-100%):
- LED Verde: Encendido (tanque lleno).
- Bomba (LED Azul): Se apaga (detiene el flujo de agua).
4.5. IMPLEMENTACIÓN EN PROTOBOARD
4.5.1. Preparación del Hardware
1. Colocar un Arduino UNO en la protoboard.
2. Conectar dos potenciómetros a los pines analógicos:
3. Pot 1:
a. Pin izquierdo → GND
b. Pin derecho → 5V
c. Pin central → A0
4. Pot 2:
a. Pin izquierdo → GND
b. Pin derecho → 5V
c. Pin central → A1
5. LEDs (Indicadores de Estado):
a. Usar 6 LEDs (2 verdes, 2 azules, 2 rojos) con resistencias de 330Ω
b. LED Verde (Lleno) → Pines 2 y 5
c. LED Azul (Motor encendido) → Pines 3 y 6
d. LED Rojo (Vacío) → Pines 4 y 7
4.5.2. Carga y Pruebas del Código
1. Conectar el Arduino UNO a la computadora mediante cable USB.
2. Abrir el Arduino IDE y cargar el código previamente simulado.
3. Subir el código al Arduino.
4. Abrir el Monitor Serial (Herramientas → Monitor Serial) para verificar los valores de los potenciómetros.
4.5.3. Pruebas Funcionales
1. Girar los potenciómetros y verificar:
a. Si el nivel ≤ 10% → LED Rojo + Bomba ON (LED Azul).
b. Si el nivel > 10% y < 90% → Solo Bomba ON (LED Azul).
c. Si el nivel ≥ 90% → LED Verde ON + Bomba OFF.
2. Revisar cortocircuitos o falsos contactos.
3. Ajustar umbrales en el código si los LEDs no coinciden con los rangos esperados.
4. Probar cambios bruscos en los potenciómetros para confirmar que no hay parpadeos en LEDs.
5. CONCLUCIONES
5.1. Metodología de Trabajo
Iniciamos el proyecto aplicando lógica de programación mediante DFD (Diagrama de Flujo de Datos) para visualizar
claramente el comportamiento del sistema antes de implementar el código en Arduino. Esto nos permitió:
1. Definir las condiciones clave (umbrales de vacío/lleno).
2. Planear la secuencia de acciones (encendido/apagado de LEDs y bomba).
3. Identificar posibles problemas antes de programar.
5.2. Implementación por Etapas
Comenzamos con un solo motor para:
1. Simplificar la programación inicial.
2. Validar que la lógica funcionara correctamente.
3. Facilitar la depuración de errores antes de escalar a dos motores.
5.3. Problemas Encontrados y Soluciones
5.3.1. Reactivación innecesaria de la bomba
Problema: Cuando el tanque bajaba de 90% (lleno) a ~10%, el LED azul (bomba) se encendía, aunque no fuera
necesario.
Causa: Las condicionales no consideraban el estado previo del tanque.
Solución: Implementamos la variable estadoMotor:
estadoMotor = 1 cuando el tanque alcanza 90% (recordando que ya estuvo lleno).
Esto evita que la bomba se reactive hasta que el nivel baje al 10%.
5.3.2. Umbrales mal definidos
Problema: Al ajustar el potenciómetro, la bomba se activaba en niveles incorrectos (ej: 89% o 11%).
Causa: Las condiciones usaban operadores equivocados (ej: > en lugar de >=).
Solución: Aseguramos que:
Tanque lleno: nivel >= umbralLleno (90%).
Tanque vacío: nivel <= umbralVacio (10%).
5.4. Lecciones Aprendidas
Variables de estado son cruciales: Permiten que el sistema "recuerde" condiciones previas y evite
comportamientos erráticos.
Precisión en umbrales: Pequeños errores en las condiciones (ej: > vs >=) pueden causar fallas graves.
Pruebas incrementales: Implementar primero un sistema simple (1 motor) reduce complejidad y facilita la
depuración.