Orologio con Arduino senza modulo RTC
Realizziamo un semplice orologio digitale con Arduino Uno e display LCD 16×2 senza utilizzare un modulo Real Time Clock, regolando ore e minuti tramite due pulsanti.
Cosa imparerai
- come contare secondi, minuti e ore con Arduino;
- come usare
millis()senza bloccare il programma; - come regolare ore e minuti con due pulsanti;
- come formattare l’ora nel formato HH:MM:SS;
- come usare sia un LCD I2C sia un LCD 16×2 tradizionale.
Materiale necessario
🧰 Kit Arduino consigliato
Un kit completo è utile per avere breadboard, cavetti, resistenze, pulsanti, display e molti componenti necessari per sperimentare con Arduino.
👉 Guarda il kit Arduino consigliatoLink 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 ArduinoLink di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.
Schema con display LCD 16×2 I2C
Schema con display I2C. L’immagine mantiene una larghezza massima di 734 px.
Schema con display LCD 16×2 tradizionale
Versione con LCD collegato in parallelo.
Pulsanti di regolazione
| Funzione | Pin Arduino |
|---|---|
| Aumenta ore | D8 |
| Aumenta minuti | D9 |
Le resistenze da 10 kΩ mantengono gli ingressi in uno stato definito quando i pulsanti non sono premuti.
Codice Arduino con display I2C
/*
OROLOGIO DIGITALE CON ARDUINO SENZA MODULO RTC
Versione con display LCD 16x2 I2C
Pulsante ore -> D8
Pulsante minuti -> D9
IMPORTANTE:
questo progetto conta il tempo usando millis().
Non sostituisce un vero RTC: spegnendo Arduino l'ora viene persa
e nel lungo periodo può accumulare errore.
*/
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
// Display I2C utilizzato nel progetto
LiquidCrystal_I2C lcd(
0x27,
2, 1, 0,
4, 5, 6, 7,
3, POSITIVE
);
const byte BUTTON_HOURS = 8;
const byte BUTTON_MINUTES = 9;
// Ora iniziale all'accensione
byte ore = 12;
byte minuti = 0;
byte secondi = 0;
// Riferimento per il conteggio dei secondi
unsigned long ultimoSecondo = 0;
// Per rilevare una sola pressione per volta
bool precedenteOre = LOW;
bool precedenteMinuti = LOW;
void setup() {
lcd.begin(16, 2);
lcd.backlight();
pinMode(BUTTON_HOURS, INPUT);
pinMode(BUTTON_MINUTES, INPUT);
aggiornaDisplay();
}
void loop() {
unsigned long adesso = millis();
// Aggiorna il tempo ogni 1000 ms.
// Il while recupera eventuali piccoli ritardi del loop.
while (adesso - ultimoSecondo >= 1000UL) {
ultimoSecondo += 1000UL;
incrementaSecondo();
aggiornaDisplay();
}
// ------------------------------------------------------
// REGOLAZIONE ORE
// ------------------------------------------------------
bool statoOre = digitalRead(BUTTON_HOURS);
if (statoOre == HIGH && precedenteOre == LOW) {
ore++;
if (ore >= 24) {
ore = 0;
}
aggiornaDisplay();
}
precedenteOre = statoOre;
// ------------------------------------------------------
// REGOLAZIONE MINUTI
// ------------------------------------------------------
bool statoMinuti = digitalRead(BUTTON_MINUTES);
if (statoMinuti == HIGH && precedenteMinuti == LOW) {
minuti++;
secondi = 0;
if (minuti >= 60) {
minuti = 0;
ore++;
if (ore >= 24) {
ore = 0;
}
}
aggiornaDisplay();
}
precedenteMinuti = statoMinuti;
}
// Incrementa l'orologio di un secondo
void incrementaSecondo() {
secondi++;
if (secondi >= 60) {
secondi = 0;
minuti++;
}
if (minuti >= 60) {
minuti = 0;
ore++;
}
if (ore >= 24) {
ore = 0;
}
}
// Stampa l'ora nel formato HH:MM:SS
void aggiornaDisplay() {
lcd.setCursor(0, 0);
lcd.print("ORA ");
if (ore < 10) lcd.print('0');
lcd.print(ore);
lcd.print(':');
if (minuti < 10) lcd.print('0');
lcd.print(minuti);
lcd.print(':');
if (secondi < 10) lcd.print('0');
lcd.print(secondi);
lcd.print(" ");
lcd.setCursor(0, 1);
lcd.print("BUONA GIORNATA ");
}
Perché usare millis() invece di delay(1000)
Un orologio software può essere realizzato incrementando una variabile ogni secondo. Usare però un semplice delay(1000) blocca Arduino durante l’attesa e rende meno reattivi i pulsanti.
Con millis() il programma controlla continuamente il tempo trascorso e può nello stesso momento leggere i pulsanti.
Regolare l’orologio
Il pulsante su D8 incrementa le ore. Il pulsante su D9 incrementa i minuti e azzera i secondi, rendendo più semplice sincronizzare il display con un riferimento esterno.
Il codice usa il formato a 24 ore: dopo 23:59:59 si torna a 00:00:00.
Versione con LCD 16×2 tradizionale
Con il display parallelo vengono utilizzati questi pin:
| LCD | Arduino |
|---|---|
| RS | D12 |
| EN | D11 |
| D4 | D5 |
| D5 | D4 |
| D6 | D3 |
| D7 | D2 |
/*
OROLOGIO DIGITALE CON ARDUINO SENZA MODULO RTC
Versione con LCD 16x2 tradizionale
LCD:
RS -> D12
EN -> D11
D4 -> D5
D5 -> D4
D6 -> D3
D7 -> D2
Pulsante ore -> D8
Pulsante minuti -> D9
*/
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
const byte BUTTON_HOURS = 8;
const byte BUTTON_MINUTES = 9;
byte ore = 12;
byte minuti = 0;
byte secondi = 0;
unsigned long ultimoSecondo = 0;
bool precedenteOre = LOW;
bool precedenteMinuti = LOW;
void setup() {
lcd.begin(16, 2);
pinMode(BUTTON_HOURS, INPUT);
pinMode(BUTTON_MINUTES, INPUT);
aggiornaDisplay();
}
void loop() {
unsigned long adesso = millis();
while (adesso - ultimoSecondo >= 1000UL) {
ultimoSecondo += 1000UL;
incrementaSecondo();
aggiornaDisplay();
}
bool statoOre = digitalRead(BUTTON_HOURS);
if (statoOre == HIGH && precedenteOre == LOW) {
ore++;
if (ore >= 24) {
ore = 0;
}
aggiornaDisplay();
}
precedenteOre = statoOre;
bool statoMinuti = digitalRead(BUTTON_MINUTES);
if (statoMinuti == HIGH && precedenteMinuti == LOW) {
minuti++;
secondi = 0;
if (minuti >= 60) {
minuti = 0;
ore++;
if (ore >= 24) {
ore = 0;
}
}
aggiornaDisplay();
}
precedenteMinuti = statoMinuti;
}
void incrementaSecondo() {
secondi++;
if (secondi >= 60) {
secondi = 0;
minuti++;
}
if (minuti >= 60) {
minuti = 0;
ore++;
}
if (ore >= 24) {
ore = 0;
}
}
void aggiornaDisplay() {
lcd.setCursor(0, 0);
lcd.print("ORA ");
if (ore < 10) lcd.print('0');
lcd.print(ore);
lcd.print(':');
if (minuti < 10) lcd.print('0');
lcd.print(minuti);
lcd.print(':');
if (secondi < 10) lcd.print('0');
lcd.print(secondi);
lcd.print(" ");
lcd.setCursor(0, 1);
lcd.print("BUONA GIORNATA ");
}
Libreria LCD I2C
Per la versione I2C è disponibile la libreria utilizzata dal progetto:
⬇️ Scarica newliquidcrystal_1.3.4.zip
Scarica gli sketch
⬇️ Sketch display I2C ⬇️ Sketch display 16×2
Quanto è preciso senza RTC?
Il tempo viene derivato dall’oscillatore che fa funzionare Arduino. È sufficiente per un esperimento, ma non è progettato per mantenere l’ora con la precisione e la stabilità di un RTC dedicato.
Inoltre, al reset o allo spegnimento, le variabili tornano ai valori iniziali e l’orologio deve essere regolato nuovamente.
Debug rapido
- se il display I2C non mostra nulla, verifica indirizzo e libreria;
- se l’ora non aumenta, controlla che lo sketch stia eseguendo il loop normalmente;
- se i pulsanti non rispondono, verifica D8, D9 e le resistenze da 10 kΩ;
- se una singola pressione incrementa più volte, aggiungi un debounce hardware o software;
- se l’orologio perde o guadagna tempo, è un limite del conteggio software e dell’oscillatore;
- con LCD tradizionale verifica i collegamenti D2–D5, D11 e D12.
Varianti del progetto
- aggiungere un terzo pulsante per azzerare i secondi;
- aggiungere modalità 12/24 ore;
- aggiungere una sveglia;
- mostrare data e giorno della settimana con un RTC;
- salvare l’ultima impostazione in EEPROM;
- aggiungere un buzzer allo scoccare dell’ora;
- sostituire il display LCD con un OLED.
Cosa devi ricordare
- Il progetto non utilizza un modulo RTC.
- Il tempo viene contato via software con
millis(). - D8 regola le ore e D9 i minuti.
- Sono disponibili versione LCD I2C e LCD tradizionale.
- Dopo uno spegnimento l’ora deve essere impostata nuovamente.
- Per maggiore precisione e memoria dell’ora serve un RTC dedicato.
Domande frequenti
L’orologio continua a funzionare se spengo Arduino?
No. Senza un RTC con alimentazione di backup, allo spegnimento il conteggio si interrompe e alla riaccensione l’ora riparte dai valori definiti nel programma.
Posso renderlo preciso come un normale orologio?
Per un uso realmente preciso conviene aggiungere un modulo RTC. Il conteggio software è adatto soprattutto a fini didattici.
Posso usare solo il display I2C?
Sì. La versione I2C richiede meno pin ed è generalmente più semplice da cablare.
Posso aggiungere una sveglia?
Sì. Puoi confrontare ore e minuti con un orario impostato e attivare un buzzer quando i valori coincidono.

