RTC DS3231 stops

Hi everyone this is the program for my exam project, but it has a problem with the DS3231. The project is based on two work rooms, controlled both for air quality and to obtain an ideal temperature. The problem is that the DS3231 counts for a second and then stops. The DS3231 additionally has to change the time and date. Thank you all

#include <LiquidCrystal_I2C.h>
#include <DHT.h> //libreria sensore temperatura
#include <Wire.h> //comunicare con lcd
#include <Servo.h>
#include <TimeLib.h>  
#include <DS3232RTC.h> 
#include "Adafruit_CCS811.h"

#define DHTTYPE DHT22 //tipo di sensore utilizzato lettura ogni 2 sec

//stanza 1 (DX)
#define LED_PIN_M1 4 //luminosità M1
#define Tp_s1 45 //temperatura Sl
#define PM1 5//Selezione M1 
#define PS1 6 //luce bianca S1
LiquidCrystal_I2C lcd1(0x23, 20, 4); //indirizzo,colonne,righe M1

//stanza 2 (SX)
#define LED_PIN_M2 8 //luminosità M2
#define Tp_s2 44 //temperatura S2
#define PM2 10 //Selezione M2
#define PS2 9 //luce bianca S2
LiquidCrystal_I2C lcd2(0x27, 20, 4); //indirizzo,colonne,righe M2

#define Psan 7 // pulsante sanificatore

//orologio
#define Pgiu 13 //pulsante giu orologio
#define Psu 12 //pulsante su orologio
#define Pmenu 11 //pulsante menu orologio
int ore , minuti, secondi;
time_t t;
tmElements_t tm;
int indiceset      = 0;  // indice utilizzato per avviare e gestire la routine di settaggio dei parametri
int setta          = 0;  // valore pulsante settaggio
int su             = 0;  // valore pulsante avanti
int giu            = 0;  // valore pulsante indietro
int incremento     = 0;  // valore utilizzato per aumentare o diminuire il parametro in via di settaggio
int indicedati     = 0;  // indice di scorrimetno della tabella tabdati
int riga           = 0;  // riga del display sulla quale si sta agendo
int datodaesporre  = 0;  // parametro in via di esposizione
long tempoprec     = 0; // zona di memorizzazione del momento dell'ultima esposizione dei dati
long tempocorrente = 0; // zona di memorizzazione del momento corrente
int intermittenza  = 0; // semaforo di intermittenza (0 espone il parametro, 1 non espone il parametro)
int tabdati [21]   // tabella di acquisizione dei parametri
{ // min   max  valore
  10,     99,      0,   // anno
  1,      12,      0,   // mese
  1,      31,      0,   // giorno
  0,      23,      0,   // ora
  0,      59,      0,   // minuto
  0,      59,      0,   // secondo
  0,      0,       0,   // dummy
};
// ************* fine delle variabili e degli elementi necessari al settaggio dell'orologio ***********
int digits         = 0;    // zona di memorizzazione dei minuti e dei secondi da esporre sul display lcd
char tabmesi [37]  =  "genfebmaraprmaggiulugagosetottnovdic";  // tabella descr. mesi
int mese           = 0;    // zona di memorizzazione del mese corrente
int lavoro         = 0;    // zona di lavoro, utilizzata per calcoli intermedi

//rele dx
#define s2Lb 23 // led S2 blu
#define s2Lg 25 // led s2 verde
#define s2Lr 27 // led S2 rosso
#define s1Lb 29 // led S1 blu
#define s1Lg 31 // led S1 verde
#define s1Lr 33 // led S1 rosso
#define LUV 35// led UV

//rele cx
#define pompaB 22 // pompa blu
#define pompaR 24 // pompa rossa
#define VenP 26 //ventole plennium
#define VenC 28// ventola condizionatore
#define Rsan 30 //sanificatore

// variabili per utilizzo sensori PPM
int PPM1 ;
int PPM2 ;
Adafruit_CCS811 ccs1;
Adafruit_CCS811 ccs2;


//variabili S.temperatura e umidita
int temp_s1 = 0 ;  // sensore di temperatura s1
int temp_s2 = 0 ;  //sensorte di temperatura s2
int temp_A = 0;    //temperatura ambiente
DHT dht1(Tp_s1, DHTTYPE);
DHT dht2(Tp_s2, DHTTYPE);
int um_s1 = 0 ; // umidita s1
int um_s2 = 0 ; //umidita s2

//gestione mills
//M1
unsigned long previousMillis = 0; //memorizza ultimo aggiornamento
const long interval = 2000;   //    // intervallo in millisecondi    
//M2 
unsigned long previousMillis2 = 0; //memorizza ultimo aggiornamento
const long interval2 = 2000;   //    // intervallo in millisecondi  
//sanificatore
unsigned long previousMillis3 = 0; //memorizza ultimo aggiornamento
const long interval3 = 2000;   //    // intervallo in millisecondi   
//led verde
unsigned long previousMillis4 = 0; //memorizza ultimo aggiornamento
const long interval4 = 10000;   //    // intervallo in millisecondi 

//stampe
//M1 stanza1
String SL1 = "meeting room"; 
String AQ = "air quality:";  
String ppm = "PPM";
String TP = "temperature:";
String gradi = "C";
String UM = "Humidity:";
String RH = "%"; 
// M1 stanza2
String SL2 = "office"; 
// M2 stanza1
String riga1 = "meeting R|| office"; 
String stang = "||";
String riga3 = "IAQ";  
String riga3p = "PPM";
// M2 stanza2
String riga2 = "time:";
String riga4 = "date:";

//servo
Servo servodx;
Servo servosx;
Servo servocx;
int mediaPPM = 0; //per manovrare servo cx


//sottoprogrammi per funzionamento orologio
//
//********* routine di esposizione di data, ora e temperatura sul display lcd
//
void esponidati(void)
{
  // esposizione dei dati provenienti dal timer di arduino
  lcd2.clear();
  lcd2.setCursor(0, 0);
  lcd2.print("   ");
  lcd2.print(day());
  lcd2.print(' ');
  mese = month();                        // mememorizza il mese
  mese = mese - 1;                       // diminuisce di 1 il valore del mese poiche'
  //                                        la descrizione del primo mese (gen) inizia
  //                                        all'indirizzo zero della tabella mesi
  lcd2.print (tabmesi [(mese * 3)]);      // espone la prima lettera del mese
  lcd2.print (tabmesi [(mese * 3 + 1)]);  // espone la seconda lettera del mese
  lcd2.print (tabmesi [(mese * 3 + 2)]);  // espone la terza lettera del mese
  lcd2.print(' ');
  lcd2.print(year());
  lcd2.setCursor(4, 1);
  lcd2.print(hour());
  digits = (minute());
  printDigits();                         // routine esposizione zeri non significativi
  digits = (second());
  printDigits();                         // routine esposizione zeri non significativi
}
//
//****routine visulazzazione minuti e secondi comprensivi di zeri non significativi********
//
void printDigits()
{
  lcd2.print(':');
  if (digits < 10)
    lcd2.print('0');
  lcd2.print(digits);
}
//
// *************** inizio delle routine necesarie al settaggio dell'orologio ********
//
//
//******** routine di sincronizzazione del timer di arduino con il timer del ds3231
//
void sincronizzarduino ()
{
  lcd2.clear ();
  lcd2.setCursor(0, 0);       // posiziona il cursore all'inizio della prima riga
  setSyncProvider(RTC.get);  // sincronizza il timer di Arduino con i dati presenti
  //                            sul modulo RTC
  lcd2. clear ();
  if (timeStatus() != timeSet)  // verifica se la sincronizzazione e' andata  a  buon fine
    lcd2.print(" orologio non");
  else
    lcd2.print("   orologio");
  lcd2.setCursor (0, 1);
  lcd2.print  (" sincronizzato");
  delay (1500);
}
//
//******** routine di settaggio dell'orologio ******************
//
void acquisiscidati ()
{
  lcd2.clear ();
  // inserisce in tabdati i valori provenienti dal timer di arduino
  // al fine di usarli come valori iniziali per il settaggio
  tabdati [2] = year();
  tabdati [2] = tabdati [2] - 2000;
  tabdati [5] = month ();
  tabdati [8] = day ();
  tabdati [11] = hour ();
  tabdati [14] = minute ();
  tabdati [17] = second ();
  //
  // scorre tabdati e consente il settaggio dei vari parametri
  for (indiceset = 0; indiceset < 6; indiceset = indiceset)
  {
    esponitabdati ();
    setta = 0;
    su    = 0;
    giu   = 0;
    incremento = 0;
    setta = digitalRead (Pmenu);
    su    = digitalRead (Psu);
    giu   = digitalRead (Pgiu);
    if ((setta == 1) || (su == 1) || (giu == 1))
      delay (500);   // attende 5 decimi di secondo per evitare di interpretare una doppia pressione
    if (setta == 1)
      indiceset ++;
    if (su == 1)
      incremento = 1;
    if (giu == 1)
      incremento = -1;
    //
    // modifica il parametro corrente di tabadati con il valore presente in  "incremento" e verifica
    // che il nuovo valore in tabdati non ecceda i limiti
    tabdati [(indiceset * 3) + 2] = tabdati [(indiceset * 3) + 2] + incremento;
    if (tabdati [(indiceset * 3) + 2] > tabdati [(indiceset * 3) + 1])
      tabdati [(indiceset * 3) + 2] = tabdati [(indiceset * 3) + 1];
    if ( tabdati [(indiceset * 3) + 2] < tabdati [(indiceset * 3) ] )
      tabdati [(indiceset * 3) + 2] = tabdati [(indiceset * 3)];
  }
  //  inserisce in ds3231 i nuovi dati
  tm.Year = y2kYearToTm(tabdati [2]);
  tm.Month  = tabdati [5];
  tm.Day    = tabdati [8];
  tm.Hour   = tabdati [11];
  tm.Minute = tabdati [14];
  tm.Second = tabdati [17];
  t         = makeTime(tm);
  RTC.set(t);           // aggiorna (setta) il modulo RTC
  setTime(t);           // aggiorna (setta) il modulo RTC
  indiceset = 0;        //  azzera l'indice di tabdati e riprende le normali funzioni dell'orologio
}
//
//****** routine di esposizione dei dati in via di settaggio ****
//
void esponitabdati ()
{
  tempocorrente = millis ();
  if ((tempocorrente - tempoprec) > 500)  // espone solo se sono passati piu' di 5 decimi di secondo dall'ultima visualizzazione
  {
    tempoprec = tempocorrente;
    riga = 0;
    lcd2.setCursor (6, 0);
    lcd2.print ("/");
    lcd2.setCursor (9, 0);
    lcd2.print ("/");
    lcd2.setCursor (6, 1);
    lcd2.print (":");
    lcd2.setCursor (9, 1);
    lcd2.print (":");
    for (indicedati = 0; indicedati < 6; indicedati++)
    { // espone i parametri presenti in tabdati
      if (indicedati > 2)
        riga = 1;
      datodaesporre = tabdati [(indicedati * 3) + 2];
      lcd2.setCursor (((indicedati - riga * 3) * 3) + 4, riga);
      if (datodaesporre < 10)
        lcd2.print ("0");
      lcd2.print (datodaesporre);
    }
    riga = 0;
    if (indiceset > 2)
      riga = 1;
    if (intermittenza == 1)  // gestisce il blinking del parametro corrente
    {
      intermittenza = 0;
      lcd2.setCursor (((indiceset - riga * 3) * 3) + 4, riga);
      lcd2.print ("00");
    }
    else
    {
      intermittenza = 1;
      datodaesporre = tabdati [(indiceset * 3) + 2];
      lcd2.setCursor (((indiceset - riga * 3) * 3) + 4, riga);
      if (datodaesporre < 10)
        lcd2.print ("0");
      lcd2.print (datodaesporre);
    }
  }
}
//
// *************** fine delle routine necessarie al settaggio dell'orologio ******


void setup(void) 
{ 
  //gestione monitor
  lcd1.init();//inizializza comunicazione schermo 1
  lcd1.backlight();//sfondo
  lcd2.init();//inizializza comunicazione schermo 2
  lcd2.backlight(); //sfondo
  pinMode(LED_PIN_M1, OUTPUT);
  analogWrite(LED_PIN_M1, 200); //luminosità M1
  pinMode(LED_PIN_M2, OUTPUT);
  analogWrite(LED_PIN_M2, 200); //luminosità M2
  pinMode (PM1,INPUT);
  pinMode (PM2,INPUT);

  //orologio
   sincronizzarduino ();  // sincronizza il timer di arduino con i dati forniti da ds3231

  //pulsanti luci stanze
  pinMode (PS1,INPUT);//luce bianca S1
  pinMode (PS2,INPUT); //luce bianca S2
  

  //pulsanti vari
  pinMode (Psan,INPUT); //sanificatore
  pinMode (Pgiu,INPUT); // giu orologio
  pinMode (Psu,INPUT); //su orologio
  pinMode (Pmenu,INPUT);  //menu orologio
  
  //output rele dx
  pinMode (s2Lb,OUTPUT);
  pinMode (s2Lg,OUTPUT);
  pinMode (s2Lr,OUTPUT);
  pinMode (s1Lb,OUTPUT);
  pinMode (s1Lg,OUTPUT);
  pinMode (s1Lr,OUTPUT);
  pinMode (LUV,OUTPUT);
  
  //output rele sx
  pinMode (pompaB ,OUTPUT);
  pinMode (pompaR,OUTPUT);
  pinMode (VenP,OUTPUT);
  pinMode (VenC,OUTPUT);
  pinMode (Rsan,OUTPUT);
  
  //gestione PPM
  ccs1.begin(0x5A); //inizzializza e da indirizzo I2c di default
  ccs2.begin(0x5B); //inizzializza e da indirizzo I2c alternativo
  
  //iniziano a lavorare i sensori di temperatura
  dht1.begin();
  dht2.begin();

  //servo
  servodx.attach ( 37);
  servosx.attach ( 39);
  servocx.attach ( 38);

  //leggo temperatura ambiente 
   temp_A = dht1.readTemperature();
  
}

void loop(void) 
{
  
   servodx.write(180);
  //leggo sensori 
  //leggo temperatura
  temp_s1 = dht1.readTemperature();
  temp_s2 = dht2.readTemperature();
  //leggo umidita
  um_s1 = dht1.readHumidity();
  um_s2 = dht2.readHumidity();
  //leggo PPM
 PPM1 =ccs1.geteCO2();
 PPM2 =ccs1.geteCO2();

      if (digitalRead(PS1) == 1 and  digitalRead(PS2) == 1, digitalRead(PS1) == 1 or  digitalRead(PS2) == 1)
        {
        digitalWrite (VenP, HIGH);//accendo ventole
        digitalWrite (LUV, HIGH);//accendi led UV
        
        //muovo servo scambio aria in base alla media dei PPM percepiti
        mediaPPM = ((PPM1+PPM2)/2);
        mediaPPM = map(mediaPPM, 500, 1500, 0, 89);
        servocx.write(mediaPPM);

           //stanza 1
           if (digitalRead(PS1 == 1))
           {
          
            //servo sx
            PPM1 = map(PPM1, 500, 1500, 0, 89);
            servosx.write(PPM1);

            //condizionamento aria S1
            if ( temp_s1 > temp_A )   
            {
              digitalWrite (pompaB, HIGH);
              digitalWrite (VenC, HIGH);

              //luce blu
              digitalWrite (s1Lb, HIGH);
              digitalWrite (s1Lg, LOW);
              digitalWrite (s1Lr, LOW);
            }
            
            if ( temp_s1 < temp_A )
            {
              digitalWrite (pompaR, HIGH);
              digitalWrite (VenC, HIGH);

               //luce blu
              digitalWrite (s1Lb, LOW);
              digitalWrite (s1Lg, LOW);
              digitalWrite (s1Lr, HIGH);
            }
            
            if ( temp_s1 = temp_A )
            {
              digitalWrite (pompaR, LOW);
              digitalWrite (pompaB, LOW);
              digitalWrite (VenC, LOW);

              //luce bianca
              digitalWrite (s1Lb, HIGH);
              digitalWrite (s1Lg, HIGH);
              digitalWrite (s1Lr, HIGH);
            }
            
           }

           //stanza 2
            if (digitalRead(PS2 == 1))
           {
           
            //servo dx
            PPM2 = map(PPM2, 500, 1500, 0, 89);
            servodx.write(PPM2);

            //condizionamento aria S1
            if ( temp_s2 > temp_A )   
            {
              digitalWrite (pompaB, HIGH);
              digitalWrite (VenC, HIGH);

              //luce blu
              digitalWrite (s2Lb, HIGH);
              digitalWrite (s2Lg, LOW);
              digitalWrite (s2Lr, LOW);
            }
            
            if ( temp_s2 < temp_A )
            {
              digitalWrite (pompaR, HIGH);
              digitalWrite (VenC, HIGH);

              //luce rossa
              digitalWrite (s2Lb, LOW);
              digitalWrite (s2Lg, LOW);
              digitalWrite (s2Lr, HIGH);
            }
            
            if ( temp_s2 = temp_A )
            {
              digitalWrite (pompaR, LOW);
              digitalWrite (pompaB, LOW);
              digitalWrite (VenC, LOW);
              
              //luce bianca
              digitalWrite (s2Lb, HIGH);
              digitalWrite (s2Lg, HIGH);
              digitalWrite (s2Lr, HIGH);
            }
            
           }
        }
        else
        { 
          digitalWrite (LUV, LOW);//spengoled UV
          digitalWrite (VenP, LOW);//spengo ventole
          digitalWrite (pompaR, LOW);
          digitalWrite (pompaB, LOW);
          digitalWrite (VenC, LOW);
          //stanza 1
          digitalWrite (s1Lb, LOW);
          digitalWrite (s1Lg, LOW);
          digitalWrite (s1Lr, LOW);
          //stanza 2
          digitalWrite (s2Lb, LOW);
          digitalWrite (s2Lg, LOW);
          digitalWrite (s2Lr, LOW);
        }

        //sanificatore
        if (ore==23 and minuti ==00 and secondi == 00 and digitalRead(PS1) == 0 and  digitalRead(PS2) == 0 )
        {
          servodx.write(0);
          servosx.write(0);
          servocx.write(90);
          digitalWrite (VenP, HIGH);//accendo ventole
          digitalWrite (LUV, HIGH);//accendi led UV
           unsigned long currentMillis4 = millis(); //memorizza stato attualle
           if (currentMillis4 - previousMillis4>= interval3) 
           {
           unsigned long currentMillis3 = millis(); //memorizza stato attualle
           if (currentMillis3 - previousMillis3>= interval3) 
           {
           digitalWrite (Rsan, HIGH);
           //led verde
           digitalWrite (s2Lg, HIGH);
           digitalWrite (s1Lg, HIGH);
           previousMillis3 = currentMillis3; 
           }
           digitalWrite (Rsan, LOW); //spegne sanificatore dopo 2 secondi 
           previousMillis4 = currentMillis4;
           }
           //spegne led verde dopo 10 secondi
           digitalWrite (s2Lg, LOW); 
           digitalWrite (s1Lg, LOW);
        }
        if (digitalRead (Psan) == 1 and digitalRead(PS1) == 0 and  digitalRead(PS2) == 0)
        {
          digitalWrite (VenP, HIGH);//accendo ventole
          digitalWrite (LUV, HIGH);//accendi led UV
          servodx.write(0);
          servosx.write(0);
          servocx.write(90);
          unsigned long currentMillis4 = millis(); //memorizza stato attualle
           if (currentMillis4 - previousMillis4>= interval3) 
           {
           unsigned long currentMillis3 = millis(); //memorizza stato attualle
           if (currentMillis3 - previousMillis3>= interval3) 
           {
           digitalWrite (Rsan, HIGH);
           //led verde
           digitalWrite (s2Lg, HIGH);
           digitalWrite (s1Lg, HIGH);
           previousMillis3 = currentMillis3;
           }
           digitalWrite (Rsan, LOW);//spegne sanificatore dopo 2 secondi
           previousMillis4 = currentMillis4;
           }
           //spegne led verde dopo 10 secondi
           digitalWrite (s2Lg, LOW);
           digitalWrite (s1Lg, LOW);
        }
        
        if (digitalRead (Psan) == 0 and digitalRead(PS1) == 0 and  digitalRead(PS2) == 0 and ore !=23 and minuti !=00 and secondi != 00)   
        {
            digitalWrite (VenP, LOW);//spegni ventole
            digitalWrite (LUV, LOW);//spegni led UV
            digitalWrite (Rsan, LOW); //spegni sanificatore 
            servodx.write(90);
            servosx.write(90);
            servocx.write(0);
        }
        
        //Stampa M1
     if ( digitalRead (PM1)==0)  //stampa sala riunioni
     {
     unsigned long currentMillis = millis(); //memorizza stato attualle
       if (currentMillis - previousMillis >= interval) 
       {
       lcd1.clear();//pulisce
       lcd1.setCursor(4, 0);//cursore MR
       lcd1.print(SL1);
       lcd1.setCursor(0, 1);
       lcd1.print(AQ);
       lcd1.setCursor(12, 1);
       lcd1.print(PPM1);
       lcd1.setCursor(17, 1);
       lcd1.print(ppm);
       lcd1.setCursor(0, 2);
       lcd1.print(TP);
       lcd1.setCursor(13, 2);
       lcd1.print(temp_s1);
       lcd1.setCursor(16, 2);
       lcd1.print((char)223);//stampa gradi
       lcd1.setCursor(17, 2);
       lcd1.print(gradi);
       lcd1.setCursor(0, 3);
       lcd1.print(UM);
       lcd1.setCursor(10, 3);
       lcd1.print(um_s1);
       lcd1.setCursor(13, 3);
       lcd1.print(RH);
       previousMillis = currentMillis;
       }
     }
     else //stampa ufficio
     {
     unsigned long currentMillis = millis(); //memorizza stato attualle
       if (currentMillis - previousMillis >= interval) 
       {
       lcd1.clear();//pulisce
       lcd1.setCursor(7, 0);//cursore MR
       lcd1.print(SL2);
       lcd1.setCursor(0, 1);
       lcd1.print(AQ);
       lcd1.setCursor(12, 1);
       lcd1.print(PPM2);
       lcd1.setCursor(17, 1);
       lcd1.print(ppm);
       lcd1.setCursor(0, 2);
       lcd1.print(TP);
       lcd1.setCursor(13, 2);
       lcd1.print(temp_s2);
       lcd1.setCursor(16, 2);
       lcd1.print((char)223);//stampa gradi
       lcd1.setCursor(17, 2);
       lcd1.print(gradi);
       lcd1.setCursor(0, 3);
       lcd1.print(UM);
       lcd1.setCursor(10, 3);
       lcd1.print(um_s2);
       lcd1.setCursor(13, 3);
       lcd1.print(RH);
       previousMillis = currentMillis;
       }
     }
      
//Stampa M2
      
     if ( digitalRead (PM2)==1)  //stampa sala riunioni e ufficio
     {
     unsigned long currentMillis2 = millis(); //memorizza stato attualle
       if (currentMillis2 - previousMillis2 >= interval2) 
       {
        
       lcd2.clear();//pulisce
       lcd2.setCursor(0, 0);
       lcd2.print(riga1);
       lcd2.setCursor(9, 1);
       lcd2.print(stang);
       lcd2.setCursor(0, 2);
       lcd2.print(riga3);
       lcd2.setCursor(9, 2);
       lcd2.print(stang);
       lcd2.setCursor(17, 2);
       lcd2.print(riga3p);
       lcd2.setCursor(9, 3);
       lcd2.print(stang);
  
       previousMillis2 = currentMillis2;
       } 
  
      }
    
      else // data ora
      {
      unsigned long currentMillis2 = millis(); //memorizza stato attualle
        if (currentMillis2 - previousMillis2 >= interval2) 
        {
          // ********** inizio dele istruzioni necessarie al settaggio dell'orologio ********
  indiceset = 0;
  indiceset = digitalRead (Pmenu);
  if (indiceset == 1)    // se e' stato premuto il pulsante di settaggio
  { delay (1000);  // attende un secondo per evitare l'interpretazione di una doppia pressione)
    acquisiscidati ();   // lancia la routine di settaggio
  }
  // ********* fine delle istruzioni di settaggio ***********************************
  //
  tempocorrente = millis();
  if ((tempocorrente - tempoprec ) > 1000)  // se e' passato piu' di un secondo dall'ultima visualizzazione
  {
    tempoprec = tempocorrente;
    esponidati ();
  }
        previousMillis2 = currentMillis2;
        }
      }
        }

This is the watch schedule alone

#include <Wire.h>             //http://arduino.cc/en/Reference/Wire
#include <DS3232RTC.h>        //http://github.com/JChristensen/DS3232RTC
#include <TimeLib.h>          //http://playground.arduino.cc/Code/Time

#include <LiquidCrystal_I2C.h>  // libreria di gestione del display lcd
//                    addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
LiquidCrystal_I2C lcd(0x23, 20, 4);  // tipologia del display
// LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
// ^  indirizzo alternativo, da attivare al posto della precedente istruzione se lcd non funziona
// ^^ Alternative address, to activate in place of previous instruction if LCD doesn't work
//

time_t t;
tmElements_t tm;
//
//****** inizio elenco variabili ed elementi necessari al settaggio dell'orologio digitale  *********************
#define settaggio 10
#define avanti 9
#define indietro 8
int indiceset      = 0;  // indice utilizzato per avviare e gestire la routine di settaggio dei parametri
int setta          = 0;  // valore pulsante settaggio
int su             = 0;  // valore pulsante avanti
int giu            = 0;  // valore pulsante indietro
int incremento     = 0;  // valore utilizzato per aumentare o diminuire il parametro in via di settaggio
int indicedati     = 0;  // indice di scorrimetno della tabella tabdati
int riga           = 0;  // riga del display sulla quale si sta agendo
int datodaesporre  = 0;  // parametro in via di esposizione
long tempoprec     = 0; // zona di memorizzazione del momento dell'ultima esposizione dei dati
long tempocorrente = 0; // zona di memorizzazione del momento corrente
int intermittenza  = 0; // semaforo di intermittenza (0 espone il parametro, 1 non espone il parametro)
int tabdati [21]   // tabella di acquisizione dei parametri
{ // min   max  valore
  10,     99,      0,   // anno
  1,      12,      0,   // mese
  1,      31,      0,   // giorno
  0,      23,      0,   // ora
  0,      59,      0,   // minuto
  0,      59,      0,   // secondo
  0,      0,       0,   // dummy
};
// ************* fine delle variabili e degli elementi necessari al settaggio dell'orologio ***********
//
int digits         = 0;    // zona di memorizzazione dei minuti e dei secondi da esporre
//                           sul display lcd
char tabmesi [37]  =  "genfebmaraprmaggiulugagosetottnovdic";  // tabella descr. mesi
int mese           = 0;    // zona di memorizzazione del mese corrente
int lavoro         = 0;    // zona di lavoro, utilizzata per calcoli intermedi



//
//********* routine di esposizione di data, ora e temperatura sul display lcd
//

  void esponidati(void)
  {
    // esposizione dei dati provenienti dal timer di arduino
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("   ");
    lcd.print(day());
    lcd.print(' ');
    mese = month();                        // mememorizza il mese
    mese = mese - 1;                       // diminuisce di 1 il valore del mese poiche'
    //                                        la descrizione del primo mese (gen) inizia
    //                                        all'indirizzo zero della tabella mesi
    lcd.print (tabmesi [(mese * 3)]);      // espone la prima lettera del mese
    lcd.print (tabmesi [(mese * 3 + 1)]);  // espone la seconda lettera del mese
    lcd.print (tabmesi [(mese * 3 + 2)]);  // espone la terza lettera del mese
    lcd.print(' ');
    lcd.print(year());
    lcd.setCursor(4, 1);
    lcd.print(hour());
    digits = (minute());
    printDigits();                         // routine esposizione zeri non significativi
    digits = (second());
    printDigits();                         // routine esposizione zeri non significativi
  }

  //
  //****routine visulazzazione minuti e secondi comprensivi di zeri non significativi********
  //

  void printDigits()
  {
    lcd.print(':');
    if (digits < 10)
      lcd.print('0');
    lcd.print(digits);
  }
  //
  // *************** inizio delle routine necesarie al settaggio dell'orologio ********
  //
  //
  //******** routine di sincronizzazione del timer di arduino con il timer del ds3231
  //

 
  void sincronizzarduino ()
  {
    lcd.clear ();
    lcd.setCursor(0, 0);       // posiziona il cursore all'inizio della prima riga
    setSyncProvider(RTC.get);  // sincronizza il timer di Arduino con i dati presenti
    //                            sul modulo RTC
    lcd. clear ();
    if (timeStatus() != timeSet)  // verifica se la sincronizzazione e' andata  a  buon fine
      lcd.print(" orologio non");
    else
      lcd.print("   orologio");
    lcd.setCursor (0, 1);
    lcd.print  (" sincronizzato");
    delay (1500);
  }
  //
  //******** routine di settaggio dell'orologio ******************
  //
  void acquisiscidati ()
  {
    lcd.clear ();
    // inserisce in tabdati i valori provenienti dal timer di arduino
    // al fine di usarli come valori iniziali per il settaggio
    tabdati [2] = year();
    tabdati [2] = tabdati [2] - 2000;
    tabdati [5] = month ();
    tabdati [8] = day ();
    tabdati [11] = hour ();
    tabdati [14] = minute ();
    tabdati [17] = second ();
    //
    // scorre tabdati e consente il settaggio dei vari parametri
    for (indiceset = 0; indiceset < 6; indiceset = indiceset)
    {
      esponitabdati ();
      setta = 0;
      su    = 0;
      giu   = 0;
      incremento = 0;
      setta = digitalRead (settaggio);
      su    = digitalRead (avanti);
      giu   = digitalRead (indietro);
      if ((setta == 1) || (su == 1) || (giu == 1))
        delay (500);   // attende 5 decimi di secondo per evitare di interpretare una doppia pressione
      if (setta == 1)
        indiceset ++;
      if (su == 1)
        incremento = 1;
      if (giu == 1)
        incremento = -1;
      //
      // modifica il parametro corrente di tabadati con il valore presente in  "incremento" e verifica
      // che il nuovo valore in tabdati non ecceda i limiti
      tabdati [(indiceset * 3) + 2] = tabdati [(indiceset * 3) + 2] + incremento;
      if (tabdati [(indiceset * 3) + 2] > tabdati [(indiceset * 3) + 1])
        tabdati [(indiceset * 3) + 2] = tabdati [(indiceset * 3) + 1];
      if ( tabdati [(indiceset * 3) + 2] < tabdati [(indiceset * 3) ] )
        tabdati [(indiceset * 3) + 2] = tabdati [(indiceset * 3)];
    }
    //  inserisce in ds3231 i nuovi dati
    tm.Year = y2kYearToTm(tabdati [2]);
    tm.Month  = tabdati [5];
    tm.Day    = tabdati [8];
    tm.Hour   = tabdati [11];
    tm.Minute = tabdati [14];
    tm.Second = tabdati [17];
    t         = makeTime(tm);
    RTC.set(t);           // aggiorna (setta) il modulo RTC
    setTime(t);           // aggiorna (setta) il modulo RTC
    indiceset = 0;        //  azzera l'indice di tabdati e riprende le normali funzioni dell'orologio
  }

  void esponitabdati ()
  {
    tempocorrente = millis ();
    if ((tempocorrente - tempoprec) > 500)  // espone solo se sono passati piu' di 5 decimi di secondo dall'ultima visualizzazione
    {
      tempoprec = tempocorrente;
      riga = 0;
      lcd.setCursor (6, 0);
      lcd.print ("/");
      lcd.setCursor (9, 0);
      lcd.print ("/");
      lcd.setCursor (6, 1);
      lcd.print (":");
      lcd.setCursor (9, 1);
      lcd.print (":");
      for (indicedati = 0; indicedati < 6; indicedati++)
      { // espone i parametri presenti in tabdati
        if (indicedati > 2)
          riga = 1;
        datodaesporre = tabdati [(indicedati * 3) + 2];
        lcd.setCursor (((indicedati - riga * 3) * 3) + 4, riga);
        if (datodaesporre < 10)
          lcd.print ("0");
        lcd.print (datodaesporre);
      }
      riga = 0;
      if (indiceset > 2)
        riga = 1;
      if (intermittenza == 1)  // gestisce il blinking del parametro corrente
      {
        intermittenza = 0;
        lcd.setCursor (((indiceset - riga * 3) * 3) + 4, riga);
        lcd.print ("00");
      }
      else
      {
        intermittenza = 1;
        datodaesporre = tabdati [(indiceset * 3) + 2];
        lcd.setCursor (((indiceset - riga * 3) * 3) + 4, riga);
        if (datodaesporre < 10)
          lcd.print ("0");
        lcd.print (datodaesporre);
      }
    }
  }



//
// *************** fine delle routine necessarie al settaggio dell'orologio ******
//
//

//
//


void setup (void)
{
  Serial.begin (9600);       // inizializza il monitor seriale
  // ********** le seguenti tre istruzioni sono funzionali al settaggio dell'orologio
  pinMode (settaggio, INPUT);  //istruzione necessaria la settaggio
  pinMode (avanti, INPUT);     // istruzione necessaria al settaggio
  pinMode (indietro, INPUT);   // istruzione necessaria al settaggio
  //
  lcd.begin(16, 2);          // inizializza il display (16 caratteri per due righe) e accende
  lcd.backlight();           // lo sfondo
  lcd.print ("   buongiorno");
  delay (1500);
  sincronizzarduino ();  // sincronizza il timer di arduino con i dati forniti da ds3231
}


  void loop (void)
{
  // ********** inizio dele istruzioni necessarie al settaggio dell'orologio ********
  indiceset = 0;
  indiceset = digitalRead (settaggio);
  if (indiceset == 1)    // se e' stato premuto il pulsante di settaggio
  { delay (1000);  // attende un secondo per evitare l'interpretazione di una doppia pressione)
    acquisiscidati ();   // lancia la routine di settaggio
  }
  // ********* fine delle istruzioni di settaggio ***********************************
  //
  tempocorrente = millis();
  if ((tempocorrente - tempoprec ) > 1000)  // se e' passato piu' di un secondo dall'ultima visualizzazione
  {
    tempoprec = tempocorrente;
    esponidati ();
  }
 }

Also here