Problema con RTC DS3231 en programador de riego

Buenos días.
Adjunto el proyecto con el que estoy liado, no entiendo mucho de programación, estoy empezando y soy muy malo con esto, pero intento aprender, perdonar por anticipado mi código que seguramente tendrá muchísimo errores, pero mi problema principal es que el modulo RTC DS3231 se atrasa muchísimo en una semana más de 12 horas, por favor estoy loco buscando información pero o no la entiendo o no la encuentro, muchísimas gracias de antemano.

Un saludo.
programador_de_riego_RV1.ino (22.7 KB)

//#include "RTClib.h"

#include <EEPROM.h>

#include <LiquidCrystal_I2C.h>
char DiaSemana[7][4] = {"Dom", "Lun", "Mar", "Mie", "Jue", "Vie", "Sab" };

#include <Wire.h>

//RTC_DS3231 RTC;
LiquidCrystal_I2C lcd(0x27, 16, 2);
#include "Sodaq_DS3231.h"



// RTC pin SDA-4 SCL-5
// PANTALLA  SDA-4  SCL-5
// BOTON RESET VA AL GND



int upButton = 10;       //DT
int downButton = 11;    //CLK
int selectButton = 12;   //SW
int menu = 1;

int Hora_Inicio1 = 0;
int Hora_Fin1 = 0;
int Minutos_Inicio1 = 0;
int Minutos_Fin1 = 0;

int Hora_Inicio2 = 0;
int Hora_Fin2 = 0;
int Minutos_Inicio2 = 0;
int Minutos_Fin2 = 0;

int Hora_Inicio3 = 0;
int Hora_Fin3 = 0;
int Minutos_Inicio3 = 0;
int Minutos_Fin3 = 0;

int Hora_Inicio4 = 0;
int Hora_Fin4 = 0;
int Minutos_Inicio4 = 0;
int Minutos_Fin4 = 0;

int Hora_Inicio5 = 0;
int Hora_Fin5 = 0;
int Minutos_Inicio5 = 0;
int Minutos_Fin5 = 0;

int Hora_Inicio6 = 0;
int Hora_Fin6 = 0;
int Minutos_Inicio6 = 0;
int Minutos_Fin6 = 0;




int Sector_1 = 3;
int Sector_2 = 4;
int Sector_3 = 5;
int Sector_4 = 6;
int Sector_5 = 7;
int Sector_6 = 8;
int Master = 9;



void setup() {

  pinMode(Sector_1, OUTPUT);
  pinMode(Sector_2, OUTPUT);
  pinMode(Sector_3, OUTPUT);
  pinMode(Sector_4, OUTPUT);
  pinMode(Sector_5, OUTPUT);
  pinMode(Sector_6, OUTPUT);
  pinMode(Master, OUTPUT);

    Sector_1 = LOW;
    Sector_2 = LOW;
    Sector_3 = LOW;
    Sector_4 = LOW;
    Sector_5 = LOW;
    Sector_6 = LOW;
    Master = LOW;


  Serial.begin(9600);
  if (! rtc.begin()) {        // si falla la inicializacion del modulo
    lcd.init();
    lcd.backlight();
    lcd.setCursor(2, 0);
    lcd.print("Modulo RTC");
    lcd.setCursor(0, 1);
    lcd.print("no encontrado  !");                      // muestra mensaje de error
    while (1);         // bucle infinito que detiene ejecucion del programa
  }


  Wire.begin();
  rtc.begin();
  //RTC.adjust(DateTime(__DATE__, __TIME__));  // funcion que permite establecer fecha y horario
  // al momento de la compilacion. Comentar esta linea
//DateTime dt(2021, 05, 30, 02, 25, 0, 0);
//rtc.setDateTime(dt);





  delay(100);
  Hora_Inicio1 = EEPROM.get(5, Hora_Inicio1);
  delay(100);
  Hora_Fin1 = EEPROM.get(10, Hora_Fin1);
  delay(100);
  Minutos_Inicio1 = EEPROM.get(15, Minutos_Inicio1);
  delay(100);
  Minutos_Fin1 = EEPROM.get(20, Minutos_Fin1);
  delay(100);


  Hora_Inicio2 = EEPROM.get(25, Hora_Inicio2);
  delay(100);
  Hora_Fin2 = EEPROM.get(30, Hora_Fin2);
  delay(100);
  Minutos_Inicio2 = EEPROM.get(35, Minutos_Inicio2);
  delay(100);
  Minutos_Fin2 = EEPROM.get(40, Minutos_Fin2);
  delay(100);


  Hora_Inicio3 = EEPROM.get(45, Hora_Inicio3);
  delay(100);
  Hora_Fin3 = EEPROM.get(50, Hora_Fin3);
  delay(100);
  Minutos_Inicio3 = EEPROM.get(55, Minutos_Inicio3);
  delay(100);
  Minutos_Fin3 = EEPROM.get(60, Minutos_Fin3);
  delay(100);


  Hora_Inicio4 = EEPROM.get(65, Hora_Inicio4);
  delay(100);
  Hora_Fin4 = EEPROM.get(70, Hora_Fin4);
  delay(100);
  Minutos_Inicio4 = EEPROM.get(75, Minutos_Inicio4);
  delay(100);
  Minutos_Fin4 = EEPROM.get(80, Minutos_Fin4);
  delay(100);


  Hora_Inicio5 = EEPROM.get(85, Hora_Inicio5);
  delay(100);
  Hora_Fin5 = EEPROM.get(90, Hora_Fin5);
  delay(100);
  Minutos_Inicio5 = EEPROM.get(95, Minutos_Inicio5);
  delay(100);
  Minutos_Fin5 = EEPROM.get(100, Minutos_Fin5);
  delay(100);


  Hora_Inicio6 = EEPROM.get(105, Hora_Inicio6);
  delay(100);
  Hora_Fin6 = EEPROM.get(110, Hora_Fin6);
  delay(100);
  Minutos_Inicio6 = EEPROM.get(115, Minutos_Inicio6);
  delay(100);
  Minutos_Fin6 = EEPROM.get(120, Minutos_Fin6);
  delay(100);


  lcd.init();
  lcd.backlight();
  pinMode(upButton, INPUT_PULLUP);
  pinMode(downButton, INPUT_PULLUP);
  pinMode(selectButton, INPUT_PULLUP);




  lcd.clear();
  lcd.setCursor(2, 0);
  lcd.print("PROGRAMADOR ");
  lcd.setCursor(0, 1);
  lcd.print("DE RIEGO DTI,DTH ");
  delay(5000);
  lcd.clear();
  updateMenu();




}

void loop() {
  
  DateTime fecha = rtc.now();      // funcion que devuelve fecha y horario en formato

  

  // accionamiento de las electro válvulas

  if (Hora_Inicio1 == 24) {           // acción para contar hasta 24 los pulsos de las Horas
    Hora_Inicio1 = 0;
  }
  if (Minutos_Inicio1 == 60) {        // acción para contar hasta 60 los pulsos de los Minutos
    Minutos_Inicio1 = 00;
  }
  if (Hora_Fin1 == 24) {
    Hora_Fin1 = 0;
  }
  if (Minutos_Fin1 == 60) {
    Minutos_Fin1 = 0;
  }
  if (fecha.hour() == Hora_Inicio1 && fecha.minute() == Minutos_Inicio1 ) {
    digitalWrite(Sector_1, LOW);
    digitalWrite(Master, LOW);
  }

  if (fecha.hour() == Hora_Fin1 && fecha.minute() == Minutos_Fin1 ) {
    digitalWrite(Sector_1, HIGH);
    digitalWrite(Master, HIGH);
  }


  if (Hora_Inicio2 == 24) {
    Hora_Inicio2 = 0;
  }
  if (Minutos_Inicio2 == 60) {
    Minutos_Inicio2 = 0;
  }
  if (Hora_Fin2 == 24) {
    Hora_Fin2 = 0;
  }
  if (Minutos_Fin2 == 60) {
    Minutos_Fin2 = 0;
  }
  if (fecha.hour() == Hora_Inicio2 && fecha.minute() == Minutos_Inicio2 ) {
    digitalWrite(Sector_2, LOW);
    digitalWrite(Master, LOW);
  }
  if (fecha.hour() == Hora_Fin2 && fecha.minute() == Minutos_Fin2 ) {
    digitalWrite(Sector_2, HIGH);
    digitalWrite(Master, HIGH);
  }


  if (Hora_Inicio3 == 24) {
    Hora_Inicio3 = 0;
  }
  if (Minutos_Inicio3 == 60) {
    Minutos_Inicio3 = 0;
  }
  if (Hora_Fin3 == 24) {
    Hora_Fin3 = 0;
  }
  if (Minutos_Fin3 == 60) {
    Minutos_Fin3 = 0;
  }
  if (fecha.hour() == Hora_Inicio3 && fecha.minute() == Minutos_Inicio3 ) {
    digitalWrite(Sector_3, LOW);
    digitalWrite(Master, LOW);
  }
  if (fecha.hour() == Hora_Fin3 && fecha.minute() == Minutos_Fin3 ) {
    digitalWrite(Sector_3, HIGH);
    digitalWrite(Master, HIGH);
  }


  if (Hora_Inicio4 == 24) {
    Hora_Inicio4 = 0;
  }
  if (Minutos_Inicio4 == 60) {
    Minutos_Inicio4 = 0;
  }
  if (Hora_Fin4 == 24) {
    Hora_Fin4 = 0;
  }
  if (Minutos_Fin4 == 60) {
    Minutos_Fin4 = 0;
  }
  if (fecha.hour() == Hora_Inicio4 && fecha.minute() == Minutos_Inicio4 ) {
    digitalWrite(Sector_4, LOW);
    digitalWrite(Master, LOW);
  }
  if (fecha.hour() == Hora_Fin4 && fecha.minute() == Minutos_Fin4 ) {
    digitalWrite(Sector_4, HIGH);
    digitalWrite(Master, HIGH);
  }


  if (Hora_Inicio5 == 24) {
    Hora_Inicio5 = 0;
  }
  if (Minutos_Inicio5 == 60) {
    Minutos_Inicio5 = 0;
  }
  if (Hora_Fin5 == 24) {
    Hora_Fin5 = 0;
  }
  if (Minutos_Fin5 == 60) {
    Minutos_Fin5 = 0;
  }
  if (fecha.hour() == Hora_Inicio5 && fecha.minute() == Minutos_Inicio5 ) {
    digitalWrite(Sector_5, LOW);
    digitalWrite(Master, LOW);
  }
  if (fecha.hour() == Hora_Fin5 && fecha.minute() == Minutos_Fin5 ) {
    digitalWrite(Sector_5, HIGH);
    digitalWrite(Master, HIGH);
  }

  if (Hora_Inicio6 == 24) {
    Hora_Inicio6 = 0;
  }
  if (Minutos_Inicio6 == 60) {
    Minutos_Inicio6 = 0;
  }
  if (Hora_Fin6 == 24) {
    Hora_Fin6 = 0;
  }
  if (Minutos_Fin6 == 60) {
    Minutos_Fin6 = 0;
  }
  if (fecha.hour() == Hora_Inicio6 && fecha.minute() == Minutos_Inicio6 ) {
    digitalWrite(Sector_6, LOW);
    digitalWrite(Master, LOW);
  }
  if (fecha.hour() == Hora_Fin6 && fecha.minute() == Minutos_Fin6 ) {
    digitalWrite(Sector_6, HIGH);
    digitalWrite(Master, HIGH);
  }







  //control del encoder rotatorio

  if (!digitalRead(downButton)) {
    menu++;
    updateMenu();
    delay(200);
    while (!digitalRead(downButton));
  }
  if (!digitalRead(upButton)) {
    menu--;
    updateMenu();
    delay(200);
    while (!digitalRead(upButton));
  }
  if (!digitalRead(selectButton)) {
    executeAction();
    updateMenu();
    delay(200);
    while (!digitalRead(selectButton));
  }
}



// comienza el Menu

void updateMenu() {
   DateTime fecha = rtc.now();
  switch (menu) {
    case 0:
      menu = 27;
      break;
    case 1:
      lcd.backlight();
      lcd.display();
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(fecha.hour());
      lcd.print(":");
      lcd.print(fecha.minute());
      lcd.print(":");
      lcd.println(fecha.second());
      lcd.print("  ");
      lcd.print(rtc.getTemperature());
      lcd.print("C");



      lcd.setCursor(0, 1);
      lcd.print(fecha.year());
      lcd.print("/");
      lcd.print(fecha.month());
      lcd.print("/");
      lcd.print(fecha.date());
      lcd.print("   ");
      lcd.print(DiaSemana[fecha.dayOfWeek()]);
      //lcd.print(fecha.day());



      break;


    case 2:
      lcd.clear();
      lcd.backlight();
      lcd.display();
      lcd.print(">S1_H_Inicio");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Inicio1);
      lcd.setCursor(0, 1);
      lcd.print(" S1_M_Inicio");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Inicio1);
      break;
    case 3:
      lcd.clear();
      lcd.backlight();
      lcd.display();
      lcd.print(" S1_H_Inicio");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Inicio1);
      lcd.setCursor(0, 1);
      lcd.print(">S1_M_Inicio");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Inicio1);
      break;
    case 4:
      lcd.clear();
      lcd.backlight();
      lcd.display();
      lcd.print(">S1_H_Fin");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Fin1);
      lcd.setCursor(0, 1);
      lcd.print(" S1_M_Fin");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Fin1);
      break;
    case 5:
      lcd.clear();
      lcd.print(" S1_H_Fin");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Fin1);
      lcd.setCursor(0, 1);
      lcd.print(">S1_M_Fin");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Fin1);
      break;



    case 6:
      lcd.clear();
      lcd.print(">S2_H_Inicio");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Inicio2);
      lcd.setCursor(0, 1);
      lcd.print(" S2_M_Inicio");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Inicio2);
      break;
    case 7:
      lcd.clear();
      lcd.print(" S2_H_Inicio");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Inicio2);
      lcd.setCursor(0, 1);
      lcd.print(">S2_M_Inicio");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Inicio2);
      break;
    case 8:
      lcd.clear();
      lcd.print(">S2_H_Fin");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Fin2);
      lcd.setCursor(0, 1);
      lcd.print(" S2_M_Fin");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Fin2);
      break;
    case 9:
      lcd.clear();
      lcd.print(" S2_H_Fin");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Fin2);
      lcd.setCursor(0, 1);
      lcd.print(">S2_M_Fin");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Fin2);
      break;



    case 10:
      lcd.clear();
      lcd.print(">S3_H_Inicio");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Inicio3);
      lcd.setCursor(0, 1);
      lcd.print(" S3_M_Inicio");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Inicio3);
      break;
    case 11:
      lcd.clear();
      lcd.print(" S3_H_Inicio");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Inicio3);
      lcd.setCursor(0, 1);
      lcd.print(">S3_M_Inicio");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Inicio3);
      break;
    case 12:
      lcd.clear();
      lcd.print(">S3_H_Fin");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Fin3);
      lcd.setCursor(0, 1);
      lcd.print(" S3_M_Fin");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Fin3);
      break;
    case 13:
      lcd.clear();
      lcd.print(" S3_H_Fin");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Fin3);
      lcd.setCursor(0, 1);
      lcd.print(">S3_M_Fin");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Fin3);
      break;



    case 14:
      lcd.clear();
      lcd.print(">S4_H_Inicio");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Inicio4);
      lcd.setCursor(0, 1);
      lcd.print(" S4_M_Inicio");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Inicio4);
      break;
    case 15:
      lcd.clear();
      lcd.print(" S4_H_Inicio");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Inicio4);
      lcd.setCursor(0, 1);
      lcd.print(">S4_M_Inicio");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Inicio4);
      break;
    case 16:
      lcd.clear();
      lcd.print(">S4_H_Fin");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Fin4);
      lcd.setCursor(0, 1);
      lcd.print(" S4_M_Fin");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Fin4);
      break;
    case 17:
      lcd.clear();
      lcd.print(" S4_H_Fin");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Fin4);
      lcd.setCursor(0, 1);
      lcd.print(">S4_M_Fin");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Fin4);
      break;



    case 18:
      lcd.clear();
      lcd.print(">S5_H_Inicio");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Inicio5);
      lcd.setCursor(0, 1);
      lcd.print(" S5_M_Inicio");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Inicio5);
      break;
    case 19:
      lcd.clear();
      lcd.print(" S5_H_Inicio");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Inicio5);
      lcd.setCursor(0, 1);
      lcd.print(">S5_M_Inicio");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Inicio5);
      break;
    case 20:
      lcd.clear();
      lcd.print(">S5_H_Fin");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Fin5);
      lcd.setCursor(0, 1);
      lcd.print(" S5_M_Fin");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Fin5);

      break;
    case 21:
      lcd.clear();
      lcd.print(" S5_H_Fin");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Fin5);
      lcd.setCursor(0, 1);
      lcd.print(">S5_M_Fin");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Fin5);
      break;



    case 22:
      lcd.clear();
      lcd.print(">S6_H_Inicio");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Inicio6);
      lcd.setCursor(0, 1);
      lcd.print(" S6_M_Inicio");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Inicio6);
      break;
    case 23:
      lcd.clear();
      lcd.print(" S6_H_Inicio");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Inicio6);
      lcd.setCursor(0, 1);
      lcd.print(">S6_M_Inicio");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Inicio6);
      break;
    case 24:
      lcd.clear();
      lcd.print(">S6_H_Fin");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Fin6);
      lcd.setCursor(0, 1);
      lcd.print(" S6_M_Fin");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Fin6);
      break;
    case 25:
      lcd.clear();
      lcd.print(" S6_H_Fin");
      lcd.setCursor(13, 0);
      lcd.print(Hora_Fin6);
      lcd.setCursor(0, 1);
      lcd.print(">S6_M_Fin");
      lcd.setCursor(13, 1);
      lcd.print(Minutos_Fin6);
      break;



    case 26:
      lcd.clear();
      lcd.print(">GUARDAR");
      lcd.setCursor(0, 1);
      lcd.print("Prueba");
      break;
    case 27:
      lcd.clear();
      lcd.print("GUARDAR");
      lcd.setCursor(0, 1);
      lcd.print(">Prueba");

      break;
    case 28:
      lcd.backlight();
      lcd.display();
      menu = 1;
      break;
  }
}

void executeAction() {
  switch (menu) {
    case 2:
      action1();
      break;
    case 3:
      action2();
      break;
    case 4:
      action3();
      break;
    case 5:
      action4();
      break;
    case 6:
      action5();
      break;
    case 7:
      action6();
      break;
    case 8:
      action7();
      break;
    case 9:
      action8();
      break;
    case 10:
      action9();
      break;
    case 11:
      action10();
      break;
    case 12:
      action11();
      break;
    case 13:
      action12();
      break;
    case 14:
      action13();
      break;
    case 15:
      action14();
      break;
    case 16:
      action15();
      break;
    case 17:
      action16();
      break;
    case 18:
      action17();
      break;
    case 19:
      action18();
      break;
    case 20:
      action19();
      break;
    case 21:
      action20();
      break;
    case 22:
      action21();
      break;
    case 23:
      action22();
      break;
    case 24:
      action23();
      break;
    case 25:
      action24();
      break;
    case 26:
      action25();
      break;
    case 27:
      action26();
      break;
    case 28:
      action27();
      break;

  }
}

void action1() {
  Hora_Inicio1 ++ ;
  lcd.clear();
  lcd.print(Hora_Inicio1);
  lcd.print(":");
  lcd.print(Minutos_Inicio1);
  delay(1000);
}
void action2() {
  Minutos_Inicio1 = Minutos_Inicio1 + 5;
  lcd.clear();
  lcd.print(Hora_Inicio1);
  lcd.print(":");
  lcd.print(Minutos_Inicio1);
  delay(1000);
}
void action3() {
  Hora_Fin1 ++ ;
  lcd.clear();
  lcd.print(Hora_Fin1);
  lcd.print(":");
  lcd.print(Minutos_Fin1);
  delay(1000);
}
void action4() {
  Minutos_Fin1 = Minutos_Fin1 + 5;
  lcd.clear();
  lcd.print(Hora_Fin1);
  lcd.print(":");
  lcd.print(Minutos_Fin1);
  delay(1000);
}


void action5() {
  Hora_Inicio2 ++ ;
  lcd.clear();
  lcd.print(Hora_Inicio2);
  lcd.print(":");
  lcd.print(Minutos_Inicio2);
  delay(1000);
}
void action6() {
  Minutos_Inicio2 = Minutos_Inicio2 + 5;
  lcd.clear();
  lcd.print(Hora_Inicio2);
  lcd.print(":");
  lcd.print(Minutos_Inicio2);
  delay(1000);
}
void action7() {
  Hora_Fin2 ++ ;
  lcd.clear();
  lcd.print(Hora_Fin2);
  lcd.print(":");
  lcd.print(Minutos_Fin2);
  delay(1000);
}
void action8() {
  Minutos_Fin2 = Minutos_Fin2 + 5;
  lcd.clear();
  lcd.print(Hora_Fin2);
  lcd.print(":");
  lcd.print(Minutos_Fin2);
  delay(1000);
}


void action9() {
  Hora_Inicio3 ++ ;
  lcd.clear();
  lcd.print(Hora_Inicio3);
  lcd.print(":");
  lcd.print(Minutos_Inicio3);
  delay(1000);
}
void action10() {
  Minutos_Inicio3 = Minutos_Inicio3 + 5;
  lcd.clear();
  lcd.print(Hora_Inicio3);
  lcd.print(":");
  lcd.print(Minutos_Inicio3);
  delay(1000);
}
void action11() {
  Hora_Fin3 ++ ;
  lcd.clear();
  lcd.print(Hora_Fin3);
  lcd.print(":");
  lcd.print(Minutos_Fin3);
  delay(1000);
}
void action12() {
  Minutos_Fin3 = Minutos_Fin3 + 5;
  lcd.clear();
  lcd.print(Hora_Fin3);
  lcd.print(":");
  lcd.print(Minutos_Fin3);
  delay(1000);
}


void action13() {
  Hora_Inicio4 ++ ;
  lcd.clear();
  lcd.print(Hora_Inicio4);
  lcd.print(":");
  lcd.print(Minutos_Inicio4);
  delay(1000);
}
void action14() {
  Minutos_Inicio4 = Minutos_Inicio4 + 5;
  lcd.clear();
  lcd.print(Hora_Inicio4);
  lcd.print(":");
  lcd.print(Minutos_Inicio4);
  delay(1000);
}
void action15() {
  Hora_Fin4 ++ ;
  lcd.clear();
  lcd.print(Hora_Fin4);
  lcd.print(":");
  lcd.print(Minutos_Fin4);
  delay(1000);
}
void action16() {
  Minutos_Fin4 = Minutos_Fin4 + 5;
  lcd.clear();
  lcd.print(Hora_Fin4);
  lcd.print(":");
  lcd.print(Minutos_Fin4);
  delay(1000);
}


void action17() {
  Hora_Inicio5 ++ ;
  lcd.clear();
  lcd.print(Hora_Inicio5);
  lcd.print(":");
  lcd.print(Minutos_Inicio5);
  delay(1000);
}
void action18() {
  Minutos_Inicio5 = Minutos_Inicio5 + 5;
  lcd.clear();
  lcd.print(Hora_Inicio5);
  lcd.print(":");
  lcd.print(Minutos_Inicio5);
  delay(1000);
}
void action19() {
  Hora_Fin5 ++ ;
  lcd.clear();
  lcd.print(Hora_Fin5);
  lcd.print(":");
  lcd.print(Minutos_Fin5);
  delay(1000);
}
void action20() {
  Minutos_Fin5 = Minutos_Fin5 + 5;
  lcd.clear();
  lcd.print(Hora_Fin5);
  lcd.print(":");
  lcd.print(Minutos_Fin5);
  delay(1000);
}


void action21() {
  Hora_Inicio6 ++ ;
  lcd.clear();
  lcd.print(Hora_Inicio6);
  lcd.print(":");
  lcd.print(Minutos_Inicio6);
  delay(1000);
}
void action22() {
  Minutos_Inicio6 = Minutos_Inicio6 + 5;
  lcd.clear();
  lcd.print(Hora_Inicio6);
  lcd.print(":");
  lcd.print(Minutos_Inicio6);
  delay(1000);
}
void action23() {
  Hora_Fin6 ++ ;
  lcd.clear();
  lcd.print(Hora_Fin6);
  lcd.print(":");
  lcd.print(Minutos_Fin6);
  delay(1000);
}
void action24() {
  Minutos_Fin6 = Minutos_Fin6 + 5;
  lcd.clear();
  lcd.print(Hora_Fin6);
  lcd.print(":");
  lcd.print(Minutos_Fin6);
  delay(1000);
}



//GRABAR EN EEPROM

void action25() {


  delay(100);
  EEPROM.put(5, Hora_Inicio1);

  delay(100);
  EEPROM.put(10, Hora_Fin1);

  delay(100);
  EEPROM.put(15, Minutos_Inicio1);

  delay(100);
  EEPROM.put(20, Minutos_Fin1);



  delay(100);
  EEPROM.put(25, Hora_Inicio2);

  delay(100);
  EEPROM.put(30, Hora_Fin2);

  delay(100);
  EEPROM.put(35, Minutos_Inicio2);

  delay(100);
  EEPROM.put(40, Minutos_Fin2);



  delay(100);
  EEPROM.put(45, Hora_Inicio3);

  delay(100);
  EEPROM.put(50, Hora_Fin3);

  delay(100);
  EEPROM.put(55, Minutos_Inicio3);

  delay(100);
  EEPROM.put(60, Minutos_Fin3);



  delay(100);
  EEPROM.put(65, Hora_Inicio4);

  delay(100);
  EEPROM.put(70, Hora_Fin4);

  delay(100);
  EEPROM.put(75, Minutos_Inicio4);

  delay(100);
  EEPROM.put(80, Minutos_Fin4);



  delay(100);
  EEPROM.put(85, Hora_Inicio5);

  delay(100);
  EEPROM.put(90, Hora_Fin5);

  delay(100);
  EEPROM.put(95, Minutos_Inicio5);

  delay(100);
  EEPROM.put(100, Minutos_Fin5);



  delay(100);
  EEPROM.put(105, Hora_Inicio6);

  delay(100);
  EEPROM.put(110, Hora_Fin6);

  delay(100);
  EEPROM.put(115, Minutos_Inicio6);

  delay(100);
  EEPROM.put(120, Minutos_Fin6);
  delay(100);
  lcd.clear();
  lcd.print("GUARDANDO");
  delay(3000);
  lcd.clear();
  lcd.print("OK");
  delay(1500);
}


void action26() {
  delay(100);
  digitalWrite(Sector_1, LOW);
  digitalWrite(Master, LOW);
  delay(10000);
  digitalWrite(Sector_1, HIGH);
  digitalWrite(Master, HIGH);
  delay(5000);
  
  digitalWrite(Sector_2, LOW);
  digitalWrite(Master, LOW);
  delay(10000);
  digitalWrite(Sector_2, HIGH);
  digitalWrite(Master, HIGH);
  delay(5000);

  digitalWrite(Sector_3, LOW);
  digitalWrite(Master, LOW);
  delay(10000);
  digitalWrite(Sector_3, HIGH);
  digitalWrite(Master, HIGH);
  delay(5000);

  digitalWrite(Sector_4, LOW);
  digitalWrite(Master, LOW);
  delay(10000);
  digitalWrite(Sector_4, HIGH);
  digitalWrite(Master, HIGH);
  delay(5000);

  digitalWrite(Sector_5, LOW);
  digitalWrite(Master, LOW);
  delay(10000);
  digitalWrite(Sector_5, HIGH);
  digitalWrite(Master, HIGH);
  delay(5000);

  digitalWrite(Sector_6, LOW);
  digitalWrite(Master, LOW);
  delay(10000);
  digitalWrite(Sector_6, HIGH);
  digitalWrite(Master, HIGH);
  delay(1000);

}


void action27() {
  delay(100);
  lcd.clear();
  menu = 1;

}

Primero te digo que no hay limitación en el tamaño del código que puedes subir en tu post y va en tu contra obligarnos a descargar el código para ayudarte siendo que perfectamente podríamos verlo aquí directamente.
Edita tu post y pon el código de acuerdo a las Normas del foro, es para tu beneficio.

Por otro lado, imagino que

Sector_x = LOW;

crees que es lo mismo que

digitalWrite(Sector_x, LOW);

Pues no, lo que haces es poner la variable a 0 (LOW = 0), entonces todos los

digitalWrite(Sector_x, algo);

posteriores los haces sobre el pin 0.
Lo mismo ocurre con master.

Estas 2 líneas están de más

  Wire.begin();
  rtc.begin();

La primera, desde mi punto de vista es innecesaria porque Wire ya fue iniciado por rtc
La segunda porque rtc ya fue iniciado luego de Serial.begin() (y si no inició es porque no se encontró el RTC).

Respecto al retraso, supongo que es un problema del módulo, otra cosa no se me ocurre.

Saludos

Muchísimas gracias, editaré como me comentas

El El vie, 16 jul 2021 a las 19:25, gatul via Arduino Forum <arduino@discoursemail.com> escribió:

Recién confirmé que mi módulo RTC (también con chip DS3231) en 18 días apenas se retrasó 3 segundos comparado con la hora del servidor NTP desde el que se actualiza la hora de mi PC.

Tal vez te convendría cargar los ejemplos adjust (para ponerlo en hora) y luego now (que te muestra la hora por consola) de la librería.

Déjalo correr 1 hora (si el módulo tiene la batería puesta, puedes apagar todo), y luego verifica el retraso.

De ser tal cual lo cuentas, tendrías que ver un retraso de más de 4 min por cada hora transcurrida, y ya sería definitivamente una falla del módulo.

Saludos

Moderador:
Te envío privado por favor léelo y ten presente las indicaciones que ahi te doy.

Voy a hacer observaciones como las que hizo @gatul considerando que eres nuevo en este mundo de microcontroladores.
Mi consejo es que mas alla de tu necesidad no creas que porque viste un video en youtube y te pareció fácil, realmente lo es. Ya has comprobado la infinidad de cosa que hay que tener en cuenta. Electricidad, Electrónica y Programación o Software.
No son cuestiones menores. Se que lo sabes pero porque lo recuerdo:
Un buen libro que te introduzca con teoría sobre el Arduino te ayuda a comprender mejor en qué te estas metiendo y no lo digo para desalentarte, todo lo contrario, para que tengas una mejor idea de qué se puede hacer y donde estan tus limites al igual que los nuestros.

  1. No hace falta ABUSAR (lo pongo con mayúsculas) de delay().
    Olvida delay() y te lo observo ahora que recién empiezas.
    Delay detiene el micro.
    Cada vez que haces esto
delay(100);
  Hora_Inicio1 = EEPROM.get(5, Hora_Inicio1);
  delay(100);

Has detenido el micro 200 mseg y eso es mucho tiempo en estas cosas.
Esto escrito asi por ti

delay(100);
  Hora_Inicio1 = EEPROM.get(5, Hora_Inicio1);
  delay(100);
  Hora_Fin1 = EEPROM.get(10, Hora_Fin1);
  delay(100);
  Minutos_Inicio1 = EEPROM.get(15, Minutos_Inicio1);
  delay(100);
  Minutos_Fin1 = EEPROM.get(20, Minutos_Fin1);
  delay(100);


  Hora_Inicio2 = EEPROM.get(25, Hora_Inicio2);

puede y debe hacerse asi

  Hora_Inicio1 = EEPROM.get(5, Hora_Inicio1);
  Hora_Fin1 = EEPROM.get(10, Hora_Fin1);
  Minutos_Inicio1 = EEPROM.get(15, Minutos_Inicio1);
  Minutos_Fin1 = EEPROM.get(20, Minutos_Fin1);
  Hora_Inicio2 = EEPROM.get(25, Hora_Inicio2);

Y todavia puede hacerse en 1 sola instrucción pero no quiero marearte ahora.
Puedes poner todo en un vector o sea una matriz de 1 dimension con los datos o mejor crear una estructura con las horas de inicio y fin y otras cosas comunes a tu código.
En resumen de esta observación: no uses delay() cuando no hace falta.
Que lo reemplaza, millis(). Donde se aprende? Ve a Documentación y busca los tutoriales que ahi tenemos al respecto. Hay muy buenos tutos.

  1. Este delay() si esta bien
    En contrapartida y solo para darte la otra mirada este delay(5000) que detiene para ver solo la pantalla con tu presentación si que esta bien. Justamente eso quieres. Una pausa.
lcd.print("DE RIEGO DTI,DTH ");
  delay(5000);
  1. Estas comparaciones
if (fecha.hour() == Hora_Inicio1 && fecha.minute() == Minutos_Inicio1 ) {
    digitalWrite(Sector_1, LOW);
    digitalWrite(Master, LOW);
  }

Se van a ejecutar muchas veces durante un minuto. Siempre ten en cuenta eso.
Un buen código no repite las cosas o las acciones de control.
De nuevo, recien empiezas y cuesta verlo al comienzo pero mira la línea.
La condición sera VERDADERA durante todo el minuto que coincidan las cosas.
Una manera de evitar que eso se repita es usar un flag o bandera. Una variable del tipo si o no, en otras palabras 1 o 0, o sea un bit.
Esa variable se designa como bool o boolean

bool flag = true  // es decir cuando flag sea VERDADERO o true entonces se ejecuta 
                  // algo de lo contrario no.

con esto la condición se modifica asi

if (fecha.hour() == Hora_Inicio1 && fecha.minute() == Minutos_Inicio1 && flag) {
    digitalWrite(Sector_1, LOW);
    digitalWrite(Master, LOW);
     // como ya terminé que hago? pongo flag = false asi no se ejecuta mas pero ojo!!
      flag = false;
  }

La única observación que esto deshabilita la condición por siempre de modo que en algun momento debemos reactivar haciendo otra vez flag = true pero cuando sea conveniente. Lo ideal sería cuando acaba el minuto en cuestion o en la siguiente condicion. Una opción es con un else, otra en la siguiente condición similar, con lo que desactivas la que le corresponda flag1 a flag6 y activas la anterior.
Eso te lo dejo a ti para que lo resuelvas o lo vemos luego.

  1. No entiendo porque permanentemente haces esto para cada hora seleccionada
  if (Hora_Inicio1 == 24) {           // acción para contar hasta 24 los pulsos de las Horas
    Hora_Inicio1 = 0;
  }
  if (Minutos_Inicio1 == 60) {        // acción para contar hasta 60 los pulsos de los Minutos
    Minutos_Inicio1 = 00;
  }

No sería mas conveniente hacer una validación con el menú y si detectas algo que lo corrija?
Incluso que fuese una rutina como esta

// llamas a la rutina
valido_hora_min(Hora_Inicio1, Minutos_Inicio1);

// luego del loop
void valido_hora_min(int tmpHora, int tmpMin) {
  if (tmpHora== 24) {           // acción para contar hasta 24 los pulsos de las Horas
      tmpHora= 0;
  }
  if (tmpMin== 60) {        // acción para contar hasta 60 los pulsos de los Minutos
    tmpMin= 00;
  }
}

Eso reduciría tu código.

Hay mas observaciones pero dejaré que digieras estas y luego conversamos por otras opciones que van a achicar tu código.