Mga switch sa Pagbasa Sa ATtiny2313: 9 Mga Hakbang

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

Mayroong maraming Mga Tagubilin na nakikipag-usap sa mga output mula sa ATtiny2313 at mga katulad na AVR device. Halimbawa Motor-with-an-AVR-Microprocessor /. Ang pagtatrabaho sa pinakabagong mula sa The Real Elliot, na kung saan ay ipinakita kung paano makontrol ang mga stepper motor, nalaman ko na magiging kapaki-pakinabang na makapagpatakbo ng mga kahaliling seksyon ng code sa parehong programa kaya hindi ko na muling pinoprogramang ang ATtiny2313 bawat isa oras nais kong subukan ang isang bahagyang pagkakaiba-iba ng code (tulad ng kalahating hakbang o pagpapatakbo ng stepper sa kabaligtaran). Habang madaling sumulat ng code gamit ang isang switch / case statement upang payagan ang pagpili ng mga kahaliling pagkakaiba-iba, kailangan ng ilang paraan ng pagpili ng kaso. Nangangahulugan iyon na ang ilang uri ng input aparato ay dapat basahin upang makontrol ang kaso. Sa kasamaang palad, ang ATtiny2313 ay may maraming mga I / O pin at mahusay na idinisenyo para sa pagbabasa ng mga input mula sa mga switch. Ipapakita ng Tagubilin na ito kung paano basahin ang mga input at gumawa ng mga desisyon batay sa kanilang estado. Dahil nag-iisa lamang ito ay makakagawa ng isang medyo nakakainip na Tagubilin, ipapaliwanag ko ang isang simpleng paraan ng paggamit ng timer / counter na kakayahan ng ATtiny2313 upang himukin ang isang maliit na speaker bilang beeper. Magkakaroon din ng isang maliit na paghihirap sa simpleng mga diskarteng pag-debug.

Hakbang 1: Ang Input na Device

Ang Instructable na ito ay nagtatayo sa mahusay na gawain ng The Real Elliot at ginagamit ang ATtiny2313 Ghetto development system na inilalarawan niya. Ang sheet ng data ng ATtiny2313 mula sa Atmel ay ang tunay na sanggunian para sa lahat ng mga pag-andar, ngunit hindi ito kinakailangang madaling basahin. https://www.atmel.com/dyn/products/datasheets.asp?family_id=607 (Ang link ay mayroong lahat ng mga sheet ng data ng AVR, hanapin ang 2313.) Ipinapakita ng figure ang isang simpleng hanay ng mga switch ng pag-input. Ito ay simpleng pakete ng apat na on / off switch; kilala rin bilang solong poste, solong throw switch (SPST). Karaniwan, ang isang koneksyon, o poste, ng bawat switch ay nakatali sa lupa habang ang iba pang koneksyon ay hinila ng mataas sa pamamagitan ng isang kasalukuyang nililimitahan risistor (10K o higit pa). Ang isang input ng microcontroller ay konektado sa poste na may risistor. Kung bukas ang switch, babasahin ng microcontroller ang input bilang HI. Kung sarado ang switch, babasahin ng microcontroller ang input na LO. Sumangguni sa eskematiko para sa mga detalye. Pinapasimple ng ATtiny2313 ang mga bagay sa pamamagitan ng pagbibigay ng programmable na pull-up resistors sa I / O pin kapag naka-configure ito bilang mga input. Nangangahulugan ito na ang mga switch ay maaaring magkaroon lamang ng isang poste na nakatali sa lupa (LO) at ang iba pang poste na konektado sa isang input ng processor. Ang unang halimbawa ay nagpapakita lamang ng dalawang switch. Ang mga switch ay nabasa at na-configure gamit ang sumusunod na code. I-configure ang mga switch bilang mga input: (Walang kinakailangang code; ito ang default.) I-on ang mga pull-up resistor: PORTB = _BV (PB0) | _BV (PB1); Basahin ang mga input: but1 = ~ PINB & 0x03; Tandaan ang paggamit ng inversion at masking upang makakuha ng tamang halaga.

Hakbang 2: Mga Blinkenlight para sa isang Signal

Gagamitin namin ang dalawang switch na ito upang magpikit ng isang LED na maaaring mai-program na bilang ng beses. Ang mga LED na gagamitin namin ay ang mga blinkenlight na pinasikat ng The Real Elliot. Ang mga switch 1 at 2 ay tratuhin bilang dalawang binary digit, kaya't ang kombinasyon ay maaaring kumatawan sa mga numero na 0, 1, 2, at 3. Babasahin ng aming programa ang dalawang switch at blink ang LED ang naaangkop na bilang ng beses, ngunit kung ang switch lamang nagbago ang mga setting. Ang mga switch ay nai-deblaim para sa 500 milliseconds (hindi na-optimize). Ang debounce algorithm ay medyo simple. Nabasa ang mga switch at nabasa ang pagbabasa. Kung ito ay naiiba mula sa dating halaga ngunit ang huling nai-save na halaga), ang programa ay naantala para sa 500 milliseconds at ang mga switch ay basahin muli. Kung ang halaga ay pareho ng dati nang nabasa, ang halaga ng luma. Ngunit maa-update at ang LED ay magpapikit ng bilang ng mga beses na ipinahiwatig ng binary halaga ng dalawang switch. Tandaan ang pagbabaligtad ng halaga dahil ang isang switch na "on" ay binabasa ang LO. Ang mga switch ay patuloy na mai-scan para sa karagdagang mga pagbabago. Mangyaring mag-refer sa naunang Mga Tagubilin ng The Real Elliot upang matuto nang higit pa tungkol sa mga blinkenlight. Tingnan ito https://www.ganssle.com/debouncing.pdf upang malaman ang higit pa tungkol sa mga pag-debon ng switch. Narito ang ATtiny2313 code para sa halimbawang ito. Sa pagpapatakbo, ang program na ito ay magpapikit sa LED sa PB4 (pisikal na pin 8) dalawang beses upang ipakita na naisasimulan. Babasahin nito pagkatapos ang mga switch ng isa at dalawa, at magpikit ng isa hanggang tatlong beses depende sa setting ng switch sa tuwing binago ang mga ito. Kapag ang mga switch ay hindi nagbabago, ang LED ay dahan-dahang magpikit. Upang patakbuhin ang code na ito, lumikha ng isang bagong direktoryo (tawagin itong "Pangunahin" kung nais mo) at i-download ang sumusunod na C code file at gumawa dito. Palitan ang pangalan ng Makefile1.txt sa Makefile lamang. Gamit ang WinAVR, ipunin ang programa at i-load ito sa iyong ATtiny2313.

Hakbang 3: Isang Minor Digression sa Pag-debug

Kung katulad mo ako (at bawat iba pang programmer sa mundo) marahil ay naranasan mo ang mga oras kung kailan ang "walang error" na code na maingat mong na-type at naipon ay hindi ginagawa ang inaasahan mong gawin. Marahil ay wala itong ginagawa! Kaya ano ang problema? Paano mo malalaman Sa kasamaang palad, maraming mga diskarte sa pagkuha ng mga bagay upang gumana. (Kunin ang librong ito para sa isang mahusay na paggamot ng paksa ng pag-debug. ang alam mo Kung nakakuha ka ng isang blinkenlight upang gumana nang isang beses, pagkatapos ay gamitin itong muli upang makita kung nasaan ka sa iyong programa. Gusto kong magkaroon ng LED blink nang dalawang beses upang ipahiwatig ang pagsisimula ng programa. Maaari mong ilagay ang code upang gawin ito nang una sa simula ng iyong programa. Kapag nalaman mo na walang mali sa iyong hardware, lumikha ng isang pagpapaandar upang gawin ang pagkurap. Narito ang pag-andar na ginagamit ko./*_ ------------------------------ ** blinkEm - pagpapaandar upang kumurap ng LED gamit ang PD4 ** PD4 ay dapat na naka-configure bilang isang output. ** ---- --------------------- * / void blinkEm (uint8_t count) {habang (count> 0) {PORTD = _BV (PD4); _delay_ms (1000); PORTD = ~ _BV (PD4); _delay_ms (1000); bilangin--; }} Posible na ngayong gamitin ang pagpapaandar na ito sa iba't ibang mga punto sa iyong code bilang isang senyas na ang code ay nagpatupad ng ganon kalayo. Ang pagkakaalam na tumatakbo ang code ay nangangahulugang maaari mong maingat na suriin ang bawat seksyon na tumakbo, ngunit hindi nagawa ang inaasahan mo, upang makahanap ng mga error. Ang pagbabago ng isang bagay nang paisa-isa ay isang pangunahing pamamaraan para sa pag-debug din (inilarawan sa sanggunian sa itaas). Gumagana ang klasikong pamamaraang ito kasama ang "hatiin at lupigin": ang pagkuha ng mga hakbang sa sanggol upang magdagdag ng pag-andar na incrementally. Ito ay maaaring mukhang isang mabagal na diskarte, ngunit hindi ito halos mabagal tulad ng pagsubok sa pag-debug ng isang malaking seksyon ng hindi gumaganang code nang sabay-sabay.

Hakbang 4: Higit pang Pag-debug

Maraming mga beses kung nais naming suriin ang isang seksyon ng code sa pamamagitan ng paglaktaw ng karamihan sa mga linya dito, pagkatapos ay paganahin ang mga ito nang paisa-isa habang pinatutunayan namin ang bawat isa ay gumagana. Karaniwan, ginagawa namin ito sa pamamagitan ng "pagbibigay ng puna" na mga linya na nais naming laktawan. Ang isang extension ng diskarteng ito ay upang i-cut at i-paste ang isang bloke ng code, puna ang orihinal (kaya hindi namin mawala ito), at i-hack ang kopya. Ang C ay may apat na madaling paraan upang magbigay ng puna sa mga linya. Ang paglalagay ng "//" sa harap ng isang linya ay nagkomento sa linya na iyon. Ang pagsasara ng isa o higit pang mga linya sa "/ *" at "* /" ay magkokomento sa isang buong seksyon. Para sa pamamaraang ito upang gumana nang epektibo, dapat walang ibang "* /" sa code block (maliban sa nagtatapos). Kaya't isang mabisang disiplina ang gumamit ng // para sa mga komento sa loob ng mga bloke ng code, at ipareserba ang / * * / konstruksyon para sa mga bloke ng komento at para sa pagbibigay puna sa mga seksyon ng code. Paglalagay ng "#if 0" sa simula ng isang bloke upang magbigay ng puna at tinatapos ang seksyon na may "#endif". Ang karagdagang pagpipiliang kontrol ay posible gamit ang "#ifdef (identifier)" sa simula ng isang bloke at "#endif" sa dulo. Kung nais mong maipon ang bloke, gamitin ang "#define (identifier)" nang mas maaga sa programa. Tandaan ang mga marka ng panipi ay para sa diin lamang at hindi dapat isama. Ang pagsasama-sama ng mga diskarteng ito ay dapat magbigay ng isang kapaki-pakinabang na diskarte sa pag-debug ng iyong mga programa sa ATtiny2313. Maaari mong makita ang mga tool na ito na kapaki-pakinabang sa pagpapatuloy namin sa pamamagitan ng Instructable na ito.

Hakbang 5: Paggamit ng Timer / Counter 0 para sa Beep

Ang ATtiny2313 ay may dalawang malakas na mapagkukunan ng timer / counter: isang 8-bit at isang 16-bit. Maaari itong mai-configure bilang mga tagabuo ng dalas, variable na pulse width modulate Controllers, at output ihambing ang mga rehistro. Ang buong pag-andar ng mga ito ay inilarawan sa 49 na mga pahina ng sheet ng data. Gayunpaman, gagamit kami ng isang simpleng kaso. Ang Timer / Counter 0 lamang (ang 8-bit na isa) ang gagamitin at gagamitin lamang ito bilang isang generator ng dalas. Ang dalas ay ililipat sa isang maliit na speaker upang makagawa ng isang beep. Ang timer / Counter 0 ay buong inilarawan sa mga pahina 66 hanggang 83 ng sheet ng data ng ATtiny2313. Ang isang malapit na pagbabasa ng materyal na ito ay magbibigay sa isa ng isang kumpletong pag-unawa sa Oras / Counter 0. Sa kabutihang palad, isang medyo simpleng mode, Clear Timer on Compare (CTC), ang kinakailangan lamang upang makabuo ng tono ng beep na gusto natin.

Para sa mode na gagamitin namin, ang pagpapatakbo ng Timer / Counter ay tuwid na pasulong. Kapag napili ang isang signal ng orasan, magsisimula ang counter sa zero at nagpapalaki ng bawat pulso ng orasan. Kapag naabot ng halaga ng counter ang halaga sa Pagrehistro ng Paghahambing ng Output (TOP), ang counter ay muling pag-reset sa zero at ang pagbibilang ay nagsisimulang muli. Ang output bit na nauugnay sa Timer / Counter ay na-toggle upang makabuo ng isang parisukat na output ng alon. Direkta nitong hinihimok ang isang audio transducer upang makagawa ng tunog ng beep. Ang isang maliit na TDK Audio Transducer ay gumagawa ng beep. Ang isang naaangkop na yunit ay Digikey 445-2530-ND, TDK SD1209T3-A1 (Gumamit ako ng isang maagang bersyon nito). Ito ay isang bersyon ng 3 volt; gagana rin ang bersyon ng 5 volt na inaasahan ko. Direkta ko itong hinihimok mula sa output port ng Attiny2313 at tila maayos itong gumagana. Ang Sparkfun ay may katulad na aparato.

Hakbang 6: Pag-configure ng Timer / Counter 0

Maaaring gamitin ang mode na CTC upang i-toggle ang output na OC0A sa Pin 2, Port B (pisikal na pin 14). Upang paganahin ang output sa pin na ito, ang DDRB ay dapat na maitakda nang naaangkop. Ang C code para dito ay tulad ng pagse-set up ng isang output para sa isang blinkenlight. DDRB = _BV (PB2); // Port B2 ay isang output. Ang susunod na hakbang ay upang magbigay ng isang signal ng orasan at i-load ang output ihambing ang magparehistro upang makabuo ng isang waveform bilang isang dalas. Ang equation para sa nagresultang dalas ay ibinibigay sa sheet ng data (pahina 72). Ang mga tuntunin sa equation ay ilalarawan sa ibaba. Narito ang equation: fOC0A = fclk_I / O / 2 * N * (1 + OCR0A) Kung saan ang fOC0A: = output frequency fclk_I / O: = frequency ng frequency ng orasan N: = orasan prescale factor OCR0A: = halaga sa output ihambing ang magparehistro para sa Timer / Counter 0A. Dalas ng Pinagmulan ng Orasan, fclk_I / OTIni ang dalas ng orasan ng system. Ang default na halaga ay 1MHz. Kinokontrol ng Bits CS00, CS01, at CS02 ng TCCR0B ang pagpipiliang ito. Dahil pinipili din ng mga bit na ito ang halaga ng N, inilalarawan ito sa susunod. Halaga ng Prescaler, NN ang halaga na ginamit upang hatiin, o prescale, ang orasan ng system. Kinokontrol ng Bits CS00, CS01, at CS02 ng TCCR0B ang pagpipiliang ito. Ang talahanayan 41 sa pahina 81 ng ATtiny2313 data sheet ay naglalarawan ng mga kumbinasyon. Dahil ang isang dalas na malapit sa 1kHz ay ninanais, ang mga piraso ng CS00 at CS01 ng TCCR0B ay maitatakda. Tandaan na ang pagtatakda ng lahat ng tatlong mga piraso sa 0, kung gayon ang pagpili ng walang mapagkukunan ng orasan, ay epektibo na hihinto ang output. Ito ang pamamaraang gagamitin upang simulan at ihinto ang beep. Halaga ng TOP, ang OCR0Ang halagang ito ay ang TOP na halaga para sa counter na na-load sa Pagrehistro ng Paghahambing ng Output para sa Timer / Counter 0A. Kapag naabot ang halagang ito, ang counter ay mare-reset sa zero at ang pagbibilang ay magsisimulang muli hanggang sa maabot ang TOP at ulitin ang ikot. Ang TOP ay madaling mabago, kaya't ang dalas ng beeper ay madaling mabago. Dahil ang isang dalas na malapit sa 1kHz ay ninanais, ang TOP ay nakatakda sa 7. (Tandaan na ang prescaler ay maaaring itakda sa 8, at ang TOP ay itakda sa 63. Parehong resulta - ang iyong pinili.) Dalas ng Output, fOC0AUsing ang equation upang makalkula ang mga resulta ng dalas ng output sa: fOC0A = 1, 000, 000/2 * 64 * (1 + 7) fOC0A = 977HzSara nang malapit! Narito ang code upang mai-load ang Rehistro ng Paghahambing ng Output at ang Rehistro ng Timer Counter Control 0B. Mangyaring tingnan ang aktwal na code ng programa upang maunawaan kung paano ginagamit ang mga ito. OCR0A = 7; // Time Value TCCR0B = _BV (CS01) | _BV (CS00); // Piliin ang panloob na orasan at prescale = 8 TCCR0B = 0; // walang pinagmulan ng orasan na pinapatay ang pagtatakda ng Oras / Counter Mode Bilang isang huling detalye, tutukuyin namin ang Timer / Counter mode na nais namin sa pamamagitan ng pagtatakda ng mga naaangkop na piraso sa Pagrehistro ng Timer / Counter Control 0A. Ang mode na CTC ay napili sa pamamagitan ng pagtatakda ng bit WGM01 tulad ng inilarawan sa Talahanayan 40, pahina 79 ng sheet ng data. Dahil nais namin ang output upang i-toggle ang bawat cycle, ang bit COM0A0 ay kailangan ding itakda tulad ng inilarawan sa Talaan 34 sa pahina 77. Narito ang code: TCCR0A = _BV (COM0A0) | _BV (WGM01); // CTC Toggle Mode

Hakbang 7: Paggamit ng Apat na Mga switch

Habang ipinapatupad namin ang beeper, palawakin natin ang aming hardware at software upang mahawakan ang apat na switch. Dahil ang output ng Timer Counter 0A ay nasa Port B, pin 2, hindi namin simpleng mai-hook up ang mas maraming mga switch nang sunud-sunod sa Port B. Ang isang madaling solusyon ay ang paggamit ng Port D, ngunit panatilihin nating magagamit ang port na iyon para sa iba pang mga pagpapaandar (marahil isang stepper motor). Kaya't hook natin ang mga karagdagang switch sa PB3 at PB4. Ang pagbabasa ng mga switch ay halos hindi nagbago. Ang halaga ng mask ay binago sa 0x1B (00011011 binary) upang i-mask ang bit 2 kasama ang 5, 6, at 7. Ang isang karagdagang trick ay ginagamit upang lumikha ng isang 4-bit na binary number. Paglipat ng mga piraso ng 3 at 4 na kanang isang piraso at pagsamahin ang mga ito sa mga piraso na 0 at 1 sa isang 4 na numero ng binary. Ito ang karaniwang C syntax para sa paglilipat at pagsasama-sama ng mga piraso, ngunit maaaring hindi ito kilala ng baguhan. but1a = (ngunit1 & 0x03) | ((but1 & 0x18) >> 1); // but1 has switch readingIn operasyon, ang programa ay magpapikit ng dalawang beses at beep dalawang beses upang senyas ng pagsisimula. Anumang oras na ang mga switch ay binago, ang numero na kinakatawan nila ay beeped. Kapag ang mga switch ay hindi nagbabago, ang LED ay kumikislap. Upang patakbuhin ang code na ito, lumikha ng isang bagong direktoryo (tawagan itong Beep kung nais mo) at i-download ang sumusunod na C code file at gumawa dito. Palitan ang pangalan ng Makefile2.txt sa Makefile lamang. Gamit ang WinAVR, ipunin ang programa at i-load ito sa iyong Attiny2313.

Hakbang 8: Gamit ang Lumipat / kaso Bumuo

Ang pangwakas na hakbang ay "software lamang": Tulad ng ipinangako, ipapatupad namin ang switch / case konstruksyon. Bagaman ang halimbawang ito ay nagpapakita lamang ng dalawang kahaliling mga pagkilos, dapat itong maging malinaw kung paano gamitin ang konstruksyon na ito upang pumili ng isa sa maraming mga kahaliling seksyon ng code. Sa pagpapatakbo, sinusubaybayan ng program na ito ang mga switch at kung mayroong isang pagbabago, ito ay beep ang naaangkop na numero kung ito ay kakaiba; kakurap ito kung pantay ang bilang. Wala itong ginagawa maliban kung magbago ang isang switch.

Upang patakbuhin ang code na ito, lumikha ng isang bagong direktoryo (tawagan itong Lumipat kung nais mo) at i-download ang sumusunod na C code file at gumawa dito. Palitan ang pangalan ng Makefile3.txt sa Makefile lamang. Gamit ang WinAVR, ipunin ang programa at i-load ito sa iyong Attiny2313.

Hakbang 9: Konklusyon

Kaya ayun! Ngayon alam mo kung paano gamitin ang mga switch upang makontrol ang pagpapatupad ng iyong programa sa pamamagitan ng pagbabasa sa mga ito at pagpili ng isang aksyon batay sa setting ng switch. Alam mo rin kung paano lumikha ng isang tono ng beep at natutunan din ang ilang diskarte sa pag-debug.

Kung nais mong subukan ang iyong pag-unawa, subukang baguhin ang huling programa upang tumugtog sa isang mataas na tono kung pantay, beep isang mababang tala kung kakaiba, at patuloy na kumurap ng LED kung walang pagbabago sa mga switch. Maaaring gusto mong tingnan bumalik sa seksyon sa pag-debug para sa tulong.