PIC Tutorial- Mula sa Mga Rehistro sa Mga Pagkagambala

Bago makuha ang mga detalye ng minuto ng PIC na programa, magiging unang kahalagahan upang malaman ang ilang magagandang pamamaraan sa pagprograma.

Pag-unawa sa Mga Rehistro

Upang magsimula sa ipalagay na nagta-type ka ng isang (semicolon) sa anumang punto ng programa, ang lahat na darating pagkatapos ng semicolon na ito ay hindi papansinin ng tagatala, hanggang sa siyempre bumalik sa posisyon ang karwahe.

Pinapayagan kami ng tampok na nasa itaas na magdagdag ng mga komento o puna tulad na hindi sila naging bahagi ng programa ngunit pinapabilis kami upang makilala ang programa sa tulong ng mga komento sa tabi nito. Ang paglalagay ng mga komento ay isang inirekumendang kasanayan habang pinaprograma ang anumang IC.

Susunod na mahalagang bagay sa kurso ay upang magtalaga ng mga pangalan sa iba't ibang mga pare-pareho (malalaman mo ang mga ito nang mas detalyado). Ginagawa nitong aso na mas simple na maunawaan kung ano ang sinusulat, o patungkol sa mga kasangkot na halaga, sa halip na maguluhan sa mga isinasamang numero.

Ang nasa itaas ay dapat gawin sa anyo ng mga tunay na pangalan para sa agarang pagkilala, halimbawa COUNT, mahalagang tandaan na dito ang lahat ng mga malalaking titik ay nagtatrabaho upang gawin itong naiiba at ipahiwatig din na ito ay isang pare-pareho na halaga.

Tulad ng nakikita natin, ang nasa itaas ay ginagawa sa anyo ng isang kahon na gawa sa mga semicolon na ginagawang mas malinis lamang ito. Bilang karagdagan subukan ang pagdodokumento ng programa sa papel din, makakatulong ang kasanayan na ito upang maunawaan ang mga bagay sa isang hakbang na matalino.

2. Ang Mga Rehistro.

Ang rehistro sa loob ng isang PIC ay isang lugar na tumatanggap ng nakasulat na mga detalye pati na rin pinapayagan ang pagbabasa mula rito. Maaari mong ihambing ito sa isang sheet ng papel kung saan maaari mong mailarawan ang mga nilalaman at aso na idagdag sa pamamagitan ng pagsulat dito.

Ang figure sa ibaba ay naglalarawan ng isang tipikal na map file file na naka-embed sa loob ng isang PIC16F84. Ang format ay hindi isang bagay na aktwal na itinakda sa loob ng PIC, simpleng upang ipahiwatig kung paano maaaring ayusin ang mga piraso sa loob ng maliit na tilad at upang maunawaan ang ilan sa mga kasangkot na utos.

Maaari mong makita na ito ay karaniwang nahahati sa Bank 0 at Bank 1. Ang Bank 1 ay responsable para sa pagkontrol sa aktwal na pagtatrabaho ng PIC, halimbawa sa tel ng PIC na ang mga piraso sa Port A ay itinalaga bilang mga input at alin ang bilang mga output.

Ang Bank 2 ay para lamang sa pagmamanipula ng impormasyon.

Unawain natin ito sa pamamagitan ng sumusunod na halimbawa:

Ipagpalagay na nais naming magtalaga ng kaunti sa PortA high. Para dito kakailanganin muna naming pumunta sa Bank 1 para sa pagtatakda ng tinukoy na bit o i-pin sa Port A sa anyo ng isang output. Pagkatapos nito bumalik kami sa Bank 0 at maghatid ng isang lohika 1 (bit 1) sa tukoy na pin na iyon.

Ang pinakakaraniwang mga rehistro na nais naming gamitin sa Bank 1 ay ang STATUS, TRISA at TRISB.

Tinutulungan kami ng STATUS na bumalik sa Bank 0, pinapayagan kami ng TRISA na pumili kung aling mga pin sa Port A ang mga output at alin ang maaaring maging mga input, habang pinapabilis ng TRISB na pumili sa pagitan ng output at input pin sa Port B. Pinapayagan ng gumagamit ang SELIS register sa BANK 0 upang i-flip sa Bank 1.

Ibuod natin ang buong konsepto sa sumusunod na paglalarawan:

STATUS:

Upang lumipat mula sa Bank 0 patungo sa Bank 1 inuutusan namin ang rehistro ng STATUS. Ito ay ipinatupad sa pamamagitan ng pagtatakda ng bit # 5 ng rehistro ng STATUS sa 1. Upang bumalik sa Bank 0, nagtatalaga kami ng bit 5 ng rehistro ng STATUS sa 0. Ang rehistro ng STATUS ay nakaposisyon sa address 03h, dito ay nangangahulugan ng tat ang numero maaaring nasa Hexadecimal.

TRISA at TRISB:

Ang mga ito ay matatagpuan sa address ng 85h at 86h na tumutugma. Para sa pagprograma ng isang pin bilang isang output o isang input, naghahatid lamang kami ng isang zero o isang isa sa partikular na bit sa rehistro. Ngayon ay maaari itong gawin sa dalawang paraan, sa pamamagitan ng binary, o Hex. Kung sakaling hindi ma-convert ng isang tao ang parameter na maaari siyang pumunta para sa isang pang-agham na calculator para sa pagpapatupad ng mga halaga.

Ngayon ay mayroon kaming 5 mga pin sa Port A, na tumutugma sa 5 mga pin. Kung balak nating ayusin ang isa sa mga pin bilang mga input, naghahatid kami ng isang '1' sa partikular na piraso.

Kung sakaling nais naming italaga ang isa sa mga pin bilang mga output, itatakda namin ang tukoy na pin sa '0'. Ang mga piraso ay tumutulong sa eksaktong tumutugma sa mga piraso, o mas tumpak na bit 0 ay RA0, ang bit 1 ay magiging RA1, bit 2 = RA2 at iba pa. Unawain natin ito sa ganitong paraan:

Ipagpalagay na nais mong ayusin ang RA0, RA3 at RA4 bilang mga output, habang ang RA1 / RA2 bilang i / ps, gagawin mo ito sa pamamagitan ng pagpapadala ng 00110 (06h). Suriin na ang bit 0 ay papunta sa kanan tulad ng nakalagay dito:

Port A Pin RA4 RA3 RA2 RA1 RA0

Bit Number 4 3 2 1 0

Binary 0 0 1 1 0

Ganun din sa TRISB.

PORTA at PORTB

Upang maihatid ang isa sa mga output pin na mataas, nag-aalok lamang kami ng isang '1' sa kani-kanilang piraso sa aming rehistro sa PORTA o PORTB. Ang isang magkaparehong pamamaraan ay maaaring sundin para sa mga rehistro ng TRISA at TRISB din. Bago kami mag-bilis sa aming unang halimbawa ng pag-coding, unawain lamang natin ang isang coupe ng maraming mga rehistro, v: w at f.

W at F

Ang W register ay isang ordinaryong rehistro na nagbibigay-daan sa iyo upang magtalaga ng anumang halaga na iyong pinili. Sa sandaling magtalaga ka ng isang magnitude sa W, maaari kang magpatuloy sa pamamagitan ng pagdaragdag nito sa isa pang halaga o ilipat lamang ito. Gamit ang isa pang itinalagang halaga, ang mga detalye ay ma-o-overtake sa W.

Isusulong ng F ang nakasulat na bagay nito sa isang rehistro. Kakailanganin namin ang rehistro ng F na ito upang magtalaga ng isang halaga sa isang rehistro, maaaring higit sa STATUS o sa mga rehistro ng TRISA, dahil hindi kami papayagan na ilagay nang diretso ang mga halaga sa mga ito. Isang Halimbawa ng Programa

Suriin natin ang sumusunod na halimbawa ng code na magpapakita sa amin kung paano ipinatupad ang tagubilin sa itaas at masasaksihan din ang ilang mga tagubilin sa kurso.

Magsimula tayo sa pamamagitan ng pag-aayos ng Port A tulad ng tinalakay sa itaas.

Para sa mga ito kailangan naming ilipat mula sa Bank 0 patungo sa Bank1, ginagawa ito sa pamamagitan ng pagse-set up ng rehistro ng STATUS na matatagpuan sa address 03h, bit 5 hanggang 1.

BSF 03h, 5

Ang BSF Means Bit Set F. Gumagamit kami ng dalawang numero pagkatapos ng tagubiling ito - 03h, na kung saan ay ang rehistro ng STATUS address, at ang bilang 5 na tumutugma sa bilang ng bit.

Kaya, kung ano ang sinasabi namin ay 'Itakda ang bit 5 sa address 03h hanggang 1'.

Nasa Bank 1 na kami ngayon.

MOVLW 00110b

Inilalagay namin ang halagang binary na 00110 (ang titik b ay nangangahulugang ang numero ay nasa binary) sa aming pangkalahatang layunin na magparehistro W. Maaari kong gawin ito sa hex, kung saan ang aming tagubilin ay:

MOVLW 06h

Alinman sa gumagana. Ang MOVLW ay nangangahulugang 'Ilipat ang Halaga ng Literal sa W', na sa English nangangahulugang ilagay ang halagang sumusunod nang direkta sa W magparehistro.

Ngayon kailangan naming ilagay ang halagang ito sa aming TRISA register upang i-set up ang port:

MOVWF 85h

Ipinapahiwatig ng tagubiling ito na 'Ilipat Ang Mga Nilalaman Ng W Sa Ang Rehistrasyong Address na Sumusunod', sa pagkakataong ito ang address ay tumutukoy sa TRISA.

Ang aming rehistro sa TRISA sa puntong ito ay nagtataglay ng bilang 00110, o ipinakita nang grapiko:

Port A Pin RA4 RA3 RA2 RA1 RA0

Binary 0 0 1 1 0

Input / Output O O I I O

Kaya't nagtataglay kami ngayon ng aming mga Port A pin, dapat kaming bumalik sa Bank 0 upang ayusin ang isa sa impormasyon.

BCF 03h, 5

Ang tagubiling ito ay nakakamit ang pabaliktad ng BSF. Ipinapahiwatig nito ang 'Bit Clear F'. Ang isang pares ng mga numero na tumutugma ay ang address ng rehistro, narito ang STATUS register, pati na rin ang bit figure, sa halimbawang ito bit limang. Kung ano ang eksaktong nakumpleto namin sa kasalukuyan ay, tinukoy ng kaunti sa aming

Nagrehistro ang STATUS sa 0

Bumalik kami sa puntong ito sa Bank 0.
Ang sumusunod ay ang code lahat sa isang bloke:

BSF 03h, 5 Pumunta sa Bank 1
MOVLW 06h Ilagay ang 00110 sa W
MOVWF 85h Ilipat ang 00110 papunta sa TRISA
BCF 03h, 5 Bumalik sa Bank 0

Sa loob ng huling pagtuturo, nakumpirma namin sa iyo ang paraan upang maitaguyod ang mga port ng IO port sa PIC na posibleng maging input o output.

Sa pamamagitan ng kursong ito, Hayaan akong tulungan kang magpadala ng data sa mga port.

Pagpapadala ng Data sa Mga Port

Sa kasunod na tutorial, makukumpleto namin sa pamamagitan ng pag-flash ng isang LED on at off na binubuo ng isang kumpletong pagdedetalye ng programa at isang prangka na circuit diagram upang maaari mong makita ang PIC na gumaganap nang tumpak kung ano ang inaasahan namin ito.

Huwag subukang pagsamahin at i-program ang iyong PIC sa mga resulta sa ibaba, dahil ang mga ito ay mga guhit lamang. Sa una, itataguyod namin ang Port A bit 2 bilang isang output:

Maaari itong makilala mula sa nakaraang pagtuturo. Ang nag-iisang pagkakaiba ay maaaring Naayos namin ang bawat piraso ng mga pin sa A bilang output, sa pamamagitan ng paghahatid ng 0h sa tri-state register. Kaya kung ano ang dapat niyang gawin ngayon ay lumipat ng isang LED.

Natapos namin ito sa pamamagitan ng pag-iiskedyul ng isa sa mga pin (ang isa na may naka-link na LED dito) na mataas. Upang mailagay ito nang naiiba, inilalagay namin ang isang '1' sa pin. Ito ay eksaktong eksakto kung paano ito isinasagawa (obserbahan ang mga komento para sa isang paglilinaw para sa bawat linya):

Samakatuwid, kung ano ang nagawa natin ngayon ay i-on ang LED pagkatapos ay i-off nang isang beses. Ang nais namin ay ang LED upang lumipat sa magkakasunod na patay na patuloy.

Nakakamit natin ito sa pamamagitan ng pagkuha ng programa upang bumalik sa simula. Natapos namin ito sa pamamagitan ng unang pagtataguyod ng isang tag sa simula ng aming programa, pagkatapos ay ipapaalam sa programa na magpatuloy doon. Tinutukoy namin ang isang tag nang deretso.

Sinisimulan namin ang isang term, sinasabi na MULA, susunod na i-type ang code:

Tulad ng ipinakita, una naming binanggit ang expression na 'Magsimula' kaagad sa simula ng programa.

Susunod, sa huling pagtatapos ng programa malinaw na binanggit namin ang 'goto Start'. Ginagawa ng tagubilin na 'goto' kung ano ang idineklara nito.

Ang program na ito ay patuloy na magpapalipat-lipat sa LED tuwing pinalalakas namin ang circuit, may posibilidad na patayin sa sandaling alisin namin ang kuryente. Maaari nating suriin muli ang aming programa:

Tiyak na tinanggal namin ang mga komento, subalit maaari pa rin naming obserbahan ang mga tagubilin at numero.

Maaari itong maging isang maliit na nakakagulat sa paglaon kung sakaling subukan mo ang pag-troubleshoot ng programa at habang sinusulat ang code na kabisado mo ang al ng mga address.

Kahit na ang mga komento ay maaaring mailagay pa rin maaari itong maging isang medyo kalat. Mangangailangan ito ng pagbibigay ng pangalan ng mga numero at maaaring magawa ng isang karagdagang tagubilin: nagpapahiwatig ang pagtuturo ng 'equ' Ang 'equ' na ang ilang mga bagay ay maaaring katumbas ng ibang mga bagay.

Maaaring hindi ito isang tagubilin para sa PIC, sa halip para sa nagtitipon. Pinapabilis ng tagubilin na ito ang pagtatalaga ng pangalan sa isang lokasyon ng address ng rehistro, o isang pare-pareho sa isang termino sa pagprograma.

Kami ay magtataguyod ng ilang mga pare-pareho para sa aming programa at masaksihan din kung gaano prangka ang pagbabasa ng programa.

Simula ngayon ay naayos namin ang pare-pareho ang mga halaga na maaari naming magpatuloy sa pamamagitan ng pagse-set up ng mga ito sa aming programa. Ang mga pare-pareho na halaga ay kailangang italaga bago gamitin ang mga ito.

samakatuwid siguraduhin na palaging iposisyon ang mga ito sa simula ng programa. Isusulat namin muli ang programa na hindi kasama ang mga komento muli, upang ihambing ang naunang pag-label sa pinakabago.

Maaari mong mapansin na ang mga nagpapatuloy ay nagbibigay-daan sa kaunting mas madaling pag-unawa sa programa, subalit wala pa rin kaming mga puna, walang mga alalahanin, dahil hindi pa kami tapos.

Maaaring may isang maliit na downside ng aming flashing LED program.
Ang bawat pagtuturo ay nangangailangan ng 1 na pagkakasunud-sunod ng orasan upang matapos. Kung sakaling gumagamit kami ng isang 4MHz na kristal, pagkatapos ang bawat pagtuturo ay tumatawag para sa 1 / 4MHz, o 1uS upang matapos.

Dahil gumagamit kami ng limang mga tagubilin lamang, ang LED ay maaaktibo pagkatapos ay 5uS. Ito ay maaaring maging napakabilis para mapansin ng mga tao, bilang karagdagan, mukhang ang LED ay ganap na nakabukas.

Ang dapat nating magawa sa halip ay gumawa ng isang pagsugpo sa pagitan ng paglipat ng LED at pag-patay ng LED. Ang teorya ng pagsugpo ay ang pagbibilang namin mula sa isang naunang dami, kaya kapag umabot sa zero, huminto kami sa pagbibilang.

Ang zero na halaga ay nangangahulugang ang pagtatapos ng pagkaantala, at patuloy naming ginagawa ang aming proseso sa buong programa. Samakatuwid, ang unang dapat nating gawin ay upang matukoy ang isang pare-pareho na gagamitin bilang aming counter.

Tapusin natin ang patuloy na COUNT na ito. Pagkatapos nito, dapat nating matukoy kung gaano kahalaga ang isang numero upang magsimulang magbilang mula. Tiyak, ang pinakamalaking figure na maaari naming isama ay 255, o FFh sa hex., Tulad ng pinag-usapan ko sa naunang tutorial, ang panturo na pagtuturo ay nagtatalaga ng isang expression sa isang sitwasyon ng rehistro.

Ipinapahiwatig nito na anuman ang dami naming inilalaan sa aming COUNT, tutugma ito sa mga item ng isang rehistro. Kung sakaling susubukan naming italaga ang halagang FFh, magkakaroon kami ng pagkakamali sa sandaling makuha namin ang compile ng programa.

Ang dahilan kung bakit ang lokasyon FFh ay, samakatuwid hindi kami makakakuha ng access dito. Samakatuwid, paano namin dapat italaga ang isang tunay na numero? Tiyak, mangangailangan ito ng isang maliit na pag-iisip ng pag-lateral.

Kung marahil ay itinalaga namin ang aming COUNT sa address na 08h, halimbawa, ipahiwatig nito ang isang pangunahing patutunguhan sa pagrehistro ng layunin. Bilang default, ang mga hindi nagalaw na lugar ay nakatakda sa FFh. Dahil dito, kung ang COUNT ay humahantong sa 08h, makaka-engkwentro ka sa halaga ng FFh habang una kaming nagpapatakbo. Gayunpaman, ako ikaw, paano namin maaayos ang COUNT sa isa pang numero?, Ang inilalapat lamang namin ay ang 'paglipat' ng isang pagpapahalaga sa patutunguhang ito.

Bilang isang ilustrasyon, ipalagay na hinahangad namin na ang COUNT ay magtaglay ng halagang 85h, hindi namin mabanggit ang COUNT equ 85h dahil iyon ang posisyon ng labas ng rehistro ng Tri-State para sa Port A. Tiyak na ang nagawa namin ay ang sumusunod: Movlw 85hFirst put ang halaga ng 85h sa W rehistro Movwf 08h

Ngayon ilipat ito sa aming 08h register. Kasunod, kung sakaling ipahayag namin ang COUNT pantay na 08h, ang COUNT ay tutugma sa halagang 85h. Maselan, hindi ba! Samakatuwid, sa una tinutukoy namin ang aming pare-pareho: COUNT equ 08h Sumusunod dapat nating bawasan ang COUNT na ito ng isa hanggang sa maging zero.

Nangyayari lamang ito na mayroong isang tagubilin na idinisenyo upang magawa ito para sa amin, sa pamamagitan ng paggamit ng isang 'goto' at isang tag.

Ang tagubiling ilalapat namin ay: DECFSZ COUNT, 1 Ang tagubiling ito ay nagsasaad ng ‘Bawasan ang rehistro (narito ang COUNT) sa pamamagitan ng bilang na sumusubaybay sa kuwit. Kung makamit natin ang zero, lumukso ng dalawang puwesto sa unahan. ’Hahanapin muna natin ito sa aksyon, bago natin ito ilagay sa ating kurso.

Ang aming nagawa ay paunang itinatag ang aming pare-pareho na COUNT hanggang 255. Ang kasunod na segment ay pumoposisyon sa isang tag, na tinawag na LABEL malapit sa aming tagubilin sa decfsz.

Ang decfsz COUNT, 1 ay binabawasan ang halaga ng COUNT nang isa, at pinapanatili ang resulta ng diretso sa COUNT. Bukod dito pinatutunayan nito upang suriin kung ang COUNT ay nagtataglay ng halagang 0.

Kung hindi, ito sa kasong iyon ay nagpapalitaw ng programa na lumipat sa kasunod na linya. Ngayon mayroon kaming isang deklarasyong 'goto' na naghahatid sa amin pabalik sa aming tagubilin sa decfsz.

Kung sakaling ang halaga ng COUNT ay gumaganap nang pantay-pantay, pagkatapos ang mga resulta ng tagubilin ng decfsz sa aming programa upang tumalon nang 2 mga puwang sa unahan, at ipapadala sa kung saan Kami ay nag-angkin na 'Magdala dito'.

Samakatuwid, dahil maaari mong obserbahan, nagdala kami ng programa na umupo sa isang lugar para sa isang natukoy na oras bago magpatuloy. Maaaring mapangalanan itong isang loop ng pagkaantala.

Pag-unawa sa Mga Pag-antala ng Loops

Kung sakaling nangangailangan kami ng isang mas malaking pagkaantala, maaari naming ituloy ang isang loop sa susunod. Ang sobrang mga loop, ang pinalawig ang pagkaantala. Hayaan mo kaming hindi bababa sa dalawa, sa pag-aakalang nais naming obserbahan ang LED flash .. Ilalagay namin ang mga pagkaantala ng mga loop sa aming programa, at makamit sa pamamagitan ng pagbibigay nito ng isang tunay na programa sa pamamagitan ng pagpapakilala ng mga komento:

Posibleng maipon ang program na ito pagkatapos kung aling programa ang PIC. Malinaw na, tiyaking tinatangka mo ang circuit upang suriin kung talagang gumagana ito. Ang sumusunod ay isang circuit diagram na dapat mong buuin sa sandaling na-program mo ang PIC.

Magaling, maaari mong aktwal na binubuo ang iyong unang programa ng PIC, pati na rin ang konstruksyon ng isang circuit upang pumikit ang isang LED on at off. Hanggang ngayon, kung sakaling nasundan mo ang mga kursong ito, maaaring natutunan mo ang pangkalahatang pitong tagubilin sa labas ng 35, ngunit walang pag-aalinlangan sa ngayon maaari mong kontrolin ang mga I / O port!

Susubukan mo bang baguhin ang mga antalang loop upang mai-render ang LED flash nang mas mabilis - ano ang lilitaw ang kaunting halaga ng COUNT upang mahalagang makita ang LED flash? O marahil, gugustuhin mong isama ang isang ika-3 o pandagdag na mga antalang loops pagkatapos ng paunang isa upang patatagin ang LED pababa. isang natatanging pare-pareho para sa bawat pagkaantala loop.

Maaari mong potensyal na mag-rebound sa iyong mga antalang loop upang mai-render ang LED flash sa isang tukoy na bilis, halimbawa pagkatapos ng isang segundo. Sa loob ng susunod na pagtuturo ipaalam sa amin makita kung paano namin magagamit ang isang bagay na kilala bilang isang subroutine upang mapanatili ang programa na compact at pangunahing Ang isang subroutine ay isang mahalagang bahagi ng code, o programa, na maaaring tinukoy bilang at kung kailan mo maaaring kailanganin ito. Ang mga subroutine ay ginagamit sa mga kaso kung saan ka nakakamit ng madalas na magkaparehong pagpapaandar.

Ano ang mga Subroutine

Ang mga pakinabang ng paggamit ng isang subroutine ay malamang na mas simple na baguhin ang halaga nang isang beses sa loob ng isang subroutine sa halip na, sabihin, sampung beses sa lahat sa pamamagitan ng iyong programa, pati na rin itong nag-aambag nang malaki upang bawasan ang antas ng memorya na naubos ng iyong programa sa loob ng PIC. Susuriin namin ang isang subroutine:

Sa una, kailangan naming ibigay ang aming subroutine isang pagtatalaga, at sa sitwasyong ito Pinili namin ang ROUTINE. Pagkatapos naming i-type ang code na nais naming isagawa bilang normal. Iyon ang dahilan kung bakit, Napili namin ang pagkaantala sa aming flashing led program. Panghuli, natatapos namin ang subroutine sa pamamagitan ng pag-keying sa tagubilin na RETURN.

Upang simulan ang subroutine mula sa kahit saan sa aming programa, mabilis naming nai-type ang tagubilin na Tawag at pagkatapos ang pagtatalaga ng subroutine.

Isasaalang-alang namin ito sa kaunting lalim pa. Kapag nakarating kami sa seksyon ng aming programa na TUMAWAG ng xxx, kung saan ang xxx ang pangalan ng aming subroutine, lumulundag ang programa sa kahit saan na naka-install ang subroutine xxx. Ang mga tagubilin sa loob ng subroutine ay isinasagawa.

Kailan man magawa ang pagtuturo ng PAGBABALIK, tatalon ang programa na babalik sa aming punong programa sa tagubilin kasunod sa aming CALL xxx na tagubilin.

Posibleng tawagan ang katulad na subroutine nang maraming beses hangga't gusto mo, na nagpapaliwanag kung bakit ang paggamit ng mga subroutine ay nagpapabawas sa pangkalahatang tagal ng aming programa.

Gayunpaman, mayroong isang pares ng mga kadahilanan na dapat mong malaman. Sa una, tulad ng sa aming punong-guro na programa, ang anumang mga tukoy na pare-pareho ay kailangang kilalanin bago mo magamit ang mga ito.

Maaari itong kilalanin sa loob mismo ng subroutine, o direkta sa simula ng punong-guro na programa. Ipinapanukala ko sa iyo na kilalanin mo ang lahat sa simula ng iyong pangunahing programa, mula noon kinikilala mo na ang mga bagay ay nasa magkatulad na posisyon. Susunod, dapat tiyakin ng isa na ang pangunahing programa ay lumaktaw sa subroutine.

Ang ipinahihiwatig ko rito ay dapat mong ilagay ang subroutine nang direkta sa pagtatapos ng iyong pangunahing programa, maliban kung gumamit ka ng isang deklarasyong 'Goto' upang lumundag kung nasaan ang subroutine, magpapatuloy ang programa at ipapatupad ang subroutine anuman ang ikaw ay kailanganin ito sa o kung hindi man.

Ang PIC ay hindi makikilala sa pagitan ng isang subroutine at ng punong-guro na programa. Susuriin namin ang aming flashing led program, subalit sa oras na ito gagamitin namin ang isang subroutine para sa loop ng pagkaantala. Sa isip, matutuklasan mo kung gaano ka gaanong kumplikado ang paglitaw ng programa, pati na rin maaari mong makita kung paano praktikal na nalalapat ang subroutine.

Sa paglaon, maaari mong obserbahan na sa pamamagitan ng paggamit ng isang subroutine para sa aming pagkaantala loop, maaaring nabawasan namin ang mga sukat ng programa.

Sa tuwing nais natin ang isang pagkaantala, posibleng kapag naka-on o naka-off ang LED, karaniwang tinatawag naming subroutine ang pagkaantala. Sa pagtatapos ng subroutine, ang programa ay humantong sa linya sa pagsunod sa aming tagubilin na 'Tawag'. Sa ilustrasyon sa itaas, i-flip namin ang LED.

Pagkatapos namin makipag-ugnay sa subroutine. Bumalik ang programa sa order upang magawa naming patayin ang LED. Tawag namin muli ang subroutine, kung sakaling maaaring nakumpleto ang subroutine, bumalik ang programa at ang kasunod na tagubilin na kinikilala nito ay 'goto Start'. Para sa sinumang maaaring ma-intriga, ang aming unang programa ay 120 bytes ang haba.

Sa pamamagitan ng paggamit ng subroutine, mabawasan namin ang laki ng aming programa hanggang sa 103 bytes. Hindi ito maaaring maging kamangha-mangha, subalit isinasaalang-alang ang katotohanan na mayroon lamang kaming 1024 bytes sa pangkalahatan sa loob ng PIC, bawat maliit na halaga ng mga benepisyo.

Sa loob ng susunod na pagtuturo, suriin natin ang pagbabasa mula sa mga port.

Sa ngayon, nagsusulat kami sa Port A upang makapag-switch at patayin ang isang LED. Sa puntong ito, makikita natin kung paano namin babasahin ang mga I / O na pin sa mga port.

Pagbabasa ng Mga Input / Output Port

Ito mismo ay upang matiyak na nakakapag-link kami ng isang panlabas na circuit, at naiimpluwensyahan ang anumang mga tukoy na output na inaalok nito.

Dapat mong kabisaduhin mula sa aming mga naunang kurso, kung nais mong maitaguyod ang mga I / O port, kailangan naming tumalon mula sa Bank 0 patungo sa Bank 1. Gagawa muna namin iyon:

Sa puntong ito naayos na namin ang bit 0 ng Port A upang mai-input. dapat nating suriin ngayon kung ang pin ay mataas o mababa. Upang magawa ito, maaaring magamit ng isa lamang ang isa sa dalawang mga tagubilin:

BTFSC at BTFSS.

Ang tagubilin ng BTFSC ay nangangahulugang 'Gumawa ng kaunting pagsubok sa rehistro pati na rin ang itinalagang bit namin.

Kung sakaling ito ay isang 0, sa kasong iyon ay tinanggal namin ang kasunod na tagubilin '. Ipinapahiwatig ng BTFSS na 'Gumawa ng kaunting pagsubok sa rehistro at kaunting itinataguyod namin. Kung sakaling ito ay nakatakda sa isang 1, pagkatapos ay lampasan namin ang kasunod na tagubilin.

Alin sa ginagamit namin, natutukoy ng tiyak kung paano namin nais na tumugon ang aming programa habang pinag-aaralan namin ang input. Bilang isang paglalarawan, kung naghihintay lang kami ng input na maging isang 1, pagkatapos ay maaari naming magamit ang tagubilin ng BTFSS sa sumusunod na pamamaraan:

Code dito:

BTFSS PortA, 0 simulan ang Larawan na Magdala dito:
:

Ang programa ay lilipat lamang sa 'Dalhin dito' sa kondisyon na ang bit 0 sa PortA ay naka-iskedyul sa isang 1.

Kasalukuyan kaming magsusulat ng isang programa na maaaring mag-prompt ng isang LED sa isang rate, subalit kung ang isang switch ay nakakulong ay i-flash nito ang LED ng dalawang beses nang mas mabagal.

Posibleng marahil gamitin ang program na ito para sa iyong sarili, isinama pa rin namin ang listahan kahit papaano.

Maaari mong subukan at akda ang buong programa, upang masuri kung sakaling naunawaan mo ang mga prinsipyo. Gagamitin namin ang katumbas na circuit tulad ng dati, kasama ang pagsasama ng isang switch na nakakabit na RA0 ng PIC at ang positibong riles ng aming supply.

Ang nagawa natin dito ay upang buksan ang LED. Kasunod kong natutukoy kung ang switch ay nakasara.

Kung sakaling nakakulong ito, susunod na kumokonekta ako sa aming pagkaantala ng subroutine. Nagbibigay ito sa amin ng katumbas na pagkaantala tulad ng dati, subalit sa puntong ito ay nakikipag-ugnay kami sa dalawang beses.

Nalalapat ang parehong bagay sa tuwing patay ang LED. Kung sakaling ang switch ay hindi nakasara, pagkatapos ay naitala namin ang aming naunang naitala sa at off na mga panahon.

Sinusundan mo ba ang mga araling ito mula sa simula, maaaring hinahangad mong maunawaan na kasalukuyan mong natuklasan ang sampu sa 35 mga tagubilin para sa PIC 16F84! At bawat piraso ng mga ito ay nangyayari na natutunan lamang sa pamamagitan ng paglipat ng isang LED on at off.

Hanggang sa ngayon, binubuo namin ang PIC blink isang LED on at off.

Kasunod ay may kakayahan kami sa aming PIC sa pamamagitan ng pagsasama ng isang switch, samakatuwid ay nag-iiba ang bilis ng flash.

Mahusay na Paggamit ng Memory Space

Ang nag-iisang isyu ay, ang programa ay medyo mahaba at sa halip hindi mabisa ng puwang ng memorya. Tila ok habang isinama ko ang mga utos sa kauna-unahang pagkakataon, subalit dapat mayroong isang mas madaling paraan ng pagpapatupad nito. Positive na mayroong, susuriin namin kung paano namin literal na binubuksan at naka-off ang LED.

Movlw 02hmovwf PORTAmovlw 00hmovlw PORTA

Sa una pinalamanan namin ang aming w magparehistro sa 02h, pagkatapos na ilipat ito sa aming rehistro sa PortA upang i-on ang LED. Upang patayin ito, naka-pack kami ng 00h pagkatapos na ilipat ito sa aming pagrehistro sa PortA.

Sa pagitan ng lahat ng mga gawain na ito napilitan kaming makipag-ugnay sa isang subroutine upang matiyak na maaari naming obserbahan ang LED flashing.

Samakatuwid, kailangan naming ilipat ang dalawang hanay ng impormasyon ng ilang beses (isang beses sa w magparehistro pagkatapos ay sa PORTA) pati na rin tumawag sa isang subroutine ng dalawang beses (isang beses para sa pagkatapos ay isang beses para sa off). Sa gayon, paano natin makakamit ito na may idinagdag na kahusayan? Napakasimple.

Gumagamit kami ng iba't ibang tagubilin na kilala bilang XORF. Gumagawa ang tagubilin ng XORF ng isang Eksklusibo O pagpapaandar sa rehistro na itinakda namin sa impormasyong ibinibigay namin. Naniniwala akong kailangan kong linawin kung ano sa mundo ang isang Eksklusibo O bago tayo magpatuloy. Kung sakaling mayroon kaming dalawang mga input, at isang output, ang input ay maaari lamang isang 1 kung, at hangga't, magkakaiba ang dalawang input. Habang pareho ang mga ito, malamang na ang output ay 0. Ang sumusunod ay isang talahanayan ng katotohanan, para sa mga indibidwal na pipiliin na suriin ang mga ito:

A B F0 0 00 1 11 0 11 1 0

Susubukan namin sa puntong ito kung ano ang nangyayari kung bibigyan namin ang B tulad ng aming naunang output, at binabago lamang ang halaga ng A:

A B F
0 0 0
0 0 0
1 0 1
1 1 0
1 0 1

Kung panatilihin namin ang halaga ng Isang pareho sa 1, at Eksklusibo namin O ito sa output, ang output ay magpalipat-lipat. Kung sakaling hindi mo ito mapansin mula sa talahanayan ng katotohanan, sa ibaba ay masasaksihan ang paggamit ng binary:

0 Kasalukuyang Output
EX-O Sa 1 1 Bagong Output
EX-O Sa 1 0 Bagong Output

Siguro maaari mong makita na sa pamamagitan ng eksklusibong ORing output na may 1, i-toggle namin ngayon ang output mula 0 hanggang 1 hanggang 0.
Samakatuwid, upang i-on at i-off ang aming LED, nangangailangan lamang kami ng isang pares ng mga pangungusap:

MOVLW 02h
PINTONG XORWF, 1

Ano ang tiyak na makakamtan namin ay pagdaragdag ng aming w magparehistro sa 02h. Kami ay nasa kasong iyon Eksklusibo na ORING ang numerong ito kahit na ano ang nasa aming PortA. Kung sakaling ang bit 1 ay isang 1, magbabago ito sa isang 0. Kung sakaling ang bit 1 ay isang 0, babaguhin ito sa isang 1. Suriin natin ang code na ito isang beses o dalawang beses, upang maipakita kung paano ito tumatakbo sa binary:

PINTOR
00010
xorwf 00000
xorwf 00010
xorwf 00000
xorwf 00010

Hindi namin talaga kailangang i-load ang magkaparehong halaga sa aming pagrehistro sa bawat oras, samakatuwid posible na magawa ang isang oras na ito sa simula, at simpleng tumalon pabalik sa aming toggle command. Bilang karagdagan, hindi namin dapat ayusin ang isang halaga sa aming pagrehistro sa PortA. Ang dahilan? Tiyak, dahil sa kaso ng power up ito ay isang 1, madali natin itong mapapalitan. Ako, bilang kahalili isang 0 sa power up, gagawin pa namin ito ngayon.

Samakatuwid nais mong makita ang aming bagong nabuo na code. Ang una ay kumakatawan sa aming kumikislap na LED code, habang ang pangalawa ay nagpapakita ng isa na may karagdagan ng switch:

Hinahayaan mong makita mo na sa pamamagitan lamang ng paggamit ng isang madaling tagubilin, nabawasan namin ngayon ang sukat ng aming programa. Ang totoo, upang maipakita kung gaano namin mabawasan ang aming mga programa sa pamamagitan ng, Ipinakita namin ang dalawang programa, kung ano ang binubuo, at ang kanilang mga sukat sa talahanayan sa ibaba:

Mga Dimensyon ng Pagbabago ng Programa (Bytes)
Flashing LED Orihinal 120
Idinagdag ang Flashing LED Subroutine 103
Flashing LED XOR Function na Ginamit 91
LED With Switch Orihinal 132
LED With Switch XOR Function Ginamit 124.

Samakatuwid, hindi lamang namin natuklasan ang ilang mga tagubilin sa nobela, tiyak na bilang karagdagan ay nabawasan ang laki ng aming pag-script!

Sa ibaba, susuriin namin kung paano mo mapalitan ang mga indibidwal na piraso, isakatuparan ang ilang prangka na aritmetika, pati na rin ang mga talahanayan ng data.

Mga Lohikal na Tagapamahala

Sa loob ng huling tutorial ipinakita ko ang Eksklusibong OR operasyon. Ang pagpapaandar ng ExOR ay nauunawaan bilang isang lohikal na operator.

Sa loob ng tutorial na ito ay malilinaw ko ang karagdagang mga lohikal na operator na isinusulong ng PIC. Hindi magkakaroon ng anumang uri ng kaso sa mga point program, subalit Malalaman namin ang mga madaling pamamaraan upang magamit ang mga operator sa pamamagitan ng paglalapat ng maliliit na lugar ng code.

AT Karaniwang pinag-aaralan ng pagpapaandar ng AND ang dalawang piraso at naghahatid ng isang 1 kung pareho ang mga ito, at isang 0 kung sakaling magkakaiba ang mga ito. Halimbawa, kung binanggit namin ang 1 AT 1, ang kinalabasan ay 1, habang sa kaso na idineklara namin ang 1 AT 0 ang kahihinatnan ay 0.

Hindi na kailangang sabihin, nakapag-aralan din namin ang mga salita, pati na rin ang lahat ng mga natapos na pag-andar ng AT ay suriin nang kaunti ang dalawang mga termino. Ang halimbawa sa ibaba ay nagpapakita ng dalawang 8-bit na salitang nagiging ANDed kasama ang produkto:

11001011
AT 10110011
Katumbas ng 10000011

Inaasahan kong sumasang-ayon ka, ang kinalabasan ay magkakaroon lamang ng isang 1 tuwing magkakasabay ang 2 1 sa bawat isa sa isang pares ng mga salita. Nagagamit namin ang pagpapaandar ng AT upang mapatunayan ang mga port, halimbawa.

Kung sakaling susuriin namin ang ilang mga I / O na pin na naka-link sa isang circuit, at dapat nating bantayan ang isang partikular na sitwasyon kung saan ilan lamang sa mga pin ang mataas, sa kasong iyon magagawang basahin natin ang port, pagkatapos kung saan AT ang kinalabasan kasama ang kundisyon na sinusuri namin, kapareho ng halimbawa sa itaas.

Nagbibigay ang PIC ng dalawang sangkap para sa AT.
Sila ay ANDLW at ANDWF. Pinapayagan kami ng ANDLW na magsagawa ng isang pag-andar AT kasama ang mga detalye ng rehistro ng W, at isang halaga na itinakda namin.

Ang syntax ay: ANDLW kung saan eksaktong eksaktong pupuntahan natin AT ang mga nilalaman ng W kasama.

Ang kahihinatnan ng pag-andar ng AT ay maiimbak nang direkta sa W rehistro.
Pinahihintulutan kami ng ANDWF na magsagawa ng isang pag-andar AT sa pagrehistro sa W at isang iba't ibang rehistro, halimbawa ng isang PORT. Ang syntax ay: ANDWF, d kung saan ang rehistro na masigasig kami tungkol sa, hal. Ipinapakita ng PORTA, at d ang PIC kung saan mo dapat iposisyon ang resulta. Kung d = 0, ang kinalabasan ay inilalagay sa W register, at ng d = 1 ang resulta ay nai-save sa rehistro na itinakda namin. Ang dalawang bahagi ng code sa ibaba ay nagpapakita ng isang magandang halimbawa ng bawat pag-andar ng AT.

Ang inisyal ay sinusuri ang katayuan ng PORTA, kung saan kailangan nating suriin kung ang mga input ay 1100. Maaari nating ibalik ang kinalabasan sa W register

ilipat ang 1100
ANDWF 05h, 0 Ang pangalawang ilustrasyon ay maaari na ngayong i-verify ang mga nilalaman ng rehistro ng W:
ANDLW 1100

O kaya

Natuklasan namin ngayon ang isang O pag-andar, upang maging tumpak ang XOR. Ito ay bubuo sa isang 1 kung ang dalawang mga piraso ay hindi pareho, ngunit magkakaiba. Maaari kang makahanap ng isa pang pagpapaandar na O tinatawag na IOR, na kung saan ay kasama ang OR. Ang pagpapaandar na ito ay bubuo ng isang 1 kung sakaling ang alinman sa bit ay isang 1, ngunit bilang karagdagan kung ang bawat piraso ay 1. Sa ibaba ay isang malinaw na hiwa na talahanayan ng katotohanan upang ilarawan ito:

A B O / P
0 0 0
0 1 1
1 0 1
1 1 1

Ano ang Mga Operator ng Arithmetic

ADD

Natutupad ng pagpapaandar na ito kung ano ang karaniwang inaangkin nito. Nagbibigay ito ng dalawang numero! Kung sakaling ang kinahinatnan ng pagdaragdag ng dalawang numero ay lumalagpas sa 8 bits, sa kasong iyon ay maaaring itakda ang isang flag ng CARRY. Ang watawat ng CARRY ay matatagpuan sa address na 03h bit 0.

Kapag naiskedyul ang bit na ito, nalampasan ng dalawang pigura ang 8 bits. Kapag ito ay isang 0, sa kasong iyon ang kinahinatnan ay matatagpuan sa loob ng 8 bits. Tulad ng dati, ang PIC ay naghahatid sa amin ng dalawang mga istilo ng ADD, partikular na ang ADDLW at ADDWF. Tulad ng maaaring ipinapalagay mo, ito ay katulad ng pagpapaandar sa itaas. Nag-aalok ang ADDLW ng mga nilalaman ng pagrehistro sa W na itinakda namin. Ang syntax ay: ADDLW ADDWF idagdag ang mga nilalaman ng W register at ilang iba pang rehistro na itinalaga namin.

Ang syntax ay: ADDWF, d ay kung saan

SUB

Sa puntong ito, sa palagay ko hindi mo maaaring ipalagay kung ano ang isinasagawa ng pagpapaandar na ito! Sa katunayan, pinaghihinalaan mo ito, ang pagpapaandar na ito
binabawas ng kaunti mula sa isa pa. Muli ang PIC ay nagbibigay sa amin ng 2 panlasa: SUBLW at SUBWF. Ang syntax ay tiyak na katulad sa para sa pag-andar ng ADD, bukod sa maliwanag na nagta-type ka ng SUB bilang kapalit ng ADD!

Pagdaragdag Kung sakaling nais naming isama ang 1 sa isang numero sa PIC, maaari naming ganap na magamit ang pag-andar ng ADD, at magamit ang numero uno. ~ Ang kahirapan dito ay dapat muna nating ilagay ang pigura sa pagrehistro sa W, pagkatapos ay gamitin ang kontrol ng ADDLW 1 upang madagdagan ito. Kung sakaling ninanais naming isama ang 1 sa isang rehistro, maaari itong maging mas masahol pa. Dapat muna nating ilagay ang numero 1 sa pagrehistro sa W, pagkatapos na gamitin ang ADDWF, 1. Samakatuwid, halimbawa, upang isama ang 1 sa lokasyon na 0C, sabihin, kakailanganin nating taglayin ang sumusunod na bahagi ng script:

ilipat ang 01
addwf 0c, 1

Mayroong isang mas madaling paraan ng pagsasagawa nito. Maaari nating gamitin ang utos na INCF. Ang syntax ay: INCF, d kung saan, ang rehistro, o lugar, na pinag-aalala namin, at ipinapakita ang d sa PIC kung saan mo dapat iposisyon ang kinalabasan. Sa kaso d = 0, ang kinalabasan ay nasa loob ng pagrehistro ng W, at kung sakaling d = 1, ang resulta ay nakatakda sa rehistro na itinakda namin.

Sa pamamagitan ng paggamit ng indibidwal na tagubilin na ito ay talagang makakakuha kami ng limampung porsyento ng coding. Kung sakaling ninanais namin ang kinalabasan na naibalik sa rehistro ng W, sa kasong iyon na gumagamit ng halimbawa sa itaas, maaaring kailanganin naming isama ang isang karagdagang utos upang ilipat ang mga item ng 0C pabalik sa rehistro ng W, pagkatapos kung saan ilagay ang rehistro ng 0C pabalik sa mahalaga kung ano ito

Mayroong umiiral na utos ng pagtaas. Ito ay INCFSZ. Ang utos na ito ay maaaring dagdagan ang rehistro na itinakda namin, subalit kung kami ang rehistro ay katumbas ng 0 pagkatapos ng pagtaas (magaganap iyon habang isinasama namin ang 1 hanggang 127) pagkatapos nito ay maaaring ipasa ng PIC ang kasunod na tagubilin. Ang bahagi ng code sa ibaba ay sumasalamin nito:

Loop incfsz 0C
Goto Loop
:
:
Natitirang programa.

Sa itaas na bahagi ng code, ang 0C ay madaragdagan ng 1. Susunod na pagmamay-ari namin ang isang tagubilin na nagpapaalam sa PIC na bumalik sa aming tag na pinangalanang Loop, at dagdagan muli ang 0C ng 1. Nagpapatuloy ito hanggang sa 0C ay katumbas ng 127. Sa pangyayaring ito, kapag nadagdagan namin ang 0C ng 1, 0C ay tutugma na ngayon 0. Ang aming INCFSZ na tagubilin ay maaaring napakahusay na ipaalam sa PIC na alisin ang kasunod na tagubilin, na sa pagkakataong ito ay ang deklarasyon ng goto, samakatuwid ang PIC ay magpapatuloy sa natitirang programa.

Pagbawas

Napag-usapan na namin ngayon ang pag-andar ng pagbawas sa naunang pagsasanay, samakatuwid hindi ko na ito susuriin pa.

Komplementa

Ang pangwakas na tagubilin sa talakayang ito ay babaligtarin ang bawat solong bahagi sa rehistro na itinakda namin. Ang syntax ay: COMF, d kung saan

Pag-unawa sa Mga Operasyong Bit

Maaari itong magamit, halimbawa, upang mabilis na ipagpalit ang mga pin ng isang port mula sa output hanggang sa input at iba pa. Pinapayagan kami ng mga pagpapaandar ng bit na hugis ng isang solong bit sa loob ng isang expression. Pinapayagan nila kaming magpatuloy, magtakda at magtanggal ng mga solong piraso sa mga rehistro o numero na itinakda namin.

Sa pagtatapos ng kursong ito Isisiwalat namin ang isang programa na idinisenyo upang lumikha ng isang hanay ng mga ilaw sa pagsunud-sunod na magpatuloy, pagkatapos ay ang pabalik na paraan. Naobserbahan namin ito na nagawa nang mas maaga nang suriin namin ang eksklusibong function na O, kung saan Eksklusibo kaming NAGSASURO sa mga port na may isang expression. Napansin namin ngayon ang ilang mga pag-andar kapag itinaguyod namin ang mga port sa PIC, at

Hayaan mo akong ulitin ang kanilang paggamit dito.

BCF

Ang tagubilin na ito ay magtatanggal ng kaunting itinakda namin sa isang rehistro na itinalaga namin. Ang syntax
ay:
BCF,

Ginamit namin ito nang mas maaga upang baguhin mula sa pahina 1 hanggang pahina 0 sa pamamagitan ng pag-alis ng kaunti sa rehistro ng STATUS. Nagagamit din namin ito upang ayusin nang kaunti sa 0 sa anumang magkakaibang rehistro / lokasyon. Halimbawa, kung nais naming itakda ang ika-3 piraso sa 11001101 na nai-save sa seksyon 0C sa 0, maaari naming
ipasok:

BCF 0C, 03

BSF

Ang pagtuturo na ito ay maaayos ang anumang itinakda namin sa 1 sa anumang rehistro na isinasaad namin. Ginamit namin ito nang mas maaga upang magpatuloy mula sa Pahina 0 hanggang sa Pahina 1. Ang syntax ay: BSF ,, at ginagamit nang tumpak sa parehong pamamaraan tulad ng BCF sa itaas.

BTFSCUp hanggang ngayon maaari naming itakda o i-clear nang kaunti sa isang rehistro. Gayunpaman isipin kung kailangan nating suriin kung ang isa ay isang 1 o isang 0 sa isang rehistro?

Tiyak, posible na gumamit ng BTFSC. Nakasaad dito ang Bit Test Rehistro F, at Laktawan Kung Malinaw Ito. Susuriin ng tagubiling ito ang kaunting itinalaga namin sa rehistro. Kung sakaling ang bit ay isang 0, ipaalam sa tagubilin ang PIC sa pamamagitan ng pagpasa sa kasunod na tagubilin.

Maaari naming magamit ang tagubiling ito kung sakaling nais naming suriin ang isang watawat, halimbawa ang pagdala ng watawat. Tinitipid ito sa amin na kailangang basahin ang rehistro ng STATUS at maghanap para sa mga indibidwal na piraso upang malaman kung aling mga watawat ang naayos. 29 Halimbawa, kung nais naming suriin kung ang flag ng Carry ay itinakda sa 1 pagkatapos na magdagdag ng 2 na numero, maaari naming mai-type ang sumusunod:

BTFSC 03h, 0
magpatuloy dito kung nakatakda sa 1
o dito kung nakatakda sa 0

Kung sakaling ang katayuan ng kaunti ay isang 1, sa kasong iyon ang tagubilin kasunod sa BTFSC ay makukumpleto. Kung sakaling ito ay nakatakda sa isang 0, sa kasong iyon ang susunod na tagubilin ay nilaktawan. Ang sumusunod na bahagi ng code exhibits kung saan ito maaaring gamitin:

Loop:
:
:
BTFSC 03,0
Goto Loop

Sa code sa itaas, ang PIC ay makakakuha lamang mula sa loop kung sakaling ang bit 0 ng rehistro ng STATUS (o ang pagdadala ng watawat) ay tinukoy sa 0. O kung hindi man, isasagawa ang utos ng goto.

BTFSS

Ang panuto na ito ay nagsasaad ng Bit Test Rehistro F, At Laktawan Kung Itakda. Maaari itong maihambing sa tagubilin ng BTFSC, bukod sa ang PIC ay aalisin ang kasunod na tagubilin kung ang bit na aming sinusuri ay nakatakda sa 1, sa halip na 0.

CLRF

Aayosin ng tagubiling ito ang buong detalye ng isang pagrehistro sa 0. Ang syntax ay:

CLRF
Ginamit namin ito nang mas maaga upang itakda ang output ng mga Ports sa 0, sa pamamagitan ng paglalapat ng CLRF 85h. Dagdag dito ay pinagtatrabaho namin ito upang ayusin ang mga Ports upang isama ang lahat ng mga pin sa output sa pamamagitan ng paggamit ng CLRF
05h.

CLRW

Maaari itong maging katulad ng tagubilin sa CLRF, maliban sa pag-clear sa W register. Ang syntax ay medyo simple:

CLRW

RLF At RRF

Ang mga tagubiling ito ay magdadala ng kaunti sa isang pagrehistro ng isang solong puwang sa kaliwa (RLF) o sa kanan (RRF) sa isang rehistro. Halimbawa, kung kailangan namin ng 00000001 at nagtrabaho kami ng RLF, sa kasong iyon maaari kaming magtataglay ng 00000010. Sa puntong ito, ano ang nangyayari kung sakaling mayroong 10000000 at inilapat ang tagubilin sa RLF? Tiyak, ang 1 ay nakaposisyon sa pagdala ng watawat. Kung sakaling inilapat namin muli ang tagubilin ng RLF, muling lilitaw ang 1 sa simula. Magkapareho ang nangyayari, gayunpaman sa kabaligtaran, para sa tagubilin sa RRF. Ang kaso sa punto sa ibaba ay ipinapakita ito para sa tagubilin sa RLF, kung saan Makikita natin ang 8 piraso ng isang rehistro, pati na rin ang bitbit na watawat:

C 87654321
0 00000001
RLF 0 00000010
RLF 0 00000100
RLF 0 00001000
RLF 0 00010000
RLF 0 00100000
RLF 0 01000000
RLF 0 10000000
RLF 1 00000000
RLF 0 00000001

Halimbawa ng Programa

Makakakita kami ngayon ng isang halimbawa ng code na maaaring isaayos at himukin ng isa. Lilikha ito ng isang sunud-sunod na ilaw na nagsisimula sa PortA bit 0, papunta sa PortB bit 8 at
pagkatapos ay bumalik.
I-hook up ang mga LED sa bawat isa sa mga Port pin. Magkakaroon kami ng kaunti
ang mga pamamaraan na itinuro sa tutorial na ito.

TIME EQU 9FH Variable para sa loop ng pagkaantala.
PORTB EQU 06H Port B address.
TRISB EQU 86H Port B Tristate address.
PORTA EQU 05H Port Isang address.
TRISA EQU 85H Port A Tristate address.
STATUS EQU 03H Pahina piliin ang magparehistro.
COUNT1 EQU 0CH Magrehistro ng loop.
COUNT2 EQU 0DH Loop register.

BSF STATUS, 5 Pumunta sa pahina 1
I-MOVLW 00H at i-set up
MOVWF TRISB parehong Ports A at B
I-MOVLW 00H sa output,
MOVWF TRISA pagkatapos ay bumalik sa
STATUS ng BCF, 5 pahina 0.
MOVLW 00H I-clear ang Port A.
MOVWF DOOR

Simula ng pangunahing programa

RUNMOVLW
01H Itakda ang unang bitMOVWF
PORTB sa Port B.CALL
TANGGULIN Maghintay sandaliCALL
PANAHONAN
Ilipat ang kaunti sa kaliwa sa Port B, pagkatapos ay i-pause.RLF
PORTB, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1 Inililipat nito ang bit sa bitbit na bandila
Lumipat ngayon sa Port A, at ilipat ang kaliwa .RLF
PORTA, 1 Inililipat nito ang kaunti mula sa zero flag patungong PortACALL
DELAYCALL DELAYRLF
PINTOR, 1CALL
DELAYCALL
DELAYRLF
PINTOR, 1CALL
DELAYCALL
DELAYRLF
PINTOR, 1CALL
DELAYCALL
PANAHONAN
Ilipat ang bit pabalik sa Port ARRF
PINTOR, 1CALL
DELAYCALL
DELAYRRF
PINTOR, 1CALL
DELAYCALL
DELAYRRF
PINTOR, 1CALL
DELAYCALL
DELAYRRF
PORTA, 1 Inililipat nito ang kaunti sa zero flag Ngayon ilipat ang kaunti
bumalik sa Port BRRF
PORTB, 1CALL
DELAYCALL
DELAYRRF
PORTB, 1CALL
DELAYCALL
DELAYRRF
PORTB, 1CALL
DELAYCALL
DELAYRRF
PORTB, 1CALL
DELAYCALL DELAYRRF
PORTB, 1CALL
DELAYCALL
DELAYRRF
PORTB, 1CALL
DELAYCALL
DELAYRRF
PORTB, 1CALL
DELAYCALL
PAG-ULIT Ngayon ay bumalik kami kung saan tayo nagsimula, GOTO
TUMAYO tayo ulit.

Mayroong isang mahusay na pagpipilian sa hanay ng pagsasanay na nagpapahintulot sa iyo na magamit ang isang talahanayan ng data.

Ang isang talahanayan ng data ay isang listahan lamang ng mga quote ng data, kung saan ang lahat ay tiningnan batay sa ilang mga pagsasaalang-alang.
Halimbawa, maaari kang magkaroon ng isang circuit na gumagamit ng isang PIC na binibilang ang dami ng mga pagkakataon na ang isang input pin ay naging mataas sa 1 segundo. Pagkatapos nito maaari mong ipakita ang numero sa isang 7 segment na pagpapakita.

Kaagad na inilunsad ang tiyempo, nagsisimula ang PIC na bilangin ang dami ng mga okasyon na mataas ang pin. Matapos ang 1 segundo binisita nito ang talahanayan at sinulyapan ang data dapat itong ipakita ang numero sa display na sumasagisag sa dami ng mga sitwasyon na mataas ang pin. Maaari itong maging kapaki-pakinabang, dahil hindi namin natutukoy kung ano ang maaaring maging figure hanggang sa magawa ng PIC ang pagtatantya nito.

Sa pamamagitan ng paggamit ng isang talahanayan, pinapayagan naming matukoy ng PIC kung aling figure ang ilalarawan. Sa puntong ito, bago ko ipagpatuloy na ipakita sa iyo kung paano gumagana ang talahanayan ng data, maaaring sabihin ko sa iyo na ang PIC ay nagpapanatili ng landas ng kinaroroonan sa programa habang ito ay tumatakbo ang programa.

Pinapabilis nito ang mga nagsagawa ng ilang mga programa sa BASIC. Kung hindi man, huwag mag-alala, baka gusto mong magpatuloy na malaman ang tungkol sa teorya. May imahinasyon na mayroong isang BASIC na programa na katulad ng ipinakita sa ibaba:

10 TAON K = 0
11 K = K + 1
12 KUNG K> 10 TAPOS GOTO 20 ELSE GOTO 11
20 PRINT K
21 WAKAS

Ang programa ay nagsisimula sa linya 10. Sa sandaling ang K ay naka-iskedyul sa 0, susunod na susulong sa linya 11. Matapos naming isama ang 1 hanggang K pagkatapos naming magpatuloy sa linya 12.

Sa puntong ito maaari kaming maging mausisa kung ang K ay mas mataas sa 10. Kung sakaling ito ay, susunod na magtungo tayo sa linya 20, o kung hindi man, babalik tayo sa linya 11.

Ang dokumentong Linya 20 ang K, at ang linya 21 ay nagtatapos sa programa. Gumagamit ang BASIC ng mga istatistika ng linya upang matulungan ang programmer na panatilihin ang isang talaan kung nasaan ang mga isyu, dahil ang mga label ay hindi pinahintulutan. Gumagamit ang PIC ng mga label upang makatakas sa pagitan ng mga patutunguhan - o maaari ba talaga ito?

Ginagamit namin ang mga label upang matiyak na may kamalayan kami kung nasaan ang mga isyu, pati na rin upang matiyak na maipapaalam namin sa PIC sa isang simpleng paraan kung saan maghanap.

Tiyak na ang nangyayari ay sinasamantala ng PIC ang isang panloob na linya na counter na tinatawag na isang Program Counter. Ang Program Counter (dinaglat sa PC) na landas ng patutunguhan ng memorya ng kung saan ang kasalukuyang tagubilin.

Kailan man ipaalam sa amin ang PIC upang bisitahin ang isang napiling label, naiintindihan nito ang lugar ng memorya at samakatuwid ay nadaragdagan ang PC hanggang sa makita nito ang patutunguhan ng memorya. Ito ang tiyak na kapareho ng pamamaraan sa pag-check namin sa BASIC na programa sa itaas. Nasa ibaba ang isang segment ng code, kasama ang mga puwang ng memorya, o mga item ng PC, sa tabi ng bawat tagubilin:

Tagubilin sa PC0000 movlw 03
0001 Movwf 0C
0002 Loop decfsc 0C
0003 goto Loop
0004 pagtatapos

Sa pagpapakita sa itaas, naayos namin ang PC sa 0000. Dito mayroon kaming tagubilin na Movlw 03. Kapag ipinatupad ng PIC ang data na ito, nadaragdagan nito ang PC upang mai-scan ang kasunod na tagubilin. Sa puntong ito ang PIC ay nakikita ang Movwf 0C. Ang PC ay nadagdagan muli.

Ngayon ang pag-aaral ng PIC ay decfsc 0C. Kung sakaling ang mga detalye ng 0C ay hindi 0, sa kasong iyon ang PC ay nadagdagan ng 1, pati na rin ang sumusunod na tagubilin, goto Loop, ipinapaalam sa PC na bumalik sa posisyon na 0003, na mayroong nasabing Loop. Kung sakaling ang mga detalye ng 0C ay 0, pagkatapos ay pinayuhan ang PC na dagdagan ng 2, ilagay lamang na alisin ang kasunod na tagubilin.

Pag-unawa sa Mga Talaan ng Data

Inilalagay nito ang PC sa posisyon na 0004, kung saan natapos ang programa. Ang mga patutunguhan ay naayos ng nagtitipon, at hindi namin pangkalahatan na dapat alalahanin kung ano ang nagagawa ng PC. Hanggang, mahahanap namin ang pangangailangan na kontrolin ito tulad ng ginagawa namin sa paggamit ng mga talahanayan ng data. Ang pinaka-maginhawang paraan upang ilarawan kung paano gumana ang isang talahanayan ng data, ay magsimula sa isang ilustrasyon.

PC equ 02
paglipat 03
talahanayan ng tawag
:
table addwf PC
retlw 01
retlw 02
retlw 03
retlw 04
retlw 05
retlw 06
retlw 07
bumalik ka

Ang paunang tagubilin ay naglalaan ng label na PC na may address ng Program Counter (02h). Malapit na kaming matapos ilagay ang halaga ng 03h sa w magparehistro. Kami pagkatapos nito ay nakikipag-usap sa mesa. Ang pinakamahalagang linya sa talahanayan ng subroutine ay nagdaragdag ng mga detalye ng W register (03h) sa counter ng programa.

Ito ay nagpapalitaw sa counter ng programa upang itaas ang 3, o upang ilagay ito sa ibang paraan, pinasisigla ang counter ng programa upang magpatuloy sa 3 linya. Habang ang counter ay dumating ng 3 mga linya pababa dito ay kinikilala ng PIC ang retlw ng tagubilin. Ang utos na ito ay nagpapadala ng halagang sumusunod dito sa rehistro ng W, pagkatapos na bumalik mula sa subroutine. Karaniwang nangangahulugang ang RETLW ay Return, Literal kay W.

Tingnan na naglagay ako ng isang kuwit pagkatapos ng salitang Bumalik. Dahil nasa isang subroutine kami, nangangailangan kami ng isang tagubilin sa Return sa ibabaw nito. Samakatuwid ang RET sa tagubilin. Matapos ang pagtuturo ng RETLW ay isang numero, at ito mismo ang inilalagay sa W register.

Sa pagkakataong ito ito ang pigura 3. Maaari kaming magtalaga ng anumang dami sa pagrehistro ng W, hangga't ang figure na ito ay pinagsama sa Program Counter sa talahanayan subroutine, matutuklasan namin ang isang retlw na tagubilin. Sa ilustrasyong nasa itaas ipinapahiwatig nito na maaari kaming magtaglay ng anumang numero mula 1 hanggang 7. Kung sakaling magpatuloy kami sa paglipas ng subroutine, maaari nating tapusin ang pagsasagawa ng isang karagdagang seksyon ng programa. Para sa kadahilanang ito, kadalasan ay isang matalinong paglipat upang ilagay ang talahanayan ng data nang eksakto sa pagtatapos ng programa ng PIC, samakatuwid kung mag-overshoot kami sa kasong iyon ay makakarating kami sa pagtatapos ng programa kahit papaano.

Ang paksa ng mga nakakagambala ay maaaring maging ang pinakamahabang at pinakamahirap na pumunta sa pamamagitan ng.

Hindi ka makakahanap ng anumang komplikadong pamamaraan ng pag-detalye ng mga nakakagambala, subalit may kaunting swerte sa pagtatapos ng bahaging ito maaari kang mag-apply ng mga nakakagambala sa iyong sariling mga programa.
Pinaghiwalay namin ang seksyon sa 2 yugto. Iyon ay upang paganahin ang paghiwalayin ang paksa sa mga seksyon, din upang magbigay sa iyo ng isang madaling gamiting plit up para sa madaling pag-unawa.

Ano nga ba ang nakakagambala? Tiyak, tulad ng ipinahihiwatig ng term, ang isang nakakagambala ay isang pamamaraan o isang senyas na pumipigil sa isang microprocessor / microcontroller mula sa anumang bagay na ginagawa nito na maaaring mangyari ang ibang bagay.

Payagan akong magbigay sa iyo ng isang pang-araw-araw na paglalarawan. Isipin na nakakarelaks ka sa iyong sariling tahanan, nakikipag-usap sa ibang tao. Bigla nalang tumunog ang telepono.

Huminto ka sa pakikipag-usap, at kunin ang telepono upang makausap ang tumatawag. Kapag mayroon ka ng iyong pakikipag-ugnayan sa telepono, nagpasya kang bumalik sa pakikipag-usap sa indibidwal bago tumunog ang telepono. Posibleng isaalang-alang ang pangunahing gawain habang nakikipag-chat ka sa isang tao, ang pag-ring ng telepono ay nakagagambala upang makagambala sa iyong pakikipag-usap, at ang pahinga sa gawain ay ang paraan ng pagsasalita sa telepono.

Habang ang pagtalakay sa telepono ay nagtatapos, pagkatapos ay bumalik ka sa iyong pangunahing gawain sa pakikipag-chat. Ang ilustrasyong ito ay tiyak kung paano makagambala ang isang processor upang gumawa ng aksyon.

Ang pangunahing programa ay tumatakbo, isinasagawa ang ilang mga pag-andar sa isang circuit, subalit kapag naganap ang isang pagkagambala ang mga pangunahing programa ay huminto habang ang isang iba't ibang mga gawain ay ginaganap. nagtatapos na gawain, ang processor ay lumilipat pabalik sa pangunahing gawain tulad ng dati.

Pag-unawa sa Mga Nakagambala

Nagtataglay ang PIC ng 4 na mapagkukunan ng makagambala. Maaari silang hatiin sa isang pares ng mga grupo. Dalawa ang mapagkukunan ng mga nakakagambala na maaaring magamit nang panlabas sa PIC, habang ang dalawa pa ay panloob na proseso. Hayaan akong linawin ang dalawang panlabas na uri dito. Ang iba pang dalawa ay ilalarawan sa iba't ibang mga tutorial sa sandaling makarating kami sa mga timer at pag-iimbak ng data.

Dapat mong suriin ang pin-out ng PIC, mapapansin mo na ang pin 6 na ito ay RB0 / INT. Sa puntong ito, ang RB0 ay malinaw na Port B bit 0. Ang INT ay kumakatawan na maaari rin itong mai-configure bilang isang panlabas na makagambala na pin. Bukod dito, ang mga Port B pin na 4 hanggang 7 (mga pin 10 hanggang 13) ay maaari ding magamit para sa mga nakakagambala. Bago namin magamit ang INT o ibang Port B pin, kailangan nating magawa ang dalawang gawain. Napakauna dapat nating ipaalam sa PIC na gagamitin namin ang mga nakakagambala.

Susunod, dapat naming italaga kung aling port B pin ang aming gagamitin bilang isang nakakagambala sa halip na bilang isang I / O pin. Sa loob ng PIC maaari kang makahanap ng isang rehistro na kilala bilang INTCON, at nasa address na 0Bh. Sa rehistro na ito matutuklasan mo ang 8 mga piraso na maaaring paganahin o hindi paganahin. Ang Bit 7 ng INTCON ay kilala bilang GIE. Ito ang Global Interrngupt Paganahin. Ang pag-aayos nito sa 1 ay nagpapaalam sa PIC na gagamitin namin ang isang nakakagambala.

Ang Bit 4 ng INTCON ay kilala bilang INTE, INTerrupt Enable. Ang paglalagay ng bit na ito sa 1 ay nagpapahiwatig sa PIC na ang RB0 ay magiging isang nakakagambala na pin. Ang pag-configure ng bit 3, na tinatawag na RBIE, ay nagpapaalam sa PIc na gagamitin namin ang Port B bits 4 hanggang 7. Sa puntong ito naiintindihan ng PIC kapag ang pin na ito ay maaaring maging mataas o mababa, kailangang ihinto kung ano ang ginagawa nito at magpatuloy sa isang nakakagambala gawain Sa puntong ito, dapat naming ipaalam sa PIC kung ang pagkakagambala ay malamang na nasa pataas na gilid (0V hanggang + 5V) o ang pagbagsak ng gilid (+ 5V hanggang 0V) pagbabago ng signal.

Sa simpleng salita, nais ba naming makagambala ang PIC sa tuwing ang signal ay gumagalaw mula sa mababa hanggang sa mataas, o mula sa mataas hanggang sa mababa. Sa pamamagitan ng pagkakasala, maaari itong maitaguyod upang mailagay sa tumataas na gilid.

Ang edge na ‘triggering’ ay naka-iskedyul sa isang karagdagang rehistro na tinatawag na OPTION register, sa address na 81h. Ang kaunting pananabik sa atin ay bit 6, na madalas na tinukoy bilang INTEDG.

Ang pagtatakda nito sa 1 ay nagpapalitaw sa PIC na makagambala sa mounting edge (default na estado) at ang pagtatakda nito sa 0 ay nagpapasigla sa PIC na makagambala sa sliding edge. Kung nais mong i-aktibo ang PIC sa tumataas na gilid, tiyak na hindi mo kailangang gumawa ng anuman sa kaunting ito.

Sa puntong ito, nakalulungkot, ang rehistro ng Opsyon ay nasa Bank 1, nangangahulugang nasisiyahan kaming magbago mula sa bangko 0 hanggang bangko 1, itakda ang kaunti sa rehistro ng Pagpipilian, pagkatapos na bumalik sa bangko 0. Ang susi dito ay upang makamit ang bawat bit ng Bank 1 na nagrerehistro sa isang solong welga, halimbawa ng pagtataguyod ng mga port pin, pagkatapos na bumalik sa Bank 0 kung tapos ka na.

Mabuti, dahil dito ay naabisuhan namin ang PIC kung aling pin ang marahil ang nakakagambala, at kung saan mag-uudyok, ano ang nangyayari sa programa at sa PIC anumang oras na maganap ang pagkagambala? Ang isang pares ng mga bagay-bagay maganap. Napakauna, naka-iskedyul ng isang 'flag'.

Ipinaaalam nito ang panloob na processor ng PIC na may isang nagambala na naganap. Susunod, ang counter ng programa (na pinag-usapan ko sa loob ng nakaraang tutorial) mga tip sa isang tukoy na address sa loob ng PIC. Mabilis nating suriin ang lahat ng ito nang paisa-isa. Makagambala ng Bandila Sa aming pagrehistro sa INTCON, ang bit 1 ay ang makagambala na watawat, na tinatawag na INTF. Sa puntong ito, tuwing may anumang nakakagambala na paglitaw, ang watawat na ito ay maaaring maayos sa 1.

Kapag walang nakakagambala, ang watawat ay inilalagay sa 0. Pati na rin ay tungkol sa lahat ng mga nagawa. Sa puntong ito maaari mong napagnilay-nilay ‘ano ang punto?’ Tiyak, kahit na ang flag na ito ay naka-iskedyul sa 1, ang PIC ay hindi magawa, at hindi, ay tumugon sa isa pang makagambala. Samakatuwid, ipahayag natin na nagdudulot kami ng isang nakakagambala. Ang bandila ay maaaring maayos sa 1, at ang PIC ay maaaring pumunta sa aming gawain para sa paggana ng nakakagambala.

Kapag ang watawat na ito ay hindi naayos sa 1, at pinahintulutan ang PIC na magpatuloy na sagutin ang nakakagambala, pagkatapos ay patuloy na pag-pulso ng pin ay maaaring panatilihin ang PIC na bumalik sa simula ng aming nakakagambalang gawain, at hindi nangangahulugang nakumpleto ito. Bumabalik sa aking paglalarawan ng telepono, katulad ito ng pag-angat ng telepono, at kaagad na nagpatuloy upang talakayin ito ay nagsisimulang mag-ring muli dahil may ibang tao na nais makipag-usap sa iyo.

Maipapayo na kumpletuhin ang isang diyalogo, pagkatapos ay grab ulit ang telepono upang makipag-usap sa kasunod na indibidwal. Maaari kang makahanap ng isang maliit na problema sa watawat na ito. Kahit na mabilis na itinatakda ng PIC ang watawat na ito sa 1, hindi ito itinatakda muli nitong 0! Ang aktibidad na iyon ay dapat na gamitin ng programmer - ibig sabihin ikaw. Maaari itong maisagawa nang walang kahirap-hirap, dahil tiyak kong ipinagpapalagay, at kailangang makamit matapos maisagawa ng PIC ang nakakagambala na gawain.

Lokasyon ng Memorya Kailan ka paunang pinalakas ang PIC, o kung sakaling mayroong isang pag-reset, ang mga tip sa Program Counter upang tugunan ang 0000h, na maaaring walang simulang sa simula ng memorya ng programa. Ngunit, sa kaganapan ay mayroong isang nakakagambala, ipahiwatig ng Program Counter ang address na 0004h.

Samakatuwid, habang binubuo namin ang aming programa na magkakaroon ng mga nakakagambala, una naming dapat ipagbigay-alam sa PIC na mag-hop sa address na 0004h, at panatilihin ang nakakagambalang gawain na nagsisimula sa address na 0004h na hiwalay mula sa natitirang programa.

Maaari itong maging walang abala upang maisagawa. Sa una, sinisimulan namin ang aming programa sa isang utos na kilala bilang ORG. Isinasaad ng utos na ito ang Pinagmulan, o pagsisimula. Dumidikit kami dito gamit ang isang address. Dahil ang PIC ay nagsisimula sa address na 0000h, nagta-type kami ng ORG 0000h. Pagkatapos nito dapat naming i-bypass ang address na 0004h. Natapos namin ito sa pamamagitan ng paglalagay ng isang tagubilin sa GOTO, sinamahan ng isang label kung aling mga tip sa aming pangunahing programa.

Pagkatapos naming sumunod sa utos na ito ng GOTO na may isa pang ORG, sa sandaling ito na may address na 0004h. Pagkatapos ng utos na ito na ipasok namin ang aming nakakagambalang gawain. Sa puntong ito, maaari naming mai-type nang tama ang aming nakakagambalang na gawain tuwid na sumusunod sa pangalawang utos ng ORG, o nakaposisyon namin ang isang pahayag ng GOTO na tumuturo sa nakakagambalang gawain.

Ito ay tunay na nauugnay sa pagpipilian sa iyong bahagi. Upang maipaalam ang PIC na inaalok nito ay dumating sa pagtatapos ng nakakagambala na gawain kailangan naming iposisyon ang utos na RTFIE sa pagtatapos ng gawain. Ang utos na ito ay nangangahulugang pagbabalik mula sa nakakagambala na gawain. Habang napansin ito ng PIC, ipinapahiwatig ng Program Counter sa huling posisyon na dati nang nasa PIC bago maganap ang pagkagambala. Naitaguyod namin sa ibaba ang isang maikling seksyon ng code upang maipakita ang nasa itaas:

Mayroong isang pares ng mga bagay-bagay dapat mong masabihan kapag gumagamit ng mga nakakagambala. Ang pauna ay may kaugaliang na kung maaari mong gamitin ang magkaparehong rehistro sa iyong pangunahing programa at ang nakakagambala na gawain, sa isipan na ang mga detalye ng rehistro ay malamang na magbago kapag naganap ang pagkagambala.

Halimbawa, gamitin natin ang w magparehistro upang ipasa ang data sa pangunahing programa ng Port, samakatuwid maaari mong karagdagang gamitin ang rehistro sa makagambala na gawain upang ilipat ang data mula sa isang patutunguhan patungo sa iba pa.

Kung sakaling hindi ka maingat, isasama ng w register ang huling halagang natanggap nito habang nasa nakakagambala na gawain, kaya kapag bumalik ka mula sa abala ang impormasyong ito ay maihahatid sa Port A kaysa sa halagang mayroon ka dati naganap ang pagkakagambala.

Ang paraan sa paligid nito ay upang mai-save pansamantala ang mga detalye ng w magparehistro bago mo ito magamit muli sa paggambala ng gawain. Ang pangalawa ay ang katunayan na maaari kang makahanap ng isang pagkaantala sa pagitan ng kung kailan naganap ang isang nakakagambala at kung kailan maaaring lumitaw ang kasunod na isa. Habang naiintindihan mo, ang PIC ay nagtataglay ng isang panlabas na orasan, na maaaring isang kristal o maaaring ito ay isang resistor-capacitor combo.

Hindi alintana kung ano ang dalas ng orasan na ito, hinahati ito ng PIC ng 4 pagkatapos na gamitin ito para sa panloob na tiyempo. Halimbawa kung sakaling mayroon kang isang 4MHz na kristal na naka-link sa iyong PIC, sa kasong iyon Gagampanan ng PIC ang mga tagubilin sa 1MHz. Ang panloob na tiyempo na ito ay kilala bilang isang Siklo ng Pagtuturo. Sa puntong ito, inaangkin ang sheet ng data (walang alinlangan sa kaunting pag-print) na kailangan mong paganahin ang 3 hanggang 4 na mga bilog sa pagtuturo sa pagitan ng mga nakakagambala.

Aking ay upang paganahin ang 4 na pag-ikot. Ang dahilan sa likod ng pagkaantala ay nangangailangan ang PIC ng oras upang tumalon sa nakagambalang address, ang watawat, at bumalik pabalik mula sa nakakagambalang gawain. Samakatuwid, itago ito sa iyong isipan kung nagtatrabaho ka sa isang kahaliling circuit upang maisaaktibo ang isang nakakagambala para sa PIC.

Sa puntong ito, ang isang punto ay ang katotohanan na kung gumagamit ka ng mga piraso na 4 hanggang 7 ng Port B bilang isang nakakagambala. Hindi mo mapili ang mga tukoy na pin sa Port B upang gumana bilang isang nakakagambala.

Samakatuwid, kung sakaling pahintulutan mo ang mga pin na ito, malamang na lahat sila ay maaaring makuha. Samakatuwid, halimbawa, hindi ka maaaring magkaroon ng mga piraso na 4 at 5 - ang mga piraso na 6 at 7 ay malamang na bigyang lakas sa parehong oras. Ano nga ba ang layunin ng pagkuha ng apat na piraso upang kumatawan sa isang nakakagambala? Tiyak, maaari kang magkaroon ng isang circuit na naka-hook sa PIC, kung sakaling ang sinuman sa apat na linya ay mataas, sa kasong ito maaaring ito ay isang isyu na kinakailangan mo ng PIC na maka-impluwensya kaagad.

Ang isang paglalarawan nito ay maaaring isang alarma sa seguridad sa bahay, kung saan ang apat na sensor ay naka-link sa Port B pin 4 hanggang 7. Ang anumang tukoy na sensor ay maaaring mag-prompt sa PIC na magpalitaw ng isang alarma, at ang regular na pag-sign ng alarm ay ang nakakagambala na gawain. Tinitipid nito ang pagsuri sa mga daungan palagi at pinapayagan ang PIC na magpatuloy sa iba't ibang mga bagay. Sa loob ng susunod na tutorial, bubuo kami ng isang programa upang pamahalaan ang isang nakakagambala.

Nakipag-usap kami sa maraming mga pangunahing kaalaman sa loob ng huling tutorial, samakatuwid nararamdaman kong dumating na ang oras na binubuo namin ang aming unang programa.

Ang program na isusulat namin ay bibilangin ang dami ng mga okasyon na binubuksan namin ang isang switch, at pagkatapos ay ipinakita ang numero.

Ang programa ay bibilangin mula 0 hanggang 9, makikita sa 4 na mga LED sa binary form, kasama ang input o makagambala ay malamang na nasa RB0.

Ang numero unong bagay na dapat nating isagawa ay ipaalam sa PIC na tumalon sa address kung saan itinuturo ng Program Counter tuwing may naganap na pagkagambala.

Mapapansin mo na gumagamit kami ng isang natatanging pamamaraan ng pagpapakita ng mga hexadecimal na numero. Bago ako nangyari mag-apply F9h kung saan h ipinahiwatig hexadecimal. Maaari naming isulat ito bilang 0xF9, na kung saan ay ang istraktura na gagamitin namin mula ngayon.

Ngayon kailangan naming sabihin sa PIC na gagamit kami ng mga nakakagambala, at gumagamit kami ng RB0 pin 6 bilang isang nakakagambala na pin:

bsf INTCON, 7GIE - Global na makagambala paganahin ang (1 = paganahin)
bsf INTCON, 4INTE - RB0 makagambala paganahin (1 = paganahin)
Lilinisan ko ang makagambala na bandila kung sakali (wala akong tiwala sa anumang bagay!)
bcf INTCON, 1INTF - I-clear ang flag bit kung sakali

Sa kasalukuyan dapat nating maitaguyod ang aming 2 port. Tandaan na habang gumagamit kami ngayon ng RB0 bilang isang nakakagambala na pin, kailangan itong maitaguyod bilang isang input:

Gagamitin namin ang isang variable na tinatawag na COUNT upang maiimbak ang bilang ng mga bilang ng switch. Maaari lamang nating dagdagan ang halaga sa Port A, ngunit makikita mo kung bakit gumagamit ako ng variable kapag isinulat namin ang aming nakakagambalang gawain.

Samakatuwid, ang aming punong programa ay binubuo, at sa puntong ito dapat naming ipaalam sa PIC kung paano magpatuloy sa tuwing magaganap ang isang nakakagambala. Sa loob ng halimbawang ito, ang aming makagambala ay maaaring ang switch. Kung ano ang nais naming ang PIC ay isa sa naaayos na COUNT sa tuwing nakakulong ang switch.

Gayunpaman, nais lamang naming ipakita kung gaano karaming mga okasyon ang switch ay nagsara mula 0 hanggang 9. Sa itaas, sinabi ko na maaari naming magkaroon ng simpleng pagtaas ng halaga sa Port A sa tuwing mayroong nakakagambala. Gayunpaman, ang Port A ay may 5 piraso, kung sakaling madagdagan namin ang port, magkakaroon kami ng pinakamataas na bilang ng 31. Mayroong isang pares ng mga paliwanag kung bakit pinili ko na hindi lumipat sa 31.

Sa una, gagamitin namin ang isang 7-segment na screen, na maaaring higit sa lahat ay mula 0 hanggang 15 (0 hanggang F sa hex). Susunod, karagdagan kong hinahangad na ipakita sa iyo ang ilan sa mga utos ng aritmetika kung saan ka nadapa sa nakaraang mga aralin.

Samakatuwid ay magpapatuloy kami sa aming nakakagambala na gawain. Sa kasalukuyan ang unang dapat nating gawin ay maikli ang mga detalye ng aming pagrehistro, dahil inilapat namin ito upang ilipat ang mga nilalaman ng COUNT sa PORTA. Kung sakaling hindi namin ito mai-save, sa kasong iyon maaari kaming makapaghatid ng isang ganap na naiibang bilang dahil sa aming arithmetic. Samakatuwid gawin muna natin iyon:

Sa puntong ito naiintindihan namin kung ang halaga ng COUNT ay 9 o higit pa. Ang kailangan lamang nating magawa ngayon ay kung ang COUNT ay higit sa 9, ibalik ito sa 0, o bumalik sa pangunahing programa upang matiyak na maihatid namin ito sa Port A. Ang utos ng BTFSS dahil naintindihan mo ang susunod
tagubilin kung sakaling ang pagdala ng watawat ay naka-iskedyul ie COUNT = 10:

Ang tanging bagay na natitirang gawin ngayon ay sama-sama na ipasok pati na rin matukoy ang mga halaga sa aming mga pare-pareho, na nagawa naming magsagawa kaagad sa pagsisimula ng aming programa.

Sa bawat oras na buhayin mo ang switch on, ang mga LED ay bibilangin sa binary mula 0000 hanggang 1010 pagkatapos ay bumalik sa 0000.

Ipinapakita ng sumusunod na pigura ang diagram ng circuit na katugma sa ipinaliwanag na code sa itaas. Kagiliw-giliw na makikita mo na ang timer capacitor ay isinama sa disenyo. Ito ay magandang maliit na taktika kung saan nakukuha mo ang kalayaan na iwasan ang pagsasama ng capacitor sakaling wala kang kasama sa panahong iyon.

Dito naglalaro ang capacitance sa pamamagitan ng stray capacitance sa kabuuan ng oscillator pin at ground.
Siyempre hindi ito maaaring maging isang napaka-talino na paraan ng pag-iwas sa isang capacitor dahil ang halaga ng pagkaligaw ay maaaring mag-iba sa iba't ibang mga ibinigay na kundisyon.

Ang isa pang seksyon na maaaring masaksihan sa circuit ay ang denouncing network sa buong switch. Pinipigilan nito ang pagkagambala habang lumilipat ang mekanikal at pinipigilan ang PIC na malito kung ang paglipat ay isang solong toggle o maraming toggle.