• 20 hours
  • Medium

Free online content available in this course.

Certificate of achievement available at the end this course

Got it!

Last updated on 7/13/17

Utiliser le moniteur série en entrée et sortie

Log in or subscribe for free to enjoy all this course has to offer!

Rappelez-vous, vous avez vu dans le cours d'initiation, la possibilité d'utiliser le moniteur série pour afficher des données, des résultats ou une page de présentation.

Vous allez, dans ce chapitre, utiliser le moniteur dans l'autre sens, c'est-à-dire pour envoyer des données à l'Arduino.

Vous allez donc apprendre à créer des messages que votre carte pourra décoder et utiliser.

Ce chapitre est important, car finalement, à chaque fois que vous aurez à envoyer des données à votre carte (depuis votre ordinateur, depuis Internet, depuis un autre arduino...), vous utiliserez le même principe.

Voyons déjà les possibilités de notre moniteur série.

Le moniteur série pour envoyer des données

Lorsque vous téléchargez un programme sur votre carte Arduino qui est connectée à votre ordinateur, vous pouvez ouvrir le moniteur série avec l'icône de la loupe, pendant qu'il tourne.

icône d'ouverture du moniteur série
Icône d'ouverture du moniteur série

Observons un peu mieux notre moniteur série. Voici une capture d'écran (réalisée sous Mac) :

Le moniteur série
Le moniteur série

Les numéros en rouge correspondent aux zone suivantes :

  1. Le titre de la fenêtre correspond au port de connexion que vous utilisez pour communiquer avec l'Arduino.

  2. Vous avez une zone de saisie (dans laquelle on peut justement saisir des choses !).

  3. Vous voyez aussi un bouton "envoyer", qui sert à envoyer les choses saisies.

  4. La grande zone d'affichage (où viennent s'inscrire les informations envoyées par Serial.print()  ou  Serial.println().

  5. Une case à cocher pour arrêter le défilement des informations affichées.

  6. Un menu déroulant (et peut-être déroutant) qui vous laisse le choix entre quatre possibilités.

  7. Un menu déroulant qui vous permet de paramétrer les bauds, qui représentent la vitesse de transmission des données.

Jusqu'à maintenant, nous utilisions notre cher moniteur comme afficheur (l'Arduino envoie des informations qui sont traitées par votre ordinateur et affichées par le moniteur). Pour cela, vous deviez initialiser la communication dans le  setup()en utilisant la commande  Serial.begin(9600).

Bien, pour commencer, nous allons tester une autre valeur avec le code qui suit :

void setup() {
  Serial.begin(115200);
}

void loop() {
  Serial.println("test");
}

Si vous téléversez le programme et ouvrez le moniteur, vous allez obtenir un affichage assez "confus".

Que se passe-t-il ?

Et bien tout simplement, votre Arduino et votre ordinateur ne sont pas sur la même fréquence de transmission d'information. Du coup, la traduction ne peut pas se faire correctement !

Choisissez maintenant, sur le moniteur dans le menu déroulant (numéro 7 sur l'image), 115200 bauds. Vous voyez, qu'après une réinitialisation du programme, l'affichage se fait correctement.

Avant d'aller plus loin, il vous faut savoir deux ou trois petites choses sur ce fameux échange de données entre votre ordinateur et votre carte Arduino...

Des nombres pour chaque lettre

Tout d'abord, sachez que pour un ordinateur, une lettre n'existe pas. C'est juste une représentation graphique sur un écran (ou une imprimante) qui permet à l'être humain de comprendre le programme et de communiquer avec lui.

C'est ce que nous appelons une interface homme/machine. Alors l'interface est en fait l'ensemble des moyens qui sont à notre portée pour communiquer avec la machine.

Dans notre cas voici ce qui est en action :

  • Le clavier de votre ordinateur : il permet de transformer des contacts réalisés par des touches (boutons poussoirs) en codes qui sont envoyés à votre ordinateur (en fait les contacts sont d’abord transformés en tensions qui elles-mêmes seront traitées pour être codées). Chaque touche a donc finalement une sorte d'adresse.

  • L'écran de votre ordinateur : il vous permet, en temps plus ou moins réel, de "voir" ce que l'ordinateur est programmé pour vous montrer. Pour un traitement de texte, il vous montre ce que vous tapez, et ce que le programme proposera en rendu final. Un caractère affiché, est un allumage programmé de plusieurs pixels dans une forme que vous reconnaîtrez. Chaque pixel a une adresse mémoire dans votre ordinateur.

  • Le processeur, les pilotes et les cartes graphiques : l'ensemble permet à votre ordinateur de coder et décoder très rapidement ce qui se passe pendant que vous tapez au clavier. Il reçoit l'information du programme qui gère le clavier (le pilote) puis le programme en cours est informé que le clavier a une information, le programme traite cette information, informe le processeur, qui informe la carte graphique qui allume un certain nombre de pixels dans une position précise : une lettre.

 Ha ben oui, ça force le respect ! D'ailleurs, lorsque vous alimentez votre Arduino sans le connecter à l'ordinateur, vous n'avez aucun moyen de savoir ce qu'il fait ou de le programmer.

L'Arduino est un ordinateur de très petite taille, auquel il n'est attaché par défaut aucun écran et aucun clavier. Finalement, tout seul, l'Arduino ne comporte aucune interface homme/machine (ou presque, mais vous le comprendrez à la fin de cette partie ;)).

(Oui Lukas, ça marche aussi pour les femmes. Homme est à prendre au sens "humain")

Lorsque vous le connectez à l'ordinateur, là encore, il ne se passe rien (sauf un message parfois sur Windows). Il faut avoir démarré un programme spécifique, l'IDE par exemple, si l'on veut pouvoir communiquer avec lui.

Alors pour comprendre comment fonctionne le codage des lettres, il faut avoir quelques notions historiques...

Un peu d'histoire

Vers l’an 3000 avant JC (non Lukas, pas Jules César) l'homme invente l'écriture (pas d'un seul coup). À partir de ce moment, il sort de la préhistoire et entre dans l'histoire. Les formes et les styles d’écriture évoluent durant des millénaires. Elle devient peu à peu (avec la lecture) un moyen pour chacun d'acquérir la connaissance (et souvent le pouvoir).

Aujourd’hui, il est très difficile d’accéder à l’information qui nous entoure lorsque l’on ne sait ni lire ni écrire.

Donc notre écrit permet de fixer et de transmettre l'information.

La façon d'écrire a elle aussi évoluée. Déjà par les supports, les formes (en fonction des langues), mais surtout depuis la mécanisation de l'écrit. L'invention de l'imprimerie a permis dans une certaine mesure, de figer et de normer les lettres. Nous avons donc, en France, nos 26 lettres de l'alphabet que nous pouvons écrire en cursives (écriture à la main) ou en lettres d'imprimerie. Chacune existe sous deux formes : la majuscule et la minuscule.

L'imprimerie et l'écriture ont aussi de multiples codes nécessaires à la transmission d'une information correcte : parenthèses, guillemets, points, virgule... Donc toute une série de codes que nous avons l'habitude d'utiliser.

L'ensemble de ces codes représentent ce qu'on appelle une casse en typographie. C'était à l'époque de l'imprimerie manuelle, un grand tiroir où étaient rangées les lettres de même fonte (nous verrons ce que c'est plus loin). Les minuscules étant employées plus fréquemment, elle étaient en bas du tiroir (bas de casse) et les majuscules en haut (haut de casse).

Voici donc quelques informations sur le vocabulaire lié à l'imprimerie, qui est resté dans le langage informatique :

  • Le caractère est la forme de la lettre ou de la ponctuation qui va être imprimé.

  • La graisse est l'épaisseur du trait d'un caractère. C'est pour cela qu'on peut écrire en gras (trait plus épais).

  • Le style est la forme donnée à chaque caractère. Il s'agit d'une représentation qui est choisie (helvétique, comic sans ms...). Le caractère "a" n'aura pas la même forme en fonction du style.

  • Le corps est la taille de la lettre, donc sa hauteur et sa largeur (proportionnelle).

  • La variation qui permet de faire varier la lettre (italique, plus ou moins grasse, serif ou non, c'est-à-dire avec des excroissances aux extrémités).

  • La fonte correspond à un groupe ayant le même style, graisse et corps.

  • La police regroupe tous les caractères d'une même fonte, dont le style est coordonné.

Mais c'est quoi le rapport avec l'Arduino ?

Et bien après l'imprimerie, l'humain a inventé l'ordinateur (pas d'un seul coup non plus). L'ordinateur utilise des longues successions de 1 et de 0 (de courants haut et bas) pour fonctionner. Donc tout naturellement, l'humain a cherché à transformer son langage écrit en codes pour l'ordinateur. Son but était simple : pouvoir transformer facilement un processus (succession d'actions) en langage machine.

La lettre en pixels

Les premières machines (comme notre Arduino d'ailleurs) codaient les caractères sous 7 bits. C'est en fait une transposition du caractère sur un affichage à point :

Caractères affichés sur une matrice de 7x5
Caractères affichés sur une matrice de 7x5

Dans l'exemple de l'image, on voit bien qu'en fonction de l'allumage des pixels, on obtient une forme, un caractère.

 

Au tout début de la programmation, on programmait beaucoup en mettant des codes (chiffres hexadécimaux) directement dans la mémoire de l'ordinateur. Ces codes étaient le programme. Mais déjà, existaient les affichages sur écran. L'un des premiers standards de codage des caractères fut le code ASCII (American Standard Code for Information Interchange) proposé en 1971. Il code sous 7 bits et permet de coder 2^7=128 caractères.

Le code ASCII permet de faire correspondre un code à un caractère imprimable (à l'écran par exemple). Il existe maintenant des standards qui codent sous plus de 7 bits. Mais nous allons nous intéresser seulement au codage ASCII. Pourquoi ? Tout simplement parce que c'est celui utilisé par l'Arduino avec le moniteur.

Voici un lien vers le tableau des codes ASCII de l'Arduino.

On remarque deux choses :

  • Les 33 premiers codes ne sont pas imprimables. Ce sont des caractères de commande.

  • Il n'y a pas de lettres accentuées. C'est normal, le code ASCII est d'origine américaine, et la langue anglaise ne comporte pas d'accent.

Voyons maintenant comment faire pour afficher un caractère.

Affichez un caractère simple sur le moniteur

Nous voyons dans le tableau des codes ASCII dont je viens de vous donner le lien que la lettre “A” a le code “65”.

Voici un petit programme à tester (attention de bien faire correspondre les bauds à 9600) :

void setup() {
  Serial.begin(9600);
  Serial.println();
  Serial.println(65);
  Serial.println('A');
  Serial.println(char(65));
  Serial.println(int('A'));
}

void loop() {
  
}

qui vous donne en affichage sur le moniteur :

65

A

A

65

Si vous observez le programme, vous pouvez en déduire (j'espère) les points suivants :

  • Serial.println(65) : affiche le nombre 65, donc deux caractères (le 6 et le 5).

  • Serial.println('A') : affiche la lettre A. J'attire votre attention sur les guillemets simples. C'est ainsi qu'on indique à l'Arduino qu'il s'agit d'un type caractère.

  • Serial.println(char(65)) : affiche la lettre A. Grâce à l'instruction  char() on force le typage en caractère. l'Arduino affiche donc un caractère grâce à son code.

  • Serial.println(int('A')) : affiche 65. L'instruction  int() force le typage vers un nombre entier. On transforme donc le caractère en code ASCII.

Je vous propose un petit exercice :

Écrivez un programme qui affiche le tableau des codes ASCII et des caractères correspondants, entre les valeurs 32 et 127. On affiche d'abord le code, puis un espace, puis le caractère correspondant.

Je vous aide, une petite boucle sera la bienvenue ;) !

Rendez-vous dans la partie Annexes du cours pour voir la correction !

Finalement on peut déclarer un caractère de deux façons :  char caractere='A';  ou  char caractere=65;

C'est le typage char qui est important.

 Affichez des caractères spéciaux sur le moniteur

Il existe dans la table ASCII des caractères spéciaux que l'on utilise souvent :

Code ASCII

Fonction

Code lettre

0

NULL

\0

9

Tabulation

\t

10

Fin de ligne

\n

13

retour chariot

\r

On peut les afficher de deux façons :

  • soit en utilisant le code ASCII avec la fonction  char() :  Serial.println( char(9)) fera une tabulation.

  • soit en écrivant directement son code lettre :  Serial.println('\t") fera aussi une tabulation. Il faut utiliser l'anti-slash  \ avant la lettre.

 

Un autre exercice ? Ok (si, si Lukas, je vous ai entendu dire oui !)

Essayez d'afficher la table des caractères ASCII, mais cette fois en mettant une tabulation entre le code et le caractère, et en utilisant les caractères spéciaux pour faire un retour à la ligne (donc pas de  println()).

Découvrez la solution dans la partie Annexes du cours ! 

Voyons maintenant comment on écrit un mot...

Affichez un mot sur le moniteur

Il faut savoir qu'à chaque fois que vous écrivez un mot vers le moniteur, vous écrivez surtout des successions de caractères. Ces caractères sont stockés dans un tableau de type  char. Ce tableau est aussi appelé chaîne de caractères.

Voici différentes déclarations possibles d'une chaîne de caractères :

char chaine[15]; // déclare une chaîne de 14 caractères et une place pour le caractère null (14+1=15)
char chaine[8]={'B','o','n','j','o','u','r'}; //déclare une chaîne de 7 caractères, donne les valeurs en laissant la dernière comme null (7+1=8)
char chaine[8]={'B','o','n','j','o','u','r','\0'}; // déclare une chaîne de 8 caractères, donne les valeurs dont la valeur nulle à la fin
char chaine[]="Bonjour"; // déclare directement la chaîne. Elle contiendra 7 caractères plus le caractère null
char chaine[8]="Bonjour"; // déclare explicitement la chaîne. On réserve la dernière place pour le caractère null
char chaine[15]="Bonjour"; // déclare une chaîne de 7 caractères. Toutes les autres cases du tableau contiendront le caractère null

Du coup, lorsqu'on gère des chaînes de caractères, on gère en fait des tableaux de type  char. Ça ouvre beaucoup de possibilités !

Parcourez une chaîne de caractères

Pour parcourir une chaine de caractères (pour aller d'une lettre à l'autre, ou aller à une lettre précise) il suffit donc de parcourir le tableau. Lorsqu'on rencontre le caractère  NULL, on est au bout de la chaîne.

Voici un programme qui affiche la chaîne de caractère en séparant les lettres par une virgule :

char mot[]="Arduino"; // on initialise la chaîne de caractères

void setup() {
  Serial.begin(9600); // début communication série
  Serial.println(); // on saute une ligne
  int l=0; // variable de position dans la chaîne de caractère
  while (mot[l]){ // tant que la lettre n'est pas le caractère NULL
    Serial.print(mot[l]); // on écrit la lettre
    Serial.print(','); // on écrit une virgule
    l++; // on avance d'une position dans la chaîne
  }
}

void loop() {
  
  }

C'est là encore un exemple très pratique pour parcourir une chaîne de caractères. Il faut bien le comprendre.

Remplacez un caractère dans une chaîne

Là encore, c'est assez simple. Il suffit d'aller mettre une valeur dans la bonne case du tableau pour remplacer l'ancienne valeur. Si l'on veut remplacer toutes les valeurs de même type, il faut parcourir toute la chaîne.

Voici un programme qui parcourt la chaîne et remplace tous les espaces par des tirets :

char mot[]="Jean de la Fontaine"; // une chaîne de caractère avec des espaces

void setup() {
  Serial.begin(9600); // on initialise la communication série
  Serial.println(); // on saute une ligne
  int l=0; // variable pour parcourir la chaîne
  while (mot[l]){ // tant qu'on n'est pas au bout de la chaîne (caractère NULL)
    if (mot[l]==' ') // on teste si le caractère est un espace
      mot[l]='-'; // si oui, on le remplace par un tiret
    l++; // on passe au caractère suivant
  }
  Serial.println(mot); // on écrit la chaîne résultante
}

void loop() {
  
  } 

Vous pouvez observer que la chaîne peut être écrite directement avec  Serial.println(chaine). La fonction n'est possible que si le caractère  NULL est bien en fin de chaîne et si la variable est un tableau de  char.

Allez, un petit exercice pour se maintenir en forme...

Concevez un programme qui inverse les lettres d'un mot. Attention à la position du caractère  NULL , qui doit rester à la fin ! (pour débuter, on imagine que vous connaissez la longueur de la chaîne.)

Découvrez la correction dans la partie Annexes du cours ! 

Envoyez un message à l'Arduino

Vous avez maintenant assez de connaissances pour utiliser la fonction "envoyer" du moniteur série.

Nous venons de voir que les fonctions  Serial.print() et  Serial.println() envoient la chaîne caractère par caractère.

Et bien l'Arduino, de son côté, s'il doit lire un message, il le fera de la même façon. Un caractère à la fois.

Tout d'abord, il faut que l'Arduino soit à l'écoute d'une éventuelle arrivée d'information. On utilise pour ce faire la fonction  Serial.available();. Elle retourne le nombre de caractères en attente d'être reçus.

Si des caractères (type  char) sont en attente, on peut ensuite utiliser la fonction  Serial.read();  qui va lire le premier caractère de la chaîne en attente. On peut stocker ce caractère, l'écrire, le traiter.

Pour parcourir la chaîne entière, on peut utiliser une boucle  while  jusqu'à atteindre la fin de la chaîne.

Voici un programme qui va vous renvoyer ce que vous avez écrit :

void setup() {
  Serial.begin(9600); //début de la communication série
}

void loop() {
  while (Serial.available()) { // tant que des caractères sont en attente d'être lus
    char c = Serial.read(); // on lit le charactère
    Serial.print(c); // on l'écrit sur le moniteur
    delay(10); // petit temps de pause
  }
}

Ouvrez le moniteur et tapez un texte en haut, puis cliquez sur envoyer.

Le programme affiche votre mot (ou série de caractères). Recommencez. Vous observez que le mot suivant est collé au premier.

Tout simplement parce que lorsque vous cliquez sur "envoyer", le moniteur n'envoie pas de caractère de fin de ligne et de retour chariot. Modifiez le menu déroulant en bas et observez les résultats.

De même, l'envoi de  '\n'  n'a aucun effet, car le moniteur va envoyer le caractère  '\'  et le caractère  'n'.

Voici maintenant un programme qui vous affiche le caractère et à côté le code ASCII qui correspond :

void setup() {
  Serial.begin(9600); // initialisation de la communication
}

void loop() {
  while (Serial.available()) { // tant que des caractères sont en attente
    char c = Serial.read(); // on lit le caractère
    Serial.print(c); // on l'affiche
    Serial.print('\t'); // on affiche une tabulation
    Serial.println(int(c)); //on affiche le code correspondant
    delay(10); //petit temps de pause
  }
}

Là encore, essayez de modifier les paramètres du menu déroulant du moniteur. Vous observez l'apparition des codes 10 ou 13 qui correspondent aux caractères de fin de ligne (10) ou de retour chariot (13).

En résumé

Vous avez appris dans ce chapitre :

  • Que l'écriture est un moyen de code efficace pour transporter de l'information

  • Que l'ordinateur transforme chaque lettre en nombre

  • Qu'un caractère est un nombre, qu'une chaîne de caractères est un tableau.

  • Que l'on peut parcourir une chaine de caractères. On peut aussi la modifier, en extraire des caractères et leur donner du sens.

  • Comment recevoir un message avec l'Arduino lorsqu'il est émit depuis le moniteur.

Donc, vous savez maintenant recevoir un message avec l'Arduino. Il faudrait maintenant pouvoir en faire quelque chose...

(Oui Lukas, on fait un petit break !)

Ce sera donc l'objet du chapitre suivant !

Example of certificate of achievement
Example of certificate of achievement