9 Exercices Corrigés Lego Mindstorms

Cette série d’exercices corrigés sur Lego Mindstorms permet de se familiariser avec des logiciels de programmation et de robotique.

Lego Mindstorms

Exercice 1

Dans cet exercice, vous allez apprendre à programmer le robot pour effectuer des mouvements simples. Bien comprendre comment faire effectuer ses mouvements à votre robot est primordial car il aura constamment besoin de les effectuer dans les exercices suivants.

En vous aidant du guide de programmation qui vous a été fourni, veuillez programmer votre robot
pour qu’il effectue les actions suivantes :

avancer pendant une durée de 3 secondes,

reculer pendant une durée de 3 secondes,

tourner vers la gauche puis vers la droite.

Cet exercice a pour but d’expliquer simplement comment programmer le robot en utilisant le logiciel de LEGO. Il existe deux manières d’aborder ces problèmes :

soit en utilisant le bloc Déplacer (qui permet de contrôler les deux moteurs à la fois), soit en utilisant deux blocs Moteurs (un pour chaque moteur, qui permet de contrôler chaque moteur indépendamment).

La seconde façon utilise des boucles donc il est préférable de l’aborder si les étudiants sont à l’aise avec cette notion (qui sera vue dans le deuxième exercice).

– avancer pendant une durée de 3 secondes, Placer un bloc Déplacer, cocher les moteurs B et C et entrer 3 secondes comme durée.

– reculer pendant une durée de 3 secondes, Même chose que pour l’exercice précédent sauf qu’il faut sélectionner la direction « En arrière ».

– tourner sur des angles vers la gauche puis vers la droite. Placer le curseur de l’option « Diriger » soit complètement à droite, soit complètement à gauche.

Exercice 2

En  algorithmique  et  en  programmation,  une  boucle  est  une  structure  de  contrôle  qui  permet  de répéter une série d’instructions tant qu’une condition est vraie ou n’est pas respectée (selon le type de boucle  utilisé).  Il  en  existe  plusieurs  types  comme  par  exemple  Tant  que  (condition)  faire.  Une boucle  peut  aussi  être  infinie,  c’est-à-dire  que  son  bloc  d’instruction  sera  répété  indéfiniment  (plus concr`etement : jusqu’à arrêt manuel  du programme).

Le robot est équipé d’un certain nombre de capteurs (dont une description plus précise de chacun est  donnée  dans  le  guide  fourni).  Ces  capteurs  permettent  de  mesurer  différents  paramètres  de  l’environnement  dans  lequel évolue  le  robot.  Il  est  possible  de  se  servir  de  ces  mesures  comme  condition d’arrêt des boucles et c’est ce qui va nous intéresser par la suite.

Une boucle infinie nous permet donc de faire effectuer une action (ou une séquence d’actions) au robot sans condition d’arrêt particulière.

  1. Faites effectuer à votre robot une trajectoire en forme de cercle à votre robot en illimité
  2. Faites avancer puis reculer (sur une courte distance seulement) de manière illimité
  3. Boucle avec condition d’arrêt

Une  boucle  s’utilise  le  plus  généralement  avec  une  condition  d’arrêt,  c’est-à-dire  que  l’ensemble  des instructions  du  corps  de  boucle  ne  s’exécuteront  que  tant  que  la  condition  précisée  serait  vraie  (d’un point de vue logique). En pseudo-code, une boucle s’écrit de la manière suivante :

Tant Que (condition) faire

     instructions

Fin  Tant  Que

Vous  serez  par  la  suite  amenés  à  réfléchir  aux  algorithmes  de  vos  programmes  et  à  les  écrire sous forme de pseudo-code. Le pseudo-code est un langage  proche du naturel, c’est-à-dire que lors de l’écriture de l’algorithme vous n’avez pas besoin de réfléchir à l’implémentation (comment le traduire dans le langage de programmation).

Dans le cas de notre robot, on peut mettre comme condition des opérations logiques, un compteur ou  des  capteurs  et  c’est  ce  que  nous  allons  voir  ici.  Par  exemple,  admettons  que  notre  robot  possède un capteur de détection de bruit (ce n’est pas le cas en réalité) et qu’on veuille qu’il avance jusqu’à ce qu’il détecte un bruit, un algorithme en pseudo-code serait :

Tant  que  (bruit  non  détecté)

      Avancer()

Fin  Tant  Que

Lorsqu’il détectera le bruit, il arrêtera de répéter son bloc d’instructions.

Pour chacune des actions suivantes et en utilisant un capteur distinct, écrivez un petit algorithme en pseudo-code puis programmez le :

  1. Faire avancer le robot puis s’arrêter à 20 cm d’un obstacle,
  2. Faire avancer le robot puis s’arrêter au contact d’un obstacle,
  3. Faire avancer le robot puis s’arrêter à la vue d’une couleur au sol.

Boucle infinie

  1. Faites effectuer `a votre robot une trajectoire en forme de cercle à votre robot en illimité 

Pour cela, il faut utiliser deux blocs Moteurs  et les placer dans une boucle ”illimitée”. Pour effectuer la trajectoire en cercle, un moteur doit tourner plus vite que l’autre (jouer sur le paramètre ”Puissance”) comme par exemple B à 75 et C à 40.

  1. Faites avancer puis reculer (sur une courte distance seulement) de manière illimité

Il faut mettre deux blocs moteurs pour avancer (même puissance, même direction, même durée) dans une  boucle  infinie,  puis  remettre  deux  blocs  moteurs  pour  reculer  (la  direction  doit être  inversée  par rapport à l’action d’avancer).

Attention, pour que les deux moteurs soient actifs en parallèle, la durée doit être en degrés (par exemple 500) ou rotations et le premiers des deux blocs moteurs (pour chaque action), doit avoir l’option ”Attendre la fin” décochée.

lego mindstorms

Boucles avec conditions d’arrêt

  1. Faire avancer le robot puis s’arrêter à 5 cm d’un obstacle,

Tant Que (distance() 5)

     faire Avancer()

Fin  Tant  Que

Les boucles utilisées par le logiciel de programmation de LEGO ne sont pas des Tant  Que, c’est-à-dire que la condition de la boucle est la condition de sortie de boucle et non la condition de validité.

Ici, la boucle doit donc avoir le capteur ultrason comme paramètre de ”Contrôle” et comme condition ”Jusque < 5 cm”. Cette boucle doit contenir deux blocs Moteurs pour les moteurs B et C avec la même puissance et la même direction et dont la durée est ”illimité”.

lego mindstorms

  1. Faire avancer le robot puis s’arrêter au contact d’un obstacle,

Tant  Que  (CapteurTactile  non  enfoncé)  faire

     Avancer()

Fin  Tant  Que

La boucle doit contenir deux blocs Moteurs  pour les moteurs B et C (même puissance, même direction, durée  illimitée)  et  avoir  comme  contrôle  un  des  capteurs  tactile  avec  comme  condition  ”Action  : enfoncé”.

lego mindstorms

Attention  :  cette  version  est  simple  mais  le  robot  ne  s’arrête  qu’au  contact  d’un  seul  capteur.  Il est  néanmoins  possible  d’utiliser  une équation  logique  pour  mettre  en  jeu  les  deux  capteurs  (le  robot s’arrête avec le contact d’un des deux capteurs). Pour cela il faut utiliser deux blocs ”Capteur tactile” et construire l’équation logique suivante (que l’on entre comme condition dans une boucle avec comme contrôle ”Logique”) :

E = 1 + 2

lego mindstorms

  1. Faire avancer le robot puis s’arrêter à la vue d’une couleur au sol.

La  couleur  choisie  n’a  pas  vraiment  d’importance,  mais  le  noir  est  choix  pratique  car  il  peut  être mesuré avec le capteur de couleur ou de luminosité.

Tant Que (couleur() /= noir) faire

     Avancer()

Fin  Tant  Que

La boucle doit contenir deux blocs Moteurs  pour les moteurs B et C (même puissance, même direction, durée illimitée) et avoir comme contrôle le capteur de couleur en mode ”Couleur” avec comme condition ”Jusque dans la plage” et les curseurs encadrant le noir.

lego mindstorms

On peut utiliser le capteur couleur en mode ”Photosensible” pour cet exercice si la couleur d’arrêt est le noir. Pour cela, dans le mode ”Photosensible” mettre comme condition ”Jusque < X” où  X est une borne supérieure du noir à déterminer par mesure sur le support utilisé comme piste d’essai.

Exercice 3

Vous  allez  être  amené  à  programmer  votre  robot  pour  qu’il  compte  les  couleurs.  Il  devra  être capable d’avancer le long d’une zone comportant une succession de zones de couleurs certes, la fin de cette  zone  est  marquée  par  une  bande  noire.  Il  doit  donc  compter  le  nombre  de  fois  qu’apparait  une bande de couleur tout en avançant son écran. A la fin du parcours, il affichera le nombre de zone de couleur sur écran.

  1. Rédigez en pseudo-code un algorithme correspondant à cette problématique
  2. Implémentez votre algorithme dans votre robot

Le but de cet exercice est de faire réutiliser ce qui a été vu jusque l`a (boucles, capteur) tout en introduisant la notion de variable (d’un point de vue algorithmique et au niveau du logiciel de programmation du robot).

  1. Rédigez en pseudo-code un algorithme correspondant à cette problématique

CouleurPrecedente couleur() NbRouge 0

NbJaune 0

NbBleu 0

Tant  Que  (CouleurLue()  =/    NOIR)  faire

     Tant Que (couleur() = CouleurPrecedente)

          Avancer()

     Fin  Tant  Que

     Si (couleur() = ROUGE) alors NbRouge = NbRouge + 1

     Si (couleur() = JAUNE) alors NbJaune = NbJaune + 1

     Si (couleur() = BLEU) alors NbBleu = NbBleu + 1

     Fin Si

     CouleurPrecedente couleur()

Fin Tant  Que

couleur()  est  une  fonction  qui  retourne  la  valeur  numérique  de  la  couleur  lue  par  le  capteur  de couleur.

Cet  algorithme  fonctionne  de  la  façon  suivante  :  le  robot  avance  tant  qu’il  est  toujours  dans  la même  zone  de  couleur  puis  dès  qu’il  a  changé  de  zone,  il  incrémente  alors  la  variable  associée  à  cette couleur.  Il  finit  par  mettre  à  jour  la  variable  CouleurPrecedente  pour  ainsi  détecter  le  changement de  zone  au  prochain  tour  de  boucle.  Le  tout  est  dans  une  boucle  de  détection  du  noir  qui  arrêtera  le robot dès qu’il aura lu du noir.

  1. Implémentez votre algorithme dans votre robot

Pour  le  programmer,  il  faut  dans  un  premier  temps  créer  les  variables  qui  nous  serviront  par  la  suite (CouleurPrecedente, Rouge, Bleu, Jaune) ; elles sont de type numérique et initialisées dès le début du programme.

Après  on  place  une  boucle  principale  avec  comme  contrôle  ”Capteur  de  couleur”  et  comme  action ”Jusque dans la plage noire”. Au sein de cette boucle on remet une boucle contenant deux blocs moteurs pour faire avancer le robot (durée sur ”Illimité”). Le contrôle de cette boucle doit être placé sur ”Logique” avec comme entrée une opération de comparaison entre la variable ”CouleurPrecedente” et le capteur de couleur :

lego mindstorm

Après  cette  boucle,  on  place  trois  blocs  commutateur  (un  pour  chaque  couleur)  dans  lequel  on exécute  l’opération  d’incrémentation  de  la  variable  de  couleur  associée.  Voici  par  exemple  celui  du rouge :

lego mindstorms

Puis, après ces trois commutateurs, on n’oublie pas de remettre à jour la variable ”CouleurPrecedente” avec le capteur de couleur (comme lors de l’initialisation).

Après  la  boucle  principale,  on  effectue  un  affichage  du  contenu  des  variables  couleurs  sur  l’écran  ou avec des sons.

Exercice 4

Le robot doit suivre un tracé au sol de couleur noir, le sol étant blanc.

  1. Rédigez en pseudo-code un algorithme correspondant à cette problématique
  2. Implémentez votre algorithme dans votre robot.

Question bonus : votre programme peut-il suivre tous types de tracés ?

  1. Rédigez en pseudo-code un algorithme correspondant `a cette problématique

Tant que (vrai) faire

     Tant Que (couleur() = NOIR) faire

          DevierGauche()

     Fin Tant Que

     Tant Que (couleur() = BLANC) faire

          DevierDroite()

     Fin Tant  Que

Fin  Tant  Que    

couleur() est une fonction qui retourne la valeur numérique de la couleur lue par le capteur de couleur.

DevierGauche()  et  DevierDroite()  sont  des  fonctions  qui  font  avancer  le  robot  en  déviant  vers  la gauche ou vers la droite.

Un suiveur de ligne ne suit en réalité pas la ligne mais le bord de la ligne (la limite entre le blanc et le noir). L’algorithme présenté ici est très simple. Au sein d’une boucle infinie, on place deux boucles : une  pour  le  noir  et  une  pour  le  blanc.  La  boucle  pour  le  noir  fait  dévier  le  robot  vers  la  gauche  tant qu’il  lit  du  noir,  et  la  boucle  pour  le  blanc  fait  dévier  le  robot  vers  la  droite  tant  qu’il  lit  du  blanc. Ainsi, le robot alterne les mouvements vers la gauche et vers la droite.

Note  :  cet  algorithme  correspond  à  un  ”suiveur  gauche”,  c’est-à-dire  dans  le  cas  où  le  blanc  est  à gauche du noir. On peut faire un ”suiveur droite” en inversant les sens de déviation.

  1. Implémentez votre algorithme dans votre robot

Pour  l’implémenter  dans  le  robot,  on  place  en  premier  lieu  un  bloc  ”boucle”  avec  comme  contrôle ”Pour toujours”.

Dans ce bloc, on place alors une autre boucle mais cette fois-ci avec pour contrôle ”Capteur de couleur” en mode ”Photosensible” et avec comme action ”Jusque < 35” (35 est une valeur de la borne supérieure de la luminosité du noir, cette valeur est à déterminer par mesure lors de la séance car elle peut varier selon l’éclairage ou la piste d’essai utilisée).

A  l’intérieur de cette boucle, placer deux blocs ”Moteurs” pour  chacun  des  deux  moteurs  dont  l’un  des  deux  a  une  puissance  moins  élevée  que  l’autre  (pour dévier  à  gauche,  le  moteur  C  doit  aller  moins  vite  que  le  B).  Faire  une  boucle  similaire  pour  le  blanc avec cette fois-ci action positionné sur ”Jusque  > 35” et les puissances des moteurs inversées.

L’écart  entre  les  puissances  respectives  des  moteurs  jouera  à  la  fois  sur  la  vitesse  globale  du  robot (le  temps  qu’il  mettra  à  faire  un  tour  complet)  et  sur  sa  capacité  à  suivre  un  tracé  plus  ou  moins tordu. Pour cela, ne pas hésiter à faire plusieurs essais avec des valeurs différentes pour trouver un bon compromis (des valeurs correctes sont par exemple 75 et 10).

lego mindstorms

Question bonus : votre programme peut-il suivre tous types de tracés ?

Normalement  ce  programme  ne  permet  pas  de  suivre  tous  les  types  de  tracés.  En  effet,  dès  que  le tracé deviendra trop complexe, le robot ne devrait plus être capable de suivre (à moins d’avoir un des deux  moteurs  quasiment à  l’arrêt,  ce  qui  le  rendra  alors  très  lent).  Il  ne  peut  pas  suivre  un  virage intérieur  ou  trop  serré,  ni  un  virage  en  angle  droit.  Pour  s’en  convaincre,  ne  pas  héesiter  à  l’exécuter sur les circuits bonus.

Exercice 5

Lors de l’exécution de certaines taches, votre robot est souvent amené à refaire des actions standards plusieurs fois comme par exemple tourner à 90˚vers la droite ou avancer de 10 cm. Afin d’alléger  votre programme, il est possible de créer des blocs personnalisés qui s’utilisent par la suite comme les blocs par défaut (de cette façon, au lieu d’avoir plusieurs fois les différents blocs qui gèrent les calculs d’angle et l’activation des moteurs, on n’en utilise qu’un plusieurs fois). Ce principe s’apparente aux fonctions (ou procédures) en algorithmique.

Pour rappel, en algorithmique, une fonction est une suite d’instructions relativement indépendantes du  programme  principal  et  qui  est  répétée  plusieurs  fois.  Cette  suite  d’instruction  est  alors  regroupé dans un seul bloc d’instruction qui est la fonction.

En vous servant du guide de programmation (et plus particulièrement de la partie création de bloc) ainsi que de l’annexe sur les calculs de distance et de rotation, créez les blocs personnalisés suivants :

  • Avancer :  fait  avancer  le  robot  selon  la  distance  donnée  en  entrée  (cette  distance  sera  en  centimètres),
  • Reculer :  fait  reculer  le  robot  selon  la  distance  donnée  en  entrée  (cette  distance  sera  en  centimètres),
  • TournerDroite : fait tourner le robot selon un angle donné en entrée vers la droite,
  • TournerGauche : fait tourner le robot selon un angle donné en entrée vers la gauche,
  • PivoterDroite : fait pivoter le robot selon un angle donné en entrée vers la droite,
  • PivoterGauche : fait pivoter le robot selon un angle donné en entrée vers la gauche

Maintenant, à l’aide des blocs que vous venez de créer, veuillez créer un programme qui permet à votre robot d’effectuer cette trajectoire :

lego mindstorms

Il faut donc se servir du guide de programmation ainsi que de l’annexe sur les distances et rotations pour créer les blocs et implémenter les formules grâce aux blocs d’opérations mathématiques.

– Avancer : fait avancer le robot selon la distance donnée en entrée (cette distance sera en centimètres),

Il faut donc coder la formule distance*360/13.5 en utilisant des constantes pour 360 et 13,5 et une variable en mode lecture pour la distance ; puis donner le résultat en valeur d’entrée d’un bloc Déplacer paramétré sur une durée en ”Degrés”. Pour créer le le bloc, il suffit donc de sélectionner tous ces blocs sauf le bloc de variable pour la distance, puis aller dans Modifier → Créer nouveau bloc Mon bloc :

lego mindstorms

  • Reculer : fait reculer le robot selon la distance donnée en entrée (cette distance sera en centimètres),

Il faut coder la même formule que pour le bloc Avancer mais cette fois le bloc Déplacer doit être paramétré pour faire tourner les moteurs dans l’autre sens.

  • TournerDroite : fait tourner le robot selon un angle donné en entrée vers la droite,

Cette fois-ci, c’est la formule angle*2pi*15.5/13.5 et mettre le résultat en entrée du moteur C (le moteur B devant être désactivé).

lego mindstorms

  • TournerGauche : fait tourner le robot selon un angle donné en entrée vers la gauche,

La formule reste la même que précédemment mais cette fois c’est le moteur B qui est activé et le moteur C qui est désactivé.

  • PivoterDroite : fait pivoter le robot selon un angle donné en entrée vers la droite,

La formule est quasiment la même que précédemment sauf qu’on enlève le coefficient 2 (le cercle décrit étant deux fois moins grand). Par ailleurs, le résultat du calcul est donné en entrée des moteurs B et C cette fois ; le moteur C allant vers l’avant et le moteur B vers l’arrière.

lego mindstorms

  • PivoterGauche : fait pivoter le robot selon un angle donné en entrée vers la gauche. Même formule que pour le bloc précédent sauf que les sens des moteurs sont inversé

Les fichiers sont à placer dans le dossier Blocks/Mes blocs du dossier du profil : Avancer.rbt, Reculer.rbt, TournerGauche.rbt, TournerDroite.rbt, PivoterGauche.rbt, PivoterDroite.rbt

La trajectoire à faire effectuer ensuite au robot est plutôt simple avec les blocs. Il faut donc placer successivement les blocs Avancer, PivoterDroite, Avancer, PivoterGauche, Avancer, PivoterDroite, Avancer, PivoterDroite, Avancer, PivoterDroite avec les distances et angles associés. Attention néanmoins à prendre la bonne valeur d’angle pour les pivots (on doit prendre la valeur de l’angle supplémentaire).

lego mindstorms

Exercice 6

A l’aide d’un graphe d’état (automate à état fini), donnez le programme au actions suivantes.

  1. S’arrêter au bon endroit

L’état initial considère le robot dans le blanc, cela permet de pouvoir faire démarrer le robot de n’importe où (c’est-à-dire du blanc ou du noir). A chaque changement de couleur (noir ou blanc), il passera dans l’état suivant. Chaque état à comme action associée le fait d’avancer sauf l’état suivant la troisième transition noir (qui correspond donc à la troisième fois que le robot rencontre une zone noire) où le robot s’arrête.

lego mindstorms

 2. Détection d’obstacle, le robot avance tout droit puis recule s’il heurte un obstacle

lego mindstorms

3. Le robot avance tout droit puis tourne à droite (resp. à gauche) s’il rencontre un obstacle à gauche (resp. à droite) ou fait demi-tour si l’obstacle est face à lui.

lego mindstorms

1.

Pour programmer ce graphe d’état, il faut préalablement créer une variable de type numérique etat qui contiendra l’état courant. Elle sera sera initialisée à 0 au début du programme. On ajoute au sein d’une boucle donc la condition est jusqu’à etat = 5, un premier commutateur sur la valeur de la variable etat qui permettra de changer la valeur de l’état courant selon les actions détectées (lecture de blanc ou de noir) suivi d’un second commutateur aussi sur la valeur de la variable etat qui déterminera les actions à effectuer dans chaque état :

lego mindstorms

2.

Il faut procéder de la même façon que pour le programme précédent : deux commutateurs ; un pour les transitions et un pour les actions. Néanmoins, sur le fichier fourni en correction nous avons regroupé ces deux commutateurs en un pour montrer que cela était aussi possible. Le changement de la variable etat se fait donc à la fin de la boucle d’action. Cette façon est plus compacte mais un peu moins claire et organisée mais reste possible et fonctionnelle.

lego mindstorms

3.

On reprend donc la même structure de programme que précédemment mais cette fois en différenciant bien le contact à gauche ou à droite.

lego mindstorms

Exercice 7

On  va  chercher  à  programmer  le  robot  pour  qu’il  recherche  un  objet  dans  un  espace  délimité  par un trait noir et le sorte de cet espace. Votre programme devra donc comporter deux phases distinctes : une première de recherche de l’objet et une seconde de sortie de l’objet de cet espace (il sortira l’objet en  le  poussant  vers  l’extérieur).

 Votre  programme  doit être  intelligent  :  il  ne  faut  pas  programmer  le robot pour qu’il aille directement à l’objet (ce dernier pouvant se trouver n’importe où dans l’espace). De plus, le robot devra partir dans une position bien distincte. Voici un exemple de placement d’objet :

  1. Décrivez un algorithme simple pour effectuer cette tache,
  2. Créez un programme effectuant ces actions à partir de l’algorithme.

lego mindstorms

1.

lego mindstorms

Dans un premier temps le robot avance jusqu’à soit rencontrer du noir, soit toucher un objet. S’il rencontre du noir, il recule et pivote alors d’un angle aléatoire (compris entre 0 et 180 degrés) puis repart. S’il rentre en contact avec un objet, il continu alors d’avancer jusqu’à rencontrer du noir ; il aura alors sorti l’objet du cadre.

2.

Pour programmer ceci, on commence par placer une boucle avec comme condition logique que l’un des capteurs tactiles soit enfoncé (utiliser donc les blocs pour ces capteurs avec un bloc logique OU ). On place alors à l’intérieur de cette boucle une boucle avec comme condition logique Noir OU (Tactile1 OU Tactile2), on arrête les moteurs à la sortie de cette boucle pour ne pas que le robot sorte du cadre si la boucle s’est arrêtée parce qu’il a vu du noir :

lego mindstorms

On place ensuite un commutateur pour voir si la boucle s’est interrompue car le robot a vu du noir. Dans ce cas, on place un bloc Reculer – créé dans l’exercice précédent – suivi d’un bloc Aléatoire qui tire un nombre compris entre 0 et 180 et le donne en entrée d’un bloc PivoterGauche.

lego mindstorms

Après la boucle principale, on place une boucle faisant avancer le robot jusqu’à ce qu’il voit du noir.

Exercice 8

Comme dans le précédent exercice, on va programmer notre robot pour qu’il recherche un objet dans un espace. Sauf que dans cette version on utilisera le capteur ultrason. Il s’agit donc de programmer le robot pour que dans un premier temps il recherche dans quelle direction se trouve l’objet, puis qu’ensuite il se dirige vers lui et s’arrête à 5 cm.

  1. Rédigez en pseudo-code un algorithme correspondant à cette problématique
  2. Implémentez votre algorithme dans votre robot

1.

lego mindstorms

Ici, plutôt que de chercher de façon aveugle l’objet, le robot va chercher dans quelle direction il se trouve. Pour cela, le capteur va balayer tout l’espace face au robot (le capteur fera une rotation sur un angle de 180˚) et chercher la plus courte distance à un obstacle (sur le même principe qu’un algorithme de recherche de minimum dans un tableau) ; il mémorisera l’angle pour ainsi déduire la direction dans laquelle le robot ira.

2.

Dans un premier temps, on fait tourner le moteur A de 90˚ vers la gauche pour orienter le capteur ultrason, puis on place juste après un bloc capteur Rotation pour réinitialiser la valeur renvoyée par ce dernier. On stocke ensuite dans une variable distanceMin la valeur renvoyée par le capteur ultrason et on initialise une autre variable angle à 0. Et enfin, on lance une rotation lente de A vers la droite :

lego mindstorms

On place maintenant une boucle dans laquelle on effectuera les comparaisons pour trouver l’angle de la distance minimale. Cette boucle a pour contrôle le capteur de rotation du moteur A et comme condition jusque > 180˚. Au début de la boucle, on mémorise dans Nombre 1 la distance mesurée par le capteur ultrason et dans angle la valeur renvoyée par le capteur de rotation de A. On effectue alors les comparaisons et éventuelles affectation avec ces variables.

lego mindstorms

Enfin, après la boucle, on arrête le moteur A puis on lui fait effectuer une rotation de 90˚vers la gauche pour recentrer le capteur ultrason. On fait alors pivoter le robot en fonction de la valeur de angle puis on le fait avancer jusqu’à 5 cm de l’objet :

lego mindstorms

AUTRE APROCHE :

On fait pivoter lentement le capteur ultrason jusqu’à ce qu’on est un obstacle et à ce moment on fait se diriger le robot vers lui. Cette approche suppose donc que l’espace face au robot (donc sur une distance donnée, par exemple 40 cm) ne comporte que l’objet recherché, elle reste donc moins bonne que la précédente mais plus simple à comprendre, c’est pourquoi elle est présentée ici :

lego mindstorms

Le programme ressemble donc beaucoup au la version initiale, si ce n’est que la rotation du moteur A s’arrête dès qu’il détecte un objet.

lego mindstorms

Exercice 9

On va maintenant programmer le robot de façon à ce qu’il soit capable de sortir d’un labyrinthe simple. Attention, trouver un chemin pour traverser un labyrinthe est problème difficile d’un point de vue informatique (on parle de problème NP-Complet ), c’est pourquoi tous les labyrinthes proposés sont simples car il ne vous est pas demandé un algorithme efficace pour tous les labyrinthes.

A- Labyrinthe de base

Le premier type de labyrinthe est composé uniquement de parois hautes (25 cm). Voici son plan :

lego mindstorms

Vous allez donc devoir programmer votre robot pour qu’il le traverse. Pour cela, vous devrez utiliser le capteur ultrason pour déterminer à chaque intersection de quel côté aller.

  1. Rédigez en pseudo-code un algorithme naïf permettant au robot de traverser un tel labyrinthe
  2. Implémentez votre algorithme dans votre robot

B- Labyrinthe avancé

On modifie maintenant le labyrinthe en remplaçant une paroi haute par un obstacle bas (10 cm).

Comment faire pour que le robot traverse toujours le labyrinthe ?

  1. Modifiez l’algorithme précédent pour prendre en compte ce changement
  2. Implémentez votre algorithme modifié dans votre robot

C- Impasse

On va maintenant prendre ce tracé de labyrinthe :

lego mindstorms

Comme vous pouvez le constater, ce labyrinthe comporte une impasse. Que faire si votre robot se retrouve dedans ?

  1. Modifiez l’algorithme précédent pour qu’il prenne en compte les impasses
  2. Implémentez votre algorithme modifié dans votre robot
  3. Question bonus : peut-il traverser tous les labyrinthes ?

A-

Ce premier type de labyrinthe ne comporte qu’un chemin qui mène directement à la sortie. Le but est de comprendre le comportement du robot au sein de ce labyrinthe ; c’est-à-dire avancer jusqu’à un mur puis chercher de quel côté tourner. 

Pour savoir de quel côté tourner, on peut avoir plusieurs approches, comme par exemple regarder arbitrairement à gauche pour voir s’il y a un obstacle et le cas échéant tourner à gauche sinon à droite. Dans l’algorithme (et donc le programme proposé) suivant, à chaque intersection le robot tourne du côté où l’obstacle est le plus loin. Voici l’algorithme :

lego mindstorms

Le robot avance jusqu’à 15 cm du mur puis s’arrête. Il mesure alors la distance le séparant du mur à gauche puis du mur à droite. il tourne alors du côté où cette distance est la plus grande puis recommence à avancer. Il s’arrête dès qu’il voit du rouge.

On commence par placer des blocs Variable en mode Ecrire pour initialiser les variables distanceGauche et distanceDroite à 0. Ensuite, on place une boucle avec comme contrôle le capteur de couleur et comme condition d’arrêt Jusque dans la plage rouge (cette boucle permettra de terminer le programme lorsque le robot sera à la fin du labyrinthe).

On place ensuite une boucle pour faire avancer le robot jusqu’à un obstacle. Elle doit donc contenir deux blocs Moteur pour B et C avec une comme durée Illimité

Attention, le robot doit s’arrêter (et donc sortir de cette boucle) soit à 15 cm d’un obstacle, soit quand il voit du rouge ; le contrôle ne doit donc pas être le capteur ultrason mais une équation logique construite avec deux blocs capteurs (capteur ultrason réglé sur distance inférieure à 15 cm et capteur de couleur réglé sur dans la plage rouge) :

lego mindstorms

La suite du programme est l’ensemble des instructions correspondant à choisir de quel côté le robot va tourner. Cette partie prend place au sein d’un commutateur avec comme contrôle le capteur de couleur et réglé sur Hors de la plage rouge ; en effet, cela permet de ne pas effectuer la recherche d’obstacle si le robot s’est arrêté. 

La première étape consiste donc à faire tourner le moteur A vers la gauche puis d’enregistrer la valeur retournée par le capteur ultrason dans distanceGauche, puis de faire tourner le moteur A vers la droite et d’enregistrer la valeur retournée par le capteur ultrason dans distanceDroite. On compare ensuite les deux variables et dans un commutateur logique qui prend en entrée le résultat de la comparaison, on utilise les blocs PivoterDroite ou PivoterGauche créés dans un exercice précédent (avec 90 comme valeur d’angle en entrée) pour tourner du bon côté :

lego mindstorms

B-

On modifie maintenant le labyrinthe en remplaçant une paroi haute par un obstacle bas (10 cm).

Pour prendre en compte ce changement, il faut ajouter l’utilisation du capteur tactile. On va donc faire s’arrêter le robot s’il touche un obstacle qu’il n’aurait puˆ voir avec le capteur ultrason.

lego mindstorms

L’algorithme est quasiment le même que pour la question précédente. Seule la condition de la boucle pour faire avancer le robot a changé : le robot arrête d’avancer s’il est à 15 cm d’un obstacle OU s’il touche un obstacle. Après cette boucle, on ajoute une condition pour vérifier si c’est le second cas (capteurs tactiles) qui a fait s’arrêter le robot, et si c’est le cas, on le fait reculer de 15 cm. La suite de l’algorithme est inchangée.

Il suffit donc de reprendre le programme précédent et d’y apporter quelques modifications et ajouts. Il faut modifier l’équation logique de contrôle de la boucle qui fait avancer le robot jusqu’à un obstacle. Le robot doit maintenant en effet s’arrêter s’il est à 15 cm d’un obstacle ou s’il voit du rouge ou s’il rentre en contact avec un obstacle. On doit donc ajouter les blocs correspondants aux capteurs tactiles 1 et 2 avec un bloc logique (type OU ) :

lego mindstorms

Après cette boucle, on place un commutateur pour vérifier si on est sorti de la boucle à cause des capteurs tactiles et faire reculer le robot de 15 cm le cas échéant (pour cela, on peut utiliser le bloc créé pour reculer) :

lego mindstorms

C-

Le robot est dans une impasse si, lorsqu’il est arrêté (donc bloqué par une paroi face à lui), les parois à gauche et à droite sont trop rapprochées de lui (la distance mesurée à gauche est inférieure à une certaine distance – ici on a choisi 20 cm –, idem pour la distance mesurée à droite). Il faut donc modifier la condition pour décider de quel côté tourner :

lego mindstorms

L’algorithme est donc très similaire au précédent. On a ajouté la condition Si (distanceGauche < 20 ET distanceDroite < 20) qui permet de détecter une impasse et donc fait faire demi-tour au robot si c’est le cas. Sinon la décision du côté duquel tourner reste la même.

Pour détecter les impasses, on reprend le programme du labyrinthe avancé et on place les blocs servant à déterminer de quel côté le robot va tourner dans un commutateur ayant comme contrôle une valeur logique : la valeur sera le résultat de l’équation distanceGauche < 20 ET distanceDroite <20 :

lego mindstorms

Partager