Modul de interfață rtc (ds3231) cu microcontroler pic: ceas digital

Aproape toate dispozitivele încorporate sunt concepute pentru a interacționa cu lumea reală. Aceștia acționează ca o punte de comunicare între lumea digitală și lumea reală. Pentru a face acest proces mai ușor și eficient, lumea digitală ar trebui uneori să țină evidența timpului și a datei lumii reale. În acest fel, lumea digitală va ști ce oră / zi este în lumea reală și poate face chiar distincție între zi și noapte. De asemenea, poate acționa ca o sursă de timp pentru a efectua anumite sarcini la o dată sau o dată specificate. Așadar, aici interfațăm un modul RTC cu microcontrolerul PIC și afișăm ora și data pe ecranul LCD 16x2. Acest proiect poate fi folosit și ca ceas digital.

Materiale necesare:

• Alimentare 5V reglementată
• PIC16F877A
• Oscilator de cristal 20Mhz
• Condensator 33pf - 2Nos
• Rezistor 10K, 5,1K, 1K
• Modulul DS3231 RTC
• POT -10k
• Modul LCD 16 * 2
• Conectarea firelor

Modul RTC:

Cea mai obișnuită modalitate prin care un microcontroler poate ține evidența orei sau datei din lumea reală este utilizarea unui IC RTC. Termenul RTC înseamnă Real Time Clock; acest IC ține evidența orei și datei din lumea reală și ar împărtăși aceste informații microcontrolerului ori de câte ori este solicitat. IC RTC pe care îl folosim aici este cel mai popular și mai precis DS3231. Acest CI derivă doar cu câteva secunde în fiecare an și, prin urmare, este extrem de fiabil. De dragul acestui tutorial, folosim modulul DS3231 RTC care poate fi cumpărat cu ușurință online sau de la magazinul local de hardware. Modulul vine cu o celulă monedă de 3V care alimentează modulul RTC întotdeauna și, prin urmare, odată setată ora și data, acesta va fi actualizat atâta timp cât celula monedă este în viață.

Modulul DS3231 comunică cu ajutorul protocolului I2C, deci dacă nu știți ce este și cum este utilizat cu PIC, citiți tutorialul I2C cu PIC înainte de a continua. De asemenea, în acest tutorial vom crea un fișier antet care poate fi utilizat pentru a comunica cu modulul nostru RTC și, de asemenea, pentru a testa același lucru pe hardware afișând ora și data pe un ecran LCD, deci este important să învățați cum să interfațați LCD afișaj cu microcontroler PIC. Fișierul antet creat în acest tutorial pentru DS3231 poate fi ulterior utilizat / modificat pentru a se potrivi aplicațiilor dvs.

Am folosit anterior DS3231 RTC cu Arduino în proiectele de mai jos:

• Alimentator automat pentru animale de companie folosind Arduino
• Arduino Data Logger

Conectarea DS3231 RTC cu microcontrolerul PIC:

Schema de circuit pentru ceasul digital bazat pe microcontroler PIC este prezentată mai jos. După cum am spus mai devreme, DS3231 funcționează cu ajutorul comunicării I2C, astfel încât va avea un Serial Clock (SCL) și un Serial Data (SDA) pin care trebuie conectat la pinii I2C de pe PIC-ul nostru, care este pinul 18 (SCL) și pinul 23 (SDA). Un rezistor de tracțiune de valoare 4.7k este utilizat pentru a menține autobuzul în stare înaltă atunci când este inactiv.

Un afișaj LCD este, de asemenea, conectat la pinii din portul D pentru a afișa data și ora curente. Schema completă a circuitului a fost proiectată pe proteus și este prezentată mai jos. Vom folosi același lucru pentru a simula sau programa mai târziu în acest tutorial.

Urmați schema circuitului și efectuați conexiunile în consecință, caseta I2C prezentată mai sus este utilizată pentru depanarea I2C, deci nu o vom include în conexiunile noastre. De asemenea, nu se arată că modulul RTC trebuie alimentat cu o sursă de + 5V utilizând pinii Vcc și Ground de pe modul. Mi-am folosit panoul pentru a face conexiunea și după ce am făcut conexiunile necesare, configurarea mea a arătat cam așa mai jos.

Dacă sunteți nou în PIC Microcontroller, începeți cu Noțiuni introductive despre PIC Microcontroller.

Programarea PIC pentru modulul RTC:

Programul complet pentru acest ceas digital poate fi descărcat din fișierul ZIP de aici. Programul include în total trei fișiere antet. Acestea sunt fișierul lcd.h pentru lucrul cu afișajul LCD, fișierul PIC16F877a_I2C.h pentru lucrul cu comunicarea I2C cu PIC și în cele din urmă PIC16F877a_DS3231.h fișier pentru a lucra cu module RTC. Toate cele trei fișiere antet sunt necesare pentru acest program și sunt disponibile în fișierul ZIP de mai sus. Mai jos, voi explica programul principal care folosește toate aceste fișiere de antet pentru a citi ora și data din modulul RTC și pentru a-l afișa pe ecranul LCD. După aceea, voi explica ce se întâmplă de fapt în interiorul fișierului antet RTC. Ca întotdeauna, începeți programul prin configurarea biților de configurare și setarea frecvenței ceasului la 20 MHz, deoarece aceasta este ceea ce am folosit în hardware-ul nostru.

#pragma config FOSC = HS // Oscillator Selection bits (HS oscilator) #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT disabled) #pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT enabled) # pragma config BOREN = ON // Brown-out Reset Enable bit (BOR activat) #pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 este I / O digital, HV activat MCLR trebuie utilizat pentru programare) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off) #pragma config WRT = OFF // Flash Program Memory Write Enable bits (Protection write off; all memory program poate fi scris către controlul EECON) #pragma config CP = OFF // Bit program de protecție cod memorie program Flash (protecție cod dezactivată) #define _XTAL_FREQ 20000000

Următorul pas ar fi să definiți pinii LCD, dacă vă uitați la hardware, puteți observa că am conectat pinii LCD-ului la PORT D de la RD2 la RD7, deci definim același lucru așa cum se arată mai jos.

#define RS RD2 #define EN RD3 #define D4 RD4 #define D5 RD5 #define D6 RD6 #define D7 RD7

În mod implicit, când ați achiziționat modulul RTC, ora și data corectă nu vor fi setate în acesta, așa că trebuie să-l setăm prin programul nostru. Deci, declarăm variabile pentru fiecare dată și feed în data și ora reală, așa cum se arată mai jos. La momentul încărcării programului, ora și data mea erau 10: 55 dimineața, pe 5-5-2018, așa că am setat variabilele după cum urmează. Puteți seta ora și data corecte conform aplicației dvs. reale

/ * Setați valoarea curentă a datei și orei sub * / int sec = 00; int min = 55; oră int = 10; int data = 06; int luna = 05; int an = 18; / * Setat ora și data * /

Apoi adăugăm toate fișierele antet despre care am discutat. Dacă ați descărcat și ați deschis programul din fișierul ZIP, atunci nu va fi o problemă, altfel asigurați-vă că toate fișierele antet sunt adăugate în fișierul sursă sau în directorul de proiect.

#include #include " lcd .h" #include "PIC16F877a_I2C.h" #include "PIC16F877a_DS3231.h"

Deoarece am folosit PORT D ca pini de ieșire pentru interfața LCD, trebuie să le declarăm drept pini de ieșire în programul nostru și să inițializăm afișajul LCD așa cum se arată mai jos.

TRISD = 0x00; // Faceți pinii portului D ca ieșire pentru interfața LCD Lcd_Start (); // Inițializați modulul LCD

Modulul RTC comunică cu ajutorul protocolului I2C, deci trebuie să activăm comunicarea I2C microcontrolerul nostru PIC. Majoritatea dispozitivelor, inclusiv modulele DS3231, au o frecvență de operare I2C de 100 KHz, astfel încât să începem comunicarea I2C cu o frecvență de 100 KHz, așa cum se arată mai jos.

I2C_Initialize (100); // Inițializați I2C Master cu ceas de 100KHz

De îndată ce am stabilit o comunicare I2C cu modulul RTC, primul lucru pe care îl facem este să stabilim ora și data curente pe care le-am introdus în programul nostru. Acest lucru se poate face apelând funcția set_Time_Date așa cum se arată mai jos. Odată ce ora și data sunt setate, modulul le va urmări automat și le va incrementa la fel ca un ceas digital.

Set_Time_Date (); // setați ora și data pe modulul RTC

Pentru a indica faptul că programul a început, vom afișa un mic mesaj introductiv pentru care va rămâne pe ecran timp de 2 secunde. Acest mesaj va afișa RTC cu PIC –Circuit Digest pe ecran. Programul pentru același lucru este prezentat mai jos

Lcd_Clear (); Lcd_Set_Cursor (1,1); Lcd_Print_String ("RTC cu PIC"); Lcd_Set_Cursor (2,1); Lcd_Print_String ("-Circuit Digest"); __delay_ms (1500);

În bucla noastră infinită de timp ar trebui să citim ora și data curente și apoi să afișăm valorile pe ecranul nostru LCD. Pentru a citi ora și data din modulul RTC, funcția Update_Current_Time_Date poate fi utilizată așa cum se arată mai jos. Această funcție va citi valoarea din modulul RTC și va actualiza variabilele sec, min, oră, dată, lună și an cu valorile curente. Apoi le putem folosi pentru scopul nostru.

Update_Current_Date_Time (); // Citiți data și ora curente din modulul RTC

Variabilele sunt de tip întreg, trebuie să le convertim în caractere individuale, astfel încât să le putem afișa pe ecranul LCD. Deci, folosim operatorul de modul pentru a obține cifra o dată și împărțim variabila la 10 pentru a obține cifra zecilor. La fel se procedează pentru toate variabilele.

// Împărțiți în caractere pentru a afișa pe lcd caractere sec_0 = sec% 10; char sec_1 = (sec / 10); char min_0 = min% 10; char min_1 = min / 10; char hour_0 = ora% 10; ora char_1 = ora / 10; char date_0 = data% 10; char date_1 = data / 10; char luna_0 = luna% 10; char luna_1 = luna / 10; char anul_0 = anul% 10; char year_1 = anul / 10;

Tot ce rămâne de făcut este afișarea informațiilor pe care le-am dobândit pe ecranul LCD. Acest lucru se poate face cu ușurință cu funcțiile LCD pe care le-am discutat anterior în tutorialul nostru LCD. Deci, codul pentru afișarea orei este dat mai jos, aceeași metodă este utilizată pentru a afișa și data. O întârziere de 500 ms este dată după afișarea datelor, astfel încât să acționeze ca un interval de actualizare.

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');

Scurtă explicație a fișierului antet PIC16F877a_DS3231.h:

Lucrurile explicate până acum sunt suficiente pentru a utiliza modulul DS3231 cu PIC pentru propriile dvs. proiecte, dar pentru mințile curioase de acolo ar dori să știe ce se întâmplă de fapt în fișierul antet și datele sunt de fapt primite de la modulul RTC de către PIC, doar citiți mai departe.

Cel mai bun mod de a parcurge acest lucru este citirea completă a fișei tehnice a DS3231. Pentru a oferi o scurtă informație despre ceea ce este necesar, modulul acționează ca un sclav al PIC, iar adresa tuturor modulelor DS3231 este D0. Deci, scrieți datele în modul trebuie să trecem adresa D0 și pentru a Citi datele de la RTC trebuie să trecem adresa D1. Dacă trecem adresa de scriere a modulului RTC, ne pregătim să obținem date de la PIC, astfel încât datele ulterioare scrise de PIC vor fi primite și salvate în modulul RTC. În mod similar, dacă trimitem adresa pentru Citireatunci PIC ar trebui să se pregătească să citească valorile de la RTC, deoarece modulul RTC va începe să trimită toate datele pe care le are. Secvența de biți pentru D0 și D1 este prezentată mai jos din foaia de date. Observați că adresa 0b11010000 reprezintă D0 (Write) și 0b11010001 reprezintă D01 (Read)

Când PIC trimite adresa D0 sau D1 fie pentru a scrie, fie pentru a citi, următoarele date trebuie citite sau scrise într-o ordine. Această ordine este prezentată în tabelul de mai jos. Deci, primele date vor fi sec (00h) urmate de minute (01h) urmate de ore (02h) urmate de zi (03h) și până la MSB de temperatură.

Modulul RTC nu înțelege valorile zecimale, comunică numai prin valori BCD. Deci, înainte de a scrie orice valori în modulul RTC, acesta ar trebui convertit în BCD și, de asemenea, valorile primite de la modulul RTC vor fi în format BCD și ar trebui să fie convertite în Decimal pentru a avea sens pentru noi. Având în vedere acest lucru, putem crea toate funcțiile necesare pentru utilizarea modulului RTC.

Funcții BCD_2_DEC și DEC_2_BCD:

Primele două funcții ar fi folosite pentru a converti datele BCD în Zecimale și datele Zecimale în BCD, deoarece modulul RTC înțelege doar BCD. Formulele pentru a converti BCD în Zecimal și pentru BCD în Zecimal este

Zecimal = (BCD >> 4) * 10 + (BCD & 0x0F) BCD = ((Zecimal / 10) << 4) + (Zecimal% 10)

Trebuie doar să folosim aceste două formule pentru a crea o funcție care ia ca parametru unitatea opusă și o convertește în formatul necesar și o returnează, funcția pentru a face același lucru este prezentată mai jos

int BCD_2_DEC (int to_convert) { return (to_convert >> 4) * 10 + (to_convert & 0x0F); } int DEC_2_BCD (int to_convert) { return ((to_convert / 10) << 4) + (to_convert% 10); }

Funcția Set_Time_Date ():

Această funcție va scrie valoarea timpului și datei de la modulul PIC la modulul RTC. Valorile timpului real și ale datei trebuie actualizate de către utilizator în variabilele sec, min, oră, dată, lună și an. Aceste valori vor fi apoi convertite în BCD și scrise în modulul RTC.

După cum am discutat, pentru a scrie o valoare în modulul RTC trebuie să trecem adresa D0 și să scriem un bit bit 0 pentru a iniția procesul de scriere. Apoi putem trimite datele în ordine așa cum se arată în tabelul de mai sus.

void Set_Time_Date () { I2C_Begin (); I2C_Write (0xD0); I2C_Write (0); I2C_Write (DEC_2_BCD (sec)); // actualiza sec I2C_Write (DEC_2_BCD (min)); // actualizați min I2C_Write (DEC_2_BCD (oră)); // actualiza ora I2C_Write (1); // ignorați ziua de actualizare I2C_Write (DEC_2_BCD (data)); // data actualizării I2C_Write (DEC_2_BCD (lună)); // actualizați luna I2C_Write (DEC_2_BCD (an)); // actualiza anul I2C_End (); }

Funcția Update_Current_Date_Time ():

Ultima funcție din bibliotecă este cea utilizată pentru a citi ora și data de la modulul RTC și a le transmite microcontrolerului PIC. Această funcție este împărțită în trei segmente, unul pentru a iniția procesul de citire, al doilea pentru a citi valorile și a le salva în variabilele globale, cum ar fi sec, min, oră, dată, lună și an. Iar al treilea este să recunoaștem că lectura a avut succes.

Observați că pentru fiecare acțiune comunicarea I2C ar trebui să înceapă și să se încheie.

Pentru a citi valorile din RTC trebuie să trimitem adresa D0 urmată de un 0. Acest lucru va face ca modulul RTC să trimită toate valorile pe care le are în ordinea prezentată în tabelul de mai sus. Putem doar să le citim să le convertim în zecimal și să le salvăm în variabile în aceeași ordine.

În cele din urmă, după efectuarea citirii, modulul RTC va trimite un bit de confirmare care ar trebui să fie citit și confirmat.

void Update_Current_Date_Time () { // START pentru a citi I2C_Begin (); I2C_Write (0xD0); I2C_Write (0); I2C_End (); // CITIȚI I2C_Begin (); I2C_Write (0xD1); // Inițializați datele citite sec = BCD_2_DEC (I2C_Read (1)); min = BCD_2_DEC (I2C_Read (1)); ora = BCD_2_DEC (I2C_Read (1)); I2C_Read (1); data = BCD_2_DEC (I2C_Read (1)); luna = BCD_2_DEC (I2C_Read (1)); anul = BCD_2_DEC (I2C_Read (1)); I2C_End (); // END Lectură I2C_Begin (); I2C_Write (0xD1); // Inițializați datele citite I2C_Read (1); I2C_End (); }

Simulare:

Proiectul poate fi simulat folosind software-ul de simulare Proteus. Faceți conexiunile așa cum se arată în schema de circuit și încărcați fișierul hexagonal în controlerul PIC. Când îl simulați, veți găsi două casete pop-up și data și ora afișate pe ecranul LCD, așa cum se arată mai jos.

Cea mică din partea de sus arată ora și data care sunt actuale în interiorul modulului RTC și a doua fereastră pop-up este debuggerul I2C. Este un instrument excelent pentru a verifica ce date sunt transmise de fapt și în afara erorii I2C.

Afișează ora și data pe ecranul LCD:

Odată ce hardware-ul dvs. este gata și codul este descărcat ca fișier ZIP prin linkul dat, deschideți programul utilizând MPLABX IDE. Mai întâi trebuie să lansați IDE și să utilizați opțiunea de proiect deschis și să navigați la conținutul din fișierul ZIP și să deschideți folderul.X.

Pur și simplu verificați dacă programul se compilează și încărcați codul în hardware-ul dvs. utilizând PicKit3. De îndată ce programul este încărcat, ar trebui să vedeți mesajul introductiv și apoi ora și data ar trebui să fie afișate așa cum se arată mai jos.

Dacă nu există nimic pe ecranul LCD, verificați conexiunile și asigurați-vă că nivelul de contrast este setat corect, modificând potențiometrul. Acesta este modul în care puteți arăta ora și data tuturor proiectelor dvs. de microcontroler PIC și puteți utiliza acest lucru ca ceas digital. Sper că ați învățat ceva nou și v-a plăcut să învățați acest tutorial. Dacă ați întâmpinat vreo problemă, postați-le pe comentariile de mai jos sau pe forumuri pentru ajutor tehnic.

Descărcați programul PIC complet pentru acest proiect cu fișiere antet de aici și verificați în continuare toate tutorialele PIC aici.