Projets

[MP04e] Lego, ça rend marteau !

Objectifs :

  • Découverte du robot lego Mindstorm Education NXT 2.0
  • Programmation des déplacements du robot NXT
  • Programmation comportementale du robot NXT

Critères d'évaluation :

C1.2 Détailler le déroulement d'une communication numérique, le rôle des constituants d'un système numérique, ce qu'effectue tout ou partie d'un programme ou de l'algorithme associé,...

Lectures et travail demandés :

INTRODUCTION

Le robot Lego Mindstorm NXT est très utilisé dans l’apprentissage de la robotique. Accessible dès l’âge de 8 ans par l’intermédiaire d’un langage graphique à base de pictogramme, le robot NXT est un système très évolué capable d’effectuer des tâches complexes (et même simultanées). Il peut être aussi programmé avec des langages évolués comme le langage C ou le Java, ce qui fait qu’il est beaucoup utilisé dans les grandes écoles d’ingénieurs. Pour notre module de formation « robotique », le robot NXT sera assemblé dans une configuration prédéfinie.

Sa programmation et sa mise en œuvre nécessite d’identifier la nature des informations délivrées par ses capteurs et les limites de leur utilisation.

DECOUVERTE DU ROBOT LEGO MIBDSTORM NXT V2.0

Objectif : Vérifier les caractéristiques annoncées par le fabricant et déterminer les limites d’utilisation des capteurs.

La brique NXT est le « cerveau » du robot Mindstorms. Les fonctionnalités associées aux quatre boutons poussoirs sont présentées dans le Guide_NXT.pdf (voir pages 10-13). Les programmes implantés dans la brique vont vous aider à tester les différents capteurs disponibles.

Ceux-ci sont représentés ci-dessous. Pour chacun d’eux une procédure de test est proposée dans les paragraphes B1.1 à B1.4 de ce document.

Capteur tactile

servomoteur interactif

Capteur à ultrasons

Capteur photosensible

Capteur sonore

Vérifier que l’assemblage du robot mis à votre disposition correspond au robot professeur. Sinon signaler le au professeur.

Vérifier que :

  • le servomoteur gauche (côté haut-parleur) est bien connecté au port C
  • le servomoteur droit est bien connecté au port A
  • le capteur tactile est connecté au port 1
  • le capteur ultrason est connecté au port 2
  • le capteur photosensible est connecté au port 3
  • le capteur sonore est connecté au port 4

Test du capteur tactile

Le capteur tactile est présenté dans le guide page 26

Testez-le comme cela est décrit dans le guide. Pour cela, il est nécessaire de se rendre dans le menu de la brique :

View -> Select « Touch » -> Port 1

Relevez les valeurs affichées par le NXT, pour chacun des états (actionné, non actionné) du capteur.

Test du capteur de rotation intégré au servomoteur interactif

Le servomoteur interactif et le capteur de rotation intégré (tachymètre) sont présentés dans le guide pages 34-35.

Un servomoteur est connecté sur le port A. Sélectionnez le Port A dans le menu de la brique :

View -> Select « Motor rotations » -> PortA

Faites tourner (doucement) le moteur à la main.

L’écran indiquant initialement « 0 », quelle est la valeur affichée après que le moteur ait effectué trois tours dans le sens horaire ? Toujours en partant de la valeur zéro, quelle est celle affichée sur l’écran après que le moteur est effectué trois tours dans le sens antihoraire ?

Réglez l’affichage pour obtenir le déplacement angulaire du capteur par : View -> Select «Compléter le tableau ci-dessous.Motor degrees » -> PortA

Faites tourner (doucement) le moteur à la main.

L’écran indiquant initialement 0, quelle est la valeur affichée après que le moteur ait effectué trois tours dans le sens horaire ?

Toujours en partant de la valeur zéro, quelle est celle affichée sur l’écran après que le moteur est effectué trois tours dans le sens antihoraire ? L’angle obtenu est-il correct ? Si la réponse est non, quelle valeur devrait-on obtenir ?

Test du capteur à ultrasons

Le capteur à ultrasons est présenté dans le guide page 32.

Testez-le comme cela est décrit dans le guide

Relevez les distances minimum dmin et maximum dmax de détection du capteur affichées à l’écran et mesurer la distance réelle avec un mètre. Comparez cet intervalle à celui annoncé par le fabricant dans le guide. La précision annoncée est-elle respectée ?

Test du capteur photosensible

Le capteur photosensible est présenté dans le guide pages 30.

Testez-le comme cela est décrit dans le guide

Relevez le % de lumière réfléchie en fonction des couleurs.

Test du capteur sonore

Le capteur sonore est présenté dans le guide pages 28.

Testez-le comme cela est décrit dans le guide.

Programmation des déplacements du robot NXT

Le Robot Lego Mindstorm Education NXT V2.0 est équipé d'actionneurs (ici 2servomoteurs) lui permettant, entre autre, de se déplacer. L'objectif de cette séance est d'obtenir un déplacement le plus précis possible en programmant la brique à l'aide d'un langage de programmation évolué : le NXC.

Logiciel BricxCC

Ce logiciel est gratuit et permet de programmer dans un langage proche du C, le « NXC » soit « Not eXactly C » (pas exactement du C). Son EDI (Environnement de Développement Intégré), nommé BricxCC (Bricx Command Center), est convivial et met à disposition des programmateurs de nombreux outils d’aide au développement.

Configurer BricxCC : voir document ressource « cours_Mecatro_NXT.pdf » pages 10-17.



Remarques :

  • Le driver pour nxt doit être installé sur le PC.
  • Le programme interne du robot doit être mis jour (menu Tools/Download Firmware).

Utilisation des moteurs

Les robots NXT sont équipés d’actionneurs pouvant être utilisé en autre pour le déplacement.

Voir document ressource « cours_Mecatro_NXT.pdf » pages 24-30.

Réaliser et tester le programme dont l’algorithme est le suivant :

Pour cela :

Ouvrir un nouveau fichier programme. Nommer le directement et enregistrer le dans votre répertoire de travail personnel ( exemple : test_moteurs.nxc).

Cliquer dans la fenêtre Template (raccourci F9), au niveau du groupement Programs, sur l’instruction task…(){}. Cela va créer un bout de code informatique automatiquement au niveau de votre programme. Ce bout de programme permet de définir une tâche à réaliser pour le robot. Il faut nommer cette tâche et la compléter. Il s’agit là de notre programme principal (« main »). Il faut donc remplacer task ‘’ name ‘’ () par task main (). Les accolades ouvrantes ( { ) et fermente ( } ) permettent de délimiter la tâche (cela représente le début et la fin de notre algorithme).

Pour activer le moteur, nous allons utiliser la procédure OnFwd accessible comme précédemment via la fenêtre Template dans la rubrique Outputs.

Pour effectuer une attente de 4 secondes, nous allons utiliser la procédure Wait() accessible via la fenêtre Template dans la rubrique Timing.

Nous obtenons le programme suivant :

Vérifier que votre robot est allumé et connecté le à votre PC via USB puis lancer la compilation (F5) et chargement de votre programme (F6) dans la brique NXT. Une fois chargé, vous pouvez soit lancer votre programme depuis votre PC (run : F7 et stop : F8), mais votre robot reste relié à votre PC, soit depuis la brique dans le menu My Files/software files

 

Déplacement en ligne droite sur 1 m

Présentation des moteurs

Nous allons maintenant apprendre à déplacer le robot avec précision. Pour cela, nous devons effectuer des mesures au niveau des actionneurs.

Mesure du déplacement du robot par odométrie

L’odométrie est une technique permettant d'estimer la position d'un véhicule en mouvement. Cette mesure de bas niveau est présente sur quasiment tous les robots mobiles, grâce à des capteurs de rotation. Sur le NXT, le capteur de rotation intégré au servomoteur, mesure la rotation du moteur en degrés (précision +/-1 degré). L'odométrie repose sur la mesure individuelle des déplacements des roues pour reconstituer le mouvement global du robot. En partant d'une position initiale connue et en ajoutant les déplacements mesurés, on peut ainsi calculer à chaque instant la position courante du véhicule.

Instructions de programmation pour contrôler le moteur avec précision

La procédure de commande de position utilisée dans BricxCC est la suivante :

RotateMotor(outputs,power,angle);

Avec  “angle” en ° (peut être négatif pour tourner dans le sens inverse)

Ainsi pour que le robot face un tour de roue dans le sens horaire, le paramètre « angle » doit être réglé à +360.

Pour effectuer 4 tours de roue, il faut soit configurer la fonction RotateMotor avec angle=360x4=1440°, soit mettre en place une boucle.

Au niveau des boucles, deux possibilités s’offrent à nous :

for (initialisation;condition;incrémentation) {instruction};

OU

repeat (expression) {instructions} ;

Exemple d’utilisation  du « for » :

Exemple d’utilisation du « repeat »

Rédiger et tester un programme qui permet de faire avancer de 4 tours de roue en utilisant l’instruction repeat.

Avancer en ligne droite

Vous avez observé lors du programme précédent que votre robot se déplace de travers. Cela est normal, car les moteurs sont tous légèrement différents. Ainsi pour la même instruction de rotation d’angle, chaque moteur tourne à une vitesse différente, d’où le déplacement de travers. Pour pouvoir remédier à ce phénomène, nous allons mesurer en temps réel le nombre de degrés effectués par chaque moteur, à l’aide du capteur de rotation intégré, puis corriger le décalage si besoin.

Pour mesurer le nombre de degrés, nous allons utiliser la fonction suivante :

  • MotorRotationCount(output);  // Le capteur renvoie le nombre de degrés effectués sur le moteur

Pour initialiser le capteur, nous allons utiliser la procédure suivante :

  • ResetRotationCount(output);  // remise à zéro du capteur de rotation intégré

 Rappel : il faut bien différentier le terme procédure et fonction (la fonction ou la procédure exécutent toutes les deux des instructions mais seule la fonction renvoie une valeur).

 L’algorithme est le suivant :

Avancer en ligne droite sur 1m

Nous souhaitons créer une procédure qui permet d’avancer en ligne droite sur une distance et une vitesse définies par l’utilisateur : Marche_avant(puissance, distance)

Exemple d’utilisation d’une procédure :

Pour effectuer un déplacement de notre robot sur une distance précise, nous devons déterminer le nombre de degrés de rotation moteur correspondant.

Pour cela nous allons calculer le périmètre de notre roue et ainsi déterminer la distance parcourue par notre robot lors d’une rotation de 1°.

Quelques explications :

Mesurer avec une règle le diamètre de vos roues ou lire ce diamètre directement inscrit sur la roue (exemple : 43.2 x 22 => diamètre 43,2 mm et largeur 22 mm).

La connaissance du diamètre de la roue va nous permettre de calculer la distance quelle aura parcourue en faisant un tour (soit 360°).

Pour cela nous allons devoir calculer sa circonférence.

La circonférence d'une roue (ou périmètre d’un cercle) représente la longueur d’une ligne courbe fermée. Cette circonférence se calcule avec la relation suivante :

La ligne courbe représente donc la distance parcourue par une roue en un tour.

Enfin il suffit de diviser la circonférence par 360 et on obtient la distance parcourue par le robot avec une rotation des moteurs de 1°

Programmer et tester l’algorithme suivant :

Déplacement en formant un carré de 1 m sur 1m

Rotation

Pour effectuer une rotation sur lui-même le robot doit activer ses deux moteurs simultanément en sens opposé :

Pour effectuer une rotation d’un certain nombre de degrés, il faut déterminer la longueur de l’arc de cercle décrit par l’une des roues.

 avec 2.R = la distance entre les deux roues

 Réaliser une procédure :

Rotation(puissance, degre)

 

carré de 1 m sur 1m

Rédiger un programme qui permet de faire avancer le robot d’1m en ligne droite puis de tourner à 90° puis à nouveau d’effectuer une ligne droite sur 1m et ainsi de suite afin de suivre une trajectoire formant un carré de 1m de côté.

Pour cela, vous allez utiliser les deux procédures :

  • Marche_avant(puissance, distance)
  • Tourne_droite(puissance, angle)


Programmation comportementale du robot NXT

Le Robot Lego Mindstorm Education NXT V2.0 est équipé de capteurs lui permettant d’appréhender son environnement afin de se déplacer de façon autonome suivant le comportement décrit dans le programme. Dans cette partie, nous allons mettre en œuvre deux capteurs :

  • Le capteur tactile : détection d’obstacle par contact.

  • Le capteur ultrason : détection d’obstacle distant.

Test du capteur « tactile »

La procédure d’activation du capteur de tactile est la suivante :

SetSensorTouch(S1); // Activation du capteur tactile sur S1

L’état du capteur (1 ou 0) est contenu dans la variable :

SENSOR_1

Tester et programmer l’algorithme suivant :

Remarque 1: voir page 33 du cours pour programmer l’émission d’un son (f = 440Hz – durée 1s)

Remarque 2 : la boucle « tant que toujours » est une boucle infinie (boucle tant que le robot est en fonctionnement). Elle se traduit par l’instruction while(1){…}

Tester et programmer l’algorithme suivant :

Test du capteur à ultrasons

La procédure d’activation du capteur ultrason est la suivante :

SetSensorLowspeed()

La distance mesurée par le capteur est renvoyée par la fonction :

SensorUS()

Tester et programmer l’algorithme suivant :

Remarque : pour afficher sur l’écran de la brique les données d’un capteur regarder l’exemple page 39

Nous souhaitons maintenant que notre robot adapte sa puissance en fonction de la distance de l’obstacle. Le cahier des charges est le suivant : Le robot s’arrête lorsqu’il s’approche à moins de 10cm d’un obstacle. Sinon sa puissance est proportionnelle à la distance de l’obstacle pour atteindre son maximum (100%) si l’obstacle est à plus de 70cm.

Déterminer l’équation Vitesse= f( distance) dans l’intervalle [10cm ; 70cm]

Tester et programmer l’algorithme suivant :

Ressources :

  • Guide utilisateur Lego NXT
  • Cours mecatronique avec lego nxt et BricxCC

Pour aller plus loin :