Cette série d’exercices corrigés sur Lego Mindstorms permet de se familiariser avec des logiciels de programmation et de robotique.
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.
- Faites effectuer à votre robot une trajectoire en forme de cercle à votre robot en illimité
- Faites avancer puis reculer (sur une courte distance seulement) de manière illimité
- 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 :
- Faire avancer le robot puis s’arrêter à 20 cm d’un obstacle,
- Faire avancer le robot puis s’arrêter au contact d’un obstacle,
- Faire avancer le robot puis s’arrêter à la vue d’une couleur au sol.
Boucle infinie
- 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.
- 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.
Boucles avec conditions d’arrêt
- 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é”.
- 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é”.
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
- 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.
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.
- Rédigez en pseudo-code un algorithme correspondant à cette problématique
- 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).
- 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.
- 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 :
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 :
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.
- Rédigez en pseudo-code un algorithme correspondant à cette problématique
- Implémentez votre algorithme dans votre robot.
Question bonus : votre programme peut-il suivre tous types de tracés ?
- 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.
- 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).
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 :
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 :
- 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é).
- 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.
- 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).
Exercice 6
A l’aide d’un graphe d’état (automate à état fini), donnez le programme au actions suivantes.
- 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.
2. Détection d’obstacle, le robot avance tout droit puis recule s’il heurte un obstacle
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.
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 :
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.
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.
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 :
- Décrivez un algorithme simple pour effectuer cette tache,
- Créez un programme effectuant ces actions à partir de l’algorithme.
1.
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 :
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.
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.
- Rédigez en pseudo-code un algorithme correspondant à cette problématique
- Implémentez votre algorithme dans votre robot
1.
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 :
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.
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 :
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 :
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.
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 :
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.
- Rédigez en pseudo-code un algorithme naïf permettant au robot de traverser un tel labyrinthe
- 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 ?
- Modifiez l’algorithme précédent pour prendre en compte ce changement
- Implémentez votre algorithme modifié dans votre robot
C- Impasse
On va maintenant prendre ce tracé de labyrinthe :
Comme vous pouvez le constater, ce labyrinthe comporte une impasse. Que faire si votre robot se retrouve dedans ?
- Modifiez l’algorithme précédent pour qu’il prenne en compte les impasses
- Implémentez votre algorithme modifié dans votre robot
- 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 :
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) :
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é :
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.
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 ) :
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) :
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 :
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 :
