Data e ora del nostro Raspberry vengono sincronizzate all’avvio del sistema operativo tramite server NTP. In tutte le altre applicazioni dove non avete un accesso ad internet la data e l’ora sono impostate di default ma non corrisponderanno a valori corretti. In questi casi una soluzione è utilizzare un rtc che in caso di spegnimento della scheda tenga sempre aggiornato il dato di data e tempo.

Vediamo come fare.

La prima cosa è procurarci un modulo rtc pronto all’uso oppure realizzarne uno partendo dai singoli componenti. Nel mio caso visto il costo e la praticità di installazione ho scelto un rtc già assemblato. Il modello si basa sul chip DS3231 è ha un pratico connettore che permette l’installazione connettendolo direttamente sui pin header del raspberry;

DS3231 ad Alta precisione modulo di Memoria Orologio RTC per Arduino Raspberry Pi

Nell’immagine seguente potete osservare come deve essere installato il modulo rtc ds3231. 

Configurazione del dispositivo

La comunicazione tra il DS3231 e il Raspberry avviene utilizzando il bus I2C. Procediamo alla sua attivazione eseguendo il comando:

sudo raspi-config

Viene avviata la schermata del Raspberry PI Software Configuration Tool.  Portiamoci sulla voce Interface Options e premiamo invio, nella schermata successiva selezioniamo la voce I2C. Confermiamo rispondendo affermativamente e attendiamo l’attivazione del bus I2C:

Dopo aver terminato l’attivazione del bus, riavviamo il sistema operativo con il comando seguente:

sudo reboot

Dopo il riavviamo apriamo una nuova finestra terminale e utilizzando programma i2cdetect possiamo verificare che il modulo rtc e il bus I2C stiano funzionando:

i2cdetect -y 1

dovremmo avere una schermata simile alla seguente:

il programma i2cdetect non fa altro che scansionare il bus I2C alla ricerca di dispositivi collegati. Nel nostro caso ha trovato un dispositivo all’indirizzo 0x68 che corrisponde all’unico dispositivo collegato al raspberry, ovvero il modulo DS3231.

Per sicurezza possiamo verificare sul datasheet dell’rtc l’indirizzo del dispositivo.

A questo punto possiamo caricare sul kernel linux il modulo rtc ds3232 (compatibile con il DS3231) eseguendo il seguente commando:

sudo modprobe rtc-ds3232

premiamo invio per eseguire il commando:

a questo punto dobbiamo creare un nuovo device con indirizzo 0x68 ed inserirlo nel bus I2C. Per eseguire questa serie di commandi dobbiamo loggarci come utente root digitando il comando seguente:

su

inseriamo la password per l’utente root.

Nel caso in cui non si disponga di una pssword per l’utente root è necessario crearla digitando il comando:

sudo passwd root

Digitiamo una nuova password per l’utente root e confermiamo ripetendola nuovamente.

Ora che abbiamo i privilegi del superuser digitiamo il seguente commando:

echo ds3232 0x68 > /sys/class/i2c-adapter/i2c-1/new_device

premiamo invio. Digitiamo il comando exit per ritornare all’utente pi:

Impostare data e ora dell’RTC

Dopo le precedenti istruzioni il sistema carica automaticamente i dati correnti di data e ora sull’RTC. Se questi dati corrispondono ai valori corretti non dobbiamo far altro che leggere i dati con il seguente comando:

sudo hwclock -r

in alternativa possiamo settare i valori come desideriamo eseguendo questo comando:

sudo hwclock --set --date "Fri Jan 1 15:00:00 CET 2021"

Tutte queste impostazioni non rimangono memorizzate al successivo riavvio del sistema operativo e quindi necessario inserire queste istruzioni su un file che viene lanciato durante le fasi di boot come ad esempio il file rc.local, quindi procediamo ad eseguire le seguenti istruzioni:

Modifichiamo il files modules per caricare sul kernel il modulo rtc-ds3232

sudo nano /etc/modules

inseriamo alla fine del file la seguente stringa:

rtc-ds3232

salviamo il file con la combinazione di tasti crtl+o  e usciamo con ctrl+x

Ora apriamo il file rc.local:

sudo nano /etc/rc.local

portiamoci con puntatore prima dell’istruzione exit 0 e aggiungiamo le seguenti istruzioni:

echo ds3232 0x68 > /sys/class/i2c-adapter/i2c-1/new_device

inseriamo subito dopo anche l’istruzione seguente:

sudo hwclock -s

in modo da sincronizzare la data e l’ora del sistema operativo con quella del modulo RTC.

disconnettiamo il Raspberry dalla rete cablata o WiFi, riavviamo e verifichiamo con il comando date che le impostazioni del sistema siano coerenti con quelle impostate precedentemente nell’rtc.

The post Aggiungere un RTC al Raspberry PI appeared first on Esperimenti con logiche programmabili.

Considero molto utile avere un dispositivo che permetta di tenere traccia del tempo e della data, poiché in molti progetti, come quelli della domotica, richiedono un sistema per recuperare queste informazioni. Avere un circuito che mi garantisca, anche in mancanza di alimentazione, un riferimento temporale sicuro è fondamentale.

Tipicamente, l’integrato che viene utilizzato maggiormente, in campo hobbistico, è il DS1307. Le sue caratteristiche tecniche sono le seguenti

ha un costo contenuto, circa 2.5€, è disponibile sia in package  THT(Through-Hole Technology) sia in SMD, in versioni con standard industriali (temperature di esercizio da -40 a +85 °C).

Anche utilizzarlo è risultato semplice, vista la possibilità di colloquiare tramite bus I2C. Una volta realizzato il circuito seguente, scriviamo alcun istruzioni per settare i registri del DS1307 in modo da impostare la data e l’ora.

La struttura di questi registri è la seguente:

mentre le istruzioni le trovate di seguito

//includo la libreria per la
//comunicazione su bus I2C
#include <Wire.h>

void setup()
{
//inizializzo la libreria
Wire.begin();

//attivo la comunicazione con il DS1307
//l'indirizzo dell'RTC è 0x68
Wire.beginTransmission(0x68);
//il primo byte stabilisce il registro
//iniziale da scivere
Wire.write((byte)0x00);
//specifico il tempo e la data
Wire.write((byte)0x00); //1° byte SECONDI da 0x00 a 0x59
Wire.write((byte)0x10); //2° byte MINUTI da 0x00 a 0x59
Wire.write((byte)0x80 | 0x10); //3° byte ORE da 0x00 a 0x23
Wire.write((byte)0x01); //4° byte GIORNO della settimana da 0x01 a 0x07
Wire.write((byte)0x21); //5° byte GIORNO del mese da 0x01 a 0x31
Wire.write((byte)0x03); //6° byte MESE da 0x01 a 0x12
Wire.write((byte)0x12); //7° byte ANNO 0x00 a 0x99
Wire.endTransmission();
}

void loop()
{
delay(100);
}

Per poter recuperare le informazioni è sufficiente eseguire una lettura in sequenza dei primi 7 byte, partendo dall’indirizzo 0x00

//includo la libreria per la
//comunicazione su bus I2C
#include <Wire.h>

void setup()
{
//inizializzo la seriale
Serial.begin(9600);

//inizializzo la libreria
Wire.begin();

//attivo la comunicazione con il DS1307
//l'indirizzo dell'RTC è 0x68
Wire.beginTransmission(0x68);
//il primo byte stabilisce il registro
//iniziale da scivere
Wire.write((byte)0x00);
//specifico il tempo e la data
Wire.write((byte)0x00); //1° byte SECONDI da 0x00 a 0x59
Wire.write((byte)0x10); //2° byte MINUTI da 0x00 a 0x59
Wire.write((byte)0x80 | 0x10); //3° byte ORE da 0x00 a 0x24
Wire.write((byte)0x01); //4° byte GIORNO della settimana da 0x01 a 0x07
Wire.write((byte)0x21); //5° byte GIORNO del mese da 0x00 a 0x31
Wire.write((byte)0x03); //6° byte MESE da 0x00 a 0x12
Wire.write((byte)0x12); //7° byte ANNO 0x00 a 0x99
Wire.endTransmission();
}

void loop()
{
//inizzializza la trasmissione partendo
//dall'indirizzo 0x00
Wire.beginTransmission(0x68);
Wire.write((byte)0x00);
Wire.endTransmission();

//richiedo 7 byte dal dispositivo con
//indirizzo 0x68
Wire.requestFrom(0x68, 7);
//regupero i 7 byte relativi ai
//corrispondenti registri
byte secondi = Wire.read();
byte minuti = Wire.read();
byte ora = Wire.read();
byte giorno_sett = Wire.read();
byte giorno_mese = Wire.read();
byte mese = Wire.read();
byte anno = Wire.read();

Serial.print("Orario corrente: ");
Serial.print(ora, HEX);
Serial.print(":");
Serial.print(minuti, HEX);
Serial.print(":");
Serial.println(secondi, HEX);

Serial.print("Giorno della settimana: ");
Serial.println(giorno_sett, HEX);

Serial.print("Data corrente: ");
Serial.print(giorno_mese, HEX);
Serial.print("/");
Serial.print(mese, HEX);
Serial.print("/");
Serial.println(anno, HEX);
Serial.println();

delay(1000);
}

La batteria tampone, tipicamente una CR2032, garantisce un back-up di circa 6 mesi.

Delocalizzare la gestione dell’orario su un chip esterno permette di concentrare le risorse dell’Arduino su altri processi e allo stesso tempo di impiegare in modo veloce e semplice il bus I2C per recuperare le informazioni di tempo e data.

Realizzare automatismi basati sul DS1307 è risultato molto economico e semplice, vi invito quindi ad acquistare direttamente il chip piuttosto che i kit già assemblati che attualmente si aggirano tra gli 8€ e i 15€.

The post Usare il modulo RTC DS1307 con Arduino appeared first on Esperimenti con logiche programmabili.