Rapport Convoi-Robot

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 0

Annexe Page 21


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


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.


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 » :


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.

!


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

http://fr.wikipedia.org/wiki/Bricx_Command_Center


▪ 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 ");


OnFwd(OUT_A,100);

OnFwd(OUT_B,100);

break;

case GAUCHE: // Si c’est a gauche, on tourne à gauche.

TextOut(5,LCD_LINE2,"GAUCHE");


OnFwd(OUT_A,-30);

OnFwd(OUT_B,70);

break;


default:

TextOut(5,LCD_LINE2," RIEN ");


OnFwd(OUT_A,0);

OnFwd(OUT_B,0);

break;

}

}


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…


(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).


!

Les rayons du capteur

infrarouge captent le

papier blanc situé à

l’arrière du robot

maître


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


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)


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.

!


▪ 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.


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


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.


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


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.


▪ 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.).

http://fr.wikipedia.org/wiki/Philips

http://fr.wikipedia.org/wiki/Domotique

http://fr.wikipedia.org/wiki/Microprocesseur

http://fr.wikipedia.org/wiki/T%C3%A9l%C3%A9vision

http://fr.wikipedia.org/wiki/Tuner

http://fr.wikipedia.org/wiki/P%C3%A9ritel


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 ???


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/

https://sites.google.com/a/rt-iut.re/projetrobot/


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é


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 ----------------------------


// 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



int zone = SensorNXTSumoEyesRaw(S1); // On crée la zone

while(true)

{

// Si capteur ultrason détecte robot a <10cm, on s'arrete.


{

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");



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 ");


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");


OnFwd(OUT_A,-30);

OnFwd(OUT_B,100);

break;

default:

TextOut(5,LCD_LINE2," RIEN ");


OnFwd(OUT_A,0);

OnFwd(OUT_B,0);

break;

}

}


Wait(MS_50);

zone = SensorNXTSumoEyesRaw(S1);

}

}


Robot Autonome

// ------------------------- Programme Robot Autonome --------------------------


// 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;



while(true)

{

// Si capteur ultrason détecte robot a <20cm, on regarde autour:


{

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);

}

}

Rapport Convoi-Robot

Documents

Transcript of Rapport Convoi-Robot