Interface de ligne de commande simple

À propos de ce projet

Ligne de commande

Il arrive un moment où vous devez trouver la valeur d'un capteur ou vous voulez dire à votre robot de faire quelque chose comme "se déplacer à gauche". Vous devez peut-être demander à votre programme la valeur d'exécution d'une variable ou définir la valeur d'un potentiomètre numérique.

Ce dont vous avez besoin, c'est d'une ligne de commande. Oui, il est facile de faire en sorte que votre Arduino réponde aux commandes de texte.

En voici une sur laquelle vous pouvez vous appuyer. C'est une interface de ligne de commande simple, rapide et très économe en mémoire (CLI) que vous pouvez couper et coller en quelques minutes dans votre propre code et être opérationnel. Les commandes consistent en un nom suivi de plusieurs arguments. Il prend même en charge le retour arrière lorsque vous saisissez vos commandes.

Présentation rapide

Chaque croquis a une loop() une fonction. Le vôtre pourrait être aussi simple que celui ci-dessous. Il appelle deux routines dans un onglet séparé nommé CommandLine.h . Je vais vous guider à travers ces deux fichiers et vous serez opérationnel.

Boucle

Ce qu'il fait :  A chaque fois loop() l'exécute pour voir si nous avons une commande du port série, en appelant getCommandLineFromSerialPort() . La variable CommandLine est déclaré dans CommandLine.h mais stylistiquement, vous voudrez peut-être le déplacer vers l'onglet Boucle principal. Lorsqu'une commande complète est arrivée sur le port série et a été copiée dans le tampon de commandes :

        char   commandLine[COMMAND_BUFFER_LENGTH + 1] ; 

Puis boucle() appelle DoMyCommand() pour exécuter la commande appropriée.

Voyons maintenant ce qu'il y a dans CommandLine.h . Je dois préciser que j'ai mis tout le code dans CommandLine.h , car tout ce que vous avez à faire est de couper et coller ce code dans un nouvel onglet de votre IDE Arduino (assurez-vous de donner à l'onglet un nom qui se termine par ".h "). Ensuite, incluez ce fichier dans votre fichier principal, c'est-à-dire

 #include "CommandLine.h" 

Cela vous permet de mettre tout le code de la ligne de commande dans un seul onglet et de vous référer à ses routines ailleurs dans votre programme sans aucun code supplémentaire.

Recherche dans CommandLine.h

Le fichier CommandLine.h est inclus à la fin de cet article. Dans CommandLine.h , chaque ligne que vous devez modifier est marquée du commentaire, //Modifier ici . Le fichier comprend deux exemples de commandes add et sous et montre comment ils sont appelés depuis DoMyCommand .

Pour beaucoup d'entre vous, c'est tout ce dont vous aurez besoin. Passez simplement par CommandLine.h . Pour ceux qui voudraient un regard plus détaillé, continuez à lire.

Regarder plus en profondeur

Dans CommandLine.h nous incluons d'abord . Chaîne.h est une bibliothèque standard C . Si vous n'avez pas encore rencontré de bibliothèques C, effectuez une recherche rapide sur Internet pour "Le langage de programmation C". La bible C a été écrite il y a des années par Brian Kernigan et Dennis Ritchie et a été tenue à jour. La plupart des gens en possèdent un exemplaire, mais vous pouvez le trouver en ligne gratuitement.

Nous n'utiliserons que le strtok() routine (chaîne en jeton) de . Cette routine lit un jeton, c'est-à-dire un mot délimité par certains caractères (le deuxième paramètre de strtok ). Cela fonctionne comme ceci.

• Lorsque vous l'appelez pour la première fois, vous lui passez une chaîne ptr et il renverra le premier jeton

• Lors des appels suivants, (voici la glorieuse partie hack) passez-le NULL au lieu d'une chaîne ptr et il continuera là où il s'était arrêté avec la chaîne initiale, obtenant ainsi un jeton (environ un mot) à la fois.

Nous incluons également à partir duquel nous n'utilisons que atoi() pour la conversion ascii-entier. Ne vous inquiétez pas, le compilateur n'inclura que cette seule routine et non la bibliothèque entière, mais vous voudrez peut-être vérifier les autres routines de ces bibliothèques car elles sont utiles.

Ensuite, il y a une petite macro facultative que j'ai écrite appelée print2 :

#define print2(x,y) (Serial.print(x), Serial.println(y) 

Je veux toujours imprimer une étiquette et une chaîne. Vous l'utilisez comme ceci :

print2("myVar =", myVar); 

Si myVar est 25, cela s'imprimera dans la fenêtre série :

myVar =25 

CommandLine.h contient getCommandLineFromSerialPort() qui assemble une ligne de commande à partir du port série. Chaque fois qu'il est appelé, il lit à partir du port série et stocke l'entrée dans le tampon d'entrée global, CommandLine[] . Lorsqu'il atteint un retour caractère signifiant la fin de la commande il renvoie true .

Le tampon entièrement assemblé est maintenant passé à DoMyCommand() qui détermine quelle fonction l'utilisateur demande et l'appelle. Avec un grand nombre de commandes, vous pouvez obtenir une instruction if-the-else assez lourde.

Si vous disposez d'un nombre vraiment énorme de commandes, il existe de nombreuses façons d'accélérer les choses, comme l'adoption de ce qu'on appelle une fonction de hachage. Alternativement, vous pouvez créer un seul caractère pour les commandes, puis utiliser ce caractère comme étiquette d'une instruction switch-case. Je trouve que ni l'un ni l'autre n'est nécessaire très souvent. Un mot est beaucoup plus facile à retenir qu'un seul caractère et étant donné qu'il s'agit d'un Arduino, combien de commandes pouvez-vous vraiment avoir avant de manquer de place sur la puce ?

Ajouter et sous

Chaque fonction de commande est responsable de l'analyse de ses propres arguments. C'est un moyen simple de le faire et assez facile à modifier. Une alternative à cela est de lire tous les arguments immédiatement dans DoMyCommand . Vous pouvez mettre des arguments individuels dans un tableau global de chaînes argv[] .

Pour les besoins de cet exemple, j'ai défini deux commandes :add et sous . Les deux utilisent des arguments numériques mais j'ai inclus readWord (qui pourrait être appelé readStringToken ) pour retourner un mot. Vous pouvez également modifier ce readStringToken pour autoriser des chaînes telles que "ceci est une chaîne ". Considérez-le comme un exercice laissé au lecteur.

Le moyen le plus rapide de courir

Si vous avez un fichier de boucle principal comme indiqué ci-dessus, créez un nouvel onglet en utilisant le triangle pointant vers le bas à droite de votre fenêtre IDE Arduino et copiez CommandLine.h (ci-dessous) dans celui-ci, vous devriez pouvoir taper add et sous commandes.

À vous de jouer !

Code

• Interpréteur de ligne de commande simple pour Arduino

Interpréteur de ligne de commande simple pour ArduinoC/C++

/************************************************ ************************************ Comment utiliser CommandLine :Créez un croquis. Recherchez ci-dessous un exemple de configuration et de code de boucle principale, puis copiez-le et collez-le dans la nouvelle esquisse. Créez un nouvel onglet. (Utilisez le menu déroulant (petit triangle) à l'extrême droite de l'éditeur Arduino. Nommez l'onglet CommandLine.h Collez-y ce fichier. Test :téléchargez le croquis que vous venez de créer sur votre Arduino comme d'habitude et ouvrez la fenêtre série. Tapez ces commandes suivies de return :add 5, 10 subtract 10, 5 Regardez les commandes d'ajout et de soustraction incluses, puis écrivez la vôtre ! ********************* ******************************************************** ****** Voici ce qui se passe sous les couvertures************************************ ************************************** Interpréteur de ligne de commande simple et clair Ce fichier permettra vous devez taper des commandes dans la fenêtre série, comme ajouter 23 599 blink 5 playSong Yesterday à votre croquis exécuté sur l'Arduino et les exécuter.Note de mise en œuvre :cela utilisera des chaînes C par opposition à des objets de chaîne en partant du principe que si vous avez besoin d'une ligne de commande interpréteur, vous manquez probablement aussi d'espace et l'objet String a tendance à être peu gourmand en espace. 1) Les commandes de protocole simple sont des mots et des nombres séparés par des espaces ou des virgules Le premier mot est la commande, chaque mot supplémentaire est un argument "\n" termine chaque commande 2) Utilisation de la routine de la bibliothèque C strtok :Une commande est un mot séparé par des espaces ou des virgules. Un mot séparé par certains caractères (comme un espace ou une virgule) est appelé un jeton. Pour obtenir les jetons un par un, j'utilise le strtok de routage C lib (partie de C stdlib.h voir ci-dessous comment l'inclure). Cela fait partie de la bibliothèque de langage C  que vous pouvez rechercher en ligne. Fondamentalement, vous :1) passez une chaîne (et les délimiteurs que vous utilisez, c'est-à-dire espace et virgule) et il renverra le premier jeton de la chaîne 2) lors des appels suivants, passez-le NULL (au lieu de la chaîne ptr) et il continuer là où il s'est arrêté avec la chaîne initiale. J'ai écrit quelques routines d'aide de base :readNumber :utilise strtok et atoi (atoi :ascii to int, encore une fois une partie de C stdlib.h) pour renvoyer un entier. Notez que atoi renvoie un int et si vous utilisez des ints à 1 octet comme uint8_t, vous devrez obtenir le lowByte(). readWord :renvoie un ptr à un mot de texte 4) DoMyCommand :une liste de if-then-elses pour chaque commande. Vous pourriez en faire une instruction case si toutes les commandes étaient un seul caractère. Utiliser un mot est plus lisible. Pour les besoins de cet exemple, nous avons :Add Subtract nullCommand*//******************exemple de code de boucle principale ************* ************************* #include "CommandLine.h" void setup() { Serial.begin(115200); } boucle vide() { bool reçu =getCommandLineFromSerialPort(CommandLine); // Global CommandLine est défini dans CommandLine.h if (reçu) DoMyCommand(CommandLine); }****************************************************** ********************************* ///Nommez cet onglet :CommandLine.h#include  #include //cette macro suivante est bonne pour le débogage, par exemple print2("myVar=", myVar);#define print2(x,y) (Serial.print(x), Serial.println(y))#define CR '\r'#define LF '\n'#define BS '\b'#define NULLCHAR '\0'#define SPACE ' '#define COMMAND_BUFFER_LENGTH 25 //longueur du tampon série pour les commandes entrantes CommandLine[COMMAND_BUFFER_LENGTH + 1] ; //Lire les commandes dans ce tampon à partir de Serial. +1 de longueur pour une terminaison charconst char *delimiters =", \n"; //les commandes peuvent être séparées par un retour, un espace ou une virgule/****************************************** ******************************************************** ******************** vos noms de commande ici*/const char *addCommandToken ="add"; //Modifier hereconst char *subtractCommandToken ="sub"; //Modifier ici/************************************************ ******************************************************** ************** getCommandLineFromSerialPort() Renvoie la chaîne de la commande suivante. Les commandes sont délimitées par return" Gérer le caractère BackSpace Mettre tous les caractères en minuscules****************************************** ******************************************************** **********************/boolgetCommandLineFromSerialPort(char * commandLine){ static uint8_t charsRead =0 ; //remarque :COMAND_BUFFER_LENGTH doit contenir moins de 255 caractères // lire de manière asynchrone jusqu'à l'entrée de la commande complète while (Serial.available()) { char c =Serial.read(); switch (c) { case CR :// avoir probablement la commande complète dans le tampon maintenant, les commandes sont terminées par CR et/ou LS case LF :commandLine[charsRead] =NULLCHAR ; //null termine notre commande char array if (charsRead> 0) { charsRead =0 ; //charsRead est statique, il faut donc réinitialiser Serial.println(commandLine); return true ; } break ; case BS :// gérer le retour arrière dans l'entrée :mettre un espace dans le dernier caractère if (charsRead> 0) { // et ajuster commandLine et charsRead commandLine[--charsRead] =NULLCHAR ; Serial < La somme est =", résultat); } else { if (strcmp(ptrToCommandName, subtractCommandToken) ==0) { //Modifier ici result =subtractCommand(); //chaîne K&R.h p. 251 print2("> La différence est =", résultat); } else { nullCommand(ptrToCommandName); } }}