Marc-Olivier TURENNE-Terminale S4 Projet ISN 2013isn.codelab.info/site/assets/files/1301/dossier_isn_marco.pdf · Ces capteurs peuvent par exemple servir à faire interagir le robot

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


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.


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


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


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


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


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.


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


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

https://github.com/codelab-info/tratuvi

https://github.com/marcokite


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

http://creativecommons.org/licenses/by-nc/3.0/fr/


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



}

}

int j=0;

void mousePressed () { //pour les 6 "if" suivant": gestion du sens des

//moteurs (fonction des boutons)


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

}


print ("Reverse");//ligne de code destinée au programmeur (pour les

//tests)

nxt.motorForward(1, 10+j);

nxt.motorForward(2, 10+j);

}


print ("Left");//ligne de code destinée au programmeur (pour les tests)



}


print ("Right");//ligne de code destinée au programmeur (pour les

tests)



}


print ("STOP");//ligne de code destinée au programmeur (pour les tests)



}

//pour les 3 "if" suivant: Attribution d'une valeur de j de vitesse

// et dessin de rectangle pour connaitre la vitesse (incomplet)


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

}


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

}


14 | P a g e


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





LegoNXT nxt;

void setup() {

// Start connection with LegoNXT brick



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



delay(2000);




15 | P a g e

delay(2000);



}

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



delay(2000);



delay(2000);



}

}

Programme « Mode déplacement Vitesse Variable » (cible)

//Importation des librairies





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



size(800, 800);

background(0, 0, 0);


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


}


17 | P a g e

if (x<0) {


nxt.motorForward(2, vity+vitx);

}

}

else {//si onoff=0, les moteurs sont mis à zéro: aucun déplacement



}

}

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;

}

}

Documents

Marc-Olivier TURENNE-Terminale S4 Projet ISN 2013isn.codelab.info/site/assets/files/1301/dossier_isn_marco.pdf · Ces capteurs peuvent par exemple servir à faire interagir le robot