Mga Pangunahing Kaalaman sa Microcontroller

Ang isang bagay ay mahusay tungkol sa mga microcontroller IC, magagamit ang mga ito halos sa lahat ng bahagi ng mundo at mga elektronikong tagatingi.

Panimula

Ang mga aparatong pang-microcontroller ay patok na ginagamit sa mga aplikasyon na kinasasangkutan ng mga pagtatasa ng nakapaligid na kapaligiran at sa mga katulad na electronics.

Mahahanap mo ang mga aparatong ito na ginagamit para sa pagpapakita ng isang tiyak na parameter, sa mga aplikasyon ng kontrol sa motor, pag-iilaw ng LED, mga sensor ng iba't ibang uri tulad ng tilt sensor, accelerometer, speed meter, mga logger ng data, mga control sa temperatura, mga keyboard atbp.

Ang pangunahing pag-unawa patungkol sa mga microcontroller ay maaaring makuha sa pamamagitan ng pag-refer sa AVR Amega32 microcontroller na napakasulong na kung minsan ay tinatawag itong isang computer sa loob ng isang maliit na tilad.

Ang aparato na ito ay itinalaga upang magsagawa ng serye ng mga utos upang makabuo ng isang programa.

Ang wika ng program na makikita mo rito ay C ++. Malalaman mo ang wikang ito sa higit na kalaliman sa kurso dito.

Pagdating sa mga MCU, nakukuha mo ang pasilidad na mayroong pagpipiliang kontrolin at i-configure ang lahat ng mga pinout nito.

Kung medyo pagod ka na dito, chill ka lang kasi wala naman itong kumplikado, papagaan ka sa lahat ng aspeto na tuloy-tuloy ngunit matatag habang sumusulong tayo.

Sa isang MCU chip lahat ng mga pin maliban sa Vdd at Vss na kung saan ay ang mga power pin ng maliit na tilad, ay maaaring italaga sa mga eksklusibong pagtatalaga.

Mga Detalye ng Pinout

Kung susulyapan mo ang maliit na tilad mula sa tuktok, makakahanap ka ng isang maliit na tatsulok na bingaw na nagsasaad ng pagsisimula ng punto mula sa kung saan nagsisimula ang mga pinout bilangin na iyon ang # 1 pin ng maliit na tilad ay nagsisimula sa ilalim lamang ng pagkakakilanlan na ito.

Simula mula sa pin na ito mahahanap mo ang 20 mga pin hanggang sa ibaba sa gilid na iyon (kaliwa), at isa pang 20 mga pin sa kabilang panig (kanan), na nagpapatuloy mula sa ibaba hanggang sa itaas sa kanang bahagi.

Ang unang 8 na pin na nagsisimula sa bingaw ay ang PBO-7 na bumubuo sa mga index pin ng IC dahil ang lahat ng programa dito ay nagsisimula sa index zero.

Ang serye ng mga pinout sa itaas ay tinawag na PORT B, habang may iba pang magkatulad na hanay ng mga port na itinalaga A hanggang D.

Ang mga port na ito ay maaaring italaga upang tanggapin at kilalanin ang isang naka-feed na data na tinatawag na INPUT, at upang magpadala din ng data sa ilang tinukoy na form na tinatawag na OUTPUT.

Ang dalawa sa mga pin na dumating sa pangkalahatang kategorya ay ang (+) / (-) mga pin na tinukoy din bilang Vdd at GND.

Ang isang pin mula sa PORT D (PDO-6) ay maaaring makita na matatagpuan sa kaliwang bahagi ng maliit na tilad sa ibabang lugar.

Ang PD7 na pin # 7 ng PORT D ay maaaring masubaybayan na nakatayo nang nag-iisa at nagsisimula sa kanang serye sa mga serye ng mga pinout.

Ang paglipat ngayon mula sa kanang kamay na bahagi ng maliit na tilad kung saan nagtatapos ang PORT D, sinisimulan ng PORT C ang bilang nito pataas sa pagkakasunud-sunod.

Nag-aambag ito sa maraming mga kagiliw-giliw na mga pin ng MCU mula mismo sa analog sa mga digital.

Itinatampok ang mga pin na ito upang maging mga sensing input para sa pagtuklas ng maraming mga parameter sa pamamagitan ng panlabas na na-configure na mga yugto ng analog circuit.

Ang mga pin sa itaas ay bumubuo sa PORT A.

Ang analog sa digital na conversion sa kabuuan ng mga pin ay maaaring maunawaan sa tulong ng isang halimbawa kung saan ang isang antas ng temperatura ng analog na napansin na gumagamit ng isang ordinaryong sensor tulad ng isang thermister ay inilapat sa isa sa mga PORT A pin na madaling tanggapin at converter ng MCU upang makabuo ng isang digital readout mula zero hanggang 255 degree F (isang 8-bit na numero na maaaring ma-upgrade para sa pagkamit ng isang 10-bit na output).

Ang isa pang tampok na maaaring masaksihan sa mga MCU bilang karagdagan ay ang magagamit na puwang ng programa o ang memorya na tumutukoy sa puwang para sa mga variable at programa na tinukoy para sa microcontroller.

Bukod dito, ang mga MCU ay may built-in na orasan na nakatalaga para sa pagbibilang ng mga nauugnay na parameter.

Ang mga tampok na orasan ay nagbibigay-daan sa MCU na ilapat ang sarili nito para sa maraming iba't ibang mga proseso ng pagbibilang na maaaring mabilis sa saklaw ng mga microsecond depende sa detalye ng partikular na aparato, at maaari ding mas mabagal sa anumang nais na mga saklaw.

Sa ngayon ay maaaring naiintindihan mo ang konsepto ng microcontroller sa ilang lawak at patungkol sa mga port at pin nito.

Paano Lumikha ng isang SPI Connector mula sa Programmer hanggang sa Microcontroller

Ngayon ay oras na upang lumalim nang kaunti sa paksa at siyasatin ang mundo ng pagprograma.

Sinabi na, bago magpasok sa isang programa sa paglo-load ng pamamaraan sa maliit na tilad kailangan nating makahanap ng tamang paraan upang maisama ang konektor ng SPI (Serial Peripheral Interface) sa MCU.

Gayunpaman kahit na pagkatapos nito hindi lamang natin maitulak ang SPI sa mga pinout ng MCU, maaari ba natin? Hindi rin natin pinapayagan ang mga pinalawig na mga wire mula sa SPI upang direktang maipasok sa board ng tinapay. Maaari rin itong maging sanhi ng maling setting ng mga wire na konektado sa mga maling pin na gumagawa ng hindi magagandang koneksyon.

Samakatuwid upang makagawa ng mga bagay na ganap na hindi nagkakamali, ginagawa namin ang mga pamamaraan sa isang maliit na veroboard kung saan nakukuha namin ang kinakailangang pagkonekta na mga metal na pin na tinatawag ding 'header' na solder. Ang mga header pin na ito ay maaari nang gamitin para sa pagkonekta sa konektor ng SPI. Ang mga koneksyon mula sa header na ito ay maaaring wakasan sa isa pang mga parallel header pin na maaaring magamit para sa mga koneksyon sa breadboard.

Sa gayon ang pagpupulong sa itaas ay bumubuo ngayon ng isang masikip at maaasahang intermediate na platform ng pagkonekta para sa SPI sa MCU.

Uptil ngayon ang lahat ay mukhang maganda ang perpekto ng ad, kaya't magpatuloy tayo upang kumita patungkol sa programmer na kinakailangan sa pagitan ng iyong PC at ng MCU.

Maaaring may isang host ng mga kumpanya na gumawa at nagbebenta ng mga unit ng programmer na ito, kaya ang pagkuha ng mga ito ay hindi dapat maging isang problema sa iyo, tulad ng Adafruit Industries, USBtinyISP o Sparkfun atbp.

Ang ilan sa mga ito ay maaaring magmukhang ganap na magkakaiba sa mga maginoo na uri, ngunit karaniwang magkakapareho ang lahat at sundin ang karaniwang mga patakaran sa pagprograma at maaaring magamit bilang isang interface sa pagitan ng iyong PC at ng AVR microcontroller.

Gayunpaman siguraduhin ang isang pag-iisip, kung gumagamit ka ng iba pang MCU at hindi isang AVR Atmega32, maaaring kailanganin mong suriin para sa isang magkatugma na programmer para sa partikular na MCU chip.

Maaaring napansin na ang ilan sa mga programmer na ito ay gumagamit ng magkaparehong mga driver, isang bagay na tat dapat alagaan at malalaman natin ang tungkol dito sa aming mga susunod na kabanata.

Ang pagkonekta ng iyong PC gamit ang microcontroller chip ay totoong pangunahing, at ikalulugod mong malaman kung gaano kasimple ang mga paglilitis na kinakailangan para dito. Kaya't pindutin natin kaagad ang pindutanJ

Ang paggawa ng ipinaliwanag sa itaas na board ng interface ng SPI ay hindi mahirap, lahat ay tungkol sa pagkuha ng iyong iron solder na gumagana sa lahat ng mga koneksyon sa ipinakita na dalawang mga header row ng mga pin sa isang maliit na board ng pangkalahatang layunin.

Ipinapakita ng figure sa itaas ang mga detalye ng koneksyon na kailangan mong sundin habang magkakaugnay ang mga wire sa pagitan ng mga header.

Upang gawing mas simple ang mga bagay, dumaan tayo sa mga sumusunod na detalye ng koneksyon para sa pareho sa pamamagitan ng pag-refer sa imahe sa itaas:

Ang pin ng SPI na nagsisimula sa kaliwang tuktok ay pupunta sa 'Master IN, Slave OUT' (MISO)

Ang SPI pin mula sa gitna sa kaliwa ay kumokonekta sa pin ng orasan (SCK)

Ang SPI pin sa ibabang kaliwang ibabang sumali sa Reset. (Malalaman naming detalyado ang tungkol sa pin na ito sa mga sumusunod na tutorial)

Nauugnay ang SPI sa kanang kanang kawit ng GND pin ng MCU, ang GND ay tumutukoy sa pin na bumubuo sa zero supply line o negatibong (kamag-anak) na riles ng supply.

Ang pagwawakas ng SPI mula sa gitnang kanang header ay naka-link sa 'Master Out, Slave IN' (MOSI) na pin ng MCU.

Ang SPI na lumalabas sa tuktok na kanang header ay naka-wire sa (+) ng MCU na malinaw na ang Vdd o ang positibong supply pin ng MCU.

Ayan yun.

Ikonekta ang dalawang konektor tulad ng ipinaliwanag at ang iyong SPI interface board ay handa na para sa mga kinakailangang aksyon.

Para sa karagdagang tulong maaari kang kumunsulta sa figure na ipinakita sa itaas, ang iyong panghuling interface board ay dapat magmukhang ganito pagkatapos na ang lahat ng mga koneksyon sa wire ay naaangkop na nagawa sa tulong ng talakayan sa itaas.

Inaasahan kong nabuo mo na ang interface ng SPI tulad ng ipinaliwanag sa nakaraang tutorial, at oras na upang matiyak na tatanggapin ng aming computer ang programmer na kailangan naming isama sa pagitan ng PC at ng MCU.

Paggawa ng isang Simple Programming Code para sa isang MCU

Kumuha kami ng isang yunit ng USBTinyISP na magagamit mula sa Sparkfun, para sa pag-link ng computer sa microcontroller.

Alam namin na ang anumang operating system ng computer tulad ng Windows ay mangangailangan ng mga driver nang walang kung saan ay walang silbi na mag-load ng anumang bagay sa computer, sa gayon ang aming programmer ay mangangailangan ng mga driver upang mai-load sa iyong computer.

Sulyapan natin ang mga pamamaraang kinakailangan para sa pag-install ng mga driver sa iyong computer OS, dito kinukuha namin ang halimbawa ng Windows 7 OS na may alinman sa 32-bit o 64-bit na mga detalye.

Buksan ang sparkfun.com at mag-click sa 'pocket AVR programmer page'. Ang link ay maaaring madaling mailarawan sa loob ng pahina.

Susunod, hanapin ang 'Windows driver' sa ilalim ng mga dokumento at i-click lamang ito.

Bibigyan ka nito ng pocketprog-driver.zip file sa iyong computer.

Pumunta sa iyong computer, hanapin ang lokasyon ng pag-download at i-unzip lamang ang na-download na file sa isang folder.

Kung sakaling ang iyong computer ay isang 64-bit OS, kailangan mong sundin ang ilang higit pang mga hakbang tulad ng naibigay sa ilalim, na may 32-bit OS, maaari mong direktang simulan ang pag-install mula sa hindi naka-zip na file.

Para sa isang 64-bit na sundin ang mga ito, para sa 32-bit na huwag pansinin lamang:

Google 'libusb sourceforge' at mag-click sa mga link na ito pinakabagong bersyon.

Mahahanap mo ang ilang karagdagang mga file, subalit magiging interesado kang hanapin ang bib file, iyon ay: libusb-win32-bin - #. #. #. #. Zip

Ngayon, pumunta at hanapin ang lokasyon ng pag-download na ito sa iyong computer, i-unzip ito at i-save ito sa isa sa mga folder.

Sa folder na ito, mag-navigate sa folder ng bin, magpatuloy sa folder ng amd64.

Makikita mo ang isang pares ng mga folder dito bilang: ghcalled libusb0.dll at libusb0.sys.

Gusto mong palitan ang pangalan ng mga ito bilang: libusb0_x64.dll at libusb0_x64.sys.

Ngayon kakailanganin mong kopyahin ang mga file sa itaas sa folder ng pocketprog-driver, patungan lang ang mga file sa mayroon nang bersyon.

Upang mai-install ang mga driver sa itaas, ang sumusunod na pamamaraan na kung saan ay isang hindi pang-maginoo sa uri nito ay magiging interes ka:

Ito ay isang mode na 'magdagdag ng legacy hardware'.

Mag-click sa 'Start Menu'

Pagkatapos ay magpatuloy sa pamamagitan ng pag-right click sa 'computer'

Mag-click sa 'Pamahalaan', at sa wakas mag-click sa 'aparato manager'

Susunod, sa loob ng menu, piliin ang 'Magdagdag ng Legacy Hardware'

Magpatuloy upang pindutin ang 'susunod', hanggang sa maipasok ang wizard

Kasunod sa mga tagubilin, mag-click sa 'I-install ang hardware na kakailanganin mong pumili mula sa isang advanced na listahan' ito ay mag-uudyok sa icon ng pindutan ng radyo sa partikular na pagpipilian. Ito ay talagang isang pindutan ng kontrol sa windows na lilitaw ngayon tulad ng isang maliit na bilog na mayroong isang bilugan na asul na pag-file sa loob.

Ngayon i-click lamang ang 'Susunod'

Ipapakita nito sa iyo ang menu na 'Ipakita ang lahat ng Mga Device' kung saan kakailanganin mong i-click.

Pagkatapos nito magpatuloy upang mag-click sa 'Magkaroon ng Disk' Icon.

Sa tulong ng icon na 'Mag-browse', magpatuloy sa lokasyon ng pocketprog-driver folder. Kung ang pagpili ay wastong nagawa mo, makikita mo ang visual na pocketprog.inf file na nakalagay sa partikular na folder.

I-double click ang file na ito at tiyak na masasaksihan mo ang driver na nakakabit sa iyong PC.

Paulit-ulit !! Magsimula tayo sa aming susunod na tutorial sa susunod na pahina.

Sa ngayon maaaring na-install mo ang kinakailangang software at binuo ang interface ng SPI.

Paano Maglipat ng isang Programa sa isang Microcontroller chip

Ang susunod na hakbang ay tatawag para sa ilang mga bahagi tulad ng isang breadboard, isang LED at isang kinakalkula na risistor para sa inilaan na application.

Sa seksyong ito matututunan namin ang pamamaraan ng pagsubok ng programmer at kumpirmahing ang pag-install ng mga nauugnay na driver at ang software.

Upang mapatunayan kung ang mga driver at ang software ay na-install nang tama ipapatupad namin ang isang simpleng programa na kilala bilang avrdude.

Ang AVRdude ay isang programa na nauugnay sa pinakabagong pag-install ng WinAVR nang walang kung saan ang tunay na paglipat ng file sa MCU ay hindi maaaring maging posible.

Ang program na ito ay isang .hex format ng file na mahalagang naiintindihan ng MCU para sa mga kinakailangang pagpapatupad.

Kung sakaling hindi magtagumpay ang pag-verify, hindi magagawa ng programmer ang paglipat ng file.

Mabilis nating makita kung paano natin maipapatupad ang pamamaraan ng pagsubok sa tulong ng mga sumusunod na tagubilin:

Buksan ang prompt ng DOS (Disk operating system) sa pamamagitan ng pag-click sa 'start menu' at pagta-type sa cmd.exe sa ibinigay na box para sa paghahanap.

Ngayon ang pagsasakatuparan ng AVRdude ay maaaring gawin sa pamamagitan lamang ng pagta-type ng avrdude –c usbtiny –p m32 sa prompt ng DOS. Sa sandaling ipatupad ito, agad na makikilala ng DOS kung ang tagumpay ay matagumpay.

Sa utos sa itaas, ang '-c' ay isang pag-aabiso sa bandila na kasama ang pagtutukoy ng parameter ng 'usbtiny' na programmer, habang ang tag na '-p' ay kinikilala ang aparato ng microcontroller ('m32 na nagpapahiwatig ng Atmega32).

Kung sakaling gumamit ka ng ibang MCU, kakailanganin mong isama ang mga nauugnay na mga unlapi para sa pagpapatupad.

Kapag natapos na ang pamamaraang nasa itaas, maaari kang mag-type ng 'exit' sa prompt ng DOS, at ililipat ka nito sa labas ng window.

Kung seryoso kang nagtataka tungkol sa aktwal na mga detalye ng programa, mabuti para doon kailangan muna naming maghinang at buuin ang panlabas na analogue LED circuit kung saan maaaring ipatupad ang programa, sapagkat maliban kung may isang sistema na kilalanin ang tugon mula sa MCU, ang programa at ang pagpapatakbo ng microcontroller ay magiging walang katuturan.

Ang paggawa ng LED board ay napaka-simple, ang lahat ay tungkol sa paghihinang ng dalawang mga lead ng LED sa isang piraso ng veroboard at ikonekta ang risistor sa isa sa mga lead ng LED. Ang papel na ginagampanan ng LED na ito ay upang limitahan lamang ang kasalukuyang sa LED upang hindi ito masunog dahil sa sobrang boltahe ng kasalukuyang ad mula sa output ng MCU.

Ang halaga ng risistor ay maaaring kalkulahin sa pamamagitan ng paggamit ng sumusunod na simpleng formula:

R = (Ub - LEDfwd) / I

Kung saan ang Ub ay ang boltahe ng suplay, ang LEDfwd ay ang pinakamainam na boltahe ng pagpapatakbo ng ginamit na LED, at ako ang pinakamainam na amps nito.

Ipagpalagay na gumagamit kami ng isang RED LED na may LED forward boltahe = 2.5V at kasalukuyang I = 20mA, ang equation sa itaas ay maaaring malutas tulad ng sumusunod:

Dahil ang boltahe mula sa MCU ay magiging 5V, maaari itong ipahayag bilang:

R = (5 - 2.5) /. 02 = 125 ohms, ¼ watt, ang pinakamalapit na halaga na 120 ohms ang magagawa.

Ngayon mayroon kaming LED, isang resistor na 120 ohm at isang veroboard, magkaugnay lamang sa mga sangkap sa itaas na ibinigay sa diagram gamit ang microcontroller.

Kapag tapos na ito, maaaring ma-program ang MCU para sa inilaan na tugon sa na-set up na LED.

Susunod, ang programa ng MCU.

Upang payagan ang microcontroller na magsagawa ng ilang mga makabuluhang pagpapatupad, kinakailangan na sumulat ng mga naaangkop na tagubilin sa MCU.

Paano Mag-install ng Kapaligiran ng Programming at Imbistigahan ang WinAVR

Para sa mga ito maaari naming magamit ang aming sariling 'text editor' sa aming PC, bagaman maaaring pahalagahan ng isa sa amin ang paggamit ng isang mas propesyonal na 'kapaligiran sa programa' sa halip na isang ordinaryong editor ng teksto, simple sapagkat ang pamamaraang ito ay magpapahintulot sa iyo na masiyahan sa ilang in-built na kagiliw-giliw na mga tampok sa loob ng 'kapaligiran sa pag-program' na package.

Susuportahan nito ang paglikha at pag-edit ng mga programa sa pamamagitan ng iba't ibang mga wika at isulat din ang mga ito sa isang maihahatid na mode na madaling naiintindihan at tinanggap ng isang microcontroller chip.

Sa huli ay susuportahan ito ng WinAVR at maililipat sa nababahaging chip ng MCU.

Ang WinAVR ay maaaring maging kasangkapan upang maisagawa ang maraming iba pang mga operasyon tulad ng pag-troubleshoot ng mga programa at babalaan kami tungkol sa posibleng syntax at pag-iipon ng mga pagkakamali at error. Tatalakayin namin ang mga ito sa aking susunod na mga tutorial.

Gagawin mo ang kurso sa pag-install ng WinAVR upang maging napakabilis at mabilis. Sumisid tayo sa mga detalye sa mga sumusunod na puntos:

Kakailanganin mong i-download ang pinakabagong mga bersyon mula sa folder ng forge file na mapagkukunan ng WinAVR. Mahahanap mo ang ilang kapaki-pakinabang na impormasyon na nauugnay sa pag-download na ito mula sa opisyal na website.

Sasabihan ka sa isang query sa seguridad, upang masagot mo kung nais mong maganap ang pag-download, tinanong ang file na mai-download ay isang maipapatupad na file.

I-download ang file at simulan ang proseso ng pagpapatupad sa pamamagitan ng pag-click dito. Hayaang magsimula ang pag-install.

Gagabayan ka ng proseso ng ilang mga nasasagot na katanungan upang maaari mong i-streamline ang pag-install ayon sa iyong kaginhawaan. Nais mong huwag pansinin ang marami sa mga ito sa kanilang mga default na form, lahat ng ito ay sa iyo upang piliin ang mga na sa palagay mo ay pinakaangkop para sa mga pagkilos.

Hanggang ngayon makikita mo ang lahat ng normal at madaling pagpunta at makahanap ng ilang mga pagpipilian na ako ang start menu na itinapon sa iyo. Walang alalahanin, ilan lamang sa mga ito ang talagang gumagamit ng isa lamang sa tem na pinangalanang 'programmers notepad'.

Kapag na-click ang icon na ito, sisimulan ang interface ng gumagamit upang maaari mong mailapat ang pagsulat ng mga programa (tulad ng paglikha at pag-edit). Masasaksihan mo rin ang programa na binubuo ng mga utos sa menu para sa pagtulong sa iyo na mag-ipon ng mga code at i-embed ang mga ito sa microcontroller.

Ang pangunahing gawain ng notepad ng programmer sa itaas ay upang baguhin ang isang nababasa na code ng tao na nais mong isulat sa isang serye ng mga tagubilin na maiintindihan lamang ng MCU.

Saklaw ng susunod na tutorial ang pagsubok ng programmer sa itaas upang makatiyak kami patungkol sa pagiging tugma nito sa Windows at kung perpektong 'nakikipagkamay' ito sa iyong microcontroller IC.

Paano Mag-Program ng isang MCU para sa PAG-ON ng isang LED

Kapag nakumpirma na nito, magpapatuloy kami upang lumikha ng isang maliit na 'huwag gumawa' na code, upang matiyak lamang na ang pamamaraan ng paglilipat ng code ay hindi makaranas ng mga pagkakamali.

Siyempre handa na kami ngayon na ipatupad ang aming unang programa sa loob ng MCU, ngunit bago ito ay kagiliw-giliw na buod nang buod kung ano ang ginawa natin sa kurso ng aming mga nakaraang tutorial:

Nakuha namin ang microRtroller ng AVR Atmel ayon sa aming kinakailangang detalye dito ginamit namin ang ATMega32 para sa mga guhit. Susunod, nalaman namin ang tungkol sa mga pangunahing kaalaman sa microcontroller at ang yunit ng programmer na responsable para sa paglilipat ng isang programa sa MCU chip.

Dagdag dito, itinayo namin ang konektor ng interface ng SP na mahalaga upang ang iyong computer ay maiugnay sa microcontroller para sa mga pagkilos sa programa.

Pagkatapos nito ay nakumpirma namin kung ang mga driver ay na-install nang tama sa computer para sa isang 32-bit pati na rin isang 64-ngunit operating system.

Susunod, na-install namin ang kapaligiran sa programa na tinatawag na Win AVR para sa pagpapadali ng madaling paglipat ng ad ng paglipat ng mga code sa microcontroller, na sinusundan ng pagpapatupad ng avrdude para sa pagpapatunay ng programmer sa iyong PC at magkakaugnay na microcontroller.

Sa wakas sa nakaraang kabanata natapos namin ang pagbuo ng LED / resistor circuit at ikinonekta ito sa mga nauugnay na output ng MCU.

Iyon ay isang pulutong ng trabaho sa gayon gayunpaman oras na upang magtungo kaagad sa ilang totoong mga bagay sa programa!

Upang magsimula sa nais naming hatiin ang microcontroller sa tatlong mga kategorya mas madali nitong pinapasimple ang aming pag-unawa:

Pagkontrol, Pagtuklas, at Komunikasyon

Nakatutuwang malaman na ang mga pag-andar sa itaas ay maaaring mai-program sa maraming iba't ibang mga paraan.

Sa aming unang programa ay susubukan naming umorder ng microcontroller na 'kontrolin' ang isang panlabas na parameter, oo tama ka na ito ang magiging LED na itinayo namin kamakailan.

Upang maging tumpak, sasabihin namin sa MCU na lumipat SA nakakonektang LED, oo alam kong mukhang primitive ito, ngunit laging laging madali ang panimulang yugto.

Sumusulong sa kasalukuyang trabaho, ginagawa ang MCU control ang LED ay talagang medyo simple:

Para dito tinuturo namin ang pin # 0 sa PORT B ​​upang makagawa ng kinakailangang 5V para sa LED.

Alalahanin mula sa nakaraang tutorial, ikinonekta namin ang anode ng LED sa nabanggit na pin ng MCU sa itaas.

Mayroong dalawang mahahalagang bagay na kinakailangan upang matugunan ang pin na ito ng MCU: 1) output at 2) 5 volts

Malalaman namin ang isang paraan kung saan tinuturo namin ang partikular na pin upang maging output ng MCU.

Kapag naitakda ito upang maging output ng maliit na tilad, maaari naming turuan ito na maging 'mataas' (5V) o 'mababa' (0V) na ninanais para sa isang application.

Dahil ang anumang mga circuit ng lohika tulad ng isang MCU ang mga pin ay maaaring maging isang output o isang input at maaaring mai-configure upang makabuo ng alinman sa isang mataas na lohika o mababang lohika, ang mga pin ay kailangan lamang italaga alinman upang maging isang lohikal na mataas o isang lohikal na mababa , walang anumang mga kalagitnaan o hindi natukoy na estado maliban sa mga pares ng mga estado para sa mga microcontroller o para sa anumang digital IC para sa bagay na iyon. Gayundin ang parehong nalalapat para sa bawat pin ng MCU.

Tulad ng para sa mga takdang-aralin sa input at output, ang mga input ay nakaposisyon upang tanggapin ang mga signal mula sa panlabas na mga yugto ng analogue, habang ang mga output ay responsable para sa pagbibigay kahulugan sa mga tinukoy na lohikal na estado, o isang dalas.

Bagaman ang mga takdang-aralin sa itaas ay maaaring magawa sa maraming iba't ibang mga pamamaraan, tatalakayin namin ang isa sa kanila alang-alang sa pagiging simple. Gayunpaman dapat tandaan na kahit na ang ipapakita sa ngayon ay mukhang madali at kawili-wili, hindi ito mabubuhay at hindi isang inirekumendang uri para sa lahat ng mga aplikasyon ng MCU, sa parehong kadahilanan ay ipapakilala ka sa mga mas tanyag na pamamaraan ng pagprogram sa paglaon sa kurso. . Papayagan lamang ng mga programang ito ang nais na mga pin na italaga ayon sa mga detalye nang hindi nakakaapekto sa iba pang magkadugtong na maaaring itinalaga na upang gumawa ng iba pang mga pagpapaandar.

Gayunpaman sa ngayon hindi na kami masyadong mag-aalala tungkol sa iba pang mga pin at gagamitin lamang ang mga nauugnay na mga pin ng interes, na iniiwasan ang mga komplikasyon sa ilang mga saklaw.

Para sa pagtatalaga ng isang pin bilang isang output kailangan namin upang gamitin ang Data Direction Register (DDR). Kung nagtataka ka kung ano ang ibig sabihin ng pagrehistro dito, ito ay isang puwang lamang sa MCU na nagbibigay-daan sa microcontroller na tumugon sa ilang tinukoy na pamamaraan.

Gamit ang DDR maaari naming itakda ang pin upang magpadala ng isang data na tulad ng isang 'output', o tumanggap ng data na nasa anyo ng isang 'input'.

Gayunpaman maaari kang malito tungkol sa salita, ano ang ipinahihiwatig nito? Ang isang data ay nagdaragdag ng isang pangatlong dimensyon sa mga pin na maaaring italaga na patuloy na sa lohika zero (0V) o mataas na lohika (5V), ngunit kumusta naman ang mga signal na maaaring mabilis na mag-iba tulad ng dalas ng mga pulso. Ang isang dalas ay sasamahan ng mataas at mababang mga lohika (5V at 0V) na uma-oscillate sa ilang mga tinukoy na agwat o panahon, sa gayon ito ay nagiging oriented sa oras at maaaring maiakma patungkol sa oras, kaya nakilala namin bilang 'data' na nangangahulugang isang parameter na nagsasaad isang pagpapaandar na may kaugnayan sa isa pang pagpapaandar (mga estado ng lohika at oras).

Ang isang paraan ng pagtatalaga ng pin0 bilang isang output ay sa pamamagitan ng pagsulat ng sumusunod na code:

DDRB = 0b00000001

Sa program sa itaas, sinasaad ng DDRB ang Direksyon ng Direksyon ng Data para sa PORT B ​​0b na nagtuturo sa tagatala hinggil sa sumusunod na binary expression ng isang numero habang ang '1' sa dulo ng ekspresyon ay nagpapahiwatig ng posisyon ng pin0, iyon ang lokasyon sa form ng unang pin ng PORT B.

Kung naalala mong natutunan natin na ang PORT B ​​ay nag-uugnay ng 8 mga pin dito (mula 0 hanggang pin7), at kung napansin mo ang nasa itaas na code ay mayroon ding 8 mga digit dito, nangangahulugang ang bawat digit ay nagpapahiwatig ng 8 mga pin ng PORT B.

Ngayon ang susunod na pamamaraan ay upang magtalaga ng 5V sa pin na ito (pin0). Muli ang prinsipyo ng pagpapatakbo ay magkapareho sa DDR tulad ng nasa itaas na ipinahayag sa pamamagitan ng sumusunod na binary code:

PORTB = 0b00000001

Tulad ng nakikita, ang nag-iisa lamang na pagkakaiba sa itaas ng code at ng mas maaga ay sa code na ito na ginamit namin ang rehistro ng PORT. Partikular na pinangangasiwaan ng rehistro na ito ang mga takdang-pin ng partikular na port na kung saan nakaposisyon ito sa loob ng MCU. Sa gayon ay nagbibigay-daan ito sa amin na italaga ang totoong mga lohika ng data (0 o 1) para sa mga pinout na iyon.

Ngayon ay maaaring interesado kaming talakayin ang ilan tungkol sa tinatayang mga detalye ng aming programa. Tulad ng alam namin ang lahat ng mga programa ay nangangailangan ng isang partikular na puwang upang simulan ang pagpapatupad, maaari itong ihambing sa isang chef na alam ang lahat ng mga sangkap tungkol sa isang partikular na resipe ngunit hindi inatasan mula sa kung saan magsisimula.

Ang pagpapaandar na 'pangunahing' dito ay ang lokasyon kung saan ang bawat isa sa mga programa ng C / C ++ ay pinasimulan ang pagpapatupad. Samakatuwid ang pangunahing maaaring malikha bilang:

int main (walang bisa)
{
}

Gayunpaman upang paganahin ang programa na bigyang kahulugan ang mga detalye ng rehistro ng DDR at PORT at ang kanilang paggana sa loob ng MCU chip, isang karagdagang pahayag ang kailangang isama na maaaring binubuo ng lahat ng data tungkol sa AVR MCU. Marahil ay nais naming idagdag ang pagsasama na ito sa lahat ng aming mga programa.

# isama
int main (walang bisa)
{
}

Kaagad na nagsimula ang compilation, ang seksyon ng pre-processor ng tagatala ay nakatuon sa direktoryo ng AVR upang makilala ang 'io.h' na file. Ang extension na '.h' dito ay nagpapahiwatig na ito ay isang header file, at ang code na ito sa loob ng file ay ipapakilala sa simula (ulo) ng pinagmulang file na nilikha, samakatuwid ang pangalang 'header'.

Dito maaari naming ipakilala ang mga pahayag ng DDR at PORT sa aming code, dahil ang pagdaragdag ng io.h header file ay magdirekta sa tagatala hinggil sa kanila.

# isama

int main (walang bisa)

{

DDRB = 0b00000001 // Direksyon ng Data Magrehistro setting pin0 sa output at ang natitirang mga pin bilang input

PORTB = 0b00000001 // Itakda ang pin0 hanggang 5 volts

}

Inaayos ng nasa itaas ang oryentasyon ng pin0 bilang output, pagkakaroon ng lakas na 5V. Gayunpaman may isang isyu pa rin na hindi natutukoy para sa pin na ito, iyon ang pin na ito ay hindi pa mabilinan na ilipat ON nang walang katapusan hangga't ang MCU ay pinapagana. Ang walang katapusang loop ng feedback na ito ay magtitiyak na ang pin na ito mula sa MCU ay hindi magpapalipat-lipat, sa halip ay magpapatuloy sa output ng 5V nang walang katiyakan.

Bagaman maraming iba't ibang mga pamamaraan ng paglalapat ng isang tagubilin sa loop para sa isang pin, susubukan naming gamitin ang loop na 'habang' dito. Tulad ng iminungkahi ng pangalan, sinasabi ng loop na 'habang' ang microcontroller na 'habang' magagamit ang kuryente kailangan mong manatiling aktibo sa nakatalagang 5V para sa itinalagang pinout.

# isama

int main (walang bisa)

{

DDRB = 0b00000001 // Direksyon ng Data Magrehistro setting pin0 sa output at ang natitirang mga pin bilang input

PORTB = 0b00000001 // Itakda ang pin0 hanggang 5 volts

habang (1)

{

// Ang code ay nandito kung kinakailangan upang maipatupad nang paulit-ulit ... nang walang katapusan

}

}

Maaaring gusto mong tandaan na, dito ginamit namin ang '1' sa anyo ng isang argument para sa loop na 'habang', dahil ang lahat maliban sa '0' ay maaaring maituring na isang lohikal na 'totoo'.

Ipinapahiwatig nito, ang pagsasaalang-alang ng 'habang' na loop ay hindi magiging responsable para sa anumang bagay maliban sa isang lohikal na 'totoo', na nangangahulugang ang partikular na pin ay magkakabit sa tinukoy na estado nang walang katiyakan.

Ang LED ay maaaring masaksihan na maging ON sa nakatalagang pin na permanente hangga't ang MCU ay nakatanggap ng kapangyarihan sa buong Vdd at Vss nito.

Iyon lang, ngayon mayroon kaming resulta na nais naming makuha at sa wakas ay makita itong nangyayari pagkatapos ng labis na pagsusumikap, ngunit gayunpaman upang tingnan ang matamis na resulta ng aming pagsusumikap ay napakasisiya.

Sa loob ng mga susunod na tutorial matututunan namin kung paano magdagdag ng isang dimensyong 'oras' sa LED sa itaas, iyon ang paraan upang gawin itong kumurap sa isang tiyak na tinukoy na rate.

Sa totoo lang, sa pagpapatupad sa itaas, ang LED ay talagang kumikislap ngunit ang rate ng loop ay napakabilis na ito ay halos tulad ng isang permanenteng switch ON sa LED na ilaw.

Makikita natin kung paano maidaragdag ang loop na ito nang may pagkaantala tulad ng ninanais upang gawin ang blink ng LED sa naantalang rate.

Paano Gumawa ng LED Blink Gamit ang AVR microcontroller

Sa huling talakayan, natutunan namin kung paano gumawa ng LED switch ON sa pamamagitan ng isang microcontroller, napakahusay di ba? Maaaring hindi masyadong marami!

Malalaman dito kung paano pagandahin ang nasa itaas na pag-iilaw ng LED sa pamamagitan ng pag-uugnay sa isang bi-directional na pag-andar, susubukan naming gawin itong flash o magpikit sa ilang tinukoy na dalas o rate. Makikita rin namin kung paano maaaring tumaas o mabawasan ang rate na ito ayon sa ninanais ng gumagamit.

Tingnan natin ito:

# isama

# isama

int main (walang bisa)

{

DDRB | = 1<< PINB0

habang (1)

{

PORTB ^ = 1<< PINB0

_delay_ms (100)

}

}

Kung naguguluhan ka sa mga kakatwang simbolo na iyon (&, ^, | atbp) na ginamit sa expression sa itaas (& wala doon ngunit maaaring magamit sa iba pang mga katulad na code), narito ang kaugnay na impormasyon na nais mong malaman tungkol sa mga ito :

Nagsasama ito ng maraming pamantayan ng mga lohikal na algorithm tulad ng AT, O, HINDI at XOR na karaniwang ginagamit gamit ang code sa itaas.

Ang mga lohikal na pag-andar na partikular na ihinahambing ang dalawang piraso ng '1' at '0' ayon sa kanilang itinalagang mga talahanayan ng katotohanan.

Makakakuha kami ng isang ideya sa pamamagitan ng pag-aaral ng sumusunod na pag-aayos ng kaunti:

01001011 &
10001101
katumbas
00001001

Sa code sa itaas at tumutukoy sa AT na ginagamit sa C programa.

Ang pagbasa ng mga hilera nang patayo, iminumungkahi nito na ang 0 at 1 ay katumbas ng 0, 1 at 0 na katumbas din ng 0, 0 at 0 ay katumbas ng 0, 1 at 1 na katumbas ng 1. Ang pagbasa nito ay kasing simple nito. Ito ay ayon sa talahanayan ng katotohanan ng isang operator ng AT.

Kung susuriin namin ang sumusunod na talahanayan, ipinapahiwatig nito ang simbolo na '|' na tumutukoy sa paggamit ng pag-andar na 'O', ang '|' maaaring matagpuan sa kaliwa lamang ng 'backspace' sa iyong computer keyboard:

01001011 |
10001101
katumbas
11001111

Kapansin-pansin ang talahanayan ng katotohanan na ito ng isang OR na pag-andar ng lohika na nagpapahiwatig na ang mga 0 o 1 ay katumbas ng 1, 1 o 0 ay katumbas din ng 1, 0 o 0 ay katumbas ng 0, habang ang 1 o 1 ay katumbas ng 1.

Ang sumusunod na kumbinasyon ng kaunting ay para sa XOR operator ng lohika na tinukoy ng ^ at maaaring mapag-aralan tulad ng ginawa namin sa AT, O mga talahanayan ng katotohanan:

01001011 ^
10001101
katumbas
11000110

Ipagpatuloy natin ngayon ang unang programa at alamin kung ano ang ipinahihiwatig ng sumusunod na linya dito:

# isama

Sa pamamagitan ng aming mga nakaraang tutorial alam namin kung paano gumagana ang expression, kaya hindi namin ito uulitin subalit ang kanilang tila isang bagong 'isama' na ipinahayag ng # isama na kailangang siyasatin.

Sa ganitong 'isama' ang pagkaantala.h ay nagbibigay-daan sa amin ng ilang madaling paraan ng pagpapatupad.

Tulad ng ipinahihiwatig ng pangalan ng pagkaantala.h ay nagbibigay-daan sa amin upang magbuod ng pagkaantala sa partikular na programa.

Ang susunod na expression na int main (walang bisa) ay maaaring alisin mula sa nagpapatuloy na talakayan dahil nasakop na namin ito sa aming mga naunang post.

Susunod ay ang binagong DDRB.

Ipinapakita ng sumusunod ang naunang form na kung saan ay hindi isang mas mahusay na paraan ng pagtatalaga ng mga pin dahil lahat ng mga pin mula 0 hanggang 7 ay lumipat upang mabuo ang mga input. Ngunit isipin lamang kung ano ang magiging sitwasyon kung nais naming lumikha ng isang mas mahabang programa na nangangailangan ng mga pin para sa ilang iba pang pagpapaandar? Halimbawa ay maaaring kailanganin ang pin2 para sa paglalapat ng isang remote switching ng isang appliance. Sa kasong iyon hindi namin mapahahalagahan ang pagtatalaga ng pareho bilang isang input sa pamamagitan lamang ng pagsubok at error. Maaaring mangahulugan iyon ng maling sagot mula sa remote transmitter sa tatanggap ng appliance.

DDRB = 0b00000001

Mas gusto naming impluwensyahan ang isang piraso lamang, hat pin0 bit, pagsulyap sa pag-andar na 'O' maaari itong maisagawa sa pamamagitan ng isang binary masking.

DDRB = DDRB | 0b00000001

Narito ito ay natabunan ng isang 'OR' mask: 0b00000001, kahit na ito ay lumilitaw na isang tunay na numero ng binary, kung sakaling ang naunang DDRB halimbawa: 0b01001010, pagkatapos ay ang paglalapat ng isang O dito sa pamamagitan ng masking ay maaaring magbigay: 0b01001010 | 0b00000001 = 0b01001011.

Ang nagreresultang pagkakaiba na maaaring masaksihan ay sa pin0 lamang, na ang mga piraso ay nagbago!

Ang pag-compress ng pahayag sa itaas nang higit pa sa pamamagitan ng C ++ ay nagbibigay:

DDRB | = 0b00000001

Gayunpaman nalaman namin na mayroong higit pa sa naibigay na programa. Bagaman maaaring ito ay mukhang lehitimo at halata dapat nating kunin ang benepisyo ng ilan sa mga pahayag mula sa io.h header file lalo na kung panimula itong nilikha para sa ating kaginhawaan?

Kaya kung ang “DDRB | = 1<< PINBO, why it’s like that?

1<< PINBO is implemented for applying the masking effect. The “1” indicates what may be introduced inside the mask, while the < < is simply the left shift functionality. It executes exactly as it’s named, and PINBO is the number of locations that the “1” would sequence across the left hand side. To be precise PINBO may be equivalent of a 0.

Kaya't nagsisimula kami sa isang 0b00000000, at naglalagay ng isang '1' upang makabuo ng 0b0000001 at pagkatapos ay ilipat namin ito sa kaliwang 0 na posisyon, na nagbibigay ng eksaktong eksaktong 0b00000001 tulad ng nasa itaas.

Ngayon, kung ipalagay na ito ay PINB4, ang pahayag ay maaaring ipahayag bilang 1<< PINB4. I this case the “1” would be pushed to the left 4 locations producing: 0b00010000.

Mag-ingat na gumagamit kami ng isang zero index na nangangahulugang mayroong apat na zero pagkatapos ng '1'.

Nagpapatuloy ngayon sa 'habang' loop na aming napansin sa buong 'walang katapusang loop' nang mas maaga. Ngunit marahil ngayon nais namin ang microcontroller na magpatupad ng ilan sa mga nais na pagpapatupad. Maaari lamang itong magawa sa loob ng ibinigay na loop. Ito ang loop kung saan ang partikular na pagkakasunud-sunod ay paulit-ulit na paulit-ulit.

Kung sakaling mailagay ang pagpapatupad bago ang loop, naisagawa lamang itong magpatupad nang isang beses.

Gayunpaman upang magawa ang LED blink nang walang katiyakan kakailanganin nitong ilipat ang PINB0 na halili ON / OFF sa loob ng loop. Natagpuan din namin ang mga pagkaantala na ipinakilala, kung wala ang pagpikit ng LED ay imposible. Ngunit pipilitin nitong humantong ang LED sa isang napakabilis na rate na mahirap makilala sa mata, kakailanganin itong magpabagal nang kaunti upang maging makilala ng ating mga mata.

Alam namin ang pag-set up ng pamamaraan ng isang partikular na bit sa binary na numero, ngunit hindi sigurado ang pamamaraan ng paglalapat ng isang tukoy na '0' sakaling ito ay isang '1' pa.

Makikita ang sumusunod na programa na ginagawa ito ngunit malalaman din namin na maaaring hindi ito nakikita sa programa.

Ang paunang dalawang pahayag ay binabago ang kaunti sa '1' (5V, LED lights), pagkatapos ang isang pag-pause ay ipinakilala sa loob ng 100 ms.

Ang susunod na pares ng mga linya ay ginagawang PINB0 bit sa '0' (zero boltahe, LED shut off), ngunit paumanhin ang AT ihambing ay hindi magagawang magpatupad ng isang '0' mula sa kaunti, ngunit kung gagamitin namin HINDI '~' para sa binary mask maaari itong ilipat ang lahat ng 0 sa 1s at vice versa.

Ito ay magbibigay-daan sa amin upang maimpluwensyahan lamang ang PINB0 bit at i-flip ito sa '0'. Ang panaklong ay isinama upang maglaman ng pagpapatupad ng masking tulad na ang HINDI pagpapatakbo ay maaaring mailapat para sa buong mga maskara at hindi lamang sa '1' bago ang kaliwang shift na '<<”.

PORTB | = 1<< PINB0
_delay_ms (100)
PORTB & = ~ (1<< PINB0)
_delay_ms (100)

Upang likhain ang mga pagkaantala sa ON OFF o ang mga panahon ng pantay na tagal, maaari naming putulin ang nakaraang apat na linya sa dalawa at ilapat ang pagpapaandar ng XOR sa aming pakinabang. Dapat pansinin na isang pagpapatupad ng XOR ang isang itinalagang pin sa isang 1 sakaling ito ay 0 at kabaligtaran. Maimpluwensyahan lamang ng pagpapatupad na ito ang PINB0. Tulad ng maaaring beses na mailapat ang utos, gagawin lamang nito ang kaunti sa kabaligtaran ng umiiral na lohika.

PORTB ^ = 1<< PINB0
_delay_ms (100)

TAPOS NA! Ang iyong LED ay kumikislap ngayon ayon sa itinakdang rate .... .Simple, hindi ba iyon?