AVRSH: isang Command Interpreter Shell para sa Arduino / AVR .: 6 na Hakbang (na may Mga Larawan)

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

Nais mo bang "mai-log in" sa iyong AVR microcontroller? Naisip mo bang magiging cool na "pusa" ang isang rehistro upang makita ang mga nilalaman nito? Palagi mo bang ginustong isang paraan upang mapalakas at mapalakas ang indibidwal na mga sub-system ng paligid ng iyong AVR o Arduino sa * real time *? Ako rin, kaya sinulat ko ang AVR Shell, isang mala-UNIX na shell. Ito ay tulad ng UNIX sapagkat nakapagpapaalala nito ang shell account na lumabas ka at bumili upang patakbuhin ang iyong mga bots ng banggaan sa irc nick, pati na rin ang pagkakaroon ng isang utos o dalawa na magkatulad. Mayroon din itong isang filesystem na kahawig ng UNIX extfs, na gumagamit ng isang panlabas na EEPROM, ngunit iyon ay naging isang proyekto sa kanyang sarili kaya't ilalabas ko nang hiwalay ang module na iyon sa ilalim ng ibang pagtuturo kapag handa na ito sa produksyon. Narito ang isang listahan ng mga bagay na maaari mong gawin ngayon sa AVR Shell:

• Basahin ang lahat ng iyong Rehistro ng Direksyon ng Data (DDRn), mga port, at mga pin sa real-time
• Sumulat sa lahat ng iyong DDRn's, port, at pin upang i-on ang mga motor, LED's, o basahin ang mga sensor nang real-time
• Ilista ang lahat ng mga kilalang rehistro sa system
• Lumikha at mag-imbak ng mga halaga sa mga variable na tinukoy ng gumagamit na nai-back up ng EEPROM.
• Lumikha ng isang root password at patunayan laban dito (ginamit para sa pag-access sa telnet)
• Basahin ang na-configure na bilis ng orasan ng CPU
• Baguhin ang bilis ng iyong orasan ng CPU sa pamamagitan ng pagtatakda ng isang prescaler
• Simulan at ihinto ang 16-bit timer para sa tiyempo ng iba't ibang mga bagay
• I-power up at / o i-power down ang mga sub-system ng paligid: Analog sa Digital Converter (ADC), Serial Peripheral Interface (SPI), Two-wire Interface (TWI / I2C), UART / USART. Kapaki-pakinabang para sa kung kailan mo nais na bawasan ang pagkonsumo ng kuryente ng microcontroller o upang paganahin ang ilang mga pagpapaandar.
• Nakasulat sa C ++ na may magagamit muli na mga bagay.

Ang nagtuturo na ito ay lalakad sa pag-install, paggamit, at pagpapasadya ng avrsh.

Hakbang 1: Ano ang Kakailanganin Mo

Ang itinuturo na ito ay hindi nangangailangan ng labis maliban sa iyo:

• Magkaroon ng isang Arduino o ATmega328P. Maaaring gumana ang iba pang mga AVR, ngunit maaaring kailanganin mong baguhin ang code upang ilista ang anumang mga rehistro na natatangi sa iyong MCU. Ang mga pangalan ay kailangan lamang upang tumugma sa nakalista sa header file na natatangi sa iyong MCU. Marami sa mga pangalan ng rehistro ay pareho sa pagitan ng mga AVR, kaya't ang iyong mileage ay maaaring mag-iba kapag nag-porting.
• Magkaroon ng isang paraan upang kumonekta sa serial USART ng iyong Arduino / AVR. Ang sistema ay nasubukan nang labis sa AVR Terminal, isang Windows app na gumagawa ng isang serial na koneksyon sa pamamagitan ng iyong USB o COM port. Gumagawa sa mga Arduino gamit ang koneksyon sa USB at anumang AVR gamit ang USB-BUB mula sa Moderndevice.com. Kabilang sa iba pang mga pagpipilian sa terminal ang: Putty, minicom (Linux at FreeBSD), screen (Linux / FreeBSD), Hyperterminal, Teraterm. Natagpuan ko ang masilya at teraterm na nagpapadala ng ilang basura kapag kumokonekta upang ang iyong unang utos ay maaaring maging garbled.
• I-install at patakbo ang firmware ng AVR Shell, na maaari mong i-download mula sa mga pahinang ito, o palaging makuha ang pinakabagong bersyon sa BattleDroids.net.

Upang mai-install ang AVR Terminal, i-unpack lamang ito at patakbuhin ito. Upang mai-install ang AVR Shell firmware, i-download ito at direktang i-upload ang hex file at ikonekta ang iyong serial terminal sa 9600 baud, o i-compile ito ng iyong sarili sa "make" at pagkatapos ay "gumawa ng programa" upang mai-upload ang hex. Tandaan, maaaring kailanganin mong baguhin ang mga setting ng AVRDUDE upang maipakita ang iyong COM port. Tandaan: Ang katangiang PROGMEM ay nasira sa kasalukuyang pagpapatupad ng AVR GCC para sa C ++ at ito ay kilalang bug. Kung iyong pinagsama-sama ito, asahan na makakuha ng maraming mga mensahe ng babala na nagsasabing "babala: mga inisyal na variable lamang ang maaaring mailagay sa lugar ng memorya ng programa." Bukod sa nakakainis na makita, ang babalang ito ay hindi nakakasama. Tulad ng C ++ sa naka-embed na platform ay hindi mataas sa listahan ng mga prayoridad ng AVR GCC, hindi alam kung kailan maaayos ito. Kung titingnan mo ang code, makikita mo kung saan ako gumawa ng paligid upang mabawasan ang babalang ito sa pamamagitan ng pagpapatupad ng aking sariling mga pahayag sa katangian. Simple lang. Mag-download at mag-install ng anumang bagay na maaaring kailanganin mong i-flip ang pahina at kumuha tayo ng crackin '.

Hakbang 2: Mga Rehistro sa Pagbasa at Pagsulat

Pangunahing isinulat ang AVR Shell upang ma-access ang ilang mga sensor na nakakonekta ko sa aking AVR. Nagsimula ito sa isang simpleng LED pagkatapos ay lumipat sa mga light sensor, mga sensor ng temperatura, at sa wakas sa dalawang mga ultrasonic transducer. Maaaring itakda ng avrsh ang mga digital na bahagi ng mga sensor na ito sa pamamagitan ng pagsulat sa mga rehistro na kumokontrol sa kanila. Pagmanipula ng mga rehistro ng AVR habang tumatakbo Upang makakuha ng isang listahan ng lahat ng mga kilalang rehistro sa iyong Arduino, uri:

print register at makakakuha ka ng isang printout na ganito

Alam ko ang tungkol sa mga sumusunod na rehistro:

TIFR0 PORTC TIFR1 PORTD TIFR2 DDRD PCIFR DDRB EIFR DDRC EIMSK PINB EECR Pinc EEDR PIND SREG EEARL GPIOR0 EEARH GPIOR1 GTCCR GPIOR2 TCCR0A TCCR0B TCNT0 OCR0A OCR0B SPCR SPDR ACSR SMCR MCUSR MCUCR SPMCSR WDTCSR CLKPR PRR OSCCAL PCICR EICRA PCMSK0 PCMSK1 TIMSK0 TIMSK1 TIMSK2 ADCL ADCH ADCSRA ADCSRB ADMUX DIDR0 DIDR1 TCCR1A TCCR1B TCCR1C TCNT1L TCNT1H ICR1L ICR1H OCR1AL OCR1AH OCR1BL OCR1BH TCCR2A TCCR2B TCNT2 OCR2A OCR2B ASSR TWBR TWSR TWAR TWDR TWCR TWAMR UCSR0A UCSR0B UCSR0C UBRR0L UBRR0H UDR0 PORTB root @ ATmega328p> Upang makita kung paano itinakda ang mga indibidwal na piraso sa anumang rehistro, gamitin ang utos ng pusa o echo

pusa% GPIOR0 Hinihiling kong ipakita ng tagasalin ang utos na ipakita, o i-echo, ang mga nilalaman ng Pangkalahatang Pakay na I / O Magrehistro # 0. Tandaan ang porsyento ng sign (%) sa harap ng pangalan ng rehistro. Kailangan mo ito upang ipahiwatig sa shell na ito ay isang nakalaan na keyword na tumutukoy sa isang rehistro. Ang karaniwang output mula sa isang utos ng echo ay ganito ang hitsura

Ang GPIOR0 (0x0) ay nakatakda sa [00000000] Ipinapakita ng output ang pangalan ng rehistro, ang hexadecimal na halaga na matatagpuan sa rehistro at ang binary na representasyon ng rehistro (ipinapakita ang bawat piraso bilang isang 1 o 0). Upang magtakda ng isang partikular na piraso sa anumang rehistro, gamitin ang "index ng" operator . Halimbawa, sabihin nating nais ko ang ika-3 na bit sa isang 1

% GPIOR0 [3] = 1 at bibigyan ka ng shell ng isang tugon na nagpapahiwatig na aksyon ito at ang resulta

Ang GPIOR0 (0x0) ay nakatakda sa [00000000] (0x8) na nakatakda sa [00001000] Huwag kalimutan ang porsyentong pag-sign upang sabihin sa shell na nagtatrabaho ka sa isang rehistro. Tandaan din na sa pamamagitan ng pagtatakda ng ika-3 bit, iyon ang 4 na bit dahil gumagamit ang aming AVR ng isang zero-based na index. Sa madaling salita, ang pagbibilang sa ika-3 bit ay binibilang mo ang 0, 1, 2, 3, na kung saan ay ang ika-4 na lugar, ngunit ang ika-3 na bit. Maaari mong malinis nang kaunti sa parehong paraan sa pamamagitan ng pagtatakda ng kaunti hanggang sa zero. Sa pamamagitan ng pagtatakda ng mga kagaya nito maaari mong baguhin ang paggana ng iyong AVR nang mabilis. Halimbawa, sa pamamagitan ng pagbabago ng halaga ng pagtutugma ng timer ng CTC na matatagpuan sa OCR1A. Hinahayaan ka rin nitong silipin ang mga partikular na setting na kakailanganin mong i-programmatic na suriin ang iyong code, tulad ng halaga ng UBBR para sa iyong rate ng baud. Ang pagtatrabaho sa DDRn, PORTn, at PINn Ang I / O pin ay nakatalaga din sa mga rehistro at maaaring maitakda sa eksaktong parehong paraan, ngunit isang espesyal na syntax ang nilikha upang gumana sa mga ganitong uri ng rehistro. Sa code, mayroong isang normal na proseso para, halimbawa, pag-on ng isang LED o iba pang aparato na nangangailangan ng isang digital na mataas o mababa. Kinakailangan nito ang pagtatakda ng Rehistro ng Direksyon ng Data upang ipahiwatig ang pin ay para sa output, at pagkatapos ay pagsulat ng isang 1 o 0 sa partikular na bit sa tamang port. Ipagpalagay na mayroon kaming isang LED na konektado sa digital pin 13 (PB5) at nais naming i-on ito, narito kung paano gawin iyon habang tumatakbo ang iyong AVR

itakda ang pin pb5 outputwrite pin pb5 mataas Ang output, bukod sa nakikita mong dumating ang iyong LED, ganito ang hitsura

root @ ATmega328p> itakda ang pin pb5 outputSet pb5 para sa outputroot @ ATmega328p> isulat ang pin pb5 mataas I-print ang lohika na mataas sa pin pb5 Ang "root @ ATmega328p>" ay ang prompt ng shell na nagpapahiwatig na handa na itong tanggapin ang mga utos mula sa iyo. Upang i-off ang LED, magsusulat ka lamang ng isang mababa sa pin. Kung nais mong basahin ang digital input mula sa isang pin, gamitin ang read command. Gamit ang aming halimbawa sa itaas

root @ ATmega328p> basahin ang pin pb5Pin: ang pb5 ay TAAS Bilang kahalili, i-echo lamang ang rehistro ng pin na kumokontrol sa pin port. Halimbawa, kung mayroon kaming mga paglipat na konektado sa digital pin 7 at 8 (PD7 at PD8), maaari mong ipadala ang utos

echo% PIND at ipapakita ng shell ang mga nilalaman ng rehistro na iyon, ipinapakita sa iyo ang lahat ng mga estado ng pag-input / output ng mga konektadong aparato at kung ang estado ng switch ay naka-on o naka-off.

Hakbang 3: Mga Fuse sa Pagbasa at Pagsulat

Ang mga piyus ay mga espesyal na uri ng rehistro. Kinokontrol nila ang lahat mula sa bilis ng orasan ng iyong microcontroller hanggang sa kung anong mga pamamaraan sa pag-program ang magagamit upang maprotektahan ang EEPROM. Minsan kakailanganin mong baguhin ang mga setting na ito, lalo na kung lumilikha ka ng isang stand-alone na AVR system. Hindi ako sigurado na dapat mong baguhin ang iyong mga setting ng piyus sa Arduino. Mag-ingat sa iyong piyus; Maaari mong i-lock ang iyong sarili kung hindi mo itinakda ang mga ito nang hindi tama. Sa isang nakaraang itinuro, ipinakita ko kung paano mo maaaring basahin at maitakda ang iyong mga piyus gamit ang iyong programmer at avrdude. Dito, ipapakita ko sa iyo kung paano basahin muli ang iyong mga piyus sa run time upang makita kung paano talaga itinakda ng iyong MCU ang mga ito. Tandaan, na hindi ito ang setting ng compile-time na nakukuha mo mula sa mga kahulugan ngunit ang aktwal na mga piyus habang binabasa ng MCU ang mga ito sa run time. Mula sa Talahanayan 27-9 sa ATmega328P datasheet (databook, mas katulad nito) ang mga piraso ng Fuse Low Byte ay ang mga sumusunod:

CKDIV8 CKOUT SUT1 SUT0 CKSEL3 CKSEL2 CKSEL1 CKSEL0Ang isang kagiliw-giliw na bagay na dapat tandaan ay na sa mga piyus, ang ibig sabihin ng 0 ay naka-program at ang isang 1 ay nangangahulugan na ang partikular na piraso ay hindi naka-program. Medyo counter-intuitive, ngunit kapag alam mo ito alam mo ito.

• Itinatakda ng CKDIV8 ang iyong orasan ng CPU na mahahati sa 8. Ang ATmega328P ay nagmula sa pabrika na na-program upang magamit ang panloob na oscillator sa 8MHz na naka-program na CKDIV8 (ibig sabihin nakatakda sa 0) na magbibigay sa iyo ng pangwakas na F_CPU o CPU frequency ng 1MHz. Sa Arduino's, nabago ito dahil na-configure ang mga ito upang magamit ang isang panlabas na oscillator sa 16MHz.
• Ang CKOUT kapag na-program ay maglalabas ng iyong CPU orasan sa PB0, na kung saan ay digital pin 8 sa Arduinos.
• Tinutukoy ng SUT [1..0] ang oras ng pagsisimula para sa iyong AVR.
• Itinatakda ng CKSEL [3..0] ang mapagkukunan ng orasan, tulad ng panloob na oscillator ng RC, panlabas na oscillator, atbp.

Kapag nabasa mo ang iyong mga piyus, ibabalik ito sa iyo sa hexadecimal. Ito ang format na kailangan mo kung nais mong isulat ang mga piyus sa pamamagitan ng avrdude. Sa aking arduino, narito ang nakukuha ko nang mabasa ko ang mas mababang byte ng fuse:

root @ ATmega328p> basahin ang lfuseLower Fuse: 0xffKaya, ang lahat ng mga piraso ay nakatakda sa 1. Ginawa ko ang parehong pamamaraan sa isang clone ng Arduino at nakuha ang parehong halaga. Sinusuri ang isa sa aking mga stand-alone na AVR system, nakakuha ako ng 0xDA na ang halagang itinakda ko ng ilang oras pabalik sa pag-configure ng maliit na tilad. Ang parehong pamamaraan ay ginagamit para sa pag-check sa High Fuse Byte, Extended Fuse Byte, at Lock fuse. Ang pagkakalibrate at pirma ng fuse bytes ay hindi pinagana sa code na may isang tagubilin sa preprocessor na # kung 0, na maaari mong baguhin kung sa palagay mo ay masaya.

Hakbang 4: Iba Pang Mga Kautusan

Mayroong maraming iba pang mga utos na nauunawaan ng default na interpreter ng utos na maaari kang maging kapaki-pakinabang. Maaari mong makita ang lahat ng ipinatupad at hinaharap na paglabas ng mga utos sa pamamagitan ng pag-isyu ng tulong o menu sa kaagad. Mabilis kong sasakupin ang mga ito dito dahil sa karamihan ay nagpapaliwanag sa sarili. Mga setting ng Frequency ng Orasan ng CPU Maaari mong malaman kung ano ang na-configure na iyong firmware upang magamit bilang mga setting ng orasan ng CPU gamit ang fcpu command:

root @ ATmega328p> fcpuCPU Freq: 1600000016 milyon iyon, o 16 milyong herz, na mas kilala bilang 16 MHz. Maaari mong baguhin ito nang mabilis, para sa anumang kadahilanan, gamit ang utos ng orasan. Ang utos na ito ay tumatagal ng isang argumento: gagamitin ang prescaler kapag hinahati ang bilis ng iyong orasan. Nauunawaan ng utos ng orasan ang mga prescaler na halagang ito:

• ckdiv2
• ckdiv4
• ckdiv8
• ckdiv16
• ckdiv32
• ckdiv64
• ckdiv128
• ckdiv256

Gamit ang utos:

orasan ckdiv2 kapag ang bilis ng iyong CPU ay 16MHz ay magreresulta sa bilis ng iyong orasan na mabago sa 8MHz. Ang paggamit ng isang prescaler ng ckdiv64 na may paunang bilis ng orasan na 16MHz ay magreresulta sa isang pangwakas na bilis ng orasan na 250 KHz. Bakit sa Earth gusto mong gawing mas mabagal ang iyong MCU? Sa gayon, para sa isang, ang isang mas mababang bilis ng orasan ay kumakain ng mas kaunting lakas at kung mayroon kang iyong MCU na tumatakbo sa isang baterya sa isang enclosure ng proyekto maaaring hindi mo ito kailangan upang tumakbo sa pinakamataas na bilis, at maaaring samakatuwid, babaan ang bilis at bawasan ang pagkonsumo ng kuryente, pagdaragdag ng buhay ng baterya. Gayundin, kung gumagamit ka ng orasan para sa anumang uri ng mga isyu sa tiyempo sa isa pang MCU, sabihin, na nagpapatupad ng isang software UART o ilang mga bagay, baka gusto mong itakda ito sa isang partikular na halaga na madaling makakuha ng magandang kahit baud rate kasama ang mas mababang mga rate ng error. Powering Up at Powering Down Peripheral Sub-Systems Sa parehong tala tulad ng pagbawas ng pagkonsumo ng kuryente na nabanggit kanina, baka gusto mong bawasan pa ang lakas sa pamamagitan ng pag-shut down ng ilan sa mga on-board peripheral na hindi mo ginagamit. Ang tagasalin ng interpreter at shell ay kasalukuyang maaaring magpapagana at magpapagana ng mga sumusunod na peripheral:

• Analog-to-Digital Converter (ADC). Ginagamit ang peripheral na ito kapag mayroon kang isang analog sensor na nagbibigay ng data (tulad ng temperatura, ilaw, pagbilis, atbp) at kailangan itong i-convert sa isang digital na halaga.
• Serial Peripheral Interface (SPI). Ang SPI bus ay ginagamit upang makipag-usap sa ibang mga aparato na pinagana ng SPI, tulad ng panlabas na alaala, mga driver ng LED, panlabas na ADC, atbp. Ang mga bahagi ng SPI ay ginagamit para sa ISP na programa, o kahit papaano ang mga pin, kaya't mag-ingat sa pag-shut down nito kung ikaw ay nagprogram sa pamamagitan ng ISP.
• Dalawang Wire Interface. Ang ilang mga panlabas na aparato ay gumagamit ng I2C bus upang makipag-usap, bagaman ang mga ito ay mabilis na pinalitan ng mga aparatong pinapagana ng SPI dahil ang SPI ay may mas malaking throughput.
• USART. Ito ang iyong serial interface. Marahil ay hindi mo nais na patayin ito kung nakakonekta ka sa AVR sa pamamagitan ng serial connection! Gayunpaman, idinagdag ko ito dito bilang isang balangkas para sa pag-port sa mga aparato na mayroong maraming USART tulad ng ATmega162 o ATmega644P.
• lahat Ang argument na ito sa powerup o utos ng powerdown ay binubuksan ang lahat ng mga peripheral na nabanggit o pinapatay ang lahat ng ito sa isang utos. Muli, matalinong gamitin ang utos na ito.

root @ ATmega328p> powerdown twiPowerdown ng twi complete.root@ATmega328p> powerup twiPowerup ng twi complete.

Pagsisimula at Paghinto ng Mga Timer Ang shell ay may built-in na 16-bit timer na magagamit para magamit. Sinimulan mo ang timer sa utos ng timer:

simulan ang timerat itigil ang timer gamit ang stop argument

ihinto ang timerAng timer na ito ay hindi makakasalungat sa panloob na timer ng USART. Tingnan ang code para sa mga detalye ng pagpapatupad ng USART timer, kung ang uri ng detalyeng detalye na iyon ay interesado sa iyo

root @ ATmega328p> timer startStarted timer.root@ATmega328p> timer stopElapsed time: ~ 157 segundo Pagpapatotoo Ang shell ay maaaring mag-imbak ng isang 8-character na password sa EEPROM. Ang mekanismo ng password na ito ay nilikha upang suportahan ang mga kakayahan sa pag-login sa telnet, ngunit maaaring mapalawak upang maprotektahan ang iba pang mga bagay. Halimbawa, maaari kang mangailangan ng ilang mga utos, tulad ng pagbabago ng mga halaga ng rehistro, sa pamamagitan ng mekanismo ng pagpapatotoo. Itakda ang password gamit ang utos ng password

root @ ATmega328p> passwd blahWrote ang root password sa EEPROMPahintulutan laban sa password niya (o nangangailangan ng sistematikong pahintulot sa pamamagitan ng code) kasama ang utos ng auth. Tandaan, na kung susubukan mong baguhin ang root password at mayroon nang isang itinakdang root password, dapat mong pahintulutan ang iyong sarili laban sa lumang password bago payagan itong baguhin sa isang bagong password

root @ ATmega328p> passwd blinky Dapat mo munang pahintulutan ang iyong sarili.root@ATmega328p> auth blahAuthorised.root@ATmega328p> passwd blinkyWrote BAGONG root password sa EEPROMSiyempre, kakailanganin mong i-load ang avrsh.eep file kung burahin mo ang firmware upang maibalik ang iyong dating mga halaga at variable. Lilikha ng Makefile ang EEPROM file para sa iyo. Mga variable na nauunawaan ng shell ang paniwala ng mga variable na tinukoy ng gumagamit. Nililimitahan ito ng code sa 20, ngunit maaari mo itong baguhin kung nais mo sa pamamagitan ng pagbabago ng tinukoy na MAX_VARIABLES sa script.h. Maaari mong i-save ang anumang 16-bit na halaga (iyon ay, anumang numero hanggang sa 65, 536) sa isang variable na maaalaala sa paglaon. Ang syntax ay katulad ng mga pagrehistro maliban sa isang dolyar na tanda ($) ay ginagamit upang magpahiwatig ng mga variable sa shell. Ilista ang lahat ng iyong mga variable gamit ang print variable variable

mga variable na naka-printMga variable na tinukoy ng gumagamit: Pangalan ng Index -> Halaga (01): $ FREE $ -> 0 (02): $ FREE $ -> 0 (03): $ FREE $ -> 0 (04): $ FREE $ -> 0 (05): $ FREE $ -> 0 (06): $ FREE $ -> 0 (07): $ FREE $ -> 0 (08): $ FREE $ -> 0 (09): $ FREE $ -> 0 (10): $ FREE $ -> 0 (11): $ FREE $ -> 0 (12): $ FREE $ -> 0 (13): $ FREE $ -> 0 (14): $ FREE $ -> 0 (15): $ FREE $ -> 0 (16): $ FREE $ -> 0 (17): $ FREE $ -> 0 (18): $ FREE $ -> 0 (19): $ FREE $ -> 0 (20): $ FREE $ -> 0 Kumpleto. Magtakda ng variable

$ newvar = 25 $ timeout = 23245Kunin ang halaga ng isang naibigay na variable

root @ ATmega328p> echo $ newvar $ newvar 25Maaari mong makita kung ano ang lahat ng mga variable na kasalukuyan mong itinatag sa print print na alam mo na

Mga variable na tinukoy ng gumagamit: Pangalan ng Index -> Halaga (01): newvar -> 25 (02): timeout -> 23245 (03): $ FREE $ -> 0 (04): $ FREE $ -> 0 (05): $ FREE $ -> 0 (06): $ FREE $ -> 0 (07): $ FREE $ -> 0 (08): $ FREE $ -> 0 (09): $ FREE $ -> 0 (10): $ FREE $ -> 0 (11): $ FREE $ -> 0 (12): $ FREE $ -> 0 (13): $ FREE $ -> 0 (14): $ FREE $ -> 0 (15): $ FREE $ -> 0 (16): $ FREE $ -> 0 (17): $ FREE $ -> 0 (18): $ FREE $ -> 0 (19): $ FREE $ -> 0 (20): $ FREE $ -> 0 Kumpleto. Ipinapahiwatig lamang ng $ FREE $ na pangalan na ang variable na lokasyon ay libre at hindi pa naitalaga ng isang variable na pangalan.

Hakbang 5: Pagpapasadya ng Shell

Malaya kang mag-hack sa code at ipasadya ito sa iyong sariling mga pangangailangan, kung nais mo. Kung nalaman kong ilalabas ko ang code na ito, gumawa ako ng isang hiwalay na klase ng interpreter ng utos at istraktura ng utos at paulit-ulit sa pamamagitan ng pagtawag na ito ng isang pointer ng pag-andar. Bawasan nito ang dami ng code, ngunit sa pamamagitan nito ay itinatakda ng shell ang linya ng utos at tinawag ang naaangkop na pamamaraan ng shell. Upang idagdag sa iyong sariling pasadyang mga utos, gawin ang sumusunod: 1. Idagdag ang iyong utos sa listahan ng parse Ang parse ng utos ay i-parse ang linya ng utos at bigyan ka ng utos at anumang mga pagtatalo nang magkahiwalay. Ang mga argumento ay ipinapasa bilang mga payo sa mga payo, o isang hanay ng mga payo, subalit nais mong gumana sa kanila. Ito ay matatagpuan sa shell.cpp. Buksan ang shell.cpp at hanapin ang ExecCmd na pamamaraan ng klase ng AVRShell. Maaari mong idagdag ang utos sa memorya ng programa. Kung gagawin mo ito, idagdag ang utos sa progmem.h at progmem.cpp. Maaari mong idagdag ang utos sa memorya ng programa nang direkta gamit ang PSTR () macro, ngunit makakabuo ka ng isa pang babala ng uri na nabanggit kanina. Muli, ito ay isang kilalang bug na nagtatrabaho sa C ++, ngunit maaari mo itong mapalibot sa pamamagitan ng pagdaragdag ng utos nang direkta sa progmem. * Mga file, tulad ng nagawa ko. Kung hindi mo alintana ang pagdaragdag sa iyong paggamit ng SRAM, maaari mong idagdag ang utos tulad ng nailarawan ko sa utos na "orasan". Sabihin na nais mong magdagdag ng isang bagong utos na tinatawag na "newcmd." Pumunta sa AVRShell:: ExecCmd at maghanap ng isang maginhawang lugar upang maipasok ang sumusunod na code:

iba pa kung (! strcmp (c, "newcmd")) cmdNewCmd (args);Ito ay idaragdag ang iyong utos at tawagan ang pamamaraan ng cmdNewCmd na isusulat mo sa susunod na hakbang. 2. Isulat ang iyong pasadyang code ng utos Sa parehong file, idagdag ang iyong pasadyang code ng utos. Ito ang kahulugan ng pamamaraan. Gusto mo pa ring idagdag ang deklarasyon sa shell.h. Ikabit lamang ito sa iba pang mga utos. Sa nakaraang halimbawa, ang code ay maaaring magmukhang ganito

voidAVRShell:: cmdNewCmd (char ** args) {sprintf_P (buff, PSTR ("Ang iyong utos ay% s / r / n", args [0]); WritingRAM (buff);}Maraming bagay dito. Una, ang "buff" ay isang 40-character array buffer na ibinigay sa code para sa iyong paggamit. Ginagamit namin ang bersyon ng memorya ng programa ng sprintf dahil ipinapasa namin ito sa isang PSTR. Maaari mong gamitin ang regular na bersyon kung nais mo, ngunit tiyaking hindi mo naipapasa ang format sa isang PSTR. Gayundin, ang mga argumento ay nasa array ng args. Kung nag-type ka ng "newcmd arg1 arg2" maaari kang makakuha sa mga argumentong ito gamit ang mga args [0] at args [1] na mga subscripts. Maaari kang pumasa sa isang maximum na MAX_ARGS argument, tulad ng tinukoy sa code. Huwag mag-atubiling baguhin ang halagang iyon kapag muling pinagsama-sama kung kailangan mo ng higit pang mga argumento upang maipasa nang sabay-sabay. Ang WritingLine at WritingRAM ay mga pandaigdigang pagpapaandar na nagbabalik ng mga pamamaraan ng UART ng parehong pangalan. Ang ika-2 argument sa pagpapaandar na ito ay implicit. Kung wala kang naipasa, isang prompt ng utos ay isusulat pagkatapos. Kung magpapasa ka ng 0 bilang ika-2 na argumento, hindi sususulat ang isang prompt. Kapaki-pakinabang ito kapag nais mong magsulat ng maraming magkakahiwalay na mga string upang ma-output bago ibalik ang user sa prompt. 3. Ipatupad ng shell ang command code Nasabi mo na sa executor ng shell na ipatupad ang pamamaraan cmdNewCmd kapag na-set up mo ang bagong utos, ngunit idagdag ito sa shell.h file upang maunawaan ito ng object ng shell. Idagdag lamang ito sa ibaba ng huling utos o sa harap ng unang utos, o saanman doon. At iyon lang. I-recompile at i-upload ang firmware sa iyong Arduino at ang iyong bagong utos ay magagamit mula sa shell sa prompt.

Hakbang 6: Buod

Dapat mong malaman kung paano mag-install at kumonekta sa iyong AVR / Arduino at makakuha ng isang live na prompt sa iyong tumatakbo na microcontroller. Alam mo ang maraming mga utos na kukuha ng data ng runtime mula sa MCU o magtakda ng mga halaga sa MCU on the fly. Ipinakita rin sa iyo kung paano magdagdag ng iyong sariling pasadyang code upang lumikha ng iyong sariling natatanging mga utos sa shell upang higit na ipasadya ito para sa iyong sariling mga pangangailangan. Maaari mo ring mai-gat ang interpreter ng utos na magkaroon lamang ito ng iyong pasadyang mga utos, kung nababagay sa iyong mga pangangailangan. Inaasahan kong nasiyahan ka sa itinuturo na ito at ang AVR Shell ay maaaring maging kapaki-pakinabang para sa iyo, alinman bilang isang interpreter ng real-time na utos o bilang isang proseso ng pag-aaral sa pagpapatupad ng iyong sarili. Tulad ng nakasanayan, Inaasahan ko ang anumang mga komento o mungkahi sa kung paano ito maaaring mapabuti! Makatutuwa sa iyong AVR!