Pic16f877a sveglia digitale basata su microcontrollore

La rivoluzione digitale iniziata nel 1950 trasforma tutte le strutture elettroniche meccaniche e analogiche esistenti in computer digitali. Poiché la crescita dell'elettronica digitale è stata esponenziale, oggi è quasi impossibile per una persona resistere all'uso di qualsiasi apparecchiatura elettronica. A partire dalla sveglia che ti sveglia e dal tostapane che ti serve la colazione, tutto è un contributo dell'elettronica digitale. Pensando a tutto ciò è davvero eccitante programmare le nostre cose che potrebbero svolgere compiti semplici ma utili, come la sveglia che costruiremo in questo progetto con il microcontrollore PIC. Abbiamo già costruito una sveglia con altri microcontrollori:

• Sveglia Raspberry Pi utilizzando il modulo RTC DS1307
• Orologio digitale basato su Arduino con sveglia
• Sveglia utilizzando il microcontrollore ATmega32

Questa sveglia avrà un display LCD 16x2 che mostrerà l'ora corrente e l'ora impostata. Useremo pochi pulsanti per impostare l'ora della sveglia ogni volta che sarà necessario. L'ora corrente verrà tenuta traccia utilizzando il modulo RTC DS3231 e utilizzeremo la comunicazione IIC per ottenere questi valori dal modulo RTC. Abbiamo già imparato a conoscere il modulo RTC e come interfacciarlo con PIC. Quindi si consiglia di leggere quel tutorial, salteremo la maggior parte delle informazioni trattate in quel tutorial.

Materiali richiesti:

• Tagliere - 2Nos
• PIC16F877A
• Fonte di alimentazione 5V - Modulo di alimentazione
• Cristallo da 20 MHz
• Condensatore 33pf - 2Nos
• Modulo RTC DS3231
• Modulo display LCD 16 * 2
• 10K POT
• Resistenza da 10k e 1K
• Pulsanti - 5 n
• Cicalino
• Cavi di collegamento

Prerequisiti:

Questo progetto richiede che tu conosca alcune nozioni di base sul microcontrollore PIC e su come programmarlo. Useremo GPIO, display LCD e modulo RTC per questo progetto. Quindi è meglio imparare in anticipo come utilizzare questi moduli. I seguenti link ti aiuteranno a imparare lo stesso

• Scrivere il tuo primo programma con PIC Microcontroller
• Interfacciamento LCD con PIC
• Comunicazione I2C tramite PIC
• DS3231 RTC interfacciato con PIC

Schema elettrico:

Di seguito è mostrato lo schema del circuito per questo progetto di sveglia basato su PIC, creato utilizzando il software proteus. Il verrà utilizzato anche per ulteriori simulazioni in questo progetto.

I cinque pulsanti fungeranno da ingresso per impostare l'allarme per il tempo richiesto. Quindi un'estremità di tutti i pulsanti è collegata a terra e le altre estremità sono collegate al pin PORTB, su questi pin verrà utilizzata una resistenza di pull-up interna per evitare che i pin fluttuino. Il Buzzer agirà come un'uscita e ci darà un segnale acustico quando l'allarme viene attivato ed è collegato al pin PORT S. L'ora corrente è sempre tenuta traccia dal modulo RTC DS3231 dal quale il PIC riceve i dati tramite bus I2C, quindi i pin SCL e SDA del modulo RTC sono collegati ai pin SCL e SDA del controller PIC. Un display LCD è collegato al PORTD del PIC che viene utilizzato per visualizzare l'ora corrente e l'ora impostata. Ulteriori informazioni sull'utilizzo del modulo RTC DS3231 con PIC qui.

Il circuito completo può essere costruito su una breadboard. Poiché ci sono un paio di dozzine di cavi da collegare, abbi pazienza e assicurati che i collegamenti siano corretti. Una volta terminate le connessioni, la mia configurazione hardware era simile a questa di seguito

Ho usato un modulo breadboard e un adattatore 12V per alimentare il modulo. Questa è la mia fonte di tensione di alimentazione + 5V. Inoltre devo usare due breadboard per mantenere pulito il circuito. Puoi anche saldare l'intero circuito su una scheda perf se stai cercando di realizzare un progetto più robusto.

Programmazione per sveglia:

Il programma PIC completo per questo progetto Sveglia può essere trovato in fondo a questa pagina. Questo progetto richiede anche tre librerie per l'utilizzo di LCD, I2C e RTC con PIC. Il codice completo con i file di intestazione può essere scaricato dal file ZIP qui e può essere aperto utilizzando MPLABX dopo l'estrazione. Più in basso sto solo spiegando il file c principale come piccoli frammenti. Puoi tornare ai tutorial sopra menzionati se vuoi sapere come funzionano i file di intestazione.

Prima di entrare nel programma principale, dobbiamo definire i pin che abbiamo usato con un nome più significativo. In questo modo sarà facile utilizzarli durante la programmazione. Di seguito sono riportati i pin definiti nel nostro programma

// Definisci i pin LCD #define RS RD2 // Ripristina pin LCD #define EN RD3 // Abilita pin LCD #define D4 RD4 // Bit dati 0 dell'LCD #define D5 RD5 // Bit dati 1 dell'LCD #define D6 RD6 // Bit di dati 2 dell'LCD #define D7 RD7 // Bit di dati 3 dell'LCD // Definisci pulsanti #define MB RB1 // Il pulsante centrale #define LB RB0 // Pulsante sinistro #define RB RB2 // Pulsante destro # define UB RB3 // Pulsante superiore #define BB RB4 // Pulsante inferiore // Definisci buzz #define BUZZ RD1 // Il buzzer è collegato a RD1

All'interno della funzione principale iniziamo dichiarando i pin di input e output. Nel nostro progetto il PORTB viene utilizzato per i pulsanti che è un dispositivo di input, quindi impostiamo i loro pin come input e PORTD viene utilizzato per LCD e buzzer, quindi impostiamo i loro pin come Output. Inoltre, un pin non dovrebbe mai essere lasciato flottante, il che significa che i pin I / O devono essere sempre collegati a massa o alla tensione di + 5V. Nel nostro caso per i pulsanti i pin non saranno collegati a nulla quando il pulsante non viene premuto quindi utilizziamo una resistenza interna di pull-up che imposta il pin su High quando non in uso. Questo viene fatto utilizzando i registri di controllo come mostrato di seguito

TRISD = 0x00; // Rende i pin della porta D come outptu per l'interfacciamento LCD TRISB = 0xFF; // Gli interruttori sono dichiarati come pin di input OPTION_REG = 0b00000000; // Abilita resistenza pull up sulla porta B per switch BUZZ = 0; // Spegnimento del cicalino

Poiché abbiamo il file di intestazione LCD e I2C collegato al programma principale, possiamo avviare l'inizializzazione LCD chiamando una semplice funzione. Lo stesso può essere fatto anche per l' inizializzazione I2C. Qui stiamo iniziando la comunicazione I2C a 100kHz poiché il modulo RTC funziona con 100kHz.

Lcd_Start (); // Inizializza il modulo LCD I2C_Initialize (100); // Inizializza il master I2C con un clock di 100 KHz

La funzione seguente viene utilizzata per impostare l'ora e la data sul modulo RTC, una volta impostate l'ora e la data rimuovere questa riga. Altrimenti, ogni volta che si avvia il programma, l'ora e la data verranno impostate ancora e ancora

// Rimuovere la riga sottostante una volta che l'ora e la data sono state impostate per la prima volta. Set_Time_Date (); // imposta l'ora e la data sul modulo RTC

Per indicare che il programma si sta avviando, mostriamo una piccola schermata introduttiva che mostra il nome del progetto e il nome del sito web come mostrato di seguito

// Invia un messaggio introduttivo sull'LCD Lcd_Clear (); Lcd_Set_Cursor (1,1); Lcd_Print_String ("Sveglia"); Lcd_Set_Cursor (2,1); Lcd_Print_String ("-Circuit Digest"); __delay_ms (1500);

Successivamente, all'interno del ciclo while, dobbiamo leggere l'ora e la data correnti dal modulo RTC, questo può essere fatto semplicemente chiamando la funzione sottostante.

Update_Current_Date_Time (); // Legge la data e l'ora correnti dal modulo RTC

La chiamata alla funzione precedente aggiornerà le variabili sec, min e hour con il valore corrente. Per visualizzarli sullo schermo LCD dobbiamo dividerli in singoli caratteri utilizzando il codice sottostante.

// Divide il in char da visualizzare su lcd char sec_0 = sec% 10; char sec_1 = (sec / 10); char min_0 = min% 10; char min_1 = min / 10; char hour_0 = ora% 10; char ora_1 = ora / 10;

Successivamente, aggiorniamo i valori sullo schermo LCD. L'ora corrente verrà visualizzata nella prima riga e l'ora impostata in cui l'allarme deve essere attivato viene visualizzata nella seconda riga. Il codice che fa lo stesso è mostrato di seguito.

// Visualizza l'ora corrente sullo schermo LCD Lcd_Clear (); Lcd_Set_Cursor (1, 1); Lcd_Print_String ("TIME:"); Lcd_Print_Char (ora_1 + '0'); Lcd_Print_Char (hour_0 + '0'); Lcd_Print_Char (':'); Lcd_Print_Char (min_1 + '0'); Lcd_Print_Char (min_0 + '0'); Lcd_Print_Char (':'); Lcd_Print_Char (sec_1 + '0'); Lcd_Print_Char (sec_0 + '0'); // Visualizza la data sullo schermo LCD Lcd_Set_Cursor (2, 1); Lcd_Print_String ("Allarme:"); Lcd_Print_Char (alarm_val + '0'); Lcd_Print_Char (alarm_val + '0'); Lcd_Print_Char (':'); Lcd_Print_Char (alarm_val + '0 '); Lcd_Print_Char (alarm_val + '0');

Ora, abbiamo visualizzato l'ora e impostato l'ora sul display LCD, dobbiamo controllare se l'utente sta cercando di impostare l'ora della sveglia. Per fare ciò l'utente deve premere il pulsante centrale, quindi controlleremo se il pulsante centrale è stato premuto e alterneremo una variabile per entrare in modalità di impostazione della sveglia. Lo stesso pulsante verrà nuovamente premuto per confermare che i valori sono stati impostati e in tal caso si dovrà uscire dalla modalità di impostazione dell'allarme. Quindi usiamo la riga di codice sottostante per modificare lo stato della variabile set_alarm .

// Usa il pulsante centrale per verificare se l' allarme deve essere impostato if (MB == 0 && set_alarm == 0) {// Se il pulsante centrale viene premuto e l'allarme non è attivato mentre (! MB); // Attendi il rilascio del pulsante set_alarm = 1; // avvia l'impostazione del valore di allarme } if (MB == 0 && set_alarm == 1) {// Se viene premuto il pulsante centrale e l'allarme non viene disattivato mentre (! MB); // Attendi il rilascio del pulsante set_alarm = 0; // interrompi l'impostazione del valore di allarme }

Se l'utente ha premuto il pulsante centrale, significa che sta cercando di impostare l'ora della sveglia. In questo caso il programma entra in modalità impostazione allarme utilizzando il codice sopra. All'interno della modalità di impostazione dell'allarme se l'utente preme il pulsante sinistro o destro significa che dobbiamo spostare il cursore a sinistra oa destra. Per fare questo dobbiamo semplicemente incrementare o decrementare il valore della posizione in cui il cursore deve essere posizionato

if (LB == 0) {// Se il pulsante sinistro viene premuto mentre (! LB); // Attendi il rilascio del pulsante pos--; // Quindi sposta il cursore a sinistra } if (RB == 0) {// Se il pulsante destro viene premuto mentre (! RB); // Attendi il rilascio del pulsante pos ++; // Sposta il cursore a destra }

Durante l'utilizzo di un pulsante con un microcontrollore o un microprocessore c'è un problema comune da affrontare. Questo problema è chiamato come switch bouncing. Questo è quando il pulsante viene premuto, potrebbe dare impulsi rumorosi all'MCU / MPU che potrebbero falsificare l'MCU per più voci. Questo problema può essere risolto aggiungendo un condensatore sull'interruttore o utilizzando una funzione di ritardo non appena viene rilevata la pressione del pulsante. Questo tipo di soluzione si chiama de-bouncing. Qui abbiamo usato un ciclo while per mantenere il programma in posizione finché il pulsante non viene rilasciato. Questa non è la migliore soluzione antirimbalzo, ma per noi funzionerà perfettamente.

while (! RB);

Simile al pulsante sinistro e destro, abbiamo anche i pulsanti superiore e inferiore che possono essere utilizzati per aumentare o diminuire il valore dell'ora della sveglia. Il codice per fare lo stesso è mostrato di seguito. Si noti che ogni carattere dell'ora di allarme impostata è indirizzato dal valore di indice della matrice. In questo modo possiamo accedere facilmente al carattere richiesto i cui valori devono essere modificati.

if (UB == 0) {// Se il pulsante superiore viene premuto mentre (! UB); // Attendi il rilascio del pulsante alarm_val ++; // Aumenta quel particolare valore di carattere } if (BB == 0) {// Se il pulsante inferiore viene premuto mentre (! UB); // Attendi il rilascio del pulsante alarm_val--; // Diminuisci quel particolare valore di caratteri }

Una volta impostata l'ora della sveglia, l'utente premerà nuovamente il pulsante centrale. Quindi possiamo iniziare a confrontare l'ora corrente con l'ora impostata. Il confronto verificando se ogni singolo carattere dell'ora corrente è uguale al carattere dell'ora impostata. Se i valori sono uguali, attiviamo l'allarme impostando la variabile trigger_alarm , altrimenti confrontiamo finché non diventa uguale.

// SE l'allarme è impostato Controlla se il valore impostato è uguale al valore corrente if (set_alarm == 0 && alarm_val == hour_1 && alarm_val == hour_0 && alarm_val == min_1 && alarm_val == min_0) trigger_alarm = 1; // Attiva il trigger se il valore corrisponde

Se l'allarme è impostato dobbiamo suonare il cicalino per avvisare l'utente dell'allarme. Questo può essere fatto semplicemente attivando il cicalino a intervalli regolari come mostrato di seguito.

if (trigger_alarm) {// Se viene attivato l'allarme // Beep the buzzer BUZZ = 1; __delay_ms (500); BUZZ = 0; __delay_ms (500); }

Simulazione:

Questo programma può anche essere simulato utilizzando il software proteus. Basta ricreare il circuito mostrato sopra e caricare il file esadecimale nel PIC. Il codice esadecimale per questo progetto può essere trovato nel file ZIP che è collegato qui. Di seguito è mostrata una schermata acquisita durante la simulazione

La simulazione diventa molto utile quando stai cercando di aggiungere nuove funzionalità al progetto. È inoltre possibile utilizzare il modulo debugger I2C per verificare quali dati entrano ed escono dal bus I2C. Puoi provare a premere i pulsanti e anche impostare l'ora della sveglia. Quando l'ora impostata è uguale all'ora corrente, il cicalino aumenterà.

Funzionamento della sveglia digitale utilizzando PIC16F877A:

Costruisci il circuito sulla breadboard, ottieni il codice dal link per il download e compilarlo usando MplabX e il compilatore XC8. Se hai scaricato il codice dal file ZIP fornito qui, non dovresti avere problemi a compilarlo poiché i file di intestazione sono già allegati.

Dopo la compilazione, carica il programma sul tuo hardware usando il programmatore PicKit3. La connessione per collegare il programmatore pickit al PIC IC è mostrata anche nello schema del circuito. Dopo che il programma è stato caricato, dovresti vedere la schermata introduttiva e quindi l'ora visualizzata, quindi puoi utilizzare i pulsanti per impostare l'ora della sveglia. La mia configurazione hardware quando alimentata è simile alla seguente.

Quando l'ora della sveglia corrisponde all'ora corrente, il cicalino inizierà a suonare per allarmare l'utente. La lavorazione completa si trova nel video sottostante. Il progetto ha una pletora di opzioni su cui costruire. Il modulo RTC può tenere traccia di qualsiasi ora e data, in modo da poter eseguire un'attività pianificata in qualsiasi ora / data richiesta. È inoltre possibile collegare un apparecchio CA come un ventilatore o una luce e programmarlo per accenderlo o spegnerlo quando necessario. Ci sono ancora molte altre cose che puoi costruire su questo progetto, fammi sapere quale idea ti viene in mente come aggiornamento di questo progetto e sarò felice di sentirti.

Spero che tu abbia capito il progetto e imparato qualcosa di utile dal processo. Se hai dei dubbi su questo progetto usa la sezione commenti per pubblicarli o usa i forum per qualsiasi aiuto tecnico.

Il codice PIC completo con i file di intestazione può essere trovato qui