- Mga Materyal na Kinakailangan:
- Paunang mga kinakailangan:
- Diagram ng Circuit:
- Programming para sa Alarm Clock:
- Simulation:
- Paggawa ng Digital Alarm Clock gamit ang PIC16F877A:
Ang digital Revolution ay nagsimula noong 1950 binago ang lahat ng mga umiiral na mekanikal at analog na elektronikong istruktura sa mga digital computer. Dahil ang paglago ng mga digital electronics ay naging exponential, ngayon halos imposible para sa isang tao na pigilan ang paggamit ng anumang elektronikong kagamitan. Simula mula sa alarm clock na gumising sa iyo at sa toaster na naghahain sa iyo ng agahan, ang lahat ay isang kontribusyon mula sa digital electronics. Sa pag-iisip ng lahat ng mga ito ay talagang kapanapanabik na i-program ang aming sariling mga bagay na maaaring gumawa ng mga simple ngunit kapaki-pakinabang na gawain, tulad ng Alarm Clock na itatayo namin sa proyektong ito sa PIC Microcontroller. Nakagawa na kami dati ng alarm clock kasama ang iba pang mga Microcontroller:
- Raspberry Pi Alarm Clock gamit ang RTC Module DS1307
- Batay sa Arduino na Digital Clock na may Alarm
- Clock ng Alarm gamit ang ATmega32 Microcontroller
Ang alarm clock na ito ay magkakaroon ng 16x2 LCD display na magpapakita sa kasalukuyang oras at itinakdang oras. Gumagamit kami ng ilang mga pindutan ng push upang itakda ang oras ng alarma tuwing kinakailangan. Ang kasalukuyang oras ay mananatili sa track gamit ang module ng DS3231 RTC at gagamitin namin ang komunikasyon ng IIC upang makuha ang mga halagang ito mula sa module ng RTC. Nalaman na namin ang tungkol sa module ng RTC at kung paano ito i-interface sa PIC. Kaya inirerekumenda na basahin ang tutorial na iyon, lalaktawan namin ang karamihan sa impormasyong sakop sa tutorial na iyon.
Mga Materyal na Kinakailangan:
- Lupon ng Tinapay - 2Hindi
- PIC16F877A
- 5V pinagmulan ng kuryente - module ng Pag-supply
- 20 MHz na kristal
- 33pf capacitor - 2No
- Modulong DS3231 RTC
- 16 * 2 LCD module ng pagpapakita
- 10K POT
- 10k at 1K risistor
- Mga pindutan ng push - 5No
- Buzzer
- Mga kumokonekta na mga wire
Paunang mga kinakailangan:
Hinihiling sa proyektong ito na alam mo ang ilang mga pangunahing kaalaman tungkol sa PIC microcontroller at kung paano ito i-program. Gagamitin namin ang mga GPIO, LCD display at RTC module para sa proyektong ito. Kaya mas mahusay na malaman kung paano gamitin ang mga modyul na ito bago. Ang mga sumusunod na link ay makakatulong sa iyo upang malaman ang pareho
- Pagsusulat ng iyong unang programa sa PIC Microcontroller
- Ang pagitan ng LCD na may PIC
- Komunikasyon sa I2C gamit ang PIC
- Ang DS3231 RTC na nakikipag-interfaces sa PIC
Diagram ng Circuit:
Ang circuit diagram para sa PIC based Alarm Clock Project na ito ay ipinapakita sa ibaba, na nilikha gamit ang proteus software. Gagamitin din ang para sa simulasi nang higit pa sa proyektong ito.
Ang limang mga pindutan ng tulak ay kikilos bilang isang input para sa pagtatakda ng alarma para sa kinakailangang oras. Kaya't ang isang dulo ng lahat ng mga pindutan ng push ay konektado sa lupa at ang iba pang mga dulo ay konektado sa PORTB pin, gagamitin ang panloob na pull-up risistor sa mga pin na ito upang maiwasan ang mga lumulutang na pin. Ang Buzzer ay kikilos bilang isang output at bibigyan kami ng isang beep kapag ang alarm ay napalitaw at nakakonekta sa PORT S pin. Ang kasalukuyang oras ay palaging sinusubaybayan ng module ng DS3231 RTC na kung saan natatanggap ng PIC ang data sa pamamagitan ng I2C bus, kaya ang mga SCL at SDA na pin ng RTC module ay konektado sa SCL at SDA pin ng PIC controller. Ang isang LCD display ay naka-attach sa PORTD ng PIC na ginagamit upang ipakita ang kasalukuyang oras at itinakdang oras. Matuto nang higit pa tungkol sa paggamit ng module ng DS3231 RTC na may PIC dito.
Ang kumpletong circuit ay maaaring itayo sa isang breadboard. Dahil mayroong ilang dosenang mga wires upang kumonekta sa gayon magkaroon lamang ng pasensya at tiyakin na ang mga koneksyon ay tama. Ang aking set-up na hardware ay mukhang isang bagay tulad nito sa ibaba sa sandaling tapos ako sa mga koneksyon
Gumamit ako ng module ng breadboard at 12V adapter upang mapagana ang module. Ito ang aking mapagkukunan ng boltahe ng suplay ng + 5V. Gayundin kailangan kong gumamit ng dalawang mga breadboard upang mapanatiling malinis ang circuit. Maaari mo ring solder ang buong circuit sa isang perf board kung naghahanap ka upang makagawa ng mas matibay na proyekto.
Programming para sa Alarm Clock:
Ang kumpletong programa ng PIC para sa proyekto ng Alarm Clock na ito ay matatagpuan sa ilalim ng pahinang ito. Ang proyektong ito ay nangangailangan din ng tatlong mga aklatan para sa paggamit ng LCD, I2C at RTC na may PIC. Ang kumpletong code na may mga file ng header ay maaaring ma-download mula sa ZIP file dito at maaaring buksan gamit ang MPLABX pagkatapos ng pagkuha. Dagdag sa ibaba ay ipinapaliwanag ko lamang ang pangunahing c file bilang maliit na mga snippet. Maaari kang bumalik sa nabanggit na mga tutorial kung nais mong malaman kung paano gumagana ang mga file ng header.
Bago pumasok sa pangunahing programa, kailangan nating tukuyin ang mga pin na ginamit namin na may mas makabuluhang pangalan. Sa ganitong paraan madali ang paggamit ng mga ito sa panahon ng pagprogram. Ang mga pin na tinukoy sa aming programa ay ipinapakita sa ibaba
// Define the LCD pins #define RS RD2 // Reset pin of LCD #define EN RD3 // Enable pin of LCD #define D4 RD4 // Data bit 0 of LCD #define D5 RD5 // Data bit 1 of LCD #define D6 RD6 // Data bit 2 ng LCD #define D7 RD7 // Data bit 3 ng LCD // Define Buttons #define MB RB1 // The middle button #define LB RB0 // Left button #define RB RB2 // Right button # tukuyin ang UB RB3 // Itaas na Button # tukuyin ang BB RB4 // Bottom button // Tukuyin ang Buzz #define BUZZ RD1 // Buzzer ay konektado sa RD1
Sa loob ng pangunahing pag- andar nagsisimula kami sa pamamagitan ng pagdedeklara ng Mga input at output pin. Sa aming proyekto ang PORTB ay ginagamit para sa mga push button na isang input aparato kaya itinakda namin ang kanilang mga pin bilang mga input at ginagamit ang PORTD para sa LCD at buzzer kaya itinakda namin ang kanilang mga pin bilang Output. Gayundin ang isang pin ay hindi dapat iwanang lumulutang na kahulugan, ang mga I / O pin ay dapat palaging konektado sa alinman sa Ground o sa boltahe na + 5V. Sa aming kaso para sa mga pindutan ng push ang mga pin ay hindi makakonekta sa anumang bagay kapag ang pindutan ay hindi pinindot kaya gumagamit kami ng isang panloob na pull-up risistor na itinatakda ang pin sa Mataas kapag hindi ginagamit. Ginagawa ito gamit ang mga rehistro ng kontrol tulad ng ipinakita sa ibaba
TRISD = 0x00; // Gumawa ng mga Port D pin bilang outptu para sa LCD interfacing TRISB = 0xFF; // Ang mga switch ay idineklara bilang mga input pin OPTION_REG = 0b00000000; // Paganahin ang hilahin ang Resistor sa port B para sa mga switch BUZZ = 0; // Turn of buzzer
Dahil mayroon kaming naka-link na header na file ng LCD at I2C sa pangunahing programa, maaari naming simulan ang pagsisimula ng LCD sa pamamagitan ng pagtawag sa isang simpleng pagpapaandar. Ang pareho ay maaaring gawin para sa pagsisimula din ng I2C. Dito sinisimulan namin ang komunikasyon ng I2C sa 100kHz dahil ang module ng RTC ay gumagana sa 100kHz.
Lcd_Start (); // Initialize LCD module I2C_Initialize (100); // Initialize I2C Master na may 100KHz na orasan
Ang pagpapaandar sa ibaba ay ginagamit upang itakda ang oras at petsa sa module ng RTC, sa sandaling ang oras at petsa ay nakatakda alisin ang linyang ito. Iba pa sa tuwing sinisimulan mo ang programa ang oras at petsa ay maitatakda nang paulit-ulit
// Alisin ang linya sa ibaba nang isang beses ang oras at petsa ay nakatakda sa unang pagkakataon. Set_Time_Date (); // itakda ang oras at petsa sa module ng RTC
Upang ipahiwatig na nagsisimula na ang programa ay nagpapakita kami ng isang maliit na intro screen na nagpapakita ng pangalan ng proyekto at pangalan ng website tulad ng ipinakita sa ibaba
// Magbigay ng mensahe ng intro sa LCD Lcd_Clear (); Lcd_Set_Cursor (1,1); Lcd_Print_String ("Alarm Clock"); Lcd_Set_Cursor (2,1); Lcd_Print_String ("-Circuit Digest"); __delay_ms (1500);
Susunod sa loob ng habang loop kailangan nating basahin ang kasalukuyang oras at petsa mula sa module ng RTC, magagawa ito sa pamamagitan lamang ng pagtawag sa pagpapaandar sa ibaba.
Update_Current_Date_Time (); // Basahin ang kasalukuyang petsa at oras mula sa module ng RTC
Ang pagtawag sa pagpapaandar sa itaas ay ia-update ang mga variable seg, min at oras na may kasalukuyang halaga. Upang maipakita ang mga ito sa screen ng LCD kailangan nating hatiin ang mga ito sa mga indibidwal na character gamit ang code sa ibaba.
// 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;
Susunod, ina- update namin ang mga halaga sa screen ng LCD. Ang kasalukuyang oras ay ipapakita sa unang linya at ang itinakdang oras kung saan dapat ma-trigger ang alarma ay ipinapakita sa pangalawang linya. Ang code na gumagawa ng pareho ay ipinapakita sa ibaba.
// Ipakita ang Kasalukuyang Oras sa LCD screen 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'); // Ipakita ang Petsa sa LCD screen Lcd_Set_Cursor (2, 1); Lcd_Print_String ("Alarm:"); 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');
Ngayon, ipinakita namin ang oras at itinakda ang oras sa LCD kailangan naming suriin kung sinusubukan ng gumagamit na itakda ang oras ng alarma. Upang magawa ito, kailangang pindutin ng gumagamit ang gitnang pindutan, kaya susuriin namin kung ang gitnang pindutan ay pinindot at magpalipat-lipat ng variable upang makapasok sa alarm set mode. Ang parehong pindutan ay pipilitin muli upang kumpirmahing ang mga halaga ay nakatakda at sa kasong iyon kailangan naming lumabas sa mode ng alarm set. Kaya ginagamit namin ang linya sa ibaba ng code upang baguhin ang katayuan ng variable set_alarm .
// Gumamit ng gitnang pindutan upang suriin kung ang alarm ay dapat itakda kung (MB == 0 && set_alarm == 0) {// Kung ang gitnang pindutan ay pinindot at ang alarma ay hindi nakabukas habang (! MB); // Wait hanggang button ay pinakawalan set_alarm = 1; // start setting setting alarm } kung (MB == 0 && set_alarm == 1) {// Kung ang gitnang pindutan ay pinindot at ang alarma ay hindi naka-off habang (! MB); // Wait hanggang button ay pinakawalan set_alarm = 0; // ihinto ang pagtatakda ng halaga ng alarma }
Kung pinindot ng gumagamit ang gitnang pindutan, nangangahulugan ito na sinusubukan niyang itakda ang oras ng alarma. Sa kasong ito ang programa ay pumapasok sa mode na itinakda ng alarma gamit ang code sa itaas. Sa loob ng alarm set mode kung pinindot ng gumagamit ang kaliwa o kanang pindutan nangangahulugang kailangan nating ilipat ang cursor pakaliwa o pakanan. Upang magawa ito simpleng pagtaas namin ng pagbawas ng halaga ng posisyon kung saan dapat mailagay ang cursor
kung (LB == 0) {// Kung kaliwang pindutan ay pinindot habang (! LB); // Wait hanggang button ay pinakawalan pos--; // Pagkatapos ay ilipat ang cursor sa kaliwa } kung (RB == 0) {// Kung ang kanang pindutan ay pinindot habang (! RB); // Wait hanggang button ay pinakawalan pos ++; // Ilipat ang cursor sa kanan }
Habang gumagamit ng isang pindutan ng push na may isang microcontroller o microprocessor mayroong isang karaniwang problema upang harapin. Ang problemang ito ay tinawag bilang switch bouncing. Iyon ay kapag pinindot ang pindutan maaari itong magbigay ng maingay na pulso sa MCU / MPU na maaaring peke ang MCU para sa maraming mga entry. Ang problemang ito ay maaaring malutas sa pamamagitan ng pagdaragdag ng isang capacitor sa kabuuan ng switch o sa pamamagitan ng paggamit ng isang pagpapaandar na pagpapaandar sa sandaling ang pindutan ng pindutan ay nakita. Ang ganitong uri ng solusyon ay tinatawag na de-bouncing. Dito nagamit namin ang isang habang loop upang hawakan ang programa sa lugar hanggang sa mailabas ang pindutan. Ito ay hindi isang pinakamahusay na de-bouncing solution ngunit para sa amin gagana lamang ito.
habang (! RB);
Katulad ng kaliwa at kanang pindutan, mayroon din kaming mga itaas at ibabang mga pindutan na maaaring magamit upang madagdagan o mabawasan ang halaga ng oras ng alarma. Ang code na gawin ang pareho ay ipinapakita sa ibaba. Pansinin na ang bawat character ng itinakdang oras ng alarma ay hinarap ng index halaga ng array. Ito ay madali nating na-access ang kinakailangang character na ang mga halaga ay dapat baguhin.
kung (UB == 0) {// Kung ang itaas na pindutan ay pinindot habang (! UB); // Maghintay hanggang ang pindutan ay pinakawalan ng alarm_val ++; // Taasan ang partikular na halaga ng char } kung (BB == 0) {// Kung ang mas mababang pindutan ay pinindot habang (! UB); // Maghintay hanggang mailabas ang alarm_val--; // Bawasan ang partikular na halaga ng char }
Sa sandaling nakatakda ang oras ng alarma ay pipindutin muli ng gumagamit ang gitnang pindutan. Pagkatapos ay maaari naming simulang ihambing ang kasalukuyang oras sa itinakdang oras. Ang paghahambing sa pamamagitan ng pag-check kung ang bawat solong character ng kasalukuyang oras ay katumbas ng character ng itinakdang oras. Kung ang mga halaga ay pantay-pantay pagkatapos ay pinapalabas namin ang alarma sa pamamagitan ng pagtatakda ng variable na trigger_alarm iba pa ihinahambing lamang namin hanggang sa maging pantay.
// KUNG nakatakda ang alarma Suriin kung ang itinakdang halaga ay katumbas ng kasalukuyang halaga kung (set_alarm == 0 && alarm_val == hour_1 && alarm_val == hour_0 && alarm_val == min_1 && alarm_val == min_0) trigger_alarm = 1; // I-on ang gatilyo kung tugma ang halaga
Kung nakatakda ang alarma kailangan nating beep ang buzzer upang alerto ang gumagamit para sa alarma. Magagawa ito sa pamamagitan lamang ng pag-toggle ng Buzzer sa isang regular na agwat tulad ng ipinakita sa ibaba.
kung (trigger_alarm) {// Kung ang alarm ay na-trigger // Beep the buzzer BUZZ = 1; __delay_ms (500); BUZZ = 0; __delay_ms (500); }
Simulation:
Ang program na ito ay maaari ding gayahin gamit ang proteus software. Lamang likhain muli ang circuit na ipinakita sa itaas at i-load ang hex file sa PIC. Ang hex code para sa proyektong ito ay matatagpuan sa ZIP file na naka-link dito. Ang isang pagbaril sa screen na kinuha habang ang simulation ay ipinapakita sa ibaba
Ang simulation ay magiging napaka kapaki-pakinabang kapag sinusubukan mong magdagdag ng mga bagong tampok sa proyekto. Maaari mo ring gamitin ang I2C debugger module upang suriin kung anong data ang papasok at lalabas sa pamamagitan ng I2C bus. Maaari mong subukang pindutin ang mga pindutan at itakda din ang oras ng alarma. Kapag ang itinakdang oras ay katumbas ng kasalukuyang oras pagkatapos ang buzzer ay magiging mataas.
Paggawa ng Digital Alarm Clock gamit ang PIC16F877A:
Buuin ang circuit sa breadboard, kunin ang code mula sa link sa pag-download at i-compile ito gamit ang MplabX at XC8 compiler. Kung na-download mo ang code mula sa ibinigay na ZIP file dito, dapat wala kang problema sa pag-ipon nito dahil ang mga file ng header ay naka-attach na.
Matapos ang pag-compile ng upload ng programa sa iyo ng hardware gamit ang PicKit3 programmer. Ang koneksyon upang ikonekta ang pickit programmer sa PIC IC ay ipinapakita din sa diagram ng circuit. Matapos ma-upload ang programa dapat mong makita ang intro screen at pagkatapos ay ang oras na ipinapakita maaari mo nang gamitin ang mga pindutan ng itulak upang itakda ang oras ng alarma. Ang setting ng aking hardware kapag pinagagana ay ganito sa ibaba.
Kapag tumutugma ang oras ng alarma sa kasalukuyang oras ay magsisimulang mag-beep ang buzzer upang alarma ang gumagamit. Ang kumpletong pagtatrabaho ay matatagpuan sa video sa ibaba. Ang proyekto ay may maraming mga pagpipilian upang maitaguyod. Maaaring subaybayan ng module ng RTC ang anumang oras at petsa, upang maaari mong maisagawa ang isang naka-iskedyul na gawain sa anumang oras / petsa na kinakailangan. Maaari mo ring ikonekta ang isang appliance ng AC tulad ng isang fan o ilaw at iiskedyul ito upang I-ON o I-OFF kung kinakailangan. Marami pang iba ang maaari mong maitayo sa proyektong ito, ipaalam sa akin kung anong ideya ang pumapasok sa iyong isipan bilang isang pag-upgrade sa proyektong ito at masaya akong makarinig mula sa iyo.
Inaasahan kong naintindihan mo ang proyekto at natutunan ang isang bagay na kapaki-pakinabang mula sa proseso. Kung mayroon kang anumang pagdududa sa proyektong ito gamitin ang seksyon ng komento upang mai-post ang mga ito o gamitin ang mga forum para sa anumang tulong na panteknikal.
Ang kumpletong PIC code na may mga file ng header ay matatagpuan dito