AVRSH: un Shell de interpret interpret pentru Arduino / AVR .: 6 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:47

Ați dorit vreodată să fiți „conectat” la microcontrolerul dvs. AVR? Te-ai gândit vreodată că ar fi grozav să „pisici” un registru pentru a-i vedea conținutul? Ați dorit întotdeauna o modalitate de a porni și opri subsistemele periferice individuale ale AVR sau Arduino în * timp real *? Și eu, așa că am scris AVR Shell, un shell asemănător UNIX. Este asemănător UNIX, deoarece amintește de contul shell pe care l-ați ieșit și pe care l-ați cumpărat pentru a rula robotii de coliziune irc nick, precum și pentru a avea o comandă sau două în comun. De asemenea, are un sistem de fișiere care seamănă cu extix-urile UNIX, folosind o EEPROM externă, dar care a devenit un proiect în sine, așa că voi lansa modulul separat sub un alt instructable când este pregătit pentru producție. Iată o listă a lucrurilor pe care le puteți face în prezent cu AVR Shell:

• Citiți toate registrele de direcție a datelor (DDRn), porturile și pinii în timp real
• Scrieți toate DDR-urile, porturile și pinii pentru a porni motoarele, LED-urile sau citiți senzorii în timp real
• Enumerați toate registrele cunoscute din sistem
• Creați și stocați valori în variabile definite de utilizator, copiate de siguranță de EEPROM.
• Creați o parolă root și autentificați-vă împotriva acesteia (utilizată pentru acces telnet)
• Citiți viteza de ceas configurată a procesorului
• Schimbați viteza de ceas a procesorului prin setarea unui prescaler
• Porniți și opriți temporizatoarele pe 16 biți pentru sincronizarea diferitelor lucruri
• Porniți și / sau opriți subsistemele periferice: convertoare analog-digitale (ADC), interfață periferică serială (SPI), interfață cu două fire (TWI / I2C), UART / USART. Util pentru când doriți să reduceți consumul de energie al microcontrolerului sau să activați anumite funcții.
• Scris în C ++ cu obiecte reutilizabile.

Acest instructable va parcurge instalarea, utilizarea și personalizarea avrsh.

Pasul 1: De ce veți avea nevoie

Acest instructiv nu necesită prea multe, cu excepția faptului că dvs.:

• Aveți un Arduino sau ATmega328P. Alte AVR-uri ar putea funcționa, dar este posibil să fie necesar să modificați codul pentru a lista orice registre care sunt unice pentru MCU-ul dvs. Numele trebuie să se potrivească doar cu ceea ce este listat în fișierul de antet unic pentru MCU. Multe dintre numele registrelor sunt aceleași între AVR-uri, astfel încât kilometrajul dvs. poate varia la portare.
• Aveți o modalitate de a vă conecta la serialul USART al Arduino / AVR. Sistemul a fost testat cel mai mult cu terminalul AVR, o aplicație Windows care realizează o conexiune serială prin portul USB sau COM. Funcționează cu Arduinos utilizând conexiunea USB și orice AVR care utilizează USB-BUB de la Moderndevice.com. Alte opțiuni de terminal includ: Putty, minicom (Linux și FreeBSD), ecran (Linux / FreeBSD), Hyperterminal, Teraterm. Am găsit chit și teraterm trimit niște gunoi la conectare, astfel încât prima dvs. comandă să fie distrusă.
• Aveți instalat și rulat firmware-ul AVR Shell, pe care îl puteți descărca de pe aceste pagini sau obțineți întotdeauna cea mai recentă versiune de pe BattleDroids.net.

Pentru a instala terminalul AVR, pur și simplu despachetați-l și rulați-l. Pentru a instala firmware-ul AVR Shell, descărcați-l și încărcați direct fișierul hex și conectați terminalul serial la 9600 baud, sau compilați-l singur cu „make” și apoi „make program” pentru a încărca hex. Notă, poate fi necesar să modificați setările AVRDUDE pentru a reflecta portul COM. Notă: Atributul PROGMEM este rupt în implementarea curentă AVR GCC pentru C ++ și aceasta este o eroare cunoscută. Dacă îl compilați, așteptați să primiți multe mesaje de avertizare care să spună „avertisment: numai variabilele inițializate pot fi plasate în zona de memorie a programului”. Pe lângă faptul că este enervant de văzut, acest avertisment este inofensiv. Deoarece C ++ pe platforma încorporată nu se află pe lista priorităților AVR GCC, nu se știe când va fi remediat acest lucru. Dacă verificați codul, veți vedea unde am făcut eforturi pentru a reduce acest avertisment prin implementarea propriilor declarații de atribut. Destul de simplu. Descărcați și instalați orice ar putea fi necesar pentru a răsturna pagina și haideți să facem crack.

Pasul 2: Citirea și scrierea registrelor

AVR Shell a fost scris în primul rând pentru a accesa niște senzori pe care i-am conectat la AVR-ul meu. A început cu un LED simplu, apoi a trecut la senzorii de lumină, senzorii de temperatură și, în cele din urmă, la doi traductori cu ultrasunete. avrsh poate seta componentele digitale ale acestor senzori scriind în registrele care le controlează. Manipularea registrelor AVR în timpul rulării Pentru a obține o listă a tuturor registrelor cunoscute pe Arduino, tastați:

tipăriți registre și veți obține o imprimare care arată astfel

Știu despre următoarele registre:

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 RPR 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 RSSA TWBR TWSR TWAR TWDR TWCR TWAMR UCSR0A UCSR0B UCSR0C UBRR0L UBRR0H UDR0 PORTB root @ ATmega328p> Pentru a vedea cum sunt setați biții individuali în orice registru, utilizați comanda cat sau echo

cat% GPIOR0 Aici îi cer interpretului de comandă să afișeze sau să facă ecou conținutului Registrului I / O cu scop general # 0. Rețineți semnul procentual (%) în fața numelui registrului. Aveți nevoie de acest lucru pentru a indica shell-ului că acesta este un cuvânt cheie rezervat care identifică un registru. Ieșirea tipică dintr-o comandă ecou arată astfel

GPIOR0 (0x0) setat la [00000000] Ieșirea arată numele registrului, valoarea hexazecimală găsită în registru și reprezentarea binară a registrului (afișând fiecare bit ca 1 sau 0). Pentru a seta un anumit bit în orice registru, utilizați "indexul" operatorului . De exemplu, să presupunem că vreau al treilea bit la 1

% GPIOR0 [3] = 1 iar shell-ul vă va oferi un răspuns indicând acțiunea și rezultatul

GPIOR0 (0x0) setat la [00000000] (0x8) setat la [00001000] Nu uitați semnul procentului pentru a spune shell-ului că lucrați cu un registru. De asemenea, rețineți că, prin setarea celui de-al treilea bit, este vorba de 4 biți, deoarece AVR-urile noastre utilizează un index bazat pe zero. Cu alte cuvinte, numărând până la al 3-lea bit numărați 0, 1, 2, 3, care este locul 4, dar al treilea bit. Puteți șterge un pic în același mod setând un pic la zero. Setând astfel de biți puteți schimba funcționarea AVR-ului dvs. din mers. De exemplu, schimbând valoarea de potrivire a temporizatorului CTC găsită în OCR1A. De asemenea, vă permite să aruncați o privire în anumite setări pe care ar trebui să le verificați programat în codul dvs., cum ar fi valoarea UBBR pentru rata de baud. Lucrul cu DDRn, PORTn și PINn Pinurile I / O sunt, de asemenea, atribuite registrelor și pot fi setate exact în același mod, dar a fost creată o sintaxă specială pentru a lucra cu aceste tipuri de registre. În cod, există un proces normal pentru, să zicem, pornirea unui LED sau a unui alt dispozitiv care necesită un nivel ridicat sau scăzut digital. Este necesar să setați Registrul de direcție a datelor pentru a indica pinul este pentru ieșire și apoi scrieți 1 sau 0 pe bitul specific în portul corect. Presupunând că avem un LED conectat la pinul digital 13 (PB5) și dorim să-l aprindem, iată cum să faceți acest lucru în timp ce AVR-ul dvs. rulează

setează pinul pb5 outputwrite pin pb5 high Ieșirea, pe lângă faptul că vă poate vedea LED-ul aprins, ar arăta așa

root @ ATmega328p> set pin pb5 output Set pb5 for outputroot @ ATmega328p> write pin pb5 high Scriere logică high to pin pb5 „Root @ ATmega328p>” este promptul shell-ului care indică faptul că este gata să accepte comenzi de la dvs. Pentru a opri LED-ul, ați scrie pur și simplu un minim pe pin. Dacă doriți să citiți intrarea digitală dintr-un pin, utilizați comanda read. Folosind exemplul nostru de mai sus

root @ ATmega328p> citiți pinul pb5 Pin: pb5 este HIGH Alternativ, trebuie doar să răsunați registrul pin care controlează acel port pin. De exemplu, dacă avem switch-uri dip conectate la pinul digital 7 și 8 (PD7 și PD8), puteți trimite comanda

ecou% PIND iar shell-ul ar afișa apoi conținutul acelui registru, arătându-vă toate stările de intrare / ieșire ale dispozitivelor conectate și dacă starea comutatorului a fost activată sau dezactivată.

Pasul 3: Citirea și scrierea siguranțelor

Siguranțele sunt tipuri speciale de registre. Acestea controlează totul, de la viteza de ceas a microcontrolerului dvs. la ce metode de programare sunt disponibile pentru protejarea la scriere a EEPROM. Uneori va trebui să modificați aceste setări, mai ales dacă creați un sistem AVR autonom. Nu sunt sigur că ar trebui să modificați setările siguranței pe Arduino. Fii atent la siguranțele tale; vă puteți bloca dacă le setați incorect. Într-o instruire anterioară, am demonstrat cum puteți citi și seta siguranțele folosind programatorul și avrdude. Aici, vă voi arăta cum să citiți siguranțele în timp de rulare pentru a vedea cum le-a setat MCU-ul. Rețineți că aceasta nu este setarea de timp de compilare pe care o obțineți din definiții, ci siguranțele reale pe măsură ce MCU le citește în timpul rulării. Din Tabelul 27-9 din foaia de date ATmega328P (databook, mai mult ca acesta), biții Fuse Low Byte sunt după cum urmează:

CKDIV8 CKOUT SUT1 SUT0 CKSEL3 CKSEL2 CKSEL1 CKSEL0Un lucru interesant de remarcat este că, cu siguranțe, 0 înseamnă programat și un 1 înseamnă că acel bit special este neprogramat. Oarecum contra-intuitiv, dar odată ce îl știi, îl știi.

• CKDIV8 setează ceasul CPU să fie împărțit la 8. ATmega328P provine din fabrică programat pentru a utiliza oscilatorul său intern la 8MHz cu CKDIV8 programat (adică setat la 0), oferindu-vă o F_CPU finală sau frecvența CPU de 1MHz. Pe Arduino, acest lucru este modificat, deoarece acestea sunt configurate pentru a utiliza un oscilator extern la 16 MHz.
• CKOUT atunci când este programat va afișa ceasul CPU pe PB0, care este pinul digital 8 pe Arduinos.
• SUT [1..0] specifică timpul de pornire pentru AVR.
• CKSEL [3..0] setează sursa ceasului, cum ar fi oscilatorul RC intern, oscilatorul extern etc.

Când vă citiți siguranțele, acestea vă vor fi returnate în format hexazecimal. Acesta este formatul de care aveți nevoie dacă doriți să scrieți siguranțele prin avrdude. Pe arduino, iată ce primesc când citesc octetul de siguranță inferior:

root @ ATmega328p> citiți lfuse Siguranță inferioară: 0xffDeci, toți biții sunt setați la 1. Am făcut aceeași procedură pe o clonă Arduino și am obținut aceeași valoare. Verificând unul dintre sistemele mele AVR de sine stătătoare, am obținut 0xDA, care este valoarea pe care o stabilisem cu ceva timp în urmă la configurarea cipului. Aceeași procedură este utilizată pentru verificarea siguranțelor High Fuse Byte, Extended Fuse Byte și Lock. Octrații de calibrare și de siguranță de siguranță au fost dezactivați în cod cu o directivă de preprocesare #if 0, pe care o puteți schimba dacă vă simțiți dezastruos.

Pasul 4: Alte comenzi

Există mai multe alte comenzi pe care interpretul implicit de comenzi le înțelege pe care le-ați putea găsi utile. Puteți vedea toate comenzile implementate și de lansare viitoare prin emiterea de ajutor sau meniu la prompt. Le voi acoperi rapid aici, deoarece acestea sunt în mare parte auto-explicative. Setări de frecvență a ceasului CPU Puteți afla ce firmware a fost configurat pentru a utiliza ca setări de ceas CPU cu comanda fcpu:

root @ ATmega328p> fcpuCPU Freq: 16000000Este vorba de 16 milioane sau 16 milioane de herz, mai cunoscut sub numele de 16 MHz. Puteți schimba acest lucru din mers, indiferent de motiv, cu comanda ceasului. Această comandă preia un argument: prescalerul de utilizat atunci când vă împărțiți viteza ceasului. Comanda de ceas înțelege aceste valori de prescalare:

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

Folosind comanda:

ceas ckdiv2 atunci când viteza procesorului dvs. este de 16 MHz ar duce la schimbarea vitezei ceasului la 8 MHz. Folosirea unui prescaler de ckdiv64 cu o viteză de ceas inițială de 16 MHz va avea ca rezultat o viteză de ceas finală de 250 KHz. De ce pe Pământ ai vrea să-ți faci MCU-ul mai lent? Ei bine, pentru unul, o viteză de ceas mai mică consumă mai puțină energie și, dacă aveți unitatea MCU care funcționează cu o baterie într-o carcasă a proiectului, este posibil să nu aveți nevoie de aceasta pentru a rula la viteza maximă și, prin urmare, puteți reduce viteza și reduceți consumul de energie., mărind durata de viață a bateriei. De asemenea, dacă utilizați ceasul pentru orice fel de probleme de sincronizare cu un alt MCU, să zicem, implementând un software UART sau ceva similar, poate doriți să-l setați la o anumită valoare, care este ușor să obțineți o rată de baud uniformă cu rate de eroare mai mici. Pornirea și oprirea subsistemelor periferice În aceeași notă ca și reducerea consumului de energie menționat anterior, poate doriți să reduceți și mai mult puterea prin oprirea unora dintre perifericele de la bord pe care nu le utilizați. Interpretul de comandă și shell-ul pot porni și opri în prezent următoarele periferice:

• Convertor analog-digital (ADC). Acest periferic este utilizat atunci când aveți un senzor analogic care furnizează date (cum ar fi temperatura, lumina, accelerația etc.) și trebuie să îl convertiți într-o valoare digitală.
• Interfață periferică serial (SPI). Busul SPI este utilizat pentru a comunica cu alte dispozitive compatibile cu SPI, cum ar fi memoriile externe, driverele cu LED-uri, ADC-urile externe, etc. dacă programați prin ISP.
• Interfață cu două fire. Unele dispozitive externe folosesc magistrala I2C pentru a comunica, deși acestea sunt rapid înlocuite de dispozitive cu SPI, deoarece SPI are un randament mai mare.
• USART. Aceasta este interfața dvs. serial. Probabil că nu doriți să opriți acest lucru dacă sunteți conectat la AVR prin conexiunea serială! Cu toate acestea, am adăugat acest lucru aici ca un schelet pentru portarea pe dispozitive care au mai multe USART, cum ar fi ATmega162 sau ATmega644P.
• toate. Acest argument al comenzii de pornire sau oprire pornește toate perifericele menționate sau le oprește pe toate cu o singură comandă. Din nou, utilizați această comandă cu înțelepciune.

root @ ATmega328p> powerdown twi Powerdown of twi complete.root@ATmega328p> powerup twi Powerup of twi complete.

Pornirea și oprirea cronometrelor Shell-ul are un temporizator de 16 biți încorporat, care este disponibil pentru utilizare. Porniți temporizatorul cu comanda temporizatorului:

pornirea temporizatoruluiși opriți cronometrul cu argumentul stop

oprire cronometruAcest temporizator nu va intra în conflict cu temporizatorul intern USART. Consultați codul pentru detaliile de implementare ale temporizatorului USART, dacă acest tip de detaliu sângeros vă interesează

root @ ATmega328p> timer start Timer pornit.root@ATmega328p> timer stop Timp scurs: ~ 157 secunde Autentificare Shell-ul poate stoca o parolă de 8 caractere în EEPROM. Acest mecanism de parolă a fost creat pentru a susține capacitățile de conectare telnet, dar ar putea fi extins pentru a proteja alte lucruri. De exemplu, puteți solicita anumite comenzi, cum ar fi schimbarea valorilor registrului, prin mecanismul de autentificare. Setați parola cu comanda parolă

root @ ATmega328p> passwd blah Scrieți parola root în EEPROMAutorizați împotriva parolei (sau solicitați autorizarea programată prin cod) cu comanda auth. Rețineți că, dacă încercați să modificați parola root și există deja o parolă root setată, trebuie să vă autorizați împotriva parolei vechi înainte de a vi se permite să o schimbați într-o nouă parolă

root @ ATmega328p> passwd blinky Trebuie să vă autorizați mai întâi.root@ATmega328p> auth blahAuthorized.root@ATmega328p> passwd blinky Scrieți o parolă nouă de root la EEPROMDesigur, va trebui să încărcați fișierul avrsh.eep dacă ștergeți firmware-ul pentru a vă restabili valorile și variabilele vechi. Makefile va crea fișierul EEPROM pentru dvs. Variabile Shell-ul înțelege noțiunea de variabile definite de utilizator. Codul limitează acest lucru la 20, dar puteți schimba acest lucru, dacă doriți, schimbând MAX_VARIABLES în script.h. Puteți salva orice valoare pe 16 biți (adică orice număr până la 65, 536) într-o variabilă care va fi reamintită ulterior. Sintaxa este similară cu registrele, cu excepția faptului că un semn de dolar ($) este utilizat pentru a indica variabile la shell. Enumerați toate variabilele dvs. cu comanda print variables

variabile tipărite Variabile definite de utilizator: Numele indexului -> Valoare (01): $ GRATUIT $ -> 0 (02): $ GRATUIT $ -> 0 (03): $ GRATUIT $ -> 0 (04): $ GRATUIT $ -> 0 (05): $ GRATUIT $ -> 0 (06): $ GRATUIT $ -> 0 (07): $ GRATUIT $ -> 0 (08): $ GRATUIT $ -> 0 (09): $ GRATUIT $ -> 0 (10): $ GRATUIT $ -> 0 (11): $ GRATUIT $ -> 0 (12): $ GRATUIT $ -> 0 (13): $ GRATUIT $ -> 0 (14): $ GRATUIT $ -> 0 (15): $ GRATUIT $ -> 0 (16): $ GRATUIT $ -> 0 (17): $ GRATUIT $ -> 0 (18): $ GRATUIT $ -> 0 (19): $ GRATUIT $ -> 0 (20): $ GRATUIT $ -> 0 Complet. Setați o variabilă

$ newvar = 25 $ timeout = 23245Obțineți valoarea unei variabile date

root @ ATmega328p> echo $ newvar $ newvar 25Puteți vedea ce variabile ați instanțiat în prezent cu comanda de imprimare pe care le cunoașteți deja

Variabile definite de utilizator: Nume index -> Valoare (01): newvar -> 25 (02): timeout -> 23245 (03): $ GRATUIT $ -> 0 (04): $ GRATUIT $ -> 0 (05): $ GRATUIT $ -> 0 (06): $ GRATUIT $ -> 0 (07): $ GRATUIT $ -> 0 (08): $ GRATUIT $ -> 0 (09): $ GRATUIT $ -> 0 (10): $ GRATUIT $ -> 0 (11): $ GRATUIT $ - - 0 (12): $ GRATUIT $ -> 0 (13): $ GRATUIT $ -> 0 (14): $ GRATUIT $ -> 0 (15): $ GRATUIT $ -> 0 (16): $ GRATUIT $ - - 0 (17): $ GRATUIT $ -> 0 (18): $ GRATUIT $ -> 0 (19): $ GRATUIT $ -> 0 (20): $ GRATUIT $ -> 0Completați. Numele $ FREE $ indică doar faptul că locația variabilă este gratuită și că nu i s-a atribuit încă un nume variabil.

Pasul 5: Personalizarea Shell-ului

Sunteți liber să hackuiți codul și să îl personalizați în funcție de nevoile dvs., dacă doriți. Dacă aș fi știut că voi elibera acest cod, aș fi făcut o clasă separată de interpretor de comandă și o structură de comandă și aș fi iterat pur și simplu prin apelarea unui pointer de funcție. Ar reduce cantitatea de cod, dar așa cum stă, shell-ul analizează linia de comandă și apelează metoda shell corespunzătoare. Pentru a adăuga propriile comenzi personalizate, procedați în felul următor: analizați linia de comandă și vă oferă comanda și orice argumente separat. Argumentele sunt transmise ca indicatori către indicatori sau o serie de indicatori, oricum doriți să lucrați cu ei. Aceasta se găsește în shell.cpp. Deschideți shell.cpp și găsiți metoda ExecCmd din clasa AVRShell. Poate doriți să adăugați comanda în memoria programului. Dacă da, adăugați comanda în progmem.h și progmem.cpp. Puteți adăuga comanda în memoria programului direct utilizând macrocomanda PSTR (), dar veți genera un alt avertisment de tipul menționat anterior. Din nou, acesta este un bug cunoscut care funcționează cu C ++, dar puteți evita acest lucru adăugând comanda direct în fișierele progmem. *, Așa cum am făcut. Dacă nu vă deranjează să adăugați la utilizarea SRAM, puteți adăuga comanda așa cum am ilustrat cu comanda „ceas”. Spuneți că doriți să adăugați o nouă comandă numită „newcmd”. Accesați AVRShell:: ExecCmd și găsiți un loc convenabil pentru a insera următorul cod:

else if (! strcmp (c, "newcmd")) cmdNewCmd (args);Aceasta vă va adăuga comanda și va apela metoda cmdNewCmd pe care o veți scrie în pasul următor. 2. Scrieți codul de comandă personalizat În același fișier, adăugați codul de comandă personalizat. Aceasta este definiția metodei. Veți dori în continuare să adăugați declarația la shell.h. Doar adăugați-l la celelalte comenzi. În exemplul anterior, codul ar putea arăta cam așa

voidAVRShell:: cmdNewCmd (char ** args) {sprintf_P (buff, PSTR ("Comanda ta este% s / r / n", args [0]); WriteRAM (buff);}Există mai multe lucruri aici. În primul rând, „buff” este un buffer matricial de 40 de caractere furnizat în cod pentru utilizarea dvs. Folosim versiunea de memorie a programului de sprintf, deoarece îi trecem un PSTR. Puteți utiliza versiunea obișnuită dacă doriți, dar asigurați-vă că nu treceți formatul într-un PSTR. De asemenea, argumentele se află în matricea args. Dacă ați introdus „newcmd arg1 arg2” puteți obține aceste argumente cu indicele args [0] și args [1]. Puteți trece maximum MAX_ARGS argumente, așa cum sunt definite în cod. Simțiți-vă liber să schimbați această valoare atunci când recompilați dacă aveți nevoie de mai multe argumente care să fie transmise simultan. WriteLine și WriteRAM sunt funcții globale care returnează metodele UART cu același nume. Al doilea argument al acestei funcții este implicit. Dacă nu treceți nimic, un prompt de comandă va fi scris ulterior. Dacă treceți un 0 ca al doilea argument, nu va fi scris un prompt. Acest lucru este util atunci când doriți să scrieți mai multe șiruri separate pentru a ieși înainte ca promptul de comandă să fie returnat utilizatorului. 3. Solicitați shell-ului să execute codul de comandă Ați spus deja executorului shell-ului să execute metoda cmdNewCmd când configurați comanda nouă, dar adăugați-o în fișierul shell.h pentru a fi înțeleasă de obiectul shell. Doar adăugați-l sub ultima comandă sau în fața primei comenzi sau oriunde acolo. Și atât. Recompilați și încărcați firmware-ul pe Arduino, iar noua comandă este disponibilă din shell la prompt.

Pasul 6: Rezumat

Ar trebui să știți cum să instalați și să vă conectați la AVR / Arduino și să primiți un prompt live pe microcontrolerul care rulează. Știți mai multe comenzi care vor extrage datele de rulare din MCU sau vor seta valori în MCU din mers. De asemenea, vi s-a arătat cum să adăugați propriul cod personalizat pentru a crea propriile comenzi unice în shell pentru a-l personaliza în continuare pentru propriile dvs. nevoi. Puteți chiar să eliminați interpretul de comandă pentru a-l conține numai comenzile personalizate, dacă acest lucru se potrivește nevoilor dvs. Sper că v-a plăcut acest lucru instructiv și că AVR Shell vă poate fi util, fie ca interpret de comandă în timp real, fie ca un proces de învățare în implementarea propriului dvs. Ca întotdeauna, aștept cu nerăbdare orice comentarii sau sugestii cu privire la modul în care acest instructabil poate fi îmbunătățit! Distrați-vă cu AVR-ul dvs.!