Interfacing rtc module (ds3231) na may pic microcontroller: digital na orasan

Halos lahat ng naka-embed na aparato ay dinisenyo upang makipag-ugnay sa totoong mundo. Kumikilos sila bilang isang tulay upang makipag-usap sa pagitan ng digital na mundo at ng totoong mundo. Upang gawing mas madali at mahusay ang prosesong ito, kailangan ng digital na mundo na subaybayan ang oras ng at petsa ng totoong mundo. Sa ganitong paraan malalaman ng digital na mundo kung anong oras / araw ito sa totoong mundo at maaaring makilala pa ang oras ng araw o gabi. Maaari rin itong kumilos bilang isang mapagkukunan ng oras upang maisagawa ang ilang mga gawain sa isang tinukoy na oras o petsa. Kaya narito ay nakikipag-ugnay kami sa isang module ng RTC sa PIC Microcontroller at ipinapakita ang oras at petsa sa 16x2 LCD. Ang proyektong ito ay maaari ding magamit bilang Digital Clock.

Mga Materyal na Kinakailangan:

• Naayos ang 5V Supply
• PIC16F877A
• Crystal Oscillator 20Mhz
• Capacitor 33pf - 2No
• 10K, 5.1K, 1K risistor
• Modulong DS3231 RTC
• POT -10k
• LCD Modyul 16 * 2
• Mga kumokonekta na mga wire

Module ng RTC:

Ang pinakakaraniwang paraan para masubaybayan ng isang microcontroller ang oras o petsa ng totoong mundo ay sa pamamagitan ng paggamit ng RTC IC. Ang term na RTC ay nangangahulugang Real Time Clock; sinusubaybayan ng IC na ito ang totoong oras at petsa ng mundo at ibabahagi ang impormasyong ito sa microcontroller kahit kailan hiniling. Ang RTC IC na ginagamit namin dito ay ang pinakatanyag at tumpak na DS3231. Ang IC na ito ay naaanod lamang ng ilang segundo bawat taon at samakatuwid ay lubos na maaasahan. Para sa kapakanan ng tutorial na ito ginagamit namin ang module na DS3231 RTC na maaaring madaling mabili online o mula sa lokal na tindahan ng hardware. Ang module ay may isang 3V coin cell na laging nagpapagana sa module ng RTC at samakatuwid sa oras na itakda ang oras at petsa ay maa-update ito habang buhay ang coin cell.

Ang module ng DS3231 ay nakikipag-usap sa tulong ng I2C protocol, kaya kung hindi mo alam kung ano ito at kung paano ito ginagamit sa PIC basahin ang I2C na may tutorial na PIC bago magpatuloy. Sa tutorial din na ito ay lilikha kami ng isang header file na maaaring magamit upang makipag-usap sa aming module ng RTC at subukan din ang pareho sa hardware sa pamamagitan ng pagpapakita ng oras at petsa sa isang LCD display kaya mahalaga ding malaman kung paano mag-interface ng LCD ipakita sa PIC microcontroller. Ang header file na nilikha sa tutorial na ito para sa DS3231 ay maaaring magamit / baguhin sa paglaon upang umangkop sa iyong mga application.

Ginamit namin dati ang DS3231 RTC kasama ang Arduino sa mga ibaba na proyekto:

• Awtomatikong Pagpapakain ng Alagang Hayop gamit ang Arduino
• Arduino Data Logger

Pagkonekta sa DS3231 RTC sa PIC Microcontroller:

Ang diagram ng circuit para sa PIC Microcontroller batay sa Digital Clock ay ibinibigay sa ibaba. Tulad ng sinabi nang mas maaga ang DS3231 ay gumagana sa tulong ng komunikasyon ng I2C kaya magkakaroon ito ng Serial Clock (SCL) at isang Serial Data (SDA) na pin na dapat na konektado sa mga I2C na pin sa aming PIC na kung saan ay ang pin 18 (SCL) at pin 23 (SDA). Ang isang pull up risistor na may halagang 4.7k ay ginagamit upang mapanatili ang bus sa mataas na estado kapag walang ginagawa.

Ang isang LCD display ay konektado din sa mga pin sa Port D upang maipakita ang kasalukuyang petsa at oras. Ang kumpletong diagram ng circuit ay idinisenyo sa proteus at ipinakita sa ibaba. Gagamitin namin ang pareho upang gayahin o programa sa paglaon sa tutorial na ito.

Sundin ang circuit diagram at gawin ang mga koneksyon nang naaayon, ang kahon ng I2C na ipinakita sa itaas ay ginagamit para sa pag-debug ng I2C kaya hindi namin isasama iyon sa aming mga koneksyon. Hindi rin ipinapakita na ang module ng RTC ay dapat na pinalakas ng isang supply na + 5V gamit ang Vcc at Ground pins sa modyul. Ginamit ko ang aking breadboard upang gawin ang koneksyon at pagkatapos gawin ang kinakailangang mga koneksyon ang aking set-up ay tumingin ng isang bagay tulad nito sa ibaba.

Kung bago ka sa PIC Microcontroller pagkatapos ay magsimula sa Pagsisimula sa PIC Microcontroller.

Programming PIC para sa RTC Module:

Ang kumpletong programa para sa Digital na orasan na ito ay maaaring ma-download mula sa ZIP file dito. Kasama sa programa ang tatlong mga header file nang sama-sama. Ang mga ito ang lcd.h file para sa pagtatrabaho sa LCD display, ang PIC16F877a_I2C.h file para sa pagtatrabaho sa I2C na komunikasyon sa PIC at sa wakas ang PIC16F877a_DS3231.h mag-file upang gumana sa mga module ng RTC. Ang lahat ng tatlong mga file ng header ay kinakailangan para sa program na ito at magagamit sa ZIP file sa itaas. Malayo sa ibaba ay ipapaliwanag ko ang pangunahing programa na gumagamit ng lahat ng mga header file na ito upang basahin ang oras at petsa mula sa module ng RTC at ipakita ito sa LCD screen. Pagkatapos nito ay ipapaliwanag ko kung ano talaga ang nangyayari sa loob ng RTC header file. Tulad ng laging simulan ang programa sa pamamagitan ng pag-set up ng mga config bit at pagtatakda ng dalas ng orasan bilang 20MHz dahil iyon ang ginamit namin sa aming hardware.

#pragma config FOSC = HS // Oscillator Selection bits (HS oscillator) #pragma config WDTE = OFF // Watchdog Timer Paganahin ang bit (hindi pinagana ang WDT) #pragma config PWRTE = ON // Power-up Timer Paganahin ang bit (pinagana ang PWRT) # pragma config BOREN = ON // Brown-out Reset Paganahin ang bit (pinagana ang BOR) #pragma config LVP = OFF // Mababang Boltahe (Single-Supply) In-Circuit Serial Programming Paganahin ang bit (ang RB3 ay digital I / O, HV sa Dapat gamitin ang MCLR para sa pagprograma) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Proteksyon ang Data EEPROM code) #pragma config WRT = OFF // Flash Program Memory Sumulat Paganahin ang mga bits (Isulat ang proteksyon; lahat ng memorya ng programa maaaring nakasulat sa pamamagitan ng kontrol ng EECON) #pragma config CP = OFF // Flash Program Memory Code ng Proteksyon ng kaunti (Code protection off) #define _XTAL_FREQ 20000000

Ang susunod na hakbang ay upang tukuyin ang mga LCD pin, kung titingnan mo ang hardware maaari mong mapansin na nakakonekta namin ang mga pin ng LCD sa PORT D mula sa RD2 hanggang RD7, kaya tinukoy namin ang katulad ng ipinakita sa ibaba.

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

Bilang default kapag binili mo ang module ng RTC ang tamang oras at petsa ay hindi maitatakda dito, kaya kailangan nating itakda ito sa pamamagitan ng aming programa. Kaya idineklara namin ang variable para sa bawat data at feed sa totoong oras at petsa ng mundo tulad ng ipinakita sa ibaba. Sa oras ng pag-upload ng programa ang aking oras at petsa ay 10:55 ng umaga sa 6-5-2018 kaya't itinakda ko ang mga variable na nasa ibaba. Maaari mong itakda ang tamang oras at petsa ayon sa iyong aktwal na aplikasyon

/ * Itakda ang kasalukuyang halaga ng petsa at oras sa ibaba * / int sec = 00; int min = 55; int oras = 10; int date = 06; int buwan = 05; int taon = 18; / * Itakda ang Oras at Petsa * /

Susunod na idinagdag namin ang lahat ng mga file ng header na tinalakay namin. Kung na-download mo at binuksan ang programa mula sa ZIP file pagkatapos hindi ito magiging isang problema pa siguraduhin na ang lahat ng mga header file ay naidagdag sa iyong source file o iyong direktoryo ng proyekto.

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

Dahil ginamit namin ang PORT D bilang mga output pin para sa interfacing ng LCD kailangan naming ideklara ang mga ito bilang mga output pin sa aming programa at ipasimula ang LCD display tulad ng ipinakita sa ibaba

TRISD = 0x00; // Gumawa ng mga Port D pin bilang outptu para sa LCD interfacing Lcd_Start (); // Initialize LCD module

Ang module ng RTC ay nakikipag-usap sa tulong ng I2C protocol kaya kailangan naming paganahin ang komunikasyon ng I2C sa aming PIC microcontroller. Karamihan sa mga aparato kasama ang aming mga module ng DS3231 ay mayroong dalas ng operating na I2C na 100KHz kaya sinimulan namin ang komunikasyon ng I2C na may dalas na 100KHz tulad ng ipinakita sa ibaba

I2C_Initialize (100); // Initialize I2C Master na may 100KHz na orasan

Sa sandaling naitaguyod namin ang isang komunikasyon sa I2C sa module ng RTC ang unang bagay na ginagawa namin ay itakda ang kasalukuyang oras at petsa na ipinasok namin sa aming programa. Maaari itong magawa sa pamamagitan ng pagtawag sa set_Time_Date function tulad ng ipinakita sa ibaba. Kapag ang oras at petsa ay itinakda ang module ay awtomatikong subaybayan ito at dagdagan ang mga ito tulad ng isang digital na orasan.

Set_Time_Date (); // itakda ang oras at petsa sa module ng RTC

Upang ipahiwatig na nagsimula na ang programa ay magpapakita kami ng isang maliit na mensahe ng intro kung saan mananatili sa screen nang 2 segundo. Ipapakita ng mensaheng ito ang RTC na may PIC –Circuit Digest sa screen. Ang programa para sa pareho ay ipinapakita sa ibaba

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

Sa loob ng aming walang hanggan habang loop dapat nating basahin ang kasalukuyang oras at petsa at pagkatapos ay ipakita ang mga halaga sa aming LCD screen. Upang mabasa ang Oras at Petsa mula sa module ng RTC maaaring magamit ang pagpapaandar na Update_Current_Time_Date tulad ng ipinakita sa ibaba. Ang function na ito ay basahin ang form na halaga ng module ng RTC at i-update ang mga variable seg, min, oras, petsa, buwan at taon sa kasalukuyang mga halaga. Pagkatapos ay maaari nating gamitin ang mga ito para sa ating hangarin.

Update_Current_Date_Time (); // Basahin ang kasalukuyang petsa at oras mula sa module ng RTC

Ang mga variable ay nasa uri ng data ng integer, kailangan nating i-convert ang mga ito sa mga indibidwal na character upang maipakita namin ang mga ito sa LCD screen. Kaya ginagamit namin ang modulus operator upang makuha ang isang beses na digit at hatiin ang variable sa 10 upang makuha ang sampung digit. Ang pareho ay tapos na para sa lahat ng mga variable.

// Hatiin ang char upang ipakita sa lcd char sec_0 = sec% 10; char sec_1 = (sec / 10); char min_0 = min% 10; char min_1 = min / 10; char hour_0 = oras% 10; char hour_1 = oras / 10; char date_0 = date% 10; char date_1 = date / 10; char month_0 = buwan% 10; char month_1 = buwan / 10; char year_0 = taon% 10; char year_1 = taon / 10;

Ang natitirang gawin ay ang pagpapakita ng impormasyong nakuha namin sa LCD screen. Madali itong magagawa sa mga pagpapaandar ng LCD na dati nating tinalakay sa aming LCD tutorial. Kaya't ang code upang ipakita ang oras ay ibinigay sa ibaba, ang parehong pamamaraan ay ginagamit upang maipakita din ang petsa. Ang isang pagkaantala ng 500 ms ay ibinigay pagkatapos ipakita ang data upang ito ay kumilos bilang isang agwat ng pag-update.

Lcd_Clear (); Lcd_Set_Cursor (1,1); Lcd_Print_String ("TIME:"); Lcd_Print_Char (hour_1 + '0'); Lcd_Print_Char (oras_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');

Maikling paliwanag ng PIC16F877a_DS3231.h header file:

Ang mga bagay na ipinaliwanag sa ngayon ay sapat na upang magamit ang module ng DS3231 na may PIC para sa iyong sariling mga proyekto, ngunit para sa mga nagtataka na isip doon ay nais na malaman kung ano ang tunay na nangyayari sa loob ng header file at ang data ay talagang natanggap mula sa RTC module ng PIC, lamang basahin pa.

Ang pinakamahusay na paraan upang dumaan ito, ay sa pamamagitan ng pagbabasa ng buong buong datasheet ng DS3231. Upang magbigay ng isang maikling ng kung ano ang kinakailangan, ang module ay gumaganap bilang isang alipin sa PIC at ang address ng lahat ng module ng DS3231 ay D0. Kaya't isulat ang data sa modyul na mayroon kami upang maipasa ang address na D0 at upang Basahin ang data mula sa RTC kailangan nating ipasa ang address na D1. Kung ipasa natin ang sulatin ang address ng RTC module naghahanda kami upang makakuha ng data mula sa PIC kaya ang mga kahihinatayang data na isinulat ng PIC ay matatanggap at mai-save sa module ng RTC. Katulad nito kung ipadala namin ang address para sa Basahinpagkatapos ay dapat maghanda ang PIC na Basahin ang mga halaga mula sa RTC dahil ang module ng RTC ay magsisimulang ipadala ang lahat ng data na mayroon ito. Ang pagkakasunud-sunod ng bit para sa parehong D0 at D1 ay ipinapakita sa ibaba mula sa datasheet. Pansinin ang address na 0b11010000 ay nangangahulugang D0 (Isulat) at 0b11010001 ay nangangahulugang D01 (Basahin)

Kapag ipinadala ng PIC ang address na D0 o D1 alinman upang magsulat o magbasa, ang sumusunod na data ay dapat basahin o isulat sa isang pagkakasunud-sunod. Ang order na ito ay ipinapakita sa talahanayan sa ibaba. Kaya ang unang data ay magiging sec (00h) na susundan ng minuto (01h) na susundan ng oras (02h) na susundan ng araw (03h) at hanggang sa MSB ng Temperatura.

Hindi maintindihan ng module ng RTC ang mga desimal na halaga, nakikipag-usap lamang ito sa pamamagitan ng mga halagang BCD. Kaya bago magsulat ng anumang mga halaga sa module ng RTC dapat itong i-convert sa BCD at ang mga halagang natanggap mula sa module ng RTC ay nasa format na BCD at dapat itong i-convert sa Decimal upang magkaroon ng katuturan para sa atin. Sa pag-iisip na ito hinahayaan lumikha ng lahat ng pagpapaandar na kinakailangan para sa paggamit ng module ng RTC.

Ang mga pagpapaandar ng BCD_2_DEC at DEC_2_BCD:

Ang unang dalawang pag-andar ay gagamitin upang mai-convert ang data ng BCD sa decimal at ang desimal data sa BCD dahil ang RTC module ay nakakaintindi lamang sa BCD. Ang mga formula upang mai-convert ang BCD sa decimal at para sa BCD sa Decimal ay

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

Kailangan lang naming gamitin ang dalawang formula na ito upang lumikha ng isang pagpapaandar na tumatagal sa kabaligtaran na yunit bilang parameter at i-convert ito sa kinakailangang format at ibabalik ito, ang pagpapaandar para sa paggawa ng pareho ay ipinapakita sa ibaba

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

Pag-andar ng Set_Time_Date ():

Isusulat ng pagpapaandar na ito ang halaga ng oras at petsa mula sa module ng PIC hanggang RTC. Ang mga halaga ng totoong oras at petsa ay dapat na ma-update sa mga variable seg, min, oras, petsa, buwan at taon ng gumagamit. Ang mga halagang ito ay mai-convert sa BCD at isulat sa module ng RTC.

Tulad ng tinalakay namin, upang magsulat ng isang halaga sa module ng RTC kailangan naming ipasa ang address na D0 at magsulat ng isang bull bit 0 upang simulan ang proseso ng pagsulat. Pagkatapos ay maaari naming ipadala ang data sa pagkakasunud-sunod tulad ng ipinakita sa talahanayan sa itaas.

walang bisa ang Set_Time_Date () { I2C_Begin (); I2C_Write (0xD0); I2C_Write (0); I2C_Write (DEC_2_BCD (sec)); // update sec I2C_Write (DEC_2_BCD (min)); // update min I2C_Write (DEC_2_BCD (oras)); // update hour I2C_Write (1); // huwag pansinin ang araw ng pag-update ng I2C_Write (DEC_2_BCD (petsa)); // update date I2C_Write (DEC_2_BCD (month)); // update month I2C_Write (DEC_2_BCD (taon)); // update year I2C_End (); }

Pag-andar ng Update_Current_Date_Time ():

Ang huling pag-andar sa silid-aklatan ay ang ginagamit upang basahin ang oras at petsa mula sa module ng RTC at ipasa ito sa microcontroller ng PIC. Ang pagpapaandar na ito ay nahahati sa tatlong mga segment, isa upang pasimulan ang proseso ng pagbabasa sa pangalawa upang mabasa ang mga halaga at i-save ito sa mga pandaigdigang variable tulad ng sec, min, oras, petsa, buwan at taon. At ang pangatlo ay upang kilalanin na ang pagbabasa ay matagumpay.

Pansinin na para sa bawat pagkilos ang komunikasyon ng I2C ay dapat na simulan at tapusin.

Upang mabasa ang mga halaga mula sa RTC kailangan naming ipadala ang address na D0 na susundan ng isang 0. Gagawin nito ang module ng RTC na ipadala ang lahat ng mga halaga na mayroon ito sa pagkakasunud-sunod na ipinakita sa talahanayan sa itaas. Maaari lamang nating basahin ang pag-convert sa kanila sa Decimal at i-save ito sa mga variable sa parehong pagkakasunud-sunod.

Panghuli, matapos ang pagbabasa ay tapos na ang module ng RTC ay magpapadala ng isang bit ng pagkilala na dapat ding basahin at kilalanin.

walang bisa ang Update_Current_Date_Time () { // SIMULA upang Basahin ang I2C_Begin (); I2C_Write (0xD0); I2C_Write (0); I2C_End (); // BASAHIN I2C_Begin (); I2C_Write (0xD1); // Initialize data read sec = BCD_2_DEC (I2C_Read (1)); min = BCD_2_DEC (I2C_Read (1)); oras = BCD_2_DEC (I2C_Read (1)); I2C_Read (1); petsa = BCD_2_DEC (I2C_Read (1)); buwan = BCD_2_DEC (I2C_Read (1)); taon = BCD_2_DEC (I2C_Read (1)); I2C_End (); // END Reading I2C_Begin (); I2C_Write (0xD1); // Initialize data read I2C_Read (1); I2C_End (); }

Simulation:

Ang proyekto ay maaaring gayahin gamit ang Proteus simulation software. Gawin ang mga koneksyon tulad ng ipinapakita sa circuit diagram at i-load ang hex file sa PIC controller. Kapag ginaya mo ito makikita mo ang dalawang mga pop-up box at ang petsa at oras na ipinapakita sa LCD tulad ng ipinakita sa ibaba.

Ang maliit sa tuktok ay nagpapakita ng oras at petsa na kasalukuyang nasa loob ng module ng RTC at ang pangalawang pop-up ay ang I2C debugger. Ito ay isang mahusay na tool upang suriin kung anong data ang talagang naipapasa at palabas ng I2C bug.

Ipakita ang Oras at Petsa sa LCD:

Kapag handa na ang iyong hardware at na-download ang code bilang ZIP file sa pamamagitan ng ibinigay na link buksan ang programa gamit ang MPLABX IDE. Kailangan mong ilunsad muna ang IDE at gamitin ang bukas na pagpipilian ng proyekto at mag-browse sa mga nilalaman sa loob ng ZIP file at buksan ang.X folder.

Suriin lamang kung ang programa ay nag-iipon at i-upload ang code sa iyong hardware sa pamamagitan ng paggamit ng PicKit3. Sa sandaling na-upload ang programa dapat mong makita ang pambungad na mensahe at pagkatapos ay dapat ipakita ang oras at petsa tulad ng ipinakita sa ibaba.

Kung wala sa LCD suriin ang iyong mga koneksyon at siguraduhin na ang antas ng kaibahan ay itinakda nang tama sa pamamagitan ng pag-iba ng potensyomiter. Iyon ang paraan kung paano mo maipapakita ang oras at petsa sa lahat ng iyong mga proyekto ng microcontroller ng PIC at magagamit ito bilang Digital Clock. Inaasahan kong may bago kang natutunan at nasiyahan sa pag-aaral ng tutorial na ito. Kung naharap mo ang anumang problema i-post ang mga ito sa mga komento sa ibaba o sa mga forum para sa tulong na panteknikal.

I-download ang kumpletong programa ng PIC para sa proyektong ito na may mga file ng header mula dito at karagdagang suriin ang aming lahat ng mga Tutorial sa PIC dito.