1 Equipe Pédagogique : Jerôme Cantaloube, Laurent

Equipe Pédagogique : Jerôme Cantaloube, Laurent Bernard et Yann Bertrand.
Elouen TRAVAUX
1
I – Présentation du Projet NXT
Dans ce dossier, nous allons traiter de notre projet portant sur les Robots NXT «MINDSTORM». Ces
robots ont été conçus en 2006 par l'entreprise LEGO, dans le but de toucher le milieu de
l’éducation et de l’enseignement des sciences, du collège aux universités. Ces robots sont d'ailleurs
le centre de nombreux concours. Le kit Lego Mindstorm NXT est actuellement en version 2.0.
Ces robots sont composés d'une brique intelligente, permettant de relier des servomoteurs, ainsi
que des capteurs. Il y a, dans le pack d'origine un capteur d'ultrasons, un capteur sonore, un
capteur tactile, ainsi qu'un capteur de luminosité. Ces capteurs peuvent par exemple servir à faire
intérragir le robot avec son environnement.
Ce sont bien sûr les servomoteurs qui permettent au robot de se mouvoir.
Ces robots sont vendus avec un logiciel de programmation simple, propre aux NXT, permettant à
n'importe qui de pouvoir s'en servir sans avoir besoin de connaissances spécifiques. Il est
également possible de programmer les robots NXT avec le logiciel PROCESSING, en installant des
librairies extérieures, développées spécialement pour les NXT par des développeurs extérieurs.
Avant de commencer notre travail, nous nous sommes renseignés sur ce qui existait déjà, et avons
trouvé des choses très étonnantes. Par exemple un programme NXT ayant pour objectif de
terminer le plus rapidement possible un «Rubik's Cube», seul et sans aide extérieure : des bras ont
été conçus, et sont commandés par les servomoteurs.
Il est bien évident que nous n'avions ni les connaissances nécessaires, ni le temps pour réaliser ce
genre de programme, et surtout pour penser une utilisation réellement utile. Nous nous sommes
donc simplement lancés dans des interfaces de contrôle à distance, via le dispositif Bluetooth :
diriger un robot NXT via une interface, directement depuis un ordinateur.
Nous allons maintenant nous intéresser à notre projet concernant les robots NXT. L'objectif
premier de ce projet était de proposer des interfaces de contrôle différentes de celles qui
existaient déjà, mais surtout de les programmer différemment, puisqu'il n'y a pas énormément
d'interfaces programmées avec le logiciel Processing.
L'enjeu de départ était que chacun propose une interface différente, dans le but de les rassembler
par la suite dans un menu que nous imaginerions, programmerions nous-mêmes, toujours avec le
même logiciel, Processing, dont nous nous servons depuis le début de l'année en cours d'ISN.
Nous avons donc tout mis en œuvre pour atteindre notre objectif, et avons réalisé des interfaces
personnelles tout en gardant une collaboration importante.
Elouen TRAVAUX
2
II – Analyse du besoin
Le domaine de la robotique est aujourd'hui un milieu en plein essor, pouvant servir dans de
nombreux domaines tels que la médecine, l'exploration spatiale, la domestique, l'industrie ou
encore les loisirs.
L'objectif visé était clairement de proposer plusieurs interfaces, gérées dans un menu, pour
permettre à l'utilisateur de se servir de l'interface qui lui correspond le mieux, pour contrôler son
robot de la façon la plus simple possible, directement depuis son ordinateur, via une connexion
Bluetooth et le logiciel Processing.
Le choix de la technologie Bluetooth nous est apparue évidente car elle répondait aux besoins
(communication sans fil de courte de distance). De plus, le robot Nxt est équipé de série de la
technologie de communication Bluetooth. Nous avons constaté que beaucoup d'applications sous
Androïd éxistaient, mais le pilotage depuis un ordinateur n'était pas aussi développé, c'est donc la
raison pour laquelle nous avons décidé de développer une multi-interface, pour les non
possesseurs de tablettes ou autres périphériques Androïd, leur permettant de piloter leur robot
NXT de façon confortable et ludique, depuis leur ordinateur.
III – Recherche d'idées
Nous nous sommes d'abord lancés dans des interfaces, mais nous nous sommes rendus compte
qu'elles avaient toutes des fonctions très proches et un fonctionnement similaire, et donc sans
grand intérêt. Après concertation, nous nous sommes donc lancés dans 3 nouvelles interfaces dans
l'objectif de les rassembler ensuite dans notre menu.
Pour ce faire, nous avons pris du temps pour nous renseigner sur ce dont nous aurons besoin pour
réaliser notre travail, en utilisant bien évidemment les outils Numériques, avec Internet, mais aussi
en s'appuyant sur les notices d'utilisation du robot. Après ces recherches, nous avons opté pour les
librairies NXT Com développées par Jorge Cardoso.
Nous avons donc utilisé le langage «Java» pour établir nos programmes de contrôle de nos robots
NXT, ainsi que l'interface Bluetooth pour établir une connexion instantanée entre l'ordinateur et la
brique NXT, à l'aide d'une clef Bluetooth extérieure (ou directement depuis une interface
Bluetooth intégrée à un ordinateur).
Ce dispositif nous a d'ailleurs malheureusement beaucoup pénalisé au niveau du temps, car le
matériel ne fonctionnait pas du tout de façon régulière, et il nous est arrivé de ne pas avoir le
temps de faire beaucoup de choses pendant une séance, car la connexion entre l'ordinateur et le
robot ne se faisait pas. Nous avons donc eu des séances où nous avons été contraints de travailler
«à l'aveugle», sans pouvoir tester nos programmes en conditions réelles.
Elouen TRAVAUX
3
IV – Répartition des tâches
Marco TURENNE
Interface «Déplacement Vitesse Variable
Lecture de la valeur de la boussole et
action à faire en fonction de l’angle
donné par le programme d’Elouen TRAVAUX
Sullivan VILLA
Interface « mode parcours »
Elouen TRAVAUX
Interface «Souris, clavier»
Partie «Calcul de
l’angle» du mode
boussole.
Nous nous sommes ainsi répartis les tâches de façon à ce que nous puissions collaborer le plus
possible, mais en réalisant chacun sa part de travail, et ainsi pouvoir terminer le projet tel que
nous le prévoyions au départ.
Il y a également la création du menu, que nous avons décidé de faire tous ensemble, afin qu'il représente au mieux le groupe.
Vous découvrirez ce menu dans quelques pages (page7), grâce à une capture d'écran.
V - Réalisation
Après nous être répartis les tâches dans le groupe, nous nous sommes chacun lancé dans une
interface différente de contrôle d'un robot NXT, dans l'idée de toutes les rassembler ensuite dans
un menu que nous établirons.
Pour ma part, l'objectif était de penser et de réaliser une interface de contrôle du robot, qui
rassemble la souris d'un ordinateur mais aussi son clavier. En effet, la première interface que j'ai
réalisé fait fonctionner le robot dans les conditions suivantes : La souris doit être positionnée dans
un des cadres à l'écran (avancer, reculer, droite, gauche) et une touche du clavier doit être activée,
afin d'éviter de faire fonctionner le robot lorsque l'on n'est pas à côté de l'ordinateur mais que l'on
a laissé la souris sur un des cadres.
Dans cette interface, l'idée était de permettre à l'utilisateur de contrôler son robot de la façon la
plus simple possible : j'ai donc mis au point une possibilité de contrôle qui comprend les fonctions :
Elouen TRAVAUX
4
« Tourner à gauche/droite » : Cette
fonction fait tourner les deux moteurs,
mais un qui fonctionne 2,5 fois plus vite
que l'autre, afin de permettre au robot de
tourner, tout en avançant, et ainsi lui
éviter de faire du sur-place.
« Tourner Rapidement » : Cette fonction
fait la même chose que la précédente,
mais elle fait fonctionner l'un de moteurs
5 fois plus vite que l'autre, afin de
permettre au robot de tourner beaucoup
plus vite (exemple, si le robot doit faire un
demi-tour, il sera plus rapide d'utiliser la
fonction « Rapide » plutôt que la fonction
normale.
« Avancer/Reculer » : Cette fonction simple a été ajoutée à la suite, car si l'on voulait que le robot
avance parfaitement droit, il fallait passer alternativement des cadres « Droite » et « Gauche »,
dans le même principe qu'un kayak, ce qui n'était pas pratique du tout. C'est pourquoi j'ai ajouté
ces deux fonctions qui font tout simplement fonctionner les deux moteurs à la même vitesse,
permettant au robot de rouler droit.
L'intégralité de cette interface a donc été réalisée avec le logiciel Processing. Le contrôle du robot à
distance nécessite un dispositif Bluetooth, qui nous a posé énormément de problèmes, puisque le
matériel n'a quasiment jamais fonctionné correctement pendant les cours, alors qu'il marchait
bien chez nous. La majeure partie de la réalisation graphique a donc été réalisée au lycée, et la
partie matérielle a été effectuée à nos domiciles respectifs, afin d'éviter de perdre du temps avec
du matériel qui ne fonctionnait pas toujours.
Lorsque l'on passe la souris sur l'un des triangles, et qu'une touche du clavier est enclenchée, le
triangle blanc devient bleu: à cet instant, le robot reçoit l'ordre de tourner à droite (voir photo cidessus).
Pour la réalisation de ce programme, j'ai dessiné les triangles dans le void draw, et le passage au
bleu lorsque la souris passe dessus se fait car, lorsque la souris passe entre tels et tels pixels (voir
code source en annexe), et bien sûr qu'une touche du clavier est active, le programme redessine le
même triangle par-dessus, de sorte que l'on voit que le triangle devient bleu.
Il s'agit exactement du même principe pour les touches avancer et reculer.
Pour ce qui est du contrôle du robot, il s'agit simplement de fonctions de base établies pour
programmer via Processing, qui sont incluses dans des librairies extérieures à Processing, que nous
avons téléchargé. La seule commande utilisée dans ce programme est la commande de faire
marcher le moteur. En effet, il y a aussi la commande Stop, mais qui ne sert à rien ici puisque
lorsque l'on relâche la touche du clavier, on ne se situe plus dans la boucle, et le programme
s'arrête de lui-même.
Lorsque nous avions chacun terminé notre première interface, nous avons remarqué qu'elles
s’exécutaient quasiment toutes de la même manière, c'est-à-dire qu'il s'agissait simplement d'un
« suivi » de la souris. Nous avons alors pensé à trois autres interfaces : une interface permettant à
l'utilisateur de paramétrer et de gérer le parcours que devra faire son robot, une interface
5
Elouen TRAVAUX
« autonome », qui détecte les obstacles et qui agit pour les éviter, ainsi qu'une interface munie
d'une boussole.
L'interface boussole est une interface qui se gère avec la souris. Sur l'écran s'affiche une rose des
vents qui reste fixe, lorsque l'utilisateur passe la souris sur le Nord, le robot devra prendre en
compte sa position initiale, tourner jusqu'à ce que l'avant du robot soit en direction du nord, et
ensuite avancer vers le nord.
Afin de pouvoir utiliser la boussole, il fallait
d'abord faire un calcul d'angle entre la droite
reliant la centre à la position Est, et la droite
reliant le centre à la position de la souris.
Ce calcul d'angle est réalisé sur Processing
avec la fonction « arctan2 » qui donne un
angle en radians, qu'on lui demande
d'afficher en degrés afin de pouvoir renvoyer
ces données au robot NXT, et ainsi pouvoir
amorcer le début du mouvement.
A la suite de cela, nous avons commencé
à essayer de comprendre le fonctionnement
du capteur boussole, et c'est ici que nous
nous sommes rendus compte que la
boussole ne renvoyait pas des signaux très
compréhensibles pour nous. En effet, après avoir effectué des tests, Marco TURENNE s'est rendu
compte que la boussole renvoyait des informations qui semblaient aléatoires (il est bien évident
que ce n'est pas le cas, mais nous n'avons pas réussi à comprendre comment cette boussole
fonctionnait).
Nous avons donc décidé à ce moment-là de ne pas terminer cette interface.
VI – Intégration et Validation
L'objectif final de notre projet est de mettre en commun nos idées, les perfectionner si besoin est,
mais surtout, d'établir un menu permettant de basculer d'une interface à une autre, sans difficulté.
Pour la création de ce menu, nous avons encore utilisé le logiciel Processing, puis avons d'abord
réalisé un travail graphique, pour intégrer des boutons permettant l'accès à nos différentes
interfaces.
Voici, à la page suivante, une capture d'écran qui montre l'avancée de notre menu reliant toutes
nos interfaces (Déplacement Vitesse Variable, Classique, Parcours, Automatique). Ce menu n'est
actuellement pas terminé, nous sommes, au moment de l'écriture de ce dossier en phase de
finalisation de ce menu.
Elouen TRAVAUX
6
VII – Bilan et conclusions
Notre projet me paraît personnellement être un projet très intéressant, qui m'a beaucoup apporté,
tant dans le domaine du travail en équipe que dans la réalisation du programme en lui-même, le
sujet était un très bon sujet, très intéressant, avec un réel objectif, et c'était un réel plaisir de
travailler dans ces conditions, bien qu'il y ait eu des hauts et des bas, notamment avec le matériel
qui n'a pas toujours fonctionné, mais j'ai tout de même réellement apprécié travailler avec ce
sujet, et j'ai le sentiment que nous formions une plutôt bonne équipe de travail avec mes
camarades, Marco TURENNE ainsi que Sullivan VILLA.
Pour ce qui est de la maquette d'interface finale, il y a un point sur lequel nous aurions pu travailler
si nous avions eu plus de temps, car j'aime beaucoup le graphisme, et il se trouve que nos
interfaces sont certes jolies, mais ne donnent pas forcément un résultat professionnel,
graphiquement parlant. Avec un peu plus de temps, je pense que j'aurais aimé retoucher aux
interfaces, et les rendre plus esthétiques, en plus du caractère fonctionnel de celles-ci. C'est donc
un côté que nous aurions pu éventuellement améliorer dans la maquette finale, bien qu'elle soit
tout de même assez jolie, et entièrement fonctionnelle, ce qui est bien sûr le plus important au
final. Nous aurions aussi pu développer une interface se servant de la wifi.
7
Elouen TRAVAUX
En tout cas, il est clair que ce projet m'a permis de commencer à vraiment travailler en équipe
pour la première fois ce qui va beaucoup me servir dans mes futures études, car je suis candidat au
BTS Audiovisuel, et ce sont des études qui privilégient énormément le travail en équipe, car nous
serons amenés à travailler avec tous les corps de métiers que rassemblent le milieu de
l'Audiovisuel (son, montage.. etc).
En clair, et pour conclure, il est clair que ce projet d'ISN sur les robots NXT n'a fait que m'apporter
des points positifs, que ce soit pour la suite de mes études, ou bien pour ma vie future, et j'espère
travailler à nouveau en équipe le plus rapidement possible, afin de renouveler cette belle
expérience, mais surtout cette belle ambiance de travail, avec une équipe qui a envie de travailler,
parce que c'est un sujet qui nous a vraiment intéressés, et qui nous a permis de nous investir le
plus possible. Et c'est cet investissement qui nous a motivés pour travailler, essayer de trouver des
solutions aux problèmes que nous rencontrions, et surtout, le plus important, essayer de faire au
mieux, avec les moyens que nous avions.
Je tenais donc à remercier les autres membres de mon groupe qui ont contribué à ce que ce projet
se passe au mieux, et je pense que l'on est tous d'accord pour dire que nous sommes satisfaits du
résultat final, malgré les nombreux problèmes rencontrés tout au long du cycle de projet.
VIII – Diffusion du Projet
Mon projet est à retrouver sur la plateforme Github, qui permet le dépôt de fichiers importants sur
un serveur web, nous permettant de retrouver des fichiers très facilement, sans avoir besoin de
prendre avec soi une clef USB ou un disque dur lorsque l'on ne travaille pas chez soi.
Mon profil GITHUB : www.github.com/Elouen
Profil GITHUB de groupe : https://github.com/codelab-info/tratuvi
CV HTML : http://data.codelab.info/workspace/elouts4/CV/CVFInal/CVFinalGillesHedesovetaj.html
Pour protéger notre projet, et établir les droits correspondants, nous avons décidé d'utiliser une
licence de diffusion «Créative Commons».
Nous avons choisi la licence ci-dessus :
Le sigle BY représente la signature personnelle de la personne ayant effectué le projet, et le sigle
NC représente l'aspect non commercial du projet.
C'est à dire que personne ne pourra tirer profit et gagner de l'argent grâce à ce projet : ni les
créateurs, ni les personnes qui pour une raison quelconque ont accès au projet. Enfin, le projet
appartient à quelqu'un et ne peux pas être usurpé, avec la licence BY.
Elouen TRAVAUX
8
IX - Annexes
CODES SOURCE : Mode Boutons et Clavier
// Charger les librairies
import processing.serial.*;
import SpringGUI.*;
import pt.citar.diablu.nxt.protocol.*;
import pt.citar.diablu.processing.nxt.*;
import pt.citar.diablu.nxt.brick.*;
SpringGUI gui;
LegoNXT nxt;
void setup() {
size(800, 800); //taille de la fenêtre
background(0); //couloir noire
frameRate(30); //vitesse d'exécution
smooth();
}
// Paramétrage de la connexion avec le NXT en Bluetooth
println(Serial.list());
nxt = new LegoNXT(this, "COM4"); //COM4 du périphérique Bluetooth
void draw() {
fill(255, 255, 255); //Couleur blanche
triangle(400, 400, 700, 400, 400, 100); //Triangle Droite-Haut
triangle(400, 400, 700, 400, 400, 700); //Triangle Droite-Bas
triangle(400, 400, 100, 400, 400, 100); //Triangle Gauche-Haut
triangle(400, 400, 100, 400, 400, 700); //Tri Gauche Bas
rect(325, 25, 150, 40); //Rectangle Avancer
rect(325, 735, 150, 40); //Rectangle Reculer
fill(0); //couleur noire
//Positionnement des textes
text("LEFT", 300, 300);
text("RIGHT", 475, 300);
text("LEFT FAST", 275, 500);
text("RIGHT FAST", 450, 500);
text("Avancer", 375, 50);
text("Reculer", 375, 760);
if (keyPressed == true) { //si une touche du clavier est activée
//souris placée dans ces intervalles
if (mouseX>100 && mouseX<400 && mouseY>100 && mouseY<400) {
Elouen TRAVAUX
9
println("LEFT"); //pour vérifier
fill(0, 255, 255); //couleur
triangle(400, 400, 100, 400, 400, 100); //Triangle Gauche-Haut
fill(0, 0, 0); //couleur noire
text("LEFT", 300, 300); //texte
//Start Motor C
nxt.motorForward(2, -100);
}
//Start Motor B
nxt.motorForward(1, -40);
if (mouseX>400 && mouseX<700 && mouseY>100 && mouseY<400) {
println("RIGHT");
fill(0, 255, 255);
triangle(400, 400, 700, 400, 400, 100); //Triangle Droite-Haut
fill(0, 0, 0);
text("RIGHT", 475, 300);
//Start Motor C
nxt.motorForward(2, -40);
}
//Start Motor B
nxt.motorForward(1, -100);
if (mouseX>100 && mouseX<400 && mouseY>400 && mouseY<700) {
println("LEFT FAST");
fill(0, 255, 255);
triangle(400, 400, 100, 400, 400, 700); //Triangle Gauche-Bas
fill(0, 0, 0);
text("LEFT FAST", 275, 500);
//Start Motor C
nxt.motorForward(2, -150);
}
//Start Motor B
nxt.motorForward(1, -30);
if (mouseX>400 && mouseX<700 && mouseY>400 && mouseY<700) {
println("RIGHT FAST");
fill(0, 255, 255);
triangle(400, 400, 700, 400, 400, 700); //Triangle Droite-Bas
fill(0, 0, 0);
text("RIGHT FAST", 450, 500);
//Start Motor C
Elouen TRAVAUX
10
nxt.motorForward(2, -30);
//Start Motor B
nxt.motorForward(1, -150);
}
if (mouseX>325 && mouseX<475 && mouseY>25 && mouseY<65) {
println("AVANCER");
fill(0, 255, 255);
rect(325, 25, 150, 40); //Rectangle Avancer
fill(0, 0, 0);
text("Avancer", 375, 50);
}
//Start Motor B
nxt.motorForward(1, -100);
//Start Motor C
nxt.motorForward(2, -100);
if (mouseX>325 && mouseX<475 && mouseY>735 && mouseY<775) {
println("RECULER");
fill(0, 255, 255);
rect(325, 735, 150, 40); //Rectangle Reculer
fill(0, 0, 0);
text("Reculer", 375, 760);
//Start Motor B
nxt.motorForward(1, 100);
//Start Motor C
nxt.motorForward(2, 100);
}
}
}
CODE SOURCE : Calcul de l’angle
PImage fond;
//paramétrage de la zone de travail
void setup () {
size(800, 800);
smooth();
frameRate(30); // vitesse d’execution
}
Elouen TRAVAUX
11
void draw () {
fond = loadImage("boussole800.jpg"); //charger l’image boussole800
background(fond); //faire de l’image chargée l’image d’arrière-plan
//si la souris se trouve à gauche de l’axe vertical central
if (mouseY<400) {
float x = mouseX - 400;
float y = mouseY - 400;
float angle = atan2(-y, x); //calcul de l’angle en radians entre la droite horizontale centrale, et la
droite reliant les points O (centre de la zone de travail) et le point situé du côté de l’Est.
float deg = (angle*180)/3.14; //Transformation de la valeur de l’angle en degrés
println(deg); //afficher le résultat (simple verification en cours de programmation)
}
if (mouseY>400) {
float x = mouseX - 400;
float y = mouseY - 400;
float angle = atan2(y, x);
}
float deg = 360 - ((angle*180)/3.14);
println(deg);
}
Elouen TRAVAUX
12