1 Prise en Main

Travaux Pratiques Mécatronique
ENSPS 1A
TP1 : Lego Mindstorms Tribot : exploration, évitement et odométrie
Ce TP est une initiation à l’utilisation de la brique NXT pour traiter des problèmes simples de
robotique mobile. Dans ce TP vous allez travailler entièrement sous Linux, environnement sous
lequel vous programmerez les interactions selon deux méthodes :
– soit localement, en programmant en NXC et en chargeant votre programme avant de l’exécuter.
Alors vous n’aurez plus la main sur la brique durant l’exécution du programme ;
– soit en utilisant la communication Bluetooth entre le PC et la brique.
Par ailleurs, vous disposez d’un PC Linux :
– login : tpmecatroX avec X votre numéro de groupe ; mot de passe : marcopolo%
– logiciels pré-installés :
– nbc : compilateur NXC
– linxt : utilitaires de communication via USB avec le NXT
– gcc et la librairie nxtlibc
– l’éditeur de texte gedit
– ressources disponibles :
– $HOME/Docs : NXC guide.pdf (API NXC), presentation.pdf (le cours), nxtlibc.0.1.htm
(API nxtlibc : Bluetooth command ), LEGO MINDSTORMS NXT Direct commands.pdf
(trames Bluetooth) mais aussi internet et le manuel Linux : man évidemment . . .
1
Prise en Main
Allumer l’ordinateur et booter sous Linux Ubuntu 8.10.
1.1
Lego Tribot
Assembler le robot en suivant le petit document d’assemblage. Le matériel est rangé dans les
tiroirs suivants :
– tiroir 1 : document d’assemblage du Tribot
– tiroir 2 et 3 : brique NXT et pièces LEGO pour le Tribot
– tiroir 4 : pièces additionnelles (pour fixer le capteur ultrason à l’avant du Tribot par exemple)
Dans l’intérêt de chacun, il est demandé de veiller au bon rangement de votre
espace de travail et du matériel mis à disposition. Ceci sera vérifié en fin de séance et
le calcul de la note obéira à l’algorithme suivant : final_mark=if(not_clean)*mark.
1.2
NXT basique
1. Allumer le NXT.
2. Menu View : exécuter les tests capteurs ”Touch”, ”Ultrasonic cm”, ”Motor degrees”. Tourner
à la main le moteur pour tester la mesure d’angle (il est réversible).
3. Menu NXT Program : créer un programme ”Forward” - ”Object” - ”Back Right 2” - ”Wait
2” - ”Loop” et l’exécuter.
1.3
Premiers programmes en NXC
Pour chacun de vos programmes, il est bon d’organiser votre répertoire $HOME en sous-répertoires
aux noms facilement identifiables (commande mkdir dans une console ou en utilisant le navigateur).
Remarque : le répertoire $HOME ne sera effacé qu’une fois les TP terminés.
L. Cuvillon, B. Bayle
1
1.3.1
Capteurs en NXC
1. Créer un fichier *.nxc avec l’éditeur gedit.
2. Recopier le programme du cours de démonstration de lectures des capteurs (transparent
”Input API : Sensors and rotation”).
3. Analyser son fonctionnement.
4. Compiler le programme avec nxc (nbc *.nxc -O=*.rxe).
5. Connecter le NXT au PC avec le câble USB.
6. Charger le programme en mode super-utilisateur (sudo).
7. Vérifier le bon fonctionnement du programme.
1.3.2
Une application avec moteurs et capteurs
Reprendre la seconde implémentation de l’exemple ”Move forward with obstacle avoidance”
(colonne droite) et analyser son fonctionnement. Expérimenter.
2
Navigation
2.1
Mouvement pseudo-aléatoire avec évitement d’obstacles
1. Ecrire une tâche main qui :
– initialise le capteur ultrason
– démarre une tâche move
2. Ecrire une tâche move qui :
– fait avancer le robot tant qu’aucun obstacle n’est détecté
– fait subir une rotation du robot comprise entre 90 et 270 degrés (utiliser une des fonctions
de génération d’un nombre aléatoire de NXC) si un obstacle est détecté
– reprend sa marche en avant
2.2
Arrêt automatique par minuterie
Modifier la tâche move précédente pour qu’au-delà d’un temps d’exécution prédéfini (TIME OUT
de 20s), les moteurs soient forcés à l’arrêt. Utiliser pour cela la fonction CurrentTick().
3
Odométrie
Le processeur ARM du NXT n’a pas d’unité de calcul en virgule flottante : on ne
peut faire que des calculs sur des entiers. Comme aux premiers temps de l’informatique, où
certains jugeaient inutile le calcul en virgule flottante, à vous de transformer vos calculs pour en
tenir compte (ex : −100 < sin(angle en degrés) < 100 avec NXC pour éviter la valeur à virgule).
Premier exemple
long x=50,res;
Deuxième exemple
long x=1,res;
res=x*32/100; //res=16 en m
res=x*32/100;//res=0 en m
res=x*(32/100); //res=0 en m
res=x*1000*32/100; //res=320 en mm
Tab. 1 – Calcul de x*0.32 sur un processeur sans virgule flottante
L. Cuvillon, B. Bayle
2
3.1
Vitesse de rotation des roues ϕ̇r et ϕ̇l
1. Ajouter au programme précédent une seconde tâche odom, qui réalise l’estimation odométrique.
Cette tâche sera démarrée dans le main. Il s’agit d’une tâche répétitive infinie, qui continuera
à s’exécuter après l’arrêt de la tâche move par minuterie. Pour la définir, à chaque itération
de la boucle il faut :
(a) Ecrire un algorithme permettant de calculer les vitesses des roues droite ϕ̇r et gauche
ϕ̇l (à exprimer en deg/s). Attention à la convention de sens définie dans le cours pour
chacune des roues.
(b) Effacer l’écran et afficher les 2 vitesses.
(c) Définir une période proche de 50 ms (au temps des exécutions précédentes près) pour
la tâche en forçant l’attente par l’instruction Wait(50).
2. Tester et valider (aussi peu approximativement que possible).
3.2
Vitesse linéaire v et de rotation ω
Dans la tâche odom, à la suite du calcul des vitesses angulaires des roues :
1. Calculer v et ω, respectivement vitesse linéaire (mm/s) et angulaire du robot (deg/s). Le
demi-entraxe vaut L = 56 mm, le rayon des roues r = 56 mm (c’est le hasard . . .).
2. Afficher ces vitesses à la place des vitesses de rotation des roues.
3. Tester et valider.
3.3
Odométrie : position x, y et orientation θ du robot
Dans la tâche odom, à la suite du calcul des vitesses linéaire et angulaire du robot :
1. Calculer θ en millidegrés par intégration de ω.
2. Exprimer ensuite θ en degrés et compris entre 0 et 360 deg à partir de θ (% = opérateur
modulo en NXC).
3. Calculer x et y en mm par intégration, à l’aide de v et θ précédemment calculés.
4. Afficher la position et l’orientation du robot.
5. Tester l’odométrie en faisant déplacer le robot au sol et valider le résultat.
4
Bluetooth et nxtlibc
L’objectif est de pouvoir récupérer sur le PC la position du robot pour réaliser une carte de
l’environnement ou de la planification de trajectoires.
4.1
Appariement du PC avec le NXT
1. Connecter le dongle Bluetooth sur un port USB du PC. Une applet Bluetooth apparaı̂t dans
la barre de tâches.
2. Utiliser la méthode d’appariement décrite dans le cours.
3. Relever dans le popup l’adresse Bluetooth du NXT.
4.2
Principe d’échange de messages entre le PC et le NXT
Le PC initie la connexion. Il est le maı̂tre et donc seul capable d’initier une connexion :
– le PC peut poster des messages dans les boites aux lettres numéro i, i=0 à 9, disponibles
sur le NXT par message write(i,. . .) de la nxtlibc
– le PC peut aller lire la réponse que le NXT a déposé dans les boites de numéro 10+i par
message read(10+i,. . .) de la nxtlibc
L. Cuvillon, B. Bayle
3
– le NXT peut lire et écrire dans ses boites aux lettres avec les fonctions SendMessage et
ReceiveMessage de l’API NXC
Une boite aux lettres i peut contenir jusqu’à 5 messages et peut être vide ou pleine. Si elle est
pleine, le plus ancien message est effacé.
mailboxes
NXT
O
−NXC
3
message_write(3,size,message)
ReceiveMessage(3,true,buf)
char* buf
char* res
PC
−NxtLibC
9
10
message_read(10+3,0,....,reponse)
SendMessage(10+3,res)
13
19
Fig. 1 – Principe des boites aux lettres
Pour quelques détails supplémentaires, voir documentation Bluetooth NXT LEGO. . .
4.3
Communication de l’odométrie au PC
1. Tester le programme d’exemple de connexion PC→NXT du cours en modifiant l’adresse
Bluetooth par celle de votre NXT.
2. Compiler avec gcc et tester l’ouverture de la connexion.
3. Modifier alors le programme de navigation/odométrie sur le NXT pour déposer dans une
boite aux lettres de votre choix un message contenant la configuration actuelle du robot.
4. Modifier le fichier C de connexion Bluetooth sur le PC pour régulièrement lire le message
déposé par le NXT dans la boı̂te aux lettres.
L. Cuvillon, B. Bayle
4