Learning Lab Environnements Connectés - Contributions de l’utilisateur [fr]

Robots suiveurs 3 - Code Tutoriel Communication

2020-05-13T09:47:05Z

De-almeida-ribeiro.thiago : /* Introduction */

== Introduction ==

Pour ce tutoriel, on partira d’un monde de base du logiciel Webots, qui s'appelle “emitter_receiver”. Il contient deux robots qui se déplacent de façon à éviter les obstacles et qui communiquent entre eux, tout en affichant un message sur la console. Cela se produit quand le robot récepteur se trouve à portée de l'émetteur (portée représentée par une sphère blanche autour du robot émetteur). Les deux robots utilisent le contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], mais ont des comportements différents en fonction de leur noms.

[[Fichier:emitter_receiver.gif|400px|thumb|left|fonctionnement des robots (cliquez pour jouer le GIF)]]

[[Fichier:console_emitter_receiver.jpg|400px|thumb|right|Messages sur le console]]

 



== Le contrôleur et la communication ==

Dans cette section, on expliquera la partie du code relative à la communication entre les robots. Le code étant en C, on presentera aussi les fonctions équivalents en C++, qui sont utiles pour comprendre le projet.

Au tout début, il faut ajouter les bibliothèques pour l’émetteur et le récepteur.

<nowiki>
#include <webots/emitter.h>
#include <webots/receiver.h> </nowiki>

On doit créer un “deviceTag” pour la communication, ce qui n’est pas nécessaire en C++, et prendre la main de l’émetteur ou du récepteur, selon le cas. Ensuite, on choisit le canal de communication (si ce n’est pas la bonne) pour l'émetteur et on habilite le récepteur.

<nowiki>
WbDeviceTag communication; </nowiki>

* '''Émetteur :'''
<nowiki>
communication = wb_robot_get_device("emitter");
wb_emitter_set_channel(communication, COMMUNICATION_CHANNEL); </nowiki>

* '''Récepteur :'''

<nowiki>
communication = wb_robot_get_device("receiver");
wb_receiver_enable(communication, TIME_STEP); </nowiki>

En C++, cela devient :

* '''Émetteur :'''

<nowiki>
Emitter *emitter = robot->getEmitter("emitter");
emitter->setChannel(COMMUNICATION_CHANNEL); </nowiki>

* '''Récepteur :'''
<nowiki>
Receiver *receiver = robot->getReceiver("receiver");
receiver->setChannel(COMMUNICATION_CHANNEL); </nowiki>

On remarque que, dans ce cas, l’habilitation du récepteur est faite en choisissant le canal de communication.

Enfin, l'émetteur doit envoyer le message et le récepteur doit le recevoir et l’afficher sur la console. Pour pouvoir le faire, on doit vérifier si le buffer du récepteur est vide et, si cela n’est pas le cas, mettre le message dans un autre buffer, qui sera affiché une seule fois (utilisation du if avec la variable “message_printed”). Il est important de remarquer qu’il faut chercher le nouveau paquet de l'émetteur après avoir affiché le message, sinon on vide la queue de façon permanente.

* '''Émetteur :'''
<nowiki>
const char *message = "Hello!";
wb_emitter_send(communication, message, strlen(message) + 1); </nowiki>

* '''Récepteur :'''
<nowiki>
/* is there at least one packet in the receiver's queue ? */
if (wb_receiver_get_queue_length(communication) > 0) {

/* read current packet's data */
const char *buffer = wb_receiver_get_data(communication);

if (message_printed != 1) {
/* print null-terminated message */
printf("Communicating: received \"%s\"\n", buffer);
message_printed = 1;
}

/* fetch next packet */
wb_receiver_next_packet(communication);

} else {

if (message_printed != 2) {
printf("Communication broken!\n");
message_printed = 2;
}
} </nowiki>

En C++ :

* '''Émetteur :'''
<nowiki>
const char *message = "Hello!";
emitter->send(message, strlen(message) + 1); </nowiki>

* '''Récepteur :'''
<nowiki>
if (receiver->getQueueLength() > 0)
{

/* read current packet's data */
const char *buffer = (const char*)receiver->getData();
const double *position= receiver->getEmitterDirection();

/* print null-terminated message */
if (message_printed != 1) {
printf("Communicating: received \"%s\"\n", buffer);
message_printed = 1;
}

/* fetch next packet */
receiver->nextPacket();

} else {

if (message_printed != 2)
{
printf("Communication broken!\n");
message_printed = 2;
}
} </nowiki>

Robots suiveurs 3 - Code Tutoriel Communication

2020-05-13T09:46:34Z

De-almeida-ribeiro.thiago : /* Introduction */

== Introduction ==

Pour ce tutoriel, on partira d’un monde de base du logiciel Webots, qui s'appelle “emitter_receiver”. Il contient deux robots qui se déplacent de façon à éviter les obstacles et qui communiquent entre eux, tout en affichant un message sur la console. Cela se produit quand le robot récepteur se trouve à portée de l'émetteur, portée représentée par une sphère blanche autour du robot émetteur. Les deux robots utilisent le contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], mais ont des comportements différents en fonction de leur noms.

[[Fichier:emitter_receiver.gif|400px|thumb|left|fonctionnement des robots (cliquez pour jouer le GIF)]]

[[Fichier:console_emitter_receiver.jpg|400px|thumb|right|Messages sur le console]]

 



== Le contrôleur et la communication ==

Dans cette section, on expliquera la partie du code relative à la communication entre les robots. Le code étant en C, on presentera aussi les fonctions équivalents en C++, qui sont utiles pour comprendre le projet.

Au tout début, il faut ajouter les bibliothèques pour l’émetteur et le récepteur.

<nowiki>
#include <webots/emitter.h>
#include <webots/receiver.h> </nowiki>

On doit créer un “deviceTag” pour la communication, ce qui n’est pas nécessaire en C++, et prendre la main de l’émetteur ou du récepteur, selon le cas. Ensuite, on choisit le canal de communication (si ce n’est pas la bonne) pour l'émetteur et on habilite le récepteur.

<nowiki>
WbDeviceTag communication; </nowiki>

* '''Émetteur :'''
<nowiki>
communication = wb_robot_get_device("emitter");
wb_emitter_set_channel(communication, COMMUNICATION_CHANNEL); </nowiki>

* '''Récepteur :'''

<nowiki>
communication = wb_robot_get_device("receiver");
wb_receiver_enable(communication, TIME_STEP); </nowiki>

En C++, cela devient :

* '''Émetteur :'''

<nowiki>
Emitter *emitter = robot->getEmitter("emitter");
emitter->setChannel(COMMUNICATION_CHANNEL); </nowiki>

* '''Récepteur :'''
<nowiki>
Receiver *receiver = robot->getReceiver("receiver");
receiver->setChannel(COMMUNICATION_CHANNEL); </nowiki>

On remarque que, dans ce cas, l’habilitation du récepteur est faite en choisissant le canal de communication.

Enfin, l'émetteur doit envoyer le message et le récepteur doit le recevoir et l’afficher sur la console. Pour pouvoir le faire, on doit vérifier si le buffer du récepteur est vide et, si cela n’est pas le cas, mettre le message dans un autre buffer, qui sera affiché une seule fois (utilisation du if avec la variable “message_printed”). Il est important de remarquer qu’il faut chercher le nouveau paquet de l'émetteur après avoir affiché le message, sinon on vide la queue de façon permanente.

* '''Émetteur :'''
<nowiki>
const char *message = "Hello!";
wb_emitter_send(communication, message, strlen(message) + 1); </nowiki>

* '''Récepteur :'''
<nowiki>
/* is there at least one packet in the receiver's queue ? */
if (wb_receiver_get_queue_length(communication) > 0) {

/* read current packet's data */
const char *buffer = wb_receiver_get_data(communication);

if (message_printed != 1) {
/* print null-terminated message */
printf("Communicating: received \"%s\"\n", buffer);
message_printed = 1;
}

/* fetch next packet */
wb_receiver_next_packet(communication);

} else {

if (message_printed != 2) {
printf("Communication broken!\n");
message_printed = 2;
}
} </nowiki>

En C++ :

* '''Émetteur :'''
<nowiki>
const char *message = "Hello!";
emitter->send(message, strlen(message) + 1); </nowiki>

* '''Récepteur :'''
<nowiki>
if (receiver->getQueueLength() > 0)
{

/* read current packet's data */
const char *buffer = (const char*)receiver->getData();
const double *position= receiver->getEmitterDirection();

/* print null-terminated message */
if (message_printed != 1) {
printf("Communicating: received \"%s\"\n", buffer);
message_printed = 1;
}

/* fetch next packet */
receiver->nextPacket();

} else {

if (message_printed != 2)
{
printf("Communication broken!\n");
message_printed = 2;
}
} </nowiki>

Robots suiveurs 3 - Tableau de Bord

2020-05-13T09:44:23Z

De-almeida-ribeiro.thiago : /* Résultats finaux (05/05/2020) */

== Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour se faire suivre des robots en les faisant communiquer. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu ajouter les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pour celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, existant en tant qu'exemple dans le logiciel. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu ajouter les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bloc de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il active et configure l'émetteur du robot et transmet un message quelconque. Le contrôleur “receiver” active et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bloc de code suivant est responsable de ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’alors, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et de 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir le canal de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à se suivre mais cela se fait d’une façon plus lente et irrégulière. Cela pourrait être un problème puisque le robot maître pourrait trop s’écarter des esclaves et la communication entre eux serait alors coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais pourrait permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serial" ou "infra-red. Les signaux de type "radio" (par défaut) et "serial" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serial".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* Le premier robot se dirige avec les flèches, donc le [[Robots suiveurs 3 - Code Contrôle au Clavier |Code de contrôle au clavier]] est implanté.
* Robots suiveurs : chaque robot est associé à un controller dont le code est semblable au [[Robots suiveurs 3 - Code suivi d'un objet (robot) rouge |Code de suivi d'un objet (robot) rouge]], avec des changements pour la couleur.

== Fusion des méthodes ==

=== Fusion de Code ===
Une fois l’ensemble des codes fonctionnel, nous nous sommes lancés dans la mise en place d’une simulation comprenant l’ensemble de ces derniers.

Pour cela, nous avons choisi d'exporter les robots édités des différentes simulations dans une nouvelle scène. Dans le monde où le robot a été créé, il faut faire un clic droit sur le nom du robot dans la scene tree et après cliquer sur “Export”. Cela crée un fichier .wbo à sauvegarder là où vous le voulez et, dans le nouveau monde, cliquer sur “Import...” dans la fenêtre d’ajout de nœuds pour aller chercher le fichier.

[[Fichier:import_robot.jpg|500px|thumb|right|Importer un robot]] [[Fichier:export_robot.jpg|300px|thumb|left|Exporter un robot]]

 
Nous avons ensuite implémenté les codes nécessaires à chacun des robots et harmonisé les fonctionnements. Plus précisément, il a fallu ajouter la partie de gestion de l'émission de message faite dans le controller [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]] au controller utilisé par le robot maitre pour suivre le robot rouge (par détection de couleurs).

Une fois cette fusion faite, il manquait encore la fonction d’évitement des obstacles que nous avons mises en place à ce moment.

=== Evitement ===

Les robots, en fonction de leur position dans la file, ayant des fonctions différentes (suivi d’un robot par analyse colorimétrique ou suivi d’un robot par communication sans fil), il est nécessaire d’adapter le code d’évitement pour ne pas interférer avec les fonctions de suivi. Ainsi la fonction d'évitement se base toujours sur le même principe, mais l’implémentation se fait de façon différente pour chaque controller, avec des contraintes plus ou moins complexes.

Tous les robots évitent les obstacles grâce aux capteurs de distance, mais ils doivent différencier les robots qu’ils suivent des obstacles quelconques. Pour cela, le robot maître utilise la quantité de pixels rouges dans l’image de la câmera au moment de la détection de l’obstacle, pendant que le maître-esclave et l'esclave utilisent la force du signal de communication. Dans ce dernier cas, la vérification est faite même avant la détection des obstacles, de façon à arrêter les robots.

De plus, on a aussi implémenté une fonction pour réduire la vitesse des robots au fur et à mesure qu’ils s’approchent de leur but (robots à suivre), en utilisant un produit en croix.

À la fin de nos heures de travail, nous avions alors créé et mis en place les controllers suivants: [[Robots suiveurs 3 - Code Contrôle au Clavier | RobotHumain]], [[Robots suiveurs 3 - Code RobotCamera | RobotCamera]], [[Robots suiveurs 3 - Code emitter-receiver | RobotEmitterReceiver]] et [[Robots suiveurs 3 - Code RobotReceiver| RobotReceiver]].

[[Fichier:MondeDeTest.gif|500px|thumb|center| Évitement d'obstacle]]

Robots suiveurs 3 - Tableau de Bord

2020-05-13T09:39:33Z

De-almeida-ribeiro.thiago : /* Résultats finaux (05/05/2020) */

== Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour se faire suivre des robots en les faisant communiquer. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu ajouter les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pour celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, existant en tant qu'exemple dans le logiciel. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu ajouter les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bloc de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il habilite et configure l'émetteur du robot et transmet un message quelconque. Le contrôleur “receiver” habilite et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bloc de code suivant est responsable de ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’à ce moment, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et de 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir le canal de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à suivre mais cela se fait d’une façon plus lente et irrégulière. Cela peut être un problème puisque le robot maître peut s’écarter des esclaves et la communication entre eux peut être coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais peut permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serial" ou "infra-red. Les signaux de type "radio" (par défaut) et "serial" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serial".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* Le premier robot se dirige avec les flèches, donc le [[Robots suiveurs 3 - Code Contrôle au Clavier |Code de contrôle au clavier]] est implanté.
* Robots suiveurs : chaque robot est associé à un controller dont le code est semblable au [[Robots suiveurs 3 - Code suivi d'un objet (robot) rouge |Code de suivi d'un objet (robot) rouge]], avec des changements pour la couleur.

== Fusion des méthodes ==

=== Fusion de Code ===
Une fois l’ensemble des codes fonctionnel, nous nous sommes lancés dans la mise en place d’une simulation comprenant l’ensemble de ces derniers.

Pour cela, nous avons choisi d'exporter les robots édités des différentes simulations dans une nouvelle scène. Dans le monde où le robot a été créé, il faut faire un clic droit sur le nom du robot dans la scene tree et après cliquer sur “Export”. Cela crée un fichier .wbo à sauvegarder là où vous le voulez et, dans le nouveau monde, cliquer sur “Import...” dans la fenêtre d’ajout de nœuds pour aller chercher le fichier.

[[Fichier:import_robot.jpg|500px|thumb|right|Importer un robot]] [[Fichier:export_robot.jpg|300px|thumb|left|Exporter un robot]]

 
Nous avons ensuite implémenté les codes nécessaires à chacun des robots et harmonisé les fonctionnements. Plus précisément, il a fallu ajouter la partie de gestion de l'émission de message faite dans le controller [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]] au controller utilisé par le robot maitre pour suivre le robot rouge (par détection de couleurs).

Une fois cette fusion faite, il manquait encore la fonction d’évitement des obstacles que nous avons mises en place à ce moment.

=== Evitement ===

Les robots, en fonction de leur position dans la file, ayant des fonctions différentes (suivi d’un robot par analyse colorimétrique ou suivi d’un robot par communication sans fil), il est nécessaire d’adapter le code d’évitement pour ne pas interférer avec les fonctions de suivi. Ainsi la fonction d'évitement se base toujours sur le même principe, mais l’implémentation se fait de façon différente pour chaque controller, avec des contraintes plus ou moins complexes.

Tous les robots évitent les obstacles grâce aux capteurs de distance, mais ils doivent différencier les robots qu’ils suivent des obstacles quelconques. Pour cela, le robot maître utilise la quantité de pixels rouges dans l’image de la câmera au moment de la détection de l’obstacle, pendant que le maître-esclave et l'esclave utilisent la force du signal de communication. Dans ce dernier cas, la vérification est faite même avant la détection des obstacles, de façon à arrêter les robots.

De plus, on a aussi implémenté une fonction pour réduire la vitesse des robots au fur et à mesure qu’ils s’approchent de leur but (robots à suivre), en utilisant un produit en croix.

À la fin de nos heures de travail, nous avions alors créé et mis en place les controllers suivants: [[Robots suiveurs 3 - Code Contrôle au Clavier | RobotHumain]], [[Robots suiveurs 3 - Code RobotCamera | RobotCamera]], [[Robots suiveurs 3 - Code emitter-receiver | RobotEmitterReceiver]] et [[Robots suiveurs 3 - Code RobotReceiver| RobotReceiver]].

[[Fichier:MondeDeTest.gif|500px|thumb|center| Évitement d'obstacle]]

Robots suiveurs 3 - Capteurs

2020-05-13T09:37:51Z

De-almeida-ribeiro.thiago : /* Description des champs */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
les champs du capteur de mouvement sont composés d'une table servant a définir sa fonction de transfert et de caractéristiques du laser (son nombre de rayons, son ouverture, etc).
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== LookUpTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous pouvons modifier la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Caméra =

Pour modéliser une caméra, nous utilisons une caméra embarquée classique, modélisée grâce au node [https://cyberbotics.com/doc/reference/camera Caméra], et en donnant une couleur rouge à l'objet à suivre, comme ci celui-ci était une source de chaleur. L'image résultante peut être affichée sur la fenêtre 3D et nous permet de visualiser l'image en RGB dans notre cas.

== Champ du node Camera==

{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| fieldOfView
| SFFloat
| 0.7854
| [0, pi]
|-
| width
| SFInt32
| 64
| [0, inf)
|-
| height
| SFInt32
| 64
| [0, inf)
|-
| spherical
| SFBool
| FALSE
| {TRUE, FALSE}
|-
| near
| SFFloat
| 0.01
| [0, inf)
|-
| far
| SFFloat
| 0.0
| [0, inf)
|-
| antiAliasing
| SFBool
| FALSE
| {TRUE, FALSE}
|-
| ambientOcclusionRadius
| SFFloat
| 0
| [0, inf)
|-
| bloomThreshold
| SFFloat
| -1.0
| [-1, inf)
|-
| motionBlur
| SFFloat
| 0.0
| [0, inf)
|-
| noise
| SFFloat
| 0.0
| [0, 1]
|-
| noiseMaskUrl
| SFString
| ""
| any string
|-
| lens
| SFNode
| NULL
| {Lens, PROTO}
|-
| focus
| SFNode
| NULL
| {Focus, PROTO}
|-
| zoom
| SFNode
| NULL
| {Zoom, PROTO}
|-
| recognition
| SFNode
| NULL
| {Recognition, PROTO}
|-
| lensFlare
| SFNode
| NULL
| {LensFlare, PROTO}
|}

== Fonctions utiles (en C++) ==

{| class="wikitable left"
|-
|'''Fonction'''
|'''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Activation de la caméra
|-
| virtual void disable();
| Désactivation de la caméra
|-
| int getWidth() const;
| Récupération de la largeur de l'image en pixels
|-
| int getHeight() const;
| Récupération de la hauteur de l'image en pixels
|-
| const unsigned char *getImage() const;
| Lecture de la dernière image saisie par l'appareil photo. L'image est codée comme une séquence de trois octets représentant les niveaux rouge, vert et bleu d'un pixel. Les pixels sont stockés sur des lignes horizontales allant du côté supérieur gauche de l'image jusqu'au coin inférieur droit.
|-
| static unsigned char imageGetRed(const unsigned char *image, int width, int x, int y);
| Accès au niveau de rouge d'un pixel RGB à partir de ses coordonnées
|-
| static unsigned char imageGetGreen(const unsigned char *image, int width, int x, int y);
| Accès au niveau de vert d'un pixel RGB à partir de ses coordonnées
|-
| static unsigned char imageGetBlue(const unsigned char *image, int width, int x, int y);
| Accès au niveau de bleu d'un pixel RGB à partir de ses coordonnées
|-
|}

== Utilisation de l'image ==

[[Fichier:Caméra.png ‎|155px|thumb|right|Image obtenue]]
L'image de la caméra est affichée en temps réel, en haut de la fenêtre 3D par défaut.
La résolution de la caméra peut être modifiée dans les caractéristiques de celle-ci.

Afin d'exploiter l'image issue de la caméra, il suffit d'analyser tout ou partie des pixels qui la composent. Une comparaison entre les nombres de pixels rouges, verts et bleus permet par exemple de détecter la présence d'un objet de couleur.

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émetteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).

== Champs des nodes Emitter et Receiver ==

=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "serial" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serial".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infra-red" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "serial", ce champ est ignoré.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du buffer de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infra-red" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' taille (en octets) du buffer de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire buffer, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength (ou getSignalStrength() en C++). Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction (ou getEmitterDirection() en C++). Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie le nombre d'octets de données présents dans le paquet de tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Tableau de Bord

2020-05-13T09:37:14Z

De-almeida-ribeiro.thiago : /* Communication entre robots */

== Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour se faire suivre des robots en les faisant communiquer. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu ajouter les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pour celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, existant en tant qu'exemple dans le logiciel. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu ajouter les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bout de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il habilite et configure l'émetteur du robot et transmet un message quelconque. Le contrôleur “receiver” habilite et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bout de code suivant est responsable de ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’à ce moment, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et de 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir le canal de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à suivre mais cela se fait d’une façon plus lente et irrégulière. Cela peut être un problème puisque le robot maître peut s’écarter des esclaves et la communication entre eux peut être coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais peut permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serial" ou "infra-red. Les signaux de type "radio" (par défaut) et "serial" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serial".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* Le premier robot se dirige avec les flèches, donc le [[Robots suiveurs 3 - Code Contrôle au Clavier |Code de contrôle au clavier]] est implanté.
* Robots suiveurs : chaque robot est associé à un controller dont le code est semblable au [[Robots suiveurs 3 - Code suivi d'un objet (robot) rouge |Code de suivi d'un objet (robot) rouge]], avec des changements pour la couleur.

== Fusion des méthodes ==

=== Fusion de Code ===
Une fois l’ensemble des codes fonctionnel, nous nous sommes lancés dans la mise en place d’une simulation comprenant l’ensemble de ces derniers.

Pour cela, nous avons choisi d'exporter les robots édités des différentes simulations dans une nouvelle scène. Dans le monde où le robot a été créé, il faut faire un clic droit sur le nom du robot dans la scene tree et après cliquer sur “Export”. Cela crée un fichier .wbo à sauvegarder là où vous le voulez et, dans le nouveau monde, cliquer sur “Import...” dans la fenêtre d’ajout de nœuds pour aller chercher le fichier.

[[Fichier:import_robot.jpg|500px|thumb|right|Importer un robot]] [[Fichier:export_robot.jpg|300px|thumb|left|Exporter un robot]]

 
Nous avons ensuite implémenté les codes nécessaires à chacun des robots et harmonisé les fonctionnements. Plus précisément, il a fallu ajouter la partie de gestion de l'émission de message faite dans le controller [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]] au controller utilisé par le robot maitre pour suivre le robot rouge (par détection de couleurs).

Une fois cette fusion faite, il manquait encore la fonction d’évitement des obstacles que nous avons mises en place à ce moment.

=== Evitement ===

Les robots, en fonction de leur position dans la file, ayant des fonctions différentes (suivi d’un robot par analyse colorimétrique ou suivi d’un robot par communication sans fil), il est nécessaire d’adapter le code d’évitement pour ne pas interférer avec les fonctions de suivi. Ainsi la fonction d'évitement se base toujours sur le même principe, mais l’implémentation se fait de façon différente pour chaque controller, avec des contraintes plus ou moins complexes.

Tous les robots évitent les obstacles grâce aux capteurs de distance, mais ils doivent différencier les robots qu’ils suivent des obstacles quelconques. Pour cela, le robot maître utilise la quantité de pixels rouges dans l’image de la câmera au moment de la détection de l’obstacle, pendant que le maître-esclave et l'esclave utilisent la force du signal de communication. Dans ce dernier cas, la vérification est faite même avant la détection des obstacles, de façon à arrêter les robots.

De plus, on a aussi implémenté une fonction pour réduire la vitesse des robots au fur et à mesure qu’ils s’approchent de leur but (robots à suivre), en utilisant un produit en croix.

À la fin de nos heures de travail, nous avions alors créé et mis en place les controllers suivants: [[Robots suiveurs 3 - Code Contrôle au Clavier | RobotHumain]], [[Robots suiveurs 3 - Code RobotCamera | RobotCamera]], [[Robots suiveurs 3 - Code emitter-receiver | RobotEmitterReceiver]] et [[Robots suiveurs 3 - Code RobotReceiver| RobotReceiver]].

[[Fichier:MondeDeTest.gif|500px|thumb|center| Évitement d'obstacle]]

Robots suiveurs 3 - Code RobotCamera

2020-05-12T14:40:43Z

De-almeida-ribeiro.thiago :

<nowiki>
#include <webots/Robot.hpp>
#include <webots/Emitter.hpp>
#include <webots/DistanceSensor.hpp>
#include <webots/motor.hpp>
#include <webots/Camera.hpp>
#include <iostream>
#include <stdio.h>
#include <string.h>

#define COMMUNICATION_CHANNEL 1
#define MAX_SPEED 6.28

// toutes les classes webots sont définies dans le namespace "webots"
using namespace webots;
using namespace std;

int main(int argc, char **argv) {

// créé l'instance Robot.
Robot *robot = new Robot();

// récupère le pas de temps du monde actuel
int timeStep = (int)robot->getBasicTimeStep();

// crée les instances des périphériques et les associe
Emitter *emitter = robot->getEmitter("emitter");
Motor *left_motor = robot->getMotor("left wheel motor");
Motor *right_motor = robot->getMotor("right wheel motor");
Camera *camera = robot->getCamera("camera");
DistanceSensor *ps[8];
char psNames[8][4] = {
"ps0", "ps1", "ps2", "ps3",
"ps4", "ps5", "ps6", "ps7"
};

for (int i = 0; i < 8; i++) {
ps[i] = robot->getDistanceSensor(psNames[i]);
ps[i]->enable(timeStep);
}

// active la caméra
camera->enable(timeStep);

// initialisation du moteur
left_motor->setPosition(INFINITY);
right_motor->setPosition(INFINITY);
left_motor->setVelocity(0.0);
right_motor->setVelocity(0.0);

// si mauvais canal
const int channel = emitter->getChannel();
if (channel != COMMUNICATION_CHANNEL)
{
emitter->setChannel(COMMUNICATION_CHANNEL);
}

emitter->setRange(0.4); // définit la plage de l'émetteur

int exPos = 0; // utilisé pour définir dans quel sens tourner quand on voit plus le robot rouge

double vitesse = 0; // utilisé pour faire la réduction de vitesse

// utilisés pour faire l'évitement d'obstacles
int evitementG = 0;
int incrementEvitemment = 0;

// boucle principale

// Le but est de séparer l'image en 3 partie : une partie centrale, gauche et droite
// et d'analyser le nombre de pixel rouge dans chacune de ces parties
// Si le nombre de pixel rouge est plus important au centre, on avance, si il l'est plus à
// gauche, on tourne à gauche, etc...

while (robot->step(timeStep) != -1) {

// envoie un message terminé par null
const char *message = "Hello!";
emitter->send(message, strlen(message) + 1);

// crée des variables pour compter la somme des composantes rouge, verte et bleue des pixels pour chacune des 3 parties de l'image étudiée
int red = 0;
int blue = 0;
int green = 0;

int redg = 0;
int blueg = 0;
int greeng = 0;

int redd = 0;
int blued = 0;
int greend = 0;

int redPleinCadran = 0;
int reddPleinCadran = 0;
int redgPleinCadran = 0;

int bluePleinCadran = 0;
int bluedPleinCadran = 0;
int bluegPleinCadran = 0;

int greenPleinCadran = 0;
int greendPleinCadran = 0;
int greengPleinCadran = 0;

// lit les sorties des capteurs de distance
double psValues[8];
for (int i =0;i<8;i++){
psValues[i] = ps[i]->getValue();
}

// détecte les obstacles
bool right_obstacle =
psValues[0] > 100.0 ||
psValues[1] > 100.0 ;

bool left_obstacle =
psValues[5] > 100.0 ||
psValues[6] > 100.0 ;

bool front_obstacle3 = right_obstacle || left_obstacle;

double valMax = std::max(psValues[7], psValues[0]);

// Booléen servant à éviter une collision avec un objet en face: Seuil 1
bool front_obstacle1 = psValues[7] > 200 || psValues[0] > 200;
// Booléen servant à éviter une collision avec un objet en face : Seuil 2
bool front_obstacle2 = psValues[7] > 100 || psValues[0] > 100;

// Vitesse roue gauche et droite
double leftSpeed = 0.5*MAX_SPEED;
double rightSpeed = 0.5*MAX_SPEED;

int width = camera -> getWidth();
int height = camera -> getHeight();
// Récupération de l'image de la caméra
const unsigned char *image = camera -> getImage();

// Première boucle servant à diviser l'image en 3 parties (partie centrale)
for (int i = 2* width / 5; i < 3 * width / 5; i++) {
for (int j = 2*height / 5; j < 3* height / 5; j++) {
red += camera -> imageGetRed(image, width, i, j);
blue += camera -> imageGetBlue(image, width, i, j);
green += camera -> imageGetGreen(image, width, i, j);
}
for (int j = 0; j < height; j++) {
redPleinCadran += camera -> imageGetRed(image, width, i, j);
greenPleinCadran += camera -> imageGetGreen(image, width, i, j);
bluePleinCadran += camera -> imageGetBlue(image, width, i, j);
}
}
// Deuxième boucle (partie droite)
for (int i = 3* width / 5; i < width; i++) {
for (int j = 2*height / 5; j < 3*height/5 ; j++) {
redd += camera -> imageGetRed(image, width, i, j);
blued += camera -> imageGetBlue(image, width, i, j);
greend += camera -> imageGetGreen(image, width, i, j);
}
for (int j = 0; j < height; j++) {
reddPleinCadran += camera -> imageGetRed(image, width, i, j);
greendPleinCadran += camera -> imageGetGreen(image, width, i, j);
bluedPleinCadran += camera -> imageGetBlue(image, width, i, j);
}
}
// Troisième boucle (partie gauche)
for (int i = 0 ; i < 2*width/5; i++) {
for (int j = 0; j < 2*height/5 ; j++) {
redg += camera -> imageGetRed(image, width, i, j);
blueg += camera -> imageGetBlue(image, width, i, j);
greeng += camera -> imageGetGreen(image, width, i, j);
}
for (int j = 0; j < height; j++) {
redgPleinCadran += camera -> imageGetRed(image, width, i, j);
greengPleinCadran += camera -> imageGetGreen(image, width, i, j);
bluegPleinCadran += camera -> imageGetBlue(image, width, i, j);
}
}

if (evitementG == 0){

// Si on a plus de pixel rouges au milieu, alors...
if ((red > 1.5*green) && (red > 1.5*blue) ){
// Si on a un obstacle devant alors on se stoppe
if (front_obstacle3){
if (front_obstacle1){
if (right_obstacle && reddPleinCadran> 2*bluedPleinCadran && reddPleinCadran> 2*greendPleinCadran){
left_motor->setVelocity(0.0);
right_motor->setVelocity(0.0);
}
else if (left_obstacle && redgPleinCadran> 2*bluegPleinCadran && redgPleinCadran> 2*greengPleinCadran){
left_motor->setVelocity(0.0);
right_motor->setVelocity(0.0);
}
else {
left_motor->setVelocity(0.0);
right_motor->setVelocity(0.0);
evitementG=1;
}
}
// Si on se rapproche d'un obstacle, on ralentit
else if (front_obstacle2){
double produitEnCroix = ((200-valMax)/(double)100);
vitesse = produitEnCroix * 0.5 * MAX_SPEED;
left_motor->setVelocity(vitesse);
right_motor->setVelocity(vitesse);
}
}
// Sinon on avance
else{
left_motor->setVelocity(leftSpeed);
right_motor->setVelocity(rightSpeed);
}

}
// Si il n'y a rien au milieu
else{

// Si on a plus de pixel rouge à droite alors on tourne à droite
if((redd > 1.5*greend) && (redd > 1.5*blued)){

left_motor->setVelocity(leftSpeed);
right_motor->setVelocity(-rightSpeed);
exPos = 0;

}
// Sinon si on a plus de pixel rouge à gauche alors on tourne à gauche
else{
if((redg > 1.5*greeng) && (redg > 1.5*blueg)){
left_motor->setVelocity(-leftSpeed);
right_motor->setVelocity(rightSpeed);
exPos = 1;

}
// Sinon on tourne sur nous même pour essayer de trouver un objet rouge
else{
if (exPos==1) {
left_motor->setVelocity(-leftSpeed);
right_motor->setVelocity(rightSpeed);

}
else {
left_motor->setVelocity(leftSpeed);
right_motor->setVelocity(-rightSpeed);

}
}
}
}
}
else{

//évitement
if (left_obstacle) {
// tourner à gauche si obstacle à droite
left_motor -> setVelocity(leftSpeed);
right_motor -> setVelocity(-leftSpeed);
exPos = 1;
}
else if (right_obstacle) {
// tourner à droite si obstacle à gauche
left_motor -> setVelocity(-rightSpeed);
right_motor -> setVelocity(rightSpeed);
exPos = 0;
}
// Lorsque l'obstacle n'entrave plus la progression, on avance
else if (incrementEvitemment <30){
left_motor->setVelocity(0.5 * MAX_SPEED);
right_motor->setVelocity(0.5 * MAX_SPEED);
incrementEvitemment++;
}
else{
//Réinitialisation des flags et incréments
incrementEvitemment=0;
evitementG=0;
}

}

};

// Destruction des objets et fin de programme.
delete robot;
return 0;
}

</nowiki>

Robots suiveurs 3 - Codes

2020-05-12T14:40:18Z

De-almeida-ribeiro.thiago : /* Codes finaux */

=== Code Contrôle avec le Clavier ===

*[[Robots suiveurs 3 - Code Contrôle au Clavier |Code Contrôle au Clavier]]

=== Code de robot suiveur via l'utilisation de capteurs de distance ===

*[[Robots suiveurs 3 - Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs de distance]]

=== Code de robot suiveur via communication ===

* [[Robots suiveurs 3 - Code Communication Initial (C) |Code Communication Initial (C)]]
* [[Robots suiveurs 3 - Code Communication Initial (C++) |Code Communication Initial (C++) ]]

* [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |Code Communication Intermédiaire (maître) ]]
* [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |Code Communication Intermédiaire (esclave) ]]

*[[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |Code Communication Final (controlêur "emitter") ]]
*[[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |Code Communication Final (controlêur "emitter-receiver") ]]
*[[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |Code Communication Final (controlêur "receiver") ]]

=== Codes finaux ===

*[[Robots suiveurs 3 - Code Contrôle au Clavier | RobotHumain]]
*[[Robots suiveurs 3 - Code RobotCamera | RobotCamera]]
*[[Robots suiveurs 3 - Code emitter-receiver | RobotEmitterReceiver]]
*[[Robots suiveurs 3 - Code RobotReceiver| RobotReceiver]]

Robots suiveurs 3 - Tableau de Bord

2020-05-12T14:39:59Z

De-almeida-ribeiro.thiago : /* Evitement */

== Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour se faire suivre des robots en les faisant communiquer. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu ajouter les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pour celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, existant en tant qu'exemple dans le logiciel. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu ajouter les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bout de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il habilite et configure l'émetteur du robot et transmet un message quelconque. Le contrôleur “receiver” habilite et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bout de code suivant est responsable de ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’à ce moment, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et de 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir le canal de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à suivre mais cela se fait d’une façon plus lente et irrégulière. Cela peut être un problème puisque le robot maître peut s’écarter des esclaves et la communication entre eux peut être coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais peut permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serie" ou "infra-red. Les signaux de type "radio" (par défaut) et "serie" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* [[Robots suiveurs 3 - Code Détection couleur (Robot suivi) |Code robot suivi]]
* [[Robots suiveurs 3 - Code Détection couleur (Robot suiveur) |Code robot suiveur]]

== Fusion des méthodes ==

=== Fusion de Code ===
Une fois l’ensemble des codes fonctionnel, nous nous sommes lancés dans la mise en place d’une simulation comprenant l’ensemble de ces derniers.

Pour cela, nous avons choisi d'exporter les robots édités des différentes simulations dans une nouvelle scène. Dans le monde où le robot a été créé, il faut faire un clic droit sur le nom du robot dans la scene tree et après cliquer sur “Export”. Cela crée un fichier .wbo à sauvegarder là où vous le voulez et, dans le nouveau monde, cliquer sur “Import...” dans la fenêtre d’ajout de nœuds pour aller chercher le fichier.

[[Fichier:import_robot.jpg|500px|thumb|right|Importer un robot]] [[Fichier:export_robot.jpg|300px|thumb|left|Exporter un robot]]

 
Nous avons ensuite implémenté les codes nécessaires à chacun des robots et harmonisé les fonctionnements. Plus précisément, il a fallu ajouter la partie gestion de l'émetteur et émission de message du controller [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]] (partie communication) au controller utilisé pour suivre le robot rouge (partie détection de couleur).

Une fois cette fusion faite, il manquait encore la fonction d’évitement des obstacles que nous avons mises en place à ce moment.

=== Evitement ===

Les robots, en fonction de leur position dans la file, ayant des fonctions différentes (suivi d’un robot par analyse colorimétrique ou suivi d’un robot par communication sans fil), il est nécessaire d’adapter le code d’évitement pour ne pas interférer avec les fonctions de suivi. Ainsi la fonction d'évitement se base toujours sur le même principe, mais l’implémentation se fait de façon différente pour chaque controller, avec des contraintes plus ou moins complexes.

Tous les robots évitent les obstacles grâce aux capteurs de distance, mais ils doivent différencier les robots qu’ils suivent des obstacles quelconques. Pour cela, le robot maître utilise la quantité de pixels rouges dans l’image de la câmera au moment de la détection de l’obstacle, pendant que le maître-esclave et l'esclave utilisent la force du signal de communication. Dans ce dernier cas, la vérification est faite même avant la détection des obstacles, de façon à arrêter les robots.

De plus, on a aussi implémenté une fonction pour réduire la vitesse des robots au fur et à mesure qu’ils s’approchent de son but (robot à suivre), en utilisant un produit en croix.

À la fin, on avait les controllers : [[Robots suiveurs 3 - Code Contrôle au Clavier | RobotHumain]], [[Robots suiveurs 3 - Code RobotCamera | RobotCamera]], [[Robots suiveurs 3 - Code emitter-receiver | RobotEmitterReceiver]] et [[Robots suiveurs 3 - Code RobotReceiver| RobotReceiver]].

Robots suiveurs 3

2020-05-12T14:39:16Z

De-almeida-ribeiro.thiago : /* Résultat final */

Robot suiveur 2019/2020
 
Le but du projet est de faire suivre une personne par une file indienne de robots.
 

== Présentation du projet ==

Dans la continuité du travail ayant été réalisé les années précédentes sur les sujets Robots Suiveurs 1 et 2, notre objectif initial était, dans cette 3ème itération du projet, de poursuivre leur développement tout en améliorant les fonctionnalités disponibles. Cependant, suite à l'apparition du covid-19 et au confinement s'en suivant, le matériel devint indisponible. Pour répondre à cette contrainte, il a fallu se tourner vers les simulateurs pour robotique. 
Le projet initial avait pour but de programmer des robots capables de suivre une personne en détectant la source de chaleur qu'elle émet. Le cahier des charges de base était l'utilisation d'une caméra thermique et de faire communiquer le robot principale avec les autres robots pour les faire suivre le robot principal. 
Il a donc fallu dans un premier temps déterminer quel simulateur était le plus adapté à notre utilisation, puis adapter notre cahier des charges en fonction des technologies disponibles sur le simulateur.
L'objectif est donc de respecter le cahier des charges suivant :

* Le projet, en plus d'un robot principal suivant un être vivant, doit intégrer des robots suiveurs de robots, capables de communiquer entre eux et avec le robot principal.
* Certains capteurs de distances doivent être utilisés pour éviter une collision avec un obstacle quelconque.
* Le robot principal doit intégrer une caméra thermique pour suivre sa cible. Puisque ce composant n'existe pas sur notre simulateur, on le simulera avec une caméra classique, suivant un objet rouge représentant un corps chaud.

L'objectif n'étant pas de construire un robot de zéro, nous somme reparti d'une base existante intégrant les éléments essentiels au projet. En fin de projet, le but sera de coller le plus possible à une situation réelle, que nous aurions pu obtenir en utilisant le matériel fourni.

'''Participants :'''
[[Utilisateur:‎Poulain |Matthieu Poulain]], [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago de Almeida Ribeiro]], [[Utilisateur:‎SamuelT |Samuel Tauleigne]], [[Utilisateur:‎ Mickael | Mickaël Faure]], [[Utilisateur:‎Léane |Léane Geoffroy]], [[Utilisateur:‎Louis.sage |Louis Sage]], [[Utilisateur:‎Raphaele.milan |Raphaele Milan]], [[Utilisateur:‎Clément Luton |Clément Luton]]

==Objectifs de départ (en situation de confinement)==

*Choisir le bon simulateur

*Simuler une personne

*Choisir la bonne technologie de suivi pour le robot maître

*Choisir la bonne technologie de suivi pour les robots esclaves

==Éléments du projet==
*[[Robots suiveurs 3 - Choix du simulateur | Choix du simulateur]] 
*[[Robots suiveurs 3 - Tutoriels | Tutoriels simulateur]] 
*[[Robots suiveurs 3 - Tableau de Bord | Déroulement du projet - Tableau de Bord ]] 
*[[Robots suiveurs 3 - Codes | Accès aux Codes]] 
*[[Robots suiveurs 3 - Capteurs | Description des capteurs]] 

==Étapes suivies==

Pour une explication plus détaillée du déroulement du projet, référez-vous à la partie [[Robots suiveurs 3 - Tableau de Bord | Déroulement du projet - Tableau de Bord ]]. 

*Réalisation d’un robot pilotable manuellement avec les touches du clavier
*Réalisation d’un robot suiveur basé sur des capteurs de distance
*Réalisation d’un robot suiveur basé sur une caméra pour simuler une caméra thermique
*Réalisation d’un robot suiveur basé sur des protocoles de communication

==Résultat final==

Au final, nous avons quatre robots:
 
*Un robot simulant un humain. Il est contrôlable via le clavier et est entièrement rouge pour simuler la source de chaleur. Son controller s'appelle [[Robots suiveurs 3 - Code Contrôle au Clavier | RobotHumain]]

*Un robot qu’on appelle robot maître. Il se dirige grâce à une caméra qui détecte la couleur rouge et communique avec un des robots esclaves pour diriger ce dernier. Son controller s'appelle [[Robots suiveurs 3 - Code RobotCamera | RobotCamera]].

*Un robot mixte qui est à la fois maître et esclave. Il se dirige en communiquant avec le robot maître et communique en même temps avec le dernier robot. Son controller s'appelle [[Robots suiveurs 3 - Code emitter-receiver | RobotEmitterReceiver]].

*Un robot esclave. Il se dirige en communiquant avec le robot mixte. Son controller s'appelle [[Robots suiveurs 3 - Code RobotReceiver| RobotReceiver]].
 
Chacun des robots est équipé de capteurs de distance qui leurs permettent d’éviter des obstacles, de contrôler la vitesse à l’approche d’obstacle et d'empêcher les collisions entre robots.

Les robots se suivent à la fil indienne et leur ordre dépend de leur controller: robot humain, robot maître, robot mixte puis robot esclave.

GIF FONCTIONNEMENT + dépôt du monde complet

Robots suiveurs 3 - Tableau de Bord

2020-05-12T14:18:40Z

De-almeida-ribeiro.thiago : /* Evitement */

== Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour se faire suivre des robots en les faisant communiquer. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu ajouter les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pour celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, existant en tant qu'exemple dans le logiciel. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu ajouter les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bout de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il habilite et configure l'émetteur du robot et transmet un message quelconque. Le contrôleur “receiver” habilite et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bout de code suivant est responsable de ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’à ce moment, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et de 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir le canal de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à suivre mais cela se fait d’une façon plus lente et irrégulière. Cela peut être un problème puisque le robot maître peut s’écarter des esclaves et la communication entre eux peut être coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais peut permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serie" ou "infra-red. Les signaux de type "radio" (par défaut) et "serie" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* [[Robots suiveurs 3 - Code Détection couleur (Robot suivi) |Code robot suivi]]
* [[Robots suiveurs 3 - Code Détection couleur (Robot suiveur) |Code robot suiveur]]

== Fusion des méthodes ==

=== Fusion de Code ===
Une fois l’ensemble des codes fonctionnel, nous nous sommes lancés dans la mise en place d’une simulation comprenant l’ensemble de ces derniers.

Pour cela, nous avons choisi d'exporter les robots édités des différentes simulations dans une nouvelle scène. Dans le monde où le robot a été créé, il faut faire un clic droit sur le nom du robot dans la scene tree et après cliquer sur “Export”. Cela crée un fichier .wbo à sauvegarder là où vous le voulez et, dans le nouveau monde, cliquer sur “Import...” dans la fenêtre d’ajout de nœuds pour aller chercher le fichier.

[[Fichier:import_robot.jpg|500px|thumb|right|Importer un robot]] [[Fichier:export_robot.jpg|300px|thumb|left|Exporter un robot]]

 
Nous avons ensuite implémenté les codes nécessaires à chacun des robots et harmonisé les fonctionnements. Plus précisément, il a fallu ajouter la partie gestion de l'émetteur et émission de message du controller [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]] (partie communication) au controller utilisé pour suivre le robot rouge (partie détection de couleur).

Une fois cette fusion faite, il manquait encore la fonction d’évitement des obstacles que nous avons mises en place à ce moment.

=== Evitement ===

Les robots, en fonction de leur position dans la file, ayant des fonctions différentes (suivi d’un robot par analyse colorimétrique ou suivi d’un robot par communication sans fil), il est nécessaire d’adapter le code d’évitement pour ne pas interférer avec les fonctions de suivi. Ainsi la fonction d'évitement se base toujours sur le même principe, mais l’implémentation se fait de façon différente pour chaque controller, avec des contraintes plus ou moins complexes.

Tous les robots évitent les obstacles grâce aux capteurs de distance, mais ils doivent différencier les robots qu’ils suivent des obstacles quelconques. Pour cela, le robot maître utilise la quantité de pixels rouges dans l’image de la câmera au moment de la détection de l’obstacle, pendant que le maître-esclave et l'esclave utilisent la force du signal de communication. Dans ce dernier cas, la vérification est faite même avant la détection des obstacles, de façon à arrêter les robots.

De plus, on a aussi implémenté une fonction pour réduire la vitesse des robots au fur et à mesure qu’ils s’approchent de son but (robot à suivre), en utilisant un produit en croix.

À la fin, on avait les controllers : [[Robots suiveurs 3 - Code Contrôle au Clavier |Clavier_Control]], [[Robots suiveurs 3 - Contrôleur Maître | maître]], [[Robots suiveurs 3 - Contrôleur Maître-Esclave | maître-esclave]] et [[Robots suiveurs 3 - Contrôleur Esclave | esclave]].

Robots suiveurs 3

2020-05-12T14:16:10Z

De-almeida-ribeiro.thiago : /* Résultat final */

Robot suiveur 2019/2020
 
Le but du projet est de faire suivre une personne par une file indienne de robots.
 

== Présentation du projet ==

Dans la continuité du travail ayant été réalisé les années précédentes sur les sujets Robots Suiveurs 1 et 2, notre objectif initial était, dans cette 3ème itération du projet, de poursuivre leur développement tout en améliorant les fonctionnalités disponibles. Cependant, suite à l'apparition du covid-19 et au confinement s'en suivant, le matériel devint indisponible. Pour répondre à cette contrainte, il a fallu se tourner vers les simulateurs pour robotique. 
Le projet initial avait pour but de programmer des robots capables de suivre une personne en détectant la source de chaleur qu'elle émet. Le cahier des charges de base était l'utilisation d'une caméra thermique et de faire communiquer le robot principale avec les autres robots pour les faire suivre le robot principal. 
Il a donc fallu dans un premier temps déterminer quel simulateur était le plus adapté à notre utilisation, puis adapter notre cahier des charges en fonction des technologies disponibles sur le simulateur.
L'objectif est donc de respecter le cahier des charges suivant :

* Le projet, en plus d'un robot principal suivant un être vivant, doit intégrer des robots suiveurs de robots, capables de communiquer entre eux et avec le robot principal.
* Certains capteurs de distances doivent être utilisés pour éviter une collision avec un obstacle quelconque.
* Le robot principal doit intégrer une caméra thermique pour suivre sa cible. Puisque ce composant n'existe pas sur notre simulateur, on le simulera avec une caméra classique, suivant un objet rouge représentant un corps chaud.

L'objectif n'étant pas de construire un robot de zéro, nous somme reparti d'une base existante intégrant les éléments essentiels au projet. En fin de projet, le but sera de coller le plus possible à une situation réelle, que nous aurions pu obtenir en utilisant le matériel fourni.

'''Participants :'''
[[Utilisateur:‎Poulain |Matthieu Poulain]], [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago de Almeida Ribeiro]], [[Utilisateur:‎SamuelT |Samuel Tauleigne]], [[Utilisateur:‎ Mickael | Mickaël Faure]], [[Utilisateur:‎Léane |Léane Geoffroy]], [[Utilisateur:‎Louis.sage |Louis Sage]], [[Utilisateur:‎Raphaele.milan |Raphaele Milan]], [[Utilisateur:‎Clément Luton |Clément Luton]]

==Objectifs de départ (en situation de confinement)==

*Choisir le bon simulateur

*Simuler une personne

*Choisir la bonne technologie de suivi pour le robot maître

*Choisir la bonne technologie de suivi pour les robots esclaves

==Éléments du projet==
*[[Robots suiveurs 3 - Choix du simulateur | Choix du simulateur]] 
*[[Robots suiveurs 3 - Tutoriels | Tutoriels simulateur]] 
*[[Robots suiveurs 3 - Tableau de Bord | Déroulement du projet - Tableau de Bord ]] 
*[[Robots suiveurs 3 - Codes | Accès aux Codes]] 
*[[Robots suiveurs 3 - Capteurs | Description des capteurs]] 

==Étapes suivies==

Pour une explication plus détaillée du déroulement du projet, référez-vous à la partie [[Robots suiveurs 3 - Tableau de Bord | Déroulement du projet - Tableau de Bord ]]. 

*Réalisation d’un robot pilotable manuellement avec les touches du clavier
*Réalisation d’un robot suiveur basé sur des capteurs de distance
*Réalisation d’un robot suiveur basé sur une caméra pour simuler une caméra thermique
*Réalisation d’un robot suiveur basé sur des protocoles de communication

==Résultat final==

Au final, nous avons quatre robots:
 
*Un robot simulant un humain. Il est contrôlable via le clavier et est entièrement rouge pour simuler la source de chaleur. Son controller s'appelle [[Robots suiveurs 3 - Code Contrôle au Clavier |Clavier_Control]]

*Un robot qu’on appelle robot maître. Il se dirige grâce à une caméra qui détecte la couleur rouge et communique avec un des robots esclaves pour diriger ce dernier. Son controller s'appelle [[Robots suiveurs 3 - Contrôleur Maître | maître]].

*Un robot mixte qui est à la fois maître et esclave. Il se dirige en communiquant avec le robot maître et communique en même temps avec le dernier robot. Son controller s'appelle [[Robots suiveurs 3 - Contrôleur Maître-Esclave | maître-esclave]].

*Un robot esclave. Il se dirige en communiquant avec le robot mixte. Son controller s'appelle [[Robots suiveurs 3 - Contrôleur Esclave | esclave]].
 
Chacun des robots est équipé de capteurs de distance qui leurs permettent d’éviter des obstacles, de contrôler la vitesse à l’approche d’obstacle et d'empêcher les collisions entre robots.

Les robots se suivent à la fil indienne et leur ordre dépend de leur controller: robot humain, robot maître, robot mixte puis robot esclave.

GIF FONCTIONNEMENT + dépôt du monde complet

Robots suiveurs 3 - Tableau de Bord

2020-05-12T14:14:06Z

De-almeida-ribeiro.thiago : /* Evitement */

== Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour se faire suivre des robots en les faisant communiquer. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu ajouter les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pour celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, existant en tant qu'exemple dans le logiciel. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu ajouter les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bout de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il habilite et configure l'émetteur du robot et transmet un message quelconque. Le contrôleur “receiver” habilite et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bout de code suivant est responsable de ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’à ce moment, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et de 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir le canal de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à suivre mais cela se fait d’une façon plus lente et irrégulière. Cela peut être un problème puisque le robot maître peut s’écarter des esclaves et la communication entre eux peut être coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais peut permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serie" ou "infra-red. Les signaux de type "radio" (par défaut) et "serie" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* [[Robots suiveurs 3 - Code Détection couleur (Robot suivi) |Code robot suivi]]
* [[Robots suiveurs 3 - Code Détection couleur (Robot suiveur) |Code robot suiveur]]

== Fusion des méthodes ==

=== Fusion de Code ===
Une fois l’ensemble des codes fonctionnel, nous nous sommes lancés dans la mise en place d’une simulation comprenant l’ensemble de ces derniers.

Pour cela, nous avons choisi d'exporter les robots édités des différentes simulations dans une nouvelle scène. Dans le monde où le robot a été créé, il faut faire un clic droit sur le nom du robot dans la scene tree et après cliquer sur “Export”. Cela crée un fichier .wbo à sauvegarder là où vous le voulez et, dans le nouveau monde, cliquer sur “Import...” dans la fenêtre d’ajout de nœuds pour aller chercher le fichier.

[[Fichier:import_robot.jpg|500px|thumb|right|Importer un robot]] [[Fichier:export_robot.jpg|300px|thumb|left|Exporter un robot]]

 
Nous avons ensuite implémenté les codes nécessaires à chacun des robots et harmonisé les fonctionnements. Plus précisément, il a fallu ajouter la partie gestion de l'émetteur et émission de message du controller [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]] (partie communication) au controller utilisé pour suivre le robot rouge (partie détection de couleur).

Une fois cette fusion faite, il manquait encore la fonction d’évitement des obstacles que nous avons mises en place à ce moment.

=== Evitement ===

Les robots, en fonction de leur position dans la file, ayant des fonctions différentes (suivi d’un robot par analyse colorimétrique ou suivi d’un robot par communication sans fil), il est nécessaire d’adapter le code d’évitement pour ne pas interférer avec les fonctions de suivi. Ainsi la fonction d'évitement se base toujours sur le même principe, mais l’implémentation se fait de façon différente pour chaque controller, avec des contraintes plus ou moins complexes.

Tous les robots évitent les obstacles grâce aux capteurs de distance, mais ils doivent différencier les robots qu’ils suivent des obstacles quelconques. Pour cela, le robot maître utilise la quantité de pixels rouges dans l’image de la câmera au moment de la détection de l’obstacle, pendant que le maître-esclave et l'esclave utilisent la force du signal de communication. Dans ce dernier cas, la vérification est faite même avant la détection des obstacles, de façon à arrêter les robots.

De plus, on a aussi implémenté une fonction pour réduire la vitesse des robots au fur et à mesure qu’ils s’approchent de son but (robot à suivre), en utilisant un produit en croix.

À la fin, on avait les controllers : [[Robots suiveurs 3 - Code Contrôle au Clavier |Clavier_Control]], [[Robots suiveurs 3 - Controlêur Maître | maître]], [[Robots suiveurs 3 - Controlêur Maître-Esclave | maître-esclave]] et [[Robots suiveurs 3 - Controlêur Esclave | esclave]].

Robots suiveurs 3 - Tableau de Bord

2020-05-12T14:13:47Z

De-almeida-ribeiro.thiago : /* Fusion des méthodes */

== Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour se faire suivre des robots en les faisant communiquer. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu ajouter les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pour celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, existant en tant qu'exemple dans le logiciel. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu ajouter les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bout de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il habilite et configure l'émetteur du robot et transmet un message quelconque. Le contrôleur “receiver” habilite et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bout de code suivant est responsable de ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’à ce moment, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et de 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir le canal de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à suivre mais cela se fait d’une façon plus lente et irrégulière. Cela peut être un problème puisque le robot maître peut s’écarter des esclaves et la communication entre eux peut être coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais peut permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serie" ou "infra-red. Les signaux de type "radio" (par défaut) et "serie" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* [[Robots suiveurs 3 - Code Détection couleur (Robot suivi) |Code robot suivi]]
* [[Robots suiveurs 3 - Code Détection couleur (Robot suiveur) |Code robot suiveur]]

== Fusion des méthodes ==

=== Fusion de Code ===
Une fois l’ensemble des codes fonctionnel, nous nous sommes lancés dans la mise en place d’une simulation comprenant l’ensemble de ces derniers.

Pour cela, nous avons choisi d'exporter les robots édités des différentes simulations dans une nouvelle scène. Dans le monde où le robot a été créé, il faut faire un clic droit sur le nom du robot dans la scene tree et après cliquer sur “Export”. Cela crée un fichier .wbo à sauvegarder là où vous le voulez et, dans le nouveau monde, cliquer sur “Import...” dans la fenêtre d’ajout de nœuds pour aller chercher le fichier.

[[Fichier:import_robot.jpg|500px|thumb|right|Importer un robot]] [[Fichier:export_robot.jpg|300px|thumb|left|Exporter un robot]]

 
Nous avons ensuite implémenté les codes nécessaires à chacun des robots et harmonisé les fonctionnements. Plus précisément, il a fallu ajouter la partie gestion de l'émetteur et émission de message du controller [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]] (partie communication) au controller utilisé pour suivre le robot rouge (partie détection de couleur).

Une fois cette fusion faite, il manquait encore la fonction d’évitement des obstacles que nous avons mises en place à ce moment.

=== Evitement ===

Les robots, en fonction de leur position dans la file, ayant des fonctions différentes (suivi d’un robot par analyse colorimétrique ou suivi d’un robot par communication sans fil), il est nécessaire d’adapter le code d’évitement pour ne pas interférer avec les fonctions de suivi. Ainsi la fonction d'évitement se base toujours sur le même principe, mais l’implémentation se fait de façon différente pour chaque controller, avec des contraintes plus ou moins complexes.

Tous les robots évitent les obstacles grâce aux capteurs de distance, mais ils doivent différencier les robots qu’ils suivent des obstacles quelconques. Pour cela, le robot maître utilise la quantité de pixels rouges dans l’image de la câmera au moment de la détection de l’obstacle, pendant que le maître-esclave et l'esclave utilisent la force du signal de communication. Dans ce dernier cas, la vérification est faite même avant la détection des obstacles, de façon à arrêter les robots.

De plus, on a aussi implémenté une fonction pour réduire la vitesse des robots au fur et à mesure qu’ils s’approchent de son but (robot à suivre), en utilisant un produit en croix.

À la fin, on avait les controllers : [[Robots suiveurs 3 - Code Contrôle au Clavier |Clavier_Control]], [Robots suiveurs 3 - Controlêur Maître | maître], [Robots suiveurs 3 - Controlêur Maître-Esclave | maître-esclave] et [Robots suiveurs 3 - Controlêur Esclave | esclave]

Robots suiveurs 3 - Tableau de Bord

2020-05-12T14:10:12Z

De-almeida-ribeiro.thiago : /* Fusion de Code */

== Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour se faire suivre des robots en les faisant communiquer. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu ajouter les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pour celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, existant en tant qu'exemple dans le logiciel. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu ajouter les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bout de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il habilite et configure l'émetteur du robot et transmet un message quelconque. Le contrôleur “receiver” habilite et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bout de code suivant est responsable de ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’à ce moment, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et de 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir le canal de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à suivre mais cela se fait d’une façon plus lente et irrégulière. Cela peut être un problème puisque le robot maître peut s’écarter des esclaves et la communication entre eux peut être coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais peut permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serie" ou "infra-red. Les signaux de type "radio" (par défaut) et "serie" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* [[Robots suiveurs 3 - Code Détection couleur (Robot suivi) |Code robot suivi]]
* [[Robots suiveurs 3 - Code Détection couleur (Robot suiveur) |Code robot suiveur]]

== Fusion des méthodes ==

=== Fusion de Code ===
Une fois l’ensemble des codes fonctionnel, nous nous sommes lancés dans la mise en place d’une simulation comprenant l’ensemble de ces derniers.

Pour cela, nous avons choisi d'exporter les robots édités des différentes simulations dans une nouvelle scène. Dans le monde où le robot a été créé, il faut faire un clic droit sur le nom du robot dans la scene tree et après cliquer sur “Export”. Cela crée un fichier .wbo à sauvegarder là où vous le voulez et, dans le nouveau monde, cliquer sur “Import...” dans la fenêtre d’ajout de nœuds pour aller chercher le fichier.

[[Fichier:import_robot.jpg|500px|thumb|right|Importer un robot]] [[Fichier:export_robot.jpg|300px|thumb|left|Exporter un robot]]

 
Nous avons ensuite implémenté les codes nécessaires à chacun des robots et harmonisé les fonctionnements. Plus précisément, il a fallu ajouter la partie gestion de l'émetteur et émission de message du controller [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]] (partie communication) au controller utilisé pour suivre le robot rouge (partie détection de couleur).

Une fois cette fusion faite, il manquait encore la fonction d’évitement des obstacles que nous avons mises en place à ce moment.

Robots suiveurs 3 - Tableau de Bord

2020-05-12T14:09:32Z

De-almeida-ribeiro.thiago : /* Fusion de Code */

== Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour se faire suivre des robots en les faisant communiquer. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu ajouter les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pour celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, existant en tant qu'exemple dans le logiciel. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu ajouter les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bout de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il habilite et configure l'émetteur du robot et transmet un message quelconque. Le contrôleur “receiver” habilite et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bout de code suivant est responsable de ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’à ce moment, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et de 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir le canal de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à suivre mais cela se fait d’une façon plus lente et irrégulière. Cela peut être un problème puisque le robot maître peut s’écarter des esclaves et la communication entre eux peut être coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais peut permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serie" ou "infra-red. Les signaux de type "radio" (par défaut) et "serie" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* [[Robots suiveurs 3 - Code Détection couleur (Robot suivi) |Code robot suivi]]
* [[Robots suiveurs 3 - Code Détection couleur (Robot suiveur) |Code robot suiveur]]

== Fusion des méthodes ==

=== Fusion de Code ===
Une fois l’ensemble des codes fonctionnel, nous nous sommes lancés dans la mise en place d’une simulation comprenant l’ensemble de ces derniers.

Pour cela, nous avons choisi d'exporter les robots édités des différentes simulations dans une nouvelle scène. Dans le monde où le robot a été créé, il faut faire un clic droit sur le nom du robot dans la scene tree et après cliquer sur “Export”. Cela crée un fichier .wbo à sauvegarder là où vous le voulez et, dans le nouveau monde, cliquer sur “Import...” dans la fenêtre d’ajout de nœuds pour aller chercher le fichier.

[[Fichier:import_robot.jpg|500px|thumb|right|Importer un robot]] [[Fichier:export_robot.jpg|300px|thumb|left|Exporter un robot]]

 
Nous avons ensuite implémenté les codes nécessaires à chacun des robots et harmonisé les fonctionnements. Plus précisément, il a fallu ajouter la partie gestion de l'émetteur et émission de message du controller [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]] (partie communication) au controller utilisé pour suivre le robot rouge (partie détection de couleur).

Une fois cette fusion faite, il manquait encore la fonction d’évitement des obstacles que nous avons mises en place à ce moment.

Robots suiveurs 3 - Tableau de Bord

2020-05-12T13:01:39Z

De-almeida-ribeiro.thiago : /* Fusion de Code */

== Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour se faire suivre des robots en les faisant communiquer. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu ajouter les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pour celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, existant en tant qu'exemple dans le logiciel. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu ajouter les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bout de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il habilite et configure l'émetteur du robot et transmet un message quelconque. Le contrôleur “receiver” habilite et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bout de code suivant est responsable de ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’à ce moment, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et de 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir le canal de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à suivre mais cela se fait d’une façon plus lente et irrégulière. Cela peut être un problème puisque le robot maître peut s’écarter des esclaves et la communication entre eux peut être coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais peut permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serie" ou "infra-red. Les signaux de type "radio" (par défaut) et "serie" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* [[Robots suiveurs 3 - Code Détection couleur (Robot suivi) |Code robot suivi]]
* [[Robots suiveurs 3 - Code Détection couleur (Robot suiveur) |Code robot suiveur]]

== Fusion des méthodes ==

=== Fusion de Code ===
Une fois l’ensemble des codes fonctionnel, nous nous sommes lancés dans la mise en place d’une simulation comprenant l’ensemble de ces derniers.

Pour cela nous avons exporté les robots des différentes simulations sur la scène créée. Dans le monde où le robot a été créé, il faut faire un clic droit sur le nom du robot dans la scene tree et après cliquer sur “Export”. Cela crée un fichier .wbo à sauvegarder là où vous le voulez et, dans le nouveau monde, cliquer sur “Import...” dans la fenêtre d’ajout de nœuds pour aller chercher le fichier.

Nous avons ensuite implémenté les codes nécessaires à chacun des robots et harmonisé les fonctionnements. Plus précisément, il a fallu ajouter la partie gestion de l'émetteur et émission de message du controller [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]] (partie communication) au controller utilisé pour suivre le robot rouge (partie détection de couleur).

Une fois cette fusion faite, il manquait encore la fonction d’évitement des obstacles que nous avons mises en place à ce moment.

[[Fichier:import_robot.jpg|500px|thumb|right|Importer un robot]]
[[Fichier:export_robot.jpg|300px|thumb|left|Exporter un robot]]

Robots suiveurs 3 - Tableau de Bord

2020-05-12T13:01:16Z

De-almeida-ribeiro.thiago : /* Fusion des méthodes */

== Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour se faire suivre des robots en les faisant communiquer. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu ajouter les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pour celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, existant en tant qu'exemple dans le logiciel. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu ajouter les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bout de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il habilite et configure l'émetteur du robot et transmet un message quelconque. Le contrôleur “receiver” habilite et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bout de code suivant est responsable de ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’à ce moment, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et de 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir le canal de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à suivre mais cela se fait d’une façon plus lente et irrégulière. Cela peut être un problème puisque le robot maître peut s’écarter des esclaves et la communication entre eux peut être coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais peut permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serie" ou "infra-red. Les signaux de type "radio" (par défaut) et "serie" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* [[Robots suiveurs 3 - Code Détection couleur (Robot suivi) |Code robot suivi]]
* [[Robots suiveurs 3 - Code Détection couleur (Robot suiveur) |Code robot suiveur]]

== Fusion des méthodes ==

=== Fusion de Code ===
Une fois l’ensemble des codes fonctionnel, nous nous sommes lancés dans la mise en place d’une simulation comprenant l’ensemble de ces derniers.

Pour cela nous avons exporté les robots des différentes simulations sur la scène créée. Dans le monde où le robot a été créé, il faut faire un clic droit sur le nom du robot dans la scene tree et après cliquer sur “Export”. Cela crée un fichier .wbo à sauvegarder là où vous le voulez et, dans le nouveau monde, cliquer sur “Import...” dans la fenêtre d’ajout de nœuds pour aller chercher le fichier.

Nous avons ensuite implémenté les codes nécessaires à chacun des robots et harmonisé les fonctionnements. Plus précisément, il a fallu ajouter la partie gestion de l'émetteur et émission de message du controller [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]] (partie communication) au controller utilisé pour suivre le robot rouge (partie détection de couleur).

Une fois cette fusion faite, il manquait encore la fonction d’évitement des obstacles que nous avons mises en place à ce moment.

[[Fichier:import_robot.jpg|300px|thumb|right|Importer un robot]]
[[Fichier:export_robot.jpg|300px|thumb|left|Exporter un robot]]

Robots suiveurs 3 - Tableau de Bord

2020-05-12T12:33:26Z

De-almeida-ribeiro.thiago : /* Fusion des méthodes */

== Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour se faire suivre des robots en les faisant communiquer. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu ajouter les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pour celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, existant en tant qu'exemple dans le logiciel. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu ajouter les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bout de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il habilite et configure l'émetteur du robot et transmet un message quelconque. Le contrôleur “receiver” habilite et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bout de code suivant est responsable de ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’à ce moment, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et de 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir le canal de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à suivre mais cela se fait d’une façon plus lente et irrégulière. Cela peut être un problème puisque le robot maître peut s’écarter des esclaves et la communication entre eux peut être coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais peut permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serie" ou "infra-red. Les signaux de type "radio" (par défaut) et "serie" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* [[Robots suiveurs 3 - Code Détection couleur (Robot suivi) |Code robot suivi]]
* [[Robots suiveurs 3 - Code Détection couleur (Robot suiveur) |Code robot suiveur]]

== Fusion des méthodes ==

Une fois l’ensemble des codes fonctionnel, nous nous sommes lancés dans la mise en place d’une simulation comprenant l’ensemble de ces derniers.

Pour cela nous avons exporté les robots des différentes simulations sur la scène créée. Dans le monde où le robot a été créé, il faut faire un clic droit sur le nom du robot dans la scene tree et après cliquer sur “Export”. Cela crée un fichier .wbo à sauvegarder là où vous le voulez et, dans le nouveau monde, cliquer sur “Import...” dans la fenêtre d’ajout de nœuds pour aller chercher le fichier.

Nous avons ensuite implémenté les codes nécessaires à chacun des robots et harmonisé les fonctionnements. Plus précisément, il a fallu ajouter la partie gestion de l'émetteur et émission de message du controller [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]] (partie communication) au controller utilisé pour suivre le robot rouge (partie détection de couleur).

Une fois cette fusion faite, il manquait encore la fonction d’évitement des obstacles que nous avons mises en place à ce moment.

[[Fichier:import_robot.jpg|300px|thumb|right|Importer un robot]]
[[Fichier:export_robot.jpg|300px|thumb|left|Exporter un robot]]

Robots suiveurs 3 - Tableau de Bord

2020-05-12T12:27:31Z

De-almeida-ribeiro.thiago : /* Fusion des méthodes */

== Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour se faire suivre des robots en les faisant communiquer. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu ajouter les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pour celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, existant en tant qu'exemple dans le logiciel. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu ajouter les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bout de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il habilite et configure l'émetteur du robot et transmet un message quelconque. Le contrôleur “receiver” habilite et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bout de code suivant est responsable de ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’à ce moment, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et de 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir le canal de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à suivre mais cela se fait d’une façon plus lente et irrégulière. Cela peut être un problème puisque le robot maître peut s’écarter des esclaves et la communication entre eux peut être coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais peut permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serie" ou "infra-red. Les signaux de type "radio" (par défaut) et "serie" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* [[Robots suiveurs 3 - Code Détection couleur (Robot suivi) |Code robot suivi]]
* [[Robots suiveurs 3 - Code Détection couleur (Robot suiveur) |Code robot suiveur]]

== Fusion des méthodes ==
Une fois l’ensemble des codes fonctionnel, nous nous sommes lancés dans la mise en place d’une simulation comprenant l’ensemble de ces derniers.

Pour cela nous avons exporté les robots des différentes simulations sur la scène créée. Dans le monde où le robot a été créé, il faut faire un clic droit sur le nom du robot dans la scene tree et après cliquer sur “Export”. Cela crée un fichier .wbo à sauvegarder là où vous le voulez et, dans le nouveau monde, cliquer sur “Import...” dans la fenêtre d’ajout de nœuds pour aller chercher le fichier.

Nous avons ensuite implémenté les codes nécessaires à chacun des robots et harmonisé les fonctionnements. Plus précisément, il a fallu ajouter la partie gestion de l'émetteur et émission de message du controller [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]] (partie communication) au controller utilisé pour suivre le robot rouge (partie détection de couleur).

Une fois cette fusion faite, il manquait encore la fonction d’évitement des obstacles que nous avons mises en place à ce moment.

Fichier:Import robot.jpg

2020-05-12T12:26:33Z

De-almeida-ribeiro.thiago :

Fichier:Export robot.jpg

2020-05-12T12:26:06Z

De-almeida-ribeiro.thiago :

Robots suiveurs 3 - Code Détection couleur (Robot suivi)

2020-05-12T11:39:02Z

De-almeida-ribeiro.thiago :

<nowiki>

#include <webots/Robot.hpp>

// Added a new include file
#include <webots/Motor.hpp>
#include <webots/Keyboard.hpp> // Ajout de la bibliothèque gérant les événements clavier.
#define TIME_STEP 64

#define MAX_SPEED 6.28

// All the webots classes are defined in the "webots" namespace
using namespace webots;

int main(int argc, char **argv) {
Robot *robot = new Robot();

// get a handler to the motors and set target position to infinity (speed control)
Motor *leftMotor = robot->getMotor("left wheel motor");
Motor *rightMotor = robot->getMotor("right wheel motor");
leftMotor->setPosition(INFINITY);
rightMotor->setPosition(INFINITY);

// Initialisation des moteurs à une vitesse nulle
leftMotor->setVelocity(0);
rightMotor->setVelocity(0);

// Initialisation de l'objet clavier
Keyboard keyboard = Keyboard();
keyboard.enable(50); // Activation de la détection des événements. La suite du code ne marchera pas sans cette option

while (robot->step(TIME_STEP) != -1){

int key = keyboard.getKey(); // Détecte le code clavier retourné en fonction de la touche pressée

if (key == -1) { // Si le code retourné est -1, aucune touche n'est enfoncée, il faut donc arrêter le robot
leftMotor->setVelocity(0);
rightMotor->setVelocity(0);
}

while (key > 0) {
switch (key) {

case 'Z': // Cas Z enfoncé : On applique la vitesse maximale pour avancer
leftMotor->setVelocity(MAX_SPEED);
rightMotor->setVelocity(MAX_SPEED);

break;
case 'S': //Cas S enfoncé : On applique la vitesse maximale négative pour reculer
leftMotor->setVelocity(-MAX_SPEED);
rightMotor->setVelocity(-MAX_SPEED);
break;
case 'Q': //Cas Q enfoncé : On applique une vitesse à une roue et l'inverse à l'autre pour pivoter à gauche. Au delà de 0.5 fois la vitesse maximale appliquée, la simulation de déplacement du robot saccade.
leftMotor->setVelocity(-0.49*MAX_SPEED);
rightMotor->setVelocity(0.49*MAX_SPEED);
break;
case 'D': //Cas D enfoncé : On applique une vitesse à une roue et l'inverse à l'autre pour pivoter à droite. Au delà de 0.5 fois la vitesse maximale appliquée, la simulation de déplacement du robot saccade.
leftMotor->setVelocity(0.49*MAX_SPEED);
rightMotor->setVelocity(-0.49*MAX_SPEED);
break;

//Cas A et E enfoncé : On applique une vitesse à une roue et une vitesse moins élevée à l'autre pour pivoter tout en avançant. Au delà de 0.75 fois la vitesse maximale appliquée, la simulation du déplacement du robot saccade aussi.
case 'A':
leftMotor->setVelocity(0.5*MAX_SPEED);
rightMotor->setVelocity(0.75*MAX_SPEED);
break;
case 'E':
leftMotor->setVelocity(0.75*MAX_SPEED);
rightMotor->setVelocity(0.5*MAX_SPEED);
break;
default: //Pour toute autre touche on arrête le robot
leftMotor->setVelocity(0);
rightMotor->setVelocity(0);
break;
}
key = keyboard.getKey(); // Actualisation de la sortie clavier.

}

}

delete robot;

return 0;
}
</nowiki>

Robots suiveurs 3 - Code Tutoriel Communication

2020-05-12T06:29:04Z

De-almeida-ribeiro.thiago : /* Le contrôleur et la communication */

== Introduction ==

Pour ce tutoriel, on partira d’un monde de base du logiciel Webots, qui s'appelle “emitter_receiver”. Il possède deux robots qui se déplacent de façon à éviter les obstacles et qui si communiquent (en affichant une message sur la console) quand le robot récepteur se trouve dans la portée du signal de communication, représentée par une sphère blanche autour du robot émetteur. Les deux robots utilisent le contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], mais ont des comportements différents en fonction de leur noms.

[[Fichier:emitter_receiver.gif|400px|thumb|left|fonctionnement des robots (cliquez pour jouer le GIF)]]

[[Fichier:console_emitter_receiver.jpg|400px|thumb|right|Messages sur le console]]

 



== Le contrôleur et la communication ==

Dans cette section, on expliquera la partie du code relative à la communication entre les robots. Le code étant en C, on presentera aussi les fonctions équivalents en C++, qui sont utiles pour comprendre le projet.

Au tout début, il faut ajouter les bibliothèques pour l’émetteur et le récepteur.

<nowiki>
#include <webots/emitter.h>
#include <webots/receiver.h> </nowiki>

On doit créer un “deviceTag” pour la communication, ce qui n’est pas nécessaire en C++, et prendre la main de l’émetteur ou du récepteur, selon le cas. Ensuite, on choisit le canal de communication (si ce n’est pas la bonne) pour l'émetteur et on habilite le récepteur.

<nowiki>
WbDeviceTag communication; </nowiki>

* '''Émetteur :'''
<nowiki>
communication = wb_robot_get_device("emitter");
wb_emitter_set_channel(communication, COMMUNICATION_CHANNEL); </nowiki>

* '''Récepteur :'''

<nowiki>
communication = wb_robot_get_device("receiver");
wb_receiver_enable(communication, TIME_STEP); </nowiki>

En C++, cela devient :

* '''Émetteur :'''

<nowiki>
Emitter *emitter = robot->getEmitter("emitter");
emitter->setChannel(COMMUNICATION_CHANNEL); </nowiki>

* '''Récepteur :'''
<nowiki>
Receiver *receiver = robot->getReceiver("receiver");
receiver->setChannel(COMMUNICATION_CHANNEL); </nowiki>

On remarque que, dans ce cas, l’habilitation du récepteur est faite en choisissant le canal de communication.

Enfin, l'émetteur doit envoyer le message et le récepteur doit le recevoir et l’afficher sur la console. Pour pouvoir le faire, on doit vérifier si le buffer du récepteur est vide et, si cela n’est pas le cas, mettre le message dans un autre buffer, qui sera affiché une seule fois (utilisation du if avec la variable “message_printed”). Il est important de remarquer qu’il faut chercher le nouveau paquet de l'émetteur après avoir affiché le message, sinon on vide la queue de façon permanente.

* '''Émetteur :'''
<nowiki>
const char *message = "Hello!";
wb_emitter_send(communication, message, strlen(message) + 1); </nowiki>

* '''Récepteur :'''
<nowiki>
/* is there at least one packet in the receiver's queue ? */
if (wb_receiver_get_queue_length(communication) > 0) {

/* read current packet's data */
const char *buffer = wb_receiver_get_data(communication);

if (message_printed != 1) {
/* print null-terminated message */
printf("Communicating: received \"%s\"\n", buffer);
message_printed = 1;
}

/* fetch next packet */
wb_receiver_next_packet(communication);

} else {

if (message_printed != 2) {
printf("Communication broken!\n");
message_printed = 2;
}
} </nowiki>

En C++ :

* '''Émetteur :'''
<nowiki>
const char *message = "Hello!";
emitter->send(message, strlen(message) + 1); </nowiki>

* '''Récepteur :'''
<nowiki>
if (receiver->getQueueLength() > 0)
{

/* read current packet's data */
const char *buffer = (const char*)receiver->getData();
const double *position= receiver->getEmitterDirection();

/* print null-terminated message */
if (message_printed != 1) {
printf("Communicating: received \"%s\"\n", buffer);
message_printed = 1;
}

/* fetch next packet */
receiver->nextPacket();

} else {

if (message_printed != 2)
{
printf("Communication broken!\n");
message_printed = 2;
}
} </nowiki>

Robots suiveurs 3 - Tableau de Bord

2020-05-12T06:28:26Z

De-almeida-ribeiro.thiago : /* IV) Communication entre robots */

== I) Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== II) Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== III) Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== IV) Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour faire suivre des robots esclaves à un robot maître, en utilisant la communication entre eux. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu additionner les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pou celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, trouvé dans un monde de base homonyme. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu additionner les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bout de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il habilite et configure l'émetteur du robot et transmet une message quelconque. Le contrôleur “receiver” habilite et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bout de code suivant est responsable pour ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’à ce moment, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir le canal de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit de faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à suivre mais cela se fait d’une façon plus lente et irrégulière. Cela peut être un problème puisque le robot maître peut s’écarter des esclaves et la communication entre eux peut être coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais peut permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serie" ou "infra-red. Les signaux de type "radio" (par défaut) et "serie" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== V) Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== V) Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* [[Robots suiveurs 3 - Code Détection couleur (Robot suivi) |Code robot suivi]]
* [[Robots suiveurs 3 - Code Détection couleur (Robot suiveur) |Code robot suiveur]]

Robots suiveurs 3 - Capteurs

2020-05-12T06:27:21Z

De-almeida-ribeiro.thiago : /* Fonctions Disponibles (en C++) */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== lookupTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infra-red" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du buffer de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infra-red" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' taille (en octets) du buffer de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire buffer, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength (ou getSignalStrength() en C++). Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction (ou getEmitterDirection() en C++). Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie le nombre d'octets de données présents dans le paquet de tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-12T06:25:17Z

De-almeida-ribeiro.thiago : /* Receiver */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== lookupTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infra-red" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du buffer de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infra-red" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' taille (en octets) du buffer de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire buffer, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength (ou getSignalStrength() en C++). Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction (ou getEmitterDirection() en C++). Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-12T06:23:17Z

De-almeida-ribeiro.thiago : /* Receiver */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== lookupTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infra-red" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du buffer de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infra-red" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' taille (en octets) du buffer de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire buffer, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength (ou getSignalStrength() en C++). Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction (ou getEmitterDirection() en C++). Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-12T06:22:48Z

De-almeida-ribeiro.thiago : /* Receiver */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== lookupTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infra-red" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du buffer de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infra-red" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' taille (en octets) du buffer de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire buffer, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength (ou getSignalStrength() en C++). Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-12T06:21:37Z

De-almeida-ribeiro.thiago : /* Receiver */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== lookupTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infra-red" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du buffer de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infra-red" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' taille (en octets) du buffer de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire buffer, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-12T06:20:39Z

De-almeida-ribeiro.thiago : /* Receiver */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== lookupTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infra-red" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du buffer de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infra-red" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' taille (en octets) du buffer de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire tampon, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-12T06:18:58Z

De-almeida-ribeiro.thiago : /* Description des champs */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== lookupTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infra-red" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du buffer de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infrarouge" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' taille (en octets) du buffer de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire tampon, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-12T06:16:31Z

De-almeida-ribeiro.thiago : /* Receiver */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== lookupTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infra-red" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du tampon de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infrarouge" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' taille (en octets) du buffer de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire tampon, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-12T06:16:10Z

De-almeida-ribeiro.thiago : /* Description des champs */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== lookupTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infra-red" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du tampon de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infrarouge" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' taille (en octets) du buffer de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire tampon, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-12T06:15:57Z

De-almeida-ribeiro.thiago : /* Receiver */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== lookupTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infra-red" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du tampon de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infrarouge" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' taille (en octets) du buffer de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire tampon, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.
[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-12T06:15:24Z

De-almeida-ribeiro.thiago : /* Description des champs */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== lookupTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infra-red" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du tampon de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infrarouge" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' taille (en octets) du buffer de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire tampon, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-12T06:13:59Z

De-almeida-ribeiro.thiago : /* Receiver */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== lookupTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infra-red" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré. Voir cette figure pour une illustration de la plage et de l'ouverture.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du tampon de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infrarouge" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' taille (en octets) du buffer de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire tampon, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-12T06:08:52Z

De-almeida-ribeiro.thiago : /* Description des champs */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== lookupTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infra-red" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré. Voir cette figure pour une illustration de la plage et de l'ouverture.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du tampon de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infrarouge" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' staille (en octets) du tampon de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire tampon, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-12T06:07:32Z

De-almeida-ribeiro.thiago : /* Description des champs */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeurs possibles'''
|-
| lookupTable
| SFVec3f
| lookup table
|-
| type
| SFString
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| SFFloat
| [0, 2*pi]
|-
| gaussianWidth
| SFFloat
| [0, inf)
|-
| resolution
| SFFloat
| {-1, [0, inf)}
|}

== lookupTable ==
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.
[[Fichier:Lookuptable capteur distance.PNG|vignette|center|Fonction de transfert du capteur de distance]]

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| '''Méthode'''
| '''Paramètres'''
| '''Description'''
|-
| void wb_distance_sensor_enable(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infra-red" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infrarouge" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré. Voir cette figure pour une illustration de la plage et de l'ouverture.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du tampon de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infrarouge" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' staille (en octets) du tampon de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire tampon, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Tableau de Bord

2020-05-11T15:27:10Z

De-almeida-ribeiro.thiago : /* IV) Communication entre robots */

== I) Description du simulateur ==

Le logiciel [https://cyberbotics.com/#cyberbotics Webots] est un simulateur robotique 3D OpenSource fonctionnant sous Windows, Mac OS et Linux.

Ce logiciel est très facile à prendre en main car il suffit de l'installer, de le lancer et de jouer avec les exemples livrés avec le logiciel. 
Il existe aussi un [https://cyberbotics.com/doc/guide/tutorials?tab-language=c++ tutoriel] très facile d'accès, très documenté permettant de comprendre la logique du logiciel et d'être rapidement en capacité de créer sa propre simulation. 
Ce qui en fait aussi un logiciel très facile d'accès est la possibilité de l'utiliser avec plusieurs langages de programmation grâce à des API complètes. 
En effet, les robots peuvent être contrôlés via du C, C++, Python, Java et MATLAB. On peut aussi utiliser [https://www.ros.org/ ROS]. 
Les tests sont aussi très agréables à réaliser puisqu'on peut interagir avec le robot et son environnement pendant le test.

=== Création d'un espace de test 3D ===

Le logiciel propose à l'utilisateur de créer un espace de test 3D en ajoutant toutes sortes d'éléments. 
Ces éléments peuvent être des formes élémentaires : alors le travail fait par l'utilisateur se rapprochera d'un travail de [https://fr.wikipedia.org/wiki/Conception_assist%C3%A9e_par_ordinateur CAO]. 
Ces éléments peuvent aussi être des objets existant dans la [https://cyberbotics.com/doc/guide/objects base] fournie : du mobilier, des plantes, des fruits, des extincteurs, etc. 
Pour tous ces éléments, on peut configurer de nombreuses propriétés : leur masse, leur densité, les frottements auxquels ils sont soumis, leur taille, etc. 

De même, pour les robots, il est possible d'en créer un à partir de rien mais beaucoup sont proposés dans la [https://cyberbotics.com/doc/guide/robots base de robots] : du petit robot éducatif [https://www.thymio.org/fr/ Thymio] au robot humanoïde Atlas de [https://www.bostondynamics.com/ Boston Dynamics].

Et c'est la même chose pour les actionneurs et les capteurs : une base est fournie et décrite sur le site !

=== Utilisation d'un controller ===

Chaque robot peut être associé à un programme appelé controller dont le rôle est de définir le comportement du robot. 
Ces controllers peuvent être écrits dans tous les langages supportés par Webots : C, C++, Python, Java, MATLAB. Dans les tutoriels, tous sont présentés mais nous avons choisi de travailler en C++ car tous les membres de l'équipe connaissaient ce langage. Notre objectif n'était pas d'apprendre un nouveau langage de programmation, et le C++ est tout de même très utilisé dans ce domaine. 
Au lancement de la simulation, le logiciel lancera un processus par controller utilisé sur chaque robot. On ne peut associer qu'un controller par robot (c'est l’exécutable qui est utilisé) mais on peut utiliser le même controller pour plusieurs robots : dans ce cas, des processus distincts seront créés pour chaque robot. 

=== Interface Graphique ===

[[Fichier:WebotsGUI.png|thumb]]

L'interface graphique se découpe en plusieurs parties que l'on peut afficher dans différentes fenêtres. 
La fenêtre 3D permet d'afficher et de dérouler la simulation dans l'espace 3D créé plus tôt. Dans cette fenêtre, même pendant une simulation, on peut encore déplacer des objets, les faire tourner, les faire interagir pour tester le comportement de notre robot simulé. 
Le "Scene Tree" représente le monde 3D créé. Il comporte des blocs correspondant aux différents éléments créés ou importés tels que les objets ou les robots. En cliquant sur les flèches, il est possible de dérouler les propriétés accessibles sur un composant. 
La console, affichée par défaut en bas de l'écran permet de lire des informations de débug ou les résultats de compilation. 
On peut aussi retrouver un éditeur de texte permettant de compiler le code écrit afin de le tester dans la simulation.

[https://cyberbotics.com/doc/guide/the-user-interface Pour plus de détails sur les menus et l'interface graphique]

== II) Déplacements contrôlés au clavier ==

=== Introduction===

L'objectif de cette partie est d’implémenter la possibilité de contrôler un robot avec les touches classiques zqsd afin de permettre la réalisation de tests.
Pour ce faire, on faut créer un nouveau contrôleur : Wizards -> New Robot Controller.
Notre contrôleur sera nommé Clavier_Control et codé en C++.
Une fenêtre éditor s'ouvre alors. Pour gérer le contrôle des moteurs. Nous sommes partis de la base donnée en tutoriel à cette [https://www.cyberbotics.com/doc/guide/tutorial-1-your-first-simulation-in-webots#extend-the-controller-to-speed-control adresse].

Cette base donne les fondations pour pouvoir contrôler en vitesse les moteurs. C'est exactement ce dont nous avons besoin, puisque notre robot doit accélérer lorsqu'on le lui impose.

=== Code===

Le code suivant est commenté pour les parties liées au clavier. Le tutoriel concernant la gestion des moteurs sera explicité [[Robots suiveurs 3 - Code Tutoriel Contrôle moteurs | sur cette page]]
*[[Robots suiveurs 3 - Code Contrôle au Clavier |Voir le CODE]]

L'idée générale derrière ce code est d'affecter aux moteurs une vitesse selon la touche enfoncée sur le clavier. On utilise Z et S pour respectivement avancer et reculer, Q et D pour pivoter à gauche ou à droite et enfin A et E pour avancer en pivotant légèrement.
Pour cela, on utilise un objet Keyboard existant dans la bibliothèque proposée par Webots.

=== Utilisation ===

Le code du controller mis en place a pour but de permettre un contrôle manuel du robot. Cette fonction doit entre implantée en début de projet de façon assez rapide pour permettre aux autres équipes de réaliser des tests de façon simplifiée, en ayant la main sur les action du robot en développement.

Les fonctions introduites ne sont pour autant pas Immuable, celles-ci pouvant être modifiées selon les besoins requis, les mouvement pouvant être adaptés.
On pourra de plus remarquer que l'utilisation du clavier nécessite d'avoir sélectionné la fenêtre de simulation 3D (en cliquant sur la scène 3D).

== III) Robot Suiveur simple avec capteurs de distance ==
=== Description ===
[[Fichier:E_puck_capteurs.PNG|vignette|E_puck et ses capteurs]]
Dans cette partie, on devait réaliser un robot suiveur rudimentaire en utilisant 2 capteurs de distance afin de comprendre leur fonctionnement. le logiciel webots nous fourni déjà des robots préfait possédant une multitude de capteurs. On a donc utilisé le robot E-puck, possédant 2 roues et 8 capteurs de distances autour de lui (ainsi qu'une caméra, un émetteur et un récepteur).
=== Fonctionnement ===
*[[Code de robot suiveur via l'utilisation de capteurs | Code de robot suiveur via l'utilisation de capteurs ]]
Afin d'avoir un robot simple, on utilise seulement les 2 capteurs à l'avant du robot (un plutôt à droite et l'autre plutôt à gauche). Ces capteurs servent à détecter le robot de devant. On fixe un seuil de distance activant ou non 2 booléens "robot_a_droite/gauche". On a donc 4 combinaisons différentes de ces booléens qui vont servir a commander notre robot:
{| class="wikitable alternance center"
! scope="col" | robot_a_droite
! scope="col" | robot_a_gauche
! scope="col" | résultat
|-
| faux
| faux
| avancer
|-
| faux
| vrai
| tourner à gauche
|-
| vrai
| vrai
| stop
|-
| vrai
| faux
| tourner à droite
|}

=== Résultats ===
Le résultat est plutôt satisfaisant vue sa simplicité. on remarque que les robots se suivent très bien les uns les autres vue qu'ils ont la même vitesse. Le comportement du premier robot est pas encore stable, mais comme il est censé suivre un humain, son fonctionnement va changer de toutes manières.
[[Fichier:Suiveur 1.gif|500px|center|4 robots suiveurs se suivant, le premier suit la caisse]]

=== Suite ===
Les capteurs de distance on été utilisés ici pour suivre un robot, ou pourrait par la suite les utiliser pour éviter un obstacle. Il faudra pour cela éloigner les robots les uns des autres et leur faire suivre une commande à l'aide des autres parties réalisées.

== IV) Communication entre robots ==

'''Participants :'''
[[Utilisateur:‎Clément Luton |Clément Luton]] et [[Utilisateur:‎De-almeida-ribeiro.thiago |Thiago De Almeida Ribeiro]]

Cette section a pour but d’expliquer comment utiliser le logiciel Webots pour faire suivre des robots esclaves à un robot maître, en utilisant la communication entre eux. La communication qui est permise par la simulation suit un protocole de communication série mais elle est transmise sans fil.

Les deux premières sous-sections comportent les résultats auxquels on est arrivé dans les dates indiquées, pendant que la dernière section comporte les résultats finaux, avec le niveau de détail nécessaire pour comprendre le fonctionnement du code et du logiciel. Avant de continuer, il serait intéressant d’avoir lu le [[Robots suiveurs 3 - Code Tutoriel Communication | tutoriel d’explication de code sur les bases de communication sur Webots]] et la description des nodes Emitter et Receiver, sur la [[Robots suiveurs 3 - Capteurs | page de description des capteurs]].

=== Résultats initiaux (16/04/2020) ===

Pour configurer la communication entre deux robots, au tout début, il a fallu additionner les robots au monde et exécuter la commande “Convert to Base Node(s)” (clique droit sur le robot dans le node tree). Cela a été nécessaire pour pouvoir changer quelques caractéristiques des robots, comme leur nom et la portée du signal émis (nécessaire pour le code en C mais pas pou celui en C++).

Pour faire le code, on est parti du controller emitter_receiver, trouvé dans un monde de base homonyme. Nous avons eu deux démarches : une consistant à garder le code dans son langage, le C, est à l’adapter et une autre consistant à passer en C++ pour garder une cohésion avec le groupe entier qui code aussi en C++. Alors on a un [[Robots suiveurs 3 - Code Communication Initial (C) |code en C]] en un [[Robots suiveurs 3 - Code Communication Initial (C++) |code en C++]].

Dans les deux cas nous sommes arrivés à mettre en place une communication continue entre deux robots. Nous sommes capables de savoir si la communication se passe bien ou si elle est interrompue et nous avons réussi à transmettre au robot esclave la position relative (le robot esclave est utilisé comme origine d’un système de coordonnées) du robot maître. Nous allons utiliser ces données pour déplacer correctement le robot esclave. Dans ce moment, deux solutions s’offrent à nous :

* Se déplacer selon l’axe des X puis l’axe des Z.
* Se déplacer selon l’hypoténuse formée.

[[Fichier:deplacement_comm.png|300px|thumb|center|Schéma du déplacement]]

=== Résultats intérmédiaires (17/04/2020) ===

Après un peu plus de réflexion, on a décidé d’utiliser un troisième approche pour le comportement suiveur (détaillé sur la prochaine section). On est partie du code en C++ écrit avant pour écrire le [[Robots suiveurs 3 - Code Communication Intermédiaire (maître) |code du robot maître]] et le [[Robots suiveurs 3 - Code Communication Intermédiaire (esclave) |code du robot esclave]]. On a pu contrôler le robot maître grâce au clavier et faire suivre le robot esclave grâce à la position du maître. La sphère blanche autour du robot maître représente la portée du signal de communication.

[[Fichier:suivi_position2.gif|400px|thumb|center|Le robot émetteur fait une ligne droite, le robot récepteur le suit]]

=== Résultats finaux (05/05/2020) ===

Maintenant on a deux robots esclaves et un robot maître. Le robot maître est contrôlé par le clavier et envoie sa position au premier esclave, celui-ci va suivre le maître et, à son tour, transmettre sa position au deuxième esclave, qui le suit.

Au tout début, il a fallu additionner les 3 robots (e-pucks) à un monde créé préalablement. De plus, il est intéressant de réduire le pas de temps de la simulation (WorldInfo -> basicTimeStep -> 16) pour pouvoir augmenter sa précision et sa stabilité.

Comme les trois robots fonctionnent de façon différente, il a fallu créer trois contrôleurs distincts : [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter") |"emitter"]], pour le robot maître, [[Robots suiveurs 3 - Code Communication Final (controlêur "emitter-receiver") |"emitter-receiver"]], pour le premier esclave, et [[Robots suiveurs 3 - Code Communication Final (controlêur "receiver") |"receiver"]], pour le deuxième esclave. Pour concevoir les codes, on est parti du contrôleur [[Robots suiveurs 3 - Code “emitter_receiver”|“emitter_receiver”]], trouvé dans un [[Robots suiveurs 3 - Code Tutoriel Communication | monde de base homonyme]]. Comme ce dernier est écrit en C, il a fallu le traduire en C++ au préalable pour garder une cohésion avec le groupe.

Le contrôleur “emitter” utilise un bout de code créé par d’autres intégrants du groupe pour permettre de contrôler le robot avec le clavier. De plus, il habilite et configure l'émetteur du robot et transmet une message quelconque. Le contrôleur “receiver” habilite et configure le récepteur du robot, affiche un message pour informer si la communication a été établie et permet de suivre un robot qui émet un message. Finalement, le contrôleur “emitter-receiver” est l'addition des deux contrôleurs antérieurs, sans la partie contrôle clavier.

Pour le comportement suiveur, on utilise deux fonctions de base : “getEmitterDirection()” et “getSignalStrength()”. La première permet d’obtenir la position de l'émetteur par rapport au système de coordonnées du récepteur (vecteur normalisé avec 3 composants) et la deuxième la force du signal. Le bout de code suivant est responsable pour ce comportement.

<nowiki>
const double *position=receiver->getEmitterDirection();
double signal=receiver->getSignalStrength();

if(signal>150) //Stop the robot if it's too close to the master
{
left_motor->setVelocity(0);
right_motor->setVelocity(0);
}
else{
//Following behavior
if (position[0]<-0.1)
{
left_motor->setVelocity(0);
right_motor->setVelocity(MAX_SPEED);
}
else if(position[0]>0.1)
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(0);
}
else
{
left_motor->setVelocity(MAX_SPEED);
right_motor->setVelocity(MAX_SPEED);
}
} </nowiki>

À partir de la force du signal, il est possible de savoir si le récepteur est trop proche de l'émetteur, de façon à arrêter le robot esclave pour éviter une collision. En outre, la première coordonnée du vecteur position (axe rouge dans la figure ci dessous) permet de dire si le récepteur est approximativement derrière l'émetteur (-0,1 < position[0] < 0,1). Si c’est le cas, le robot doit aller tout droit, sinon, il doit tourner à gauche où à droite.

[[Fichier:comm0.jpg|400px|thumb|center|Système de coordonées]]

Le fonctionnement est illustré dans le GIF ci-dessous.

[[Fichier:comm1.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Jusqu’à ce moment, les robots étaient considérés sans défauts. Cela veut dire que l'on n'avait pas pris en compte le bruit dans la communication. Le récepteur possède deux variables qui peuvent être modifiées afin d’y ajouter le bruit :

*signalStrengthNoise : écart-type du bruit gaussien ajouté à la force du signal renvoyé par “getSignalStrength()”. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.

*directionNoise : écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par “getEmitterDirection()”. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

Vu que le logiciel ne possède pas de fonction de base pour effectuer cette modification (comme setChannel() pour choisir la chaîne de communication, par exemple), on doit modifier le node du récepteur directement. Pour pouvoir le faire, on doit de faire un clique droit sur le robot que l'on souhaite modifier dans la scene tree et après cliquer sur “Convert to Base Node(s)”. Après, il suffit d’aller sur “Robot > children > DEF EPUCK_RECEIVER Receiver” et modifier les champs signalStrengthNoise et/ou directionNoise.

Si on met un écart-type de 1 pour la direction, par exemple, on remarque que les robots continuent à suivre mais cela se fait d’une façon plus lente et irrégulière. Cela peut être un problème puisque le robot maître peut s’écarter des esclaves et la communication entre eux peut être coupée.

[[Fichier:comm2.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

L’ajout du bruit associé à la force du signal ne doit pas affecter le comportement suiveur, mais peut permettre une collision entre les robots. Si on met, par exemple, la valeur de 0,1, on remarque que cela peut arriver :

[[Fichier:comm3.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Cela peut être réglé en mettant 80, par exemple, au lieu de 150, dans la ligne de code ci-dessous :

<nowiki>
if(signal>150) //Stop the robot if it's too close to the master </nowiki>

[[Fichier:comm4.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

Une deuxième solution serait d’utiliser les capteurs de distance du robot.

Enfin, il est important de prendre en compte les type de signaux possibles pour l'émetteur et le récepteur : "radio", "serie" ou "infra-red. Les signaux de type "radio" (par défaut) et "serie" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".

Alors, si aucune modification n’est effectué, l'émetteur et le récepteur utilisent le type “radio” et les robots pourront communiquer même s’il y a un obstacle entre eux :

[[Fichier:comm5.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

En choisissant le type “infra-red”, cela ne serait pas possible. Pour faire cette modification il suffit de changer les champs “type” dans “Robot > children > DEF EPUCK_RECEIVER Receiver” et “Robot > children > DEF EPUCK_EMITTER Emitter” (après avoir fait un “Change to Base Node(s)”.

[[Fichier:comm6.gif|400px|thumb|center|Cliquez pour jouer le GIF]]

== V) Mise en place de la scène ==
Pour modifier la scène nous nous sommes aidé du tutoriel disponible à cette [https://cyberbotics.com/doc/guide/tutorial-2-modification-of-the-environment adresse]. 
Comme dit précédemment l'interface graphique est plutôt intuitive et il est donc facile de modifier la scène. Tout se fait via le bouton Plus (Add) en haut à gauche entouré en rouge. 
[[Fichier:ObjetsAdd.png ‎|500px|thumb|center|Modification scène]]
Une fois qu'on a cliqué dessus on peut choisir un élément de base (base nodes) ou des éléments déjà existants (Proto Nodes). Dans les éléments existants il y a des objets, des robots, des véhicules... Une fois l'élément choisi il va être placé au centre du sol. La touche MAJ en même temps qu'un clic gauche de la souris permet de le déplacer là où l'on souhaite. Cette manipulation est aussi possible via la fenêtre de paramètre de l'objet (accolade en rouge sur la photo). 
On peut ainsi choisir de déplacer l'objet via les paramètres de translation, de le tourner via la rotation et enfin de changer sa taille via scale. 
Pour les objets déjà existants la méthode scale n'est pas directement accessible il faut faire un clic droit sur l'objet et sélectionner "convert to base nodes". Une fois cette opération effectuée, les paramètres scale seront accessibles. 
Pour un objet de type solid on peut modifier la forme (Shape) via les paramètres (voir l'exemple du tutoriel situé en haut).
Pour changer le controller d'un robot voir le lien [https://ujm.webgroup.fr/index.php?title=Robots_suiveurs_3_-_Tutoriels#1.29_Ajouter_un_controller_existant_.C3.A0_un_robot suivant].

== V) Robot avec détection de couleur ==
Le but est ici d'utiliser la caméra du robot E-Puck afin de de pouvoir suivre un objet de couleur, que l'on pourrai par exemple placer à l'arrière d'un robot pour que celui de derrière puisse le suivre. Nous avons dans un premier temps fait en sorte que le robot suive un objet rouge. Par la suite nous avons amélioré le système afin d'avoir plusieurs robot qui se suivent.

=== Fonctionnement ===
Pour cela, nous utilisons des méthodes de la classe Camera permettant de capturer une image et de recueillir des informations sur le nombre de pixel rouge, vert ou bleu. Nous avons donc séparer l'image en 3 zones (milieu, gauche et droite) afin de compter le nombre de pixel d'une certaine couleur dans chacune de ces partie. Si ce derniers est supérieur au nombre de pixels des autres couleurs dans une zone, on effectue le déplacement correspondant (avancer, pivotage à gauche ou à droite). Nous avons aussi utiliser les capteurs de distance situés à l'avant du robot afin d’éviter une collision quand le robot se sera trop rapproché de l'objet qu'il suit. Voici notre premier essai, le robot suit uniquement un objet rouge qu'il faut déplacer à la main :

[[Fichier:Suivi couleur.gif|500px|thumb|center|Suivi d'un cube de couleur rouge]]

Nous avons ensuite ajouté des robots de couleurs différentes, dépendant tous d'un controller différent, afin que le premier robot (bleu) soit guidé par les commandes du clavier, que le deuxième (rouge) suive le robot bleu, le troisième (vert) suive le robot rouge, et le dernier (gris) suive le robot vert :

[[Fichier:Simulation suiveurs caméra.gif|500px|thumb|center|Suivi de robots de couleur]]

Nous avons rajouté une fonctionnalité qui permet aux robots suiveurs de savoir où se trouve l'objet qu'il suivent (gauche, droite, ou devant). Ainsi, si l'objet suivi est sort du champs de vision, le robot va tourner sur le lui même en fonction de la position précédente de l'objet suivi. Si l'objet disparaît et qu'il se trouvait sur la gauche avant de disparaître, le robot va tourner sur lui même sur la gauche jusqu'à retrouver l'objet.
Voici les codes utilisés, comme le fonctionnement du des robots gris, vert et rouge est le même (seul la couleur à détecter change), nous ne mettons que le code du robot bleu (robot à suivre) et du robot rouge :
* [[Robots suiveurs 3 - Code Détection couleur (Robot suivi) |Code robot suivi]]
* [[Robots suiveurs 3 - Code Détection couleur (Robot suiveur) |Code robot suiveur]]

Robots suiveurs 3 - Capteurs

2020-05-11T15:22:03Z

De-almeida-ribeiro.thiago : /* Émetteur-récepteur */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| lookupTable
| Vec3f
| lookup table
|-
| type
| String
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| Float
| [0, 2*pi]
|-
| gaussianWidth
| Float
| [0, inf)
|-
| resolution
| Float
| {-1, [0, inf)}
|}

== lookupTable ==
[[Fichier:Lookuptable capteur distance.PNG | vignette | Fonction de transfert du capteur de distance]]
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| void wb_distance_sensor_enable
(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value
(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =
Afin de faire communiquer des robots, nous utilisons des émmeteurs et récepteurs, qu'on modélise grâce aux nodes [https://www.cyberbotics.com/doc/reference/emitter?tab-language=c++ Emitter] et [https://www.cyberbotics.com/doc/reference/receiver?tab-language=c++ Receiver], respectivement. Nous allons décrire ici les bases de son fonctionnement. Pour plus d'information, veuillez accéder aux liens des nodes (vers le site de cyberbotics).
== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infrarouge" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infrarouge" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré. Voir cette figure pour une illustration de la plage et de l'ouverture.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du tampon de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infrarouge" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' staille (en octets) du tampon de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire tampon, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-11T15:15:08Z

De-almeida-ribeiro.thiago : /* Émetteur-récepteur */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| lookupTable
| Vec3f
| lookup table
|-
| type
| String
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| Float
| [0, 2*pi]
|-
| gaussianWidth
| Float
| [0, inf)
|-
| resolution
| Float
| {-1, [0, inf)}
|}

== lookupTable ==
[[Fichier:Lookuptable capteur distance.PNG | vignette | Fonction de transfert du capteur de distance]]
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| void wb_distance_sensor_enable
(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value
(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =

== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infrarouge" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infrarouge" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré. Voir cette figure pour une illustration de la plage et de l'ouverture.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du tampon de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infrarouge" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' staille (en octets) du tampon de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire tampon, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-11T15:13:54Z

De-almeida-ribeiro.thiago : /* Fonctions Disponibles (en C++) */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| lookupTable
| Vec3f
| lookup table
|-
| type
| String
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| Float
| [0, 2*pi]
|-
| gaussianWidth
| Float
| [0, inf)
|-
| resolution
| Float
| {-1, [0, inf)}
|}

== lookupTable ==
[[Fichier:Lookuptable capteur distance.PNG | vignette | Fonction de transfert du capteur de distance]]
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| void wb_distance_sensor_enable
(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value
(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =

== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infrarouge" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infrarouge" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré. Voir cette figure pour une illustration de la plage et de l'ouverture.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du tampon de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infrarouge" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' staille (en octets) du tampon de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire tampon, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur.
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants.
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur.
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception.
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-11T15:13:04Z

De-almeida-ribeiro.thiago : /* Émetteur-récepteur */

Le logiciel Webots dispose d'une large collection de capteurs déjà configurés disposant de méthodes associées. Le robot [https://fr.wikipedia.org/wiki/E-Puck E-puck] que nous utilisons dans ce projet dispose de différents capteurs prépositionnés :

* 8 capteurs de distance infrarouge
* Camera couleur VGA
* Accéléromètre 3D (non utilisé)
* Émetteur-récepteur ZigBee

Nous allons donc détailler dans cette partie le fonctionnement des capteurs utilisés.

= Capteur de distance =
Afin de détecter des obstacles, nous utilisons des capteurs de distance qu'on modélise grâce au node [https://cyberbotics.com/doc/reference/distancesensor DistanceSensor]. Nous allons décrire ici son fonctionnement.

== Champs du node DistanceSensor ==
{| class="wikitable left"
|-
| lookupTable
| Vec3f
| lookup table
|-
| type
| String
| {"generic", "infra-red", "sonar", "laser"}
|-
| numberOfRays
| Int32
| [1, inf)
|-
| aperture
| Float
| [0, 2*pi]
|-
| gaussianWidth
| Float
| [0, inf)
|-
| resolution
| Float
| {-1, [0, inf)}
|}

== lookupTable ==
[[Fichier:Lookuptable capteur distance.PNG | vignette | Fonction de transfert du capteur de distance]]
La LookUpTable est un tableau à 2 dimensions servant à faire la correspondance entre la distance en mètre mesurée par le capteur et la valeur de sortie du capteur. Cette table consiste en une liste de coordonnées de points qui, une fois reliés, nous donne la fonction de transfert du capteur. A chaque point est associé une valeur d'écart type pour son bruit associé.

Les valeurs de la table sont pré-configurés pour correspondre à un capteur précis. On peut voir sur le graphique que plus la distance est faible, plus la valeur de sortie augmente vite. Afin d'éviter précisément des obstacles, et de simplifier la mesure des distance, nous avons modifié la table. En ne positionnant que deux points aux extrémités des intervalles, nous obtenons une droite affine. Nous avons donc une précision constante en fonction de la distance et les conversions distance/code sont plus simples. Il serait possible par la suite d'étudier l'influence du bruit sur les performances du robot. Nous pourrons aussi questionner la pertinence de ces modifications qui changent peut-être trop le fonctionnement des capteurs pour correspondre à la réalité.

== Méthodes utilisées ==

{| class="wikitable left"
|-
| void wb_distance_sensor_enable
(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Active le capteur de distance ciblé.
|-
| double wb_distance_sensor_get_value
(WbDeviceTag tag)
| WbDeviceTag tag : tag du capteur afin de le cibler
| Renvoie la valeur associée à la distance mesurée du capteur ciblé.
|}

= Camera =

= Émetteur-récepteur =

== Champs des nodes Emitter et Receiver ==
=== Emitter ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| range
| SFFloat
| -1
| {-1, [0, inf)}
|-
| maxRange
| SFFloat
| -1
| {-1, [0, inf)}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|}
=== Receiver ===
{| class="wikitable left"
|-
| '''Nom'''
| '''Type'''
| '''Valeur par défaut'''
| '''Valeurs possibles'''
|-
| type
| SFString
| "radio"
| {"radio", "serial", "infra-red"}
|-
| aperture
| SFFloat
| -1
| {-1 ,[0, 2*pi]}
|-
| channel
| SFInt32
| 0
| [0, inf)
|-
| baudRate
| SFInt32
| -1
| {-1, [0, inf)}
|-
| byteSize
| SFInt32
| 8
| [8, inf)
|-
| bufferSize
| SFInt32
| -1
| {-1, [0, inf)}
|-
| signalStrengthNoise
| SFFloat
| 0
| [0, inf)
|-
| directionNoise
| SFFloat
| 0
| [0, inf)
|}

== Description des champs ==

=== Emitter ===

* '''type :''' type de signaux: "radio", "serial" ou "infra-red". Les signaux de type "radio" (par défaut) et "série" sont transmis sans tenir compte des obstacles. Cependant, les signaux de type "infra-red" tiennent compte des obstacles potentiels entre l'émetteur et le récepteur. Tout objet solide (solide, robots, etc ...) avec un objet englobant défini est un obstacle potentiel à une communication "infra-red". La structure du robot émetteur ou récepteur lui-même ne bloquera pas une transmission "infra-red". Actuellement, il n'y a pas de différence d'implémentation entre les types "radio" et "serie".
* '''range :''' rayon de la sphère d'émission (en mètres). Un récepteur ne peut recevoir un message que s'il se trouve dans la sphère d'émission. Une valeur de -1 (par défaut) pour la plage est considérée comme une plage infinie.
* '''maxRange :''' définit la valeur maximale autorisée pour la plage. Ce champ définit la valeur maximale pouvant être définie à l'aide de la fonction wb_emitter_set_range. Une valeur de -1 (par défaut) pour maxRange est considérée comme infinie.
* '''aperture :''' angle d'ouverture du cône d'émission (en radians); pour "infrarouge" uniquement. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées de l'émetteur et l'axe du cône coïncide avec l'axe z du système de coordonnées de l'émetteur. Un émetteur "infrarouge" ne peut envoyer des données qu'aux récepteurs actuellement situés dans son cône d'émission. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie que les signaux émis sont omnidirectionnels. Pour les émetteurs "radio" et "série", ce champ est ignoré. Voir cette figure pour une illustration de la plage et de l'ouverture.
* '''channel :''' canal de transmission. Il s'agit d'un numéro d'identification pour un émetteur "infra-red" ou d'une fréquence pour un émetteur "radio". Normalement, un récepteur doit utiliser le même canal qu'un émetteur pour recevoir les données émises. Cependant, le canal spécial -1 permet de diffuser des messages sur tous les canaux. Le canal 0 (par défaut) est réservé pour communiquer avec un plugin physique. Pour la communication inter-robots, veuillez utiliser des numéros de canaux positifs.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en nombre de bits par seconde. Un baudRate de -1 (par défaut) est considéré comme infini et entraîne la transmission immédiate des données (dans un pas de temps de base) de l'émetteur au récepteur.
* '''byteSize :''' la taille d'octet est le nombre de bits requis pour transmettre un octet d'information. Il s'agit généralement de 8 (valeur par défaut), mais peut être supérieur si des bits de contrôle sont utilisés.
* '''bufferSize :''' spécifie la taille (en octets) du tampon de transmission. Le nombre total d'octets dans les paquets mis en file d'attente dans l'émetteur ne peut pas dépasser ce nombre. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée.

=== Receiver ===

* '''type :''' idem que pour l'émetteur.
* '''aperture :''' angle d'ouverture du cône de réception (en radians); pour "infra-red" uniquement. Le récepteur ne peut recevoir que des messages d'émetteurs situés actuellement dans son cône de réception. L'apex du cône est situé à l'origine ([0 0 0]) du système de coordonnées du récepteur et l'axe du cône coïncide avec l'axe z du système de coordonnées du récepteur. Une ouverture de -1 (valeur par défaut) est considérée comme infinie, ce qui signifie qu'un signal peut être reçu de n'importe quelle direction. Pour les récepteurs "radio", le champ d'ouverture est ignoré.
[[Fichier:ilustration_aperture.png|500px|thumb|center|Illustration de l'ouverture et de la portée de l'émetteur / récepteur infrarouge]]
* '''channel :''' canal de réception. La valeur est un numéro d'identification pour un récepteur "infrarouge" ou une fréquence pour un récepteur "radio". Normalement, l'émetteur et le récepteur doivent utiliser le même canal pour pouvoir communiquer. Cependant, le numéro de canal spécial -1 permet au récepteur d'écouter tous les canaux.
* '''baudRate :''' le débit en bauds est la vitesse de communication exprimée en bits par seconde. Elle doit être identique à la vitesse de l'émetteur. Actuellement, ce champ est ignoré.
* '''byteSize :''' la taille en octets est le nombre de bits utilisés pour représenter un octet de données transmises (généralement 8, mais peut être supérieur si des bits de contrôle sont utilisés). Il doit être de la même taille que la taille des octets de l'émetteur. Actuellement, ce champ est ignoré.
* '''bufferSize :''' staille (en octets) du tampon de réception. La taille des données reçues ne doit à aucun moment dépasser la taille de la mémoire tampon, sinon les données peuvent être perdues. Un bufferSize de -1 (par défaut) est considéré comme une taille de buffer illimitée. Si les données précédentes n'ont pas été lues lors de la réception de nouvelles données, les données précédentes sont perdues.
* '''signalStrengthNoise :''' écart-type du bruit gaussien ajouté à la force du signal renvoyé par wb_receiver_get_signal_strength. Le bruit est proportionnel à la force du signal, par exemple, un signalStrengthNoise de 0,1 ajoutera un bruit avec un écart-type de 0,1 pour une force de signal de 1 et 0,2 pour une force de signal de 2.
* '''directionNoise :''' écart-type du bruit gaussien ajouté à chacune des composantes de la direction retournée par wb_receiver_get_emitter_direction. Le bruit ne dépend pas de la distance entre l'émetteur-récepteur.

== Fonctions Disponibles (en C++) ==

=== Emitter ===

{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual int send(const void *data, int size);
|Ajoute à la file d'attente de l'émetteur un paquet d'octets de taille situé à l'adresse indiquée par "data".
|-
| virtual void setChannel(int channel);
| Permet au contrôleur de changer le canal de transmission.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel de l'émetteur.
|-
| virtual void setRange(double range);
| Permet au contrôleur de modifier la plage de transmission au moment de l'exécution.
|-
| double getRange() const;
| Renvoie la plage actuelle de l'émetteur
|-
| int getBufferSize() const;
| Renvoie la taille (en octets) du buffer de transmission.
|}

=== Receiver ===
{| class="wikitable left"
|-
| '''Fonction'''
| '''Utilité'''
|-
| virtual void enable(int samplingPeriod);
| Démarre le récepteur à l'écoute des paquets de données entrants
|-
| virtual void disable();
| Arrête l'écoute en arrière-plan.
|-
| int getSamplingPeriod() const;
| Renvoie la période donnée dans la fonction wb_receiver_enable, ou 0 si le périphérique est désactivé.
|-
| int getQueueLength() const;
| Renvoie le nombre de paquets de données actuellement présents dans la file d'attente du récepteur
|-
| virtual void nextPacket();
| Supprime le paquet de tête. Le paquet suivant dans la file d'attente, le cas échéant, devient le nouveau paquet principal.
|-
| const void *getData() const;
| Renvoie les données du paquet en tête de la file d'attente de réception
|-
| int getDataSize() const;
| Renvoie les données du paquet en tête de la file d'attente de réception
|-
| double getSignalStrength() const;
| Renvoie la force du signal simulé au moment où le paquet a été transmis.
|-
| const double *getEmitterDirection() const;
| Renvoie un vecteur normalisé (longueur = 1) qui indique la direction de l'émetteur par rapport au système de coordonnées du récepteur.
|-
| virtual void setChannel(int channel);
| Permet à un récepteur de changer de canal de réception.
|-
| int getChannel() const;
| Renvoie le numéro de canal actuel du récepteur.
|}

Robots suiveurs 3 - Capteurs

2020-05-11T14:42:44Z

De-almeida-ribeiro.thiago : /* Receiver */

Robots suiveurs 3 - Capteurs

2020-05-11T14:41:25Z

De-almeida-ribeiro.thiago : /* Description des champs */

Fichier:Ilustration aperture.png

2020-05-11T14:40:09Z

De-almeida-ribeiro.thiago :

Robots suiveurs 3 - Capteurs

2020-05-11T14:38:04Z

De-almeida-ribeiro.thiago : /* Receiver */

Robots suiveurs 3 - Capteurs

2020-05-11T14:36:27Z

De-almeida-ribeiro.thiago : /* Description des champs */

Robots suiveurs 3 - Capteurs

2020-05-11T14:17:44Z

De-almeida-ribeiro.thiago : /* Émetteur-récepteur */