Perfectionnez-Vous Dans La Programmation Arduino: Codez Et Décodez Des Informations

05/08/2016 OpenClassrooms
Codez et décodez des informations
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 Codez et décodez des informations
Perfectionnez-vous dans la programmation Arduino

   20 heures
  Moyenne Licence   
 
CODEZ ET DÉCODEZ DES INFORMATIONS
Le chapitre précédent vous a montré comment fonctionne l'échange d'information par code de caractères.
Les chaînes de caractères ont la possibilité de transporter non seulement des mots qui ont du sens pour les humains, mais
aussi des instructions et des données. Car si l'on peut envoyer des lettres (codées grâce à des chi res) on peut donc tout à
fait envoyer des nombres et des instructions.
Vous allez donc dans ce chapitre apprendre à créer un code pour échanger avec votre Arduino.
Vous allez aussi programmer votre Arduino pour qu'il décode vos instructions.
Vous découvrirez l'objet String qui vous facilitera la vie pour manipuler des chaînes de caractères.
Enfin vous concevrez un programme qui pilote des LED grâce aux instructions que vous enverrez par le moniteur.
 Pour suivre ce chapitre, il vous faut prévoir 5 LED et 5 résistances 220Ω

Alors, commençons par cette notion de code...
Créez un code

Imaginons que vous souhaitiez donner un ordre à votre Arduino. Vous avez réalisé un montage avec 5 LED et vous voulez
qu'il allume sur commande celle que vous désirez.
Si vous écrivez dans le moniteur "Allume la LED numéro 3", il risque de ne rien se passer. Ben oui, puisque vous n'avez pas
dit à votre Arduino de lire ce qui vient du moniteur.
Imaginons que vous réparez ce problème et que vous envoyiez le même message. Il ne se passera rien de plus !
(Non Lukas, même si on rajoute "s'il te plaît")
https://openclassrooms.com/courses/perfectionnezvousdanslaprogrammationarduino/codezetdecodezdesinformations 1/12
05/08/2016 OpenClassrooms Codez et décodez des informations
En e et, les mots ne veulent rien dire pour votre Arduino. Je vous rappelle que ce ne sont que des successions de codes
numériques.
Il va donc falloir apprendre à votre Arduino à décoder cette phrase !
C'est là qu'il faut réfléchir. Car si vous souhaitez un programme assez complet vous risquez d'avoir des instructions du
genre : "Allume la LED 5", "Éteins la LED 3 et la LED 5", "Fais clignoter la LED 2 et la LED 4"...
Ce sont des phrases adaptées au langage humain, mais pas adaptées à votre Arduino. Il faut simplifier tout ça !
 On pourrait créer un programme qui analyse des phrases humaines pour en tirer le sens et agir correctement. C'est
le cas des moteurs de recherche comme Google par exemple. Mais dans notre cas ce serait vraiment utiliser un
marteau pour écraser une mouche !
Choisir des mots-clés
Nous allons donc d'abord réfléchir aux instructions que nous voulons créer.
Allumer,
Éteindre,
Clignoter.
C'est déjà pas mal. On peut tout à fait simplifier ces ordres avec trois lettres : a (allumer), e (éteindre) et c (clignoter).
Il nous faut maintenant des paramètres, c'est-à-dire des informations précises sur ce que l'on veut faire. Dans notre cas, il
serait intéressant de pouvoir choisir quelle LED s'allume, quelle LED clignote et quelle LED s'éteint.
On peut imaginer un code du genre "c2" qui voudrait dire "fait clignoter la LED 2"
Éventuellement, on peut ajouter un truc du genre " c23" qui voudrait dire "fait clignoter la diode 2 et 3". C'est tout à fait
possible, et on est dans un échange d'information assez simple.
Enfin on peut imaginer plus compliqué : un code comme "c23e4a15" qui voudrait dire " fait clignoter la LED 2 et la LED 3,
éteins la LED 4 et allume la LED 1 et la LED 5".
En réfléchissant ainsi, nous venons de créer un code qui pourra être envoyé à l'Arduino. On imagine déjà un peu une sorte
de boucle qui va lire chaque caractère du code et qui va ensuite agir en fonction de la demande. Mais en même temps
qu'on imagine, on se pose quand même quelques questions :
Comment stocker l'information de l'ordre (allumer, éteindre, clignoter) pendant qu'on lit les numéros de diodes ?
Comment passer d'un ordre à un autre ?
Comment gérer les clignotements des diodes ?
Et là encore, il faut réfléchir. Et la ruse est là ! Il ne faut pas tout de suite réfléchir pour résoudre ces questions. Il faut avant
réfléchir pour savoir si notre code ne peut pas être amélioré. Une idée ?
(Oui Cunégonde ! Ça me paraît bien plus simple !)
Plutôt que de coder des instructions, on va coder directement l'état des diodes ! Ce qui donne un code du genre :
"accea" qui correspondrait à notre "c23e4a15". La première lettre correspond à l'état de la première diode. La seconde
lettre à l'état de la seconde... c'est un code par position. On garde l'idée des lettres, mais on simplifie le message.
 Pourquoi toute cette démonstration ?

Tout simplement pour vous montrer qu'il n'y a pas qu'une façon de coder des données. Je dirais que le bon code est celui
qui va vous servir le mieux. Il existe des standards de codage de données, nous en verrons quelques un plus loin dans ce
cours. Mais ils sont fait pour des machines puissantes, et pour un nombre d'instruction important.
Dans notre cas (faire s'allumer, s'éteindre ou clignoter des LED sur commande) ces codages complexes n'ont pas d'intérêt
(à part celui de s'entraîner à les manipuler).
Nous avons donc maintenant notre système de codage, voyons ce que l'Arduino peut en faire !
Décodez un train d'informations

L'Arduino va recevoir ce code par le port série (port USB dans notre cas). La fonction Serial.available() va lui
indiquer que des données sont en attente.
Il va pouvoir lire ces données pour les utiliser. Mais il faut faire attention à ne pas tomber dans certains pièges...
Décodez la bonne quantité d'informations
Imaginons que par mégarde, nous ayons envoyé le code deux fois (pas simple avec le moniteur, mais ça pourra arriver dans
d'autres cas), ou que le code envoyé n'aie pas été complètement capté. Il nous faut prévoir un moyen de vérifier que notre
carte Arduino a bien reçu le bon code.
La première chose à faire est de demander à la carte Arduino de lire uniquement les informations dont elle a besoin, soit 5
lettres dans notre cas. Le reste éventuel, on ne l'utilisera pas dans notre programme (on le lira pour vider la mémoire
d'attente, mais on ne le stockera pas).
On peut ensuite prévoir un moyen de vérifier que les données envoyées ont bien été reçues. Un moyen simple est de définir
une valeur pour chaque instruction, d'en faire la somme et de vérifier que cette somme correspond à celle envoyée.
Exemple : si a vaut 1, e vaut 2 et c vaut 4. Le code "accea" vaudrait 1+4+4+2+1=12. Si nous assignons ces chi res à ces lettres
dans notre code, il su ira de vérifier que le code reçu par l’Arduino vaut bien 12.
 Il est bien sûr possible d'obtenir 12 avec d'autres combinaisons. Il s'agit ici d'un exemple de vérification. Vous êtes
libres de créer celui qui vous conviendra, ou de ne pas en créer tout simplement.
Dans notre cas, nous allons décider ne ne pas créer de vérification, car les conséquences d'une erreur restent sans
importance. Plus l'erreur est grave de conséquence, plus il est important de vérifier l'intégrité des données échangées. Par
exemple, dans le cadre d'un échange d'une clé électronique d'accès, il est primordial de vérifier que la réception
correspond à l'envoi (avant de vérifier si la clé est correcte).
Voyons donc le programme qui reçoit les données du moniteur série et les transforme en code de vérification :
c_cpp
1 char reception[5]; //tableau pour la réception des données (5 valeurs)
2
3 void setup() {
4 Serial.begin(9600); //on initialise la communication série
5 }
6
7 void loop() {
8 while (Serial.available()) { //tant que des données sont en attente
9 for (int p=0;p<5;p++){ //on en lit 5
10 char c=Serial.read(); // lecture
11 reception[p]=c; //écriture dans le tableau
12 delay(10); //petite attente
13 }
14 while (Serial.available()) //s'il reste des données
15 Serial.read(); //on les lit sans les stocker
16 decodage(reception); // on appelle la fonction de décodage
17 }
18 }
19
20 //fonction pour décoder la réception
21 void decodage(char c[5]){
22 for (int p=0;p<5;p++){ //on parcourt le tableau
23 Serial.print("LED "); //on écrit le mot LED
24 Serial.print(p+1); //on écrit le numéro de la LED (position dans taleau +1)
25 Serial.print(" "); //on fait un espace
26 if (c[p]=='a') // on teste si le code est 'a'
27 Serial.println("allumee"); //si oui on écrit "allumee"
28 else if (c[p]=='e') // sinon on teste si le code est 'e'
29 Serial.println("eteinte"); //si oui on écrite "éteinte"
30 else if (c[p]=='c') //sinon on teste si le code est 'c'
31 Serial.println("clignote"); //si oui on écrit "clignote'"
32 else //sinon c'est que ça ne correspond à rien
33 Serial.println("erreur de code"); // on inscrit donc "erreur de code"
34 }
35 }
36
Vous remarquerez que dans la définition de la fonction, j'indique que l'on attend en paramètre un tableau de taille 5
contenant des variables de type char .
L'objet String

L'objet String (chaîne de caractères) est un objet existant par défaut dans la boîte à outils de l’IDE d’Arduino. Il permet
de manipuler les chaînes de caractères de façon plus naturelle et intuitive, sans forcément entrer dans les détails de la
manipulation de chaîne comme nous l'avons vu précédemment.
En gros, avec un tableau de caractères, vous devez vous-même créer toutes les fonctions dont vous avez besoin (mise en
majuscule ou en minuscule, tri des lettres, remplacement d'une lettre...)
Mais avec un objet String , vous créez une chaîne de caractère (elle est contenue dans l'objet), mais vous lui attachez
aussi toutes les fonctions pour la manipuler (car elles font partie de l'objet). C'est tout le principe des langages "objets"
(comme par exemple objectiveC, C++, Java...). Du coup, pas besoin de créer des fonctions, il su it d'utiliser celles de
l'objet.
Donc, chaque objet String, contient sa chaine de caractères et les fonctions pour la manipuler.
 Les principes du langage objets :

L'objet créé dépend d'une famille générale lié à ce type d'objet (ici, un objet String dépendra de la
famille String ).
L'objet contient des fonctions qui lui sont propres et qui lui permettent de transformer certaines de ses
variables (ceci n'est pas visible par l'utilisateur de l'objet).
L'objet contient des fonctions qui sont accessibles par l'utilisateur de l'objet afin de pouvoir échanger des
informations avec lui (lui demander de modifier une valeur, de renvoyer une information, de réaliser une
action précise...).
 Certains langages ne sont pas orientés objet (le langage c par exemple) alors que d'autres permettent la création et
la manipulation d'objets (le C++, l'objective C, le Java). Actuellement la programmation orientée objet est un
incontournable. C'est une autre façon de programmer et de construire son code. Elle permet une modélisation
facilitée des résultats attendus. Suivez un cours sur Java pour vous donner une petite idées
Le langage Arduino n'est pas un langage orienté objet, mais il utilise les possibilités des bibliothèques qui elles,
sont développées en C++. C'est très avantageux !
Voici la page du site o iciel de l'Arduino qui traite de l'objet String. Nous ne verrons pas ici toutes ses possibilités, donc
n'hésitez pas à y jeter un œil !
Alors pour pouvoir utiliser les fonctionnalités de l'objet String , nous devons tout d'abord en créer un. On utilise la
même méthode que pour déclarer un type de variable mais dans le cas d'un objet, on appelle cela un constructeur (on
construit un objet de la famille String en lui donnant une personnalité en quelque sorte) :
String maChaine="Ceci est une chaîne de caractères";
On peut ajouter deux chaînes ensembles pour créer une nouvelle chaîne :
String longueChaine=String(maChaine + " avec une phrase ajoutée !");
On remarque que le fait d'écrire String(quelqueChose); transforme le "quelqueChose" en format String . On peut
donc transformer un nombre (ou le résultat d'une lecture sur un pin analogique) en objet String . Par exemple, dans
l'instruction :
String chaineNombre=String(123); la variable chaineNombre contiendra un tableau de 4 caractères : '1', '2', '3'
et '\0'.
 Une fois transformé en chaîne de caractères, un nombre n'est plus un nombre significatif, mais une chaîne de
caractères. Pour l'utiliser en nombre, il faut le retransformer !
Mais l'intérêt de l'objet String ne s'arrête pas là ! On peut, grâce à lui manipuler les chaînes plus facilement !
Il existe tout plein de petites fonctions utiles pour nos besoins de décodage dont voici quelques exemples avec ce
programme commenté :
c_cpp
1 void setup() {
2 Serial.begin(9600);
3 //on crée une chaîne avec des espaces, des majuscules et des minuscules
4 String maChaine=" Bonjour le monde Actuel ! \n\r";
5 String resultat=""; //on crée une chaîne qui va contenir les résultats
6 Serial.println(); //saute une ligne
7
8 resultat=maChaine;//copie maChaine dans resultat
9 resultat.toLowerCase(); //fonction qui passe tout en minuscules
10 Serial.println(resultat); //affiche le résultat
11
12 resultat=maChaine;//copie maChaine dans resultat
13 resultat.toUpperCase(); //fonction qui passe tout en majuscules
14 Serial.println(resultat); //affiche le résultat
15
16 resultat=maChaine; //copie maChaine dans resultat
17 resultat.trim(); //fonction qui enlève tous les espaces superflus en début et fin de
chaîne(caractères 9, 10,11, 12, 13 et 32)
18 Serial.println(resultat);
19
20 int taille=maChaine.length(); //fonction qui renvoie le nombre de caractères de la chaîne dans
l'objet String
21 Serial.println(taille);
22
23 }
24
25 void loop() {
26 }
Les 4 fonctions présentées dans ce code, toLowerCase() , toUpperCase() , trim() et length() , sont très
utiles pour "nettoyer" une chaîne reçue par l'Arduino. En e et, si l'utilisateur envoie des espaces inutiles en début ou fin de
chaîne, s'il est en majuscules alors qu'on souhaite des minuscules (ou l'inverse) ou tout simplement si l'on souhaite
e ectuer une boucle sur la longueur de la chaîne, avec ces fonctions, on peut réaliser ce qui nous convient.
 Il faut savoir que la bibliothèque Serial utilise l'objet String , c'est la raison pour laquelle on peut a icher le
contenu de ces objets directement avec les commandes Serial.print() et Serial.println() .
Il y a trois autres fonctions à connaître qui sont utiles pour analyser un train d'informations :
maChaine.startsWith("exemple"); qui teste si l'objet String commence par les caractères de la chaîne
entre parenthèses (ici "exemple") et renvoie 1 si oui et 0 si non.
maChaine.endsWith("exemple"); qui teste si l'objet String se termine par les caractères de la chaîne
entre parenthèses.
maChaine.substring(début,fin); qui renvoie la chaîne de caractères (en objet String ) qui se trouve
entre la position "début" et "fin" de la chaîne. "fin" peut être omis, dans ce cas, la fonction renvoie tout le reste de la
chaîne depuis la position "début".
Avec toutes ces fonctions, nous avons largement de quoi analyser une chaîne complexe pour créer les actions voulues.
Nous le verrons d'ailleurs dans le chapitre sur l'Arduino connecté au réseau. Pour le moment, revenons à notre programme
de clignotement !
Voici comment utiliser l'objet String pour analyser notre code sur 5 caractères :
c_cpp
1 String reception = ""; //création de l'objet String reception
2
3 void setup() {
4 Serial.begin(9600); //on initialise la communication série
5 }
6
7 void loop() {
8 if (Serial.available()) {
10 char c = Serial.read(); // l’Arduino lit le caractère
11 reception += String(c); //et l’ajoute à l’objet reception
13 }
14 reception.trim(); //on enlève le superflu en début et fin de chaine
15 reception = reception.substring(0, 5); // ne prend que les caractère de 0 à 4 (soit 5 caractères)
16 decodage(reception); // on appelle la fonction de décodage
17 reception = "";
18 }
19 }
20 //fonction pour décoder la réception
21 void decodage(String s) {
22 Serial.println("* Etat des LED *");//titre
23 for (int p = 0; p < 5; p++) { //on parcourt le tableau
24 Serial.print("LED "); //on écrit le mot LED
25 Serial.print(p + 1); //on écrit le numéro de la LED (position dans taleau +1)
26 Serial.print(" "); //on fait un espace
27 // on utilise la fonction switch qui fonctionne aussi avec des caractères (puisque ce sont des
nombres !)
28 switch (s.charAt(p)) { // fonction string.charAt(pos) renvoie le caractère à la position "pos" de
l'objet String
29 case 'a':// on teste si le code est 'a'
30 Serial.println("allumee"); //si oui on écrit "allumee"
31 break;
32 case 'e': // sinon on teste si le code est 'e'
33 Serial.println("eteinte"); //si oui on écrit "éteinte"
34 break;
35 case 'c': //sinon on teste si le code est 'c'
36 Serial.println("clignote"); //si oui on écrit "clignote'"
37 break;
38 default://sinon c'est que ça ne correspond à rien
39 Serial.println("erreur de code"); // on inscrit donc "erreur de code"
40 }
41 }
42 Serial.println();// saut de ligne
43 }
44
J'ai utilisé la fonction switch que nous avions vue dans le cours d'initiation (pour vous la remettre un peu en mémoire). Elle
fonctionne ici aussi car le caractère 'a' est en fait un nombre entier.
Vous remarquerez dans le switch() une nouvelle fonction de l'objet String : maChaine.charAt(p); qui renvoie le
caractère (type char) situé à la position p de la chaîne de l'objet String maChaine .
Bon, nous avons tout ce qu'il faut maintenant. Voyons comment finir ce programme de pilotage de LED.
Pilotez des LED avec un programme de codage/décodage

Nous savons récupérer les informations du moniteur et les trier pour utilisation. Bien. Mais il nous faut maintenant réfléchir
à une structure correcte pour notre programme. Faisons donc un petit point :
Le montage des LED ne pose pas de problème particulier. Il nous faudra juste correctement repérer chaque pin.
Allumer ou éteindre une LED n'est pas compliqué.
Faire clignoter une LED et pas les autres va nous demander de ruser un peu. Il va nous falloir utiliser la gestion du
temps (en créant des timers simples). Pour débuter, le temps de clignotement sera identique pour chaque LED.
Le montage
Vous êtes normalement rodés pour monter 5 LED en ligne avec les résistances qui vont bien (on prendra du 220Ω). Je vous
propose d'utiliser les pins de 2 à 6. La LED attachée au pin 2 sera la LED numéro 1, celle du pin 3, la LED numéro 2...
Nous utiliserons un tableau pour stocker les numéros des pins.
 Lorsqu'on utilise le port série de l'Arduino (ce qui sera notre cas ici, puisqu'on va communiquer grâce à lui) il faut
impérativement laisser libres les pin 0 et 1 car ils servent pour cette communication.
 Si vous ne savez pas réaliser ce montage, je vous propose de retourner voir le cours d'initiation sur les LED, il
comporte toutes les informations et schémas nécessaires.
Mais comme je suis gentil, je vous donne un schéma électrique :
5 LED attachées au pins 2 à 6
Nous connecterons les LED en reliant la patte + de la LED au port de sortie de l'Arduino. Chaque port alimentera donc une
LED. Là encore, vu notre montage, l'Arduino supportera la charge.
Il ne faut pas oublier de bien définir chaque port en mode OUTPUT, et on les initialisera tous à LOW.
Le programme de base
Pour plus de clarté, nous allons créer une fonction par étape du programme. Il nous faut donc définir les étapes du
programme.
1. Lecture et traduction des données envoyées à l’Arduino, et mise à jour d’un tableau de comportement (c'est-à-dire si
les LED sont allumées, éteintes ou clignotantes)
2. Évaluation du temps écoulé et changement éventuel du tableau d'état des LED en fonction du tableau de
comportement (c'est à dire leur état réel à l'instant donné : allumée ou éteinte)
3. Allumage des LED en fonction du tableau d'état.
Ces trois fonctions ne nécessitent pas de paramètre.
Vous remarquez que je décide de créer deux tableaux distincts :
Le tableau des comportements des LED : il va stocker si la LED doit s'allumer, s'éteindre ou clignoter. Comme il y a
trois valeurs possibles, on créera un tableau de variables de type char
Le tableau des états des LED : il va stocker si la LED, à un instant donné, est allumée ou éteinte. Ce tableau changera
en fonction du tableau des comportements et du temps qui s'écoule (une LED clignotante passe de allumée à
éteinte à chaque écoulement du temps défini). Comme il n'y a que deux valeurs possibles, on créera un tableau de
booléens.
Il nous faut aussi une variable globale de stockage du temps et une variable qui définit le temps de clignotement.
Voici donc le corps du programme :

c_cpp
1 int pins[5] = {2, 3, 4, 5, 6}; //tableau qui stocke les pins des LED
2 char comportements[5] = {0, 0, 0, 0, 0}; //tableau des comportements. 0 pour éteint, 1 pour allumé, 2
pour clignotant
3 boolean etats[5] = {0, 0, 0, 0, 0}; // tableau des états. 0 pour éteint, 1 pour allumé
4 unsigned long tempsDepart; // variable pour stocker le temps à un instant donné
5 int duree = 200; // variable pour stocker la durée de clignotement en ms
6
7 void setup() {
8 Serial.begin (9600);
9 // initialisation des LED et mise à LOW
10 for (int l = 0; l < 5; l++) {
11 pinMode(pins[l], OUTPUT);
12 digitalWrite(pins[l], LOW);
13 }
14 //titre de présentation (c'est toujours plus sympa !)
15 Serial.println("******************");
16 Serial.println("* Gestion de LED *");
17 Serial.println("******************");
18 Serial.println("> start");//message de début de programme
19 tempsDepart = millis(); //initialisation du temps de départ sur le temps actuel
20 }
21
22 void loop() {
23 decodage(); //appel de la fonction de décodage
24 timer(); // appel de la fonction de gestion du temps
25 allumage(); // appel de la fonction d'allumage des LED
26 }
27
28 //‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐fonctions
29 void decodage(){
30 if (Serial.available()){ // teste si il reste des données en attente
31 //code pour le décodage
32 //la mise à jour du tableau des comportements
33 //la mise à jour du tableau des états
34 //et l'affichage sur le moniteur pour contrôle
35 }
36 }
37
38 void timer(){
39 unsigned long tempsActuel=millis();
40 if (tempsActuel‐tempsDepart>=duree){ //teste si le temps est écoulé
41 //code pour modifier le tableau d'état des LED
42 //pour chaque LED qui a un comportement clignotant
43 }
44 }
45
46 void allumage(){
47 // code pour allumer chaque LED
48 // en fonction du tableau d'état des LED
49 }
50
Vous avez tout ce qu'il vous faut pour finir ce programme. Il est important de réfléchir seul et d'essayer d'aller au bout en
obtenant le résultat.
Rassurez-vous, je vais vous donner la correction !
(Cunégonde ne soyez pas égocentrée ! Même si vous pensez ne pas en avoir besoin, jetez-y tout de même un œil une fois
votre programme conçu...)
Correction
c_cpp
1 int pins[5] = {2, 3, 4, 5, 6}; //tableau qui stocke les pins des LED
2 char comportements[5] = {0, 0, 0, 0, 0}; //tableau des comportements. 0 pour éteint, 1 pour allumé, 2
pour clignotant
3 boolean etats[5] = {0, 0, 0, 0, 0}; // tableau des états. 0 pour éteint, 1 pour allumé
4 unsigned long tempsDepart; // variable pour stocker le temps à un instant donné
5 int duree = 200; // variable pour stocker la durée de clignotement en ms
6
7 void setup() {
8 Serial.begin (9600); // initialisation de la communication série
9 // initialisation des LED et mise à LOW
10 for (int l = 0; l < 5; l++) {
11 pinMode(pins[l], OUTPUT);
12 digitalWrite(pins[l], LOW);
13 }
14 //titre de présentation (c'est toujours plus sympa !)
15 Serial.println("******************");
16 Serial.println("* Gestion de LED *");
17 Serial.println("******************");
18 Serial.println("> start");//message de début de programme
19 tempsDepart = millis(); //initialisation du temps de départ sur le temps actuel
20 }
21
22 void loop() {
23 decodage(); //appel de la fonction de décodage
24 timer(); // appel de la fonction de gestion du temps
25 allumage(); // appel de la fonction d'allumage des LED
26 }
27
28 //‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐fonctions
29 void decodage() {
30 if (Serial.available()) {// teste s'il reste des données en attente
31 String reception = "";
33 char c = Serial.read(); // lecture
34 reception += String(c); //on ajoute à l'objet reception
36 }
37 reception.trim(); //on enlève le superflu en début et fin de chaîne
38 reception = reception.substring(0, 5); // ne prend que les caractères de 0 à 4 (soit 5 caractères)
39 Serial.print ("> Etat : ");
40 //boucle de test par caractère
41 for (int c = 0; c < 5; c++) {
42 switch (reception.charAt(c)) {
43 case 'a':
44 Serial.print("\tON");
45 comportements[c] = 1; //mise à jour du tableau des comportements
46 break;
47 case 'e':
48 Serial.print("\tOFF");
50 break;
51 case 'c':
52 Serial.print("\tCLI");
54 break;
55 default :
56 comportements[c] = 0; //mise à jour du tableau des comportements par défaut à 0
57 Serial.print("\t???");
58 }
59 }
60 Serial.println(); // saut de ligne
61 // boucle de mise à jour du tableau des états en fonction du tableau des comportements
62 for (int l = 0; l < 5; l++) {
63 if (!comportements[l]) {
64 etats[l] = 0;
65 }
66 else {
67 etats[l] = 1; // on allume aussi les lED clignotantes
68 }
69 }
70 }
71 }
72 void timer() {
73 unsigned long tempsActuel = millis(); //récupération du temps Arduino
74 if (tempsActuel ‐ tempsDepart >= duree) { //test si temps écoulé
75 for (int l = 0; l < 5; l++) {
76 if (comportements[l] == 2) { //test si comportement clignotant
77 etats[l] = !etats[l]; //passe de 0 à 1 ou de 1 à 0
78 }
79 }
80 tempsDepart = tempsActuel; //initialisation du temps de départ
81 }
82 }
83
84 void allumage() {
85 for (int l = 0; l < 5; l++) {
86 digitalWrite(pins[l], etats[l]); //allumage des LED en fonction du tableau des Etats
87 }
88 }
89
Un programme de ce type peut permettre de piloter des LED, mais aussi des moteurs, des servos. À vous de l'adapter à vos
projets. Nous en verrons d'autres exemples plus loin dans ce cours.
Évolutions possibles
Si vous souhaitez vous entraîner un peu plus à décoder des informations, rien ne vous empêche de complexifier ce
programme. Voici quelques idées intéressantes (de mon point de vue ):
Ajouter un code possible pour faire varier la vitesse de clignotement depuis le moniteur.
Faire varier la vitesse de clignotement grâce à un potentiomètre.
Préparer des séquences d'allumages (de droite à gauche, de gauche à droite, tout clignote, on allume une, puis
deux, puis trois...) qui peuvent être appelées depuis le moniteur par un codage (tout en gardant la possibilité de
commander chaque diode).
Créer une version du jeu MOTUS à 5 lettres (l'Arduino choisit un mot au hasard dans un tableau, vous proposez un
mot de 5 lettres et les diodes s'allument si une lettre est au bon endroit, s'éteint si elle n'existe pas dans le mot et
clignote si elle n'est pas placée correctement). C'est un gros boulot, mais très enrichissant !
En résumé

Vous venez de voir dans ce chapitre :
Comment créer un code de communication entre vous (l'humain) et l'Arduino (la machine).
Comment récupérer ce code pour piloter l'Arduino, en allumant de LED.
Comment utiliser des fonctions de l'objet String() qui permettent de traiter des chaînes de caractères.
Je crois que vous avez avec tout ceci de bons bagages pour aller plus loin. Nous allons maintenant voir d'autres sortes
d'interfaces homme/machine qui n'utilisent pas l'ordinateur...
 J'ai terminé ce chapitre et je passe au suivant
 Utiliser le moniteur série en entrée et sortie Concevez des matrices de LED 
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

Perfectionnez-Vous Dans La Programmation Arduino: Codez Et Décodez Des Informations

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Perfectionnez-Vous Dans La Programmation Arduino: Codez Et Décodez Des Informations

Transféré par

Droits d'auteur :

Formats disponibles

05/08/2016 OpenClassrooms

Perfectionnez-vous dans la programmation Arduino

CODEZ ET DÉCODEZ DES INFORMATIONS

 Pour suivre ce chapitre, il vous faut prévoir 5 LED et 5 résistances 220Ω

(Non Lukas, même si on rajoute "s'il te plaît")

Il va donc falloir apprendre à votre Arduino à décoder cette phrase !

Choisir des mots-clés

(Oui Cunégonde ! Ça me paraît bien plus simple !)

 Pourquoi toute cette démonstration ?

Décodez un train d'informations

Décodez la bonne quantité d'informations

 Les principes du langage objets :

Pilotez des LED avec un programme de codage/décodage

Nous utiliserons un tableau pour stocker les numéros des pins.

Mais comme je suis gentil, je vous donne un schéma électrique :

5 LED attachées au pins 2 à 6

Ces trois fonctions ne nécessitent pas de paramètre.

Vous remarquez que je décide de créer deux tableaux distincts :

Voici donc le corps du programme :

Rassurez-vous, je vais vous donner la correction !

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

 Utiliser le moniteur série en entrée et sortie Concevez des matrices de LED 

Professeur des écoles passionné d'informatique et de

OpenClassrooms Professionnels En plus Suivez-nous

Vous aimerez peut-être aussi