05/08/2016 OpenClassrooms 

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

Bienvenue sur OpenClassrooms ! En poursuivant votre navigation, vous acceptez l'utilisation de cookies. En savoir OK
plus

  
Accueil Cours Perfectionnez-vous dans la programmation Arduino Utiliser le moniteur série en entrée et sortie

Perfectionnez-vous dans la programmation Arduino

   20 heures
  Moyenne Licence   

 

UTILISER LE MONITEUR SÉRIE EN ENTRÉE ET SORTIE

Rappelez-vous, vous avez vu dans le cours d'initiation, la possibilité d'utiliser le moniteur série pour aㄊ橔icher 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

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

https://openclassrooms.com/courses/perfectionnez­vous­dans­la­programmation­arduino/utiliser­le­moniteur­serie­en­entree­et­sortie 1/10
05/08/2016 OpenClassrooms ­ Utiliser le moniteur série en entrée et sortie

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'aㄊ橔ichage (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 aㄊ橔iché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 aㄊ橔icheur (l'Arduino envoie des informations qui sont
traitées par votre ordinateur et aㄊ橔iché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 :
c_cpp
1 void setup() { 
2   Serial.begin(115200); 

https://openclassrooms.com/courses/perfectionnez­vous­dans­la­programmation­arduino/utiliser­le­moniteur­serie­en­entree­et­sortie 2/10
05/08/2016 OpenClassrooms ­ Utiliser le moniteur série en entrée et sortie
3 } 
4  
5 void loop() { 
6   Serial.println("test"); 
7 } 

Si vous téléversez le programme et ouvrez le moniteur, vous allez obtenir un aㄊ橔ichage 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'aㄊ橔ichage 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 aㄊ橔iché, 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.

https://openclassrooms.com/courses/perfectionnez­vous­dans­la­programmation­arduino/utiliser­le­moniteur­serie­en­entree­et­sortie 3/10
05/08/2016 OpenClassrooms ­ Utiliser le moniteur série en entrée et sortie

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 diㄊ橔icile 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 à 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 aㄊ橔ichage à point :

https://openclassrooms.com/courses/perfectionnez­vous­dans­la­programmation­arduino/utiliser­le­moniteur­serie­en­entree­et­sortie 4/10
05/08/2016 OpenClassrooms ­ Utiliser le moniteur série en entrée et sortie

Caractères aㄊ橔iché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 (chiㄊ橔res hexadécimaux) directement
dans la mémoire de l'ordinateur. Ces codes étaient le programme. Mais déjà, existaient les aㄊ橔ichages 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.

 Actuellement, nous ne voyons presque plus les pixels d'une lettre du fait de leur taille très réduite. Chaque lettre
peut donc être codée en ASCII, mais écrite sur un format comprenant bien plus que 7x5 pixels.

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 aㄊ橔icher un caractère.

A⸵㌱ichez 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”.
https://openclassrooms.com/courses/perfectionnez­vous­dans­la­programmation­arduino/utiliser­le­moniteur­serie­en­entree­et­sortie 5/10
05/08/2016 OpenClassrooms ­ Utiliser le moniteur série en entrée et sortie

Voici un petit programme à tester (attention de bien faire correspondre les bauds à 9600) :
c_cpp
1 void setup() { 
2   Serial.begin(9600); 
3   Serial.println(); 
4   Serial.println(65); 
5   Serial.println('A'); 
6   Serial.println(char(65)); 
7   Serial.println(int('A')); 
8 } 
9  
10 void loop() { 
11    
12 } 

qui vous donne en aㄊ橔ichage sur le moniteur :

65

65

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

Serial.println(65) : aㄊ橔iche le nombre 65, donc deux caractères (le 6 et le 5).

Serial.println('A') : aㄊ橔iche 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)) : aㄊ橔iche la lettre A. Grâce à l'instruction char()  on force le typage en caractère.
l'Arduino aㄊ橔iche donc un caractère grâce à son code.
Serial.println(int('A')) : aㄊ橔iche 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 aㄊ橔iche le tableau des codes ASCII et des caractères correspondants, entre les valeurs 32 et 127.
On aㄊ橔iche 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.

 A⸵㌱ichez 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

https://openclassrooms.com/courses/perfectionnez­vous­dans­la­programmation­arduino/utiliser­le­moniteur­serie­en­entree­et­sortie 6/10
05/08/2016 OpenClassrooms ­ Utiliser le moniteur série en entrée et sortie

10 Fin de ligne \n

13 retour chariot \r

On peut les aㄊ橔icher 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.

 La commande pour faire un retour à la ligne dépend des machines. Pour faire un retour à la ligne sur le moniteur,
vous devez utiliser le caractère de fin de ligne : Serial.print('\n');
Sur d'autres, il faudra lui joindre le caractère de retour de chariot : Serial.print('\r');

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

Essayez d'aㄊ橔icher 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...

A⸵㌱ichez 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 diㄊ橔érentes déclarations possibles d'une chaîne de caractères :

c_cpp
1 char chaine[15]; // déclare une chaîne de 14 caractères et une place pour le caractère null (14+1=15) 
2 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) 
3 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 
4 char chaine[]="Bonjour"; // déclare directement la chaîne. Elle contiendra 7 caractères plus le 
caractère null 
5 char chaine[8]="Bonjour"; // déclare explicitement la chaîne. On réserve la dernière place pour le 
caractère null 
6 char chaine[15]="Bonjour"; // déclare une chaîne de 7 caractères. Toutes les autres cases du tableau 
contiendront le caractère null 


Le caractère NULL , char(0)  ou '\0'  est un caractère qui signale que la chaine est finie. Il doit être
mis à la fin de chaque chaîne de caractère.
On utilise les guillemets simples pour définir un caractère et les guillemets doubles pour définir une chaîne.
La chaîne de caractère en anglais est appelée string.

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 suㄊ橔it donc de

https://openclassrooms.com/courses/perfectionnez­vous­dans­la­programmation­arduino/utiliser­le­moniteur­serie­en­entree­et­sortie 7/10
05/08/2016 OpenClassrooms ­ Utiliser le moniteur série en entrée et sortie

parcourir le tableau. Lorsqu'on rencontre le caractère NULL , on est au bout de la chaîne.

Voici un programme qui aㄊ橔iche la chaîne de caractère en séparant les lettres par une virgule :
c_cpp
1 char mot[]="Arduino"; // on initialise la chaîne de caractères 
2  
3 void setup() { 
4   Serial.begin(9600); // début communication série 
5   Serial.println(); // on saute une ligne 
6   int l=0; // variable de position dans la chaîne de caractère 
7   while (mot[l]){ // tant que la lettre n'est pas le caractère NULL 
8     Serial.print(mot[l]); // on écrit la lettre 
9     Serial.print(','); // on écrit une virgule 
10     l++; // on avance d'une position dans la chaîne 
11   } 
12 } 
13  
14 void loop() { 
15    
16   } 

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

 Si on connaît la taille exacte de la chaîne de caractères, on peut aussi utiliser une boucle for  pour parcourir le
tableau (on n'oublie pas qu'une chaîne de caractère est un tableau...).

Remplacez un caractère dans une chaîne

Là encore, c'est assez simple. Il suㄊ橔it 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 parcours la chaîne et remplace tous les espaces par des tirets :
c_cpp
1 char mot[]="Jean de la Fontaine"; // une chaîne de caractère avec des espaces 
2  
3 void setup() { 
4   Serial.begin(9600); // on initialise la communication série 
5   Serial.println(); // on saute une ligne 
6   int l=0; // variable pour parcourir la chaîne 
7   while (mot[l]){ // tant qu'on n'est pas au bout de la chaîne (caractère NULL) 
8     if (mot[l]==' ') // on teste si le caractère est un espace 
9       mot[l]='‐'; // si oui, on le remplace par un tiret 
10     l++; // on passe au caractère suivant 
11   } 
12   Serial.println(mot); // on écrit la chaîne résultante
13 } 
14  
15 void loop() { 
16    
17   }  

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.
https://openclassrooms.com/courses/perfectionnez­vous­dans­la­programmation­arduino/utiliser­le­moniteur­serie­en­entree­et­sortie 8/10
05/08/2016 OpenClassrooms ­ Utiliser le moniteur série en entrée et sortie

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 :

c_cpp
1 void setup() { 
2   Serial.begin(9600); //début de la communication série 
3 } 
4  
5 void loop() { 
6   while (Serial.available()) { // tant que des caractères sont en attente d'être lus 
7     char c = Serial.read(); // on lit le charactère 
8     Serial.print(c); // on l'écrit sur le moniteur 
9     delay(10); // petit temps de pause 
10   } 
11 } 

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

Le programme aㄊ橔iche 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 eㄊ橔et, car le moniteur va envoyer le caractère '\' et le caractère 'n' .

Voici maintenant un programme qui vous aㄊ橔iche le caractère et à côté le code ASCII qui correspond :
c_cpp
1 void setup() { 
2   Serial.begin(9600); // initialisation de la communication 
3 } 
4  
5 void loop() { 
6   while (Serial.available()) { // tant que des caractères sont en attente 
7     char c = Serial.read(); // on lit le caractère 
8     Serial.print(c); // on l'affiche 
9     Serial.print('\t'); // on affiche une tabulation 
10     Serial.println(int(c)); //on affiche le code correspondant 
11     delay(10); //petit temps de pause 
12   } 
13 } 

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).

 Les petits temps de pause servent à clarifier la communication. En eㄊ橔et, si on échange sans pause, il est possible
que certains caractères passent à la trappe lors de la réception.

En résumé


https://openclassrooms.com/courses/perfectionnez­vous­dans­la­programmation­arduino/utiliser­le­moniteur­serie­en­entree­et­sortie 9/10
05/08/2016 OpenClassrooms ­ Utiliser le moniteur série en entrée et sortie

Vous avez appris dans ce chapitre :

Que l'écriture est un moyen de code eㄊ橔icace 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ère est un tableau.
Que l'on peut parcourir une chaine de caractères. On peut aussi la modifier, en extraire des caractère 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 !

 J'ai terminé ce chapitre et je passe au suivant

 Quiz Codez et décodez des informations 

L'auteur
Jean-Noël Rousseau
Professeur des écoles passionné d'informatique et de
micro-robotique.

OpenClassrooms Professionnels En plus Suivez-nous

Qui sommes-nous ? Aㄊ橔iliation Créer un cours Le blog OpenClassrooms
Fonctionnement de nos coursEntreprises CourseLab
Recrutement Universités et écoles Conditions Générales d'Utilisation
     
Nous contacter

English Español

https://openclassrooms.com/courses/perfectionnez­vous­dans­la­programmation­arduino/utiliser­le­moniteur­serie­en­entree­et­sortie 10/10