Tutorial sa AVR Assembler 9: 7 Mga Hakbang

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

Maligayang pagdating sa Tutorial 9.

Ipinapakita namin ngayon kung paano makontrol ang parehong isang 7-segment na display at isang 4-digit na display gamit ang aming ATmega328P at AVR Assembly code ng wika. Sa kurso ng paggawa nito kakailanganin naming gumawa ng mga paglilipat sa kung paano gamitin ang stack upang mabawasan ang bilang ng mga rehistro na kailangan naming itali. Magdaragdag kami ng isang pares ng mga capacitor (low-pass filters) upang subukang bawasan ang ingay sa aming keypad. Lilikha kami ng isang amplifier ng boltahe mula sa isang pares ng mga transistor upang ang aming INT0 makagambala switch ay mas mahusay na gumagana para sa mas mababang mga boltahe na boltahe sa ibabang hilera ng keypad. At itutulak namin ang aming mga ulo sa pader nang medyo sinusubukan na makuha ang tamang resistors upang ang bagay ay gumana nang maayos.

Gagamitin namin ang aming keypad mula sa Tutorial 7

Upang gawin ang tutorial na ito, bilang karagdagan sa karaniwang mga bagay, kakailanganin mo ang:

1. Isang 7-segment na pagpapakita

   www.sparkfun.com/products/8546

2. Isang 4-digit na pagpapakita

   www.sparkfun.com/products/11407

3. Isang pushbutton

   www.sparkfun.com/products/97

4. Ang mga datasheet para sa display na maaaring ma-download mula sa kani-kanilang mga pahina na naka-link sa itaas.
5. Isang 68 pf ceramic capacitor, isang pares ng 104 capacitors, isang bungkos ng resistors, dalawang 2N3904 NPN transistors.

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

Hakbang 1: Mga kable sa 7-seg na Display

Gagamitin namin ang parehong code na ginamit namin sa Tutorial 7 para sa keypad upang makontrol ang pagpapakita ng 7 segment. Kaya kakailanganin mong gumawa ng isang kopya nito at babaguhin namin ito.

Ipa-map namin ang mga segment sa mga pin ng aming microcontroller tulad ng sumusunod:

(dp, g, f, e, d, c, b, a) = (PD7, PD6, PB5, PB4, PB3, PB2, PB1, PB0)

kung saan ang mga titik ng mga segment ay ipinapakita sa larawan kasama ang pinout na naaayon sa karaniwang 5V at bawat isa sa mga LED segment kabilang ang decimal point (dp) sa ibabang kanan ng display. Ang dahilan para dito ay upang mai-input namin ang buong numero sa isang solong rehistro at output na nagparehistro sa mga port B at D upang magaan ang mga segment. Tulad ng nakikita mo ang mga piraso ay binibilang nang sunud-sunod mula 0 hanggang 7 at sa gayon ay mai-map ang mga ito sa tamang mga pin nang hindi kinakailangang itakda at i-clear ang mga indibidwal na piraso.

Tulad ng nakikita mo sa pamamagitan ng code na na-attach namin sa susunod na hakbang, inilipat namin ang aming gawain sa pagpapakita sa isang macro at pinalaya namin ang mga SDA at SCL na pin para magamit sa hinaharap sa susunod na Tutorial.

Dapat kong idagdag na kailangan mong maglagay ng risistor sa pagitan ng karaniwang anode ng display at ng 5V rail. Pinili ko ang isang 330 ohm risistor tulad ng dati ngunit kung gusto mo maaari mong kalkulahin ang minimum na resistensya na kinakailangan upang makuha ang maximum na ilaw sa display nang hindi ito pinrito. Narito kung paano ito gawin:

Una tingnan ang data sheet at pansinin na sa unang pahina nagbibigay ito ng iba't ibang mga katangian ng display. Ang mga mahahalagang dami ay ang "Forward Current" (I_f = 20mA) at ang "Forward Voltage" (V_f = 2.2V). Sasabihin nitong nais mong ang boltahe ay bumaba sa display kung ang kasalukuyang ay katumbas ng kasalukuyang pasulong. Ito ang maximum na kasalukuyang kukuha ng display nang walang pagprito. Dahil dito ay din ang maximum na ningning na maaari mong makuha mula sa mga segment.

Kaya't gamitin natin ang batas ng Ohm at ang panuntunan sa loop ni Kirchoff upang malaman kung anong minimum na pagtutol ang kakailanganin nating ilagay sa serye kasama ang display upang makuha ang pinakamataas na ningning. Sinasabi ng panuntunan ni Kirchoff na ang kabuuan ng mga boltahe ay nagbabago sa paligid ng isang closed loop sa isang circuit na katumbas ng zero at sinabi ng batas ni Ohm na ang boltahe ay bumaba sa isang risistor ng paglaban R ay: V = I R kung saan ako ang kasalukuyang dumadaloy sa pamamagitan ng risistor.

Kaya't binigyan ng isang boltahe ng mapagkukunan ng V at pag-ikot sa aming circuit mayroon kaming:

V - V_f - I R = 0

na nangangahulugang (V - V_f) / I = R. Kaya't ang pagtutol na kinakailangan upang makuha ang maximum na ningning (at marahil ang pagprito ng mga segment) ay:

R = (V - V_f) / I_f = (5.0V - 2.2V) /0.02A = 140 ohms

Kaya kung nais mo malugod mong magagamit ang 150 ohms nang walang pag-aalala. Gayunpaman, sa palagay ko 140 ohms ay ginagawang masyadong maliwanag para sa gusto ko at kaya gumagamit ako ng 330 ohms (na kung saan ay uri ng aking personal na paglaban ng Goldilock para sa mga LED)

Hakbang 2: Assembly Code at Video

Inilakip ko ang code ng pagpupulong at isang video na ipinapakita ang pagpapatakbo ng keypad kasama ang display. Tulad ng nakikita mong simpleng nai-map namin ang Redial key sa "r", ang flash key sa "F", ang asterisk sa "A" at ang hash sign sa "H". Maaaring ma-map ang mga ito sa iba't ibang mga operasyon tulad ng backspace, ipasok, at kung ano hindi kung nais mong magpatuloy na gamitin ang keypad para sa pag-type ng mga numero sa mga LCD display o 4 na digit na display. Hindi ako dumaan sa code line-by-line sa oras na ito dahil halos magkatulad ito sa nagawa na namin sa mga nakaraang tutorial. Ang mga pagkakaiba ay higit sa lahat sa parehong mga bagay na alam na natin kung paano gawin tulad ng mga nakakagambala at mga talahanayan ng pagtingin. Dapat mo lamang dumaan sa code at tingnan ang mga bagong bagay na naidagdag namin at ang mga bagay na binago namin at malaman ito mula doon. Babalik kami sa pagsusuri ng linya sa linya sa susunod na tutorial kapag ipinakilala namin ang mga bagong aspeto ng coding ng wika ng pagpupulong sa mga AVR microcontroller.

Tingnan natin ngayon ang isang 4-digit na display.

Hakbang 3: Mga kable sa 4-digit na Display

Ayon sa datasheet, ang 4-digit na display ay mayroong Forward Kasalukuyang 60 mA at isang boltahe sa unahan na 2.2 volts. Kaya, sa parehong pagkalkula tulad ng dati, maaari kong gamitin ang isang 47 ohm risistor kung nais ko. Sa halip ay gagamit ako ng isang… hrm.. tingnan ko … paano ang tungkol sa 330 ohms.

Ang paraan na ang 4-digit na display ay naka-wire ay mayroong 4 na mga anode, isa para sa bawat isa sa mga digit, at ang iba pang mga pin ay kumokontrol kung aling segment ang nagmumula sa bawat isa. Maaari kang magpakita ng 4 na digit nang sabay-sabay dahil ang mga ito ay multiplexed. Sa madaling salita, tulad ng ginawa namin para sa pares ng dice, simpleng ikot namin ang lakas sa pamamagitan ng bawat isa sa mga anod sa pagliko at ito ay magkikislap sa kanila pagkatapos ng isa pa. Gagawa ito nito nang napakabilis na hindi makita ng ating mga mata ang pagkurap at magmukhang nasa apat ang mga digit. Gayunpaman, siguraduhin lamang, ang paraan ng pag-code namin dito ay upang itakda ang lahat ng apat na digit, pagkatapos ay iikot ang mga anode, kaysa itakda, ilipat, itakda, ilipat, atbp Sa ganoong paraan makakakuha tayo ng isang tumpak na tiyempo sa pagitan ng pag-iilaw ng bawat digit.

Sa ngayon, subukan natin na gumagana ang mga segment.

Ilagay ang iyong 330 ohm risistor sa pagitan ng positibong riles ng iyong breadboard at ang unang anode sa display. Sinasabi sa amin ng datasheet na ang mga pin ay bilang mula 1 hanggang 16 na counter-clockwise simula sa kaliwang bahagi sa ibaba (kapag tumitingin ka sa display nang normal.. kasama ang mga decimal point kasama ang ilalim) at isinasaad nito na ang mga anode ay mga pin number 6, 8, 9, at 12.

Kaya't ikinonekta namin ang pin 6 hanggang 5V at pagkatapos ay kumuha ng isang negatibong tingga mula sa iyong GND rail at isuksok ito sa lahat ng iba pang mga pin at makita na ang lahat ng mga segment ay nag-iilaw sa digit na katumbas nito (na talagang ang pangalawang digit mula sa ang kanan). Tiyaking nakukuha mo ang lahat ng 7 mga segment at ang decimal point upang magaan.

Ngayon ay idikit ang iyong GND wire sa isa sa mga pin upang magaan ang isa sa mga segment at sa oras na ito ilipat ang risistor sa iba pang 3 mga anode at makita na ang parehong segment ay nag-iilaw sa bawat isa pang iba pang mga digit.

May anumang hindi pangkaraniwang?

Mali pala ang pinout sa datasheet. Ito ay dahil ito ang datasheet at pinout para sa isang 12-pin, 4-digit na pagpapakita. I.e. isa na walang colon o itaas na decimal point. Ang display na nakuha ko noong inorder ko ito ay isang 16 pin, 4-digit na display. Sa katunayan, sa minahan, ang mga segment ng anode ay nasa mga pin 1, 2, 6, at 8. Ang anode ng colon ay pin 4 (cathode pin 12) at ang itaas na dp anode ay pin 10 (cathode ay pin 9)

Pagsasanay 1: Gamitin ang iyong risistor at ground wire upang mai-mapa kung aling pin ang tumutugma sa aling segment at decimal point sa display upang makuha namin ang wastong mga segment na nag-iilaw kapag na-code namin ito.

Ang paraan na nais naming i-code ang mapa ng segment ay eksaktong katulad ng ginawa namin sa solong digit na 7-segment na pagpapakita sa itaas - hindi namin kailangang baguhin ang isang bagay sa code, ang tanging binago lamang namin ay kung paano nakakonekta ang mga wire sa pisara. I-plug lamang ang tamang port pin sa microcontroller sa kaukulang pin sa 4-digit na display upang, halimbawa, ang PB0 ay pupunta pa rin sa pin na naaayon sa segment a, ang PB1 ay papunta sa segment B, atbp.

Ang pagkakaiba lamang ay ngayon kailangan namin ng 4 dagdag na mga pin para sa mga anode dahil hindi na namin maaaring pumunta lamang sa 5V rail nang higit pa. Kailangan namin ang microcontroller upang magpasya kung aling digit ang makakakuha ng katas.

Sa gayon gagamitin namin ang PC1, PC2, PC3, at PD4 upang makontrol ang mga anode ng 4 na digit.

Maaari mo ring magpatuloy at i-plug ang mga wire. (huwag kalimutan ang 330 ohm resistors sa mga anode wires!)

Hakbang 4: Pag-coding ng 4-digit na Display

Pag-isipan natin kung paano natin nais na i-code ang display na ito.

Nais naming itulak ng gumagamit ang mga pindutan ng keypad at palabasin nang sunud-sunod ang mga numero sa display habang itinutulak nila ang bawat pindutan. Kaya't kung pipilitin ko ang isang 1 na susundan ng isang 2 lilitaw ito sa display bilang 12. Gusto ko ring iimbak ang halagang iyon, 12, para sa panloob na paggamit ngunit makakarating din kami sa paglaon. Sa ngayon nais ko lamang magsulat ng isang bagong macro na kumukuha ng iyong mga keypress at ipinapakita ang mga ito. Gayunpaman, dahil mayroon lamang kaming 4 na digit nais kong tiyakin na pinapayagan ka lamang nitong mag-type ng apat na numero.

Ang isa pang isyu ay ang paraan ng paggana ng multiplexed 4-digit na display ay sa pamamagitan ng pagbibisikleta ng mga anode upang ang bawat digit ay nasa isang split segundo lamang bago ipakita ang susunod at pagkatapos ay ang susunod at sa wakas ay bumalik sa una muli, atbp. kailangan ng paraan upang mai-code ito.

Nais din naming ilipat ang "cursor" sa kanan isang puwang kapag na-type namin ang susunod na digit. Kaya't kung nais kong mag-type ng 1234 halimbawa, pagkatapos kong mai-type ang 1, lilipat ang cursor upang ang susunod na na-type kong digit ay lilitaw sa susunod na 7-segment na display at iba pa. Lahat habang nangyayari ito gusto ko pa ring makita kung ano ang nai-type ko kaya't kailangan pa ring magbisikleta sa mga digit at ipakita ang mga ito.

Tunog tulad ng isang matangkad na order?

Ang mga bagay ay talagang mas masahol pa. Kailangan namin ng 4 pang mga pangkalahatang rehistro ng layunin na maaari naming magamit upang maiimbak ang kasalukuyang mga halaga ng 4 na mga digit na nais naming ipakita (kung susubukan namin sa pamamagitan ng mga ito kailangan naming panatilihin itong nakaimbak sa isang lugar) at ang problema dito ay mayroon tayo gumagamit ng hanggang sa pangkalahatang mga pagrerehistro ng layunin tulad ng mabaliw at kung hindi kami magbabantay wala na kaming maiiwan. Kaya marahil isang magandang ideya na talakayin ang isyung iyon nang mas maaga kaysa sa paglaon at ipakita sa iyo kung paano magbakante ng mga rehistro sa pamamagitan ng paggamit ng stack.

Kaya't magsimula tayo sa pamamagitan ng pagpapagaan ng mga bagay nang kaunti, gamitin ang stack, at palayain ang ilang mga pagrehistro at susubukan naming makamit ang gawain ng pagbabasa at pagpapakita ng aming mga numero sa 4-digit na display.

Hakbang 5: Push 'n Pop

Mayroong ilang mga "Pangkalahatang Mga Rehistro sa Layunin" lamang na mayroon kami at kapag ginamit na ito ay wala na. Kaya mahusay na kasanayan sa pagprograma na gamitin lamang ang mga ito para sa ilang mga variable na ginagamit bilang pansamantalang pag-iimbak na kailangan mo para sa pagbabasa mula, at pagsulat sa, mga port at SRAM, o iba pa na kakailanganin mo sa mga subroutine kahit saan at sa gayon ikaw pangalanan sila. Kaya kung ano ang nagawa ko, ngayong nasimulan na namin at natututo na gamitin ang Stack, ay dumaan sa code at hanapin ang pinangalanang mga rehistro ng pangkalahatang layunin na ginagamit lamang sa loob ng isang solong subroutine o makagambala at hindi saanman sa code at palitan ang mga ito sa isa sa aming mga rehistro sa temp at isang push at pop sa stack. Sa katunayan, kung titingnan mo ang code na nakasulat para sa mas maliit na mga microcontroller, o kung bumalik ka sa oras kung kailan mas maliit ang lahat ng chips, makikita mo lamang ang isang pares ng mga rehistro ng pangkalahatang layunin na dapat gamitin para sa lahat, kaya hindi mo magawa mag-imbak lamang ng isang halaga doon at iwanan ito mag-isa dahil sigurado ka na kailangan mo ang rehistro para sa iba pang mga bagay. Kaya makikita mo ang pushin 'at isang poppin' sa buong lugar sa code. Marahil ay dapat na pinangalanan ko ang aming temp pangkalahatang layunin na nagparehistro ng AX at BX bilang isang magalang na kudos sa mga nakaraang araw.

Ang isang halimbawa ay makakatulong na gawing mas malinaw ito.

Pansinin na sa aming Analog to Digital conversion kumpletong makagambala ADC_int gumagamit kami ng isang pangkalahatang rehistro ng layunin na pinangalanan namin ang buttonH na ginamit namin upang mai-load ang halaga ng ADCH at ihambing ito sa aming talahanayan ng paghahanap ng analog sa mga pindutang pindutin ang mga conversion. Ginagamit lamang namin ang pindutang itoH magparehistro sa loob ng ADC_int subroutine at saanman saan man. Kaya sa halip ay gagamitin namin ang aming variable temp2 na ginagamit namin bilang isang pansamantalang variable na maaari naming magamit sa loob ng anumang naibigay na subroutine at ang halaga nito ay hindi makakaapekto sa anumang bagay sa labas ng subroutine na iyon (ie ang halagang ibinibigay namin sa ADC_int ay hindi gagamitin kahit saan iba pa).

Ang isa pang halimbawa ay sa aming pagkaantala ng macro. Mayroon kaming rehistro na pinangalanan naming "milliseconds" na naglalaman ng aming oras ng pagkaantala sa milliseconds. Sa kasong ito ito ay nasa isang macro at naalala namin na ang paraan ng gawain ng macro ay inilalagay ng assembler ang buong macro code sa lugar ng programa kung saan ito tinatawag. Sa kasong ito nais naming alisin ang variable na "milliseconds" at palitan ito ng isa sa aming pansamantalang variable. Sa kasong ito ay gagawin ko ito nang kaunti upang ipakita sa iyo kung paano kahit na ang halaga ng variable ay kinakailangan sa ibang lugar maaari pa rin namin itong magamit sa pamamagitan ng paggamit ng stack. Kaya't sa halip na milliseconds ay gumagamit kami ng "temp" at upang hindi namin magulo ang iba pang mga bagay na gumagamit din ng halaga ng temp ay sinisimulan lamang namin ang "pagkaantala" na macro sa pamamagitan ng "pagtulak" ng temp sa stack, pagkatapos ay ginagamit namin ito sa halip na milliseconds, at pagkatapos ay sa dulo ng macro "pop" namin ang dating halaga pabalik mula sa stack.

Ang net na resulta ay "humiram" tayo ng temp at temp2 para sa pansamantalang paggamit at pagkatapos ay ibalik ang mga ito sa kanilang dating mga halaga kapag natapos na kami.

Narito ang ADC_int makagambala na gawain pagkatapos gawin ang pagbabagong ito:

ADC_int:

itulak ang temp; makatipid ng temp dahil binago natin ito dito itulak ang temp2; makatipid ng temp2 lds temp2, ADCH; load keypress ldi ZH, mataas (2 * numero) ldi ZL, mababa (2 * numero) cpi temp2, 0 breq return; kung ang mga nag-trigger ng ingay ay hindi nagbabago ng 7segnumber setkey: lpm temp, Z +; load mula sa table at post increment clc cp temp2, temp; ihambing ang keypress sa talahanayan brlo PC + 4; kung mas mababa ang ADCH, subukang muli lpm 7segnumber, Z; kung hindi man i-load ang keyvalue table inc digit; dagdagan ang digit na numero rjmp bumalik; at ibalik ang adiw ZH: ZL, 1; dagdagan Z rjmp setkey; at bumalik sa tuktok na pagbalik: pop temp2; ibalik ang temp2 pop temp; ibalik ang temp reti

Pansinin na ang paraan ng paggana ng stack ay ang unang on ay ang huling off. Tulad ng isang stack ng papel. Nakita mo na sa aming unang dalawang linya ay itinutulak namin ang halaga ng temp sa stack, pagkatapos ay itinutulak namin ang temp2 sa stack, pagkatapos ay ginagamit namin ito sa subroutine para sa iba pang mga bagay, at sa wakas ay ibinalik namin muli ang mga ito sa kanilang dating mga halaga ng unang popping temp2 (dahil ito ang huli na itinulak dito ay nasa tuktok ng stack at magiging una na i-pop off namin) at pagkatapos ay mag-pop temp.

Kaya't mula ngayon palagi naming gagamitin ang pamamaraang ito. Ang tanging oras na itatalaga talaga namin ang isang rehistro para sa isang bagay maliban sa isang variable ng temp ay kapag kakailanganin namin ito saanman. Halimbawa, ang rehistro na tinatawag na "overflows" ay isa na ginagamit namin sa maraming iba't ibang mga lugar sa programa at nais naming bigyan ito ng isang pangalan. Siyempre maaari pa rin nating magamit ito sa paraang nagawa namin sa temp at temp2 dahil ibabalik namin ang halaga nito pagkatapos naming matapos. Ngunit iyon ay spaghettify bagay masyadong maraming. Pinangalanan sila ng isang dahilan at mayroon kaming temp at temp2 na naitalaga para sa trabahong iyon.

Hakbang 6: Mga Filter na Low-pass at Voltage Amplifier

Upang malinis nang kaunti ang ingay at gawing mas mahusay ang aming keypad nais naming magdagdag ng isang pares ng mga low-pass filter. Sinasala ng mga ito ang ingay ng mataas na dalas at pinapayagang dumaan ang mababang signal ng dalas. Mahalaga ang paraan upang magawa ito ay upang magdagdag ng 68 pf capacitor sa pagitan ng aming analog input at ground at isang 0.1 microfarad (ibig sabihin 104) capacitor sa pagitan ng aming PD4 (INT0) na makagambala at mapunta. Kung nagpe-play ka sa mga ito habang pinipilit ang mga pindutan sa keypad maaari mong makita kung ano ang ginagawa nila.

Susunod na nais naming gumawa ng isang volt amplifier. Ito ay lumabas na ang ilalim na hilera ng mga key sa keypad (pati na rin ang redial key) ay naglalagay ng masyadong mababa ng isang boltahe upang ma-trip ang INT0 makagambala. Ang analog port ay sapat na sensitibo upang mabasa ang mga mababang boltahe mula sa mga key na ito ngunit ang aming makagambala na pin ay hindi nakakakuha ng sapat na tumataas na gilid upang makagambala kapag itinulak namin ang mga key. Samakatuwid nais namin ang ilang paraan ng pagtiyak na ang isang magandang boltahe na tumataas na gilid ay tumama sa PD4 ngunit ang parehong mababang boltahe ay tumama sa ADC0. Ito ay isang medyo matangkad na order dahil ang parehong mga signal ay nagmumula sa parehong output wire ng aming keypad. Mayroong isang bilang ng mga sopistikadong paraan upang magawa ito, ngunit hindi na namin gagamitin ang aming keypad pagkatapos ng tutorial na ito kaya't magkasama tayong magkasama sa isang pamamaraan na gumagana (bahagya).

Dapat mo munang mag-hook ng isang panlabas na pindutan upang mapalitan ang makagambala ng INT0 at makontrol ang display sa pamamagitan ng paghawak ng isang susi sa keypad at pag-click sa pindutan. Ito ay may mas kaunting mga problema sa keypad at papayagan kang maging tiwala na ang iyong mga voltages ay itinakda nang tama sa talahanayan ng pagtingin sa keypad. Kapag nalaman mo na ang keypad ay naka-wire nang tama pagkatapos ay alisin ang pindutan at ibalik ang INT0 pabalik. Mayroong ilang mga seryosong isyu sa ingay at boltahe na nagkokontrol sa keypad sa ganitong paraan upang mabuting malaman na gumagana ang lahat upang ang mga problema sa hinaharap ay maaaring ihiwalay sa key na INT0.

Kapag kinuryente mo ang iyong keypad at ang iyong boltahe amplifier, malamang na ang parehong mga halaga ng risistor na ginamit ko ay hindi gagana. Kaya kakailanganin mong gumawa ng ilang eksperimento upang makakuha ng mga halagang gagana para sa iyo.

Kung titingnan mo ang diagram na na-attach ko sa hakbang na ito makikita mo kung paano gagana ang voltage amplifier. Gumagamit kami ng ilang mga resistors at dalawang transistor. Ang paraan ng mga transistor ay gumagana (tingnan ang mga sheet ng data!) Mayroong isang minimum na boltahe na kailangan mong i-input sa base pin sa transister (ang gitnang pin) na mabubusog nito at payagan ang kasalukuyang dumaloy sa pagitan ng collector pin at ng emitter pin Sa kaso ng 2N3904 transistor na ginagamit namin dito ang boltahe ay 0.65V. Ngayon kinukuha namin ang boltahe na iyon mula sa aming output mula sa keypad at hindi namin nais na baguhin ang output na iyon kaya maglalagay kami ng isang malaking risistor sa pagitan ng output mula sa keypad at sa base ng unang transistor (ginamit ko ang 1Mohm). Na-label ko ito bilang R_1 sa diagram. Pagkatapos gusto naming mag-set up ng isang divider ng boltahe upang ang base ng transistor ay "halos" sa 0.65 volts na at isang maliit na maliit na bata pa ang magtutulak nito sa tuktok at mababad ito. Ang maliit na maliit na bit na ito ay magmumula sa output ng keypad kapag pinindot namin ang isang pindutan. Dahil ang mas mababang mga susi sa keypad ay naglalagay lamang ng isang maliit na boltahe na kailangan namin upang maging malapit sa saturation na upang ang mga ito ay sapat. Ang volters divider resisters ay may label na R_a at R_b sa diagram. Gumamit ako ng R_a = 1Mohm at R_b = 560Kohm ngunit halos tiyak na kakailanganin mong maglaro sa mga numerong ito upang maayos ito para sa iyong pag-set up. Maaaring gusto mong magkaroon ng isang pader sa malapit upang ma-bang ang iyong ulo laban at dalawa o tatlong baso ng scotch sa kamay (Inirerekumenda ko ang Laphroaig - mahal, ngunit sulit kung nais mo ang usok. Kung talagang mabaliw, mangyaring kumuha lamang ng isang pitsel ng BV at tumira para sa gabi)

Hinahayaan ngayon tingnan kung paano makukuha sa amin ng mga transistor ang isang mahusay na tumataas na gilid na papasok sa INT0 key at mabuo ang aming keypress na makagambala. Hayaan muna tingnan kung ano ang mangyayari kapag hindi ko pinipindot ang isang susi. Sa kasong iyon ang unang transistor (may label na T1 sa diagram) ay naka-off. Kaya't walang kasalukuyang dumadaloy sa pagitan ng mga kolektor at mga emitter pin. Sa gayon ang batayan ng iba pang transistor (may label na T2) ay mahihila nang mataas at sa gayon ito ay magbabad na nagpapahintulot sa kasalukuyang dumaloy sa pagitan ng mga pin nito. Nangangahulugan ito na ang emitter ng T2 ay mahila nang mababa dahil nakakonekta ito sa kolektor na kung saan mismo ay konektado sa lupa. Kaya, ang output na pupunta sa aming INT0 keypress interrupt pin (PD4) ay magiging mababa at walang makagambala.

Ngayon ano ang mangyayari kapag pinilit ko ang isang susi? Sa gayon ang batayan ng T1 ay napupunta sa itaas 0.65V (sa kaso ng mga mas mababang mga pindutan na bahagya lamang itong mapupunta sa itaas!) At pagkatapos ay pinapayagan na dumaloy na kung saan ay hilahin ang base ng T2 sa mababang boltahe at isasara nito ang T2. Ngunit nakikita namin na kapag ang T2 ay naka-off, pagkatapos ay ang output ay nakuha nang mataas at samakatuwid makakakuha kami ng isang 5V signal na papunta sa aming INT0 pin at magdulot ito ng isang nakakagambala.

Pansinin kung ano ang netong resulta dito. Kung itulak namin ang 1 key, makakakuha kami ng 5V na pupunta sa PD4 nang hindi binabago nang malaki ang output na papunta sa ADC0, at higit sa lahat, kahit na itulak namin ang Asterisk, 0, Hash, o Redial, nakakakuha rin kami ng isang 5V signal na papunta sa INT0 at din sanhi ng isang nakakagambala! Mahalaga ito dahil kung direkta lamang kaming nagpunta mula sa output ng keypad hanggang sa INT0 pin, ang mga susi na iyon ay bumubuo ng halos walang boltahe at hindi sila magiging sapat upang ma-trigger ang nakakagambalang pin. Ang aming boltahe amplifier ay nalutas ang problemang ito.

Hakbang 7: 4-digit na Display Code at Video

Iyon lang ang para sa tutorial 9! Inilakip ko ang code at isang video na ipinapakita ang operasyon.

Ito ang huling pagkakataon na gagamitin namin ang analog keypad (salamat sa diyos). Mahirap itong gamitin, ngunit napakapakinabangan din upang matulungan kaming malaman tungkol sa analog-to-digital na conversion, mga analog port, nakagagambala, multiplexing, mga filter ng ingay, amplifier ng boltahe, at maraming aspeto ng pag-coding ng pagpupulong mula sa mga talahanayan ng paghahanap hanggang sa mga timer / counter., atbp Iyon ang dahilan kung bakit nagpasya kaming gamitin ito. (plus nakakatuwa itong mag-scavenge ng mga bagay-bagay).

Ngayon ay titingnan namin muli ang komunikasyon at makuha ang aming 7-segment at ang aming 4-digit na display upang basahin ang aming mga dice roll mula sa aming dice roller sa parehong paraan na ginawa namin sa aming register analyzer. Sa oras na ito gagamitin namin ang interface ng dalawang kawad kaysa sa aming na-hack na magkasama na pamamaraan ng morse code.

Sa sandaling mayroon kaming mga komunikasyon na gumagana at ang mga rolyo ay nagpapakita sa mga ipinapakita maaari naming wakas gawin ang unang piraso ng aming pangwakas na produkto. Mapapansin mo na nang walang lahat ng mga bagay sa analog port ang aming code ay magiging mas maikli at malamang na mas madaling basahin.

Para sa iyo na mapaghangad. Narito ang isang "proyekto" na maaari mong subukan na tiyak na mayroon kang kaalaman na gagawin sa puntong ito kung dumaan ka sa lahat ng mga tutorial na ito hanggang sa puntong ito:

Project: Gumawa ng isang calculator! Gamitin ang aming 4-digit na display at ang aming keypad at magdagdag ng isang panlabas na push button na kikilos tulad ng isang "enter" key. Mapa ang asterisk sa "mga oras", ang hash upang "hatiin" ang redial sa "plus" at ang flash sa "minus" at magsulat ng isang gawain ng calculator na gumaganap tulad ng isa sa mga lumang HP "reverse polish" na mga calculator na mayroon ang lahat ng mga inhinyero noong araw. I.e. ang paraan ng pagtatrabaho nila ay ang pagpasok mo ng isang numero at pindutin ang "enter". Itinutulak nito ang numerong iyon sa stack, pagkatapos ay ipasok mo ang isang pangalawang numero at itulak ang "enter", na tinutulak ang pangalawang numero sa stack. Sa wakas pinindot mo ang isa sa mga pagpapatakbo tulad ng X, /, + o - at mailalapat ang operasyon na iyon sa nangungunang dalawang numero sa stack, ipakita ang resulta, at itulak ang resulta sa stack upang magamit mo ito muli kung ikaw ay gusto. Halimbawa upang magdagdag ng 2 + 3 na gagawin mo: 2, "enter", 3, "enter", "+" at babasahin ang display pagkatapos. Alam mo kung paano gamitin ang stack, ang display, ang keypad, at ikaw nakasulat na ang karamihan sa background code. Idagdag lamang ang enter key at ang mga subroutine na kinakailangan para sa calculator. Ito ay medyo mas kumplikado kaysa sa una mong iniisip, ngunit ito ay masaya at nakagagawa.

Magkita tayo sa susunod!