HICE una TARJETA para ALTERNANCIA de BOMBAS de AGUA || 100% funcional, PASO A PASO

Hoy vamos a hablar sobre un problema común que muchos enfrentan: cómo hacer trabajar bombas de agua de manera alternada. Como sabemos, tradicionalmente existen dos métodos para lograrlo: por temporizadores o mediante sensores de nivel. Aunque ambos funcionan adecuadamente, la realidad es que presentan algunos inconvenientes significativos. Por un lado, su instalación y el cableado es bastante laboriosa, llegando a tomar aproximadamente 6 horas . Por otro lado, estos métodos suelen incrementar considerablemente el costo de los componentes necesarios.

Sin embargo, ¿qué pasaría si pudiéramos crear una solución más eficiente? Es por eso que hemos desarrollado una tarjeta de control unificada que no solo simplifica todo el proceso, sino que además puede gestionar ambos tipos de control simultáneamente. De hecho, esta tarjeta va más allá, ya que también puede leer sensores de nivel de agua mientras mantiene las funciones manuales y automáticas tradicionales. Además de esto, permite seleccionar las bombas individualmente y cuenta con una intuitiva pantalla con pulsadores para configurar fácilmente tanto los tiempos como los modos de operación.

Si te interesa conocer paso a paso cómo hemos desarrollado este proyecto profesional, desde el diseño del esquemático electrónico hasta la implementación de la máscara personalizada, entonces no te despegues de este articulo.

#include <EEPROM.h>
#include <Wire.h>
#include "RTClib.h"

RTC_DS1307 rtc;
char daysOfTheWeek[7][12] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };

//PINES DE ENTRADA DE SENSORES DE NIVEL DE AGUA
const byte sensor_poso = 4;       // Sensor poso
const byte sensor_tanque = 3;     // Sensor tanque
const byte entrada_auxiliar = 2;  //auxiliar

//PINES DE SALIDA PARA CONTROLAR LOS LEDS
const byte led_auto = 11;    // Led Auto
const byte led_manual = 12;  // Led Manual

//PINES DE SALIDA PARA CONTROLAR LOS MOTORES
const byte motor1 = 14;  // motor1
const byte motor2 = 15;  // motor2
const byte motor3 = 16;  //motor3

//PINES DE SALIDA PARA Buzzer
const byte Buzzer = 13;  //Buzzer
// Configuración de buzzer
const int tonoTecla = 1000;     // Frecuencia en Hz para pulsación normal
const int tonoGuardado = 2000;  // Frecuencia en Hz para guardado
const int duracionCorta = 50;   // Duración en ms para tecla normal
const int duracionLarga = 200;  // Duración en ms para guardado

////////////////////////DIRECCION PARA ALMACENAR EN LA MENORIA EEPROM
const byte direc_control = 0;  //
const byte direc_motores = 3;  // Direccion EEPROM para almacenar los valores de total Motores
const byte direc_mode = 6;

bool act_sensonrs = false;
bool control = false;
byte contador_Motores_M = 2;  // cantidad de motores activas (mínimo 2, máximo 3)
byte mode = 0;
byte motors = 0;
byte read_sensor_tanque = 1;

struct ConfigMotor {
  byte horas;
  byte minutos;
  byte segundos;
};

ConfigMotor motores[3] = {
  { 0, 0, 0 },  // Motor 1
  { 0, 0, 0 },  // Motor 2
  { 0, 0, 0 }   // Motor 3
};

const int dirEEPROM[3] = { 60, 70, 80 };  // Direcciones base EEPROM para cada motor

// Variables para almacenar hora y fecha
byte hora, minuto, segundo, dia, mes, anio = 0;
unsigned long tiempoAnterior = 0;

// ====== VARIABLES GLOBALES ADICIONALES ======
byte motorActivo = 255;  // 255=ninguno, 0=motor1, 1=motor2, 2=motor3
DateTime horaInicioMotor;
const byte pinesMotores[3] = { motor1, motor2, motor3 };

void cargarConfigMotores() {
  for (int m = 0; m < 3; m++) {
    EEPROM.get(dirEEPROM[m], motores[m]);
    // Si es la primera lectura (valores en 255)
    if (motores[m].horas == 255) motores[m] = { 0, 0, 0 };
  }
}

void setup() {
  Serial.begin(9600);  // Iniciar comunicación serial para depuración
  Serial.println("Sistema iniciado");
  
  rtc.begin();
  // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));  // solo activa esta linea para ajustar la hora y la fecha, luego bloquealo

  EEPROM.get(direc_motores, contador_Motores_M);
  control = EEPROM.read(direc_control);
  EEPROM.get(direc_mode, mode);
  cargarConfigMotores();

  pinMode(sensor_poso, INPUT);
  pinMode(sensor_tanque, INPUT);
  pinMode(entrada_auxiliar, INPUT);
  attachInterrupt(digitalPinToInterrupt(sensor_tanque), tanque, FALLING);

  pinMode(led_auto, OUTPUT);
  pinMode(led_manual, OUTPUT);
  pinMode(motor1, OUTPUT);
  pinMode(motor2, OUTPUT);
  pinMode(motor3, OUTPUT);
  pinMode(Buzzer, OUTPUT);
  
  // Mostrar configuración inicial
  mostrarEstadoActual();
}

void loop() {
  // Verificar sensores y controlar motores según el modo
  if (digitalRead(sensor_poso) == LOW) act_sensonrs = true;
  else {
    digitalWrite(motor1, LOW);
    digitalWrite(motor2, LOW); 
    digitalWrite(motor3, LOW);
    act_sensonrs = false;
  }

  switch (mode) {
    case 0: 
      digitalWrite(led_auto, LOW);
      digitalWrite(led_manual, LOW);
      digitalWrite(motor1, LOW);
      digitalWrite(motor2, LOW);
      digitalWrite(motor3, LOW);
      break;
    case 1: 
      digitalWrite(led_auto, HIGH);
      digitalWrite(led_manual, LOW);
      break;
    case 2: 
      digitalWrite(led_auto, LOW);
      digitalWrite(led_manual, HIGH);
      break;
  }
  
  if (mode == 2) {
    switch (motors) {
      case 0: 
        digitalWrite(motor1, LOW);
        digitalWrite(motor2, LOW);
        digitalWrite(motor3, LOW);
        break;
      case 1: 
        digitalWrite(motor1, HIGH);
        digitalWrite(motor2, LOW);
        digitalWrite(motor3, LOW);
        break;
      case 2: 
        digitalWrite(motor1, LOW);
        digitalWrite(motor2, HIGH);
        digitalWrite(motor3, LOW);
        break;
      case 3: 
        digitalWrite(motor1, LOW);
        digitalWrite(motor2, LOW);
        digitalWrite(motor3, HIGH);
        break;
    }
  } else {
    motors = 0;
  }
  
  if (mode == 1) {
    if (control == false && act_sensonrs == true) {
      if (digitalRead(sensor_tanque) == LOW) {
        if (read_sensor_tanque == 1) {
          digitalWrite(motor1, HIGH);
          digitalWrite(motor2, LOW);
        }
        if (read_sensor_tanque == 2) {
          digitalWrite(motor1, LOW);
          digitalWrite(motor2, HIGH);
        }
      } else {
        digitalWrite(motor1, LOW);
        digitalWrite(motor2, LOW);
      }
    } else if (control == true && act_sensonrs == true) {
      controlarMotoresPorTurnos();
    }
  }
  
  // Verificar comunicación serial para comandos
  if (Serial.available() > 0) {
    procesarComandoSerial();
  }
  
  // Mostrar estado cada cierto tiempo
  static unsigned long ultimoTiempoMostrado = 0;
  if (millis() - ultimoTiempoMostrado > 5000) {  // Cada 5 segundos
    mostrarEstadoActual();
    ultimoTiempoMostrado = millis();
  }
}

void procesarComandoSerial() {
  String comando = Serial.readStringUntil('\n');
  comando.trim();
  
  if (comando == "status") {
    mostrarEstadoActual();
  } 
  else if (comando == "mode0") {
    mode = 0;
    EEPROM.put(direc_mode, mode);
    Serial.println("Modo 0: Apagado");
    sonidoGuardado();
  }
  else if (comando == "mode1") {
    mode = 1;
    EEPROM.put(direc_mode, mode);
    Serial.println("Modo 1: Auto");
    sonidoGuardado();
  }
  else if (comando == "mode2") {
    mode = 2;
    EEPROM.put(direc_mode, mode);
    Serial.println("Modo 2: Manual");
    sonidoGuardado();
  }
  else if (comando == "motor1") {
    motors = 1;
    Serial.println("Motor 1 activado");
    sonidoTecla();
  }
  else if (comando == "motor2") {
    motors = 2;
    Serial.println("Motor 2 activado");
    sonidoTecla();
  }
  else if (comando == "motor3") {
    motors = 3;
    Serial.println("Motor 3 activado");
    sonidoTecla();
  }
  else if (comando == "motoroff") {
    motors = 0;
    Serial.println("Motores apagados");
    sonidoTecla();
  }
  else if (comando == "control_sensor") {
    control = false;
    EEPROM.update(direc_control, control);
    Serial.println("Control por sensores activado");
    sonidoGuardado();
  }
  else if (comando == "control_tiempo") {
    control = true;
    EEPROM.update(direc_control, control);
    Serial.println("Control por tiempos activado");
    sonidoGuardado();
  }
  else if (comando.startsWith("motores ")) {
    int cantidad = comando.substring(8).toInt();
    if (cantidad >= 2 && cantidad <= 3) {
      contador_Motores_M = cantidad;
      EEPROM.put(direc_motores, contador_Motores_M);
      Serial.print("Cantidad de motores: ");
      Serial.println(contador_Motores_M);
      sonidoGuardado();
    } else {
      Serial.println("Error: cantidad debe ser 2 o 3");
    }
  }
  else if (comando.startsWith("config_motor")) {
    // Formato: config_motor,motor#,horas,minutos,segundos
    // Ejemplo: config_motor,1,0,30,0
    int posiciones[4];
    int parametro = 0;
    int inicio = 12; // Posición después de "config_motor,"
    
    for (int i = inicio; i < comando.length(); i++) {
      if (comando.charAt(i) == ',') {
        posiciones[parametro] = comando.substring(inicio, i).toInt();
        inicio = i + 1;
        parametro++;
      }
    }
    
    // Último valor
    if (parametro < 4) {
      posiciones[parametro] = comando.substring(inicio).toInt();
      parametro++;
    }
    
    if (parametro == 4) {
      int motor = posiciones[0] - 1; // Motor 1 sería índice 0
      if (motor >= 0 && motor < 3) {
        motores[motor].horas = posiciones[1];
        motores[motor].minutos = posiciones[2];
        motores[motor].segundos = posiciones[3];
        guardarConfigMotor(motor);
        
        Serial.print("Motor ");
        Serial.print(motor + 1);
        Serial.print(" configurado: ");
        Serial.print(motores[motor].horas);
        Serial.print(":");
        Serial.print(motores[motor].minutos);
        Serial.print(":");
        Serial.println(motores[motor].segundos);
        sonidoGuardado();
      } else {
        Serial.println("Error: Motor debe ser 1, 2 o 3");
      }
    } else {
      Serial.println("Error: formato debe ser config_motor,motor#,horas,minutos,segundos");
    }
  }
  else if (comando.startsWith("set_time")) {
    // Formato: set_time,hora,minuto,segundo,dia,mes,año
    int valores[6];
    int parametro = 0;
    int inicio = 9; // Posición después de "set_time,"
    
    for (int i = inicio; i < comando.length(); i++) {
      if (comando.charAt(i) == ',') {
        valores[parametro] = comando.substring(inicio, i).toInt();
        inicio = i + 1;
        parametro++;
      }
    }
    
    // Último valor
    if (parametro < 6) {
      valores[parametro] = comando.substring(inicio).toInt();
      parametro++;
    }
    
    if (parametro == 6) {
      rtc.adjust(DateTime(2000 + valores[5], valores[4], valores[3], valores[0], valores[1], valores[2]));
      Serial.println("Fecha y hora actualizadas");
      sonidoGuardado();
    } else {
      Serial.println("Error: formato debe ser set_time,hora,minuto,segundo,dia,mes,año");
    }
  }
  else if (comando == "help") {
    mostrarAyuda();
  }
  else {
    Serial.println("Comando desconocido. Escribe 'help' para ver los comandos disponibles.");
  }
}

void mostrarEstadoActual() {
  DateTime now = rtc.now();
  
  Serial.println("==== ESTADO ACTUAL ====");
  Serial.print("Fecha: ");
  Serial.print(now.day());
  Serial.print("/");
  Serial.print(now.month());
  Serial.print("/");
  Serial.println(now.year());
  
  Serial.print("Hora: ");
  Serial.print(now.hour());
  Serial.print(":");
  if (now.minute() < 10) Serial.print("0");
  Serial.print(now.minute());
  Serial.print(":");
  if (now.second() < 10) Serial.print("0");
  Serial.println(now.second());
  
  Serial.print("Modo: ");
  switch (mode) {
    case 0: Serial.println("Apagado"); break;
    case 1: Serial.println("Automático"); break;
    case 2: Serial.println("Manual"); break;
  }
  
  Serial.print("Control: ");
  Serial.println(control ? "Por tiempos" : "Por sensores");
  
  Serial.print("Nivel agua pozo: ");
  Serial.println(digitalRead(sensor_poso) == LOW ? "Disponible" : "No disponible");
  
  Serial.print("Sensor tanque: ");
  Serial.println(digitalRead(sensor_tanque) == LOW ? "Activo" : "Inactivo");
  
  Serial.print("Total motores: ");
  Serial.println(contador_Motores_M);
  
  Serial.println("Tiempos motores:");
  for (int i = 0; i < contador_Motores_M; i++) {
    Serial.print("Motor ");
    Serial.print(i + 1);
    Serial.print(": ");
    Serial.print(motores[i].horas);
    Serial.print(":");
    if (motores[i].minutos < 10) Serial.print("0");
    Serial.print(motores[i].minutos);
    Serial.print(":");
    if (motores[i].segundos < 10) Serial.print("0");
    Serial.println(motores[i].segundos);
  }
  
  Serial.println("======================");
}

void mostrarAyuda() {
  Serial.println("==== COMANDOS DISPONIBLES ====");
  Serial.println("status - Muestra el estado actual");
  Serial.println("mode0 - Modo apagado");
  Serial.println("mode1 - Modo automático");
  Serial.println("mode2 - Modo manual");
  Serial.println("motor1 - Activa motor 1 (solo en modo manual)");
  Serial.println("motor2 - Activa motor 2 (solo en modo manual)");
  Serial.println("motor3 - Activa motor 3 (solo en modo manual)");
  Serial.println("motoroff - Apaga todos los motores");
  Serial.println("control_sensor - Activa control por sensores");
  Serial.println("control_tiempo - Activa control por tiempos");
  Serial.println("motores N - Establece número de motores (2-3)");
  Serial.println("config_motor,M,h,m,s - Configura tiempo del motor M");
  Serial.println("set_time,h,m,s,d,M,a - Configura hora y fecha");
  Serial.println("help - Muestra esta ayuda");
  Serial.println("=============================");
}

void tanque() {
  read_sensor_tanque++;
  if (read_sensor_tanque > 2) read_sensor_tanque = 1;
}

void controlarMotoresPorTurnos() {
  // Si el control está activo pero no hay motor activo, iniciar ciclo
  if (control && motorActivo == 255) {
    motorActivo = 0;
    digitalWrite(pinesMotores[motorActivo], HIGH);
    horaInicioMotor = rtc.now();
    return;
  }

  // Si el control está inactivo pero hay motor activo, detener todo
  if (!control && motorActivo != 255) {
    for (byte i = 0; i < 3; i++) {
      digitalWrite(pinesMotores[i], LOW);
    }
    motorActivo = 255;
    return;
  }

  // Si hay motor activo y control activo, verificar tiempo
  if (control && motorActivo != 255) {
    DateTime ahora = rtc.now();
    unsigned long segundosTranscurridos = ahora.unixtime() - horaInicioMotor.unixtime();
    unsigned long segundosProgramados = motores[motorActivo].horas * 3600UL + motores[motorActivo].minutos * 60UL + motores[motorActivo].segundos;

    if (segundosTranscurridos >= segundosProgramados) {
      // Apagar motor actual
      digitalWrite(pinesMotores[motorActivo], LOW);

      // Pasar al siguiente motor (solo los configurados)
      motorActivo = (motorActivo + 1) % contador_Motores_M;

      // Encender nuevo motor
      digitalWrite(pinesMotores[motorActivo], HIGH);
      horaInicioMotor = ahora;
    }
  }
}

void guardarConfigMotor(byte numMotor) {
  EEPROM.put(dirEEPROM[numMotor], motores[numMotor]);
}

void sonidoTecla() {
  tone(Buzzer, tonoTecla, duracionCorta);
  delay(duracionCorta);  // Pequeña pausa para evitar solapamientos
}

void sonidoGuardado() {
  tone(Buzzer, tonoGuardado, duracionLarga);
  delay(duracionLarga);  // Pausa más larga para el sonido de confirmación
}