LA PROGRAMMATION DES ROBOTS LEGO MINDSTORMS - PAR L'EXEMPLE

LA PROGRAMMATION
DES ROBOTS LEGO MINDSTORMS ®

                            PAR L’EXEMPLE
                            CHAPITRE 1 : LES BASES

         www.programmer-a-l-ecole.fr

LA PROGRAMMATION DES LEGO MINDSTORMS ® PAR L'EXEMPLE.

Pour réaliser ces programmes, on construira un robot très simple du type five_minutes_bot (notice
de montage disponible sur le site http://www.nxtprograms.com) auquel on ajoutera
progressivement les différents capteurs.

DÉPLACER

C'est le premier bloc à explorer, c'est aussi le premier contact avec la programmation graphique
voire avec la programmation tout court.

Voici son paramétrage par défaut tel qu'il apparaît dès le glisser / déposer du bloc :

Nous allons créer un programme parcours avec ce seul bloc et ses paramètres par défaut,
l'enregistrer, le compiler, le charger en mémoire et l'exécuter puis modifier les paramètres un par un
et observer les différences de comportement.

Ceci fait, modifions le paramètre « Durée » en augmentant plusieurs fois le nombre de rotations
(sans excès), puis en remplaçant les rotations par des secondes puis les secondes par des degrés.
Avec deux marques (deux bandes de ruban adhésif de couleur collées sur le plancher par exemple)
matérialisons un départ et une arrivée et faisons parcourir au robot cette distance des 3 façons
différentes (rotations, degrés, secondes). On peut éventuellement remplir un tableau récapitulatif
des équivalences rotations / degrés / secondes sur un même parcours (Ces équivalences ne seront
pas absolues mais dépendantes de la nature du sol, du type de roues, de la vitesse du robot).

Paramétrons maintenant « Durée » sur « Illimité » : que devrait normalement faire le robot ? Que
va-t-il faire réellement ? Il faudra à ce stade donner l'explication de ce comportement aux élèves
en attendant qu'ils l'expérimentent par eux-mêmes un peu plus tard avec les différents capteurs :
« Illimité » veut en fait dire « Illimité jusqu'à ce que ... il arrive quelque chose », si le « quelque
chose » n'est pas prévu (et non pas s'il n' « arrive pas »), le robot n'avancera pas.

Expérimentons ensuite « Action suivante » : ordonnons au robot de parcourir - en secondes par
exemple - la distance précédemment matérialisée et comparons le fait de cocher « freiner » ou le
fait de cocher « continuer ». Cette option nous sera utile si on veut un jour que le robot s'arrête
immédiatement après avoir fini le programme …

Faisons maintenant varier « Alimentation » (paramétrée par défaut sur 75) en essayant
successivement 100 puis 50. On en déduira aisément qu'« Alimentation » correspond à un bouton

« Puissance des moteurs » ; la plupart du temps une alimentation réglée sur 40 sera largement
suffisante et économisera piles et batteries …

Continuons en modifiant « Direction » en cochant successivement le 2ème bouton radio (flèche vers
le bas) puis le 3ème (stop) : on fait ainsi reculer et s'arrêter le robot.

A votre avis à quoi peut bien servir « Diriger » ? (A ce stade des essais, les élèves devraient être en
mesure de dire que « Diriger » servira à faire tourner le robot … Quoi qu'il en soit,
l'expérimentation permettra de le vérifier ou bien de le déduire. Faire remarquer que « Direction »
et « Diriger » sont des mots de la même famille et donc que les idées qu'ils induisent sont proches).
On va alors implémenter un programme - ou modifier parcours - pour faire avancer le robot (sans
distance imposée) et le faire tourner à droite (sans durée de rotation imposée). La règle « Une action
= Un bloc », c'est à dire qu'il faudra un bloc pour avancer et un autre pour tourner, va devoir être
appliquée par les élèves sans doute de manière intuitive mais ensuite énoncée voire même écrite
comme toute première règle dans un mémento robotique.

De la même manière, on va implémenter un programme pour faire avancer le robot et le faire
tourner à gauche puis implémenter ensuite les programmes suivants :

   – avancer, tourner à droite, avancer, tourner à gauche (toujours sans distance ni rotation
     imposées).
   – avancer puis tourner suivant un angle matérialisé sur le sol par du ruban adhésif (proposer
     différents angles y compris l'angle droit).
   – avancer, tourner à droite, avancer, tourner à gauche et revenir à son point de départ.

ENREGISTRER / JOUER

Les programmes précédents exigent une certaine précision des paramètres et de nombreuses
expérimentations, peut-être lassantes pour des débutants en programmation … Il existe une
alternative pour résoudre les difficultés rencontrées : le bloc ENREGISTRER / JOUER.

Dont voici le paramétrage par défaut :

Le plus simple sera de faire une démonstration : en manœuvrant le robot « à la main », il est
possible d'enregistrer son déplacement dans un programme (ici nommé par défaut « RobotAction »)
et de reproduire ce mouvement enregistré en déposant un bloc Enregistrer/Jouer dans un nouveau
programme en en cochant le bouton « Jouer ».

Deux choses à noter : on retrouve les cases à cocher A, B, C du bloc DÉPLACER dont nous n'avons
pas encore parlé et le paramètre « Temps » détermine la durée de l'enregistrement pour lequel il
vaut mieux ne pas être trop large de façon à économiser les piles,la batterie et la mémoire du robot
et à ne pas enregistrer une absence de mouvement.

RETOUR SUR DÉPLACER

Il nous reste un paramètre à explorer, c'est « Port ».

Reprenons notre programme parcours et décochons la case B. Que se passe-t-il ? Que se passera-t-
il si on décoche C au lieu de B ? Essayons. Et si on décoche B et C ? Vérifions. B et C
correspondent aux moteurs de droite et de gauche. Par déduction, A correspond au troisième
moteur quand il y en a un. On pourrait donc reprendre nos programmes où l'on fait avancer puis
tourner sans distance ni rotation imposées les robots en les faisant tourner non plus avec
« Diriger » mais avec « Port ».

BOUCLER

Maintenant que nous savons faire avancer et tourner un robot, il devrait être possible d'implémenter
un programme carré pour lui faire exécuter ou suivre un carré matérialisé sur le sol …

Voici un programme carré possible :

On peut ici montrer que le copier / coller d'un bloc est possible, qu'il prend en compte les réglages
effectués et permet de gagner du temps …

Voici le paramétrage des quatre blocs pour avancer :

Et le paramétrage des quatre blocs pour tourner :

(Le paramétrage du virage du robot que ce soit en rotations, secondes, degrés va varier en fonction
de la résistance du sol (moquette, parquet, carrelage, etc.) et de la taille des roues et de leur type
(pneus ou chenilles) – 3,1 n'est donc là qu'à titre d'exemple)

A partir de carré, on peut grâce à « Enregistrer sous » du menu Windows, enregistrer un
programme rectangle qui, bien sûr, en l'état fera faire au robot un carré … Combien de blocs du
programme faudra-t-il modifier, lesquels et comment pour transformer le carré en rectangle ?

Modifions, enregistrons et exécutons rectangle pour vérifier la justesse de notre analyse.

Maintenant si on regarde attentivement le programme carré, on voit qu'on répète plusieurs fois la
même séquence et plus précisément qu'on répète 4 fois la séquence : « Avance de 5 rotations /
tourne à 90° ». Même si le Copier / Coller nous fait gagner du temps, le robot lui n'en gagne pas et
le programme écrit ainsi est bien lourd – dans l'écriture mais aussi en mémoire. Il existe un bloc
pour gagner en légèreté et en efficacité, le bloc BOUCLE :

Dont voici le paramétrage par défaut :

Le principe d'une boucle est le suivant : tout ce qui est à l'intérieur de la boucle est répété …
Combien de fois ? C'est à nous de le définir. Comment ? Il existe plusieurs façons …

Commençons par faire un programme carré_boucle. Le premier bloc est donc le bloc BOUCLE.
Que va-t-on y faire glisser ? Un bloc DÉPLACER pour avancer et un autre pour tourner, ce qui va
donner ceci :

Avec les paramétrages suivants :

Mais que va-t-il se passer si on laisse « Contrôle » de la boucle sur « Pour toujours » ? (On peut
éventuellement le vérifier …). On va donc choisir « Compteur » qui va nous permettre de choisir un
nombre de tours de boucle, c'est-à-dire un nombre de fois où ce qui se trouve à l'intérieur de la
boucle sera exécuté … Pour notre carré, ce sera bien évidemment 4. Comme ceci :

A votre avis, est-il cohérent de choisir un nombre décimal (par exemple 4,5) pour un nombre de
tours de boucle ? Essayez ...

On peut aussi choisir un nombre de secondes en choisissant « Temps » dans « Contrôle » (Là, les
nombres décimaux sont autorisés ...). Mais que va-t-il se passer si le temps choisi est trop court ,
comme dans l'exemple (1,5 secondes) ?

(Les autres paramétrages de la boucle (« Capteur » et « Logique » seront vus plus tard ainsi que
l'option « Compteur » de « Montrer ».)

Comment faire un rectangle avec une boucle ? Et un cercle ? Voici 2 programmes à réaliser :
rectangle_boucle et cercle_boucle. Une fois le cercle fait par le robot, sur quels paramètres faut-il
agir pour l'agrandir ou le rétrécir ?

cercle_boucle :

Avec (mais il peut être intéressant de trouver par expérimentation le nombre de tours de boucles ) :

RÉAGIR

Notre robot sait maintenant avancer, reculer, tourner mais il ne le fait pour l'instant que sur notre
ordre : il va être maintenant plus intéressant de lui permettre de décider lui-même s'il doit avancer,
reculer, tourner … Il est déjà doté d'un cerveau, la brique ; nous allons lui donner 3 des 5 sens : la
vue, l'ouïe, le toucher et nous allons le faire grâce aux capteurs. (Pour l'ouïe, le capteur sonore ne
se trouve pas au départ dans la boîte Lego Mindstorms® et doit être acheté en supplément)

Commençons par le toucher en montant sur le robot le capteur tactile et en le connectant au port
n°1. (On peut s'inspirer du montage du capteur de couleurs sur le robot line_follower en utilisant
les mêmes pièces mais en orientant ensuite le capteur tactile horizontalement au lieu de
l'orientation verticale du capteur de couleurs (notice disponible sur le site
http://www.nxtprograms.com ) ou mieux encore, on peut concevoir son propre système d'attache du
capteur).

Qu’allons-nous maintenant donner comme ordres au robot ? Nous avons plusieurs possibilités. Par
exemple , on peut lui ordonner: « Avance tout droit en attendant de toucher un obstacle alors à ce
moment-là, arrête-toi puis recule un peu et tourne (à droite par exemple) ... » ou bien « Avance tout
droit jusqu'à ce que tu touches un obstacle alors arrête-toi puis recule un peu et tourne (à droite par
exemple) ... » voire « Avance tout droit, si tu touches un obstacle, arrête-toi puis recule un peu et
tourne (à droite par exemple) ... ».

Ces ordres que nous venons d'écrire s'appellent du pseudo-code. C'est le premier travail d'un
programmeur (on parle plus volontiers maintenant de « développeur »). Une fois que le pseudo-
code est bien écrit, c'est-à-dire que les ordres sont précis et donnés au robot au bon moment, dans le
bon ordre, alors le pseudo-code peut être « traduit » dans n'importe quel langage de programmation.

Traduisons le premier pseudo-code dans notre langage de programmation graphique (on n'utilise
pour le moment que la première palette de blocs appelée « palette commune ») afin d'implémenter
le programme parcours_tactile.

Nous savons déjà quel bloc utiliser pour avancer et comment le paramétrer pour avancer tout droit ;
comment maintenant exprimer « en attendant de » en blocs ? Nous allons utiliser la seule famille de
blocs de la palette commune, la famille de ATTENDRE. Pour des raisons de simplicité, l'icône
représentant un sablier est dans la palette commune la seule à proposer différents blocs quand on la
survole avec le pointeur de la souris – ce qui en réalité n'est pas nécessaire puisqu'on peut obtenir
chacun de ces blocs en utilisant les différentes options de paramétrage d'un seul d'entre eux.

Il suffira pour le moment d'expliquer que l'on va choisir le bloc adapté à notre capteur, à savoir
celui-ci :

… que l'on va vérifier la cohérence du paramétrage par défaut :

Et que ce bloc signifie : « attendre que le capteur tactile soit enfoncé ». On va faire remarquer que
les options « attendre que le capteur tactile soit relâché » et « attendre que le capteur tactile soit
heurté » sont aussi disponibles et montrer sur le capteur lui-même les différences entre enfoncer,
relâcher et heurter.

Notre programme complet devrait maintenant ressembler à ceci :

(On montrera ici comment documenter son programme avec la touche                  et on insistera sur
l'importance de la documentation pour soi et pour les autres ...)

Détail du paramétrage du 1er bloc (« avance tout droit »):

Ici le paramétrage sur « Illimité » va fonctionner car l'événement attendu est prévu dans le
programme, le robot va réellement avancer et peut avancer de façon illimitée s'il ne touche jamais
d'obstacle …

On va sans s'y attarder montrer les différents capteurs paramétrables dans la liste déroulante de
l'option « Capteur », montrer que « Action » et « Port »sont dépendants de la nature du capteur en
sélectionnant dans la liste le capteur de couleurs :

Enregistrons, chargeons et essayons le programme, d'abord sans obstacle, puis en plaçant un
obstacle (suffisamment haut pour enfoncer le capteur) sur son chemin. Une fois l'obstacle évité, le
robot s'arrête : est-ce normal ? Que faudrait-il faire pour que le robot recommence ? Faites-le.

Voici la solution la plus immédiate:

(Tous les paramétrages de boucle sont acceptables ici puisqu'on a parlé de recommencer sans plus
de précision …)
Cependant, il existe une autre approche de la situation du début. Rappelez-vous , nous disions en
pseudo-code : « Avance tout droit en attendant de toucher un obstacle alors arrête-toi puis recule un
peu et tourne (à droite par exemple) ... ». Mais nous aurions tout aussi bien pu dire : « Avance tout
droit jusqu'à ce que tu touches un obstacle ... »,

ce qui se traduit différemment avec les blocs mais fonctionne tout aussi bien :

(Le bloc DÉPLACER se trouvant dans une boucle, il peut être paramétré sur 1 rotation. Rotation
unique qui sera alors répétée tant que durera la boucle, le déplacement étant toutefois plus saccadé
avec ce paramétrage ...)

Avec, pour le bloc DÉPLACER :

(L'option « Action suivante » a ici peu de conséquence sur le fonctionnement du programme)

Et pour la boucle, une sortie de boucle conditionnée par l'enfoncement du capteur tactile sur un
obstacle :

La suite du programme est la même :

Ce qui donne :

Mais l'idée intéressante maintenant est de faire tourner ce programme sans arrêt (comme
parcours_tactile ) et donc de le mettre dans une boucle et de voir ainsi une boucle imbriquée dans
une autre boucle … et voici parcours_tactile_2 :

L'autre idée importante à retenir est qu'un problème peut être résolu de différentes manières, plus ou
moins concises, plus ou moins élégantes ; que ces différentes manières vont se traduire par des
pseudo-codes différents et que les différences dans le code, même si elles paraissent minimes,
pourront se traduire par des programmes sensiblement différents. Pour préciser encore cette idée, le
3ème pseudo-code proposé plus haut fait intervenir la condition SI, ce SI se traduit par un autre
bloc, le bloc COMMUTATEUR - que nous verrons en détail plus tard.

Le bloc COMMUTATEUR :

On va maintenant préparer un défi pour les élèves : un parcours matérialisé par une ligne de départ
et une ligne d'arrivée, parcours sur lequel seront placés des obstacles que le robot devra tout d'abord
sentir, puis contourner pour pouvoir franchir la ligne d'arrivée. (On fera remarquer, une fois les
premiers programmes testés que le robot ne « voit » pas qu'il est arrivé … Comment plus tard
résoudre ce problème ? Comment implémenter la solution dans le programme ?)

Ces premiers programmes ont permis de faire réagir le robot au toucher, nous allons maintenant le
faire réagir sur d'autres événements : une couleur, une lumière, un son, un obstacle à distance, etc.
Pour cela, nous allons utiliser d'autres types de capteurs soit en les montant à la place du capteur
tactile, soit en les montant – grâce à de petites adaptations et à notre esprit pratique – à côté du
capteur tactile.

Montons ainsi sur le robot le capteur de couleurs (vérifions bien sa connection au bon port) et
reprenons le programme parcours_tactile :

Remplaçons dans le programme le capteur tactile par le capteur de couleurs que nous allons
paramétrer sur une des couleurs disponibles, par exemple le rouge, de la façon suivante :

Que doit-il se passer ? Le robot avancera tant qu'il ne verra pas de rouge. Quand le capteur va
rencontrer du rouge (par exemple une ligne de ruban adhésif rouge sur le sol) , le robot va s'arrêter,
reculer et tourner comme il l'avait fait précédemment en touchant un obstacle. Enregistrons le
programme sous le nom parcours_couleur et testons-le.

On pourrait fabriquer une grande figure fermée (par exemple un rectangle de 1 m sur 2 m avec une
bordure rouge) à l'intérieur de laquelle on placerait le robot qui, avec le programme
parcours_couleur, ne pourrait pas en sortir jusqu'à ce qu'on lui ait ouvert un passage avec un trou
ou une autre couleur...

Essayez maintenant d'implémenter un programme parcours_couleur_2 avec du bleu comme
couleur à reconnaître au lieu de rouge.

Essayez maintenant d'implémenter un programme parcours_couleur_3 sur le modèle de
parcours_tactile_2.

LES CONDITIONS

Imaginons maintenant qu'on veuille faire faire au robot les actions suivantes :
   – avance tout droit
   – si tu rencontres du rouge tourne de 90° à gauche et recommence à avancer
   – si tu rencontres du bleu tourne de 90° à droite et recommence à avancer

Cette suite d'action est déjà du pseudo-code en soi ; si les élèves n'ont pas perçu la nuance dans le
code amenée par le SI, on peut (et même on doit) les laisser expérimenter leurs idées et formaliser
leurs difficultés …

Puis, de la même façon que nous avions introduit la nuance en attendant de / jusqu'à ce que, nous
allons maintenant introduire la notion de condition avec SI.

Comme dit plus haut, le SI est implémenté par un bloc spécifique, le bloc COMMUTATEUR,
paramétré par défaut sur le capteur tactile...

… capteur tactile que nous allons remplacer par le capteur de couleurs :

… paramétré une première fois sur rouge ...

… et une seconde fois sur bleu ...

...ce qui va donner pour le programme parcours_couleur_4 :

Mais qu'allons-nous mettre dans les commutateurs ? Le SI admet deux réponses : OUI ou NON
symbolisées respectivement par            et par

Donc : SI OUI tu « vois » du rouge , tourne à gauche et SI OUI tu vois du bleu , tourne à droite.

Ce qu'on peut bien sûr inclure dans une boucle …

Et SI NON , tu ne vois pas de rouge (ou de bleu) ? Nous sommes ici dans le 2ème «étage » du
commutateur, celui précédé de la croix, le plus simple est de n'y placer aucun bloc, le robot dans ce
cas ne fera rien, les étapes suivantes du programme s'exécuteront ...

Mais n’y aurait-il pas plus simple ? Voyons ce pseudo-code : avance tout droit, SI tu vois du rouge
tourne à gauche mais si tu n'en vois pas ET SI tu vois du bleu tourne à droite …

De la même façon que les boucles peuvent s'imbriquer, les conditions peuvent elles            aussi
s'imbriquer …

Voici parcours_couleur_5 :

LES DEUX ALTERNATIVES D'UNE CONDITION

Pour utiliser pleinement les deux alternatives de la condition (SI / SINON), remplaçons le capteur
du robot par le capteur à ultra-sons qui permet au robot de détecter un obstacle à une distance
paramétrable et donnons-lui comme consignes : « Avance de 3 rotations, SI alors tu repères un
obstacle à 10 cm, arrête-toi et tourne de 90° à gauche, dans le cas contraire - SI tu ne repères pas
d'obstacle à 10 cm – avance encore de ces 10 cm . ». Consignes pouvant être exécutées bien sûr
plusieurs fois. ( Toute distance choisie, ici 10 cm, sera à exprimer dans le paramétrage du bloc
DÉPLACER en rotations, secondes ou degrés, au choix.)

Paramétrage du capteur à ultra-sons :

La solution, si elle permet de bien exploiter les possibilités du commutateur, est plus lourde qu'une
solution du type précédent où il suffit, en cas d'absence d'obstacle, de ne rien faire : la reprise de
l'avancée du robot sera assurée par le 1 er bloc de la boucle … On peut d'ailleurs supprimer ce 1 er
bloc dans notre programme.

La sollicitation du capteur à ultra-sons ne se fera pas en continu mais à chaque nouveau tour de
boucle, moment que l'on peut repérer par un son.

LES CONDITIONS MULTIPLES

Prenons un dé (un vrai) et à chaque face du dé, affectons une action qu'exécutera un élève: par
exemple, SI c'est 1 avance d'un pas, SI c'est 2 recule d'un pas, SI c'est 3 fais un bruit , SI c'est 4
tourne sur toi-même, etc.

Regardons maintenant la deuxième palette de blocs, la palette entière, on y voit un dé. Faisons-le
glisser sur la grille et regardons d'abord son nom : ALÉATOIRE. Que veut dire ce mot ?

Regardons ensuite son paramétrage :

Que veut dire « Plage » ? Si on voulait imiter le comportement de notre dé réel, que devrait être
l'intervalle ? Le minimum que l'on puisse obtenir ? Le maximum ?

Réglons le paramétrage de ALÉATOIRE sur ces conditions réelles …

Maintenant, chaque fois que nous allons rencontrer ce bloc dans notre programme, cela va être
comme si on lançait sur la table notre dé réel. Mais comment va-t-on connaître le nombre obtenu ?

Regardons bien notre bloc ALÉATOIRE, il possède un plot de sortie « Numérique »...

… ce qui veut dire que le nombre obtenu par le lancer virtuel du dé va « sortir » par ce plot et on
pourra l'utiliser de plusieurs manières.

On pourra par exemple le voir sur l'écran grâce au bloc AFFICHER.

Pour l'instant, nous allons ajouter un commutateur à notre programme et paramétrer le commutateur
de la façon suivante :

Mais cela ne suffit pas car de cette façon, nous n'avons que 2 choix et il nous en faut … 6.
Il faut maintenant décocher l'option « Vue à plat » et cliquer sur « + » jusqu'à arriver à 6 conditions
qui seront matérialisées dans le programme par des onglets

Nous allons « tirer un fil » du dé au commutateur, du plot de sortie au plot d'entrée. Pour cela il
suffit de cliquer sur le plot de sortie, de maintenir le bouton de la souris pressé jusqu'au plot d'entrée
du commutateur. Ce fil va transmettre au commutateur le chiffre sorti au tirage du dé.

Nous allons affecter à chaque chiffre du dé une action différente : avancer, reculer, tourner à droite,
tourner à gauche, jouer un son, jouer un autre son. Pour cela, nous allons cliquer sur le chiffre choisi
dans le tableau du paramétrage et faire glisser ensuite l'action choisie dans le commutateur.

Voici par exemple : pour 1, avance :

(Pour 2, recule ; pour 3, avance sur le seul moteur B ; pour 4, avance sur le seul moteur C ; pour 5,
joue le son « Good job » ; pour 6, joue le son « Hooray »)

On remarque que le 1er onglet est sélectionné (il est plus clair) … mais aussi qu'il n'y a que 5 onglets
maximum. Pour affecter des actions aux autres conditions, il faudra cliquer sur la condition dans le
tableau.
Pour 6, joue le son « Hooray » :

Tel qu'il est le programme ne s'exécute qu'une fois et l'on ne connaît le nombre tiré aléatoirement
que par l'action associée que fait le robot (nous verrons un peu plus tard comment afficher en même
temps ce nombre). Glissons-le dans une boucle, enregistrons-le sous le nom de lancer_de_dé et
testons-le.

AFFICHER

Nous allons reprendre ce programme pour afficher sur l'écran de la brique NXT le nombre sorti
aléatoirement.

La logique voudrait que nous tirions simplement un fil entre le bloc ALÉATOIRE et le bloc
AFFICHER (avant même tout paramétrage de ce bloc AFFICHER ) comme ceci:

Malgré la correspondance des symboles # , cela ne fonctionnera pas : il faut passer par un détour. Il
n'est pas possible d'afficher un nombre en tant que tel, il faut au préalable le « convertir » en texte
pour l'afficher en tant que texte et pour cela, utiliser ce bloc :

… de cette manière :

Il faudra ensuite paramétrer sur « Texte » le bloc AFFICHER - paramétré par défaut sur
« Illustration » - et pour plus de lisibilité, effacer le texte par défaut « Mindstorms NXT ».

On pourra même rajouter dans la boucle un bloc ATTENDRE paramétré sur 2 secondes pour nous
laisser le temps de bien lire le nombre tiré aléatoirement.

Voici le programme affichage_tirage_dé :

… avec une boucle infinie qu'il faudra bien finir par arrêter ...

ATTENDRE

Nous avons vu pour la première fois une des utilisations possibles des blocs de la famille
ATTENDRE dans notre programme parcours_tactile : l'attente d'un « événement-capteur », c'est-
à-dire d'un événement dans le fonctionnement du robot pouvant ou devant être perçu par un capteur,
constituait l'implémentation graphique de l'instruction de pseudo-code « en attendant de ».
L'exploration des possibilités de ces événements-capteurs continuait avec le capteur de couleurs et
le programme parcours_couleur et il sera évidemment possible et profitable d'adapter ces
programmes aux capteurs restants en particulier le capteurs de sons et le capteur à ultra-sons.

Dans affichage_tirage_dé, le bloc ATTENDRE était utilisé cette fois comme compteur (en
secondes) et non avec un événement-capteur, ménageant ainsi des pauses de quelques secondes
dans le déroulement du programme. Retenons simplement à ce stade que ces pauses à des endroits
bien choisis d'un programme permettent de mieux observer son fonctionnement et éventuellement
de le déboguer.

LES SONS

De la même façon, le bloc SON offrira, une fois les blocs fondamentaux correctement maîtrisés,
des opportunités d'exploration par ses nombreuses fonctionnalités. Il est en effet possible
d'enregistrer ses propres fichiers audio, d'éditer et de modifier des sons ou des fichiers.

RETOUR SUR LES BOUCLES

Depuis nos tout premiers programmes, nous avons constaté l'importance et l'utilité des boucles et
les nombreuses applications de leurs conditions de sortie.

Par condition de sortie d'une boucle, on entend l'événement – attendu ou non – qui va faire
s'interrompre la boucle et donc arrêter l'exécution de tout ce qu'elle contient : cet événement
pouvant être l'expiration d'un nombre de tours, d'une durée en secondes prévus par le programme, la
rencontre avec un obstacle perçue et transmise par le capteur tactile,etc. Une fois la boucle
interrompue, le programme continue et les autres blocs, s'il y en a, sont exécutés.

Ce peut être aussi une valeur logique : « vrai » ou « faux », valeur appelée encore valeur booléenne
ou plus simplement booléen en informatique. Lors du paramétrage de la condition de sortie de la
boucle sur « valeur logique », son icône change : un plot de sortie apparaît afin de recevoir la valeur
logique qui peut être paramétrée su « vrai » ou « faux ».

Cette valeur logique peut être transmise par une variable :

Cette variable pouvant être modifiée par le programme au cours de son exécution. (Ce qui équivaut
la plupart du temps à tester une condition.) Imaginons le programme suivant: on va lancer deux dés
jusqu'à ce qu'on fasse un double six. Le lancer des dés est simulé par le tirage de deux nombres
aléatoires, une variable logique recueillera la valeur « vrai » quand les deux nombres aléatoires
seront six au même lancer, on recommence les lancers tant que cette variable sera « fausse ».

Explicitation du programme boucle_logique (dans l'ordre des blocs) :
   – tirage du premier nombre aléatoire entre 1 et 6
   – comparaison du nombre aléatoire avec 6 et envoi de « vrai » ou « faux » suivant le résultat
       de la comparaison au 11ème bloc
   – transformation du nombre aléatoire tiré en texte pour affichage
   – affichage du nombre sur la brique
   – attente d'une seconde
   – idem 2ème dé : tirage du nombre aléatoire entre 1 et 6
   – idem 2ème dé : comparaison à 6 et envoi de « vrai » ou « faux » au 11ème bloc
   – idem 2ème dé : transformation du nombre aléatoire tiré en texte pour affichage
   – idem 2ème dé : affichage du nombre sur la brique
   – attente d'une seconde
   – 11ème bloc :comparaison des 2 valeurs logiques : si « vrai » ET « vrai » (donc si : 6 ET 6) la
       variable « Logique_1 » est à « vrai »
   – attente d'une seconde
   – tant que « Logique_1 » n'est pas à « vrai », la boucle recommence

Ce programme introduit le bloc COMPARER, premier d'une série de blocs mathématiques sur
lesquels nous reviendrons.

CE QU’UNE BOUCLE PEUT NOUS DIRE

Dans le programme précédent, on peut cocher l'option « Compteur » de la boucle, ce qui va faire
apparaître un autre plot au début de la boucle. Ce plot va pouvoir transmettre (à une variable par
exemple) le nombre de tours qu’aura effectués la boucle …

Nombre que l'on peut par exemple afficher en fin de programme une fois la boucle terminée ou
récupérer par exemple dans un commutateur pour continuer (ou non) le programme …

RETOUR SUR LES CONDITIONS

Introduit pour la première fois dans le programme parcours_couleur_4, le commutateur (switch en
anglais) permet au programme de suivre différents chemins en fonction de la réalisation (ou non)
d'une condition, voire de plusieurs conditions successives …

Le mot-clé de la condition – donc de l'utilisation d’un commutateur – qui apparaît tout
naturellement dès le pseudo-code est SI. Dans un programme destiné à faire fonctionner un robot, la
condition est le plus souvent un événement-capteur : si tu te cognes dans un obstacle, si tu repères
devant toi un obstacle, si tu vois telle couleur, etc. mais il est important de bien se rappeler pour
l'implémentation de futurs programmes plus complexes que la condition peut être aussi un nombre,
un booléen voire un mot ou une phrase …

Un enchaînement de SI peut faire intervenir plusieurs capteurs : SI la lumière ambiante est
supérieure à 50 ET SI le capteur tactile n'est pas enfoncé ET SI le capteur à ultra-sons ne détecte
rien à moins de 50 cm, etc.

CORRIGER UN PROGRAMME

Pour rectifier un programme et distinguer les parties qui se comportent de la manière attendue des
autres, il suffit de placer des pauses à des endroits « stratégiques » du programme – ou à des
intervalles réguliers – avec un simple capteur temps paramétré sur une seconde …

PROJET, PSEUDO-CODE, IMPLÉMENTATION ET TEST

On peut maintenant à ce stade de notre progression proposer un projet (différent) aux groupes, leur
demander de le mener à bien, du début à la fin.

Exemples de projets :

   1) Le robot doit pouvoir circuler sur une table sans tomber. On pourra utiliser soit le capteur à
      ultra-sons soit le capteur tactile monté de telle façon qu'il soit pressé continuellement par la
      table.
   2) Le robot doit suivre un chemin matérialisé sur le sol par une ligne de couleur. On utilisera
      ici le capteur de couleurs, le chemin pourra être une ligne courbe ou une ligne brisée avec
      uniquement des angles droits (plus facile).

   3) Le robot démarre et s'arrête sur un signal sonore (exemple un claquement de mains). On
      montera ici le capteur sonore.

4) Le robot effectue un parcours donné en évitant des obstacles placés sur son chemin (nombre
       d'obstacles variables). Capteur tactile ou à ultra-sons.

    5) Le robot démarre sur une certaine intensité lumineuse et s'arrête en son absence. (On allume
       et éteint la lumière de la pièce). On utilisera ici le capteur de couleurs paramétré en capteur
       de lumière.

LES VARIABLES ET LES CONSTANTES

Qu'est-ce qu'une variable ? Une variable est une « boîte », dans un programme, qui sert à contenir
une valeur. Cette valeur peut être numérique (un nombre entier ou décimal), logique (vrai / faux) ou
textuelle (lettre, mot ou phrase) – on parle alors du type de la variable.

A quoi sert une variable ? Une variable peut servir à enregistrer le résultat d'une action (Combien
cette boucle a-t-elle fait de tours ? Le robot a-t-il vu du rouge , oui ou non ? Quel est le premier mot
de cette phrase ?, etc.). Elle peut fournir une valeur à une action (Le robot va rouler pendant X
secondes avec la variable X = 5). Elle peut être fournie et /ou modifiée par le programmeur au cours
du programme ou par le programme lui-même au cours de son exécution …

Une variable qui ne peut plus être modifiée est une constante. Par exemple dans la formule du
calcul de la circonférence du cercle, Π (pi) est une constante.

Les icônes permettent de bien les différencier :

Voici la variable (paramétrée par défaut sur « Logique »

On peut soit la lire (fournir au programme sa valeur)

Soit l'écrire (lui affecter une valeur)

De même voici la constante :

Définir les variables et les constantes (leur nom, leur type, leur valeur) se fait dans le menu
« Modifier ». On peut créer autant de variables et de constantes qu'on le souhaite dans un
programme, il est important de leur donner un nom explicite (« vitesse », « nombre_de_rotations »,
« bouton_pressé_ ? » (pour une variable logique), etc.)

Voici un petit programme où la variable fournit une valeur (on parle d'argument) au programme :

Premier bloc : une variable appelée « Nombre 1 » (nom par défaut), de type numérique , de valeur 5
est créée (écrite), elle est fournie (lue) comme argument (2e bloc) à un bloc Déplacer comme durée
de ses rotations (3e bloc). Le robot va donc avancer de 5 rotations..

Création de la variable Nombre 1 :

Bien évidemment, en faisant « varier la variable » (cette répétition à elle seule explique le mot de
variable), on influe directement sur le programme.

Ce que l'on peut faire directement dans un programme d'ailleurs : reprenons le programme
précédent , implémentons-le dans une boucle (de 10 tours) et rajoutons l'instruction suivante qu'à
chaque tour de boucle la variable soit incrémentée de 1 (c'est-à-dire qu'elle augmente de 1). Voici le
programme parcours_variable :

Attention : si le premier bloc se trouvait dans la boucle, la variable serait remise à 5 à chaque tour
de boucle … Il est d'ailleurs très formateur de tester cette erreur courante en programmation.

Essayez l'implémentation du programme inverse, celui où la variable sera décrémentée (diminuée)
de 1 à chaque tour de boucle ...

TRANSMETTRE DES DONNÉES

Les variables dont nous avons parlé précédemment lorsqu’elles sont utilisées par les blocs sont des
données. Les programmes peuvent utiliser, modifier, transmettre à d’autres parties du programme
ces données par l’intermédiaire des plots d’entrée et de sortie des blocs et des fils qui les relient.

Trois types de données peuvent être transmises : des nombres, des booléens, du texte. À chaque
type de donnée correspond une couleur de fil. Les plots reçoivent et transmettent un type de donnée
et un seul : en cas de tentative de connexion d’un type incorrect, le fil apparaît en pointillés gris.
Un programme simple va nous permettre de bien le comprendre. Pour cela, nous allons
désolidariser le capteur tactile du robot sans le débrancher. Le capteur agira comme une
télécommande : s’il est pressé, le robot avancera d’une rotation ; s’il est relâché, il ne fera rien.

Le capteur tactile rendra une valeur VRAI / FAUX sur son état (pressé ou non), cette valeur logique
sera stockée dans une variable, cette variable conditionnera les deux options d’un commutateur
(avancer d’une rotation / ne rien faire).

La variable Logique 1 est un détour inutile et le programme fonctionne aussi bien comme ceci :

Une pause d'une seconde permet de mieux déterminer le moment où presser le capteur. Enregistrons
et testons le programme parcours_logique :

LES NOMBRES ALÉATOIRES

Pour apprendre à utiliser les nombres aléatoires ou tout simplement pour mettre un peu d'imprévu
dans nos programmes, nous allons refaire un programme parcours où nous laisserons l'ordinateur
décider de la durée du déplacement, de la marche avant ou arrière et de la direction à prendre lors
des virages … Voici une possibilité pour un programme parcours_aléatoire :

On pourrait faire encore davantage intervenir le hasard en affectant un nombre aléatoire aux
rotations à droite ou à gauche pour donner des amplitudes différentes aux virages.

Une autre application des nombres aléatoires ainsi qu'une utilisation du bloc Comparer pourrait être
celle-ci : on tire deux nombres aléatoires que l'on va comparer et suivant le résultat de la
comparaison, le robot va avancer ou reculer .

On peut ensuite explorer toutes les possibilités du bloc Comparer en changeant la condition de
retour de la valeur VRAI : A supérieur à B, A inférieur à B, A égal à B ; choisir d'afficher les
nombres aléatoires tirés ; comparer 3 nombres aléatoires et relier les comparaisons par un bloc
Logique ( si A supérieur à B ET si A supérieur à C), etc. Les possibilités n'ont d'autres limites que la
lassitude des utilisateurs. Voici une base de départ pour toutes les variations, le programme
comparer: (Le son joué permet de bien repérer les tours de boucle)

Nous voici arrivés à la fin de cette introduction à la programmation des robots Lego Mindstorms ®.
Certaines des notions présentées seront reprises et approfondies, d'autres seront abordées et
développées dans le chapitre suivant consacré à la mise en œuvre de projets.

                    Tout commentaire, toute appréciation seront les bienvenus à :

                                webmaster@programmer-a-l-ecole.fr