Post on 21-Dec-2015
description
Rapport de Projet Tuteuré
PAYET FABIEN – LEPINAY KEVIN – FRANCOISE-GERBITH EMMANUEL
COMPORTEMENTS DE ROBOTS CONVOI DE ROBOTS
Semestre 3 (Septembre - Décembre 2012)
2 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
Introduction : Page 3
I – Convoi de Robot NXT infrarouge : Page 5
A – Capteur Infrarouge NXTSUMOEYES : Page 5
B – Programmation du convoi Infrarouge : Page 7
C – Convoi maitre suiveur de ligne et Esclave infrarouge : Page 9
D – Convoi maître dirigée par Smartphone et Esclave infrarouge : Page 10
E – Convoi maître autonome et Esclave infrarouge : Page 12
II – L’application Android améliorée : Page 14
A – Ancienne Application : Page 14
B– Notre nouvelle Application : Page 14
C– Programmation de notre Application : Page 15
III – Le Capteur accéléromètre : Page 17
A – Le capteur : Page 17
B– Notre protocole : Page 19
Conclusion Page 20
Annexe Page 21
3 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
Introduction :
Durant notre DUT Réseaux et Télécommunications, nous avons une certain mission concernant les projets
tuteurés:
« Mettre en place un Convoi de Robots NXT »
L'objectif de ce projet est donc de mettre en place des protocoles de communications ainsi que des
stratégies permettant la mise en place d'un convoi de robots Lego Mindstorm devant se déplacer dans un
environnement incertain.
L’année dernière nous avons atteins plusieurs étapes :
▪ 1ère étape : Nous nous sommes tout d’abord familiariser avec les robots NXT, ses caractéristiques, sa
technologie Bluetooth, le logiciel de programmation NXC (avec BRIXC) etc…
▪ 2ème étape : De plus, nous avons réalisé notre premier convoi de Robot NXT en utilisant la technologie
Bluetooth qui a permis au Robot Maître d’envoyer des actions au robots esclaves afin que celui-ci puisse le
suivre. Nous avons cependant remarqué un disfonctionnement au niveau du convoi sur une longue
distance à cause des mauvais réglages des moteurs.
▪ 3ème étape : Pour finir nous avons réalisé une application Smartphone qui contrôle le robot NXT par
Bluetooth.
Pour cette année, nous avons définit de nouvelle étapes que nous avons également atteins à ce jour :
▪ Nous avons pu remarquer que pour le convoi de Robot en Bluetooth, nous avons eu des problèmes au
niveau des moteurs des robots. En effet, à chaque fois, il y avait un léger décalage des moteurs qui se
produisait (si un robot voulait aller tout droit, il allait un peu vers la gauche) ; cela a donc provoqué un
4 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
disfonctionnement au niveau du convoi. Pour améliorer cela, nous avons décidé de changer de protocole
et d’utiliser un capteur infrarouge :
4ème étape : Améliorer le convoi de Robot (capteur Infrarouge)
(100% , terminer)
▪ Recherche du type de capteur à utiliser
▪ Commander Capteur
▪ Programmer capteur Infrarouge pour robot esclave
▪ Test du programme
▪ Dans notre projet, nous devons également utiliser un capteur GPS qui permettra à un robot esclave de
retrouver le convoi de robot NXT grâce à la position GPS de son maître. Mais nous avons pu remarquer des
problèmes de précision, de transfert d’information etc … dû au capteur GPS. Nous avons donc décidé de
partir sur l’étude d’un capteur Accéléromètre qui permettra au robot esclave de retrouver son maître avec
un certain calcul de la distance et du trajet réaliser par le maître :
5ème étape : Utilisation du capteur Accéléromètre (pour retrouver le robot maître)
(50% , étude en cour)
▪ Recherche du type de capteur à utiliser
▪ Programmer Capteur
▪ Tester Programme (à réaliser)
▪ De plus, dû aux problèmes d’arrêt de moteur au niveau de l’application Smartphone qui dirige le robot,
nous avons décidé de le modifier et de faire en sorte que l’on puisse diriger le robot avec l’inclinaison du
Smartphone :
6ème étape : Améliorer Application Bluetooth
(100% , terminé)
▪ Améliorer programme (en utilisant l’inclinaison du smartphone) (presque terminé)
▪ Améliorer Design de l’application (dû au changement du programme) (à réaliser)
▪ Tester la nouvelle application (à réaliser)
▪ Pour finir, nous avons décidé de réaliser un Convoi de Robot à 3, c'est-à-dire avec un Smartphone qui
dirige un robot maître, et un esclave qui suit le robot maître grâce à son capteur infrarouge :
7ème étape : Convoi de Robot à 3
(100%, terminé)
▪ Programme Capteur Infrarouge
▪ Application Bluetooth (terminé)
▪ Tester le convoi
Utilisation d’un
accéléromètre.
5 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
I – Convoi de Robot NXT infrarouge :
Nous avons donc décidé de réaliser notre convoi de Robot en infrarouge. Le principe est simple : Le robot
maître avance selon ses propres moyens (dirigée par un Smartphone ou autonome) et le robot esclave
derrière lui, suivra son maître avec un capteur infrarouge qui lui permettra de savoir où se situe son robot
maître, et ainsi le suivre en effectuant les mêmes mouvements.
A – Capteur infrarouge NXTSUMOEYES :
Pour ce Projet de convoi, nous avons choisis un capteur NXT appelé « NXTSUMOEYES ». Ce capteur
infrarouge permet ainsi de détecter des alignements de formes et d'obstacles nous permettant ainsi
d'aligner notre robot en face de l'obstacle (pour une compétition de Sumo par exemple) ou bien d'éviter
l'obstacle. Dans notre cas de convoi, l’obstacle est le robot Maître situé devant l’esclave. En effet, avec ce
capteur infrarouge, l’esclave va pouvoir s’aligner derrière son robot Maître.
▪ Voici le Capteur infrarouge « NXTSUMOEYES » :
La particularité de ce capteur est qu’il permet de définir si un obstacle se situe dans l'une des 6 zones
définies ci-dessous, nous permettant ainsi de déterminer la position que le robot doit adopter face à
l'obstacle :
▪ Voici le cône de détection du Capteur infrarouge « NXTSUMOEYES » :
6 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
Le capteur NXTSumoEyes est pré-calibré et ne nécessite aucune calibration. Le faisceau infrarouge sur le
côté gauche et droit de l'IR LED s'étend comme indiqué dans la figure ci-dessus. La zone de courte portée
est d'environ 15 cm, et la zone à longue portée est d'environ 30 cm.
De plus, cette distance des plages change en fonction de la réflectivité de l’obstacle, par exemple un
obstacle blanc est détectable à une plus longue distance d'un objet sombre. La plage de détection des
objets très sombres est considérablement réduite (de moitié ou du tiers).
Dans le cadre de notre projet de convoi de robot, nous allons utiliser ce capteur infrarouge sur le robot
esclave qui est situé à l’arrière du robot Maître. En effet voici sous forme de schéma le fonctionnement de
notre convoi infrarouge :
Ici, on peut voir que le robot Esclave va suivre le robot maître en allant à la Zone où il a détecte le robot
Maître.
Afin de ne pas confondre le Robot maître et les obstacles au alentour, il est nécessaire dans notre
cas de rapprocher au maximum les deux robots (maîtres et esclaves).
Nous allons également utiliser sur le robot Esclave un capteur Ultrason afin
que le robot Esclave ne touche pas le robot Maître devant lui :
D’après nos tests effectués, la distance entre le robot maître et le robot esclave devra être entre 10 et 20
cm. Tant que le robot esclave ne respecte pas cette contrainte, il devra accélérer s’il est trop loin, ou ralentir
sa vitesse dans le cas contraire.
!
7 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
B – Programmation du Convoi infrarouge :
Dans notre cas, nous avons choisis de programmer en C. Enfin... ce n'est pas réellement du C
mais presque. En effet, nous allons programmer en NXC : " Not Exactly C".
Le Not eXactly C (pas exactement du C ) ou NXC est un langage de programmation spécifique
au robot NXT basé sur le NBC, un langage assembleur. L'IDE associé à ce langage est BricxCC.
▪ Voici notre algorithme destiné au robot Esclave qui utilise le capteur Infrarouge :
NON
OUI
NON
OUI
OUI
OUI
OUI
8 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
▪ Voici notre programme destiné au robot Esclave qui utilise le capteur Infrarouge :
task main()
{
// On définis les zones:
#define DROITE 691
#define GAUCHE 353
#define AVANT 810
// On active le capteur NXTSumoEyes:
SetSensorNXTSumoEyes(S1, false); // le "false" indique que l'on travaille
// sur la zone < 15cm
// On active le capteur Ultrason:
SetSensorLowspeed(IN_2);
int zone = SensorNXTSumoEyesRaw(S1); // On crée la zone
while(true)
{
// Si capteur ultrason détecte robot a <10cm, on s'arrete.
if(SensorUS(IN_2)<10)
{
OnFwd(OUT_A,0);
OnFwd(OUT_B,0);
Wait(MS_50);
}
// Sinon si capteur ultrason detecte robot entre 10 et 20 cm,
// on avance normalement:
else if(SensorUS(IN_2)>10 && SensorUS(IN_2)<20)
{
OnFwd(OUT_A,60);
OnFwd(OUT_B,60);
Wait(MS_50);
}
// Sinon on active le capteur infrarouge SUMOEYES:
else
{
switch (zone)
{
case DROITE: // Si c’est a droite, on tourne à droite.
TextOut(5,LCD_LINE2,"DROITE");
NumOut(0, LCD_LINE1, SensorNXTSumoEyesRaw(S1));
OnFwd(OUT_A,70);
OnFwd(OUT_B,-30);
break;
case AVANT: // Si c’est devant, on accélère pour rattraper retard
TextOut(5,LCD_LINE2,"AVANT ");
NumOut(0, LCD_LINE1, SensorNXTSumoEyesRaw(S1));
OnFwd(OUT_A,100);
OnFwd(OUT_B,100);
break;
case GAUCHE: // Si c’est a gauche, on tourne à gauche.
TextOut(5,LCD_LINE2,"GAUCHE");
NumOut(0, LCD_LINE1, SensorNXTSumoEyesRaw(S1));
OnFwd(OUT_A,-30);
OnFwd(OUT_B,70);
break;
9 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
default:
TextOut(5,LCD_LINE2," RIEN ");
NumOut(0, LCD_LINE1, SensorNXTSumoEyesRaw(S1));
OnFwd(OUT_A,0);
OnFwd(OUT_B,0);
break;
}
}
NumOut(0, LCD_LINE6, SensorNXTSumoEyesRaw(S1));
Wait(MS_50);
zone = SensorNXTSumoEyesRaw(S1);
}
}
C – Convoi Maître suiveur de ligne et Esclave infrarouge :
Testons maintenant notre programmer en réalisant ce convoi :
▪ Le Robot Maître suivra une ligne de couleur noir (le programme suiveur de ligne est sur notre site ou
dans le rapport du 2ème semestre)
▪ Le Robot Esclave suivra son robot maître avec ces capteurs infrarouge et ultrason.
Voici quelque image du convoi :
Robot maître qui
suit la ligne avec
son capteur de
couleur.
Robot esclave
qui suit le maître
avec son capteur
infrarouge.
Le robot esclave reste toujours à une
certaine distance du maître…
10 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
(Merci de consulter notre site … afin de voir la vidéo du convoi).
Indication : Ce convoi marche parfaitement, nous avons également testé avec une autre forme de ligne et
le convoi à également fonctionné.
D – Convoi Maître Dirigée par Smartphone et Esclave infrarouge :
Nous réalisons maintenant un autre type de convoi :
▪ Le Robot Maître sera dirigée avec un Smartphone. Pour cela nous utilisons notre application Bluetooth
que nous avons réalisé le semestre précédant qui permet de diriger le robot NXT avec un Smartphone
(sous Android).
▪ Le Robot Esclave suivra son robot maître avec ces capteurs infrarouge et ultrason.
!
Les rayons du capteur
infrarouge captent le
papier blanc situé à
l’arrière du robot
maître
11 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
Voici quelque image du convoi :
(Merci de consulter notre site … afin de voir la vidéo du convoi).
!
Robot maître qui
est dirigé par le
Smartphone en
Bluetooth …
Robot esclave
qui suit le maître
avec son capteur
infrarouge.
Robot maître qui
tourne à gauche
Robot esclave qui
suit le maître et
tourne à gauche
également…
Les rayons du capteur
infrarouge captent le
papier blanc situé à
l’arrière du robot
maître
12 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
E– Convoi Maître Autonome et Esclave infrarouge :
A présent que notre Robot Esclave a toutes ces capacités à suivre son robot Maître, nous allons réaliser
notre convoi :
▪ Le Robot Maître réalisera un trajet aléatoire dans un environnement incertain (il évitera les obstacles sur
son chemin etc.…)
(Le Programme qui permet au robot maître de rouler dans un environnement incertain est dans
l’annexe)
▪ Le Robot Esclave suivra son robot maître avec ces capteurs infrarouge et ultrason.
Par conte, après plusieurs tests, nous nous sommes arrêtés sur un gros problème. En effet, voici un
schéma du convoi pour comprendre le problème :
Le Robot maître avance et détecte un obstacle. Pas de panique, il est autonome et regarde de gauche à
droite afin de trouver une solution de trajet. Il tourne donc par la suite à gauche et … :
Le robot esclave suit l’objet devant lui … il suit donc le maître pendant un instant puis il rencontre
l’obstacle et croit que celui-ci est le maître. Il reste donc bloqué ICI.
!
13 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
▪ Notre solution :
Nous avons été obligés de trouver une solution à ce problème. En effet, nous allons utiliser notre
protocole de communication Bluetooth du premier convoi NXT de l’année dernière. Avec cela, le robot
maître pourra indiquer via Bluetooth au robot esclave, si il y a un obstacle, de quel côté où il faut aller …
Voici un algorithme explicatif :
Avec ce principe, nous pouvons ainsi réaliser un convoi avec un robot maître autonome évitant des
obstacles et un robot esclave le suivant. Nous avons déjà débuté la programmation de ce convoi mais
nous n’avons pas totalement terminé. Nous nous sommes donc fixé comme objectif pour l’année
prochaine de travailler principalement sur ce convoi.
14 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
II – L’application Androïd améliorée :
A –Ancienne application :
Lors de la soutenance précédente, nous vous avons présentée notre application pour contrôler le robot
NXT maître.
Les problèmes rencontrés pour cette application sont :
Pour le problème n°1 :
Vous avez pu remarquer que lorsque l’on appuyait sur le bouton pour avancer par exemple, le robot
avancé indéfiniment sans s’arrêtait.
Pour le problème n°2 :
Pour y remédié au problème n°1, nous étions obligé de créer un autre bouton pour permettre l’arrêt totale
du moteur. Mais cela n’est pas très intéressant pour la personne qui pilotera le NXT.
Donc c’est pour cela, que nous avons voulu améliorer ces petits problèmes de l’application en utilisant
l’inclinaison du Smartphone.
B – Notre nouvelle Application Androïd :
Tout d’abord, pour la création de cette nouvelle application nous avons utilisé comme l’application
précédente Google App Inventor. Pour les problèmes rencontrés sur l’application précédente, nous avons
pu réussir à améliorer cela. Car maintenant lorsque le téléphone est stabilisé, le robot s’arrête
immédiatement.
Les téléphones Androïde possèdent pour la plupart un senseur d'orientation qui permet de connaître l'orientation du téléphone dans l'espace. L'orientation du téléphone est donnée par trois valeurs :
Problème n°2
Problème n°1
15 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
l'Azimtuh en degrés angle formé par l'axe vertical du téléphone (axe x) et la direction nord 0° ≤ azimuth ≤ 360°
le Pitch en degrés angle formé par l'axe horizontal du téléphone (axe y) et la position horizontal de référence -180° ≤ pitch ≤ 180°
le Roll en degrés angle formé par l'axe vertical du téléphone (axe x) et la position horizontal de référence -90° ≤ roll ≤ 90°
VOICI UN SCHEMA EXPLICATIF :
Pour notre application, nous utilisons plus le Pitch (Tangage) et le Roll (Roulis) cela va nous permettre
d’incliner vers l’avant et l’arrière le Smartphone mais aussi d’incliné le téléphone vers la droite et la
gauche.
C –Programmation de notre nouvelle Application :
Maintenant, nous allons passer à la partie programmation de l’application. Nous
avons utilisé sur App Inventor le composant OrientationSensor qui va nous permettre
de déterminer l'orientation spatiale du téléphone. Ce capteur d'orientation est un élément non-visible qui
présente les trois valeurs que nous avons décrit précédemment.
16 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
Nous faisons une condition qui est si le client Bluetooth est connecté :
Si la valeur du roll est supérieure à 1 le robot tournera dans le sens horaire
Sinon il tournera dans le sens antihoraire
De plus si la valeur du pitch est supérieure à 1 alors le robot avancera
Sinon il va reculer
▪ De plus, vous pouvez constatez que par exemple nous avons multiplié le pitch par 3. Nous avons décidé
de faire cela car sur l’écran de l’application nous avons mis en place l’affichage du pitch, roll et azimuth. En
faisant des tests, nous nous sommes aperçus qu’en inclinant le téléphone vers l’avant, il y avait une valeur
pour le pitch. Donc à partir de ces valeurs, nous avons fait en sorte que lorsque nous voulons avancer, nous
multiplions par 3 donc on obtiendra un chiffre supérieur à 1 et lorsque l’on multipliera par -3 nous serons
dans l’autre condition et cela nous permettra de reculer car en multipliant le pitch par -3 on obtiendra un
chiffre inférieur à 1.
▪ Voici notre application sur un smartphone :
On retrouve bien les valeurs du pitch, du roll
et de l’azimuth. De plus l’application est beaucoup plus
pratique à utiliser.
Block OrientationSensor
Ici, nous associons une
valeur au roll et cela est
identique pour le pitch
et azimuth.
Le block OrientationSensor
définit trois valeurs
17 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
III – Le capteur accéléromètre :
▪ Dans un second temps dans notre projet, le protocole de communication sera étendu pour laisser une
certaine autonomie à chaque robot participant. Ainsi, le maître ne pilotera plus directement les Esclaves mais pourra par exemple leur indiquer sa position . Chaque robot participant au convoi sera donc libre de quitter ou rejoindre le convoi. ▪ Pour concevoir cela, nous avons décidé de configurer un capteur accéléromètre sur chaque robot. Ainsi, le robot maître calculera sa position et enverra ces données au robot esclave qui, d’après sa position retrouvera son maître en se rapprochant des données du maître reçu. La communication entre les robots se fera en Bluetooth.
A –Le capteur :
▪ Un accéléromètre est un capteur qui, fixé à un mobile ou tout autre
objet, permet de mesurer l’accélération linéaire de ce dernier. On
parle encore d'accéléromètre même s'il s'agit en fait de 3
accéléromètres qui calculent les 3 accélérations linéaires selon 3 axes
orthogonaux .
▪ Bien que l'accélération linéaire soit définie en m/s2 (SI), la majorité
des documentations sur ces capteurs expriment l'accélération en
« g » (accélération causée par la gravitation terrestre, soit environ
g = 9,81 m/s2).
▪ Voici un exemple d'accéléromètre utilisé par l’Institut d'études géologiques des États-Unis pour mesurer
l'importance du mouvement du sol :
▪ De plus, les accéléromètres sont utilisés pour détecter une chute (forte accélération) et arrêter le disque
dur. Ce fut la première utilisation récente d'un accéléromètre (Apple dans ses MacBook Pro), application
qui fut rapidement détournée et devint célèbre, ce qui amena à l'inclusion d'un accéléromètre dans
l'iPhone du même Apple, puis la généralisation de ce composant.
18 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
▪ Les applications de ce capteur sont très diverses :
la mesure de vitesse (par intégration) la mesure de déplacement (par double intégration) le diagnostic de machine (par analyse vibratoire) la détection de défaut dans les matériaux (en mesurant la propagation d'une vibration à travers les
matériaux)
▪ Néanmoins, elles sont généralement classées en trois grandes catégories :
Les chocs L'accélération vibratoire L'accélération de mobiles
A propos du capteur accéléromètre NXT :
Ce capteur d'accélération pour Lego Mindstorms NXT mesure l'accélération sur trois axes dans un intervalle de -2g / +2g. Le capteur permet également de mesurer une pente par rapport à l'horizontal. Comme le montre la figure ci-dessous, la mesure de l'accélération est effectuée sur 3 axes libellés :
▪ Les mesures sont effectuées approximativement 100 fois par secondes. ▪ Ce capteur se connecte grâce à un câble standard (non fourni) et utilise le protocole de communication I2C (Inter Integrated Circuit). ▪ La norme I2C est un bus qui a émergé de la « guerre des standards » lancée par tous les acteurs du
monde électronique. Conçu par Philips en 1982,pour les applications de domotique et d’électronique
domestique, il permet de relier facilement à un microprocesseur différents circuits notamment ceux d’une
télévision moderne (récepteur de la télécommande, réglages des amplificateurs basses fréquences, tuner,
horloge, gestion de la prise péritel, etc.).
19 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
B –Notre protocole :
Avec ce capteur, on va donc pouvoir permette au robot esclave perdus en chemin, de retrouver son
maître. Voici le fonctionnement de notre stratégie :
▪ Le Robot maître et le robot Esclave débute le convoi avec des coordonnées comme ci-dessous :
▪ Le Robot maître réalise son parcours mais le robot esclave se perd et doit retrouver son chemin :
Ce protocole sera donc notre prochaine mission pour l’année prochaine. Ainsi on pourra réaliser un convoi
autonome, avec des robots esclaves qui peuvent quitter et rejoindre le convoi selon leur besoin.
Robot
Maître
Robot
Esclave
Coordonnées :
;
Coordonnées :
;
Distance de 50 cm
Il ne faut pas oublier d’ajouter 50 cm
à la position dû à la distance de
départ au début du convoi.
Robot
Maître
Coordonnées :
;
Coordonnées :
;
Robot
Esclave
Le maître envoie ses coordonnées
données par son capteur
d’accéléromètre et attend l’esclave.
Le robot esclave reçois les coordonnées du maître et réalise un
calcul afin de retrouver la position du maître ( ;
). Il roule ensuite jusqu’à arriver à la position du
maître.
hey ???
20 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
CONCLUSION :
Nous voila donc en fin d’année, et nous avons réussis à améliorer notre précédant convoi de Robot NXT.
Certes, nous devons encore modifier plusieurs paramètres et l’améliorer pour l’année prochaine.
Résumons ce que nous avons donc effectué ces 4 derniers mois :
▪ Réalisation d’un convoi de robot avec un maître dirigé par un Smartphone et un esclave le suivant avec
un capteur infrarouge.
▪ Réalisation d’un convoi de robot avec un maître suiveur de ligne et un esclave le suivant avec un capteur
infrarouge
▪ Etude d’un convoi autonome (en cour de programmation)
▪ Amélioration de l’application Smartphone Android pour diriger le robot.
▪ Etude du capteur d’accéléromètre (pour plus tard) & mise en place d’une stratégie.
▪ Programmer le robot maître pour être autonome (il reste quelque petite amélioration à apporter).
Pour l’année prochaine, nous avons encore d’autres missions comme par exemple :
▪ Réaliser le convoi avec une certaine autonomie (capteur d’accéléromètre)
▪ Programmer le capteur d’accéléromètre pour retrouver le robot maître.
▪ Réaliser un convoi avec robot maître autonome et robot esclave suiveur de ligne.
▪ etc …
Nous vous invitons également à visiter notre site, pour avoir plus d’information, voir des vidéos de nos
exécutions de programmes, et pour pouvoir suivre notre projet tuteuré :
https://sites.google.com/a/rt-iut.re/projetrobot/
21 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
ANNEXE
Suiveur de ligne
Ce Programme va permettre au robot NXT de suivre une ligne de couleur noire. Le principe est simple. Si le
capteur détecte une couleur noire, il tourne d’un côté, sinon il tourne de l’autre côté. Ainsi, le robot va se
déplacer tout en restant sur la ligne. Si s’éloigne de la ligne il va donc retourné sur lui-même et retrouver la
ligne.
// --------------------- Programme suiveur de ligne ----------------------------
// Réalisé par : PAYET Fabien | LEPINAY Kévin | F-G Emmanuel
// Descprition : Ce Programme permet au robot de suivre une ligne de couleur
// noire (valeur = 1).
// Date : Février 2012.
// Capteur : [port 1 : -] [port 2 : -] [port 3 : Couleur]
// -----------------------------------------------------------------------------
task main()
{
SetSensor(IN_3, SENSOR_COLORFULL); // Définit le capteur en entrée 3 : Capteur
couleur
while (true)
{
if(Sensor(IN_3) == 1) // Si la valeur du capteur est 1 (noir)
{
OnFwd(OUT_B, 75); // Moteur B à 75
OnFwd(OUT_A, 5); // Moteur A à 5, le robot va tourné dans un sens
}
else
{
OnFwd(OUT_B, 5); // Moteur B à 5
OnFwd(OUT_A, 75); // Moteur A à 75, le robot va tourné dans l’autre sens
}
}
}
Indication :
▪ SetSensor(IN_x, Type_de_capteur) : Définit la configuration du capteur en entrée « x » .
▪ Sensor(IN_x) : Donne la valeur du capteur branché en entrée x
▪ OnFwd(OUT_x, vitesse) : Active les moteurs en sortie branché sur la sortie « x » et à la vitesse indiqué
22 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
Convoi de robot infrarouge
Ce Programme va permettre à un robot esclave ayant un capteur infrarouge de suivre son robot maître
situé devant lui grâce au capteur NXTSUMOEYES :
// ------------------------- Programme Infrarouge 1 ----------------------------
// Réalisé par : PAYET Fabien | LEPINAY Kévin | F-G Emmanuel
// Descprition : Ce programme va permette au Robot Esclave ayant un capteur
// infrarouge, de dectecter le robot maitre devant lui, et de le suivre
// et ainsi de répeter ses actions
//
// Date : Octobre 2012.
// Capteur : [port 1 : NXTSumoEyes] [port 2 : Capteur Ultrason] [port 3 : -]
// -----------------------------------------------------------------------------
task main()
{
// On définis les zones:
#define DROITE 691
#define GAUCHE 353
#define AVANT 810
// On active le capteur NXTSumoEyes:
SetSensorNXTSumoEyes(S1, false); // le "false" indique que l'on travaille
// sur la zone < 15cm
// On active le capteur Ultrason:
SetSensorLowspeed(IN_2);
int zone = SensorNXTSumoEyesRaw(S1); // On crée la zone
while(true)
{
// Si capteur ultrason détecte robot a <10cm, on s'arrete.
if(SensorUS(IN_2)<10)
{
OnFwd(OUT_A,0);
OnFwd(OUT_B,0);
Wait(MS_50);
}
// Sinon si capteur ultrason detecte robot entre 10 et 20 cm,
// on avance normalement:
else if(SensorUS(IN_2)>10 && SensorUS(IN_2)<=20)
{
OnFwd(OUT_A,70);
OnFwd(OUT_B,70);
Wait(MS_50);
}
// Sinon On active le capteur infrarouge SUMOEYES:
else
{
switch (zone)
{
case DROITE: // Si le maitre est dans la zone droite, on tourne à droite...
TextOut(5,LCD_LINE2,"DROITE");
23 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
NumOut(0, LCD_LINE1, SensorNXTSumoEyesRaw(S1));
OnFwd(OUT_A,100);
OnFwd(OUT_B,-30);
break;
case AVANT: // Si le maitre est dans la zone au milieu, on accélère...
TextOut(5,LCD_LINE2,"AVANT ");
NumOut(0, LCD_LINE1, SensorNXTSumoEyesRaw(S1));
OnFwd(OUT_A,100);
OnFwd(OUT_B,100);
break;
case GAUCHE: // Si le maitre est dans la zone gauche, on tourne à gauche...
TextOut(5,LCD_LINE2,"GAUCHE");
NumOut(0, LCD_LINE1, SensorNXTSumoEyesRaw(S1));
OnFwd(OUT_A,-30);
OnFwd(OUT_B,100);
break;
default:
TextOut(5,LCD_LINE2," RIEN ");
NumOut(0, LCD_LINE1, SensorNXTSumoEyesRaw(S1));
OnFwd(OUT_A,0);
OnFwd(OUT_B,0);
break;
}
}
NumOut(0, LCD_LINE6, SensorNXTSumoEyesRaw(S1));
Wait(MS_50);
zone = SensorNXTSumoEyesRaw(S1);
}
}
24 | R a p p o r t d e P r o j e t T u t e u r é S e m e s t r e 3 ( 2 0 1 2 )
Robot Autonome
// ------------------------- Programme Robot Autonome --------------------------
// Réalisé par : PAYET Fabien | LEPINAY Kévin | F-G Emmanuel
// Descprition : Ce programme va permette au Robot Maitre de faire un trajet
// autonome, en évitant les obstacles qu'il rencontrera.
//
// Date : Novembre 2012.
// Capteur : [port 1 : -] [port 2 : Capteur Ultrason] [port 3 : -]
// -----------------------------------------------------------------------------
task main()
{
int distance_droite = 0;
int distance_gauche = 0;
// On active le capteur Ultrason:
SetSensorLowspeed(IN_2);
while(true)
{
// Si capteur ultrason détecte robot a <20cm, on regarde autour:
if(SensorUS(IN_2)<20)
{
OnFwd(OUT_A,0);
OnFwd(OUT_B,0);
RotateMotor(OUT_C, 75, 90); // On regarde à droite
distance_droite = SensorUS(IN_2);
RotateMotor(OUT_C, 75, -180); // On regarde à gauche
distance_gauche = SensorUS(IN_2);
RotateMotor(OUT_C, 75, 90);
if(distance_gauche > 15) // Si il y a rien a gauche,
{ // On va a gauche
OnFwd(OUT_A,70);
OnFwd(OUT_B,-70);
Wait(900);
}
else // Sinon on va a droite...
{
OnFwd(OUT_A,-70);
OnFwd(OUT_B,70);
Wait(900);
}
}
else // Si pas d'osbctacle, on avance normalement...
{
OnFwd(OUT_A,60);
OnFwd(OUT_B,60);
Wait(100);
}
Wait(100);
}
}