alarma con modulo rtc

hola, estoy haciendo una alarma de casa, ya saben las típicas con un lcd, un teclado, añadí el modulo rtc para mostrar la hora en la pantalla después de un cierto tiempo de inactividad, es eso no tengo problema, el problema es que quiero que el usuario pueda configurar la hora como lo hacemos en los celulares.
después de intentarlo un poco he conseguido esto:

#include <LiquidCrystal_I2C.h> 
#include<Wire.h>
#include <Keypad.h>
#include <RTClib.h>

const byte FILAS = 4;     // define numero de filas
const byte COLUMNAS = 4;    // define numero de columnas
char keys[FILAS][COLUMNAS] = {    // define la distribucion de teclas
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};

byte pinesFilas[FILAS] = {5,4,3,2};   
byte pinesColumnas[COLUMNAS] = {9,8,7,6};

Keypad teclado = Keypad(makeKeymap(keys), pinesFilas, pinesColumnas, FILAS, COLUMNAS);   
RTC_DS3231 rtc; 
LiquidCrystal_I2C lcd(0x3f,16,2);

int POSICION_COLUMNA = 6;
int POSICION_FILA = 0;
int CONTINUIDAD = 0;
char TECLA;
char ATRAS = '*';
char UP = 'A';
char DOWN = 'B';
char ENTER = '#';

int YEAR;
int MONT;
int DAY;
int HOUR;
int MINUT;
int SRCOND;


void setup() {
  lcd.init();
  lcd.backlight();
  lcd.begin(16, 2);
  if (! rtc.begin()) {
    Serial.println("Modulo RTC no encontrado !");
 }    
 rtc.adjust(DateTime(__DATE__, __TIME__));
}

 
void loop() {
  
  DateTime fecha = rtc.now(); 
  lcd.cursor();
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("fecha 30/09/2020");           
  lcd.setCursor(0,1);
  lcd.print("hora 20:00:00");
  lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
  while (true){
  
     if (CONTINUIDAD == 0){
      TECLA = teclado.getKey(); 
    }
    
    if (TECLA){
      if (TECLA == DOWN){
        if (POSICION_FILA == 0){
          if (POSICION_COLUMNA == 6){
            CONTINUIDAD = 0;
          }
          else if (POSICION_COLUMNA == 9){
            POSICION_COLUMNA--;
            POSICION_COLUMNA--;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
          else if (POSICION_COLUMNA == 11){
            POSICION_COLUMNA--;
            POSICION_COLUMNA--;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
          else{
          POSICION_COLUMNA --;
          lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
          CONTINUIDAD = 0;
          }
        }
        else{
          if (POSICION_COLUMNA == 5){
            POSICION_FILA = 0;
            POSICION_COLUMNA = 14;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
          else if (POSICION_COLUMNA == 8){
            POSICION_COLUMNA--;
            POSICION_COLUMNA--;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
          else if (POSICION_COLUMNA == 11){
            POSICION_COLUMNA--;
            POSICION_COLUMNA--;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
          else{
            POSICION_COLUMNA --;             
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
        }
      }
      
      else if (TECLA == UP){
                  
        if (POSICION_FILA == 0){
          if (POSICION_COLUMNA == 7){
            POSICION_COLUMNA++;
            POSICION_COLUMNA++;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
          else if (POSICION_COLUMNA == 9){
            POSICION_COLUMNA++;
            POSICION_COLUMNA++;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
          else if (POSICION_COLUMNA == 14){
            POSICION_FILA = 1;
            POSICION_COLUMNA = 5;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
          else{
              POSICION_COLUMNA ++;
              lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
              CONTINUIDAD = 0;
            }
        }
        else{
          if (POSICION_COLUMNA == 6){
            POSICION_COLUMNA++;
            POSICION_COLUMNA++;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
          else if (POSICION_COLUMNA == 9){
            POSICION_COLUMNA++;
            POSICION_COLUMNA++;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
          else if (POSICION_COLUMNA == 12){
            CONTINUIDAD = 0;
          }
          else{
            POSICION_COLUMNA ++;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);             
            CONTINUIDAD = 0;
          }
        }
      }
      
      else{
        lcd.print(TECLA);
        POSICION_COLUMNA++;
        lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
        CONTINUIDAD = 0;
        
        if (POSICION_FILA == 0){
          if (POSICION_COLUMNA == 8){
            POSICION_COLUMNA++;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
          else if (POSICION_COLUMNA == 10){
            POSICION_COLUMNA++;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
          else if (POSICION_COLUMNA == 15){
            POSICION_FILA = 1;
            POSICION_COLUMNA = 5;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
        }
        else{
          if (POSICION_COLUMNA == 7){
            POSICION_COLUMNA++;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
          else if (POSICION_COLUMNA == 10){
            POSICION_COLUMNA++;
            lcd.setCursor(POSICION_COLUMNA,POSICION_FILA);
            CONTINUIDAD = 0;
          }
          else if (POSICION_COLUMNA == 12){
            lcd.clear();
            lcd.print("datos guardados");
            delay(1800);
            CONTINUIDAD = 0;
            break;
          }
        }
      }
    }
    else{
      while (true ){
        TECLA = teclado.getKey();
        DateTime fecha = rtc.now();
        if (fecha.second()%2 == 0){
          lcd.noCursor();
          TECLA = teclado.getKey();

        }
        else {
          lcd.cursor();
          TECLA = teclado.getKey();
                
        }
        if (TECLA){
          lcd.cursor();
          CONTINUIDAD = 1;
          break;
        }
      }
    }
  }
}

no estoy seguro si es la mejor forma de hacerlo, de la forma en que esta hecho he pensado en usar
rtc.adjust(DateTime(AÑO, MES, DIA, HORA, MINUTO, SEGUNDO));
para establecer la hora pero no se como hacer que las variables tomen el valor que les corresponde, podría poner un condicional para cada posición de columna y fila pero el código se alargaría demasiado y ya esta demasiado extenso, por favor si alguien tiene una idea de como hacerlo le agradecería mucho

Buenas!

Hace un buen tiempo hice un proyecto parecido, una alarma disparada por un par de timers y un sensor de temperatura para la cocina de casa. Al final le quise agregar un RTC para mostrar la hora, y como ésto iba a ir empotrado en la pared, obviamente no podía estar conectándole un conversor USB-Serie todo el tiempo para programarle la hora en caso de que se cortara la luz. Esto lo hice no con un Arduino UNO, sino con un controlador un poquito más pequeño y muy rápido me vi obligado a buscar soluciones optimizadas.

Eeentonces, a lo que vamos, hacerlo con condicionales, como dijiste, va a hacer que el código se vuelva ilegible MUY rápido. Una de las cosas que podrías hacer para evitar eso es algo como lo siguiente; crear una función que espere un valor en el teclado, y que convierta ese valor ingresado (que sería del tipo char) en un número (int) que después puedas pasar al RTC. Esa función la podrías reutilizar todas las veces que quieras dentro del código de configuración de la hora.

Sería algo como (lo escribí así nomás, así que no garantizo nada jajajaj)

int leerNumero()
{
    TECLA = teclado.getKey();

    if(TECLA == '1')
        return 1;
    else if(TECLA == '2')
        return 2;
    // Y así siguiendo...
}

Otra cosa que podrías hacer para evitarte esos condicionales INCLUSIVE, sería trabajar con valores ASCII. Mira esta tabla: http://www.asciitable.com/.
Si te fijas, los caracteres del '0' al '9' corresponden a los valores ASCII del 48 al 57, así que perfectamente podrías tomar este principio y hacer una función que te devuelva un número a partir del presionar de una tecla sin ningún condicional.

int leerASCII()
{
    TECLA = (uint8_t) teclado.getKey();

    // checkear que no esté vacío
    if(TECLA >= 48 && TECLA <= 57)
        return TECLA - 48;
    else
        // si está vacío y no se presionó nada, retornamos -1. 
        return -1;

    // Sino, le quitamos 48 al valor. 
    return TECLA - 48;
}

void loop()
{
    int numero = leerASCII();

    if(numero != -1)
    {
        // Hacer lo que quieras con ese número
    }
}

-- (Data adicional que no es del todo necesario, pero te puede servir para pensar en diferentes soluciones)

Ahora bien, todavía tendrías que ir a través de todos los valores (o sea, primero setear el año, después el mes, después el día, y así siguiendo), y aunque de por sí no está mal hacerlo así, sí se puede optimizar un poquito más. Si quisieras, podrías tener un array/matriz en donde tengas todos los valores del RTC, y en un bucle ir a través de cada uno de esos valores, actualizándolos en base a lo que el usuario quiera.

Si se me complicó mucho la explicación, mil disculpas jajajaj

Anyways, si le quieres pegar una mirada al proyecto ese que te mencioné hice hace algún tiempo, está acá: ATtiny-TempAlarm.

Te dejo también un extracto del código que setea la hora, supongo que es más fácil verlo en acción :wink:

TempAlarm/Module_RTC.h y TempAlarm/Module_RTC.cpp:

// Seconds, minutes, hours, day, date, month, year
// Limites para los diferentes campos, máximo 59 segundos, 59 minutos, 23 horas. El usuario no se puede pasar de esto!
const uint8_t TimeUpperLimits[7] {59, 59, 23, 7, 31, 12, 99};
// Lo mismo pero mínimos
const uint8_t TimeLowerLimits[7] { 0,  0,  0, 1,  1,  1,  0};
// Acá vamos a guardar la fecha/hora actual. 
uint8_t Time[7];

// Recorro Time desde la posicion 0 hasta la 6 (los 7 campos definidos previamente)
for(int8_t ByteToConfigure = 6; ByteToConfigure >= 0; ByteToConfigure--)
{
    // Hasta que yo diga :P
    for(;;)
    {
        // En resumen, si el usuario presiona el botón de MENOS (-)
        if(Switches->readKeyPulse(RTC_BUTTON_MINUS_ID, RTC_BUTTON_MINUS_THRESHOLD) >= RTC_BUTTON_MINUS_THRESHOLD)
        {
            // Y si NO llegamos al valor límite (inferior), reducimos el valor de Time[posicion en la que estamos] en 1. 
            if(Time[ByteToConfigure] > TimeLowerLimits[ByteToConfigure])
            {
                Time[ByteToConfigure]--;
            }
        }
        // Lo mismo, si el usuario presiona el botón MÁS (+)
        else if(Switches->readKeyPulse(RTC_BUTTON_PLUS_ID, RTC_BUTTON_PLUS_THRESHOLD) >= RTC_BUTTON_PLUS_THRESHOLD)
        {
            // Y si NO llegamos al valor límite (ahora superior), AUMENTAMOS el valor de Time[posicion en la que estamos] en 1. 
            if(Time[ByteToConfigure] < TimeUpperLimits[ByteToConfigure])
            {
                Time[ByteToConfigure]++;
            }
        }
        
        // Si el usuario presiona el botón de terminar configuración, salimos del bucle for(;;) que definimos antes. 
        if(Switches->readKeyPulse(RTC_BUTTON_NEXT_ID, RTC_BUTTON_NEXT_THRESHOLD) >= RTC_BUTTON_NEXT_THRESHOLD)
        {
            break;
        }
 
        // Acá ocurre la magia, setTime() (que es una función propia) toma el array "Time" que acabamos de modificar y se lo manda al RTC para guardarlo. 
        setTime();
    }
}

Si me enredé mucho, lo siento! jajajaj Mucha suerte!

Hola @ferminoliaz. Si te sirve como referencia te paso la función que hice para ajustar la hora de una alarma de eventos. En éste caso utilicé la libreria DS3231 en lugar de la tuya, pero podés adaptarla.

/------------------------------------------------------------------------------------------------
//------------------------------- Ajuste hora Reloj ----------------------------------------------
//------------------------------------------------------------------------------------------------

void ajusteHora()
    
 {
  hhh=t.hour; //-------------- pone hora------------------
  mmm=t.min;
  lcd.clear();
  lcd.setCursor(4,0);
  lcd.print(F("AJUSTAR HORA"));
  lcd.setCursor(5,2);
  if(hhh<10){lcd.print(F("0"));}
  lcd.print(hhh);
    lcd.print(F("hs "));
 if(mmm<10){lcd.print(F("0"));}
  lcd.print(mmm);
    lcd.print(F("min"));
   btnBounce(menuok);
      lcd.setCursor(6 ,3);
    lcd.print(char(94));
    while (digitalRead(menuok) == HIGH)
    {
      if (digitalRead(up) == LOW )
      {hhh=hhh+1;
        if (hhh ==24) {
          hhh = 0;
          lcd.setCursor(5 , 2);
          lcd.print(F("0"));
          lcd.print(hhh);
        }
        else
        {
          lcd.setCursor(5 ,2);
          if(hhh<10){lcd.print(F("0"));}
          lcd.print(hhh);
         
        }delay(300);
      } //btnBounce(suma);
      if (digitalRead(down) == LOW )
      {
        if (hhh == 0)
        {
          hhh = 24;
        }
        lcd.setCursor(5, 2);
        if(hhh<11){lcd.print(F("0"));}
        lcd.print(hhh - 1);
        hhh = hhh - 1;
        delay(300);//btnBounce(resta);
      }
    } lcd.setCursor(6, 3);
    lcd.print(F(" "));
    btnBounce(menuok);
 
    lcd.setCursor(11, 3);
    lcd.print(char(94));
    while (digitalRead(menuok) == HIGH)
    {
      if (digitalRead(up) == LOW )
      {mmm=mmm+1;
        if (mmm ==60) {
          mmm = 0;
          lcd.setCursor(10, 2);
          lcd.print(F("0"));
          lcd.print(mmm);
        }
        else
        {
          lcd.setCursor(10,2);
          if(mmm<10){lcd.print(F("0"));}
          lcd.print(mmm);
          
        }delay(200);
      } //btnBounce(suma);
      if (digitalRead(down) == LOW )
      {
        if (mmm == 0)
        {
          mmm = 60;
        }
        lcd.setCursor(10, 2);
        if(mmm<11){lcd.print(F("0"));}
        lcd.print(mmm - 1);
        mmm = mmm - 1;
        delay(200);//btnBounce(resta);
      }
    }
    lcd.setCursor(11, 3);
    lcd.print(F(" "));
    btnBounce(menuok);
    rtc.setTime(hhh, mmm, 0);

    //-------------------- pone Day Of Week ---------------------------------
    lcd.clear();
    //delay(200);
    lcd.print(F(" Dia actual"));
    lcd.setCursor(7,2);
    lcd.print("L M M J V S D");
    dds=t.dow,DEC;
    lcd.setCursor(5+(2*dds),3);
    lcd.write(byte(0));
    
    while(digitalRead(menuok)==HIGH)
        {
          if(digitalRead(up)==LOW && dds<7)
            {
              lcd.setCursor(5+(2*dds),3);
              lcd.print("  ");
              lcd.write(byte(0));
              dds++;
              btnBounce(up);
            }
            
            if(digitalRead(down)==LOW && dds>1)
            {
              dds--;
              lcd.setCursor(5+(2*dds),3);
              lcd.write(byte(0));
              lcd.print("  ");
              btnBounce(down);
            }
         }
       rtc.setDOW(dds); 
       btnBounce(menuok); 
    
   //-------------- pone fecha------------------
  
  lcd.clear();
  hhh=t.date;
  mmm=t.mon;
  anio=t.year;
  lcd.setCursor(4,0);
  lcd.print(F("AJUSTAR FECHA"));
  lcd.setCursor(5,2);
  if(hhh<10){lcd.print(F("0"));}
  lcd.print(hhh);
    lcd.print(F("/"));
 if(mmm<10){lcd.print(F("0"));}
  lcd.print(mmm);
    lcd.print(F("/"));
    lcd.print(anio);
   btnBounce(menuok);
      lcd.setCursor(6 ,3);
    lcd.print(char(94));

    while (digitalRead(menuok) == HIGH)
    {
      if (digitalRead(up) == LOW && hhh<31 )
       {
          hhh=hhh+1;
          lcd.setCursor(5 ,2);
          if(hhh<10){lcd.print(F("0"));}
          lcd.print(hhh);
         delay(400);
        }
       //btnBounce(suma);
      if (digitalRead(down) == LOW && hhh>1 )
      {
        hhh = hhh - 1;
        lcd.setCursor(5, 2);
        if(hhh<10){lcd.print(F("0"));}
        lcd.print(hhh);
        delay(400);
      }
        //btnBounce(resta);
   }
    lcd.setCursor(6, 3);
    lcd.print(F(" "));
    btnBounce(menuok);
 
    lcd.setCursor(9, 3);
    lcd.print(char(94));
    while (digitalRead(menuok) == HIGH)
    {
      if (digitalRead(up) == LOW && mmm<12)
        {
          mmm=mmm+1;
          lcd.setCursor(8, 2);
          if(mmm<10){lcd.print(F("0"));}
          lcd.print(mmm);
          delay(450);
         }
      //btnBounce(suma);
      if (digitalRead(down) == LOW && mmm>1 )
      {
        mmm=mmm-1;
        lcd.setCursor(8, 2);
        if(mmm<10){lcd.print(F("0"));}
        lcd.print(mmm);
        delay(450);
      }
        //btnBounce(resta);
    }
    lcd.setCursor(9, 3);
    lcd.print(" ");
    btnBounce(menuok);
    lcd.setCursor(14, 3);
    lcd.print(char(94));
    while (digitalRead(menuok) == HIGH)
    {
      if (digitalRead(up) == LOW )
        {
          anio=anio+1;
          lcd.setCursor(11, 2);
          lcd.print(anio);
          delay(450);
         }
     //btnBounce(suma);
      if (digitalRead(down) == LOW )
      {
        anio=anio-1;
        lcd.setCursor(11, 2);
        lcd.print(anio);
        delay(450);
      }
       // btnBounce(resta);
    }
    lcd.setCursor(14, 3);
    lcd.print(F(" "));
    btnBounce(menuok);
    rtc.setDate(hhh, mmm, anio);
    reordenar();
    mostrarMenu();
    lcdMenu();
 }// end ajusteHora()