- Diagram ng Circuit:
- PIC Microcontroller PIC16F877A LED Blinking Sequence Code at Paggawa ng Paliwanag:
Sa aming nakaraang tutorial, nalaman namin ang tungkol sa Blinking isang LED gamit ang PIC microcontroller at itinayo ang parehong circuit sa Perf board. Pagkatapos ay ginamit namin ang PICkit 3, ICSP at MPLAB IPE para sa pagtatapon ng programa sa aming Perf board. Ngayon, sa tutorial na ito isusulong namin ang aming sarili sa paggamit ng higit pang mga pin sa microICtroller ng PIC. Gumagamit kami ng 7 output (LEDs) at isang Input. Para sa tutorial na ito gagamitin namin ang lumang board ng Perf (ipinapakita sa ibaba) at magdagdag ng mga berg sticks upang hilahin ang kinakailangang mga pin sa ikalawang LED board. Sa pagtatapos ng tutorial na ito bubuo kami ng isang Sequence of Blinking LEDs gamit ang PIC microcontroller PIC16F877A at matututunan kung paano gumamit ng maraming mga input at output, ilang mga pangunahing kaalaman sa 'for' loop at function calling.
Ang LED board ay walang anuman kundi isa pang perf board, kung saan hihihinang namin ang mga LED na may kasalukuyang nililimitahan na Resistor (ipinapakita sa ibaba). Magdaragdag din kami ng isang pushbutton upang simulan ang pagkakasunud-sunod na pagkislap ng LED.
Diagram ng Circuit:
PIC Microcontroller PIC16F877A LED Blinking Sequence Code at Paggawa ng Paliwanag:
Ang Kumpletong Code ay ibinigay sa ibaba (suriin sa dulo), dito makukuha namin ito sa pamamagitan ng linya sa pamamagitan ng linya. Ang code na ito ay magsisimulang mag- glow ng mga LED sa isang sunud-sunod na paraan kapag pinindot ang pindutan ng push. Upang maunawaan ang mga pagkakasunud-sunod mangyaring panoorin ang video sa pagtatapos ng tutorial. Inirerekumenda ko sa iyo na ihambing ang output na ipinapakita sa video sa code sa ibaba at subukang unawain ang programa.
Tingnan natin ang linya ng code sa pamamagitan ng linya. Ang mga unang ilang linya ay para sa pagse-set up ng mga config bit na ipinaliwanag sa nakaraang tutorial kaya't nilalaktawan ko ang mga ito sa ngayon. Ang pinakamahusay na paraan upang maunawaan ang anumang programa ay upang magsimula mula sa pangunahing ( void main () ) na pagpapaandar, kaya't gawin natin iyon
TRISB0 = 1; // Turuan ang MCU na ang PORTB pin 0 ay ginagamit bilang input para sa pindutan. TRISD = 0x00; // Turuan ang MCU na ang lahat ng mga pin ay output PORTD = 0x00; // Ipasimula ang lahat ng mga pin sa 0
Ginagamit ang salitang TRIS upang tukuyin kung ang pin ay ginagamit bilang input / output at ang salitang PORT ay ginagamit upang gumawa ng isang pin na Mataas / Mababang. Ang linya na TRISB0 = 1 ay gagawa ng ika-0 na pin ng PORT B bilang input. Ito ang magiging pushbutton namin. Ang mga linya ay TRISD = 0x00; PORTD = 0x00; Gagawin ang lahat ng mga pin ng port D bilang Output at magtalaga ng isang paunang halaga ng LOW sa mga pin na iyon.
Dahil sinabi namin na ang B0 ay ginamit bilang input, ikokonekta namin ang isang dulo ng pushbutton sa pin B0 at iba pang dulo sa lupa. Sa tuwing pinipindot namin ang pindutan ang pin ay ihahawak sa lupa tulad ng ipinakita sa diagram ng koneksyon sa itaas. Ngunit upang mangyari ito kailangan naming gumamit ng isang pull up risistor upang ang pin ay gaganapin mataas kapag ang pindutan ay hindi pinindot. Ang isang pull up risistor ay isang bagay na tulad nito.
Ngunit ang aming PIC MCU ay may panloob na mahina na pull up risistor na maaaring i-aktibo ng software sa paraang iyon na nagse-save ng maraming abala (kapag maraming mga pindutan ang makakonekta).
Ano ang isang Mahinang pull up risistor?
Mayroong dalawang uri ng pull up risistor, ang isa ay Weak Pull Up at isa pa ay Strong Pull Up. Ang mahina na pull up resistors ay may mataas na halaga at sa gayon ay nagpapahintulot sa isang mahinang kasalukuyang dumaloy at ang malakas na pull up resistors ay may mababang halaga kaya pinapayagan ang isang malakas na kasalukuyang dumaloy. Ang lahat ng MCU karamihan ay gumagamit ng mahina na pull up resistors. Upang maisaaktibo ito sa aming PIC MCU kailangan naming tingnan ang aming sheet ng data para sa OPTION_REG (pagpipilian sa rehistro) tulad ng ipinakita sa snapshot sa ibaba.
Tulad ng ipinakita ang bit 7 na pakikitungo sa mahina na pull up risistor. Dapat itong gawing zero upang maisaaktibo ito. Ginagawa ito ng OPTION_REG <7> = 0 . Partikular nitong nakikipag-usap sa bit 7 na iniiwan ang iba pang mga piraso sa mga default na halaga. Sa pamamagitan nito napupunta kami sa aming habang loop, kung saan susuriin kung ang pindutan ay pinindot sa pamamagitan ng paggamit ng (RB0 == 0). Kung nasiyahan ang kundisyon tinatawagan namin ang aming pagpapaandar sa mga parameter na 1, 3, 7 at 15.
sblink (1); // FUNCTION CALL 1 na may parameter 1 sblink (3); // FUNCTION CALL 3 na may parameter 3 sblink (7); // FUNCTION CALL 7 na may parameter 7 sblink (15); // FUNCTION CALL 4 na may parameter 15
Bakit kami gumagamit ng mga pagpapaandar?
Ginagamit ang mga pagpapaandar upang mabawasan ang bilang ng mga linya sa aming code. Ito ang malalaman ng karamihan sa atin. Ngunit bakit kailangan nating bawasan ang bilang ng mga linya, lalo na pagdating sa programa ng MCU. Ang dahilan ay ang limitadong puwang sa aming memorya ng Program. Kung hindi namin mai-optimize nang maayos ang code maaari kaming maubusan ng memorya ng espasyo. Magiging madali ito kapag nagsulat kami ng mahabang mga pahina ng mga code.
Ang anumang pagpapaandar ay magkakaroon ng pagpapaandar na Kahulugan ( sblink (int get) sa aming kaso) at isang pagpapaandar Tumawag ( sblink (1) sa aming kaso). Opsyonal na magkaroon ng isang deklarasyon ng pag-andar, upang maiwasan ito na inilagay ko ang aking kahulugan ng pag-andar bago tawagan ang pagpapaandar sa aking pangunahing pag-andar.
Ang mga parameter ng pagpapaandar ay ang halaga na ipapasa mula sa pag-andar ng tawag sa kahulugan ng pagpapaandar. Sa aming kaso ang mga halaga ng integer (1, 3, 7, 15) ay ang mga parameter na naipasa mula sa function call at ang variable na "get" ay nakakakuha ng halaga ng mga parameter sa kahulugan ng pagpapaandar upang maproseso ang mga ito. Ang isang pagpapaandar ay maaaring magkaroon ng higit sa isang parameter.
Kapag tinawag na ang pagpapaandar, ang mga linya sa ibaba sa kahulugan ng pag-andar ay papatayin.
para sa (int i = 0; i <= 7 && RB0 == 0; i ++) {PORTD = get << i; // LED move Left Sequence __delay_ms (50); } para sa (int i = 7; i> = 0 && RB0 == 0; i--) {PORTD = get << i; // LED move Left Sequence __delay_ms (50); }
Ngayon ang linyang ito ay tila kakaiba: PORTD = get << i . Ipapaliwanag ko kung ano ang totoong nangyayari dito.
Ang "<<" ay isang left shift operator na naglilipat ng lahat ng mga bit sa kaliwang posisyon nito. Ngayon kapag tinawag namin ang pagpapaandar ng sblink (int get) na may parameter na '1' bilang sblink (1), gagawin nitong halaga ang 'get' bilang 1, na sa binary ay 0b00000001. Samakatuwid ang linyang ito ay magiging katulad ng PORTD = 0b00000001 << i .
Ang halaga ng "i" ay mag-iiba mula 0 hanggang 7 mula noong gumamit kami ng isang 'para sa loop' para sa (int i = 0; i <= 7 && RB0 == 0; i ++). Ang halaga ng 'ako' mula 0 hanggang 7 ay magbabago ng resulta tulad ng sumusunod:
Tulad ng nakikita mong naka-ON ang isang LED nang paisa-isa (mula kaliwa hanggang kanan) sa pamamagitan ng pagpapanatiling OFF. Ang susunod na 'para sa loop' para sa (int i = 7; i> = 0 && RB0 == 0; i--) , ay gagawin din ang pareho ngunit sa oras na ito ang LED ay bubukas ON mula kanan pakanan sa kaliwa sa isang pagkakasunud-sunod, habang nagsimula kami mula 7 at bumababa sa 0. Gumamit kami ng isang pagkaantala ng 200ms upang mailarawan namin ang LED na naka-ON at NAKA-OFF.
Ngayon kapag ipinasa namin ang halaga ng 3 sa sblink (int get) na pag- andar, kaya ang pagpapaandar sblink (3) ay isasagawa na ginagawang ang halaga ng 'makuha' bilang 0b00000011, samakatuwid ang resulta sa PORTD ay:
Kaya ngayon sa oras na ito ang dalawang LEDs ay bubuksan sa anumang naibigay na oras sa pamamagitan ng paggamit ng sblink (3). Katulad nito para sa sblink (7) at sblink (15), tatlo at apat na LEDs ay magiging ON sa isang pagkakasunud-sunod. Kapag nakumpleto na ito ay gagawin namin ang lahat ng LED upang magamit ang linya na PORTD = 0xFF . Suriin ang Video sa ibaba para sa buong Pagpapakita.
Inaasahan kong naiintindihan mo ang code at sa gayon ay natutunan kung paano gamitin ang mga pagpapaandar, 'para' at 'habang' loop upang makuha ang iyong nais na mga output. Ngayon ay maaari kang mag-tweak sa paligid ng code upang makuha ang iyong iba't ibang pagkakasunud-sunod ng LED blinking. Sige na ipunin ang iyong code at itapon ito sa iyong MCU at tangkilikin ang output. Maaari mong gamitin ang seksyon ng komento kung makaalis ka sa kung saan. Inilakip ko rin dito ang simulation at mga file ng programa.
Iyon lang ito sa aming susunod na tutorial matututunan natin kung paano gamitin ang mga timer ng PIC16F877A sa halip na gumamit ng mga pagpapaandar na pagkaantala. Maaari mong i-browse ang lahat ng mga tutorial sa microcontroller ng PIC dito.