Schema con Microcontrollore PIC per Realizzare un Orologio con Data e Ora Con il Modulo DS3231 e la Possibilità di Regolazione…
INTRO
Il seguente schema va ad eseguire tutte le funzioni viste nel tutorial sul modulo DS3231 per realizzare un orologio con data e ora precise al secondo con la possibilità di regolare data e ora grazie a due pulsanti. Si utilizza un microcontrollore PIC16F877 per controllare il modulo RTC (Real Time Clock) e LCD che viene utilizzato per mostrare data e ora. La scelta del PIC16f877 è stata quasi obbligata visto che utilizzando un PIC18F252 quando su utilizzava il programma “FixHex” prima di andare a programmare il PIC il programma va a cambiare alcuni parti del codici creando problemi di funzionamento. Il codice funziona con tutti i microcontrollori che hanno internamente il modulo SPI, l’importante è usare un PIC16 se si ha a disposizione solo il programmatore K150.
Oltre a contare il tempo e visualizzarlo su display LCD è possibile regolare data e ora, funzione utile alla prima accensione oppure in caso di mancanza di tensione di alimentazione del modulo. In pratica vengono utilizzati due pulsanti, uno seleziona se regolare l’anno, il mese, il giorno, l’ora, i minuti o i secondi, mentre l’altro pulsante incrementa il valore di queste variabili , portandole al valore iniziale automaticamente quando si raggiunge il valore massimo per gli anni ad esempio 2099.
Il giorno (Lunedì, Martedì….) non viene visualizzato in quanto non è proprio necessario, ma con una piccola modifica è possibile visualizzare anche questa informazione. La regolazione massima per il giorno del mese è 31, il che non considera i mesi con meno giorni. Bisogna stare attenti a caricare il giorno giusto per il mese giusto, altrimenti il modulo DS3231 ritorna al valore 1 di giorno. Con una piccola modifica si può dare una intelligenza maggiore al sistema di regolazione.
CODICE
Il codice è il seguente:
sbit LCD_RS at RB2_bit; //Connessioni LCD
sbit LCD_EN at RB3_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_RS_Direction at TRISB2_bit;
sbit LCD_EN_Direction at TRISB3_bit;
sbit LCD_D4_Direction at TRISB4_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D7_Direction at TRISB7_bit;
unsigned short sec absolute 0x0020; //Variabili data e ora
unsigned short minute absolute 0x0021;
unsigned short hour absolute 0x0022;
unsigned short day absolute 0x0024;
unsigned short month absolute 0x0025;
unsigned short year absolute 0x0026;
unsigned short dato absolute 0x0023;
unsigned char regolazione = 0; //Variabile regolazione
unsigned char time[9]; //Stringhe di caratteri
unsigned char ddate[11];
char text[4];
const unsigned char SECONDS_ADDRES=0x00; //Indirizzi modulo DS3231
const unsigned char MINUTES_ADDRES=0x01;
const unsigned char HOURS_ADDRES =0x02;
const unsigned char WEEKDAY_ADDRES=0x03;
const unsigned char DAY_ADDRES =0x04;
const unsigned char MONTHS_ADDRES =0x05;
const unsigned char YEAR_ADDRES =0x06;
void Write_CMD_DS3231(unsigned char address,unsigned char dato){ //Sottoprogramma scrittura comandi
if(address == 0x0E || address == 0x0F){ //Se l'indirizzo è 0x0E o 0x0F
I2C1_Start(); //Inizializza I2C Scrivi 0xD0
I2C1_Wr(0xD0); //Scrivi indirizzo
I2C1_Wr(address); //Scrivi il dato
I2C1_Wr(dato); //Ferma I2C
I2C1_Stop();
}
}
unsigned char Read_TIMER_DS3231(unsigned char address){ //Sottoprogramma lettura data e ora
unsigned char value;
if((address>=0x00)&&(address<=0x06)){ //Se l'indirizzo è compreso
I2C1_Start(); //tra quelli di data e ora inizializza I2C
I2C1_Wr(0xD0); //Scrivi 0xD0
I2C1_Wr(address); //Scrivi indirizzo
I2C1_Repeated_Start(); //Se vi sono problemi ripeti lo start
I2C1_Wr(0xD1); //Scrivi 0xD1
value = I2C1_Rd(0); //Leggi I2C
I2C1_Stop(); //Stop I2C
return(value);
}
}
unsigned char BCDUpperPart(unsigned char bcd_var){ //Sottoprogramma BCD to decimale
return (((bcd_var & 0xF0)>>4)|0x30);
}
unsigned char BCDLowerPart(unsigned char bcd_var){ //Sottoprogramma BCD to Decimale
return ((bcd_var & 0x0F)|0x30);
}
unsigned char IntToBCD (unsigned char int_var ){ //Sottoprogramma da decimale a BCD
return Dec2Bcd(int_var);
}
void Write_TIMER_DS3231(unsigned char address,unsigned char dato){ //Sottoprogramma scrittura data e ora
if((address>=0x00)&&(address<=0x06)){ //Se l'indirizzo è quello di data e ora
I2C1_Start(); //Scrivi indirizzo e dato
I2C1_Wr(0xD0);
I2C1_Wr(address);
I2C1_Wr(dato);
I2C1_Stop();
}
}
void Write_RAM_DS3231(unsigned char address,unsigned char dato){ //Sottoprogramma scrittura EEprom
if((address>=0x14)&&(address<=0xFF)){ //Se l'indirizzo è quello della EEProm
I2C1_Start(); //Avvia scrittura
I2C1_Wr(0xD0);
I2C1_Wr(address);
I2C1_Wr(dato);
I2C1_Stop();
}
}
unsigned char Read_RAM_DS3231(unsigned char address){ //Sottoprogramma lettura EEprom
unsigned char value;
if((address>=0x14)&&(address<=0xFF)){ //Se l'indirizzo è quello della EEProm
I2C1_Start(); //Avvia lettura
I2C1_Wr(0xD0);
I2C1_Wr(address);
I2C1_Repeated_Start();
I2C1_Wr(0xD1);
value = I2C1_Rd(0);
I2C1_Stop();
return(value);
}
}
void Display_Lcd_Time(unsigned char time_vect){ //Scrittura ora su LCD
time[0] = BCDUpperPart(hour); //Scrivi ora
time[1] = BCDLowerPart(hour);
time[2] = ':'; //scrivi :
time[3] = BCDUpperPart(minute); //Scrivi minuti
time[4] = BCDLowerPart(minute);
time[5] = ':'; //Scrivi :
time[6] = BCDUpperPart(sec); //Scrivi secondi
time[7] = BCDLowerPart(sec);
time[8] = '\0';
Lcd_Out(1,7,time);
}
void Display_Lcd_Date(unsigned char ddate_vect){ //Scrittura Data su LCD
ddate[0] = BCDUpperPart(day); //Scrivi giorno
ddate[1] = BCDLowerPart(day);
ddate[2] ='.'; //Scrivi .
ddate[3] = BCDUpperPart(month); //Scrivi mese
ddate[4] = BCDLowerPart(month);
ddate[5] ='.'; //Scrivi .
ddate[6] = '2'; //Scrivi 20
ddate[7] = '0';
ddate[8] = BCDUpperPart(year); //Scrivi anno
ddate[9] = BCDLowerPart(year);
ddate[10] = '\0';
Lcd_Out(2,7,ddate);
}
void EXT_INT() iv 0x0004 ics ICS_AUTO { //Interrupt
Delay_ms(300);
regolazione ++; //Cambia regolazione
INTCON.INTF = 0; //reset del flag
}
void main(){ //PORTB0 e 1 Ingressi
TRISB.F0 = 1;
TRISB.F1 = 1;
INTCON.GIE = 1; //attivo gli interrupt
OPTION_REG.INTEDG = 1; //interrupt sul fronte di salita
INTCON.INTE = 1;
Lcd_Init(); // Initializza LCD
Lcd_Cmd(_LCD_CLEAR); //Puliscilo
Lcd_Cmd(_LCD_CURSOR_OFF); //Spegni cursore
Lcd_Out(1,3," NE555.IT"); //Scrivi sulla prima riga
Delay_ms(1000);
I2C1_Init(100000); //I2C a 100KHz
Write_CMD_DS3231(0x0E,0x00); //Configura modulo ds3231
Write_CMD_DS3231(0x0F,0xF8);
sec =0x00; //Inizializza data e ora
minute =0x00;
hour =0x00;
day =0x01;
month =0x01;
year =0x17;
Write_TIMER_DS3231(SECONDS_ADDRES,sec); //Scrivi nel modulod data e ora
Write_TIMER_DS3231(MINUTES_ADDRES,minute);
Write_TIMER_DS3231(HOURS_ADDRES,hour);
Write_TIMER_DS3231(DAY_ADDRES,day);
Write_TIMER_DS3231(MONTHS_ADDRES,month);
Write_TIMER_DS3231(YEAR_ADDRES,year);
while(1){ //Ciclo infinito
Lcd_Cmd(_LCD_CLEAR); //Scrivi data e ora
Lcd_Out (1, 1, "TIME:");
Lcd_Out (2, 1, "DATE:");
sec = Read_TIMER_DS3231(SECONDS_ADDRES); //Leggi data e ora e aggiorna
minute = Read_TIMER_DS3231(MINUTES_ADDRES);
hour = Read_TIMER_DS3231(HOURS_ADDRES);
day = Read_TIMER_DS3231(DAY_ADDRES);
month = Read_TIMER_DS3231(MONTHS_ADDRES);
year = Read_TIMER_DS3231(YEAR_ADDRES);
Display_Lcd_Time(time[9]); //Visualizza data e ora
Display_Lcd_Date(ddate[11]);
Delay_ms(200); //Aggiorna ogni 0.2secondi
while (regolazione == 1){ //Se regolazione = 1
Lcd_Out (1, 1, "ANNO:"); //mostra valore anno corrente anno
Lcd_Out_Cp("20");
ByteToStr(year, text);
Lcd_Out_Cp(text);
Lcd_Out_Cp(" "); //usa stringhe vuote per pulire spazi
Lcd_Out (2, 1, " ");
if(PORTB.F1 == 1){ //Se il tasto di incremento = 1
Lcd_Cmd(_LCD_CLEAR); //Pulisci LCD
year ++; //Incrementa anno
if(year == 100) year = 0; //Se anno = 100 ritorna il valore a 0
Delay_ms(200); //ritardo anti rimbalzo
}
}
while (regolazione == 2){ //Se regolazione = 2
Lcd_Out (1, 1, "MESE: "); //Regola mese
ByteToStr(month, text);
Lcd_Out_Cp(text);
Lcd_Out_Cp(" ");
if(PORTB.F1 == 1){ //Se incremento premuto
Lcd_Cmd(_LCD_CLEAR); //incrementa mese fino a 12
month ++;
if(month == 13) month = 1; //ritorna a 1 se >12
Delay_ms(200);
}
}
while (regolazione == 3){ //Se regolazione = 3
Lcd_Out (1, 1, "GIORNO: "); //Regola giorno
ByteToStr(day, text);
Lcd_Out_Cp(text);
Lcd_Out_Cp(" ");
if(PORTB.F1 == 1){ //se incremento premuto
Lcd_Cmd(_LCD_CLEAR); //Incrementa giorno
day ++;
if(day == 32) day = 1; //Attenzione, limite 31 per tutti i mesi
Delay_ms(200);
}
}
while (regolazione == 4){ //Se regolazione = 4
Lcd_Out (1, 1, "ORA: "); //Regola ora
ByteToStr(hour, text);
Lcd_Out_Cp(text);
Lcd_Out_Cp(" ");
if(PORTB.F1 == 1){
Lcd_Cmd(_LCD_CLEAR);
hour ++;
if(hour == 25) hour = 0;
Delay_ms(200);
}
}
while (regolazione == 5){ //Regolazione = 5 regola minuti
Lcd_Out (1, 1, "MINUTI: ");
ByteToStr(minute, text);
Lcd_Out_Cp(text);
Lcd_Out_Cp(" ");
if(PORTB.F1 == 1){
Lcd_Cmd(_LCD_CLEAR);
minute ++;
if(minute == 60) minute = 0;
Delay_ms(200);
}
}
while (regolazione == 6){ //Regolazione = 6 regola secondi
Lcd_Out (1, 1, "SECONDI: ");
ByteToStr(sec, text);
Lcd_Out_Cp(text);
Lcd_Out_Cp(" ");
if(PORTB.F1 == 1){
Lcd_Cmd(_LCD_CLEAR);
sec ++;
if(sec == 60) sec = 0;
Delay_ms(200);
}
}
if(regolazione == 7){ //Se regolazione = 7
regolazione = 0; //Resetta regolazione
Lcd_Cmd(_LCD_CLEAR);
sec = IntToBCD (sec); //Converti da decimali a BCD
minute = IntToBCD (minute);
hour = IntToBCD (hour);
day = IntToBCD (day);
month = IntToBCD (month);
year = IntToBCD (year);
Write_TIMER_DS3231(SECONDS_ADDRES,sec); //Inserisci i valori nel modulo DS3231
Write_TIMER_DS3231(MINUTES_ADDRES,minute);
Write_TIMER_DS3231(HOURS_ADDRES,hour);
Write_TIMER_DS3231(DAY_ADDRES,day);
Write_TIMER_DS3231(MONTHS_ADDRES,month);
Write_TIMER_DS3231(YEAR_ADDRES,year);
}
}
}
Prima di tutto si inizializzano le connessioni con il display LCD, indicando a quali pin esso è connesso. Successivamente vengono inizializzati i registri che contengono le variabili utili e le costanti dei registri per i comandi del modulo DS3231.
Il primo sottoprogramma “Write_CMD_DS3231” serve per scrivere un comando nel modulo DS3231 e si va ad inizializzare la comunicazione I2C, poi a scrivere l’indirizzo e successivamente il dato spegnendo in fine la comunicazione.
Il secondo sottoprogramma “Read_TIMER_DS3231” viene usato per leggere i dati dal modulo DS3231 e si va a scrivere l’indirizzo del registro da leggere e poi si legge la risposta.
I tre sottoprogrammi successivi vengono usati per convertire i dati da interi a BCD e da BCD a interi.
“Write_TIMER_DS3231” viene usato per scrivere nel registro ore, minuti, secondi, anno, mese e giorno e si va a inizializzare la comunicazione, scrivere il valore del registro da modificare e si scrive il dato.
“Write_RAM_DS3231” e “Read_RAM_DS3231” servono per scrivere e leggere dati dalla memoria sul modulo memoria.
Il sottoprogramma “Display_Lcd_Time” è utilizzato per mostrare a schermo l’ora e va a scomporre i tre elementi dell’orario in decine e unità e li mostra uno per volta con i due punti come separatore. Il programma successivo funziona alla stesso modo ma viene usato per la data utilizzando punto e virgola come separatore.
Il ciclo di interrupt “EXT_INT” è utilizzato per rilevare la pressione del pulsante di regolazione e va a incrementare una variabile chiamata regolazione che indica quale variabile andare ad aggiustare.
Nel programma principale si vanno ad inizializzare gli I/O prima di tutto, poi gli interrupt e successivamente il display e la comunicazione I2C con velocità 100KHz. Infine prima del ciclo infinito si va ad inizializzare il modulo DS3231.
Nel ciclo infinito si pulisce il display, si scrive data e ora e poi si leggono questi valori mostrandoli a schermo ogni 200ms. Per la regolazione si usa la variabile regolazione, se 1 si regola l’anno, 2 il mese, 3 il giorno, 4 l’ora, 5 i minuti, 6 i secondi e infine se regolazione=7 si va a memorizzare nel modulo data e ora regolata. Se regolazione = 7 si resetta la regolazione, si convertono i dati da interi a BCD e si vanno a scrivere con la funzione “Write_TIMER_DS3231”.
In ogni singolo “while” che controlla la regolazione viene visualizzata su LCD cosa si va a regolare e si va a visualizzare anche il valore. Se l’altro tasto è a livello logico alto allora si incrementa il valore da regolare ogni 200ms e se supera il massimo del valore consentito viene portato a livello iniziale. Tutti e sei i while svolgono le stesse funzioni.
La configurazione dei fuses è la seguente:
SCHEMA
Lo schema è il seguente:
La tensione di alimentazione è 5V continui e stabilizzati. Sia il modulo DS3231 che il microcontrollore sono alimentati da questa tensione a 5V inoltre il modulo ha la batteria al litio da 3V a bottone per far si che non si stoppi il conteggio anche se la tensione di alimentazione non è presente. Il PIC16F877A è alimentato tramite i pin 11 e 32 connessi alla tensione positiva e i pin 12 e 31 connessi alla massa dell’alimentazione. Anche il display LCD è connesso alla tensione di 5V con la retroilluminazione del display connessa tra il positivo e massa tramite una resistenza da 470 Ohm. C5 serve per filtrare la tensione.
Il microcontrollore viene mantenuto in stato di funzionamento grazie alla resistenza di pull-up R1 mentre il circuito di oscillazione da 8MHz è formato dal cristallo di quarzo X1 da 8MHz e da C1 e C2.
Il pulsante “REG” porta una tensione alta sul pin 33 quando premuto mentre R3 lo mantiene a livello basso. C4 viene usato come condensatore antirimbalzo. La stessa cosa vale per il pulsante “INC”, R2 e C3.
Il modulo DS3231 è connesso al microcontrollore tramite le linee SCL e SDA. Teoricamente servirebbe una resistenza di pull-up su queste linee ma esse sono già presenti nel modulo DS3231.
Lo schema montato su breadboard è il seguente:
DOWNLOAD
Potete scaricare la simulazione del circuito con PROTEUS e il codice compilato con MIKROC al seguente LINK!!!
