marc-olivier turenne-terminale s4 projet isn...
Post on 12-Sep-2018
223 Views
Preview:
TRANSCRIPT
Marc-Olivier TURENNE-Terminale S4 Projet ISN 2013
1 | P a g e
Equipe pédagogique :
Laurent Bernard
Jérôme Cantaloube
Yann Bertrand
Marc-Olivier TURENNE Projet ISN 2013
2 | P a g e
Sommaire
I. Présentation du Projet « Robot NXT » ................................................................................ 3
II. Analyse du besoin ............................................................................................................... 4
III. Recherche d’idées ........................................................................................................... 4
IV. Répartition des tâches et Démarche collaborative ......................................................... 5
Répartition des tâches ............................................................................................................ 5
Démarches collaboratives : .................................................................................................... 6
V. Réalisation ........................................................................................................................... 6
VI. Intégration et Validation ................................................................................................. 9
VII. Bilan et Perspectives ....................................................................................................... 9
Bilan personnel du projet : ..................................................................................................... 9
VIII. Diffusion du projet ........................................................................................................ 10
IX. Annexes ......................................................................................................................... 11
Programme « Interface de compréhension du système » ................................................... 12
Programme « Mode automatique » .................................................................................... 14
Programme « Mode déplacement Vitesse Variable » (cible) .............................................. 15
Marc-Olivier TURENNE Projet ISN 2013
3 | P a g e
I. Présentation du Projet « Robot 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. Le kit Lego
Mindstorms NXT est actuellement en version 2.0.
Le robot Lego Mindstorms NXT est très utilisé pour l'enseignement et l'éducation des
sciences et techniques. De nombreuses compétitions étudiantes sont basées sur le robot
Lego comme la First Lego League ou la Coupe de France de robotique. Des compétitions
internationales existent également sur la base de ce kit robotique.
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é mais d’autre capteurs existent
comme le capteur boussole ou gyroscopique. Ces capteurs peuvent par exemple servir à
faire interagir 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à,
sur « l’état de l’art », 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.
Marc-Olivier TURENNE Projet ISN 2013
4 | P a g e
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 et 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.
II. Analyse du besoin
Le but de notre projet était de créer plusieurs interfaces, gérées depuis un menu, avec
lesquelles l’utilisateur pourrait contrôler à distance le robot, de façon simple et ludique,
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 distance). De plus le robot NXT est équipé de série
de la technologie de communication Bluetooth.
De multiples applications sous Androïd existent déjà mais le pilotage depuis un ordinateur
n’est pas aussi développé. Ainsi, nous souhaitions 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 sur leur ordinateur.
III. Recherche d’idées
Nous nous sommes d'abord lancés dans
des interfaces simples afin d’apprendre à
utiliser les différentes librairies et le robot.
Mais nous nous sommes rendu compte
qu'elles avaient toutes des fonctions très
proches et un fonctionnement similaire, et
qu’elles étaient donc sans grand intérêt.
(Ci-contre l’image de mon application de
base, voir code source dans Annexe,
Programme « Interface de compréhension
du système »)
Marc-Olivier TURENNE Projet ISN 2013
5 | P a g e
Pour ce faire, nous avons pris du temps pour nous renseigner sur ce dont nous aurions
besoin pour réaliser notre travail, en utilisant bien évidemment les outils Numériques, avec
Internet, mais aussi en nous appuyant sur les notices d'utilisation du robot. Nous avons ainsi
trouvé les librairies Processing de gestion du Bluetooth pour le robot NXT, des librairies pour
faire apparaitre des commutateurs…
Suite à ces recherches nous avons retenu la bibliothèque d’extension appelée NXTComm
développée par Jorge Cardoso car c’est la librairie la plus reconnue.
Après concertation, nous nous sommes lancés dans 3 nouvelles interfaces dans l'objectif de
les rassembler ensuite dans un menu.
Nous avons donc utilisé le langage «Java» pour établir nos programmes de contrôle du robot
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 beaucoup pénalisé au niveau du temps, car le matériel ne
fonctionnait pas de façon régulière (problèmes de drivers, d’interférences…). Souvent, la
connexion entre l'ordinateur et le robot ne s’établissait pas, et nous avons eu des séances où
nous étions contraints de travailler «à l'aveugle», sans pouvoir tester nos programmes en
conditions réelles.
IV. Répartition des tâches et Démarche collaborative
Répartition des tâches
Marc-Olivier TURENNE Sullivan VILLA Elouen TRAVAUX
Interface «Déplacement Vitesse Variable» (cible)
Interface « mode parcours » Interface « souris, clavier »
Lecture de la valeur de la boussole et action à faire en fonction de l’angle donné par le programme d’Elouen TRAVAUX.
Partie « Calcul de l’angle » du mode boussole.
Interface «Mode automatique
Assemblage des interfaces Assemblage des interfaces Assemblage des interfaces
Marc-Olivier TURENNE Projet ISN 2013
6 | P a g e
Démarches collaboratives :
Pour organiser l’avancée de notre projet, nous avons, à chaque début de séance énoncé aux
autres notre avancée personnelle, discuté de nos problèmes afin de s’entraider. Nous avons
aussi organisé plusieurs Brainstormings afin de mettre nos idées en commun.
Nous avons aussi échangé avec les autres groupes toujours dans un esprit d’entraide.
V. Réalisation
Après répartition des tâches je me suis lancé dans la réalisation de mon interface de
« pilotage automatique ». Le but de ce mode de pilotage étant que le Robot NXT soit capable
de se déplacer seul dans une pièce en évitant les obstacles, c’est-à-dire les murs et les
escaliers. Pour ce faire, j’ai d’abord, en grand fan de lego, construit un robot qui me
permettrait de pouvoir réaliser mon mode « automatique ». Un capteur de présence
détectera donc les murs ou tous les obstacles verticaux qui gênent la progression du robot et
un capteur ultrasonique détectera un vide devant le robot qui se traduit par la présence
d’une marche d’escalier. Sachant que toutes les interfaces devaient s’assembler et
fonctionner sur ce robot, j’ai fait part à mes camarades des spécificités de mon robot,
comme par exemple le fait que le robot se déplace vers l’avant quand on pilote la vitesse des
moteurs avec un nombre négatif.
//le robot se déplace vers l'avant
nxt.motorForward(1, -20);
nxt.motorForward(2, -20);
//le robot se déplace vers l'arrière
nxt.motorForward(1, 20);
nxt.motorForward(2, 20); Je me suis ensuite attelé à la conception de mon programme qui était finalement bien plus
simple que prévu puisqu’il ne fallait gérer que très peu de fonctions, ce n’était qu’au final
deux comparaisons de valeurs.
if (nxt.getDistance(1) > 7) { //si la distance capteur-ultrasonique/sol est
supérieure à 7
print ("escalier"); //ligne de vérification destinée au programmeur
signifiant la présence d'une marche d'escalier
//le robot recule, tourne sur lui-même et repart en marche avant
//il évite donc l'obstacle (voir le code complet page 14 et 15)
}
if (nxt.getButtonState(0) == true) { //si il y a un contact à l'avant du
robot
print ("obstacle vertical");//ligne de vérification destinée au
programmeur signifiant un contact
Marc-Olivier TURENNE Projet ISN 2013
7 | P a g e
//le robot recule, tourne sur lui-même et repart en marche avant
//il évite donc l'obstacle (voir le code complet page 14 et 15)
}
Il fallut toutefois déterminer la valeur de la distance capteur-sol à ne pas dépasser (le 7
surligné en jaune dans le code ci-dessus), et pour ce faire j’ai utilisé le programme de test
(qui donne en temps réel l’état des capteurs et des moteurs) mis à notre disposition sur la
plateforme ISN pour connaitre cette valeur en fonctionnement normal et donc qu’il ne fallait
pas dépasser. Bien que le programme soit simple j’ai rencontré des problèmes au niveau
matériel mis en évidence par des erreurs lors de l’initialisation des capteurs.
La solution (généralement efficace) à ces problèmes était de débrancher les capteurs avant
le lancement du programme et de les rebrancher après lancement. Bien que la solution soit
finalement assez simple, il m’a fallu un temps assez important pour la trouver. Mes
camarades ayant aussi régulièrement ce problème je leur ai immédiatement fait part de ma
découverte.
Le mode de contrôle «automatique» ne m’ayant demandé que très peu de temps je me suis
simultanément lancé dans la conception de deux nouveaux modes: une interface en
collaboration avec Elouen TRAVAUX utilisant le capteur boussole et un autre prenant en
compte le déplacement de la souris et le clic ayant pour but un contrôle précis de la
trajectoire et de la vitesse du robot NXT sans être obligé de fixer son écran d’ordinateur
(comme avec une interface bouton par exemple).
Pour ce qui est de l’interface utilisant le capteur boussole, le but était de que le robot suive
un cap (par exemple le Nord ou le cap 283°), Elouen devait concevoir la partie de
programme ayant pour but de calculer l’angle (une valeur entre 0° et 360°) déterminé par la
Ci-contre la mise en
évidence par
Processing de l’erreur
de lancement du
capteur de pression.
Marc-Olivier TURENNE Projet ISN 2013
8 | P a g e
position de la souris sur l’écran. Je devais ensuite retraiter cette information pour piloter le
robot en conséquence.
Malheureusement la librairie utilisée ne prenait pas en compte le capteur boussole. En
conséquence, la valeur renvoyée par le capteur boussole n’était pas une valeur comprise
entre 0 et 360 comme indiqué sur la fiche technique du capteur mais des suites de valeurs
sans aucun sens. Après plusieurs heures d’essais et de recherche de calcul visant à déchiffrer
et réorganiser ces valeurs, j’ai été contraint d’abandonner, car je n’ai trouvé aucune
solution.
En ce qui concerne mode «Déplacement vitesse variable » (cible) , des fonctions plus
approfondies ont été mises en œuvre comme la fonction « conversion réel en entier » ( vitx
= (int) vitxx; où vitxx est un réel et vitx un entier) ou des calculs mathématiques un petit peu
plus poussés (surtout dans la réflexion pour que le robot fasse ce que je voulais et pas le
contraire par exemple).
if (x>0) {
nxt.motorForward(1, vity-vitx);
nxt.motorForward(2, vity);
}
if (x<0) {
nxt.motorForward(1, vity);
nxt.motorForward(2, vity+vitx);
}
Importante réflexion pour
mettre en relation les ajouts,
les soustractions de vitesse et
le mouvement du robot.
L’aspect esthétique étant l’une mes
priorité j’ai appris à utiliser des fonctions
graphiques (comme par exemple la
fonction smooth(); ) pour un résultat
plutôt satisfaisant tant au niveau
esthétique qu’au niveau fonctionnel.
En ce qui concerne le menu d’assemblage, il est en cours de finition pour chacun des
membres du groupe. Pour ma part, j’ai participé à la création du menu pour ce qui est de
l’importation, et de la gestion des images.
Marc-Olivier TURENNE-Terminale S4 Projet ISN 2013
1 | P a g e
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és.
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.
Avec Elouen Travaux, nous avons collaboré pour l’interface « pilotage boussole», j’ai donc
cherché à utiliser une partie de son code pour l’intégrer dans le programme.
Voici quelques captures d'écran qui montrent comment est construit notre menu, et
comment il fonctionne (voir code source en annexe).
VII. Bilan et Perspectives
Avec un temps de réalisation plus conséquent il serait tout à fait possible d’améliorer notre
projet :
En optimisant le code grâce à des fonctions dont nous ne connaissons pas l’existence
En exportant et adaptant nos programmes vers le système Androïde ou iOS (pas de
programmes de pilotage NXT sur l’App Store d’Apple)
En ajoutant une caméra pour pouvoir piloter le NXT sans le voir.
Bilan personnel du projet :
Après la présentation des différents projets possibles par nos professeurs, l’idée de travailler
sur les robots NXT m’a tout de suite attiré. En effet, la robotique m’a toujours impressionné
mais je n’avais jamais cherché à comprendre le fonctionnement au niveau programmation
(sauf en cours de sciences de l’ingénieur où nous avons souvent programmé sur Automates
Programmables Industriels (API) en grafcet). J’étais donc très intéressé d’apprendre une
nouvelle forme de programmation robotique. L’utilisation du robot donnait un aspect
matériel et concret, ce qui donne, pour ma part, une motivation supplémentaire.
Marc-Olivier TURENNE Projet ISN 2013
10 | P a g e
Pour ce qui est du travail de groupe, ce projet ISN m’a beaucoup apporté. Au sein du groupe
nous avons travaillé de façon collaborative, en effet, l’entraide a toujours été présente ce qui
donne le plaisir et la satisfaction d’aider les autres mais aussi la reconnaissance d’avoir une
aide lors d’un problème.
La gestion des problèmes aux contraintes temporelles importantes m’a tout de même
apporté des compétences au niveau gestion du temps et m’a permis de prendre (après
consultation avec mes camarades) des décisions importantes concernant par exemple
l’adaptation du cahier des charges.
Dans une vision plus générale, la réalisation de ce projet m’a bien évidemment apporté des
compétences en terme de programmation et algorithmique ce qui est bien sûr important car
ces compétences sont utilisables dans d’autres matières comme les mathématiques ou les
sciences de l’ingénieur et que les ordinateurs (et la programmation) font partie intégrante
du monde actuel. De plus, j’ai appris à approfondir mes recherches sur le WEB, pour trouver
des solutions ou des alternatives.
VIII. Diffusion du projet
Notre projet est à retrouver sur la plateforme Github, qui permet le dépôt de fichiers
importants sur un serveur web. Ce service facilite l’accès à nos fichiers de groupe, sans avoir
besoin de prendre avec soi une clef USB ou un disque dur lorsque l'on ne travaille pas chez
soi, et de plus d’avoir la possibilité de modifier ces fichiers en commun et de voir les
modifications effectuées ainsi que les versions antérieures.
Profil GitHub du groupe :
https://github.com/codelab-info/tratuvi
Profil GitHub du personnel :
https://github.com/marcokite
Pour protéger notre projet, et établir les droits correspondants, nous avons décidé d'utiliser
une licence de diffusion «Créative Commons».
Marc-Olivier TURENNE Projet ISN 2013
11 | P a g e
Nous avons choisis 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 d’une façon ou d’une autre de ce projet : ni
les créateurs, ni les personnes qui pour une raison quelconque auraient accès au projet.
Enfin, le projet appartient à quelqu'un et ne peut pas être usurpé, avec la licence BY.
http://creativecommons.org/licenses/by-nc/3.0/fr/
Il n'y aura donc aucune vente, il s'agit bien ici d'un projet scolaire qui restera dans son cadre.
© Projet ISN 2013 - Robot NXT (Marco TURENNE, Sullivan VILLA, Elouen TRAVAUX)
IX. Annexes
Marc-Olivier TURENNE Projet ISN 2013
12 | P a g e
Programme « Interface de compréhension du système »
//importation des librairies
import processing.serial.*;
import pt.citar.diablu.nxt.protocol.*;
import pt.citar.diablu.processing.nxt.*;
import pt.citar.diablu.nxt.brick.*;
LegoNXT nxt;
void setup() {
// Start connection with LegoNXT brick
println(Serial.list());
nxt = new LegoNXT(this, "COM3");
//Start Touch Sensor
nxt.getButtonState(0);
size(400, 400);//taille de l'interface
fill(255, 0, 0);
background(200);//couleur du fond
//pour les 11 lignes suivantes: dessin des boutons
rect(50, 275, 200, 50);
fill(0);
rect(125, 125, 50, 50);
rect(300, 50, 50, 50);
rect(300, 125, 50, 50);
rect(300, 200, 50, 50);
rect(300, 275, 50, 50);
for (int i=0;i<3;i++) {// boucle "for" de dessin des boutons gérant la
//vitesse
{
fill(0);
rect(50+75*i, 200, 50, 50);
}
fill(255, 255, 255);//couleur du texte (blanc)
//pour les 5 lignes suivantes: texte dans les boutons
text("Forward", 128, 150);
text("Reverse", 128, 225);
text("Left", 55, 225);
text("Right", 210, 225);
text("STOP", 135, 300);
}
}
void draw() {
if (nxt.getButtonState(0) == true){ //si contact à l'avant du robot
print("pressed");//ligne de code destiné au programmeur (pour les
//tests)
//pour les deux lignes suivantes: Le robot tourne sur lui-même
nxt.motorForward(1, 20);
nxt.motorForward(2, -20);
}
}
int j=0;
void mousePressed () { //pour les 6 "if" suivant": gestion du sens des
//moteurs (fonction des boutons)
Marc-Olivier TURENNE Projet ISN 2013
13 | P a g e
if (mouseX >= 125 && mouseX <= 175 && mouseY >= 125 && mouseY<= 175) {
print ("Forward");//ligne de code destinée au programmeur (pour les
//tests)
nxt.motorForward(1, -10-j);
nxt.motorForward(2, -10-j);
}
if (mouseX >= 125 && mouseX <= 175 && mouseY >= 200 && mouseY<= 250) {
print ("Reverse");//ligne de code destinée au programmeur (pour les
//tests)
nxt.motorForward(1, 10+j);
nxt.motorForward(2, 10+j);
}
if (mouseX >= 50 && mouseX <= 100 && mouseY >= 200 && mouseY<= 250) {
print ("Left");//ligne de code destinée au programmeur (pour les tests)
nxt.motorForward(1, 10);
nxt.motorForward(2, -10);
}
if (mouseX >= 200 && mouseX <= 250 && mouseY >= 200 && mouseY<= 250) {
print ("Right");//ligne de code destinée au programmeur (pour les
tests)
nxt.motorForward(1, -10);
nxt.motorForward(2, 10);
}
if (mouseX >= 50 && mouseX <= 250 && mouseY >= 275 && mouseY<= 325) {
print ("STOP");//ligne de code destinée au programmeur (pour les tests)
nxt.motorForward(1, 0);
nxt.motorForward(2, 0);
}
//pour les 3 "if" suivant: Attribution d'une valeur de j de vitesse
// et dessin de rectangle pour connaitre la vitesse (incomplet)
if (mouseX >= 300 && mouseX <= 350 && mouseY >= 50 && mouseY<= 100) {
print ("Vitesse 1");//ligne de code destiné au programmeur (pour les
//tests)
j=20;
fill(56, 187, 222);
rect(300, 50, 50, 50);
fill(0);
rect(300, 125, 50, 50);
rect(300, 200, 50, 50);
rect(300, 275, 50, 50);
}
if (mouseX >= 300 && mouseX <= 350 && mouseY >= 125 && mouseY<= 175) {
print ("Vitesse 2");//ligne de code destinée au programmeur (pour les
//tests)
j=40;
fill(56, 187, 222);
rect(300, 125, 50, 50);
fill(0);
rect(300, 50, 50, 50);
rect(300, 200, 50, 50);
rect(300, 275, 50, 50);
}
Marc-Olivier TURENNE Projet ISN 2013
14 | P a g e
if (mouseX >= 300 && mouseX <= 350 && mouseY >= 200 && mouseY<= 250) {
print ("Vitesse 3");//ligne de code destinée au programmeur (pour les
//tests)
j=60;
fill(56, 187, 222);
rect(300, 200, 50, 50);
fill(0);
rect(300, 50, 50, 50);
rect(300, 125, 50, 50);
rect(300, 275, 50, 50);
}
}
Programme « Mode automatique »
//importation des librairies
import processing.serial.*;
import pt.citar.diablu.nxt.protocol.*;
import pt.citar.diablu.processing.nxt.*;
import pt.citar.diablu.nxt.brick.*;
LegoNXT nxt;
void setup() {
// Start connection with LegoNXT brick
println(Serial.list());
nxt = new LegoNXT(this, "COM3");
//Start Touch Sensor
nxt.getButtonState(0);
//Start Distance Sensor
nxt.getDistance(1);
size(800, 800);
fill(255, 0, 0);
background(200);
rect(300, 300, 200, 100);
fill(0);
text("START/STOP",360 ,360); //
}
void draw() {
if (nxt.getDistance(1) > 7) { //si la distance capteur-ultrasonique/sol
est supérieure à 7
print ("escalier"); //ligne de vérification destinée au programmeur
//pour les 8 lignes suivantes: le robot recule pendant 2s, tourne
sur lui-même pendant 2s et repart en marche avant
nxt.motorForward(1, 20);
nxt.motorForward(2, 20);
delay(2000);
nxt.motorForward(1, -20);
nxt.motorForward(2, 20);
Marc-Olivier TURENNE Projet ISN 2013
15 | P a g e
delay(2000);
nxt.motorForward(1, -20);
nxt.motorForward(2, -20);
}
if (nxt.getButtonState(0) == true) { //si il y a un contact à l'avant du
robot
print ("obstacle vertical");//ligne de vérification destinée au
programmeur
//pour les 8 lignes suivantes: le robot recule pendant 2s, tourne sur
lui-même pendant 2s et repart en marche avant
nxt.motorForward(1, 20);
nxt.motorForward(2, 20);
delay(2000);
nxt.motorForward(1, -20);
nxt.motorForward(2, 20);
delay(2000);
nxt.motorForward(1, -20);
nxt.motorForward(2, -20);
}
}
Programme « Mode déplacement Vitesse Variable » (cible)
//Importation des librairies
import processing.serial.*;
import pt.citar.diablu.nxt.protocol.*;
import pt.citar.diablu.processing.nxt.*;
import pt.citar.diablu.nxt.brick.*;
LegoNXT nxt;
//déclaration des variables
int onoff=0;
int x; //position en abscisse par rapport au centre de la fenêtre
int y; //position en ordonnée par rapport au centre de la fenêtre
//valeur de vitesse (en réel: utilisation impossible dans la fonction
nxt.motorForward(int, int);
float vitxx;
float vityy;
//valeur de vitesse (en entier utilisable dans la fonction
nxt.motorForward(int, int);
int vitx;
int vity;
void setup() {
//Start connection with LegoNXT brick
println(Serial.list());
nxt = new LegoNXT(this, "COM3");
size(800, 800);
background(0, 0, 0);
Marc-Olivier TURENNE Projet ISN 2013
16 | P a g e
//dessin de l’interface
fill(0, 0, 0);
stroke(0, 255, 0);
smooth(); //lissage des cercles
ellipse(400, 400, 800, 800);
ellipse(400, 400, 600, 600);
ellipse(400, 400, 400, 400);
ellipse(400, 400, 200, 200);
stroke(0, 255, 0);
line(0, 400, 800, 400);
line(400, 0, 400, 800);
fill(255, 20, 20);
ellipse(400, 400, 30, 30);
}
void draw() {
//calcul de la position du curseur par rapport au centre de la fenêtre
x=(mouseX-400);
y=(mouseY-400);
println("x="+x+"-y="+y);//Ligne destinée au programmeur (pour les tests)
//transformer la position du curseur en valeur de vitesse
vitxx=(0.15*x);
println(vitxx);//Ligne destinée au programmeur (pour les tests)
vitx = (int) vitxx;
//Lignes destinées au programmeur (pour les tests)
print("vitx=");
println (vitx);
println();
vityy=(0.15*y);
println(vityy);//Ligne destinée au programmeur (pour les tests)
vity = (int) vityy;
//Ligne destinée au programmeur (pour les tests)
print("vity=");
println (vity);
println();
println();
if (onoff==1) {//vérification que les moteurs doivent être actifs (voir
le void mousePressed())
//si onoff=1 il y a déplacement
//vitesse et sens de la rotation des moteurs en fonction de la zone dans
laquelle est le curseur
if (x>0) {
nxt.motorForward(1, vity-vitx);
nxt.motorForward(2, vity);
}
Marc-Olivier TURENNE Projet ISN 2013
17 | P a g e
if (x<0) {
nxt.motorForward(1, vity);
nxt.motorForward(2, vity+vitx);
}
}
else {//si onoff=0, les moteurs sont mis à zéro: aucun déplacement
nxt.motorForward(1, 0);
nxt.motorForward(2, 0);
}
}
void mousePressed() { //un clic souris change la valeur de la variable
onoff
//permet d'arrêter le robot en un clic
if (i==0) {
onoff=1;
}
else {
onoff=0;
}
}
top related