Tutorial sa AVR Assembler 7: 12 Mga Hakbang

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

Maligayang pagdating sa Tutorial 7!

Ngayon ay ipapakita muna namin kung paano mag-scavenge ng isang keypad, at pagkatapos ay ipapakita kung paano gamitin ang mga Analog input port upang makipag-usap sa keypad. Gagawin namin ito gamit ang mga nakakagambala at isang solong kawad bilang input. I-wire namin ang keypad upang ang bawat keypress ay nagpapadala ng isang natatanging boltahe sa analog input na magpapahintulot sa amin na makilala sa pamamagitan ng boltahe kung aling key ang pinindot. Pagkatapos ay ilalabas namin ang numero na pinindot sa aming register analyzer upang maipakita na ang lahat ay nangyayari ayon sa nararapat. Mayroong isang bilang ng mga pitfalls na maaari mong patakbuhin sa kapag ginagamit ang Analog to Digital Converter (ADC) sa ATmega328p at sa gayon ay gagawin namin gawin ang mga bagay sa ilang mga yugto sa paraan upang subukan at malaman kung paano maiiwasan ang mga ito. Makikita rin natin kung bakit ang paggamit ng analog sa digital converter ay hindi ang pinakamahusay na paraan upang makontrol ang isang keypad kahit na gumagamit ito ng mas kaunting mga port sa iyong microcontroller. Sa tutorial na ito kakailanganin mo:

1. isang keypad. Maaari kang bumili ng isa o maaari mong gawin ang ginawa ko at i-scavenge ang isa.
2. 2 mga babaeng header para sa keypad (kung nangangalap ka ng isa)
3. pagkonekta ng mga wire
4. isang breadboard
5. 4 1 Mga resistors ng Kohm
6. 1 15 Kohm risistor
7. 1 3.3 resistor ng Kohm
8. 1 180 ohm risistor
9. 1 680 ohm risistor
10. isang digital multimeter
11. ang iyong analyzer mula sa Tutorial 5

Maaaring gusto mong laktawan ang unang ilang mga hakbang kung mayroon ka ng isang keypad at hindi mo kailangang mag-scavenge ng isa.

Narito ang isang link sa kumpletong koleksyon ng aking mga tutorial na AVR assembler:

Hakbang 1: Scavenge isang Keypad 1

Noong una, kahit na ang iyong mga lolo't lola ay mga bata lamang, ginagamit ng mga tao ang mga kakatwang hitsura na aparato, na may mahabang kable na naka-plug sa dingding, upang makipag-usap sa isa't isa. Tinawag silang "mga telepono" at kadalasang murang mga plastik na bagay na gumawa ng nakakainis na tunog kapag may tumawag sa iyo (hindi na ang mga ringtone na "Justin Bieber" ngayon ay hindi pantay nakakainis). Sa anumang kaso, ang mga aparatong ito ay may mga keypad sa kanila na kung saan ay napaka-wired at sa gayon ay madaling mag-scavenge at mayroon silang 2 dagdag na mga susi sa kanila ("redial" at "flash") mula sa mga keypad na maaari mong bilhin na maaaring gusto mong baguhin muli bilang "mga arrow key", "menu key", o iba pa. Kaya magsisimula kami sa pamamagitan ng pag-scaven ng isang keypad mula sa isang lumang telepono. Una kunin ang telepono (Gumagamit ako ng isang GE tulad ng ipinakita sa mga larawan) at i-pry ito upang ibunyag ang mga kable. Pagkatapos kumuha ng pait at i-snap ang maliit na mga plastik na knobs na humahawak sa keypad at alisin ang keypad.

Hakbang 2: Scavenge isang Keypad 2

Kumuha ngayon ng isang lagari ng PVC at gupitin ang plastik mula sa paligid ng mga keyholes at pagkatapos ay gupitin sa gilid upang makuha ang lalim na karapatan na iniiwan ang isang manipis na keypad.

Pagkatapos ay ibalik ang keypad gamit ang maliliit na mga peg na mananatili pagkatapos mong i-clipped ang mga tuktok ng mga ito sa huling hakbang at gumamit ng isang soldering iron upang simpleng sundutin ang mainit na bakal sa bawat butas ng peg na matunaw ang plastik at ikalat ito sa ibabaw ng ilalim ng keypad na bumubuo ng mga bagong "knobs" na hahawak sa keypad sa lugar tulad ng dati.

Gusto kong i-scavenge ang tatlong mga nagsasalita at marahil ang iba pang mga bagay tulad ng switch at kung ano ang hindi sa board. Gayunpaman, sa pagkakataong ito hindi ko na susubukin ang mga switch at bagay-bagay dahil mayroon kaming iba pang mga layunin sa ngayon. Gayundin, mayroong isang TA31002 linear IC doon na kung saan ay isang ringer ng telepono. Ang datasheet ay madaling matagpuan at mai-download sa online na nagbibigay ng pinout at mga tampok. Kaya't iiwan ko ito sa solder sa board sa ngayon at pagkatapos ay maglaro kasama nito sa paglaon. Gusto kong i-hook ito hanggang sa isang oscilloscope at makita kung anong mga cool na signal ang maaari kong makalabas dito. Siguro gumawa pa ng doorbell dito. Sinong nakakaalam

Gayunpaman sa sandaling natapos mo na ang pagsira sa telepono at pag-scaven ng mga bahagi ay tatapusin namin ang paggawa ng aming keypad.

Hakbang 3: Scavenge isang Keypad 3

Gumamit ng isang namamalaging wick at alisin ang mga cable ng laso mula sa ilalim ng keypad na tinitiyak na ang mga butas sa circuit board ay malinaw at pagkatapos ay ilakip ang dalawang mga babaeng header sa board kung nasaan ang mga butas. Marahil ay kakailanganin mong i-clip down ang iyong mga header upang ang mga ito ay 4-pin na header.

Ngayon na nakakabit ang mga header maaari mo itong i-wire sa isang breadboard, kumuha ng isang multimeter, at subukan ang mga susi sa pamamagitan ng pagdikit ng multimeter sa mga random na pin at pagsukat ng paglaban. Papayagan ka nitong i-map ang mga susi. Mahirap makita kung paano naka-wire ang mga key sa mga output sa pamamagitan ng pagtingin sa circuit ngunit kung gumagamit ka ng isang multimeter maaari mo itong mai-plug in sa anumang dalawang mga pin at pagkatapos ay pindutin ang mga pindutan hanggang sa makita mo ang isang numero sa screen sa halip na isang bukas na circuit. Ito ang magiging pinout para sa key na iyon.

Mapa ang lahat ng mga susi upang mag-output ng mga pin sa ganitong paraan.

Hakbang 4: Wire the Keypad

Sundin ngayon ang diagram ng mga kable at i-wire ang keypad sa iyong breadboard.

Paano gagana ito ay ilalagay namin ang 5V sa kaliwang kamay at ang kanang bahagi ay pupunta sa GND. Ang unang pin sa kanan sa diagram ay papunta sa una sa aming mga analog na pin sa Atmega328p microcontroller. Kapag walang mga pindutan na pinindot ang signal ay 0V, at kapag ang bawat isa sa iba't ibang mga pindutan ay pinindot ang input sa analog port ay saklaw sa pagitan ng 0V at 5V na may iba't ibang halaga depende sa kung aling key ang pinindot. Pinili namin ang mga halaga ng risistor upang ang bawat landas ay maglalaman ng isang paglaban na naiiba sa iba pa. Ang analog port sa microcontroller ay tumatagal ng isang analog signal at hinati ito sa 1024 iba't ibang mga channel sa pagitan ng 0V at 5V. Nangangahulugan ito na ang bawat channel ay may lapad na 5V / 1024 = 0.005 V / channel = 5 mV / channel. Kaya't maaaring makilala ng analog port ang mga input voltage hangga't naiiba ang mga ito sa higit sa 5 mV. Sa aming kaso napili namin ang mga halaga ng risistor upang ang anumang dalawang keypresses ay magpapadala ng isang boltahe signal na naiiba sa higit sa ito upang ang microcontroller ay maaaring madaling magpasya kung aling key ang pinindot. Ang malaking problema ay ang buong sistema ay napaka ingay kaya kakailanganin nating pumili ng isang hanay ng mga voltages upang mapa sa bawat pindutan ng pindutan - ngunit makakapunta kami doon nang kaunti.

Pansinin na nakakontrol namin ang isang 14 na pindutan ng keypad gamit lamang ang isang solong linya ng pag-input sa controller. Iyon ang isa sa mga kapaki-pakinabang na aspeto ng mga analog input.

Ngayon ang aming unang pagtatangka sa pagkontrol sa keypad ay magkakaroon ng isang keypress sanhi ng isang nakakagambala, babasahin ng makagambala na subroutine ang analog input port at magpasya kung aling key ang pinindot, at pagkatapos ay ilalabas nito ang numerong iyon sa aming rehistro na analyzer subroutine na magpapakita ng pangunahing halaga sa binary sa aming 8 LEDs na na-set up namin sa Tutorial 5.

Hakbang 5: I-wire ang Keypad sa Iyong Analyzer

Ipinapakita ng mga larawan kung paano namin nais na i-wire ang keypad sa microcontroller upang makita namin ang output sa aming display ng analyzer. Mahalaga na kawad lamang namin ang output mula sa keypad sa PortC pin 0, na tinatawag ding ADC0 sa ATmega328P.

Gayunpaman, mayroong ilang mga karagdagang bagay. Pupunta rin kami sa isang wire sa PD2. I.e. kumuha ng kawad mula sa iyong 5V riles patungo sa isang pindutan at mula sa kabilang bahagi ng pindutan patungo sa PD2, at panghuli, nais naming idiskonekta ang mga pin ng AREF mula sa aming 5V riles at sa halip ay iwanan ito. Maaari naming ipasok ang isang 0.1 microfarad decoupling capacitor kung nais namin. Ito ay isang ceramic capacitor na may nakasulat na 104 dito. Ang unang dalawang digit ay ang numero at ang huling digit ay ang lakas ng 10 pinarami namin ito sa pamamagitan ng upang makakuha ng isang sagot sa picofarads (ang pico ay nangangahulugang 10 ^ -12), Kaya't nangangahulugang 104 na 10 x 10 ^ 4 picofarads, na kapareho ng 100 nanofarads (ang ibig sabihin ng nano ay 10 ^ -9), na kapareho ng 0.1 microfarads (ang micro ay nangangahulugang 10 ^ -6). Gayunpaman, ang lahat ng ginagawa nito ay isaksak ang mga pin ng AREF kapag maaari natin itong magamit bilang aming sangguniang pin.

Nais din namin ang isang resistor ng 1 Mohm sa pagitan ng PD2 at ground. Itatakda namin ang PD2 bilang isang output pin sa 0V at magti-trigger kami sa isang positibong gilid sa pin na iyon. Nais naming mawala kaagad ang gilid kapag inilabas namin ang pindutan upang isingit namin ang risistor na "hilahin pababa" na ito.

Ang dahilan na nais namin ang pindutan ay dahil nais naming ma-trigger ang aming Analog-to-Digital converter na off ang pin INT0 sa chip, na kung saan ay PD2 din. Sa paglaon nais naming ang keypress sa parehong pag-trigger ng ADC at magbigay din ng input upang mai-convert nang walang pagkakaroon ng isang hiwalay na pindutan, ngunit dahil sa paraan ng paggana ng tiyempo magsisimula kami sa pamamagitan ng pagkakaroon ng isang hiwalay na pindutan upang ma-trigger ang ADC at sa sandaling ma-iron namin ang lahat ang mga bug out at tiwala na ang lahat ay gumagana nang maayos, pagkatapos ay tatalakayin namin ang mga isyu sa ingay at tiyempo na kasama ng pag-trigger mula sa parehong pindutin ang pindutan na nais naming basahin.

Kaya, sa ngayon, ang paraan ng paggana nito ay pipigilan natin ang isang susi, pagkatapos ay itulak ang pindutan upang ma-trigger ang ADC, at pagkatapos ay bitawan at sana ang binary halaga ng pindutan na tinulak namin ay lalabas sa analyzer.

Kaya't magsulat tayo ng ilang code na magagawa iyon.

Hakbang 6: Aling Mga Toggle Switch Ang Dapat Mong Itakda?

Pag-isipan muna natin kung paano natin mai-code ito upang mabasa ng controller ang input mula sa keypad at gawin itong isang numerong halaga na naaayon sa pindutan na pinindot. Gagamitin namin ang Analog to Digital Converter (ADC) na naka-built in sa Atmega328p. Gagamitin namin ang AREF bilang aming boltahe ng sanggunian at ang aming output ng keypad ay konektado sa PortC0 o PC0. Tandaan na ang pin na ito ay tinatawag ding ADC0 para sa Analog-to-Digital Converter 0. Maaaring maging magandang ideya para sa iyo na basahin ang Seksyon 12.4 sa mga nakakagambala para sa ATmega328P at kabanata 24 din sa Analog-to-Digital Converter bago kami makakuha nagsimula o hindi bababa sa handa ang mga seksyon na iyon para sa sanggunian. Upang mai-set up ang microcontroller upang malaman nito kung ano ang gagawin sa isang analog input signal, at kung paano makihalubilo sa aming programa, kailangan muna naming magtakda ng ilang iba't ibang mga ADC kaugnay na mga piraso ng rehistro. Mahalaga itong katumbas ng mga lumang switch ng toggle sa mga unang computer. Maaari mong i-flip ang isang switch ON o OFF, o kahit na sa pabalik ay mag-plug ka ng mga cable sa pagitan ng isang outlet at isa pa upang ang mga electron na umaabot sa tinidor na iyon sa kalsada ay mahahanap ang isang gate na sarado at isa pang bukas na pinipilit ito sa ibang landas sa maze ng circuitry at sa gayon ay gumaganap ng isang iba't ibang mga lohikal na gawain. Kapag ang pag-coding sa wika ng pagpupulong mayroon kaming malapit na pag-access sa mga pagpapaandar na ito ng microcontroller na kung saan ay isa sa mga kaakit-akit na bagay tungkol sa paggawa nito sa unang lugar. Ito ay higit na "mga kamay" at higit na mas mababa ay nangyayari sa "likod ng mga eksena" tulad nito. Kaya huwag isiping itakda ang mga rehistro na ito bilang isang nakakapagod na gawain. Ito ang nakakainteres ng wika ng pagpupulong! Nakakakuha kami ng isang napaka personal na ugnayan sa panloob na pagtatrabaho at lohika ng maliit na tilad at ginagawa itong eksaktong nais namin - walang higit at walang mas kaunti. Walang nasayang na mga cycle ng orasan. Kaya narito ang isang listahan ng mga switch na kailangan nating itakda:

1. I-off ang Power Reduction ADC bit, PRADC, na kung saan ay bit 0 ng rehistro ng PRR, dahil kung ang bit na ito ay isasara nito ang ADC. Ang rehistro ng pagbawas ng kuryente ay mahalagang paraan upang patayin ang iba't ibang mga bagay na gumagamit ng lakas kapag hindi mo kailangan ang mga ito. Dahil ginagamit namin ang ADC nais naming tiyakin na hindi ito hindi pinagana sa ganitong paraan. (Tingnan ang PRADC sa pahina 46)
2. Piliin ang analog input channel upang maging ADC0 sa pamamagitan ng pag-off sa MUX3… 0 sa rehistro ng ADC Multiplexer Selection (ADMUX) (Tingnan ang talahanayan 24-4 pahina 249) naka-off na ito bilang default kaya hindi na talaga natin kailangang gawin ito. Gayunpaman, isinasama ko ito dahil kung gumamit ka man ng isang port bukod sa ADC0 kakailanganin mong i-toggle ang mga switch na ito nang naaayon. Ang iba't ibang mga kumbinasyon ng MUX3, MUX2, MUX1, MUX0 ay nagbibigay-daan sa iyo upang magamit ang anuman sa mga analog port bilang iyong input at maaari mo ring baguhin ang mga ito nang mabilis kung nais mong tingnan ang isang bungkos ng iba't ibang mga analog signal nang sabay-sabay.
3. I-off ang mga piraso ng REFS0 at REFS1 sa rehistro ng ADMUX upang magamit namin ang AREF bilang aming boltahe ng sanggunian sa halip na isang panloob na sanggunian (Tingnan ang pahina 248).
4. I-on ang ADLAR bit sa ADMUX upang ang resulta ay "kaliwang nababagay" tatalakayin namin ang pagpipiliang ito sa susunod na hakbang.
5. Itakda ang ADC0D bit sa Digital Input Huwag Paganahin ang Pagrehistro (DIDR0) upang i-off ang digital input sa PC0. Ginagamit namin ang port na iyon para sa analog na pag-input upang maaari din naming hindi paganahin ang digital na input para dito.
6. Itakda ang ISC0 at ISC1 sa External Interrupt Control Register A (EICRA) upang ipahiwatig na nais naming mag-trigger sa tumataas na gilid ng isang signal ng boltahe sa INT0 pin (PD2), tingnan ang pahina 71.
7. I-clear ang mga piraso na INT0 at INT1 sa External Interrupt Mask Register (EIMSK) upang ipahiwatig na hindi kami gumagamit ng mga nakakagambala sa pin na ito. Kung papaganahin namin ang mga nakakagambala sa pin na ito kailangan namin ng isang nakakagambala na handler sa address na 0x0002 ngunit sa halip ay inaayos namin ito upang ang isang senyas sa pin na ito ay magpapalitaw sa pag-convert ng ADC, ang pagkumpleto nito ay pinangangasiwaan ng ADC conversion kumpletong makagambala sa address sa 0x002A. Tingnan ang pahina 72.
8. Itakda ang ADC Enable (ADEN) bit (bit 7) sa ADC control at status register A (ADCSRA) upang paganahin ang ADC. Tingnan ang pahina 249.
9. Maaari naming simulan ang isang solong conversion sa pamamagitan ng pagtatakda ng ADC start conversion bit (ADSC) sa bawat oras na nais naming basahin ang analog signal, gayunpaman, sa ngayon ay mas gugustuhin naming mabasa itong awtomatiko tuwing pinipilit ng isang tao ang pindutan, kaya sa halip ay paganahin namin ang ADC Ang Autotrigger Paganahin (ADATE) ay bit sa rehistro ng ADCSRA upang ang pag-trigger ay awtomatikong tapos.
10. Itinakda din namin ang ADPS2..0 bits (ang AD Prescalar bits) sa 111 upang ang ADC na orasan ay ang CPU clock na hinati ng isang factor na 128.
11. Pipiliin namin ang mapagkukunan ng ADC na nagpapalitaw na maging PD2 na tinatawag ding INT0 (External Interrupt Request 0). Ginagawa namin ito sa pamamagitan ng pag-toggle ng iba't ibang mga piraso sa rehistro ng ADCSRB (Tingnan ang Talahanayan 24-6 sa pahina 251). Nakikita namin sa pamamagitan ng talahanayan na nais naming i-off ang ADTS0, i-on ang ADTS1, at i-off ang ADTS2 upang ma-trigger ng ADC ang pin na iyon. Tandaan kung nais naming patuloy na mai-sample ang analog port tulad ng kung binabasa namin ang ilang tuluy-tuloy na analog signal (tulad ng sampling ng tunog o isang bagay) itatakda namin ito sa Free Running Mode. Ang pamamaraan na ginagamit namin ng setting na nagpapalitaw sa PD2 ay nagpapalitaw ng isang pagbasa ng ADC ng analog port PC0 nang hindi nagdulot ng isang nakakagambala. Darating ang pagkagambala kapag nakumpleto ang conversion.
12. Paganahin ang bit ng ADC Interrupt Enable (ADIE) sa rehistro ng ADCSRA upang kapag nakumpleto ang analog sa digital conversion ay bubuo ito ng isang nakakagambala kung saan maaari kaming magsulat ng isang makagambala na handler at ilagay sa.org 0x002A.
13. Itakda ang kinagat ko sa SREG upang paganahin ang mga pagkagambala.

Pagsasanay 1: Tiyaking nabasa mo ang mga nauugnay na seksyon sa datasheet para sa bawat isa sa mga setting sa itaas upang maunawaan mo kung ano ang nangyayari at kung ano ang mangyayari kung binago namin ang mga ito sa mga kahaliling setting.

Hakbang 7: Isulat ang Interrupt Handler

Sa huling hakbang na nakita namin na naayos namin ito upang ang isang tumataas na gilid na napansin sa PD2 ay magpapalitaw ng isang analog sa digital na conversion sa PC0 at kapag nakumpleto ang conversion na ito ay magtapon ito ng isang ADC Conversion Kumpleto na makagambala. Ngayon nais naming gumawa ng isang bagay sa makagambala na ito. Kung susuriin mo ang Talahanayan 12-6 sa pahina 65 makikita mo ang isang listahan ng mga posibleng pagkagambala. Nakita na namin ang RESET na nakakagambala sa address na 0x0000 at ang Timer / Counter0 Overflow ay nakakagambala sa address na 0x0020 sa mga nakaraang Tutorial. Ngayon nais naming tingnan ang abala ng ADC na nakikita namin ng talahanayan ay nasa address na 0x002A. Kaya sa simula ng aming code ng wika sa pagpupulong kakailanganin namin ang isang linya na mabasa:

.org 0x002Arjmp ADC_int

na tatalon sa aming makagambala na handler na may label na ADC_int tuwing nakumpleto ng ADC ang isang conversion. Kaya paano namin susulatin ang aming nakakagambala na hawakan? Ang paraan ng paggana ng ADC ay sa pamamagitan ng pagsasagawa ng sumusunod na pagkalkula:

ADC = Vin x 1024 / Vref

Kaya tingnan natin kung ano ang mangyayari kung pipilitin ko ang pindutang "redial" sa keypad. Sa kasong iyon ang boltahe sa PC0 ay magbabago sa ilang halaga, sabihin na 1.52V, at dahil ang Vref ay nasa 5V magkakaroon tayo ng:

ADC = (1.52V) x 1024 / 5V = 311.296

at sa gayon ay magpapakita ito bilang isang 311. Kung nais naming i-convert ito pabalik sa isang boltahe ibabaliktad lamang namin ang pagkalkula. Hindi namin kakailanganin itong gawin subalit dahil hindi kami interesado sa mga aktwal na boltahe sa pagkilala lamang sa pagitan nila. Kapag natapos na ang conversion, ang resulta ay nakaimbak sa isang 10-bit na numero na inilagay sa mga rehistro ng ADCH at ADCL at sanhi namin itong "kaliwang nababagay" na nangangahulugang ang 10-bit ay nagsisimula sa bit 7 ng ADCH at bumaba sa bit 6 ng ADCL (mayroong 16 na kabuuan ng bit sa dalawang rehistro na ito at ginagamit lamang namin ang 10 sa kanila, ibig sabihin, 1024 na mga channel). Maaari kaming magkaroon ng resulta na "tamang pagsasaayos" kung nais namin sa pamamagitan ng pag-clear sa ADLAR na bit sa rehistro ng ADMUX. Ang dahilan kung bakit pinili namin ang kaliwang nababagay ay dahil ang aming mga signal ay malayo na magkahiwalay na ang huling dalawang digit ng numero ng channel ay hindi nauugnay at marahil ay ingay lamang kaya makikilala natin ang mga keypresse gamit lamang ang nasa itaas na 8 na digit, sa madaling salita, kakailanganin lamang nating tingnan ang ADCH upang malaman kung aling pindutan ang pinindot. Kaya't dapat basahin lamang ng aming gumagambala ang handler ang numero sa labas ng ADCH magparehistro, i-convert ang numerong iyon sa isang halaga ng keypad, at pagkatapos ay ipadala ang halagang iyon sa aming register analyzer LED's upang mapatunayan namin na ang pagtulak ng isang "9" sabihin, ay magiging sanhi ng naaayon sa LED sa "00001001". kahit na kailangan muna nating makita kung ano ang lilitaw sa ADCH kapag pinilit namin ang iba't ibang mga pindutan. Kaya't magsulat lamang tayo ng isang simpleng nagagambala na handler na nagpapadala lamang ng mga nilalaman ng ADCH sa display ng analyzer. Kaya narito ang kailangan namin:

ADC_int: lds analyzer, ADCH; i-load ang halaga ng ADCH sa aming analyzersbi EIFR, 0; limasin ang panlabas na makagambala na bandila upang handa na itong muling bumalik

Sa ngayon, dapat mong kopyahin lamang ang code mula sa aming analyzer sa tutorial 5 at idagdag ito makagambala at ang mga setting ng toggle at patakbuhin ito. Pagsasanay 2: Isulat ang code at patakbuhin ito. Makita na makuha mo ang ipinapakitang ADCH sa iyong display ng analyzer. Subukang itulak ang parehong keypress nang maraming beses. Palagi kang nakakakuha ng parehong halaga sa ADCH?

Hakbang 8: I-Map ang Mga Halaga ng Keypress

Ang kailangan nating gawin ngayon ay i-convert ang mga halaga sa ADCH sa mga bilang na naaayon sa key na pinindot. Ginagawa namin ito sa pamamagitan ng pagsulat ng mga nilalaman ng ADCH para sa bawat keypress at pagkatapos ay i-convert iyon sa isang decimal number tulad ng ginawa ko sa larawan. Sa aming nakakagambala na gawain sa paghawak ay isasaalang-alang namin ang isang buong saklaw ng mga halaga na naaayon sa bawat keypress upang ang ADC ay mai-map ang anumang bagay sa saklaw na iyon sa isang naibigay na keypress.

Pagsasanay 3: Gawin ang ma-p.webp

Narito kung ano ang nakuha ko para sa akin (malamang na magkakaiba ang sa iyo). Pansinin na na-set up ko ito sa isang saklaw ng mga halaga para sa bawat keypress.

ADC_int:; Panlabas na makagambala na analyzer ng handlerclr; maghanda para sa mga bagong pindutan ng numberldsH, ADCH; Ina-update ng ADC kapag nabasa ang ADCH sa clccpi buttonH, 240brlo PC + 3; kung ang ADCH ay mas malaki kung gayon ito ay isang 1ldi analyzer, 1; kaya i-load ang analyzer na may isang pagbabalik na 1rjmp; at ibalik ang clccpi buttonH, 230; kung ang ADCH ay mas malaki pagkatapos ay isang 2brlo PC + 3ldi analyzer, 2rjmp return clccpi buttonH, 217brlo PC + 3ldi analyzer, 3rjmp return clccpi buttonH, 203brlo PC + 3ldi analyzer, 4rjmp return clccpi buttonH, 187brlo PC + 3ldi analyzer, 5rjmp return clccpi buttonH, 155brlo PC + 3ldi analyzer, 6rjmp ibalik ang pindutan ng clccpiH, 127brlo PC + 3ldi analyzer, 255; magtatakda kami ng flash bilang lahat ng onrjmp return clccpi buttonH, 115brlo PC + 3ldi analyzer, 7rjmp return clccpi buttonH, 94brlo PC + 3ldi analyzer, 8rjmp return clccpi buttonH, 62brlo PC + 3ldi analyzer, 9rjmp return clccpi buttonH, 37brlo PC + 3ldi analyzer, 0b11110000; ang asterisk ay nangungunang kalahating onrjmp ibalik ang clccpi buttonH, 28brlo PC + 3ldi analyzer, 0rjmp return clccpi buttonH, 17brlo PC + 3ldi analyzer, 0b00001111; hash sign ay sa ilalim ng kalahati onrjmp ibalik ang clccpi buttonH, 5brlo PC + 3ldi analyzer, 0b11000011; ang redial ay nangungunang 2 ilalim 2rjmp return ldi analyzer, 0b11011011; kung hindi man naganap ang error bumalik: reti

Hakbang 9: Code at Video para sa Bersyon 1

Inilakip ko ang aking code para sa unang bersyon ng keypad driver. Sa isang ito kailangan mong itulak ang susi at pagkatapos ay itulak ang pindutan upang maging sanhi upang mabasa ng ADC ang input mula sa keypad. Ang mas gugustuhin nating magkaroon ay walang pindutan ngunit sa halip ang signal upang gawin ang conversion ay nagmula sa keypress mismo. Pagsasanay 3: Magtipon at mag-upload ng code na ito at subukan ito. Maaaring kailanganin mong baguhin ang iba't ibang mga threshold ng conversion upang tumutugma sa iyong mga voltre ng keypress dahil malamang na magkakaiba ito sa minahan. Ano ang mangyayari kung susubukan mong gumamit ng isang input mula sa keypad pareho para sa ADC0 at para sa panlabas na makagambala na pin sa halip na sa pamamagitan ng isang pindutan? Maglalagay din ako ng isang video ng pagpapatakbo ng unang bersyon ng aming keypress driver. Mapapansin mo iyon sa aking code mayroong isang seksyon na nagpapasimula sa Stack Pointer. Mayroong iba't ibang mga rehistro na maaaring gusto naming itulak at mag-pop mula sa stack kapag nagmamanipula kami ng mga variable at kung ano ang hindi at mayroon ding mga rehistro na maaari naming i-save at ibalik sa ibang pagkakataon. Halimbawa, ang SREG ay isang rehistro na hindi napanatili sa mga pagkakagambala, kaya't ang iba't ibang mga watawat na itinakda at na-clear bilang isang resulta ng pagpapatakbo ay maaaring mabago kung ang isang nakakagambala ay nangyayari sa gitna ng isang bagay. Kaya't pinakamahusay na kung itulak mo ang SREG sa stack sa simula ng isang nakakagambala na handler at pagkatapos ay i-pop ito muli sa dulo ng makagambala na handler. Inilagay ko ito sa code upang maipakita kung paano ito napasimulan at upang asahan kung paano natin kakailanganin ito sa paglaon ngunit dahil wala kaming pakialam kung ano ang mangyayari sa SREG sa mga pagkakagambala sa aming code ay hindi ko ginamit ang salansan para dito. na ginamit ko ang operasyon ng paglilipat upang itakda ang iba't ibang mga piraso sa mga pagrehistro kapag nagsisimula. Halimbawa sa linya:

ldi temp, (1 <> sts EICRA, temp

Ang utos na "<<" sa unang linya ng code sa itaas ay isang operasyon ng paglilipat. Mahalaga na kinukuha ang binary number 1, na kung saan ay 0b00000001 at binabago ang kaliwa ng dami ng bilang na ISC01. Ito ang posisyon ng bit na pinangalanang ISC01 sa EICRA register. Dahil ang ISC01 ay bit 1, ang numero 1 ay inilipat sa kaliwang 1 na posisyon upang maging 0b00000010. Katulad nito ang pangalawa, ISC00, ay bit 0 ng EICRA at sa gayon ang paglilipat ng bilang 1 ay zero na posisyon sa kaliwa. Kung titingnan ang muling pagtingin sa m328Pdef.inc file na na-download mo sa unang tutorial at gumagamit ng evrr mula noon, makikita mo na ito ay isang mahabang listahan lamang ng mga pahayag na ".equ". Malalaman mo na ang ISC01 ay katumbas ng 1. Ang assembler ay pinapalitan ang bawat halimbawa nito ng 1 bago pa man simulan na tipunin ang anumang. Ito ay mga pangalan lamang para sa mga bitbit ng rehistro upang matulungan kaming mga tao na mabasa at sumulat ng code. Ngayon, ang patayong linya sa pagitan ng dalawang operasyon ng paglilipat sa itaas ay isang lohikal na "o" operasyon. Narito ang equation:

0b00000010 | 0b00000001 = 0b00000011

at ito ang ina-load namin (gamit ang "ldi") sa temp. Ang dahilan kung bakit ginagamit ng mga tao ang pamamaraang ito upang mai-load ang mga halaga sa isang rehistro ay pinapayagan nito ang isa na gamitin ang pangalan ng kaunti sa halip na isang numero lamang at ginagawang mas madaling basahin ang code. Mayroon ding dalawang iba pang mga diskarteng ginamit namin. Ginagamit namin ang mga tagubiling "ori" at "andi". Pinapayagan kaming magtakda at MALINAW ang mga piraso ayon sa pagkakabanggit nang hindi binabago ang alinman sa iba pang mga piraso sa isang rehistro. Halimbawa, noong ginamit ko

ori temp, (1

ang "o" temp na ito na may 0b00000001 na naglalagay ng isang 1 sa zeroth bit at iniiwan ang lahat ng natitirang hindi nababago. Pati nung nagsulat kami

andi temp, 0b11111110

binabago nito ang zeroth bit ng temp sa isang 0 at iniiwan ang lahat ng natitirang hindi nabago.

Exercise 4: Dapat mong dumaan sa code at tiyaking naiintindihan mo ang bawat linya. Maaari mong makita na kawili-wili ito upang makahanap ng mas mahusay na mga pamamaraan para sa paggawa ng mga bagay at sumulat ng isang mas mahusay na programa. Mayroong daang mga paraan upang mai-code ang mga bagay at medyo tiwala akong makakahanap ka ng mas mahusay na paraan kaysa sa minahan. Maaari mo ring makita ang (mga ipinagbabawal ng langit!) Mga pagkakamali at pagkukulang. Sa kasong iyon ay gusto kong marinig ang tungkol sa kanila upang maayos nila.

Okay, ngayon tingnan natin kung matatanggal natin ang labis na button na iyon …

Hakbang 10: Code para sa Bersyon 2

Ang pinakasimpleng paraan upang matanggal ang pindutan ay alisin lamang ito nang buo, kalimutan ang input sa PB2, at ilipat lamang ang ADC sa "Libreng Running Mode".

Sa madaling salita palitan lamang ang rehistro ng ADCSRB upang ang ADTS2, ADTS1, at ADTS0 ay pawang zero.

Pagkatapos itakda ang ADSC bit sa ADCSRA sa 1 na magsisimula sa unang conversion.

I-upload ito ngayon sa iyong microcontroller at malalaman mo na ang tamang numero ay lumalabas sa display habang pinindot mo ang pindutan at habang pinipindot mo ang pindutan. Ito ay dahil ang ADC ay patuloy na pag-sample ng ADC0 port at ipinapakita ang halaga. Kapag inalis mo ang iyong daliri ng pindutan, ang "button bounce" ay magdudulot ng kaunting mga random na halaga na maganap nang mabilis at pagkatapos ay babalik ito sa 0V input. Sa aming code mayroon kaming 0V na lumilitaw bilang 0b11011011 (dahil ang keypress `0 'ay gumagamit na ng 0b00000000 na halaga ng pagpapakita)

Hindi ito ang nais na solusyon bagaman sa dalawang kadahilanan. Una hindi namin nais na pindutin nang matagal ang pindutan. Nais naming pindutin ito nang isang beses at ipakita ang numero (o ginamit sa ilang bagong code sa isang susunod na tutorial). Pangalawa, hindi namin nais na patuloy na i-sample ang ADC0. Nais naming tumagal ito ng isang solong pagbasa, i-convert ito, at pagkatapos ay matulog hanggang sa ang isang bagong keypress ay nagpapalitaw ng isang bagong conversion. Ang pinakamahusay na mode na tumatakbo ay pinakamahusay kung ang tanging bagay na nais mong gawin ng microcontroller ay patuloy na basahin ang ilang analog input - tulad ng kung nais mong ipakita ang temperatura ng real time o isang bagay.

Kaya't hanapin natin ang isa pang solusyon …

Hakbang 11: Paano Namin Natatanggal ang Button? Bersyon 3

Mayroong maraming mga paraan upang maaari kaming magpatuloy. Una maaari kaming magdagdag ng hardware upang mapupuksa ang pindutan. Halimbawa maaari naming subukang maglagay ng isang transistor sa circuit sa linya ng output ng keypress upang tumagal ito ng isang maliit na patak ng kasalukuyang mula sa output at magpadala ng isang 5V na pulso sa makagambala na pin na PD2.

Gayunpaman, marahil ay masyadong maingay ng hindi bababa sa at pinakamalala hindi ito magpapahintulot sa sapat na oras para sa isang tumpak na pagbabasa ng keypress dahil ang output ng boltahe ng keypad ay walang oras upang magpakatatag bago makuha ang pagbabasa ng ADC.

Kaya mas gugustuhin naming magkaroon ng isang solusyon sa software. Ang nais naming gawin ay magdagdag ng isang nakakagambala sa PD2 pin at sumulat ng isang nakakagambala na handler para dito na tumatawag sa isang solong pagbasa ng keypad pin. Sa madaling salita, tinatanggal namin ang pag-abala ng autotrigger mula sa ADC, at nagdaragdag ng isang panlabas na abala na tumatawag sa ADC sa loob nito. Sa ganoong paraan ang signal upang basahin ang ADC ay dumating pagkatapos ng signal ng PD2 ay naganap na at maaari itong bigyan ang mga bagay ng sapat na oras upang ma-stablize sa isang tumpak na boltahe bago mabasa ang PC0 pin at ma-convert. Magkakaroon pa rin kami ng isang nakakagambala na pagkumpleto ng ADC na naglalabas ng resulta sa display ng analyzer sa dulo.

May katuturan? Gawin natin ito …

Tingnan ang nakalakip na bagong code.

Makikita mo ang mga sumusunod na pagbabago:

1. Nagdagdag kami ng isang rjmp sa address.org 0x0002 upang mahawakan ang INT0 panlabas na makagambala
2. Binago namin ang rehistro ng EIMSK upang ipahiwatig na nais naming makagambala sa INT0 pin
3. Binago namin ang ADATE pin sa rehistro ng ADCSRA upang huwag paganahin ang autotriggering
4. Natanggal namin ang mga setting ng ADCSRB dahil wala silang kaugnayan kapag naka-off ang ADATE
5. Hindi na namin kailangang i-reset ang panlabas na flag ng pag-trigger dahil ang pagkagambala ng INT0 ay awtomatikong ginagawa ito kapag nakumpleto ito - dati wala kaming isang nakakagambala na gawain, na-trigger lang namin ang ADC ng isang signal sa pin na iyon, kaya kailangan naming limasin ang watawat na iyon sa pamamagitan ng kamay.

Ngayon sa nakakagambala na handler tumawag lamang kami ng isang solong conversion mula sa ADC.

Exercise 5: Patakbuhin ang bersyon na ito at tingnan kung ano ang mangyayari.

Hakbang 12: Code at Video para sa Bersyong Paggawa

Tulad ng nakita natin sa huling bersyon, ang pindutan na makagambala ay hindi gumana nang maayos dahil ang pagkagambala ay na-trigger sa isang tumataas na gilid upang i-pin ang PD2 at pagkatapos ay tinawag ng gumagambala na handler ang conversion ng ADC. Gayunpaman, nakuha ng ADC ang pagbabasa ng boltahe bago ito nagpatatag at sa gayon binabasa nito ang kalokohan.

Ang kailangan namin ay upang ipakilala ang isang pagkaantala sa pagitan ng makagambala sa PD2 at sa pagbabasa ng ADC sa PC0. Gagawin namin ito sa pamamagitan ng pagdaragdag ng isang timer / counter, isang counter overflow na nakakagambala, at isang pagkaantala sa gawain. Sa kabutihang palad alam na natin kung paano ito gawin mula sa Tutorial 3! Kaya kopyahin at i-paste lamang namin ang may-katuturang code mula doon.

Naibigay ko ang nagresultang code at isang video na ipinapakita ito sa pagpapatakbo.

Mapapansin mo na ang mga pagbasa ay hindi tumpak na inaasahan ng isa. Malamang na ito ay dahil sa isang bilang ng mga mapagkukunan:

1. nagta-tap kami mula sa output ng boltahe ng keypad upang mag-trigger sa PD2 na nakakaapekto sa pagbabasa sa PC0.
2. hindi namin talaga alam kung gaano katagal mag-antala pagkatapos ng pag-trigger upang makuha ang pinakamahusay na pagbabasa.
3. tumatagal ng ilang mga pag-ikot upang makumpleto ang pag-convert ng ADC na nangangahulugang hindi kami maaaring mabilis na sunog sa keypad.
4. marahil ay may ingay mismo sa keypad.
5. atbp…

Kaya, kahit na pinamamahalaan namin ang keypad upang gumana, at maaari namin itong magamit sa mga application sa pamamagitan ng paggamit ng mga halaga ng keypress sa ibang paraan sa halip na i-output lamang ang mga ito sa display ng analisador, hindi ito masyadong tumpak at ito ay nakakainis. Iyon ang dahilan kung bakit sa tingin ko na ang pinakamahusay na paraan upang mag-wire keypad ay simpleng upang ilagay ang bawat output mula sa keypad sa isang iba't ibang port at magpasya kung aling mga key ang pinindot ng kung aling mga port makita ang isang boltahe. Madali iyan, napakabilis, at napakatumpak.

Sa katunayan, mayroon lamang dalawang mga kadahilanan kung bakit nais ng isang tao na magmaneho ng isang keypad sa paraang nagawa natin dito:

1. Gumagamit lamang ito ng 2 ng mga pin sa aming microcontroller sa halip na 8.
2. Ito ay isang mahusay na proyekto upang ipakita ang iba't ibang mga aspeto ng ADC sa microcontroller na kung saan ay naiiba mula sa karaniwang mga bagay na maaari mong malaman doon tulad ng mga pagbabasa ng temperatura, pag-on potentiometers, atbp. Nais kong isang halimbawa ng na-triggered na solong pagbabasa at panlabas na pin na awtomatikong nagpapalitaw sa halip na libreng pagpapatakbo ng CPU-gobbling mode lamang.

Gayunpaman, narito ang isang huling pares ng mga ehersisyo para sa iyo:

Pagsasanay 6: Muling isulat ang ADC conversion na kumpletong makagambala na handler upang magamit ang isang Look-up na Talahanayan. I.e. Upang masubukan nito ang halagang analog sa unang item sa talahanayan at kung mas malaki ito ay babalik mula sa makagambala, kung hindi pagkatapos ay nadaragdagan nito ang Z sa susunod na item sa talahanayan at muling bumalik sa pagsubok. Paikliin nito ang code at linisin ang nakakagambala na gawain at gagawing mas maganda ito. (Magbibigay ako ng isang posibleng solusyon bilang susunod na hakbang) Exercise 7: I-hook up ang iyong keypad sa 8 mga pin sa microcontroller at isulat ang simpleng driver para dito at maranasan kung gaano ito kaganda. Maaari ba kayong mag-isip ng ilang mga paraan upang pahusayin ang aming pamamaraan?

Iyon lang ang para sa tutorial na ito. Inilakip ko ang pangwakas na bersyon sa mga payo. Habang ginagawa namin ang aming paraan na malapit sa aming pangwakas na layunin, gagamitin namin ulit ang keyboard sa Tutorial 9 upang ipakita kung paano makontrol ang pitong segment na nagpapakita nito (at pagbuo ng isang bagay na kawili-wili na gumagamit ng mga sobrang key sa keypad ng telepono) at pagkatapos ay gagawin namin lumipat sa pagkontrol ng mga bagay gamit ang mga pindutan ng pindutan sa halip (dahil ang pamamaraang iyon ay mas umaangkop sa end na produkto na itinatayo namin patungo sa mga tutorial na ito) at isasaayos lamang namin ang keypad.

Magkita tayo sa susunod!