AVRSH: een Command Interpreter Shell voor Arduino/AVR: 6 stappen (met afbeeldingen)

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:20

Altijd al "ingelogd" willen zijn op uw AVR-microcontroller? Ooit gedacht dat het cool zou zijn om een register te "katten" om de inhoud ervan te zien? Heb je altijd al een manier willen hebben om individuele perifere subsystemen van je AVR of Arduino in *realtime* in en uit te schakelen? Ik ook, dus schreef ik de AVR Shell, een UNIX-achtige shell. Het is UNIX-achtig omdat het doet denken aan het shell-account dat je uitging en kocht om je irc nick-botsbots op te laten draaien, en het doet ook een paar commando's gemeen hebben. Het heeft ook een bestandssysteem dat lijkt op UNIX extfs, met behulp van een externe EEPROM, maar dat is een project op zich geworden, dus ik zal die module afzonderlijk vrijgeven onder een andere instructable wanneer deze klaar is voor productie. Hier is een lijst van de dingen die u momenteel kunt doen met de AVR Shell:

• Lees al uw Data Direction Registers (DDRn), poorten en pinnen in realtime
• Schrijf naar al uw DDRn's, poorten en pinnen om motoren, LED's of sensoren in realtime aan te zetten
• Lijst van alle bekende registers op het systeem
• Creëer en bewaar waarden in door de gebruiker gedefinieerde variabelen, geback-upt door EEPROM.
• Maak een root-wachtwoord en authenticeer ertegen (gebruikt voor telnet-toegang)
• Lees de geconfigureerde CPU-kloksnelheid
• Verander de kloksnelheid van je CPU door een prescaler in te stellen
• Start en stop 16-bits timers voor de timing van verschillende dingen
• In- en/of uitschakelen van perifere subsystemen: analoog naar digitaal converters (ADC), seriële perifere interface (SPI), tweedraads interface (TWI/I2C), UART/USART. Handig wanneer je het stroomverbruik van de microcontroller wilt verminderen of bepaalde functies wilt inschakelen.
• Geschreven in C++ met herbruikbare objecten.

Deze instructable loopt door de installatie, het gebruik en de aanpassing van avrsh.

Stap 1: Wat heb je nodig

Dit instructable vereist niet veel behalve dat je:

• Heb een Arduino of ATmega328P. Andere AVR's zouden kunnen werken, maar het kan zijn dat u de code moet wijzigen om alle registers weer te geven die uniek zijn voor uw MCU. De namen hoeven alleen overeen te komen met wat wordt vermeld in het headerbestand dat uniek is voor uw MCU. Veel van de registernamen zijn hetzelfde tussen AVR's, dus uw kilometerstand kan variëren bij het overzetten.
• Heb een manier om verbinding te maken met de seriële USART van uw Arduino/AVR. Het systeem is het meest uitgebreid getest met de AVR Terminal, een Windows-app die een seriële verbinding maakt via je USB- of COM-poort. Werkt met Arduino's via de USB-aansluiting en elke AVR via de USB-BUB van Moderndevice.com. Andere terminalopties zijn: Putty, minicom (Linux en FreeBSD), scherm (Linux/FreeBSD), Hyperterminal, Teraterm. Ik heb gemerkt dat stopverf en teraterm wat rotzooi verzenden bij het verbinden, dus je eerste opdracht kan onleesbaar zijn.
• Zorg dat de AVR Shell-firmware is geïnstalleerd en actief is, die u van deze pagina's kunt downloaden, of download altijd de nieuwste versie op BattleDroids.net.

Om de AVR Terminal te installeren, hoeft u deze alleen maar uit te pakken en uit te voeren. Om de AVR Shell-firmware te installeren, downloadt u deze en uploadt u ofwel direct het hex-bestand en sluit u uw seriële terminal aan op 9600 baud, of compileert u het zelf met "make" en vervolgens "make-programma" om de hex te uploaden. Let op, het kan zijn dat u de AVRDUDE-instellingen moet wijzigen om uw COM-poort weer te geven. Opmerking: het PROGMEM-kenmerk is verbroken in de huidige AVR GCC-implementatie voor C++ en dit is een bekende bug. Als je het compileert, verwacht dan veel waarschuwingsberichten te krijgen met de tekst "waarschuwing: alleen geïnitialiseerde variabelen kunnen in het geheugengebied van het programma worden geplaatst." Deze waarschuwing is niet alleen vervelend om te zien, maar ook ongevaarlijk. Aangezien C++ op het embedded platform niet hoog op de prioriteitenlijst van AVR GCC staat, is het niet bekend wanneer dit zal worden opgelost. Als je de code bekijkt, zul je zien waar ik omzeilingen heb gemaakt om deze waarschuwing te verminderen door mijn eigen attribuutverklaringen te implementeren. Vrij eenvoudig. Download en installeer alles wat je nodig hebt om de pagina om te slaan en laten we beginnen.

Stap 2: Registers lezen en schrijven

De AVR Shell is in de eerste plaats geschreven om toegang te krijgen tot enkele sensoren die ik op mijn AVR had aangesloten. Het begon met een eenvoudige LED en ging toen over naar lichtsensoren, temperatuursensoren en uiteindelijk naar twee ultrasone transducers. avrsh kan de digitale componenten van deze sensoren instellen door te schrijven naar de registers die ze besturen. AVR-registers manipuleren tijdens het draaien Om een lijst van alle bekende registers op uw Arduino te krijgen, typt u:

registers afdrukken en je krijgt een afdruk die er zo uitziet

Ik weet van de volgende registers:

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 TWAMR Gebruik de opdracht cat of echo om te zien hoe de afzonderlijke bits in een register zijn ingesteld

kat %GPIOR0 Hier vraag ik de opdrachtinterpreter om de inhoud van het General Purpose I/O Register #0 weer te geven of te herhalen. Let op het procentteken (%) voor de registernaam. U hebt dit nodig om aan de shell aan te geven dat dit een gereserveerd sleutelwoord is dat een register identificeert. De typische uitvoer van een echo-opdracht ziet er als volgt uit:

GPIOR0(0x0) ingesteld op [00000000] De uitvoer toont de naam van het register, de hexadecimale waarde die in het register wordt gevonden en de binaire weergave van het register (waarbij elke bit wordt weergegeven als een 1 of 0). Gebruik de operator "index van" om een bepaald bit in een register in te stellen. Laten we bijvoorbeeld zeggen dat ik het 3e bit tot een 1. wil

%GPIOR0[3] = 1 en de shell geeft je een reactie die aangeeft wat de actie is en het resultaat

GPIOR0(0x0) ingesteld op [00000000] (0x8) ingesteld op [00001000] Vergeet het procentteken niet om de shell te laten weten dat u met een register werkt. Merk ook op dat door het 3e bit in te stellen, dat 4 bits is, omdat onze AVR's een op nul gebaseerde index gebruiken. Met andere woorden, tellend tot het 3e bit tel je 0, 1, 2, 3, wat de 4e plaats is, maar het 3e bit. U kunt op dezelfde manier een bit wissen door een bit op nul te zetten. Door dit soort bits in te stellen, kunt u de werking van uw AVR in een oogwenk veranderen. Bijvoorbeeld door de CTC-timerovereenkomstwaarde in OCR1A te wijzigen. U kunt ook een kijkje nemen in bepaalde instellingen die u programmatisch in uw code zou moeten controleren, zoals de UBBR-waarde voor uw baudrate. Werken met DDRn, PORTn en PINn De I/O-pinnen zijn ook toegewezen aan registers en kunnen op precies dezelfde manier worden ingesteld, maar er is een speciale syntaxis gemaakt om met dit soort registers te werken. In code is er een normaal proces voor bijvoorbeeld het inschakelen van een LED of ander apparaat waarvoor een digitale high of low vereist is. Het vereist het instellen van het Data Direction Register om aan te geven dat de pin voor uitvoer is en vervolgens een 1 of 0 te schrijven naar het specifieke bit in de juiste poort. Ervan uitgaande dat we een LED hebben aangesloten op digitale pin 13 (PB5) en we willen deze aanzetten, dan kun je dat als volgt doen terwijl je AVR actief is

zet pin pb5 outputwrite pin pb5 hoog De output, behalve dat je je LED kunt zien aangaan, zou er als volgt uitzien:

root@ATmega328p> zet pin pb5 outputSet pb5 voor outputroot@ATmega328p> schrijf pin pb5 hoogSchrijf logica hoog naar pin pb5 De "root@ATmega328p>" is de prompt van de shell die aangeeft dat hij klaar is om commando's van jou te accepteren. Om de LED uit te schakelen, schrijft u eenvoudig een laag naar de pin. Als u de digitale ingang van een pin wilt lezen, gebruikt u het leescommando. Met behulp van ons bovenstaande voorbeeld:

root@ATmega328p> lees pin pb5Pin: pb5 is HOOG U kunt ook gewoon het pinregister herhalen dat die pinpoort bestuurt. Als we bijvoorbeeld dipswitches hebben aangesloten op digitale pin 7 en 8 (PD7 en PD8), kunt u het commando

echo %PIND en de shell zou dan de inhoud van dat register weergeven, en u alle invoer-/uitvoerstatussen van aangesloten apparaten laten zien en of de status van de schakelaar aan of uit was.

Stap 3: Zekeringen lezen en schrijven

Zekeringen zijn speciale soorten registers. Ze regelen alles, van de kloksnelheid van uw microcontroller tot welke programmeermethoden beschikbaar zijn voor schrijfbeveiliging van EEPROM. Soms moet u deze instellingen wijzigen, vooral als u een stand-alone AVR-systeem maakt. Ik weet niet zeker of je je zekeringinstellingen op Arduino moet wijzigen. Wees voorzichtig met je zekeringen; je kunt jezelf buitensluiten als je ze verkeerd instelt. In een eerdere instructable heb ik laten zien hoe je je zekeringen kunt lezen en instellen met behulp van je programmeur en avrdude. Hier laat ik u zien hoe u uw zekeringen tijdens runtime kunt teruglezen om te zien hoe uw MCU ze daadwerkelijk heeft ingesteld. Merk op dat dit niet de compile-time-instelling is die u uit de definities haalt, maar de daadwerkelijke zekeringen zoals de MCU ze tijdens runtime leest. Uit tabel 27-9 in de ATmega328P-datasheet (databook, meer zoals het) zijn de bits van de Fuse Low Byte als volgt:

CKDIV8 CKOUT SUT1 SUT0 CKSEL3 CKSEL2 CKSEL1 CKSEL0Een interessant ding om op te merken is dat met zekeringen, 0 betekent geprogrammeerd en een 1 betekent dat dat specifieke bit niet geprogrammeerd is. Enigszins contra-intuïtief, maar als je het eenmaal weet, weet je het.

• CKDIV8 stelt uw CPU-klok in om door 8 te worden gedeeld. De ATmega328P is in de fabriek geprogrammeerd om zijn interne oscillator op 8 MHz te gebruiken met CKDIV8 geprogrammeerd (dwz ingesteld op 0), waardoor u een uiteindelijke F_CPU of CPU-frequentie van 1 MHz krijgt. Op Arduino's is dit veranderd omdat ze zijn geconfigureerd om een externe oscillator op 16MHz te gebruiken.
• CKOUT wanneer geprogrammeerd, zal uw CPU-klok uitvoeren op PB0, wat digitale pin 8 is op Arduinos.
• SUT[1..0] specificeert de opstarttijd voor uw AVR.
• CKSEL[3..0] stelt de klokbron in, zoals de interne RC-oscillator, externe oscillator, enz.

Wanneer u uw zekeringen leest, wordt deze in hexadecimaal naar u teruggestuurd. Dit is het formaat dat je nodig hebt als je de zekeringen via avrdude wilt schrijven. Op mijn Arduino krijg ik dit als ik de onderste zekeringbyte lees:

root@ATmega328p> lees lfuseLower Fuse: 0xffDus alle bits zijn ingesteld op 1. Ik deed dezelfde procedure op een Arduino-kloon en kreeg dezelfde waarde. Toen ik een van mijn stand-alone AVR-systemen controleerde, kreeg ik 0xDA, de waarde die ik enige tijd terug had ingesteld bij het configureren van de chip. Dezelfde procedure wordt gebruikt voor het controleren van de High Fuse Byte, Extended Fuse Byte en Lock-zekeringen. De kalibratie- en kenmerkende zekeringbytes zijn uitgeschakeld in de code met een #if 0 preprocessor-richtlijn, die u kunt wijzigen als u zich slordig voelt.

Stap 4: Andere opdrachten

Er zijn verschillende andere commando's die de standaardcommando-interpreter begrijpt en die u misschien nuttig vindt. U kunt alle geïmplementeerde en toekomstige release-opdrachten zien door achter de prompt help of menu te geven. Ik zal ze hier snel behandelen, omdat ze meestal voor zichzelf spreken. CPU-klokfrequentie-instellingen U kunt achterhalen waarvoor uw firmware is geconfigureerd om te gebruiken als de CPU-klokinstellingen met het fcpu-commando:

root@ATmega328p> fcpuCPU-frequentie: 16000000Dat is 16 miljoen, of 16 miljoen herz, beter bekend als 16 MHz. U kunt dit om wat voor reden dan ook on-the-fly wijzigen met het klokcommando. Deze opdracht heeft één argument nodig: de prescaler die moet worden gebruikt bij het delen van uw kloksnelheid. Het klokcommando begrijpt deze prescaler-waarden:

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

Met behulp van de opdracht:

klok ckdiv2 wanneer uw cpu-snelheid 16 MHz is, zou uw kloksnelheid worden gewijzigd naar 8 MHz. Het gebruik van een prescaler van ckdiv64 met een initiële kloksnelheid van 16 MHz zal resulteren in een uiteindelijke kloksnelheid van 250 KHz. Waarom zou je je MCU in hemelsnaam langzamer willen maken? Welnu, een lagere kloksnelheid verbruikt minder stroom en als je MCU op een batterij in een projectbehuizing werkt, heb je hem misschien niet nodig om op topsnelheid te werken, en zou daarom de snelheid kunnen verlagen en het stroomverbruik verminderen, waardoor de levensduur van de batterij wordt verlengd. Ook als u de klok gebruikt voor timingproblemen met een andere MCU, bijvoorbeeld door een software-UART of iets dergelijks te implementeren, wilt u deze misschien instellen op een bepaalde waarde die gemakkelijk is om een mooie gelijkmatige baudrate te krijgen met lagere foutenpercentages. In- en uitschakelen van perifere subsystemen Net als bij het verminderen van het eerder genoemde stroomverbruik, wilt u misschien het stroomverbruik verder verminderen door enkele van de ingebouwde randapparatuur die u niet gebruikt uit te schakelen. De opdrachtinterpreter en shell kunnen momenteel de volgende randapparatuur in- en uitschakelen:

• Analoog-naar-digitaal-omzetter (ADC). Dit randapparaat wordt gebruikt wanneer u een analoge sensor hebt die gegevens levert (zoals temperatuur, licht, versnelling, enz.) en deze moet converteren naar een digitale waarde.
• Seriële perifere interface (SPI). De SPI-bus wordt gebruikt om te communiceren met andere SPI-compatibele apparaten, zoals externe geheugens, LED-stuurprogramma's, externe ADC's, enz. Delen van de SPI worden gebruikt voor ISP-programmering, of in ieder geval de pinnen, dus wees voorzichtig bij het afsluiten hiervan als u via ISP programmeert.
• Tweedraads interface. Sommige externe apparaten gebruiken de I2C-bus om te communiceren, hoewel deze snel worden vervangen door SPI-compatibele apparaten omdat SPI een grotere doorvoer heeft.
• USART. Dit is uw seriële interface. Deze wil je waarschijnlijk niet uitschakelen als je via de seriële verbinding met de AVR bent verbonden! Ik heb dit hier echter toegevoegd als een skelet voor het overzetten naar apparaten met meerdere USART's zoals de ATmega162 of ATmega644P.
• alle. Dit argument voor de powerup- of powerdown-opdracht schakelt alle genoemde randapparatuur in of schakelt ze allemaal uit met één opdracht. Nogmaals, gebruik deze opdracht verstandig.

root@ATmega328p> powerdown twiPowerdown van twi complete.root@ATmega328p> powerup twiPowerup van twi compleet.

Timers starten en stoppen De shell heeft een ingebouwde 16-bits timer die beschikbaar is voor gebruik. Je start de timer met het timer-commando:

timer starten stop de timer met het stop-argument

timer stopDeze timer is niet in strijd met de interne USART-timer. Zie de code voor de implementatiedetails van de USART-timer, als dat soort bloederige details je interesseren

root@ATmega328p> timer startStarted timer.root@ATmega328p> timer stopVerstreken tijd: ~ 157 seconden Authenticatie De shell kan een wachtwoord van 8 tekens opslaan in EEPROM. Dit wachtwoordmechanisme is gemaakt om de telnet-inlogmogelijkheden te ondersteunen, maar kan worden uitgebreid om andere dingen te beschermen. U kunt bijvoorbeeld bepaalde opdrachten vereisen, zoals het wijzigen van registerwaarden, via het authenticatiemechanisme. Stel het wachtwoord in met de wachtwoordopdracht

root@ATmega328p> passwd blahSchrijf root-wachtwoord in EEPROMAutoriseer tegen het wachtwoord (of eis programmatisch autorisatie via de code) met het auth-commando. Merk op dat als je probeert het root-wachtwoord te wijzigen en er al een root-wachtwoord is ingesteld, je jezelf moet autoriseren met het oude wachtwoord voordat je toestemming krijgt om het te wijzigen in een nieuw wachtwoord

root@ATmega328p> passwd blinkyJe moet jezelf eerst autoriseren.root@ATmega328p> auth blahAuthorized.root@ATmega328p> passwd blinkySchrijf NIEUW root-wachtwoord in EEPROMNatuurlijk moet u het avrsh.eep-bestand laden als u de firmware wist om uw oude waarden en variabelen te herstellen. De Makefile maakt het EEPROM-bestand voor u aan. Variabelen De shell begrijpt de notie van door de gebruiker gedefinieerde variabelen. De code beperkt dit tot 20, maar u kunt dat desgewenst wijzigen door de definitie van MAX_VARIABLES in script.h te wijzigen. U kunt elke 16-bits waarde (dat wil zeggen, elk getal tot 65, 536) opslaan in een variabele die later moet worden opgeroepen. De syntaxis is vergelijkbaar met registers, behalve dat een dollarteken ($) wordt gebruikt om variabelen in de shell aan te duiden. Maak een lijst van al uw variabelen met de opdracht printvariabelen

print variabelenGebruikergedefinieerde variabelen:Indexnaam -> Waarde(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$ -> 0Voltooid. Stel een variabele in

$newvar = 25$time-out = 23245De waarde van een bepaalde variabele ophalen

root@ATmega328p> echo $newvar$ newvar 25U kunt zien wat alle variabelen die u momenteel hebt geïnstantieerd met de printopdracht die u al kent

Door de gebruiker gedefinieerde variabelen: Indexnaam -> Waarde(01): newvar -> 25(02): time-out -> 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): $GRATIS$ -> 0Voltooid. De naam $FREE$ geeft alleen aan dat de locatie van de variabele vrij is en dat er nog geen variabelenaam is toegewezen.

Stap 5: De schaal aanpassen

Je bent vrij om de code te hacken en deze aan te passen aan je eigen behoeften, als je wilt. Als ik had geweten dat ik deze code zou vrijgeven, zou ik een aparte klasse en opdrachtstructuur voor de opdrachtinterpreter hebben gemaakt en eenvoudigweg door deze aanroep van een functieaanwijzer hebben herhaald. Het zou de hoeveelheid code verminderen, maar zoals het er nu uitziet parseert de shell de opdrachtregel en roept de juiste shell-methode aan. Om uw eigen aangepaste opdrachten toe te voegen, doet u het volgende: 1. Voeg uw opdracht toe aan de parseerlijst De opdrachtparser zal ontleden de opdrachtregel en geef u de opdracht en eventuele argumenten afzonderlijk. De argumenten worden doorgegeven als pointers naar pointers, of een array van pointers, hoe u er ook mee wilt werken. Dit is te vinden in shell.cpp. Open shell.cpp en zoek de ExecCmd-methode van de AVRShell-klasse. Misschien wilt u de opdracht aan het programmageheugen toevoegen. Als je dat doet, voeg je de opdracht toe in progmem.h en progmem.cpp. U kunt de opdracht rechtstreeks aan het programmageheugen toevoegen met behulp van de PSTR()-macro, maar u genereert dan nog een waarschuwing van het eerder genoemde type. Nogmaals, dit is een bekende bug die werkt met C++, maar je kunt dit omzeilen door de opdracht rechtstreeks in de progmem.*-bestanden toe te voegen, zoals ik heb gedaan. Als je het niet erg vindt om aan je SRAM-gebruik toe te voegen, kun je de opdracht toevoegen zoals ik heb geïllustreerd met de opdracht "klok". Stel dat u een nieuwe opdracht met de naam "newcmd" wilt toevoegen. Ga naar AVRShell::ExecCmd en zoek een geschikte plaats om de volgende code in te voegen:

else if (!strcmp(c, "newcmd")) cmdNewCmd(args);Hiermee wordt uw opdracht toegevoegd en wordt de cmdNewCmd-methode aangeroepen die u in de volgende stap zult schrijven. 2. Schrijf uw aangepaste opdrachtcode Voeg in hetzelfde bestand uw aangepaste opdrachtcode toe. Dit is de methodedefinitie. U wilt de aangifte nog steeds toevoegen aan shell.h. Voeg het gewoon toe aan de andere opdrachten. In het vorige voorbeeld zou de code er ongeveer zo uit kunnen zien:

voidAVRShell::cmdNewCmd(char ** args){ sprintf_P(buff, PSTR("Uw commando is %s\r\n", args[0]); WriteRAM(buff);}Er zijn hier meerdere dingen. Ten eerste is "buff" een arraybuffer van 40 tekens die in de code voor uw gebruik is opgenomen. We gebruiken de programmageheugenversie van sprintf omdat we er een PSTR aan doorgeven. Je kunt de reguliere versie gebruiken als je wilt, maar zorg ervoor dat je het formaat niet doorgeeft in een PSTR. De argumenten bevinden zich ook in de array args. Als je "newcmd arg1 arg2" hebt getypt, kun je bij deze argumenten komen met de subscripts args[0] en args[1]. U kunt maximaal MAX_ARGS-argumenten doorgeven, zoals gedefinieerd in de code. Voel je vrij om die waarde te wijzigen wanneer je opnieuw compileert als je veel meer argumenten tegelijk wilt doorgeven. De WriteLine en WriteRAM zijn globale functies die de UART-methoden met dezelfde naam retourneren. Het tweede argument voor deze functie is impliciet. Als u niets doorgeeft, wordt er achteraf een opdrachtprompt geschreven. Als u een 0 doorgeeft als het 2e argument, wordt er geen prompt geschreven. Dit is handig als u verschillende afzonderlijke tekenreeksen wilt schrijven voor uitvoer voordat de opdrachtprompt naar de gebruiker wordt teruggestuurd. 3. Laat de shell de opdrachtcode uitvoeren U hebt de shell-uitvoerder al verteld om de methode cmdNewCmd uit te voeren toen u de nieuwe opdracht instelde, maar voeg deze toe aan het shell.h-bestand om het door het shell-object te laten begrijpen. Voeg het gewoon toe onder het laatste commando of voor het eerste commando, of ergens daarbinnen. En dat is alles. Hercompileer en upload de firmware naar uw Arduino en uw nieuwe opdracht is bij de prompt beschikbaar vanuit de shell.

Stap 6: Samenvatting

U zou moeten weten hoe u uw AVR/Arduino moet installeren en verbinden en een live prompt op uw draaiende microcontroller moet krijgen. U kent verschillende commando's die runtime-gegevens uit de MCU halen of direct waarden in de MCU instellen. Er is u ook getoond hoe u uw eigen aangepaste code kunt toevoegen om uw eigen unieke opdrachten aan de shell te maken om deze verder aan uw eigen behoeften aan te passen. Je kunt zelfs de commando-interpreter zo laten dat het alleen je aangepaste commando's bevat, als dat aan je behoeften voldoet. als een leerproces bij het implementeren van uw eigen. Zoals altijd kijk ik uit naar opmerkingen of suggesties over hoe dit instructable kan worden verbeterd! Veel plezier met uw AVR!