Paano Maipaliliwanag ang Direksyon ng Pag-ikot Mula sa isang Digital Rotary Switch Gamit ang isang PIC: 5 Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:16

Ang layunin para sa Instructable na ito ay upang ilarawan kung paano i-interface ang isang digital (quadrature coded) rotary switch gamit ang isang microcontroller. Huwag mag-alala, ipapaliwanag ko kung ano ang ibig sabihin ng quadrature coded para sa amin. Ang interface na ito at ang kasamang software ay magpapahintulot sa microcontroller na makilala ang direksyon ng pag-ikot para sa bawat paglipat mula sa isang detent patungo sa isa pa. Ginamit ko kamakailan ang ganitong uri ng switch sa isang proyekto ng microcontroller na nangangailangan ng isang set ng presyon na ipinasok gamit ang isang knob na may 16 detents sa halip na pataas / pababang mga pindutan. Ang ideya ay upang payagan ang gumagamit na "i-dial" ang nais na presyon. Bilang isang resulta, kinailangan naming bumuo ng isang gawain sa software upang makuha ang impormasyon ng posisyon mula sa switch at mabawasan ang direksyon ng pag-ikot upang madagdagan o mabawasan ang itinakdang punto ng presyon para sa pangunahing system. Sa Instructable na ito, sasakupin ko ang pisikal na interface sa microcontroller, ang teorya ng pagpapatakbo para sa rotary switch, ang teorya ng pagpapatakbo para sa software pati na rin ang nakagawiang pagbawas. Panghuli, ipapakita ko sa iyo ang aking aplikasyon ng nakagawiang pagbawas. Habang sumusulong kami, susubukan kong panatilihing medyo generic ang mga bagay upang mailapat ang ideya sa maraming mga platform hangga't maaari ngunit ibabahagi ko rin kung ano ang ginawa ko upang makita mo ang isang tukoy na application.

Hakbang 1: Mga Bahagi

Upang maipatupad ito, kakailanganin mo: Isang rotary switch (quadrature coded) Hilahin ang mga resistor Angkop na platform ng microcontrollerPara sa aking proyekto, gumamit ako ng isang Grayhill 61C22-01-04-02 optical encoder. Ang data sheet para sa rotary switch ay tumatawag para sa 8.2k ohm pull up resistors sa dalawang linya ng data na nagmumula sa switch. Gusto mong suriin ang sheet ng data para sa encoder na nais mong gamitin. Ang rotary switch na ginamit ko ay maaari ding mag-order gamit ang isang axial push button switch. Ito ay isang kapaki-pakinabang na tampok para sa paggawa ng mga napiling naka-dial sa, atbp. Ngunit hindi ko tatalakayin ang interface nito dito. Mayroon akong nakalista na "angkop na microcontroller platform" sapagkat (sa palagay ko) maaari itong ipatupad sa higit sa isang platform. Nakita ko ang maraming tao na gumagamit ng iba pang mga microcontrollers para sa Mga Instructable kaya nais kong ipakita din ang pangkalahatang diskarte. Sinulat ko ang lahat ng code sa PIC Basic Pro para magamit sa isang Microchip PIC16F877A. Talaga, ang pangunahing bagay na kailangan mo sa microcontroller ay ang kakayahang makagambala kapag may pagbabago sa lohika sa alinman sa dalawang mga pin. Sa PIC16F877A, tinatawag itong PORTB na pagbabago na nakakagambala. Maaaring may iba pang mga pangalan para dito sa iba pang mga controler. Ang tampok na makagambala ng microcontroller na ito ay bahagi ng kung bakit ginagawang matikas ang pagpapatupad na ito.

Hakbang 2: Hardware Interface

Ang isang "simpleng" solusyon ay magkakaroon ng isang "solong poste-16 throw" switch na may 16 na koneksyon sa microcontroller. Ang bawat switch output ay maiuugnay sa isang pin sa microcontroller upang ang bawat posisyon sa pag-dial ay maaaring masuri ng microcontroller. Ito ay isang labis na paggamit ng mga I / O pin. Ang mga bagay ay lumalala pa kung nais namin ng higit sa 16 na mga posisyon (detent) na magagamit sa amin sa switch. Ang bawat dagdag na posisyon sa switch ay mangangailangan ng isang labis na input sa microcontroller. Mabilis na ito ay naging isang napaka-hindi mahusay na paggamit ng mga input sa isang microcontroller. Ipasok ang kagandahan ng rotary switch. Ang rotary switch ay may dalawang output lamang sa microcontroller na nakalista bilang A at B sa sheet ng data. Mayroon lamang apat na posibleng antas ng lohika na maaaring tumagal ng mga linyang ito: AB = 00, 01, 10 at 11. Lubhang binabawasan nito ang bilang ng mga linya ng pag-input na dapat mong gamitin sa pagkonekta sa switch sa microcontroller. Kaya, pinutol namin ang bilang ng mga linya ng pag-input hanggang sa dalawa lamang. Ano ngayon? Mukhang kailangan talaga natin ng 16 magkakaibang estado ngunit ang bagong switch na ito ay mayroon lamang apat. Nabaril na ba natin ang ating mga sarili sa paa? Hindi. Basahin mo pa. Saklaw namin ang kaunting teorya sa likod ng pagpapatakbo ng rotary switch upang ipaliwanag.

Hakbang 3: Teorya ng Operasyon ng Hardware

Posible ang pag-sensing ng direksyon ng pag-ikot gamit ang nabanggit na "solong poste-16 throw" switch ngunit gumagamit ito ng maraming mga input sa microcontroller. Ang paggamit ng rotary switch ay binabawasan ang bilang ng mga input sa microcontroller ngunit ngayon kailangan naming bigyang-kahulugan ang mga signal na nagmumula sa switch at isalin ang mga iyon sa isang direksyon ng pag-ikot. Nabanggit ko nang mas maaga na ang switch ay quadrature coded. Ito rin ay isa sa mga pangunahing kagandahan sa solusyon na ito. Nangangahulugan ito na mayroong isang 2-bit na code na ibinibigay ng switch na tumutugma sa posisyon ng switch. Maaaring iniisip mo: "Kung may dalawang bit na input sa microcontroller, paano namin kinakatawan ang lahat ng 16 na posisyon?" Iyan ay isang magandang katanungan. Hindi namin sila kinatawan lahat. Kailangan lang nating malaman ang mga kamag-anak na posisyon ng knob upang matukoy natin ang direksyon ng pag-ikot. Ang ganap na posisyon ng hawakan ng pinto ay hindi nauugnay. Para sa pag-ikot ng pakanan, ang code na binibigyan ng switch ay inuulit ang bawat apat na detent at naka-grey na naka-code. Ang ibig sabihin ng grey naka-code na may isang pagbabago lamang sa bawat pagbabago ng posisyon. Sa halip na ang pag-input ng AB na binibilang para sa pag-ikot ng pag-ikot sa binary tulad nito: 00, 01, 10, 11, nagbabago tulad nito: 00, 10, 11, 01. Pansinin na para sa huling pattern, mayroon lamang isang input na nagbabago sa pagitan ng set. Ang mga counterclockwise na halaga para sa pag-input ng AB sa microcontroller ay ganito ang hitsura: 00, 01, 11, 10. Ito lamang ang baligtad ng pattern na pakaliwa na may AB = 00 na nakalista muna. Tingnan ang mga diagram para sa isang mas visual na paliwanag.

Hakbang 4: Teorya ng Operasyon ng Software

Ang gawain na kinukuha ang direksyon ng pag-ikot ay nagagambala. Ang microcontroller na iyong pinili ay kailangang makagambala anumang oras na may pagbabago sa alinman sa (hindi bababa sa) dalawang mga pin kapag pinagana ang pag-abala. Tinatawag itong PORTB pagbabago na nakakagambala sa PIC16F877A. Anumang oras ang pag-ikot ay paikutin, ang microcontroller ay magambala at ang pagpapatupad ng programa ay ipapadala sa Interrupt Service Routine (ISR). Mabilis na malalaman ng ISR kung aling paraan ang pinaikot na switch, magtakda ng isang flag nang naaangkop at mabilis na bumalik sa pangunahing programa. Kailangan namin ito upang mangyari nang mabilis sakaling mabilis na paikutin ng gumagamit ang switch. Alam namin na ang grey naka-code na pattern ng AB ay inuulit ang bawat apat na posisyon kaya kung gagawin natin ang gawain na gawain para sa mga paglilipat sa pagitan ng apat na posisyon na gagana ito para sa lahat ng iba pa. Pansinin na sa isang apat na siklo ng posisyon, mayroong apat na gilid. Isang tumataas na gilid at isang bumabagsak na gilid para sa A input pati na rin ang B input. Magagambala ang microprocessor sa tuwing may gilid na nangangahulugang maaantala ang microcontroller anumang oras na nakabukas ang knob. Bilang isang resulta, kailangang malaman ng ISR kung aling paraan nakabukas ang knob. Upang matulungan kaming malaman kung paano ito gagawin, bumabaling kami sa form ng alon para sa pag-ikot ng pakanan. Pansinin na sa anumang oras ang A ay may gilid, ang bagong halaga ay laging naiiba mula sa B. Kapag ang knob ay mula sa posisyon 1 hanggang 2, Isang paglipat mula sa lohika-0 hanggang sa lohika-1. Ang B ay 0 pa rin para sa paglipat na ito at hindi tumutugma sa bagong halaga ng A. Kapag ang knob ay napupunta mula sa posisyon 3 hanggang 4, ang A ay may isang bumabagsak na gilid habang ang B ay nananatili sa lohika-1. Pansinin ulit, na ang B at ang bagong halaga ng A ay magkakaiba. Sa ngayon, maaari nating makita na anumang oras ang A ay sanhi ng pagkagambala sa pag-ikot ng pakanan, ang bagong halaga ay naiiba mula sa B. Suriin natin ang B upang makita kung ano ang nangyayari. Ang B ay may tumataas na gilid kapag ang paglipat ng paglipat mula sa posisyon 2 hanggang 3. Dito, ang bagong halaga ng B ay kapareho ng A. Nakatingin sa huling natitirang gilid para sa pag-ikot ng relo, ang B ay may isang bumabagsak na gilid na lumilipat mula sa posisyon 4 hanggang 5. (Ang Posisyon 5 ay pareho sa posisyon 1.) Ang bagong halaga ng B ay pareho ng A dito rin! Maaari na kaming gumawa ng ilang mga pagbabawas! Kung ang A ay sanhi ng pagkagambala at ang bagong halaga ng A ay naiiba mula sa B, ang pag-ikot ay pakanan. Bilang karagdagan, kung ang B ay sanhi ng pagkagambala at ang bagong halaga ng B ay kapareho ng A, pagkatapos ang pag-ikot ay pakanan. Agad nating suriin ang kaso ng pag-ikot ng pabaliktad. Tulad ng pag-ikot ng pakaliwa, ang pag-ikot ng pag-ikot ng oras ay magdudulot ng apat na pagkakagambala sa isang siklo: dalawa para sa input A at dalawa para sa input B. Ang input A ay may tumataas na gilid kapag ang knob ay lumilipat mula sa posisyon 4 hanggang 3 at isang bumabagsak na gilid na gumagalaw mula sa posisyon 2 hanggang 1 Kapag lumipat ang knob mula sa posisyon 4 hanggang 3, ang bagong halaga ng A ay kapareho ng halaga ng B. Pansinin na kapag ang A ay lumipat mula sa posisyon 2 hanggang 1 ang bagong halaga nito ay kapareho din ng B din. Ngayon, maaari nating makita na kapag ang A ay sanhi ng pagkagambala at ang bagong halaga na tumutugma sa B ang pag-ikot ay pakaliwa. Mabilis, titingnan namin ang input B upang mapatunayan ang lahat. Ang B ay magdulot ng isang nakakagambala kapag ang knob ay lumilipat mula sa posisyon 5 (na kapareho ng 1) hanggang 4 at kapag ang knob ay lumilipat mula sa posisyon 3 hanggang 2. Sa pareho ng mga kasong ito, ang bagong halaga ng B ay hindi tumutugma sa umiiral na halaga ng A na kabaligtaran ng mga kaso kapag ang B ay sanhi ng pagkagambala para sa pag-ikot ng pakanan. Magandang balita ito Ang lahat ay nagsisiyasat tulad ng nararapat. Upang ibuod, kung ang A ay sanhi ng pagkagambala at ang bagong halaga ay hindi tumutugma sa halaga ng B o kung ang B ay sanhi ng pagkagambala at ang bagong halaga ng B ay tumutugma sa halaga ng A alam namin na mayroong pag-ikot ng pakanan. Maaari naming suriin ang iba pang mga kaso para sa pag-ikot ng pag-ikot sa software o maaari nating ipalagay na dahil hindi ito paikot sa pag-ikot ay pakaliwa. Ang aking gawain ay simpleng gumawa ng palagay.

Hakbang 5: Software

Hindi ko ginamit ang built in interrupts sa PIC Basic Pro. Gumamit ako ng isang pares ng mga file na isinama ko sa aking code mula kay Darrel Taylor upang himukin ang gawain. Dito nabibilang ang isang malaking kredito kay Darrel! Ang mga file ay libre. Bisitahin lamang ang kanyang website para sa karagdagang impormasyon, iba pang mga application at i-download ang mga file. Maaari mong laktawan ang bahaging ito kung hindi ka gumagamit ng isang PIC na nagambala ni Darrel Taylor. I-set up lamang ang mga pagkagambala kung kinakailangan sa platform na iyong ginagamit. Upang makuha ang mga pagkagambala ng Darrel Taylor (DT) na mayroong dalawang bagay na dapat gawin: 1. Isama ang mga DT_INTS-14.bas at ReEnterPBP.bas na mga file sa iyong code.2.) Kopyahin at i-paste ito sa iyong code. ASMINT_LIST macro; IntSource, Label, Type, ResetFlag? INT_Handler RBC_INT, _ISR, PBP, yes endm INT_CREATEENDASMIpasok ang mga tab at puwang tulad ng graphic sa dulo ng Instructable upang makita mo ang mga bagay nang medyo madali sa iyong code. Kakailanganin mong baguhin ito nang bahagya upang magkasya sa iyong mga pangangailangan. Sa ilalim ng Label, palitan ang ISR ng pangalan ng subroutine na iyong ISR. Huwag kalimutan ang underscore! Kailangan mo ito! Upang mapagana ang mga nakakagambala, may dalawang bagay pang dapat gawin: 1.) Isulat ang ISR. Isusulat mo ito tulad ng pagsulat mo ng isang subroutine ng PBP maliban na kakailanganin mong ipasok ang @ INT_RETURN sa dulo ng subroutine sa halip na RETURN. Kikilala nito ang makagambala at ibalik ang pagpapatupad ng programa kung saan ito tumigil sa pangunahing loop. Sa loob ng ISR, kailangan mong limasin ang makagambala na bandila upang ang iyong programa ay hindi mahuli sa isang recursive interrupt. Ang simpleng pagbasa lamang sa PORTB ay ang dapat gawin upang malinis ang makagambala na watawat sa PIC16F877A. Ang bawat magkakaibang microcontroller ay may iba't ibang paraan ng pag-clear ng mga nakakagambalang watawat. Suriin ang sheet ng data para sa iyong microcontroller.2.) Kapag naabot mo ang punto sa iyong code na nais mong paganahin ang nakakagambala, gamitin ang linya ng code na ito: ng mga bagay-bagay na naka-pack sa kung ano ang tinakpan ko lamang kaya mabilis kong ibubuod. Sa ngayon, ang iyong programa ay dapat magmukhang ganito:; Anumang kinakailangang pag-set up o codeINCLUDE "DT_INTS-14.bas" INCLUDE "ReEnterPBP.bas" ASMINT_LIST macro; IntSource, Label, Type, ResetFlag? INT_Handler RBC_INT, _myISR, PBP, yes endm INT_CREATEENDASM; Anumang iba pang kinakailangang pag-set up o code @ INT_ENABLE RBC_INT; Code na kailangang malaman kung aling paraan ang umiikot na knob @ INT_DISABLE RBC_INT; Iba pang codeEND; Pagtatapos ng programmyISR:; ISR code dito @ INT_RETURN (Interrupt Handler Set Up Table) Sa palagay ko ito ay kung saan ang sinumang hindi gumagamit ng isang PIC o DT interrupts ay maaaring sumali muli. Ngayon, kailangan talaga nating isulat ang ISR upang malaman ng microcontroller kung aling paraan ang umiikot na knob. Alalahanin mula sa seksyon ng teorya ng software na maaari naming mabawasan ang direksyon ng pag-ikot kung alam namin ang input na sanhi ng pagkagambala, ang bagong halaga at ang halaga ng iba pang input. Narito ang pseudocode: Basahin ang PORTB sa isang variable ng gasgas upang i-clear ang makagambala na flagCheck kung A ang sanhi ng pagkagambala. Kung totoo, Paghambingin ang A at B. Suriin kung magkakaiba, kung magkakaiba, Ito ay paikot na pag-ikot ng Iba Pa, Nabagong pakaliwa ang EndifCheck kung B ang sanhi ng pagkagambala. Kung totoo, Paghambingin ang A at B Suriin kung magkakaiba, kung magkapareho, Ito ay paikot na pag-ikot ng Iba Pa, Ito ay pakaliwa sa Endif Bumalik mula sa abala. Paano natin malalaman kung ang isang pagbabago sa A o B ay sanhi ng pagkagambala? Ang pagtuklas ng bagong halaga ng binago ang input at ang iba pang (hindi nabago) na pag-input ay madali sapagkat mababasa natin ang mga ito sa loob ng ISR. Kailangan nating malaman kung ano ang estado ng bawat isa bago ipadala ang pagpapatupad sa ISR. Nangyayari ito sa pangunahing gawain. Ang pangunahing gawain ay nakaupo at naghihintay para sa isang byte variable na tinawag naming CWflag upang maitakda sa 1 o i-clear sa 0 ng ISR. Matapos ang bawat kinikilalang pagbabago ng knob o kung walang aktibidad ng knob, ang variable ay nakatakda sa 5 upang ipahiwatig ang isang idle na estado. Kung ang watawat ay naitakda o na-clear, ang pangunahing gawain ay agad na nagdaragdag o nababawasan ang set point pressure na naaangkop batay sa pag-ikot at pagkatapos ay itinatakda ang variable na CWflag pabalik sa 5 dahil ang knob ay idle muli ngayon. Tulad ng pangunahing gawain ay ang pag-check sa CWflag, dinokumento din nito ang estado ng mga halaga ng A at B rotary switch. Ito ay talagang simple at ganito ang hitsura: oldA = AoldB = BTwala talagang napakahusay dito. Isama lamang ang dalawang linya sa simula ng loop na sumusuri sa CWflag para sa pag-ikot. Ina-update lang namin ang mga halaga ng lohika ng mga input mula sa rotary knob sa loob ng increment / decrement loop sa pangunahing gawain upang makita namin kung anong input ang naging sanhi ng pagkagambala kapag ang ISR ay naisakatuparan. Narito ang ISR code: ABchange: scratch = PORTB 'Basahin ang PORTB upang i-clear ang makagambala na bandila' Kung ang A ay sanhi ng pagkagambala, suriin ang B para sa direksyon ng pag-ikot KUNG oldA! = A THEN 'Kung ang A at B ay magkakaiba, ito ay paikot sa pag-ikot KUNG A! = B TAPOS GOTO CW 'Kung hindi man, ito ay counter-clockwise na pag-ikot ELSE GOTO CCW ENDIF ENDIF' Kung ang B ay sanhi ng pagkagambala, suriin ang A para sa direksyon ng pag-ikot KUNG oldB! = B THEN 'Kung ang A at B ay pareho, ito ay paikot na pag-ikot KUNG A == B THEN GOTO CW 'Kung hindi man, ito ay kontra sa paikot na pag-ikot ELSE GOTO CCW ENDIF ENDIFCW: CWflag = 1 @ INT_RETURNCCW: CWflag = 0 @ INT_RETURNSinama ko ang ISR code sa isang AB_ISR.bas file dahil ang ang mga tab sa code ay hindi nagpapakita ng paraang dapat nilang gawin. Ngayon, dahil ang ISR ay may mga lumang halaga para sa mga input na A at B matutukoy nito kung aling input ang nagdulot ng pagkagambala, ihambing ito sa iba pang (hindi nabago) na input at tukuyin ang direksyon ng pag-ikot. Ang kailangan lamang gawin ang pangunahing gawain ay suriin ang CWflag upang makita kung aling direksyon ang nakabukas na knob (kung mayroon ito) at pagdaragdag o pagbawas ng isang counter, itinakdang punto o kahit anong gusto mo o kailangan mo. Inaasahan kong makakatulong ito at hindi pa masyadong. nakakalito Lalo na kapaki-pakinabang ang ganitong uri ng interface kung ang iyong system ay gumagamit na ng mga nakakagambala dahil ito ay isa lamang pang nakakagambala upang idagdag. Mag-enjoy!