🕒 Arduino • RTC DS3231 • LCD I2C

Orologio con Arduino, RTC DS3231 e Display LCD 16×2

Visualizziamo ora e data su un display LCD 16×2 I2C usando il preciso modulo RTC DS3231 e due pulsanti per modificare direttamente ore, minuti, giorno, mese e anno.

DifficoltàIntermedia
Tempo30–40 minuti
Cosa impariRTC, I2C e regolazione data
In poche parole: il DS3231 mantiene ora e data anche quando Arduino è spento grazie alla batteria tampone. Arduino legge i registri dell’RTC tramite I2C e mostra le informazioni sul display; due pulsanti permettono di modificare i valori senza dover ricompilare lo sketch.

Il modulo RTC DS3231

Il DS3231 è un Real Time Clock utilizzato per mantenere data e ora indipendentemente dall’alimentazione di Arduino. La batteria CR2032 consente al modulo di continuare a contare il tempo quando il circuito principale viene spento.

Modulo RTC DS3231 per Arduino

Modulo RTC DS3231 con batteria tampone.

Bus I2C condiviso

Il DS3231 e il display LCD utilizzano entrambi il bus I2C. Su Arduino Uno i segnali SDA e SCL corrispondono rispettivamente ad A4 e A5, quindi i due dispositivi possono condividere le stesse linee di comunicazione.

SegnaleArduino Uno
SDAA4
SCLA5
Pulsante selezione parametroD8
Pulsante incrementoD9

Cosa imparerai

  • come utilizzare un RTC DS3231 con Arduino;
  • come condividere il bus I2C tra RTC e display;
  • come leggere ora e data direttamente dai registri del DS3231;
  • come convertire valori BCD in decimale e viceversa;
  • come modificare data e ora con due pulsanti;
  • come mostrare un orologio e un calendario su LCD 16×2.

Materiale necessario

🔌 Arduino Uno
🕒 Modulo RTC DS3231
🖥️ Display LCD 16×2 I2C
🔘 2 pulsanti microswitch
Ω 2 resistenze da 10 kΩ
🔗 Cavetti di collegamento
🧩 Breadboard

🧰 Kit Arduino consigliato

Un kit completo è utile per avere breadboard, cavetti, resistenze, pulsanti e molti componenti di base per sperimentare con Arduino.

👉 Guarda il kit Arduino consigliato

Link di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.

📘 Vuoi imparare Arduino passo dopo passo?

Se vuoi approfondire e realizzare progetti più completi, puoi dare un’occhiata anche ai miei libri dedicati ad Arduino. All’interno troverai spiegazioni semplici, schemi chiari e molti progetti pratici pensati per chi parte da zero.

👉 Scopri i miei libri su Arduino

Link di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.

Schema di collegamento

Schema Arduino RTC DS3231 LCD 16x2 I2C

Schema con Arduino Uno, DS3231, LCD I2C e due pulsanti.

Funzione dei due pulsanti

Il pulsante collegato a D8 seleziona progressivamente il parametro da modificare: ora, minuti, giorno, mese e anno. Il pulsante su D9 incrementa invece il valore attualmente selezionato.

Esempio: premi D8 per entrare nella regolazione dell’ora, usa D9 per incrementarla, quindi premi ancora D8 per passare ai minuti e così via.

Libreria necessaria

Il display LCD utilizza NewLiquidCrystal 1.3.5. Il DS3231 viene invece gestito direttamente tramite la libreria Wire, senza una libreria RTC dedicata.

⬇️ Scarica newliquidcrystal_1.3.5.zip

Codice Arduino commentato

Arduino + DS3231 + LCD I2C
/*
  OROLOGIO E CALENDARIO CON ARDUINO UNO + RTC DS3231 + LCD 16x2 I2C

  Funzioni:
  - mostra ora e data sul display LCD;
  - legge direttamente i registri del DS3231 tramite Wire;
  - usa due pulsanti per modificare ora, minuti, giorno, mese e anno;
  - il pulsante su D8 seleziona il parametro;
  - il pulsante su D9 incrementa il valore selezionato.

  Collegamenti principali:
  DS3231 SDA -> A4 su Arduino Uno
  DS3231 SCL -> A5 su Arduino Uno
  LCD I2C SDA -> A4
  LCD I2C SCL -> A5
  Pulsante selezione -> D8
  Pulsante incremento -> D9

  Il DS3231 e il display condividono lo stesso bus I2C.
*/

/**************** Arduino RTC e Data su Display I2C 16x02********************/ 

/* utilizzando il modulo DS3231 con due pulsanti per regolare la data e l'ora*/
/*
24/08/2018
tutto il materiale 
disponibile sul sito  
https://progettiarduino.com
*/ 
// includiamo la libreria del display I2C 16x2
#include <LiquidCrystal_I2C.h>
// includiamo la libreria wire (necessaria per il protocollo I2C)
#include <Wire.h>
 
// LCD module connections (RS, E, D4, D5, D6, D7)
//connessione modulo  addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);  // indirizzo LCD I2C
 
void setup() {
  pinMode(8, INPUT_PULLUP);                      // pulsante1 connesso al pin 8
  pinMode(9, INPUT_PULLUP);                      // pulsante2 connesso al pin 9
  // settaggio numero colonne e righe LCD 
  lcd.begin(16, 2);
  Wire.begin();                                  // Inizializzazzione bus I2C
}
 
char Time[]     = "ORA:   :  :  ";
char Calendar[] = "DATA:  /  /20  ";
byte i, second, minute, hour, date, month, year;
 
void DS3231_display(){
  // Converto BCD in decimale
  second = (second >> 4) * 10 + (second & 0x0F);
  minute = (minute >> 4) * 10 + (minute & 0x0F);
  hour   = (hour >> 4)   * 10 + (hour & 0x0F);
  date   = (date >> 4)   * 10 + (date & 0x0F);
  month  = (month >> 4)  * 10 + (month & 0x0F);
  year   = (year >> 4)   * 10 + (year & 0x0F);
  // Fine conversione
  Time[12]     = second % 10 + 48;
  Time[11]     = second / 10 + 48;
  Time[9]      = minute % 10 + 48;
  Time[8]      = minute / 10 + 48;
  Time[6]      = hour   % 10 + 48;
  Time[5]      = hour   / 10 + 48;
  Calendar[14] = year   % 10 + 48;
  Calendar[13] = year   / 10 + 48;
  Calendar[9]  = month  % 10 + 48;
  Calendar[8]  = month  / 10 + 48;
  Calendar[6]  = date   % 10 + 48;
  Calendar[5]  = date   / 10 + 48;
  lcd.setCursor(0, 0);
  lcd.print(Time);                               // Scrivi sul display l'ora
  lcd.setCursor(0, 1);
  lcd.print(Calendar);                           // Scrivi sul display la data
}
void blink_parameter(){
  byte j = 0;
  while(j < 10 && digitalRead(8) && digitalRead(9)){
    j++;
    delay(25);
  }
}
byte edit(byte x, byte y, byte parameter){
  char text[3];
  while(!digitalRead(8));                        // Aspetta fin quando il (pin #8) è rilasciato
  while(true){
    while(!digitalRead(9)){                      // Se il pulsante (pin #9) è premuto
      parameter++;
      if(i == 0 && parameter > 23)               // Se l'ora > 23 ==> ora = 0
        parameter = 0;
      if(i == 1 && parameter > 59)               // Se i minuti > 59 ==> minuti = 0
        parameter = 0;
      if(i == 2 && parameter > 31)               // Se la data > 31 ==> data = 1
        parameter = 1;
      if(i == 3 && parameter > 12)               // Se il mese > 12 ==> mese = 1
        parameter = 1;
      if(i == 4 && parameter > 99)               // Se l'anno > 99 ==> anno = 0
        parameter = 0;
      sprintf(text,"%02u", parameter);
      lcd.setCursor(x, y);
      lcd.print(text);
      delay(200);                                // Attendi 200ms
    }
    lcd.setCursor(x, y);
    lcd.print("  ");                             // Inserisci due spazi
    blink_parameter();
    sprintf(text,"%02u", parameter);
    lcd.setCursor(x, y);
    lcd.print(text);
    blink_parameter();
    if(!digitalRead(8)){                         // Se il pulsante sul (pin #8) è premuto
      i++;                                       // Incrementa 'i' di un parametro
      return parameter;                          // Restituisce il valore del parametro e esce
    }
  }
}
 
void loop() {
  if(!digitalRead(8)){                           // Se il pulsante1 (pin #8) è premuto
      i = 0;
      hour   = edit(5, 0, hour);
      minute = edit(8, 0, minute);
      date   = edit(5, 1, date);
      month  = edit(8, 1, month);
      year   = edit(13, 1, year);
      // Converti da decimal in BCD
      minute = ((minute / 10) << 4) + (minute % 10);
      hour = ((hour / 10) << 4) + (hour % 10);
      date = ((date / 10) << 4) + (date % 10);
      month = ((month / 10) << 4) + (month % 10);
      year = ((year / 10) << 4) + (year % 10);
      // Fine conversione
      // Scrivi data sul modulo DS3231 RTC
      Wire.beginTransmission(0x68);               // Inizia il protocollo I2C sul'indirizzo del DS3231 
      Wire.write(0);                              // Invia registrazione indirizzo
      Wire.write(0);                              // Reimposta e avvia l'oscillatore
      Wire.write(minute);                         // Scrivi i minuti
      Wire.write(hour);                           // Scrivi l'ora
      Wire.write(1);                              // Scrivi giorno (non usato)
      Wire.write(date);                           // Scrivi data
      Wire.write(month);                          // Scrivi mese
      Wire.write(year);                           // Scrivi anno
      Wire.endTransmission();                     // Interrompere la trasmissione e rilasciare il bus I2C
      delay(200);                                 // Attendi 200ms
    }
    Wire.beginTransmission(0x68);                 // Inizia il protocollo I2C sul'indirizzo del DS3231 
    Wire.write(0);                                // Invia registrazione indirizzo
    Wire.endTransmission(false);                  // I2C restart
    Wire.requestFrom(0x68, 7);                    // Richiedi 7 byte da DS3231 e rilascia il bus I2C alla fine della lettura
    second = Wire.read();                         // Leggi i secondi dal registro 0
    minute = Wire.read();                         // Leggi i minuti dal registro 1
    hour   = Wire.read();                         // Leggi ora dal registro 2
    Wire.read();                                  // Leggi il giorno dal registro 3 (non utilizzato)
    date   = Wire.read();                         // Leggi la data dal registro 4
    month  = Wire.read();                         // Leggi il mese dal registro 5
    year   = Wire.read();                         // Leggi l'anno dal registro 6
    DS3231_display();                             // Visualizza ora e calendario
    delay(50);                                    // Aspetta 50ms
}

Come funziona lo sketch

1. Lettura dei registri del DS3231

Arduino interroga direttamente l’indirizzo I2C 0x68 del DS3231 e legge sette byte contenenti secondi, minuti, ore, giorno della settimana, data, mese e anno.

2. Conversione BCD

Il DS3231 memorizza molti valori temporali in formato BCD. La funzione dedicata converte questi dati in numeri decimali più semplici da visualizzare e modificare.

3. Visualizzazione su LCD

La prima riga del display mostra l’ora, mentre la seconda presenta la data nel formato giorno/mese/anno.

4. Modalità modifica

Quando viene premuto il pulsante su D8, il programma entra nella sequenza di modifica. Il parametro selezionato lampeggia e D9 ne incrementa il valore.

5. Scrittura nel DS3231

Al termine della regolazione i nuovi valori vengono riconvertiti in BCD e riscritti nei registri dell’RTC tramite il bus I2C.

Indirizzi I2C

Il DS3231 utilizza l’indirizzo 0x68. Nell’esempio il display LCD è configurato all’indirizzo 0x3F. Poiché i due dispositivi hanno indirizzi diversi, possono convivere sullo stesso bus SDA/SCL.

Se il display non mostra nulla: alcuni adattatori LCD I2C utilizzano un indirizzo differente, spesso 0x27. In quel caso va modificata l’inizializzazione del display nel codice.

Scarica lo sketch

⬇️ Scarica arduino_rtc_ds3231___display_i2c.ino

Debug rapido

  • se l’ora non avanza, controlla batteria e alimentazione del DS3231;
  • se il display è vuoto, verifica l’indirizzo I2C;
  • se nessuno dei due dispositivi risponde, controlla SDA su A4 e SCL su A5;
  • se i pulsanti non funzionano, verifica D8 e D9;
  • se la data si azzera quando togli alimentazione, controlla la batteria tampone;
  • non invertire SDA e SCL.

Varianti del progetto

  • mostrare anche la temperatura rilevata dal DS3231;
  • aggiungere un allarme programmabile;
  • salvare eventi su microSD con data e ora;
  • aggiungere un buzzer per sveglia o timer;
  • usare un display OLED;
  • aggiungere il giorno della settimana;
  • integrare l’RTC in un datalogger.

Cosa devi ricordare

  • Il DS3231 mantiene data e ora grazie alla batteria tampone.
  • RTC e LCD condividono il bus I2C.
  • Su Arduino Uno SDA è A4 e SCL è A5.
  • D8 seleziona il parametro da modificare.
  • D9 incrementa il parametro selezionato.
  • Il DS3231 usa l’indirizzo I2C 0x68.
  • Lo sketch legge e scrive direttamente i registri dell’RTC.

Domande frequenti

Il DS3231 perde l’ora quando Arduino viene spento?

No, se la batteria tampone è presente e funzionante il modulo continua a mantenere l’orario.

RTC e display possono usare gli stessi pin SDA e SCL?

Sì. I2C è un bus condiviso e permette di collegare più dispositivi sulle stesse linee purché abbiano indirizzi differenti.

Serve una libreria specifica per il DS3231?

Non in questo progetto. Lo sketch utilizza direttamente Wire per leggere e scrivere i registri del modulo.

Posso cambiare ora e data senza collegare Arduino al PC?

Sì. I due pulsanti permettono di modificare i parametri direttamente dal circuito.