AVRSH : un interpréteur de commandes pour Arduino/AVR. : 6 étapes (avec images)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:11

Vous avez toujours voulu être "connecté" à votre microcontrôleur AVR ? Avez-vous déjà pensé que ce serait cool de "chat" un registre pour voir son contenu ? Avez-vous toujours voulu un moyen d'allumer et d'éteindre les sous-systèmes périphériques individuels de votre AVR ou Arduino en *temps réel* ? Moi aussi, j'ai donc écrit l'AVR Shell, un shell de type UNIX. C'est comme UNIX car cela rappelle le compte shell que vous avez acheté pour exécuter vos bots de collision irc nick, ainsi qu'avoir une commande ou deux en commun. Il a également un système de fichiers qui ressemble à UNIX extfs, utilisant une EEPROM externe, mais c'est devenu un projet en soi, donc je publierai ce module séparément sous un autre instructable lorsqu'il sera prêt pour la production. Voici une liste des choses que vous pouvez actuellement faire avec l'AVR Shell:

• Lisez tous vos registres de direction de données (DDRn), ports et broches en temps réel
• Écrivez sur tous vos DDRn, ports et broches pour allumer les moteurs, les LED ou lire les capteurs en temps réel
• Lister tous les registres connus sur le système
• Créez et stockez des valeurs dans des variables définies par l'utilisateur sauvegardées par EEPROM.
• Créez un mot de passe root et authentifiez-vous par rapport à celui-ci (utilisé pour l'accès telnet)
• Lire la vitesse d'horloge CPU configurée
• Modifiez la vitesse d'horloge de votre processeur en définissant un pré-scaler
• Démarrer et arrêter les minuteries 16 bits pour la synchronisation de diverses choses
• Sous-systèmes périphériques sous tension et/ou hors tension: convertisseurs analogique-numérique (ADC), interface périphérique série (SPI), interface à deux fils (TWI/I2C), UART/USART. Utile lorsque vous souhaitez réduire la consommation électrique du microcontrôleur ou activer certaines fonctions.
• Écrit en C++ avec des objets réutilisables.

Cette instructable vous guidera à travers l'installation, l'utilisation et la personnalisation d'avrsh.

Étape 1: ce dont vous aurez besoin

Cette instructable ne nécessite pas grand-chose sauf que vous:

• Avoir un Arduino ou un ATmega328P. D'autres AVR pourraient fonctionner, mais vous devrez peut-être modifier le code pour répertorier tous les registres propres à votre MCU. Les noms doivent uniquement correspondre à ce qui est répertorié dans le fichier d'en-tête unique à votre MCU. La plupart des noms de registre sont les mêmes entre les AVR, donc votre kilométrage peut varier lors du portage.
• Ayez un moyen de vous connecter à l'USART série de votre Arduino/AVR. Le système a été testé le plus largement avec le terminal AVR, une application Windows qui établit une connexion série via votre port USB ou COM. Fonctionne avec Arduinos en utilisant la connexion USB et n'importe quel AVR en utilisant l'USB-BUB de Moderndevice.com. Les autres options de terminal incluent: Putty, minicom (Linux et FreeBSD), screen (Linux/FreeBSD), Hyperterminal, Teraterm. J'ai trouvé que putty et teraterm envoient des déchets lors de la connexion, de sorte que votre première commande peut être brouillée.
• Installez et exécutez le micrologiciel AVR Shell, que vous pouvez télécharger à partir de ces pages, ou obtenez toujours la dernière version sur BattleDroids.net.

Pour installer le terminal AVR, il suffit de le déballer et de l'exécuter. Pour installer le firmware AVR Shell, téléchargez-le et téléchargez directement le fichier hexadécimal et connectez votre terminal série à 9600 bauds, ou compilez-le vous-même avec "make" puis "make program" pour télécharger l'hexadécimal. Notez que vous devrez peut-être modifier les paramètres AVRDUDE pour refléter votre port COM. Remarque: L'attribut PROGMEM est cassé dans l'implémentation actuelle de AVR GCC pour C++ et il s'agit d'un bogue connu. Si vous le compilez, attendez-vous à recevoir de nombreux messages d'avertissement indiquant « avertissement: seules les variables initialisées peuvent être placées dans la zone de mémoire du programme ». En plus d'être ennuyeux à voir, cet avertissement est inoffensif. Comme C++ sur la plate-forme embarquée n'est pas en haut de la liste des priorités AVR GCC, on ne sait pas quand cela sera corrigé. Si vous consultez le code, vous verrez où j'ai trouvé des solutions pour réduire cet avertissement en implémentant mes propres instructions d'attribut. Assez simple. Téléchargez et installez tout ce dont vous pourriez avoir besoin, puis retournez la page et commençons à craquer.

Étape 2: Lecture et écriture des registres

L'AVR Shell a été écrit principalement pour accéder à certains capteurs que j'avais connectés à mon AVR. Cela a commencé avec une simple LED, puis est passé aux capteurs de lumière, aux capteurs de température et enfin à deux transducteurs à ultrasons. avrsh peut paramétrer les composants numériques de ces capteurs en écrivant dans les registres qui les contrôlent. Manipulation des registres AVR pendant l'exécution Pour obtenir une liste de tous les registres connus sur votre Arduino, tapez:

imprimer les registres et vous obtiendrez une impression ressemblant à ceci

Je connais les registres suivants:

TIFR0 PORTC TIFR1 PORTD TIFR2 DDRD PCIFR DDRB EIFR DDRC EIMSK PINB EECR PINC RSÉME 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 TWMR UCSR UCSR0R0ph0ph0ph0 Pour voir comment les bits individuels sont définis dans n'importe quel registre, utilisez la commande cat ou echo

chat %GPIOR0 Ici, je demande à l'interpréteur de commandes d'afficher, ou de faire écho, le contenu du registre d'E/S à usage général #0. Notez le signe de pourcentage (%) devant le nom du registre. Vous en avez besoin pour indiquer au shell qu'il s'agit d'un mot-clé réservé identifiant un registre. La sortie typique d'une commande echo ressemble à ceci

GPIOR0(0x0) défini sur [0000000] La sortie affiche le nom du registre, la valeur hexadécimale trouvée dans le registre et la représentation binaire du registre (affichant chaque bit comme 1 ou 0). Pour définir un bit particulier dans n'importe quel registre, utilisez l'opérateur "index of" . Par exemple, disons que je veux le 3ème bit à 1

%GPIOR0[3] = 1 et le shell vous donnera une réponse indiquant son action et le résultat

GPIOR0(0x0) défini sur [00000000] (0x8) défini sur [00001000] N'oubliez pas le signe pourcentage pour indiquer au shell que vous travaillez avec un registre. Notez également qu'en définissant le 3ème bit, cela fait 4 bits car nos AVR utilisent un index de base zéro. En d'autres termes, en comptant jusqu'au 3ème bit, vous comptez 0, 1, 2, 3, qui est la 4ème place, mais le 3ème bit. Vous pouvez effacer un peu de la même manière en mettant un bit à zéro. En définissant des bits comme celui-ci, vous pouvez modifier le fonctionnement de votre AVR à la volée. Par exemple, en modifiant la valeur de correspondance de la minuterie CTC trouvée dans OCR1A. Il vous permet également de jeter un coup d'œil sur des paramètres particuliers que vous auriez à vérifier par programmation dans votre code, tels que la valeur UBBR pour votre débit en bauds. Travailler avec DDRn, PORTn et PINn Les broches d'E/S sont également affectées à des registres et peuvent être définies exactement de la même manière, mais une syntaxe spéciale a été créée pour fonctionner avec ces types de registres. Dans le code, il existe un processus normal pour, par exemple, allumer une LED ou un autre appareil qui nécessite un niveau haut ou bas numérique. Cela nécessite de définir le registre de direction des données pour indiquer que la broche est destinée à la sortie, puis d'écrire un 1 ou un 0 sur le bit particulier du port approprié. En supposant que nous ayons une LED connectée à la broche numérique 13 (PB5) et que nous souhaitions l'allumer, voici comment procéder pendant que votre AVR fonctionne

set pin pb5 outputwrite pin pb5 high La sortie, en plus de pouvoir voir votre LED s'allumer, ressemblerait à ceci

root@ATmega328p> définir la broche pb5 outputSet pb5 pour la sortieroot@ATmega328p> écrire la broche pb5 highWrote logique haut sur la broche pb5 Le "root@ATmega328p>" est l'invite du shell qui indique qu'il est prêt à accepter des commandes de votre part. Pour éteindre la LED, vous écririez simplement un faible sur la broche. Si vous souhaitez lire l'entrée numérique à partir d'une broche, utilisez la commande read. En utilisant notre exemple ci-dessus

root@ATmega328p> read pin pb5Pin: pb5 est HAUT Alternativement, faites simplement écho au registre de broche qui contrôle ce port de broche. Par exemple, si nous avons des commutateurs DIP connectés aux broches numériques 7 et 8 (PD7 et PD8), vous pouvez envoyer la commande

écho %PIND et le shell afficherait alors le contenu de ce registre, vous montrant tous les états d'entrée/sortie des appareils connectés et si l'état du commutateur était activé ou désactivé.

Étape 3: Lecture et écriture des fusibles

Les fusibles sont des types spéciaux de registres. Ils contrôlent tout, de la vitesse d'horloge de votre microcontrôleur aux méthodes de programmation disponibles en passant par l'EEPROM de protection en écriture. Parfois, vous devrez modifier ces paramètres, surtout si vous créez un système AVR autonome. Je ne suis pas sûr que vous deviez modifier vos paramètres de fusible sur Arduino. Soyez prudent avec vos fusibles; vous pouvez vous enfermer si vous les définissez de manière incorrecte. Dans un précédent instructable, j'ai montré comment vous pouvez lire et régler vos fusibles à l'aide de votre programmeur et avrdude. Ici, je vais vous montrer comment relire vos fusibles au moment de l'exécution pour voir comment votre MCU les a réellement réglés. Notez qu'il ne s'agit pas du paramètre de compilation que vous obtenez à partir des définitions, mais des fusibles réels lorsque le MCU les lit au moment de l'exécution. D'après le tableau 27-9 de la fiche technique ATmega328P (databook, plus similaire), les bits de l'octet bas du fusible sont les suivants:

CKDIV8 CKOUT SUT1 SUT0 CKSEL3 CKSEL2 CKSEL1 CKSEL0Une chose intéressante à noter est qu'avec les fusibles, 0 signifie programmé et 1 signifie que ce bit particulier n'est pas programmé. Un peu contre-intuitif, mais une fois que vous le savez, vous le savez.

• CKDIV8 règle votre horloge CPU pour qu'elle soit divisée par 8. L'ATmega328P est programmé en usine pour utiliser son oscillateur interne à 8MHz avec CKDIV8 programmé (c'est-à-dire réglé sur 0) vous donnant une fréquence finale F_CPU ou CPU de 1MHz. Sur les Arduino, cela est modifié car ils sont configurés pour utiliser un oscillateur externe à 16 MHz.
• CKOUT une fois programmé produira l'horloge de votre CPU sur PB0, qui est la broche numérique 8 sur Arduinos.
• SUT[1..0] spécifie l'heure de démarrage de votre AVR.
• CKSEL[3..0] définit la source d'horloge, telle que l'oscillateur RC interne, l'oscillateur externe, etc.

Lorsque vous lisez vos fusibles, il vous sera restitué en hexadécimal. C'est le format dont vous avez besoin si vous voulez écrire les fusibles via avrdude. Sur mon arduino, voici ce que j'obtiens quand je lis l'octet inférieur du fusible:

root@ATmega328p> lire lfuseLower Fuse: 0xffAinsi, tous les bits sont définis sur 1. J'ai effectué la même procédure sur un clone Arduino et j'ai obtenu la même valeur. En vérifiant l'un de mes systèmes AVR autonomes, j'ai obtenu 0xDA qui est la valeur que j'avais définie il y a quelque temps lors de la configuration de la puce. La même procédure est utilisée pour vérifier l'octet de fusible élevé, l'octet de fusible étendu et les fusibles de verrouillage. Les octets de fuse de calibrage et de signature ont été désactivés dans le code avec une directive de préprocesseur #if 0, que vous pouvez modifier si vous vous sentez brouillon.

Étape 4: Autres commandes

Il existe plusieurs autres commandes que l'interpréteur de commandes par défaut comprend et qui peuvent vous être utiles. Vous pouvez voir toutes les commandes implémentées et futures en émettant une aide ou un menu à l'invite. Je vais les couvrir rapidement ici car ils sont pour la plupart explicites. Paramètres de fréquence d'horloge CPU Vous pouvez découvrir ce que votre firmware a été configuré pour utiliser comme paramètres d'horloge CPU avec la commande fcpu:

root@ATmega328p> fcpuCPU Fréq: 1600000C'est 16 millions, ou 16 millions d'herz, plus communément appelés 16 MHz. Vous pouvez changer cela à la volée, pour une raison quelconque, avec la commande clock. Cette commande prend un argument: le prescaler à utiliser lors de la division de votre vitesse d'horloge. La commande d'horloge comprend ces valeurs de prescaler:

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

À l'aide de la commande:

horloge ckdiv2 lorsque la vitesse de votre processeur est de 16 MHz, votre vitesse d'horloge serait modifiée à 8 MHz. L'utilisation d'un prescaler de ckdiv64 avec une vitesse d'horloge initiale de 16 MHz entraînera une vitesse d'horloge finale de 250 KHz. Pourquoi diable voudriez-vous ralentir votre MCU ? Eh bien, d'une part, une vitesse d'horloge inférieure consomme moins d'énergie et si votre MCU fonctionne avec une batterie dans un boîtier de projet, vous n'en aurez peut-être pas besoin pour fonctionner à la vitesse maximale, et pourrait donc réduire la vitesse et réduire sa consommation d'énergie., augmentant la durée de vie de la batterie. De plus, si vous utilisez l'horloge pour toute sorte de problèmes de synchronisation avec un autre MCU, par exemple, implémentant un logiciel UART ou quelque chose du genre, vous voudrez peut-être le régler sur une valeur particulière avec laquelle il est facile d'obtenir un bon débit en bauds. taux d'erreur plus faibles. Mise sous tension et hors tension des sous-systèmes périphériques Sur la même note que la réduction de la consommation d'énergie mentionnée précédemment, vous souhaiterez peut-être réduire davantage la puissance en arrêtant certains des périphériques intégrés que vous n'utilisez pas. L'interpréteur de commandes et le shell peuvent actuellement mettre sous et hors tension les périphériques suivants:

• Convertisseur analogique-numérique (ADC). Ce périphérique est utilisé lorsque vous disposez d'un capteur analogique fournissant des données (comme la température, la lumière, l'accélération, etc.) et que vous devez les convertir en une valeur numérique.
• Interface périphérique série (SPI). Le bus SPI est utilisé pour communiquer avec d'autres périphériques compatibles SPI, tels que des mémoires externes, des pilotes de LED, des ADC externes, etc. si vous programmez via ISP.
• Interface à deux fils. Certains périphériques externes utilisent le bus I2C pour communiquer, bien qu'ils soient rapidement remplacés par des périphériques compatibles SPI, car SPI a un débit plus élevé.
• USART. Ceci est votre interface série. Vous ne voudrez probablement pas désactiver cette option si vous êtes connecté à l'AVR via la connexion série ! Cependant, j'ai ajouté ceci ici en tant que squelette pour le portage vers des appareils qui ont plusieurs USART comme l'ATmega162 ou l'ATmega644P.
• tous. Cet argument de la commande powerup ou powerdown allume tous les périphériques mentionnés ou les éteint tous avec une seule commande. Encore une fois, utilisez cette commande à bon escient.

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

Démarrage et arrêt des temporisateurs Le shell dispose d'un temporisateur intégré de 16 bits qui peut être utilisé. Vous démarrez le minuteur avec la commande timer:

démarrage de la minuterieet arrêter le chronomètre avec l'argument stop

arrêt de la minuterieCe temporisateur n'entrera pas en conflit avec le temporisateur interne USART. Voir le code pour les détails de mise en œuvre de la minuterie USART, si ce genre de détail sanglant vous intéresse

root@ATmega328p> timer startStarted timer.root@ATmega328p> timer stopTemps écoulé: ~ 157 secondes Authentification Le shell peut stocker un mot de passe de 8 caractères dans l'EEPROM. Ce mécanisme de mot de passe a été créé pour prendre en charge les capacités de connexion telnet, mais pourrait être étendu pour protéger d'autres choses. Par exemple, vous pouvez exiger certaines commandes, comme la modification des valeurs de registre, via le mécanisme d'authentification. Définissez le mot de passe avec la commande password

root@ATmega328p> passwd blahÉcrire le mot de passe root dans l'EEPROMAutorisez le mot de passe (ou demandez une autorisation par programme via le code) avec la commande auth. Notez que si vous essayez de changer le mot de passe root et qu'il y a déjà un mot de passe root défini, vous devez vous autoriser contre l'ancien mot de passe avant d'être autorisé à le changer en un nouveau mot de passe

root@ATmega328p> passwd blinkyVous devez d'abord vous autoriser.root@ATmega328p> auth blahAuthorized.root@ATmega328p> passwd blinkyÉcrivez un NOUVEAU mot de passe root dans l'EEPROMBien sûr, vous devrez charger le fichier avrsh.eep si vous effacez le firmware pour que vos anciennes valeurs et variables soient restaurées. Le Makefile créera le fichier EEPROM pour vous. Variables Le shell comprend la notion de variables définies par l'utilisateur. Le code limite cela à 20, mais vous pouvez modifier cela si vous le souhaitez en modifiant la définition de MAX_VARIABLES dans script.h. Vous pouvez enregistrer n'importe quelle valeur 16 bits (c'est-à-dire n'importe quel nombre jusqu'à 65, 536) dans une variable à rappeler ultérieurement. La syntaxe est similaire aux registres, sauf qu'un signe dollar ($) est utilisé pour désigner les variables du shell. Lister toutes vos variables avec la commande print variables

variables d'impressionVariables définies par l'utilisateur:Nom de l'index -> Valeur(01): $FREE$ -> 0(02): $FREE$ -> 0(03): $FREE$ -> 0(04): $FREE$ -> 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$ -> 0Complet. Définir une variable

$newvar = 25$timeout = 23245Obtenir la valeur d'une variable donnée

root@ATmega328p> echo $newvar$ newvar 25Vous pouvez voir quelles sont toutes les variables que vous avez actuellement instanciées avec la commande d'impression que vous connaissez déjà

Variables définies par l'utilisateur: Nom de l'index -> Valeur(01): newvar -> 25(02): délai d'attente -> 23245(03): $FREE$ -> 0(04): $FREE$ -> 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$ -> 0Terminé. Le nom $FREE$ indique simplement que cet emplacement de variable est libre et n'a pas encore reçu de nom de variable.

Étape 5: personnalisation du shell

Vous êtes libre de pirater le code et de le personnaliser selon vos propres besoins, si vous le souhaitez. Si j'avais su que je publierais ce code, j'aurais créé une classe d'interpréteur de commandes et une structure de commande distinctes et j'aurais simplement itéré à travers cet appel d'un pointeur de fonction. Cela réduirait la quantité de code, mais en l'état, le shell analyse la ligne de commande et appelle la méthode shell appropriée. Pour ajouter vos propres commandes personnalisées, procédez comme suit: 1. Ajoutez votre commande à la liste d'analyse analyser la ligne de commande et vous donner la commande et tous les arguments séparément. Les arguments sont passés en tant que pointeurs vers des pointeurs, ou un tableau de pointeurs, quelle que soit la manière dont vous aimez travailler avec eux. Cela se trouve dans shell.cpp. Ouvrez shell.cpp et recherchez la méthode ExecCmd de la classe AVRShell. Vous souhaiterez peut-être ajouter la commande à la mémoire du programme. Si vous le faites, ajoutez la commande dans progmem.h et progmem.cpp. Vous pouvez ajouter la commande à la mémoire du programme directement à l'aide de la macro PSTR(), mais vous générerez un autre avertissement du type mentionné précédemment. Encore une fois, il s'agit d'un bogue connu fonctionnant avec C++, mais vous pouvez le contourner en ajoutant la commande directement dans les fichiers progmem.*, comme je l'ai fait. Si cela ne vous dérange pas d'ajouter à votre utilisation de SRAM, vous pouvez ajouter la commande comme je l'ai illustré avec la commande "clock". Supposons que vous vouliez ajouter une nouvelle commande appelée "newcmd". Accédez à AVRShell::ExecCmd et trouvez un endroit pratique pour insérer le code suivant:

else if (!strcmp(c, "newcmd")) cmdNewCmd(args);Cela ajoutera votre commande et appellera la méthode cmdNewCmd que vous écrirez à l'étape suivante. 2. Écrivez votre code de commande personnalisé Dans le même fichier, ajoutez votre code de commande personnalisé. C'est la définition de la méthode. Vous voudrez toujours ajouter la déclaration à shell.h. Il suffit de l'ajouter aux autres commandes. Dans l'exemple précédent, le code pourrait ressembler à ceci

voidAVRShell::cmdNewCmd(char ** args){ sprintf_P(buff, PSTR("Votre commande est %s\r\n", args[0]); WriteRAM(buff);}Il y a plusieurs choses ici. Tout d'abord, "buff" est un tampon de tableau de 40 caractères fourni dans le code pour votre usage. Nous utilisons la version mémoire du programme de sprintf puisque nous lui passons un PSTR. Vous pouvez utiliser la version standard si vous le souhaitez, mais assurez-vous de ne pas transmettre le format dans un PSTR. De plus, les arguments sont dans le tableau args. Si vous avez tapé "newcmd arg1 arg2", vous pouvez obtenir ces arguments avec les indices args[0] et args[1]. Vous pouvez passer un maximum d'arguments MAX_ARGS, comme défini dans le code. N'hésitez pas à modifier cette valeur lorsque vous recompilez si vous avez besoin de beaucoup plus d'arguments à la fois. WriteLine et WriteRAM sont des fonctions globales qui renvoient les méthodes de l'UART du même nom. Le 2ème argument de cette fonction est implicite. Si vous ne transmettez rien, une invite de commande sera écrite par la suite. Si vous passez un 0 comme 2ème argument, aucune invite ne sera écrite. Ceci est utile lorsque vous souhaitez écrire plusieurs chaînes distinctes à afficher avant que l'invite de commande ne soit renvoyée à l'utilisateur. 3. Demandez au shell d'exécuter le code de commande Vous avez déjà demandé à l'exécuteur du shell d'exécuter la méthode cmdNewCmd lorsque vous configurez la nouvelle commande, mais ajoutez-la au fichier shell.h pour qu'elle soit comprise par l'objet shell. Ajoutez-le simplement sous la dernière commande ou devant la première commande, ou n'importe où là-dedans. Et c'est tout. Recompilez et téléchargez le firmware sur votre Arduino et votre nouvelle commande est disponible à partir du shell à l'invite.

Étape 6: Résumé

Vous devez savoir comment installer et vous connecter à votre AVR/Arduino et obtenir une invite en direct sur votre microcontrôleur en cours d'exécution. Vous connaissez plusieurs commandes qui extrairont les données d'exécution du MCU ou définiront des valeurs dans le MCU à la volée. On vous a également montré comment ajouter votre propre code personnalisé pour créer vos propres commandes uniques au shell afin de le personnaliser davantage selon vos propres besoins. Vous pouvez même vider l'interpréteur de commandes pour qu'il ne contienne que vos commandes personnalisées, si cela répond à vos besoins. J'espère que vous avez apprécié cette instruction et que l'AVR Shell peut vous être utile, soit en tant qu'interpréteur de commandes en temps réel, soit comme un processus d'apprentissage dans la mise en œuvre de votre propre. Comme toujours, j'attends avec impatience vos commentaires ou suggestions sur la façon dont cette instructable peut être améliorée ! Amusez-vous avec votre AVR !