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.

In alcuni miei articoli ho parlato della realizzazione di un impianto di micro irrigazione tramite una centralina autocostruita. Questa centralina aveva il compito di pilotare una elettrovalvola bistabile utilizzando una coppia di relè.

Nel tempo ho modificato questo prototipo per renderlo più efficiente e facile da gestire, e soprattutto perché la vecchia centralina aveva dei consumi di corrente elevati e quindi non efficiente con alimentazione a batteria.

Il circuito di questo articolo è attualmente installato nel mio giardino e in quello di alcuni miei amici.

La decisione di realizzare una nuova centralina nasce per via di alcune esigenze:
la prima è quella dovuta alla scarsità di piogge di questi ultimi anni e di conseguenza la crescente esigenza di irrigare in modo sostenibile utilizzando sistemi ad ala gocciolante o linee autocostruite con micro gocciolatori.
La seconda è dovuta alla mia passione per il fai da te e per la convinzione che i circuiti autocostruiti, benché inizialmente siano più costosi, possano essere una valida alternativa al modello usa e getta e dell’obsolescenza programmata, infatti conoscendo schema elettrico e codice del progetto possiamo, in caso di rottura di qualche componente, ripararlo o riadattarlo per ulteriori esigenze.

Questa mia nuova centralina permette di utilizzare sia elettrovalvole bistabili sia valvole motorizzate.

Le elettrovalvole bistabili sono consigliate per impianti alimentati a batteria in quanto, tramite un breve impulso elettrico di qualche millisecondo, è possibile aprire o chiudere il passaggio dell’acqua.
L’uso di una elettrovalvola nel nostro impianto di irrigazione comporta, il più delle volte, l’impiego di un filtro che privi l’acqua delle impurità che potrebbero comprometterne il funzionamento dell’elettrovalvola; le impurità dell’acqua, col tempo, possono ostruire il piccolo canale che porta l’acqua nella camera del solenoide.

Quando l’acqua possiede una torbidità elevata e non possiamo permetterci un sistema filtrante di qualità possiamo optare per una valvola motorizzata (Escludendo però il sistema di irrigazione a gocciolatori ma a irrigazione diretta).
La valvola motorizzata assorbe più corrente perché il tempo necessario per aprirla o chiuderla è maggiore rispetto all’elettrovalvola (circa3-5 secondi).

Caratteristiche nuova centralina di micro irrigazione

• Basso assorbimento di corrente in standby (circa 0.3uA)
• Open Source e Open Hardware
• Calendario con RTC
• Memorizzazione dati su SD
• Interfaccia seriale
• Programmazione tempi di irrigazione tramite jumper
• Programmazione intervalli di irrigazione tramite jumper
• Led di stato

Schema elettrico a blocchi

Lo schema elettrico è stato suddiviso in blocchi. Analizzeremo ognuno di essi con immagini separate per capirne meglio il funzionamento.

La figura seguente riguarda il sistema di alimentazione del circuito. Il connettore JP1 è collegato alla batteria (da 9 a 12v dc) e permette di alimentare l’elettrovalvola tramite un filtro a larga banda (FILT) e il resto del circuito tramite regolatore a 3.3v (MIC2940A-3.3WT).

Il regolatore che ho scelto è un convertitore DC/DC LDO della Microchip. La scelta è ricaduta su questo componente perché assorbe una corrente molto bassa.
Il componete di nome sky2 è un diodo transil bidirezionale da 15v che permette di smorzare le extratensioni generate della commutazione del solenoide dell’elettrovalvola.
Se non adeguatamente filtrate, le extratensioni possono resettare il microcontrollore rendendo il circuito instabile ed inutilizzabile.

Il partitore di tensione costituito dalle resistenze R12 e R13 serve per monitorare la carica della batteria e di conseguenza arrestare i cicli di irrigazione quando la tensione della batteria non assicura la commutazione dell’elettrovalvola.

Lo schema seguente riguarda invece il circuito RTC:

questo circuito ha il compito sia di gestire la data e l’ora, ma anche di generare un segnale di allarme (programmato via software), collegato ad un pin di interrupr del microcontrollore, questo sistema mi permette di risvegliare il microcontrollore dallo stato di ibernazione, necessario per garantire bassi assorbimenti del circuito.

Il cuore della centralina è basato sul microcontrollore ATMEGA328P-PU:

al micro è collegato lo slot SD (la comunicazione avviene usando la SPI). Osserviamo anche il connettore connettore ISP, e il connettore UART per la comunicazione seriale.
L’elettrovalvola viene pilotata tramite un ponte ad H realizzato con dei transistors; lo schema è il seguente:

l’ultimo blocco dello schema elettrico riguarda la selezione del tempo di irrigazione e dell’intervallo di tempo tra una irrigazione e la successiva:

Il segnale TMR_TIME e TMR_DATE sono collegati a due ingressi analogici del microcontrollore.

Di seguito il circuito elettrico della centralina di micro irrigazione:

Descrizione dello schema elettrico

Il microcontrollore ha il compito di gestire tutte le periferiche collegate alle sue line GPIO. La caratteristica principale di una centralina di questo tipo è il bassissimo assorbimento di corrente; supponendo di alimentare il circuito con una batteria (tipicamente una 9v o nel mio caso 8 batterie stilo alcaline tipo AA) dobbiamo garantire la durata di funzionamento per diversi mesi (naturalmente questo dato dipende dalla capacità della batteria).

Per garantire un basso assorbimento il microcontrollore andrà messo in modalità basso consumo quando non esegue nessuna operazione. Una volta entrato in questa modalità il micro potrà essere risvegliato tramite watchdog oppure tramite interrupt esterno. Nel mio progetto il risveglio è gestito da un interrupt esterno, generato dall’RTC, perché in questo modo posso gestire tempi di standby molto più prolungati rispetto al watchdog.

L’interrupt è generato dalla funzione alarm del modulo rtc MCP7940N. In pratica sul piedino 7 (sqw/MFP) viene generato un cambio di stato logico ogni volta che l’orario dell’ RTC corrisponde all’orario settato sul registro interno ALARM.

Il pilotaggio dell’elettrovalvola avviene utilizzando un ponte ad H costruito con dei transistors discreti. Lo schema permette di essere comandato tramite le uscite digitali del microcontrollore. I diodi schottky posti al centro del ponte H garantiscono l’eliminazione delle sovratensioni generate dalla commutazione del solenoide.

La selezione della durata dell’irrigazione e dell’intervallo tra una irrigazione e la successiva avviene utilizzando dei semplici jumper. I jumper sono posizionati in un partitore di tensione. L’uscita del partitore di tensione è collegata ad un ingresso analogico del microcontrollore. A seconda della posizione del jumper otterremo sull’ingresso analogico tensioni differenti. Dato che il partitore assorbe una cerca corrente, ho utilizzato dei transistor per alimentare il partitore solo quando voglio leggere la posizione dei jumper. I due transistors vengono pilotati da due uscite digitali del microcontrollore.

Assemblaggio e test della centralina

Ho dapprima realizzato il progetto utilizzando una basetta millefori, questo perché prima di realizzare il pcb volevo assicurarmi che tutto funzionasse come da progetto. Dopo qualche giorno di test ed aver avuto la certezza che lo schema non presentasse anomalie ho deciso di produrre il pcb.

Dopo aver montato i componenti sul pcb ho sistemato il circuito in una cassetta ermetica per impianti elettrici. Nella cassetta ho inserito anche la batteria. L’unico foro praticato è quello per fare uscire i due fili del solenoide dell’elettrovalvola.

Ho tenuto in osservazione il funzionamento della centralina per circa 2 mesi e mezzo e non ho avuto nessun problema. La posizione del circuito era abbastanza critica perchè rimaneva molto tempo esposta al sole. questa è stata una scelta voluta perché avevo bisogno di sotto porre il circuito a condizioni termiche estreme (giorni con temperature anche superiori ai 40°c). L’unico cosa che ho osservato è una deriva dell’orario dell’RTC, probabilmente perchè non ho eseguito la calibrazione.

In definitiva sono molto contento di questo lavoro perchè ho ottenuto bassi assorbimenti, un costo contenuto del progetto e una grande flessibilità nella programmazione delle irrigazioni.

The post Nuova centralina per impianto di microirrigazione appeared first on Esperimenti con logiche programmabili.

Molti tutorial sull’utilizzo di un RTCC (Real Time Clock and Calendar) con Arduino riguardano l’integrato DS1307 in quanto la sua diffusione è data dalla disponibilità di diverse librerie, dal costo contenuto e dalla sua integrazione in numerose shield. Nonostante ciò sul mercato esistono molti altri dispositivi interessanti che svolgono funzioni aggiuntive e hanno precisioni molto più elevate riguardo al conteggio del tempo.

Mi sono trovato a realizzare dei progetti che come specifica richiedevano una alimentazione di 3,3V, dato che il DS1307 lavora tra i 4,5V e i 5,5V ho dovuto ripiegare su un altro rtcc. Quello che ho scelto è l’MCP7940N prodotto da Microchip. Nonostante non sia disponibile la versione PDIP ho scelto questo integrato perché oltre a lavorare con tensione di alimentazione di 3,3V ha alcune altre funzioni interessanti come la possibilità di impostare due allarmi e la possibilità di calibrare l’orologio per poter aumentare la sua precisione nel conteggio del tempo.

Nella tabella seguente ho messo in comparazione le funzioni del DS1307 col MCP7940N

La gestione dei registri di questo integrato è molto semplice; è molto simile a quella del DS1307 e possiamo usare gran parte del codice usato in questo precedente articolo.

Passiamo alla pratica realizzando il seguente circuito elettrico. Lo schema è identico a quello utilizzato per il DS13017.

Il circuito utilizza il bus I2C per comunicare con l’integrato MCP7940N.

Andiamo a controllare il datasheet dell’ MCP7940N per vedere quali sono i registri che permettono il settaggio della data e dell’orario:

i registri che vanno dall’indirizzo 00h all’indirizzo 06h sono quelli che utilizzeremmo per impostare l’ora e la data. La modalità di scrittura di questi registri deve avvenire utilizzando la codifica BCD. Da notare che oltre al dato di tempo e di tata, ci sono alcuni bit che permettono di attivare alcune funzioni, ad esempio il registro 00h setta i secondi (dal bit0 al bit6) ma permette anche di avviare l’oscillatore (bit7 ST).
E’ possibile settare il bit7 manualmente, con la funzione bitSet(), oppure direttamente quando impostiamo il valore dei secondi servendoci di una maschera di bit. Vediamo subito con un esempio cosa dobbiamo fare.

Supponiamo di impostare il registro a 38 secondi. La prima cosa da fare è convertire il numero 38 in codice BCD utilizzando questa funzione:

// Converte un valore decimale in valore BCD
byte dec2bcd(byte val)
{
  return ( ((val / 10) * 16) + (val % 10));
}

il valore decimale 38 equivale al valore BCD 0b00111000.

Il valore decimale 38 viene convertito in valore BCD semplicemente convertendo le unità in codice binario e le decine in codice binario, infatti l’unità 8 equivale al valore binario 0b1000 mentre la decina 3 equivale al valore binario 0b0011. I due valori binari vengono concatenati per ottenere il valore BCD infatti 0b0011 concatenato con 0b1000 forma il valore BCD 0b00111000 (38 decimale)

Come possiamo osservare il bit7 del valore BCD è a valore logico basso. Per far partire l’oscillatore dovremmo impostare questo bit a valore logico alto. Questo può essere fatto utilizzando la funzione bitSet() o più semplicemente mascherando il valore BCD dei secondi con un valore binario che imposti il bit7 a livello alto, lasciando inalterato il valore BCD dei secondi.
Quest’ultima soluzione viene eseguita usando l’operatore | (bitwise or). Il valore della maschera deve tenere il bit7 a livello logico alto e lasciare invariato il valore dei secondi. Il valore della maschera da utilizzare sarà quindi 0b10000000 (0x80). In questo modo mettendo il valore 0b10000000 in or col valore BCD dei secondi 0b00111000 otterremmo il valore 0b10111000:

byte Maschera = 0x80;
byte valore_registro_00h = Secondi | Maschera;

Ora sappiamo come generare i dati in valore BCD e come mascherarli per attivare le funzioni aggiuntive dei registri quindi di seguito il codice che permette di impostare i registri dall’indirizzo 00h all’indirizzo 06h, con l’ora e la data:

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

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

  //attivo la comunicazione con il MCP7940N
  //l'indirizzo dell'RTC è 0x6F
  Wire.beginTransmission(0x6F);
  Wire.write(0x00);

  //specifico il tempo e la data
  Wire.write(dec2bcd(0) | 0x80); //Secondi e ST a livello logico alto
  Wire.write(dec2bcd(35)); //minuti
  Wire.write(dec2bcd(20) | 0x20);  // ore e formato 24h
  Wire.write(dec2bcd(4) | 0x08);  //giorno della settimana e VBAT on
  Wire.write(dec2bcd(3)); //Giorno
  Wire.write(dec2bcd(11)); //mese
  Wire.write(dec2bcd(16)); //anno
  Wire.endTransmission();

}

void loop()
{

}

//converte il numero decimale in numero BCD
byte bcd2dec(byte num)
{
  return (((num / 16) * 10) + (num % 16));
}

Leggere orario e data dall’MCP7940N

Dopo aver impostato data e ora e settato alcuni parametri (ST e VBATEN) il circuito RTCC MCP7940N autonomamente gestirà orario e data senza l’ausilio di istruzioni aggiuntive. A questo punto sarà sufficiente eseguire la lettura dei sette registri, da 00h a 06h, per ottenere le informazioni relative a data e ora correnti.

Il codice seguente mostra come eseguire la lettura dei registri e come elaborare i dati, in quanto i registri restituiscono i valori in formato BCD comprensivi dei bit di settagio (ST e VBATEN):

#include <Wire.h>

//struttura timeelements
tmElements_t tm;

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

  delay (500);

  //inizializzo la libreria
  Wire.begin();

}

void loop()
{
  //leggere registri MCP7940N
  //inizzializza la trasmissione partendo
  //dall'indirizzo 0x00
  Wire.beginTransmission(0x6F);
  Wire.write(0x00);
  Wire.endTransmission();

  //richiedo 7 byte dal dispositivo con
  //indirizzo 0x6F
  Wire.requestFrom(0x6F, 7);
  //regupero i 7 byte relativi ai
  //corrispondenti registri
  tm.Second = bcd2dec(Wire.read() & 0x7f); //secondi 
  tm.Minute = bcd2dec(Wire.read()); //minuti
  tm.Hour = bcd2dec(Wire.read() & 0x3f); //ore
  tm.Wday = bcd2dec(Wire.read() & 0x07); //giorno settimana
  tm.Day = bcd2dec(Wire.read()); //giorno
  tm.Month = bcd2dec(Wire.read() & 0x1F ); //mese 
  tm.Year = bcd2dec(Wire.read()); //anno

  Serial.print("Orario corrente: ");
  Serial.print(tm.Hour);
  Serial.print(":");
  Serial.print(tm.Minute );
  Serial.print(":");
  Serial.println(tm.Second);

  Serial.print("Giorno della settimana: ");
  Serial.println(tm.Wday);

  Serial.print("Data corrente: ");
  Serial.print(tm.Day);
  Serial.print("/");
  Serial.print(tm.Month);
  Serial.print("/");
  Serial.println(tm.Year);

}

//Converti numero BCD in numero Decimale
byte bcd2dec(byte num)
{
  return (((num / 16) * 10) + (num % 16));
}

Nel codice possiamo osservare come vengono mascherati i dati letti tramite un l’operatore & (bitwise and). Sapendo che i registri contengono bit che permettono di settare o resettare delle funzioni aggiuntive dell’MCP7940N, dobbiamo necessariamente escluderli dalla lettura per ottenere solamente il dato relativo al tempo.

Nel caso del registro 00h abbiamo che, oltre al dato dei secondi, è presente anche il bit7 (ST) che deve essere escluso quando convertiamo il valore BCD in decimale. Tramite l’operatore & e la maschera 0x7f (0b01111111) otteniamo un comportamento di questo tipo; supponiamo che il dato letto dal registro sia 0b10111000, mascherando questo dato con il valore 0b01111111 otteniamo 0b00111000.

In conclusione, risulta molto semplice scrivere e leggere dai registri dell’MCP7940N, dobbiamo solo stare attenti nell’utilizzo delle maschere di bit che ci permettano, in fase di scrittura, di inserire i dati di data e tempo insieme ai settaggi che abilitano alcune funzionalità, mentre, in fase di lettura, di ottenere i dati di tempo filtrando i settaggi delle funzionalità.

The post Arduino come utilizzare l’RTCC MCP7940N appeared first on Esperimenti con logiche programmabili.

Il ricevitore GPS (Global Positioning System) è oggi un dispositivo alla portata di tutti, dal costo contenuto e dal semplice utilizzo. Questo articolo vuole essere una guida introduttiva all’interpretazione dei dati di posizione forniti dal ricevitore gps, senza utilizzare librerie esterne. Ho utilizzato una scheda Arduino/Genuino UNO e il modulo Adafruit Ultimate GPS Breakout v3 (vedi l’articolo su Amazon).

Il modulo ha una sensibilità di ben -165dBm (in tracking), questo significa che riesce a rilevare segnali di 1.25nVolt, ha un refresh di 10 Hz e permette di ‘inseguire’ 22 satelliti.

Questo dispositivo rende semplice la gestione del tracking dei satelliti ed del calcolo della posizione. I dati vengono restituiti sul canale seriale TTL, alla frequenza di 1Hz. E’ sufficiente collegarsi alla seriale per poter leggere i dati. I dati principali sono quelli di posizione (espressa in Latitudine e Longitudine) la quota e l’orario zulu ma sono presenti anche altre informazioni relative ai satelliti utilizzati per il fix.

Lo schema elettrico seguente mostra i collegamenti da effettuare tra una UNO e la Adafruit Ultimate GPS Breakout v3:

Questo schema serve per inviare direttamente sul Serial Monitor i dati restituiti dal modulo gps. Il segnale trasmesso dal dispositivo viene convogliato sulla linea di trasmissione seriale della UNO affinché possa raggiungere il pc attraverso la porta usb. Carichiamo sulla UNO uno sketch vuoto:

void setup() {
  // put your setup code here, to run once:

}

void loop() {
  // put your main code here, to run repeatedly:

}

Terminato l’upload del programma lanciamo il Serial Monitor e settiamo il bps a 9600. La schermata seguente illustra le stringhe generate dal ricevitore GPS.

Nel mio caso il sensore gps non aveva ancora agganciato i satelliti, i dati ricevuti indicano una latitudine e una longitudine pari a zero. Il led posto sul pcb indica quando avviene il fix dei satelliti, se il led lampeggia ogni secondo il gps sta cercando di agganciare i segnali dei satelliti, quando vengono agganciati il led lampeggia ogni 15 secondi. Il fix dei satelliti è funzione della posizione dell’antenna del sensore, in campo aperto, senza nessun ostacolo, avviene entro il minuto mentre se ci troviamo in posizioni a bassa copertura (ad esempio dentro casa) il sensore impiegherà molto più tempo e nei casi peggiori non riuscirà ad elaborare il segnale.

Per interpretare i dati è necessario conoscere quali informazioni vengono prodotte dal ricevitore gps. Sul Serial Monitor notiamo quattro righe con informazioni differenti che si ripetono ogni secondo. Queste stringhe iniziano tutte con il simbolo del dollaro e con un codice di cinque caratteri. Il codice specifica quali dati sono  presenti nella relativa stringa, in ogni stringa i dati vengono separati dalle virgole (campi), ulteriori informazioni possono essere apprese in seguendo questo link.

Le quattro stringhe sono riassunte nel box seguente:

$GPGGA,235951.800,,,,,0,00,,,M,,M,,*79
$GPGSA,A,1,,,,,,,,,,,,,,,*1E
$GPRMC,235951.800,V,,,,,0.00,0.00,050180,,,N*40
$GPVTG,0.00,T,,M,0.00,N,0.00,K,N*32

La stringa che inizia con $GPGGA (Global Positioning System Fix Data), contiene le informazioni della latitudine, della longitudine, della quota e del tempo.
La stringa che inizia con $GPGSA, contiene dati relativi al DOP (Diluizione della precisione) e al prn (pseudo random noise) dei satelliti utilizzati per il fix.
La stringa che inizia con $GPRMC indica il valore minimo raccomandato dei dati di tempo, velocità e posizione.
La stringa che inizia con $GPVTG indica il Track made good e il valore di Groud Speed.

La stringa che ci interessa maggiormente è quella che inizia con $GPGGA perché contiene i dati di posizione ed il tempo. Il codice che andremo a scrivere recupererà i dati separandoli dalle virgole.

Modifichiamo il circuito precedente perché ci serve sia la seriale hardware sia quella software. La seriale software la useremmo per ricevere i dati dal sensore gps mentre la seriale hardware la useremmo per inviare i dati al pc:

Verifichiamo con questo codice che i dati ricevuti dalla seriale software (attivata sul pi 2 e 3) vengano ritrasmessi al pc impiegando la seriale hardware:

#include <SoftwareSerial.h>

//pin 2 RX e pin 3 TX
SoftwareSerial mySerial(2, 3);

void setup() {
  //init seriale hardware
  Serial.begin(9600);
  //init seriale software
  mySerial.begin(9600);
}

void loop() {
  //controllo se nella seriale software ci sono dati
  if (mySerial.available()) {
    //se sono presenti dati leggili ed inviali
    //alla seriale hardware
    Serial.write(mySerial.read());
  }
}

Con questo codice otterremmo sul Serial Monitor gli stessi dati ottenuti col primo esempio.
Naturalmente se è avvenuto il fix del segnale, i campi delle stringhe viste in precedenza conterranno i dati di posizione e orario, inoltre ne otterremmo anche una quinta  che inizierà per $GPGSV (indica nel dettaglio i parametri dei satelliti agganciati), quindi il risultato sarà qualcosa del genere:

$GPGSV,3,1,11,03,03,111,00,04,15,270,00,06,01,010,00,13,06,292,00*74
$GPGSV,3,2,11,14,25,170,00,16,57,208,39,18,67,296,40,19,40,246,00*74
$GPGSV,3,3,11,22,42,067,42,24,14,311,43,27,05,244,00,,,,*4D
$GPGGA,235317.000,4003.9039,N,10512.5793,W,1,08,1.6,1577.9,M,-20.7,M,,0000*5F
$GPGSA,A,3,19,28,14,18,27,22,31,39,,,,,1.7,1.0,1.3*35 
$GPRMC,225446,A,4916.45,N,12311.12,W,000.5,054.7,191194,020.3,E*68 
$GPVTG,360.0,T,348.7,M,000.0,N,000.0,K*43

Ora cercherò di isolare la stringa che inizia con $GPGGA. Per prima cosa ho modificato il codice per concatenare i caratteri ricevuti sulla seriale software in un oggetto stringa in questo modo potrò elaborarla usando i metodi della classe String:

#include <SoftwareSerial.h>

//pin 2 RX e pin 3 TX
SoftwareSerial mySerial(2, 3);
String NMEA;

void setup() {
  //init seriale hardware
  Serial.begin(9600);
  //init seriale software
  mySerial.begin(9600);
}

void loop() {
  if (mySerial.available()) {
    //leggo la prima riga
    char c = mySerial.read();
    if (c != '\n') {
      NMEA += c;
    }
    else {
      Serial.println(NMEA);
      //resetto la stringa
      //altrimenti accoderei tutti i caratteri ricevuti!
      NMEA = "";
    }
  }
}

Ottenute solo le stringhe ho la possibilità di capire come inizia la stringa, ad esempio il metodo subString restituisce una sotto stringa in funzione degli argomenti passati nei parametri. Il codice seguente invia al Serial Monitor solo le stringhe che iniziano con $GPGGA:

#include <SoftwareSerial.h>

//pin 2 RX e pin 3 TX
SoftwareSerial mySerial(2, 3);
String NMEA;

void setup() {
  //init seriale hardware
  Serial.begin(9600);
  //init seriale software
  mySerial.begin(9600);
}

void loop() {
  if (mySerial.available()) {
    //leggo la prima riga
    char c = mySerial.read();
    if (c != '\n') {
      NMEA += c;
    }
    else {
      //printo solo la stringa che mi interessa
      //quella che inizia con GPGGA
      //substring estrapola dalla stringa usando come parametri
      //la posizione iniziale e finale in questo caso 
      //parte dalla posizione 0 alla posizone 6
      if(NMEA.substring(0,6) == "$GPGGA")      
        Serial.println(NMEA);
      //resetto la stringa  
      NMEA = "";
    }
  }
}

Ho così isolato la stringa che mi interessa maggiormente. Continuo la scrittura del codice con alcune istruzioni che mi permettono di estrapolare i dati separati dalle virgole, quindi utilizzerò il metodo indexOf per passare i parametri al metodo subString:

#include <SoftwareSerial.h>

//pin 2 RX e pin 3 TX
SoftwareSerial mySerial(2, 3);
String NMEA;
int posizione_delimitatore = 0;
int index = 0;

void setup() {
  //init seriale hardware
  Serial.begin(9600);
  //init seriale software
  mySerial.begin(9600);
}

void loop() {
  if (mySerial.available()) {
    //leggo la prima riga
    char c = mySerial.read();
    if (c != '\n') {
      NMEA += c;
    }
    else {
      posizione_delimitatore = 0;
      //indice di partenza zero
      index = 0;
      //printo solo la stringa che mi interessa
      if (NMEA.substring(0, 6) == "$GPGGA")
      {
        //Serial.println(NMEA);
        //fino a che il metodo indexOf non restituisce -1
        //elabora la stringa
        while (posizione_delimitatore != -1)
        {
          //ottieni la posizione della prima virgola 
          posizione_delimitatore = NMEA.indexOf(",", index);
          //invia al Serial Monitor la sotto stringa usando come indice
          //il dato ottenuto da indexOf
          Serial.println(NMEA.substring(index, posizione_delimitatore));

          //memorizza il nuovo indice di partenza
          index = posizione_delimitatore;
          //incrementa l'indice di 1 per escludere la
          //virgola 
          index++;
        }
      }
      //resetta la stringa
      NMEA = "";
    }
  }
}

Il risultato sarà qualcosa del genere:

$GPGGA,152454.000,4003.1968,N,10512.5793,E,1,05,1.56,890.9,M,48.0,M,,*6A
$GPGGA
152454.000
4003.1968
N
10512.5793
E
1
05
1.56
890.9
M
48.0
M

*6A

Il codice suddivide correttamente tutti i campi. Molti di questi dati possono essere ulteriormente filtrati, ad esempio a me interessa ottenere il dato di tempo, la latitudine, la longitudine e la quota. Il codice seguente invia al Serial Monitor solo questi campi:

#include <SoftwareSerial.h>

//pin 2 RX e pin 3 TX
SoftwareSerial mySerial(2, 3);
String NMEA;
int posizione_delimitatore = 0;
int index = 0;
int campo = 0;

void setup() {
  //init seriale hardware
  Serial.begin(9600);
  //init seriale software
  mySerial.begin(9600);
}

void loop() {
  if (mySerial.available()) {
    //leggo la prima riga
    char c = mySerial.read();
    if (c != '\n') {
      NMEA += c;
    }
    else {
      posizione_delimitatore = 0;
      index = 0;
      //questa variabile viene usata per contare tutti i campi trovati
      campo = 0;
      //printo solo la stringa che mi interessa
      if (NMEA.substring(0, 6) == "$GPGGA")
      {
        //Serial.println(NMEA);

        while (posizione_delimitatore != -1)
        {
          posizione_delimitatore = NMEA.indexOf(",", index);

          //in funzione del campo invio al serial monitor
          //solo i dati che mi interessano
          switch (campo)
          {
            case 2:
            case 4:
            case 9:
              Serial.println(NMEA.substring(index, posizione_delimitatore));
              break;
          }

          index = posizione_delimitatore;
          index++;
          //incrementa il campo trovato
          campo++;
        }
      }
      NMEA = "";
    }
  }
}

Abbiamo cosi ottenuto il recupero dei dati di posizione e tempo senza utilizzare una libreria esterna. Le librerie rendono tutto più semplice e veloce ma credo che sia altrettanto importante capire cosa avviene dietro le quinte.

I dati ottenuti sono pronti per l’utilizzo in tutti quei progetti cui è necessario recuperare la posizione geografica e il tempo corrente.

The post Arduino gps ottenere coordinate geografiche e orario appeared first on Esperimenti con logiche programmabili.

Se anche tu hai difficoltà a ricordare le date degli appuntamenti e sei un tipo creativo e non ti accontenti dei classici promemoria via cellulare, tablet o computer, ma vuoi realizzare qualcosa di insolito, puoi sfruttare la tua passione per l’elettronica e la tua voglia di costruire per realizzare questo progetto di promemoria con Arduino.

Avendo già le basi per poter lavorare con l’integrato RTC DS1307 puoi sfruttare la ram non volatile di questo chip per memorizzare circa 18 date e permettere, ad Arduino, di avvisarti tramite display, led rgb, twitter o quello che ti viene in mente!!

L’idea è quella di utilizzare l’RTC per memorizzare il dato di tempo e sfruttare i 56 byte di flash ram aggiuntive per memorizzare le date degli avvenimenti. Arduino ha il compito di comparare le date e di agire di conseguenza pilotando le uscite digitali.

Parto dal presupposto che la data e l’ora del RTC sia già stata impostata come spiegato nel precedente tutorial.
Per memorizzare le date degli avvenimenti possiamo usare un array di 3 byte (Giorno Mese ed Anno), il codice è il seguente:

[c]
//inserisco la libreria per il bus I2C
#include <Wire.h>

//Variabile per memorizzare l’indirizzo della ram del DS1307
byte IndRam = 0x00;
//array per la data (G M A)
byte Data[3];

void setup()
{
//init bus I2C
Wire.begin();
//init seriale
Serial.begin(9600);

//imposto l’indirizzo iniziale della user ram
IndRam = 0x08;

//avvio la comunicazione con il DS1307
//indirizzo 0x68
Wire.beginTransmission(0x68);
//specifico l’indirizzo a cui voglio accedere
Wire.write(IndRam);

//imposto la data 25/04/12 in esadecimale
Data[0] = 0x19; //giorno 25
Data[1] = 0x04; //mese   04
Data[2] = 0x0C;  //anno   12

//scrivo i 3 byte negli indirizzi 0x08 0x09 0x0A
Wire.write(Data,3);

//chiudo la comunicazione
Wire.endTransmission();

}

void loop()
{}

[/c]

Nel datasheet del DS1307 la ram aggiuntiva inizia all’indirizzo 0x08 e finisce all’indirizzo 0x3F e, sapendo che per memorizzare una data servono 3 byte (G M A), devi sommare alla variabile IndRam valori multipli di 3.
Ad esempio per memorizzare la seconda data IndRam varrà 0x08 + 3 per la terza data 0x08+6 e cosi via fino a 0x08+51, ottenendo così 18 date memorizzabili.

Una volta memorizzate le date che ci interessano, è necessario scrivere del codice che confronti questi valori con quelli dell’RTC e di conseguenza eseguire delle operazioni di output.

Per primo recupero il giorno, mese e anno dell’RTC a partire dall’indirizzo  0x04

e poi recupero i dati della user ram per eseguire il confronto quindi:

[c]

void loop()
{
IndRam = 0x04;

//setto l’indirizzo da ddove iniziare
//a leggere
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

//recupero 3 byte G M A
Wire.requestFrom(0x68, 3);
byte Giorno = Wire.read();
byte Mese = Wire.read();
byte Anno = Wire.read();

Serial.print(Giorno, DEC);
Serial.print("/");
Serial.print(Mese,DEC);
Serial.print("/");
Serial.println(Anno, DEC);

//recupero tutte le date memorizzate nella user ram
//e le confronto con quella attuale dell’RTC

for( byte Ciclo = 0; Ciclo < 54; Ciclo += 3)
{
IndRam = 0x08 + Ciclo;
//Serial.println(IndRam, HEX);

Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

Wire.requestFrom(0x68, 3);
byte memGiorno = Wire.read();
byte memMese = Wire.read();
byte memAnno = Wire.read();

//confronta i dati

if(Giorno == memGiorno && Mese == memMese && Anno == memAnno)
{
//trovata data
//fai qualcosa
Serial.println("Data OK");
}

delay(10);
}

delay(1000);
}
[/c]

Il codice controlla ciclicamente se la data impostata nell’RTC è presente nella user ram in caso affermativo viene printata la stringa Data OK.
Il codice ha un problema, non tiene conto dell’andamento temporale, infatti viene fatto un controllo di valori che non permette di verificare se una data è precedente o successiva a quella impostata.
Il compito del codice dovrebbe essere quello di avvisarci degli avvenimenti futuri mentre dovrebbe escludere quelli passati.

Per poter confrontare le date tra di loro mi sono avvalso della libreria Time che tra le varie funzioni permette di restituire il numero di secondi trascorsi tra il 1 gennaio 1970 e una data definita.
Ottenendo un numero progressivo posso confrontare due date e capirne l’ordine temporale.

Installare e utilizzare la libreria Time

Sul sito ufficiale di Arduino, seguendo questo link possiamo scaricare la libreria. Scompattiamo il file zip nella cartella Arduino 1.0->libraries. Questa operazione produrrà tre cartelle una con nome Time, DS1307RTC e TimeAlarms. Riavviamo l’IDE per aggiornare le lista delle librerie e degli esempi.

Per utilizzare la libreria nello sketch del progetto che stiamo sviluppando, possiamo inserire a mano la clausola

[c]#include <Time.h>[/c]

oppure dal menu dell’ide eseguiamo Sketch->Import Library->Time

Per ottenere i secondi trascorsi dal 1 gennaio 1970 è disponibile la funzione now(), ma prima, giustamente bisogna settare la data di riferimento, per farlo si utilizza la funzione setTime(ora, minuti, secondi, giorno, mese, anno) quindi il codice precedente viene modificato così:

[c]
#include <Wire.h>
//includo la libreria Time
#include <Time.h>

byte IndRam = 0x00;
byte Data[3];

byte val = 0x00;

//queste variabili servono per memorizzare
//la data in secondi trascorsi dal 1 gen 1970
unsigned long UnixData = 0;
unsigned long memUnixData = 0;

void setup()
{
Wire.begin();
Serial.begin(9600);

//imposto l’indirizzo iniziale della user ram
IndRam = 0x08;

//carico una data da ricordare nei primi
//3 byte della user ram
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Data[0] = 0x05; //giorno 05
Data[1] = 0x04; //mese 04
Data[2] = 0x0C; //anno 12
Wire.write(Data,3);
Wire.endTransmission();

delay(100);

//verifico la data appena impostata
//nella user ram
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

Wire.requestFrom(0x68, 3);
byte data = Wire.read();
Serial.print(data);
Serial.print("/");
data = Wire.read();
Serial.print(data);
Serial.print("/");
data = Wire.read();
Serial.print(data);
Serial.println("/");

delay(100);
}

void loop()
{
//setto l’indirizzo per accedere alla data
//impostata nell’RTC
IndRam = 0x04;
//setto l’indirizzo da dove iniziare
//a leggere
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

//recupero 3 byte G M A
Wire.requestFrom(0x68, 3);
byte Giorno = Wire.read();
byte Mese = Wire.read();
byte Anno = Wire.read();

//visualizzo la data dell’RTC
Serial.print(Giorno, DEC);
Serial.print("/");
Serial.print(Mese,DEC);
Serial.print("/");
Serial.println(Anno, DEC);

//setto la libreria Time con la data dell’RTC
setTime(0,0,0, Giorno, Mese, (Anno + 2000));
//Recupero i secondi trascorsi tra la data 1 Gen 1970
//e la data dell’RTC
UnixData = now();
//Visualizzo i secondi trascorsi sul Serial Monitor
Serial.println(now());

//recupero tutte le date memorizzate nella ram
//e le confronto con quella attuale dell’RTC
//trasformandole in secondi in modo da poter confrontare
//le date

for( byte Ciclo = 0; Ciclo < 54; Ciclo += 3)
{
//imposto il primo indirizzo della user ram
//e poi proseguo ciclicamente incrementando di
//3 posizioni
IndRam = 0x08 + Ciclo;
//Serial.println(IndRam, HEX);

//setto l’indirizzo
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

//recupero i tre byte G M A
//dalla user RAM
Wire.requestFrom(0x68, 3);
byte memGiorno = Wire.read();
byte memMese = Wire.read();
byte memAnno = Wire.read();

//imposto la libreria Time con la data dela user RAM
// per convertirla in secondi
setTime(0,0,0, memGiorno, memMese, (memAnno + 2000));
memUnixData = now();
//Serial.println(now());

//confronto la data in secondi dell’RTC con la data
//appena recuperata dalla user ram

if(UnixData == memUnixData)
{
//trovata data
//fai qualcosa
Serial.println("TROVATA!!!");
}

delay(10);
}

delay(1000);
}
[/c]

Il codice ha lo stesso comportamento di quello iniziale ma adesso c’è la possibilità di eseguire il confronto numerico grazie alla conversione in secondi. Ad esempio per escludere tutte le date passate possiamo fare questa semplice modifica

[c]

//escludi le date passate

if(UnixData >= memUnixData)
{
//trovata data
//fai qualcosa
Serial.println("TROVATA!!!");
}

[/c]

oppure eseguire del codice per avvisarci una settimana in anticipo:

[c] //avvisami una settimana prima
//settimana in secondi 60*60*24*7 = 604800

if((memUnixData – UnixData) <= 604800)
{
//trovata data
//fai qualcosa
Serial.println("TROVATA!!!");
}
[/c]

Avendo il modo di eseguire un confronto numerico tra le date ci offre la possibilità di realizzare ulteriori funzioni, come ad esempio sketch che gestiscono l’Arduino a seconda delle date impostate nella user ram.

Per le operazioni da eseguire quando viene trovata una data possiamo eseguire tutte le tipiche funzioni di output che può gestire Arduino.

[c]
//escludi le date passate
if(UnixData >= memUnixData)
{
//trovata data
//fai qualcosa
Serial.println("TROVATA!!!");
}
[/c]

The post Promemoria alternativo con Arduino e RTC 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.

Solitamente quando ho il bisogno di avere un riferimento temporale, che risulta ininfluente dalle mancanze di alimentazione o da riavvi casuali della scheda, utilizzo un RTC esterno, tipicamente un DS1307. La soluzione fornita dalla Fez Panda II impiega un rtc on board che necessita solamente di una batteria tampone esterna, tipicamente quella utilizzata nei computer da 3.3Vdc.

La prima operazione da effettuare, dopo aver collegato la batteria tampone tra il pin BAT e il pin GND, è l’inizializzazione dell’RTC con una data ed un ora valida:

[csharp]
//Setto la data e l’ora per l’RTC
//Anno, Mese, Giorno, Ora, Minuti, Secondi
RealTimeClock.SetTime(new DateTime(2012, 02, 23, 12, 0, 0));
[/csharp]

questo settaggio non agisce automaticamente sulle impostazioni di data ed ora della classe DateTime, ma è soltanto il metodo per inizzializzare l’RTC.

Per poter leggere la data ed il tempo è necessario utilizzare la classe Utility per settare il local time con quello dell’RTC

[csharp]
//Leggo la data ed il tempo dall’RTC e lo assegno al local time
Utility.SetLocalTime(RealTimeClock.GetTime());
[/csharp]

Adesso la classe DateTime ha come riferimento la data e l’ora dell’RTC, posso richiamarla utilizzando questo esempio

[csharp]
//visualizzo a console la data e l’ora corrente
Debug.Print(DateTime.Now.ToString());
[/csharp]

Queste poche linee di coidce permettono di gestire l’RTC on board della Fez Panda II e di implementare ne progetti un sistema basato sul tempo.

The post Usare l’RTC della Fez Panda II appeared first on Esperimenti con logiche programmabili.