(du moniteur série vers l’Arduino)
L’Arduino peut également recevoir des données depuis le moniteur série.
. Programme pour la réception d’un caractère par l’Arduino
Dans ce programme, on demande à l’utilisateur de saisir un caractère dans le moniteur série.
Une fois, la saisie effectuée, le nombre d’octets (caractères) disponible pour lecture dans la file d’attente du port série n’est plus nul (Serial.available() > 0), le caractère envoyé est alors lu à l’aide de la fonction ”read()” et stocké dans la variable ”c” définie comme étant un caractère.
La variable ”c” est alors affichée dans le moniteur série :
Remarques :
– L’instruction ”char c” déclare une variable, ”c” d’un octet de mémoire (8 bits) qui contient une valeur correspondant à un caractère. Les caractères uniques sont écrits entre des guillemets simples, comme ceci : ‘A’
– Les caractères sont stockés de la même façon que les nombres : à chaque caractère correspond une valeur numérique comprise entre 0 et 127 (code ASCII). Ceci signifie également qu’il est possible de faire des opérations sur les caractères, dans lesquelles la valeur ASCII du caractère est utilisée (par exemple ‘A’+1 a la valeur 66, car la valeur ASCII de la lettre capitale A est 65).
– Si la donnée envoyée contient plus d’un caractère (par exemple, le nombre « 123 »), la donnée est considérée comme une suite de 3 caractères qui seront affichés à la suite tant que la fonction ”Serial.available()” retournera une valeur non nulle.
– Dans le code ASCII, chaque caractère est codé sous 7 bits (valeur numérique comprise entre 0 et 127 en décimal) et les accents ne sont pas pris en charge.
C’est pourquoi, les messages affichés dans le moniteur série, par l’instruction ”Serial.print()”, sont envoyés sans les accents (”caractere” sans le ”è”), sinon voici ce qui est affiché :
– Le code ASCII (American Standard Code for Information Interchange) est la façon standard de coder un texte numériquement :
Le code ASCII ne contient pas de caractères accentués parce qu’il a été mis au point pour la langue anglaise. Pour coder ce type de caractère, il faut recourir à un autre code. Le code ASCII a donc été étendu à 8 bits (un octet) pour pouvoir coder plus de caractères (on parle d’ailleurs de code ASCII étendu…).
Ce code attribue les valeurs 0 à 255 aux lettres majuscules et minuscules, aux chiffres, aux marques de ponctuation et aux autres symboles :
– il est possible d’afficher des caractères avec accent dans le moniteur série en ajoutant une fonction aux programmes Arduino :
|
void PrintAccents(String TEXTE, boolean CR) { int CAR; for (byte I=0; I < TEXTE.length(); I++) { if (byte (TEXTE[I]) == 195) {CAR = int(TEXTE[++I]); switch (CAR) { case -68 : {Serial.print(char (252)); break;} // ü case -69 : {Serial.print(char (251)); break;} // û case -71 : {Serial.print(char (249)); break;} // ù case -74 : {Serial.print(char (246)); break;} // ö case -76 : {Serial.print(char (244)); break;} // ô case -81 : {Serial.print(char (239)); break;} // ï case -82 : {Serial.print(char (238)); break;} // î case -85 : {Serial.print(char (235)); break;} // ë case -86 : {Serial.print(char (234)); break;} // ê case -87 : {Serial.print(char (233)); break;} // é case -88 : {Serial.print(char (232)); break;} // è case -89 : {Serial.print(char (231)); break;} // ç case -92 : {Serial.print(char (228)); break;} // ä case -94 : {Serial.print(char (226)); break;} // â case -96 : {Serial.print(char (224)); break;} // à case -126 : {Serial.print(char (194)); break;} // Â case -128 : {Serial.print(char (192)); break;} // À case -108 : {Serial.print(char (212)); break;} // Ô case -114 : {Serial.print(char (206)); break;} // Î case -118 : {Serial.print(char (202)); break;} // Ê case -119 : {Serial.print(char (201)); break;} // É case -120 : {Serial.print(char (200)); break;} // È case -121 : {Serial.print(char (199)); break;}}} // Ç else Serial.print(TEXTE[I]);} if (CR) Serial.println(); } |
Et d’utiliser la fonction ”PrintAccents()” à la place de ”Serial.Print()” pour afficher un message comportant des accents dans le moniteur série.
En fait pour l’Arduino, les caractères, qu’ils soient accentués ou pas, sont codés sur 8 bits de manière signée, c’est-à-dire de -127 à 127 en décimale, alors que dans le code ASCII étendu, Les caractères accentués sont codés de 128 à 255.
La fonction ”PrintAccents()” va analyser chaque caractère de la chaine qui doit être envoyée dans le moniteur série, à l’aide d’une boucle ”for”. Si le caractère n’est pas accentué, il est affiché tel quel, sinon (” if (byte (TEXTE[I]) == 195) ”) en fonction de la valeur de sa conversion en nombre décimal (”CAR = int(TEXTE[++I]) ”), on affiche le caractère correspondant en utilisant son code en ASCII étendu (de 128 à 255).
Un retour à la ligne est effectué si la valeur de CR est égale à 1.
Exemple (programme ”Accents.ino”) :
Résultat dans le moniteur série :
Edit:
Avec les nouvelles version du logiciel Arduino IDE (à partir de 1.8.10), il est maintenant possible d’afficher des messages avec des accents dans le moniteur série:
Et la fonction « PrintAccents() » ne peut donc être utilisée qu’avec les versions précédentes du logiciel Arduino IDE (fonction testée avec la version 1.8.1).
Exemple d’application du programme de réception d’un caractère :
Avec notre circuit, support des exemples d’application, le programme nommé « LedRVB.ino » qui sera téléversé dans la mémoire de l’Arduino demande à l’utilisateur de saisir un caractère :
. ‘R’, ‘V’ ou ‘B’ pour allumer respectivement la DEL rouge, verte ou bleue
. ‘0’ pour éteindre les DELs
Le caractère envoyé est lu et l’action correspondante est effectuée. Le programme ne fait rien si le caractère lu n’est pas un des caractères attendus.
. Programme pour la réception d’une chaine de caractères par l’Arduino
Les chaines de caractères sont représentées sous la forme de tableau de variables de type ”char” se terminant par un caractère nul (code ASCII 0, à distinguer du ‘0‘ qui a le code ASCII 48) et permettant ainsi à la fonction ”Serial.print()” de savoir où se termine la chaîne de caractères
Exemples :
|
char Str1[15]; // Déclare un tableau de 15 caractères sans l’initialiser char Str2[8] = {‘a’, ‘r’, ‘d’, ‘u’, ‘i’, ‘n’, ‘o’}; //Déclare un tableau de caractères (avec un caractère supplémentaire non utilisé) et le compilateur ajoutera le caractère nul requis char Str3[8] = {‘a’, ‘r’, ‘d’, ‘u’, ‘i’, ‘n’, ‘o’, ‘ ’}; //Idem, mais en déclarant explicitement le caractère nul char Str4[ ] = « arduino »; // Déclare un tableau de caractères initialisé avec une chaîne de caractère constante entre guillemets doubles : le compilateur dimensionnera le tableau pour stocker la chaîne de caractère constante et le caractère nul terminal char Str5[8] = « arduino »; //Déclare un tableau de caractères initialisé avec une taille explicite et une chaîne de caractère constante (avec un caractère supplémentaire non utilisé) et le compilateur ajoutera le caractère nul requis |
La réception d’une chaine de caractères envoyée depuis le moniteur série, peut être considéré comme un envoi successif de caractères uniques que l’on peut stocker dans un tableau de caractères afin de reconstituer la chaine.
Le programme nommé ”Chaines.ino” ci-dessous effectue cette reconstitution :
Dans ce programme, il est demandé de saisir une chaine de caractères.
Tant que le nombre de caractères disponibles sur le port série est nul (Val==0), la mémoire tampon du port série est vérifiée (Val=Serial.available()), toutes les 200 ms, jusqu’à ce que tous les caractères de la chaine soient comptabilisés.
Ceux-ci sont alors lu un par un à travers une boucle « for » (tampon[i]=Serial.read()) et sont stockés dans un tableau de 20 caractères au maximum appelé « tampon » qui est ensuite affiché dans le moniteur série.
Puis la mémoire du port série est vidée et il est de nouveau demander de saisir une chaine de caractères.
Voici le résultat dans le moniteur série :
Une autre méthode pour recevoir une chaine de caractères depuis le moniteur série est d’utiliser la fonction ”readString()” qui lit les caractères contenus dans la mémoire tampon du port série et retourne une chaine de caractère. Au-delà, d’un certain temps (par défaut, 1 s), la fonction se termine. Le temps d’attente pour recevoir les données peut être réglé avec la fonction ”setTimeout()” en ms.
Par exemple, dans ce nouveau programme nommé ”ReadString.ino”, toujours avec le même circuit, on va maintenant demander à l’utilisateur d’envoyer un message. Si le message est ”ON”, la DEL rouge s’allume, et si c’est ”OFF”, la DEL rouge s’éteint.
Remarques :
– Contrairement aux caractères uniques (variable de type ”char”) qui sont écrit entre des guillemets simples (‘A’), les chaines de caractères sont écrites entre des doubles guillemets (”ABC”).
– L’instruction ” String msg=””; ”déclare une variable ”chaine de caractères” initialement vide.
– les objets String sont des instances de la classe String(), qui est intégrée au logiciel Arduino depuis la version 0019 et qui permet d’utiliser et de manipuler des chaînes de caractères.
Tous les exemples suivants sont des déclarations valides pour une nouvelle instance String :
|
String stringOne = ”Hello String”; // en utilisant une chaîne de caractères String stringOne = String(stringTwo + ” with more”); // concaténation d’un objet String et d’une chaîne String stringOne = String(13); // conversion d’un nombre en base 10 par défaut String stringOne = String(analogRead(0), DEC); // conversion d’une valeur int en base 10 |
