Oggi vediamo brevemente come utilizzare un modulo RTC con Arduino. Ma forse prima dovremmo domandarci cosa sia un modulo RTC. Questa sigla significa Real Time Clock, per cui di fatto si tratta di un orologio che mantiene in memoria l’ora. Ci sono almeno due differenti motivi per cui può essere utile l’uso di uno di questi moduli. Il primo è far conoscere ad Arduino l’ora ed il giorno in cui ci troviamo, cosa fattibile anche sfruttando una connessione ad internet tramite servizio NTP, ma questi moduli hanno il vantaggio di avere anche l’alloggiamento per una batteria per cui permettono di mantenere in memoria l’orario anche se stacchiamo l’alimentazione ad Arduino e appunto senza la necessità di una connessione internet. Il secondo motivo per cui ci può servire è in tutti i casi in cui dobbiamo avere un sistema che possa misurare in maniera accurata il passaggio del tempo, infatti il timer interno di Arduino non è poi così accurato, diciamo che può sbagliare da 2 a 10 minuti al mese che può essere poco per certi tipi di applicazione ma disastroso per altre.

Quale modulo?

Beh, non tutti i moduli RTC sono uguali. Esistono differenti tipologie di chip montati a bordo ed ognuno di questi ha determinati gradi di precisione, sensibilità alla temperatura esterna, capacità di ricaricare la batteria, tipo di interfaccia, etc. Esempi sono il ds1302, ds1307 o il ds3231. Quest’ultimo sarà quello da me usato in quanto il più preciso (2 ppm) edotato di alcune caratteristiche aggiuntive che con il tempo andremo a sfruttare. Bene, il modulo in mio possesso è identico a quello dello schemino che trovate più sotto ma chiaramente il vostro potrebbe essere creato da un diverso produttore ed avere sembianze differenti. Il modulo contiene anche un sensore termico che viene usato internamente per compensare gli errori legati agli sbalzi termici. Tale sensore ha una precisione di circa 3°C ed è possibile leggerne il contenuto attraverso l’intervaccia I²C per cui per applicazioni grossolane può essere usato anche come termometro. Ci sono anche ulteriori caratteristiche, come la possibilità di impostare alcune sveglie o la presenza di un chip di memoria interna da 32K, molto utile se ad esempio volete creare un data-logger senza utilizzare schede di memoria esterne o se dovete mantenere in memoria dei valori di configurazione che resistano alla mancanza di alimentazione.

Collegamenti

Il collegamento è quanto di più semplice. Il modulo in mio possesso è alimentato 3.3-5V ma fate sempre molta attenzione alla documentazione fornita con l’hardware in vostro possesso, potreste ad esempio trovare alcuni moduli alimentati a 3.3V anche se con interfaccia “tollerante” ai 5V. Oltre alla VCC dobbiamo andare a connettere la massa e i due pin dell’interfaccia I²C (SCL ed SDA). Direi che non esiste nulla di più semplice. Se avete un Arduino UNO R3 ricordatevi che avete la replica dei pin SCL ed SDA vicino alla massa, in alto a sinistra guardando la figura qui a lato. C’è ben poco da aggiungere sul collegamento, l’unica parte hardware che potrebbe essere necessario modificare è quella relativa all’indirizzo del modulo. Questo modulo come gran parte delle periferiche I2C ha un indirizzo prestabilito ma , adifferenza di altri, permette di modificarlo via hardware. Se notate ci sono dei pad nominati A0, A1 e A2 che attraverso una saldatura permettono di modificare l’indirizzo della periferica. Certo però che potevano metterceli dei jumper! Sull’hardware non c’è altro di importante da aggiungere per cui passiamo rapidamente al software.

Software

Se non è già installata nel vostro sistema dovete aggiungere l’apposita libreria per il controllo del modulo. Andate perciò su “Sketch -> #include libreria – > gestione libreria”. Nella schermata che si apre, nella casella di ricerca scriveter “rtclib”. Io, fra le numerose presenti, ho scaricato la RTCLib 1..2.0 di Adafruit, ma ve ne sono altre, anche con funzioni più evolute come appunto la lettura della temperatura. Una volta installata ho provato l’esempio incluso “ds3231”, giusto per vedere che tutto funzionasse. Normalmente provo sempre gli esempi allegati con le librerie dopodichè vi presento uno sketch già adattato per l’articolo. Questa volta mi sono soffermato a specificarvi questa cosa perchè ho avuto una sorpresa inattesa e che ho compreso successivamente solo dopo aver studiato il codice. Il modulo in mio possesso non è dotato della batteria in quanto non inclusa e io, pur avendone, non ne ho messa nessuna in quanto il mio interesse attuale è solo quello di dimostrarne il funzionamento base. Il modulo era in un cassetto da un sacco di mesi e non è stato mai usato prima, se non in fabbrica nelle fasi di test. Quindi la logica mi dice che il modulo non può sapere che ora è per il semplice motivo che non ha una fonte di alimentazione praticamente da quando è stato costruito e invece non appena acceso anzichè mostrarmi la classica data del primo gennaio 1970, ha azzeccato la data e l’ora era sbagliata di soli 3-4 minuti. Se non sai perchè ho detto “primo gennaio 1970”, sappi che fra i più usati sistemi di “misurazione del tempo”, c’è lo UnixTime, che rappresenta il numero di secondi trascorsi a partire dal primo gennaio 1970. Quindi perchè il modulo non è impostato alle 00:00 del primo gennaio 1970? In realtà è piuttosto semplice, nello sketch c’è infatti un pezzo di codice che fa si che se viene rilevata la mancanza di alimentazione del modulo e quindi la perdita dell’orario, viene copiata data e ora della compilazione dello sketch. In questo modo anche senza batteria e senza nessun sistema di regolazione esterna, vi ritroverete con un orario non precisissimo ma abbastanza vicino a quello reale.Qui sotto vi propongo il codice che ho preso dall’esempio originale e che ho semplificato e tradotto:

// La Wire.h vi serve per l'interfaccia I2C
#include <Wire.h>
#include "RTClib.h"

RTC_DS3231 rtc;

char daysOfTheWeek[7][12] = {"Dom", "Lun", "Mar", "Mer", "Gio", "Ven", "Sab"};

void setup () {

#ifndef ESP8266
 while (!Serial); // Leonardo/Micro/Zero
#endif

Serial.begin(9600);

delay(3000);

if (! rtc.begin()) {
 Serial.println("Erorre nella comunicazione con il modulo RTC");
 while (1);
 }

if (rtc.lostPower()) {
 Serial.println("Rilevata perdita di orario del modulo RTC");
 // uso la data e l'ora di compilazione dello sketch
 rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
 // Puoi usare la rtc.adjust anche per settare manualmente data e ora. I parametri sono AA,MM,GG,HH,MM,SS
 // per il 21 gennaio 2014 alle 3 del mattino puoi usare:
 // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
 }
}

void loop () {
 DateTime now = rtc.now();
 
 Serial.print(now.year(), DEC);
 Serial.print('/');
 Serial.print(now.month(), DEC);
 Serial.print('/');
 Serial.print(now.day(), DEC);
 Serial.print(" (");
 Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
 Serial.print(") ");
 Serial.print(now.hour(), DEC);
 Serial.print(':');
 Serial.print(now.minute(), DEC);
 Serial.print(':');
 Serial.print(now.second(), DEC);
 Serial.println();
 delay(3000);
}

L’output sarà qualcosa di simile a:

2017/10/17 (Mar) 11:41:27
2017/10/17 (Mar) 11:41:30
2017/10/17 (Mar) 11:41:33
2017/10/17 (Mar) 11:41:36
2017/10/17 (Mar) 11:41:39

Per oggi non aggiungiamo nient’altro. In questo articolo abbiamo visto qualcosa di davvero semplice, abbiamo collegato il modulo rtc e caricato uno scketch che ci mostra l’orario prelevato dalla data ed ora di compilazione. In un prossimo articolo vedremo come creare un’interfaccia che ci permetta di “comunicare” con Arduino per permettere la regolazione manuale di data ed ora. Questa parte ci servirà poi per procedere con un progetto più complesso che mi è stato richiesto da un utente ma che richiede diversi approfondimenti per essere completato.

Salva