04/08/2016 OpenClassrooms ­ Faites des boucles et des calculs

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

  
Accueil Cours Programmez vos premiers montages avec Arduino Faites des boucles et des calculs

Programmez vos premiers montages avec Arduino

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

 

FAITES DES BOUCLES ET DES CALCULS

Dans tout apprentissage, la pratique reste souvent un bon moyen de mieux comprendre la théorie.

Ce chapitre va tourner autour de la réalisation de deux programmes qui devraient vous permettre d’appliquer les
connaissances que vous venez d’acquérir dans ces premiers chapitres :

1. Le premier programme va vous permettre de vous amuser avec les variables en laissant le programme les modifier à
votre place. Nous en profiterons pour réviser la notion de condition et aborder la notion de boucle qui permet bien
des choses en programmation.
2. Le second devrait faire appel à tout ce que vous avez vu dans ces premiers chapitres, et aura pour objectif de
programmer des a䏵ꨧichages sur le moniteur.

Pour ceux qui se demandent "quand-est-ce qu'on branche des matériels électroniques", et bien rassurez-vous, nous
l'aborderons dans les chapitres suivants, mais il me semble primordial de passer par le côté logiciel et programmation
avant d'aborder l'électricité et l'électronique. Le titre du cours, je vous le rappelle est Programmez vos premiers montages
avec Arduino.

Programme "Arduino compte seul"



L'objectif de ce programme est de faire compter l'Arduino tout seul. Je m'explique :

Tout d'abord, l'Arduino doit a䏵ꨧicher sur le moniteur série le nombre 1 et allumer une fois la LED 13.
Puis, après un temps d'arrêt d'une seconde, il doit a䏵ꨧicher le nombre 2 et faire clignoter 2 fois la LED 13 (à 2Hz, je
vous laisse revoir le cours sur les fréquences ).
Encore un arrêt d'une seconde, puis a䏵ꨧichage du chi䏵ꨧre 3 avec 3 clignotements ( toujours à 2 HZ).
L'opération se répète jusqu'au nombre 20, puis l'Arduino envoie "Ayé !" sur le moniteur série et plus rien ne se passe.

Pour réaliser ce programme, nous allons procéder en deux temps. Mais avant de nous lancer, laissez-moi vous présenter
quelques notions dont vous allez avoir besoin.
https://openclassrooms.com/courses/programmez­vos­premiers­montages­avec­arduino/faites­des­boucles­et­des­calculs#_=_ 1/11
04/08/2016 OpenClassrooms ­ Faites des boucles et des calculs

Calculs sur variable

Tout d'abord, il vous faut savoir qu'une variable peut être modifiée par calcul. Jusque là, nous avions écrit :
c_cpp
1 int uneVariable; //uneVariable contient on ne sait trop quoi
2 uneVariable=10; //uneVariable contient 10
3 uneVariable=32; //uneVariable contient 32

Et bien il est possible d'écrire :

c_cpp
1 int uneVariable; //uneVariable contient on ne sait trop quoi
2 uneVariable=10; //uneVariable contient 10
3 uneVariable=10+22; //uneVariable contient 32 (résultat de 10+22)

Mais là où ça devient intéressant (si si, je vous assure), c'est qu'on peut écrire ceci :
c_cpp
1 int uneVariable;
2 uneVariable=10;
3 uneVariable=uneVariable+22;

... ben oui.

Comment ça marche ? Tout simplement comme votre cerveau si je vous dis :

"Imaginez un bus. Dans ce bus, il y a 10 personnes. Il en monte 22, combien le bus contient de passagers ?"

Voilà ce que vous faites et ce que fait l'ordinateur :

Phrase Action humaine Action machine Code

Imaginez un bus vous allez d'abord imaginer le bus déclaration de la variable bus int bus;

Dans ce bus il y a 10 vous allez y mettre 10 personnes initialisation de la variable à 10. bus=10;
personnes

Il en monte 22 vous allez reprendre le nombre de appel de la variable bus bus

personnes

Il en monte 22 (suite) vous lui ajoutez 22 calcul sur la variable bus bus+22

Il en monte 22 (fin) vous mettez tout le monde dans le a䏵ꨧectation du résultat dans la bus=bus+22;
bus variable bus

 N'oubliez pas que le signe = est un signe d'a䏵ꨧectation ! Il faut

imaginer bus=bus+22 comme bus+22=>bus ( bus+22 va dans bus ). On modifie la valeur de bus par le
résultat de bus+22

Si vous avez compris cela, la suite ne devrait pas vous poser de problèmes. Voici ce qui est encore possible :
c_cpp
1 //Déclarations
2 int a;
3 int b;
4 int c;
5
6 //Initialisations
7 a=3; // a vaut 3
8 b=5; // b vaut 5
9 c=0; // c vaut 0
https://openclassrooms.com/courses/programmez­vos­premiers­montages­avec­arduino/faites­des­boucles­et­des­calculs#_=_ 2/11
04/08/2016 OpenClassrooms ­ Faites des boucles et des calculs
10
11 //Calculs
12 c=b+a; // c vaut maintenant 8
13 a=a+c; // a vaut maintenant 11 car 3+8
14 b=a+b; // b vaut maintenant 16 car 11+5
15 c=a+b; // c vaut maintenant 27 car 11+16

Prenez un instant pour être sûr(e) de bien avoir saisi ce code. Faites les calculs de tête, vérifiez.

Nous allons faire un petit programme sur l'Arduino qui compte de 1 en 1 et qui nous l'a䏵ꨧiche sur le moniteur. Vous pouvez
essayer de le réaliser seul(e) avant de regarder le code.
c_cpp
1 int compteur; //déclaration d'une variable compteur
2
3 void setup()
4 {
5 Serial.begin(9600); //initialisation communication
6 compteur=1; // initialisation de compteur
7 }
8
9 void loop()
10 {
11 Serial.println(compteur); //affiche la valeur de compteur
12 compteur=compteur+1; //on ajoute 1 à compteur
13 }

Saisissez le code, téléversez-le et ouvrez le moniteur. Si tout se passe bien, vous voyez l'a䏵ꨧichage qui progresse de 1 en 1.

 Vous remarquerez que pour a䏵ꨧicher une variable on écrit juste le nom de la variable entre les parenthèses
de Serial.println() , sans guillemets. En fait, les guillemets permettent d'a䏵ꨧicher du texte, sinon c'est une
valeur qui s'a䏵ꨧiche.

Devinette : Si vous laissez tourner ce programme, Arduino n'atteindra jamais 33000. Essayez de trouver pourquoi... (indice :
c'est en rapport avec le type de la variable)

Le fait d'ajouter 1 à une variable s'appelle incrémenter, et le fait d'enlever 1 c'est décrémenter. Ce sont des mots de
vocabulaire à connaître.

Bon, si nous reprenions notre objectif de programme de début de chapitre, nous pourrions dire que faire compter l'Arduino
jusqu'à 20 va être finalement assez simple. Il faut juste savoir comment l'arrêter... quelqu'un a une idée ?

(non Lukas, le débrancher n'est pas la réponse que j'attendais...)

Et bien nous allons utiliser une condition ! Nous allons dire à Arduino : tant que le compteur est inférieur ou égal à 20, tu
comptes, sinon tu ne fais rien. Ce qui donne en pseudo-code :
text
1 déclaration de la variable compteur
2
3 void setup()
4 {
5 initialisation de la communication
6 initialisation de compteur à 1
7 }
8
9 void loop()
10 {
11 si (compteur est inférieur ou égal à 20)
12 {
13 affichage de la valeur de compteur sur le moniteur
14 incrémentation de compteur
15 }
16 }

Je vous laisse le traduire en vrai code, c'est un bon exercice.

https://openclassrooms.com/courses/programmez­vos­premiers­montages­avec­arduino/faites­des­boucles­et­des­calculs#_=_ 3/11
04/08/2016 OpenClassrooms ­ Faites des boucles et des calculs

L'utilisation de pseudo-code est assez e䏵ꨧicace pour organiser son programme. Il permet aussi de présenter ce qu'on attend
en s'a䏵ꨧranchissant des mots-clés précis du langage. Un développeur de C pourrait sans problème le traduire pour un
a䏵ꨧichage sur la console.

Allez, voici le code pour l'Arduino :

c_cpp
1 int compteur;
2 void setup()
3 {
4 Serial.begin(9600);
5 compteur=1;
6 }
7 void loop()
8 {
9 if (compteur<=20)
10 {
11 Serial.println(compteur);
12 compteur=compteur+1;
13 }
14 }

Comme nous l'avons vu au chapitre précédent, si vous appuyez sur le bouton d'a䏵ꨧichage du moniteur (la loupe), ça relance
le programme sur l'Arduino. Mais une partie des envois précédents a eu le temps de passer et de s'a䏵ꨧicher. Tout cela
manque parfois de clarté. On peut donc ajouter une ligne de présentation juste après l'initialisation de la communication :
c_cpp
1 Serial.println("*** Debut du programme ***");

Ce n'est pas obligatoire, mais c'est plus sympa . Vous êtes libres d'écrire ce qui vous plaît en plus. Moi j'aime bien un :
"Bonjour maître, je commence."

 Ok, mais maintenant, comment on peut faire que la LED 13 clignote le nombre de fois spécifié dans compteur ?
Ha ! Ça fait plaisir de voir que ce cours vous maintient en haleine (non merci pas trop près Lukas) et vous pousse ainsi vers
le savoir !

Et bien pour répondre à cette excellente question, je vais en profiter pour aborder une notion particulièrement utile : les
boucles !

La boucle "for" 
La programmation nous permet de réaliser des boucles dans un programme. C'est à dire qu'on peut exécuter un bloc de
code plusieurs fois avant de passer à la suite. Cette répétition ouvre un grand nombre de possibilités.

Il existe plusieurs sortes de boucles, nous les verrons progressivement. Nous allons commencer par la boucle for . Elle
permet de répéter un code un nombre de fois connu à l'avance.

Elle se présente un peu comme une condition : elle commence par un mot-clé ( for ), suivi de certaines choses entre
parenthèses, puis des accolades qui contiennent le code à exécuter. Voici un exemple :
c_cpp
1 for (int t=0;t<10;t=t+1)
2 {
3 code à exécuter
4 }

Le plus di䏵ꨧicile à comprendre se situe entre les parenthèses. Il y a trois informations importantes séparées par des points-
virgules :

1. Initialisation de la variable qui va servir de compteur. Dans notre exemple, on déclare et on initialise (dans le même

https://openclassrooms.com/courses/programmez­vos­premiers­montages­avec­arduino/faites­des­boucles­et­des­calculs#_=_ 4/11
04/08/2016 OpenClassrooms ­ Faites des boucles et des calculs

temps) une variable t de type "int" : int t=0 .

2. Condition à tester pour continuer ou non la répétition. Ici, on exécute le code tant que t est inférieur à 10 : t<10 .
3. Action sur le compteur à chaque tour de boucle. Dans notre cas, t est augmenté de 1 à chaque passage : t=t+1 .

Ce qui est encore plus fort, c'est que cette variable t (le compteur) peut être utilisée dans le code à exécuter ! Du coup, voici
notre programme de comptage modifié avec une boucle for. Observez-le, testez-le et comprenez-le !
c_cpp
1 void setup()
2 {
3 Serial.begin(9600);
4 Serial.println("*** Debut du programme ***");
5 }
6 void loop()
7 {
8 for (int compteur=0;compteur<=20;compteur=compteur+1)
9 {
10 Serial.println(compteur);
11 }
12 }

Il compte bien jusqu'à 20, mais reprend ce comptage sans arrêt !

C'est normal, nous n'avons pas indiqué à Arduino qu'il ne doit le faire qu'une seule fois. Il va donc falloir creér une variable
à tester pour le lui indiquer.

Le type boolean


Je vais donc en profiter pour vous parler des variables de type boolean (ou booléens). Ce sont des variables qui ne peuvent
prendre que deux valeurs : soit 1 (true, c'est-à-dire vrai), soit 0 (false, c'est-à-dire faux). Les booléens sont des variables
pratiques pour faire des tests comme celui dont nous avons besoin pour vérifier si le compteur de notre programme
“Arduino compte seul” a fini de compter jusqu’à 20.

 On peut écrire boolean a=1; ou boolean a=true; la valeur de true est 1.

Observez le bout de code suivant :

c_cpp
1 boolean etat; //déclaration de la variable etat de type boolean
2 etat=true; //initialisation de etat à VRAI
3 if (etat) // test si etat est VRAI
4 {
5 //bloc de code exécuté si etat est VRAI
6 }

Vous remarquerez que l’on n’a pas besoin d’écrire if(etat==true) dans la condition, il su䏵ꨧit d’écrire if(etat) qui
signifie la même chose (mais les deux sont corrects).

Il faut comprendre que si vous créez une variable booléenne “drapeau” avec l’instruction suivante :
c_cpp
1 boolean drapeau;

Les trois instructions suivantes lui assigneront la même valeur “true” :

c_cpp
1 drapeau=true; //drapeau vaut true
2 drapeau=1; //drapeau vaut true, car true c'est 1
3 drapeau= 3<5; //drapeau vaut true, car 3 est inférieur à 5

Testez ce petit programme sur l'Arduino :

c_cpp
1 boolean etat;
2
3 void setup()

https://openclassrooms.com/courses/programmez­vos­premiers­montages­avec­arduino/faites­des­boucles­et­des­calculs#_=_ 5/11
04/08/2016 OpenClassrooms ­ Faites des boucles et des calculs
4 {
5 Serial.begin(9600);
6 etat=true;
7 }
8 void loop()
9 {
10 etat=3<5;
11 Serial.println(etat);
12 }

Il a䏵ꨧiche des 1. Car etat vaut 1(true) résultat du test (3<5).

Allez, on modifie notre programme "Arduino compte seul" pour y ajouter notre test de fin :
c_cpp
1 boolean affichage; //variable pour stopper l'affichage
2 void setup()
3 {
4 Serial.begin(9600);
5 affichage=true; //initialisation de la variable à true
6 Serial.println("*** Debut du programme ***");
7 }
8 void loop()
9 {
10 if (affichage) // test si affichage vaut true
11 {
12 //boucle de comptage
13 for (int compteur=0;compteur<=20;compteur=compteur+1)
14 {
15 Serial.println(compteur);
16 }
17 affichage=false; // on passe affichage à false
18 }
19 }

Vous voyez ici un bel entrelacement d'accolades. Pour s'y retrouver, il est conseillé, à chaque nouveau niveau d'accolade de
faire une tabulation. Ainsi c'est plus lisible. Vous avez un outil de formatage automatique dans le menu Outils de l'IDE. C'est
très pratique, essayez-le.

De plus, l'IDE vous propose un repérage simplifié des paires d'accolades ou de parenthèses. En e䏵ꨧet, si vous sélectionnez
ou cliquez à la droite d'une parenthèse ou d'une accolade, vous verrez que sa compagne s'encadre en bleu.

On avance pas mal, non ? Si vous trouvez ce dernier code encore trop inaccessible, je vous conseille de vous arrêter ici. De
faire une pause, de relire tranquillement le chapitre (voire les chapitres précédents) pour chercher ce qui a pu vous
échapper. Ce cours ne vous sera pas d’une grande utilité si vous copiez le code sans le comprendre .

Et maintenant, le clignotement ! Rappelez-vous, si le compteur vaut 1, on clignote 1 fois, s'il vaut 2, 2 fois, etc. Quand on
regarde le programme, on se dit que ce serait bien que le code de clignotement soit juste après l'a䏵ꨧichage de compteur
(donc après la ligne 15 dans le code ci-dessus). Comment faire ? Là encore c'est la boucle for qui va nous servir. Voici un
code pour faire clignoter 10 fois la LED 13 (a䏵ꨧiché en coloration syntaxique du langage C) :
c_cpp
1 int nombreDeFois; // variable pour le nombre de fois
2 int numeroPin; // variable pour le pin utilisé
3 boolean faireCode; // variable pour arrêter le clignotement
4
5 void setup()
6 {
7 numeroPin=13; // initialisation pin à 13
8 pinMode(numeroPin,OUTPUT);
9 nombreDeFois=10; // initialisation nb de fois à 10
10 faireCode=true; // initialisation à true
11 }
12
13 void loop()
14 {
15 if (faireCode) // test si true
16 {
17 for (int t=0;t<nombreDeFois;t=t+1) // boucle clignotement
https://openclassrooms.com/courses/programmez­vos­premiers­montages­avec­arduino/faites­des­boucles­et­des­calculs#_=_ 6/11
04/08/2016 OpenClassrooms ­ Faites des boucles et des calculs
18 {
19 //allume
20 digitalWrite(numeroPin,HIGH);
21 delay (250);
22 //éteint
23 digitalWrite(numeroPin,LOW);
24 delay (250);
25 }
26 faireCode=false;
27 }
28 }

Ce code ne devrait pas vous poser de problèmes si vous lisez les commentaires. J’utilise la même structure que le code
précédent, mais sans l’a䏵ꨧichage sur le moniteur série.

 J'utilise la coloration syntaxique du langage C (ce qui est mieux pour repérer commentaires et code). J'utiliserai
dorénavant cette coloration, la coloration de l'IDE de l'Arduino n'étant pas encore disponible.

Le problème est qu’avec ce code, la LED13 clignotera 10 fois à chaque tour (cf ligne 9). Il faudrait pouvoir faire varier cette
valeur. Et bien nous utiliserons en fait la valeur de compteur (qui va de 0 à 20) dans la boucle for du clignotement !

Je vous livre le code final car il est intéressant à étudier pour bien appréhender les variables, les conditions et les boucles.
Observez-le, dépecez-le, et surtout, essayez de le refaire seul(e)s.

Code final du programme "Arduino compte seul"


Voici le code avec les commentaires :
c_cpp
1 boolean affichage; //variable pour stopper l'affichage
2 int numPin;
3
4 void setup()
5 {
6 numPin=13;
7 pinMode(numPin,OUTPUT);
8 Serial.begin(9600);
9 affichage=true; //initialisation de la variable à true
10 Serial.println("*** Debut du programme ***");
11 }
12
13 void loop()
14 {
15 if (affichage) // test si affichage vaut true
16 {
17 //boucle de comptage
18 //compteur s'augmente de 1 à chaque tour
19 for (int compteur=1;compteur<=20;compteur=compteur+1)
20 {
21 Serial.println(compteur);
22
23 //boucle de clignotement
24 //compteur sert de limite à la boucle
25 //donc le nombre de clignotements augmente à chaque tour
26 for (int nbClignote=0;nbClignote<compteur;nbClignote=nbClignote+1)
27 {
28 //allume
29 digitalWrite(numPin,HIGH);
30 delay(250);
31 //eteind
32 digitalWrite(numPin,LOW);
33 delay(250);
34 }
35 delay(1000); //attente de 1s
36 }
37 affichage=false; // on passe affichage à false
38 Serial.println("*** Ayé ! ***");
39 }

https://openclassrooms.com/courses/programmez­vos­premiers­montages­avec­arduino/faites­des­boucles­et­des­calculs#_=_ 7/11
04/08/2016 OpenClassrooms ­ Faites des boucles et des calculs
40 }

Notez que l’on pourrait écrire ce code de manière plus e䏵ꨧicace, mais il faudrait faire recours à des notions que vous n’avez
pas encore vues donc pour l’instant on va se contenter de cette version.

N'oubliez pas d'ouvrir le moniteur, et amusez-vous à modifier les delay , les limites des boucles, etc.

Essayez de comprendre pourquoi dans les boucles for , la variable compteur est initialisée à 1, alors qu'on
initialise c à 0.

Pour incrémenter une variable il existe trois codes possibles qui sont tous corrects :
c_cpp
1 int variable;
2
3 // pour incrémenter
4 variable=variable+1; // celui‐ci vous connaissez
5 variable+=1; // autre façon, plus courte
6 variable ++; // autre façon encore plus courte
7
8 // pour décrémenter
9 variable=variable‐1;
10 variable‐=1;
11 variable ‐‐;

Petit exercice : Essayez de simplifier le code de "Arduino compte seul" sans que le résultat ne soit changé (aide : il faut
enlever ou modifier certaines boucles et tests).

Vérifiez la solution !

Nous avons réalisé ensemble pas à pas ce programme de clignotement, je vous propose maintenant d’en faire un tous
seuls comme des grands !

TP : Programme “Table de multiplication"


Dans ce programme, je vais vous demander d’a䏵ꨧicher la table de multiplication par 7 des nombres de 1 à 15. Voici quelques
règles à respecter :

Le programme devra a䏵ꨧicher la table de multiplication une seule fois, il faudra donc utiliser une condition pour
vérifier si elle a été a䏵ꨧichée.
Pour rendre le programme facile à modifier, vous stockerez le nombre 7 dans une variable de type int. Nous
apprendrons plus tard comment envoyer une information à l'Arduino depuis le moniteur, ce qui nous permettra
d'a䏵ꨧicher la table de notre choix.)
Le moniteur devra a䏵ꨧicher une table qui ressemble à ça :

https://openclassrooms.com/courses/programmez­vos­premiers­montages­avec­arduino/faites­des­boucles­et­des­calculs#_=_ 8/11
04/08/2016 OpenClassrooms ­ Faites des boucles et des calculs

Rendu sur la console du programme "Table de multiplication"

Quelques pistes utiles

Pour a䏵ꨧicher un saut de ligne, il su䏵ꨧit d'utiliser l'instruction suivante : Serial.println() , sans rien entre les
parenthèses.
Pour faire un calcul de multiplication dans un programme, on utilise l’étoile *. Donc “3x4” en humain s’écrit “3*4” en
machine. Et la division s’écrit avec le slash / en machine.

Allez, je vous laisse travailler, je vais faire une sieste. Ne désespérez pas au premier problème rencontré, relisez le cours,
essayez, modifiez. Il n'y a pas de pièges dans la conception de ce programme.

Code pour le programme "Table de multiplication"



Voici le code attendu, vous devriez vous y retrouver facilement car tous les mots vous sont maintenant familiers :
c_cpp
1 int numTable; // variable pour la table concernée
2 boolean affiche; // variable d'affichage
3
https://openclassrooms.com/courses/programmez­vos­premiers­montages­avec­arduino/faites­des­boucles­et­des­calculs#_=_ 9/11
04/08/2016 OpenClassrooms ­ Faites des boucles et des calculs
4 void setup() {
5 affiche = true; // initialisation à true
6 numTable = 7; // iniialisation à 7
7 Serial.begin(9600); //initialisation de l'affichage
8
9 //Affichage de l'entête du programme
10 Serial.println("***********************");
11 Serial.println("Table de multiplication");
12 Serial.print("La table de : "); //pas de retour à la ligne
13 Serial.println(numTable); // affichage de la variable
14 Serial.println(); // saut de ligne pour aérer
15 }
16
17 void loop() {
18 if (affiche) // test si vrai
19 {
20 // boucle de progression pour la multiplication
21 for (int t = 0; t < 15; t++)
22 {
23 int resultat = numTable * t; // variable pour stocker le résultat
24
25 // Affichage de la ligne
26 Serial.print(t);
27 Serial.print(" x ");
28 Serial.print(numTable);
29 Serial.print(" = ");
30 Serial.println(resultat);
31 }
32 Serial.println(); // saut de ligne
33 Serial.println("***********************");
34 affiche=false; // passage à false pour ne plus afficher
35 }
36
37 }

Quelques remarques :

Ligne 21 : j'utilise la méthode d'incrémentation simplifiée t++, c'est identique à t=t+1.

ligne 23 : la déclaration, l'initialisation et l'a䏵ꨧectation de la variable est faite en une seule ligne. C'est tout à fait
correct, légèrement plus gourmand en place mémoire.
La variable "resultat" créée en ligne 23 et a䏵ꨧichée en ligne 30, n'est pas une obligation. Nous aurions très bien pu
écrire en ligne 30 directement : Serial.println(numTable*t);

Bon c'était là encore une bonne partie (de rigolade ?) bien chargée de connaissances.

Dans l'état actuel de votre savoir programmistique, si vous avez réussi à réaliser seul(e)s ce dernier programme, voire celui
d'avant, on peut dire que vous êtes fichtrement avancés maintenant en programmation.

Vous êtes donc largement prêt(e)s à passer à l'étape suivante : les connaissances électriques des montages.

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

 Utilisez les constantes, les variables, les conditions

Jeux de lumière avec une LED et la breadboard 
et le moniteur série

L'auteur

Jean-Noël Rousseau
https://openclassrooms.com/courses/programmez­vos­premiers­montages­avec­arduino/faites­des­boucles­et­des­calculs#_=_ 10/11
04/08/2016 OpenClassrooms ­ Faites des boucles et des calculs

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/programmez­vos­premiers­montages­avec­arduino/faites­des­boucles­et­des­calculs#_=_ 11/11