Real-Time-Clock DS3231 con ESP32

In questo tutorial imparerai come utilizzare un modulo DS3231 Real Time Clock (RTC) con un ESP32.

Un modulo RTC è un orologio esterno che tiene traccia dell’ora e della data correnti. Funziona indipendentemente dall’alimentazione principale del sistema, permettendo di mantenere un tempo preciso anche quando l’alimentazione è spenta.

Ti mostrerò come usare un RTC in combinazione con l’ESP32 in deep-sleep, come regolare l’RTC per l’ora legale e come sincronizzare l’RTC con un server orario internet.

Componenti necessari

Per questo progetto ti serviranno un modulo DS3231 RTC e un ESP32. Io uso l’ESP32 lite come microprocessore, poiché ha un’interfaccia di ricarica batteria che permette di alimentare ESP32 e RTC con una batteria LiPo. Tuttavia, qualsiasi altro ESP32 o ESP8266 funzionerà altrettanto bene. Per visualizzare l’ora, ho scelto un OLED ma potresti anche optare per un LCD display.

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Nozioni di base sul chip DS3231

Il DS3231 è un piccolo chip (38 x 22 x 14mm) con un orologio in tempo reale (RTC) ad alta precisione e un oscillatore a cristallo compensato in temperatura integrato. Questo chip include un alloggiamento per batteria, che gli permette di funzionare anche quando l’alimentazione principale è scollegata.

L’RTC tiene traccia di secondi, minuti, ore, giorno della settimana, data, mese e anno. Per i mesi con meno di 31 giorni, la data viene regolata automaticamente, comprese le correzioni per gli anni bisestili. L’orologio può funzionare in formato 24 ore o 12 ore. Fornisce due allarmi calendario programmabili e un’uscita a onda quadra programmabile. La comunicazione avviene tramite bus I2C.

Un riferimento di tensione di precisione compensato in temperatura e un circuito comparatore monitorano lo stato di VCC, rilevano interruzioni di alimentazione, forniscono un’uscita di reset e commutano automaticamente all’alimentazione di backup quando necessario. Il dispositivo integra un sensore di temperatura digitale accessibile tramite l’interfaccia I2C.

La sezione seguente elenca le principali caratteristiche del DS3231 (source):

Specifiche tecniche

Tensione di funzionamento: 3.3–5.5V
Chip orologio: chip ad alta precisione DS3231
Precisione orologio: 2ppm nell’intervallo 0-40°C, errore annuale circa 1 minuto
Due allarmi calendario
Uscita a onda quadra programmabile
L’orologio in tempo reale genera secondi, minuti, ore, giorno della settimana, data, mese e anno, con compensazione per anni bisestili valida fino al 2100
Sensore di temperatura integrato con precisione di ±3°C
Chip di memoria: AT24C32 (capacità di 32K)
Interfaccia bus IIC, velocità massima di trasmissione 400KHz (a 5V)
Può essere collegato in cascata con altri dispositivi IIC, l’indirizzo 24C32 può essere modificato cortocircuitando A0/A1/A2, indirizzo predefinito 0x57
Utilizza batteria CR2032 per garantire il funzionamento continuo dell’orologio dopo un’interruzione di corrente

Diagramma a blocchi del DS3231

Il diagramma a blocchi seguente mostra i componenti interni del DS3231. Si possono vedere l’oscillatore a cristallo, il sensore di temperatura, il controllo di alimentazione e l’interfaccia I2C.

Block Diagram of DS3231 Chip — Diagramma a blocchi del chip DS3231

I pin del DS3231 sono i seguenti: V_CC e GND per l’alimentazione generale e V_BAT per la batteria di backup. SCL e SDA sono per l’interfaccia I2C.

Il pin etichettato “33kHz” fornisce il segnale orario a 32kHz. INT/SQW è un pin di interrupt che può essere usato per segnalare allarmi o come uscita a onda quadra programmabile.

RST è il pin di reset che può segnalare al microprocessore collegato la perdita o il ripristino dell’alimentazione. I pin “33kHz”, INT/SQW e RST hanno anche altre funzioni. Per maggiori dettagli consulta il datasheet linkato qui sotto:

DS3231 Datasheet

Nozioni di base sul modulo DS3231 RTC

Il chip DS3231 è troppo piccolo per essere collegato direttamente a un ESP32 e manca di alcuni componenti necessari. Per questo si usa tipicamente un modulo DS3231 RTC. Il modulo include i componenti mancanti e un alloggiamento per una CR2032 batteria che fornisce l’alimentazione di backup. L’immagine sotto mostra il fronte e il retro di un tipico modulo DS3231 RTC:

Front and back of DS3231 RTC Module — Fronte e retro del modulo DS3231 RTC

Invece di una CR2032 batteria puoi anche usare una batteria ricaricabile LIR2032 ma devi fare attenzione alla tensione di alimentazione. Ne parleremo più avanti.

Pinout del modulo DS3231 RTC

Il pinout di un modulo DS3231 RTC è essenzialmente lo stesso descritto per il chip DS3231.

Pinout of DS3231 RTC Module — Pinout del modulo DS3231 RTC

VCC e GND sono per l’alimentazione, con una tensione di alimentazione da 3.3 a 5.5V. SCL e SDA sono i pin per l’interfaccia I2C (con resistori di pull-up integrati da 4.7k). I pin 32K e SQW sono uscite per il segnale orario a 32kHz e per il segnale a onda quadra programmabile, ma qui non ti serviranno.

L’indirizzo I2C del modulo DS3231 RTC è configurabile tramite tre pad di saldatura (A0, A1, A2) che possono essere collegati tra loro. Vedi la sezione evidenziata nell’angolo in basso a destra del modulo nell’immagine sopra. L’indirizzo I2C predefinito è 0x57, se non sono presenti ponticelli. L’immagine sotto mostra tutte le configurazioni possibili e gli indirizzi I2C corrispondenti.

Setting I2C address of the DS3231 RTC Module — Configurazione dell’indirizzo I2C del modulo DS3231 RTC (source)

Ricarica della batteria con il modulo DS3231 RTC

Il modulo DS3231 RTC permette di caricare la batteria di backup dall’alimentazione principale (VCC). L’immagine sotto mostra lo schema elettrico del modulo DS3231 RTC. Nella sezione evidenziata in giallo si vede una resistenza da 200Ω e un diodo 1N4148 che formano un circuito di ricarica molto semplice.

Schematic of DS3231 RTC Module — Schema elettrico del modulo DS3231 RTC

Tuttavia, devi disabilitare questo circuito di ricarica se usi una batteria CR2032 non ricaricabile con una tensione di alimentazione VCC di 5V. Se usi una batteria ricaricabile LIR2032, VCC non dovrebbe mai superare i 4.7 volt per una ricarica sicura.

L’articolo Battery charging circuit of DS3231 module descrive in dettaglio i problemi del circuito di ricarica e mostra come disabilitarlo. La tabella seguente, tratta dall’articolo, elenca i diversi scenari con differenti tensioni di alimentazione e tipi di batteria, e cosa fare in ciascun caso:

Tipo di batteria	Alimentazione 3.3 V	Alimentazione 5 V
CR2032	Batteria non influenzata	Disabilitare circuito di ricarica
LIR2032	Batteria non influenzata La ricarica non funziona	Disabilitare circuito di ricarica, oppure Assicurarsi che i 5 V siano effettivamente 4.7 V

Collegare il modulo DS3231 RTC all’ESP32 lite

Collegare il modulo DS3231 RTC a un ESP32 è semplice. Prima collega SCL del DS3231 al pin 23 dell’ESP32. Poi collega SDA al pin 19 del DS3231. Infine, collega la massa a GND e 3.3V a VCC come mostrato sotto:

Connecting DS3231 RTC Module to ESP32 lite — Collegamento modulo DS3231 RTC a ESP32 lite

Poiché alimentiamo il modulo DS3231 RTC a 3.3V, puoi avere una batteria CR2032 inserita mentre è collegato all’alimentazione.

Codice di test semplice per modulo DS3231 RTC

Ti servirà una libreria software per comunicare con il modulo DS3231 RTC. Ce ne sono diverse, ma a me piace di più la Arduino-DS3231 libreria di Korneliusz Jarzębski. Per installarla vai su github repo e clicca il pulsante verde “Code”. Poi seleziona “Download Zip” dal menu come mostrato sotto:

Download ZIP file for Arduino-DS3231library — Scarica il file ZIP per la libreria Arduino-DS3231

Questo scaricherà un file chiamato “Arduino-DS3231-dev.zip” sul tuo computer. Per installare questa libreria ZIP segui i passaggi usuali. Clicca su Sketch -> Add .ZIP Library, e poi seleziona il file Arduino-DS3231-dev.zip appena scaricato.

Installing a .ZIP Arduino library — Installazione di una libreria Arduino .ZIP

Con la libreria installata, possiamo testare il funzionamento del modulo DS3231 RTC. Il codice semplice seguente imposta l’ora e la data nel modulo RTC al momento della compilazione dello sketch e poi stampa ora e data in un ciclo:

#include "Wire.h"
#include "DS3231.h"

DS3231 rtc;

void setup() {
  Serial.begin(9600);
  rtc.begin();
  rtc.setDateTime(__DATE__, __TIME__);
}

void loop() {
  RTCDateTime  dt = rtc.getDateTime();
  Serial.printf("%4d-%02d-%02d %02d:%02d:%02d\n",
                dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second);
  delay(1000);
}

Il codice inizia includendo la libreria Wire.h per la comunicazione I2C e la libreria DS3231.h per comunicare con il DS3231 RTC.

Successivamente, creiamo un’istanza della classe DS3231. Nella funzione setup() inizializziamo l’RTC e impostiamo la data e l’ora correnti usando rtc.setDateTime(). Le macro __DATE__ e __TIME__ inseriscono automaticamente la data e l’ora in cui lo sketch è stato compilato. Nota che l’ora non sarà aggiornata quando l’ESP32 viene riavviato dopo la compilazione e il caricamento del codice, ma lo gestiremo più avanti.

Nella funzione loop, recuperiamo la data e l’ora correnti dall’RTC usando RTCDateTime dt = rtc.getDateTime() e usiamo printf per stampare data e ora sul Monitor Seriale.

Esempio di output

Se carichi il codice e apri il Monitor Seriale, dovresti vedere la data e l’ora stampate come segue:

Data e ora RTC stampate nel Monitor Seriale

Ora legale con modulo DS3231 RTC

Sebbene il DS3231 tenga traccia accurata di data e ora, non si regola automaticamente per l’ora legale (DST). Ciò significa che il DS3231 riporterà l’ora (e la data) sbagliata quando il tuo paese passa all’ora legale o torna all’ora solare.

Ci sono essenzialmente due modi per gestire questo. 1) puoi aggiungere un pulsante che cambia manualmente da DST a ST e viceversa. Ovviamente non è ottimale. 2) aggiungi del codice che esegue automaticamente il cambio per il fuso orario del tuo paese.

In questa sezione ti mostro come gestire automaticamente l’ora legale usando il modulo DS3231 RTC. Useremo la libreria ezTime Library per questo. Puoi installarla tramite il Library Manager come al solito:

Install ezTime Library via Library Manager — Installa la libreria ezTime tramite Library Manager

Una volta installata, puoi usarla per regolare il DS3231 RTC all’ora legale con il seguente codice:

#include "Wire.h"
#include "DS3231.h"
#include "ezTime.h"

const char* TIMEZONE = "AEST-10AEDT,M10.1.0,M4.1.0/3";  // Melbourne

Timezone loc;
DS3231 rtc;

void setup() {
  Serial.begin(9600);
  rtc.begin();
  rtc.setDateTime(2024,12,4,3,16,30);  // UTC
  loc.setPosix(TIMEZONE);
}

void loop() {
  RTCDateTime dt = rtc.getDateTime();
  UTC.setTime(dt.hour, dt.minute, dt.second, dt.day, dt.month, dt.year);

  Serial.printf("RTC: %4d-%02d-%02d %02d:%02d:%02d\n",
                dt.year, dt.month, dt.day, 
                dt.hour, dt.minute, dt.second);

  Serial.printf("LOC: %4d-%02d-%02d %02d:%02d:%02d\n",
                loc.year(), loc.month(), loc.day(), 
                loc.hour(), loc.minute(), loc.second());                
               
  Serial.println();

  delay(5000);
}

Nel codice sopra, interfacciamo un ESP32 con un modulo DS3231 Real-Time Clock (RTC) per tenere traccia dell’ora corrente, inclusa la regolazione per l’ora legale. Il programma inizializza l’RTC, imposta una data e ora specifica, e poi recupera e mostra continuamente l’ora UTC e locale ogni 5 secondi.

Analizziamo il codice nelle sue componenti per una comprensione più chiara.

Librerie incluse

Iniziamo includendo le librerie necessarie per il progetto. La libreria Wire.h è usata per la comunicazione I2C, che è il modo in cui l’ESP32 comunica con il DS3231 RTC. La libreria DS3231.h fornisce funzioni specifiche per interagire con il modulo DS3231, e ezTime.h è usata per gestire i fusi orari e le regolazioni dell’ora legale.

#include "Wire.h"
#include "DS3231.h"
#include "ezTime.h"

Costanti e variabili

Definiamo una costante per il fuso orario. In questo caso usiamo AEST-10AEDT,M10.1.0,M4.1.0/3, che corrisponde a Melbourne, Australia. Questa stringa indica lo scostamento dall’ora UTC standard e le regole per l’ora legale.

const char* TIMEZONE = "AEST-10AEDT,M10.1.0,M4.1.0/3";  // Melbourne

Le parti di questa definizione del fuso orario sono le seguenti

AEST: Australian Eastern Standard Time
-10: scostamento UTC di 10 ore avanti rispetto al Tempo Coordinato Universale (UTC)
AEDT: Australian Eastern Daylight Time
M10.1.0: il passaggio all’ora legale avviene la prima domenica di ottobre
M4.1.0/3: il ritorno all’ora solare avviene la prima domenica di aprile, con una differenza di 3 ore da UTC.

Per altre definizioni di fusi orari dai un’occhiata a Posix Timezones Database. Basta copiare la stringa che trovi lì e modificare la costante TIMEZONE di conseguenza.

Creiamo anche istanze delle classi Timezone e DS3231. La variabile loc conterrà le informazioni sull’ora locale, mentre rtc gestirà il modulo RTC.

Timezone loc;
DS3231 rtc;

Funzione setup

Nella funzione setup() inizializziamo la comunicazione seriale a 9600 baud per il debug. Poi inizializziamo l’RTC e impostiamo una data e ora specifica (4 dicembre 2024, 03:16:30 UTC). Infine, impostiamo il fuso orario usando la costante definita.

void setup() {
  Serial.begin(9600);
  rtc.begin();
  rtc.setDateTime(2024,12,4,3,16,30);  // UTC
  loc.setPosix(TIMEZONE);
}

Funzione loop

La funzione loop() gira continuamente. Prima recuperiamo la data e ora correnti dall’RTC usando rtc.getDateTime(). Poi impostiamo l’ora UTC usando i valori ottenuti.

  RTCDateTime dt = rtc.getDateTime();
  UTC.setTime(dt.hour, dt.minute, dt.second, dt.day, dt.month, dt.year);

Successivamente stampiamo l’ora UTC corrente sul monitor seriale in una stringa formattata. Include anno, mese, giorno, ora, minuto e secondo.

  Serial.printf("RTC: %4d-%02d-%02d %02d:%02d:%02d\n",
                dt.year, dt.month, dt.day, 
                dt.hour, dt.minute, dt.second);

Stampiamo anche l’ora locale usando la variabile loc, che è stata regolata per il fuso orario e l’ora legale.

  Serial.printf("LOC: %4d-%02d-%02d %02d:%02d:%02d\n",
                loc.year(), loc.month(), loc.day(), 
                loc.hour(), loc.minute(), loc.second());

Infine aggiungiamo una nuova riga per una migliore leggibilità nell’output seriale e introduciamo un ritardo di 5000 millisecondi (5 secondi) prima che il ciclo ricominci.

  Serial.println();
  delay(5000);

Esempio di output

Se carichi il codice e apri il Monitor Seriale, dovresti vedere l’ora UTC dell’RTC e l’ora locale (LOC) stampate:

UTC and local time of RTC on Serial Monitor — Ora UTC e locale dell’RTC sul Monitor Seriale

Sincronizzare il DS3231 RTC con un server SNTP

Sebbene il codice sopra gestisca automaticamente la regolazione per l’ora legale, richiede ancora di impostare manualmente l’ora dell’RTC all’avvio dell’ESP32. Peggio ancora, devi collegare l’ESP32 a un computer, modificare il codice e riprogrammarlo. È fastidioso!

Potresti aggiungere pulsanti per modificare ora e data mentre l’ESP32 è in funzione. Se vuoi farlo, dai un’occhiata al tutorial Arduino and RTC Module DS3231, dove usiamo due pulsanti per impostare l’ora.

L’opzione migliore, però, è sincronizzare automaticamente l’RTC con un provider di tempo Internet (SNTP). Per maggiori informazioni, dai un’occhiata al tutorial How to synchronize ESP32 clock with SNTP server.

Se hai accesso costante a Internet e non ti interessa il consumo energetico, non avresti bisogno di un RTC, perché puoi sincronizzare regolarmente l’orologio interno dell’ESP32. Questo imposterà automaticamente l’orologio e gestirà anche l’ora legale. Vedi i tutorial Automatic Daylight Savings Time Clock e Digital Clock on e-Paper Display.

Tuttavia, per un progetto alimentato a batteria vuoi evitare di usare il WiFi troppo spesso, perché consuma molta energia. Un caso d’uso comune è un data logger, ad esempio per la temperatura, che vuoi far funzionare a batteria il più a lungo possibile ma che necessita di timestamp precisi.

Il codice seguente ti mostra come fare. Usa il WiFi solo quando l’ESP32 viene resettato per sincronizzare l’RTC. Altrimenti, l’ESP32 è in deep-sleep per risparmiare energia e si sveglia solo occasionalmente per leggere l’ora dall’RTC e stamparla:

#include "WiFi.h"
#include "esp_sntp.h"
#include "Wire.h"
#include "DS3231.h"
#include "ezTime.h"

const char* TIMEZONE = "AEST-10AEDT,M10.1.0,M4.1.0/3";  // Melbourne
const char* SSID = "SSID";
const char* PWD = "PASSWORD";
const int SLEEP = 10; // sec
 
DS3231 rtc; 
Timezone loc;

void syncTime() {
  WiFi.begin(SSID, PWD);
  while (WiFi.status() != WL_CONNECTED)
    ;
  configTzTime("UTC", "pool.ntp.org");
  setRtcTime();
}

void setRtcTime() {
  struct tm t;
  getLocalTime(&t);
  rtc.setDateTime(t.tm_year+1900, t.tm_mon+1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec);
}

void printTime() {
  RTCDateTime dt = rtc.getDateTime();
  UTC.setTime(dt.hour, dt.minute, dt.second, dt.day, dt.month, dt.year);

  Serial.printf("RTC: %4d-%02d-%02d %02d:%02d:%02d\n",
                dt.year, dt.month, dt.day, 
                dt.hour, dt.minute, dt.second);

  Serial.printf("LOC: %4d-%02d-%02d %02d:%02d:%02d\n",
                loc.year(), loc.month(), loc.day(), 
                loc.hour(), loc.minute(), loc.second());                
               
  Serial.println();

}

bool isReset() {
  return esp_sleep_get_wakeup_cause() != ESP_SLEEP_WAKEUP_TIMER;
}

void setup() {
  Serial.begin(9600);
  rtc.begin();
  loc.setPosix(TIMEZONE);

  if (isReset()) {
    syncTime();
  }   
  printTime();

  esp_sleep_enable_timer_wakeup(SLEEP * 1000000);                
  esp_deep_sleep_start();
}

void loop() {
}

Analizziamo il codice nelle sue componenti per una migliore comprensione.

Librerie e costanti

Iniziamo includendo le librerie necessarie per Wi-Fi, SNTP (Simple Network Time Protocol), comunicazione I2C e il DS3231 RTC. Definiamo anche alcune costanti per il fuso orario, le credenziali Wi-Fi e la durata del sonno.

#include "WiFi.h"
#include "esp_sntp.h"
#include "Wire.h"
#include "DS3231.h"
#include "ezTime.h"

const char* TIMEZONE = "AEST-10AEDT,M10.1.0,M4.1.0/3";  // Melbourne
const char* SSID = "SSID";
const char* PWD = "PASSWORD";
const int SLEEP = 10; // sec

Ovviamente dovrai sostituire le credenziali Wi-Fi con le tue.

Oggetti RTC e fuso orario

Creiamo istanze della classe DS3231 per l’RTC e della classe Timezone per gestire i calcoli dell’ora locale.

DS3231 rtc; 
Timezone loc;

Funzione di sincronizzazione dell’ora

La funzione syncTime() si connette alla rete WiFi e configura il fuso orario per il server NTP. Poi chiama setRtcTime() per aggiornare l’RTC con l’ora corrente.

void syncTime() {
  WiFi.begin(SSID, PWD);
  while (WiFi.status() != WL_CONNECTED)
    ;
  configTzTime("UTC", "pool.ntp.org");
  setRtcTime();
}

Funzione per impostare l’ora dell’RTC

Nella funzione setRtcTime() recuperiamo l’ora locale e impostiamo la data e l’ora dell’RTC di conseguenza. L’anno è aggiustato sommando 1900 perché il campo tm_year restituisce il numero di anni trascorsi dal 1900.

void setRtcTime() {
  struct tm t;
  getLocalTime(&t);
  rtc.setDateTime(t.tm_year+1900, t.tm_mon+1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec);
}

Nota che dobbiamo anche aggiungere 1 a tm_mon per ottenere il mese corretto, poiché la struttura dati struct tm usa intervalli incoerenti. Ad esempio, il giorno del mese parte da 1 mentre il mese dell’anno parte da 0:

  Member    Type  Meaning                   Range
  tm_sec    int   seconds after the minute  0-61*
  tm_min    int   minutes after the hour    0-59
  tm_hour   int   hours since midnight      0-23
  tm_mday   int   day of the month          1-31
  tm_mon    int   months since January      0-11
  tm_year   int   years since 1900
  tm_wday   int   days since Sunday         0-6
  tm_yday   int   days since January 1      0-365
  tm_isdst  int   Daylight Saving Time flag

Funzione per stampare l’ora

La funzione printTime() recupera la data e l’ora correnti dall’RTC e le stampa sul Monitor Seriale. Stampa anche l’ora locale usando l’oggetto fuso orario.

void printTime() {
  RTCDateTime dt = rtc.getDateTime();
  UTC.setTime(dt.hour, dt.minute, dt.second, dt.day, dt.month, dt.year);

  Serial.printf("RTC: %4d-%02d-%02d %02d:%02d:%02d\n",
                dt.year, dt.month, dt.day, 
                dt.hour, dt.minute, dt.second);

  Serial.printf("LOC: %4d-%02d-%02d %02d:%02d:%02d\n",
                loc.year(), loc.month(), loc.day(), 
                loc.hour(), loc.minute(), loc.second());                

  Serial.println();
}

Funzione per controllare il reset

La funzione isReset() verifica se l’ESP32 si è svegliato dal deep sleep a causa di un timer o per un’altra causa. Questo aiuta a decidere se sincronizzare l’ora o meno.

bool isReset() {
  return esp_sleep_get_wakeup_cause() != ESP_SLEEP_WAKEUP_TIMER;
}

Funzione setup

Nella funzione setup() inizializziamo la comunicazione seriale, l’RTC e impostiamo il fuso orario. Se l’ESP32 parte da zero (non si sveglia dal deep sleep), sincronizziamo l’ora. Infine stampiamo l’ora e mettiamo l’ESP32 in deep sleep per la durata specificata.

void setup() {
  Serial.begin(9600);
  rtc.begin();
  loc.setPosix(TIMEZONE);

  if (isReset()) {
    syncTime();
  }   
  printTime();

  esp_sleep_enable_timer_wakeup(SLEEP * 1000000);                
  esp_deep_sleep_start();
}

Funzione loop

La funzione loop() è vuota perché l’ESP32 non eseguirà codice mentre è in deep sleep. Si sveglierà solo per eseguire di nuovo la funzione setup() dopo la durata del sonno.

void loop() { }

Visualizzare l’ora RTC su OLED

Come esempio finale, voglio mostrarti come aggiungere un OLED per visualizzare l’ora e la data dell’RTC su uno schermo. È solo un’estensione semplice del codice sopra.

Collegare l’OLED è facile, dato che è anch’esso un dispositivo I2C. Basta collegare SDA, SCL, VCC e GND dell’OLED in parallelo al DS3231 come mostrato sotto

Connecting OLED and DS3231 to ESP32 lite — Collegamento OLED e DS3231 a ESP32 lite

Qui sotto c’è il codice che mostra ora e data sull’OLED. Nota che usa la libreria Adafruit_SSD1306, che puoi installare tramite il Library Manager come al solito.

#include "WiFi.h"
#include "esp_sntp.h"
#include "Wire.h"
#include "DS3231.h"
#include "ezTime.h"
#include "Adafruit_SSD1306.h"

const char* TIMEZONE = "AEST-10AEDT,M10.1.0,M4.1.0/3";
const char* SSID = "SSID";
const char* PWD = "PASSWORD";
const int SLEEP = 10; // sec
 
DS3231 rtc; 
Timezone loc;
Adafruit_SSD1306 oled(128, 64, &Wire, -1);

void oled_init() {
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.setTextSize(2);
  oled.setTextColor(WHITE);
}

void syncTime() {
  WiFi.begin(SSID, PWD);
  while (WiFi.status() != WL_CONNECTED)
    ;
  configTime(0, 0, "pool.ntp.org");
  setRtcTime();
}

void setRtcTime() {
  struct tm t;
  getLocalTime(&t);
  rtc.setDateTime(t.tm_year+1900, t.tm_mon+1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec);
}

void displayTime() {
  RTCDateTime dt = rtc.getDateTime();
  UTC.setTime(dt.hour, dt.minute, dt.second, dt.day, dt.month, dt.year);
  oled.clearDisplay();
  oled.setCursor(10, 15);
  oled.println(loc.dateTime("H:i:s"));  
  oled.setCursor(2, 45);
  oled.println(loc.dateTime("d/m/Y"));  
  oled.display();
}

bool isReset() {
  return esp_sleep_get_wakeup_cause() != ESP_SLEEP_WAKEUP_TIMER;
}

void setup() {
  rtc.begin();
  loc.setPosix(TIMEZONE);
  oled_init();

  if (isReset()) {
    syncTime();
  }   
  displayTime();

  esp_sleep_enable_timer_wakeup(SLEEP * 1000000);                
  esp_deep_sleep_start();
}

void loop() {
}

Le uniche aggiunte e modifiche al codice sono la funzione oled_init(), che inizializza l’OLED, e la funzione displayTime(), che mostra ora e data sull’OLED. Se carichi il codice sul tuo ESP32 dovresti vedere quanto segue sull’OLED:

Time and date displayed on OLED — Ora e data visualizzate sull’OLED

E questo è tutto! Ora dovresti essere in grado di usare il DS3231 RTC insieme a un ESP32.

Conclusioni

In questo tutorial hai imparato come usare un modulo DS3231 Real Time Clock (RTC) con un ESP32.

L’ESP32 lite con un orologio in tempo reale è particolarmente adatto per progetti alimentati a batteria che necessitano di mantenere un tempo preciso consumando poca energia. Gli usi comuni sono data loggers o orologi elettronici. Per questi ultimi, consiglio display e-Paper, poiché consumano quasi nulla. Vedi i nostri tutorial, Analog Clock on e-Paper Display e Digital Clock on e-Paper Display.

Se vuoi imparare di più sugli orologi con diversi tipi di display e sincronizzazione dell’ora dai un’occhiata a Digital Clock on e-Paper Display,

Se hai domande, sentiti libero di lasciarle nella sezione commenti.

Buon divertimento con il tinkering ; )

Stefan Maetschke

Componenti necessari

ESP32 lite

Cavo dati USB

Modulo DS3231 RTC

Set di fili Dupont

Breadboard

Display OLED

Nozioni di base sul chip DS3231

Specifiche tecniche

Diagramma a blocchi del DS3231

Nozioni di base sul modulo DS3231 RTC

Pinout del modulo DS3231 RTC

Ricarica della batteria con il modulo DS3231 RTC

Collegare il modulo DS3231 RTC all’ESP32 lite

Codice di test semplice per modulo DS3231 RTC

Esempio di output

Ora legale con modulo DS3231 RTC

Librerie incluse

Costanti e variabili

Funzione setup

Funzione loop

Esempio di output

Sincronizzare il DS3231 RTC con un server SNTP

Librerie e costanti

Oggetti RTC e fuso orario

Funzione di sincronizzazione dell’ora

Funzione per impostare l’ora dell’RTC

Funzione per stampare l’ora

Funzione per controllare il reset

Funzione setup

Funzione loop

Visualizzare l’ora RTC su OLED

Conclusioni