1

______________________________________________________________________________
PROJET : Simulation d’un robot mobile
© Pr Said BENHLIMA, Département d’Informatique
Faculté des Sciences Meknès

1. Introduction
Le but de ce projet est de contrôler le déplacement d’un robot mobile en agissant uniquement sur
la vitesse angulaire de ses roues. Il devra atteindre un maximum de buts sur une durée
prédéterminée, tout en évitant les obstacles présents dans l’environnement afin de ne pas être
ralenti.
2. Le robot mobile
Le robot est représenté de la façon suivante:

2.1. Dimensions et notations concernant le robot:

• Intervalle de temps entre chaque mise à jour de la position et de l’orientation du robot :
Δt = 0.1s
• La distance entre les roues : D = 0.05m
• Rayon du robot : Rr = 0.05m
• Distance parcourue pendant Δt : Δr
• Réorientation pendant Δt : Δα
• Rayon d’une roue : R0 = 0.02m
• Vitesse de la roue gauche (respectivement droite) ωg (respectivement ωd) en rd/s
• Distance parcourue par la roue gauche (respectivement droite) pendant Δt : Δg (respectivement
Δd) en m

• Vitesse angulaire maximum des roues : ω0Max = 10 rd/s

• Accélération maximum des roues : Δω0Max = 2 rd/s2
2.2. Déplacement du robot
Le déplacement du robot (c’est-à-dire l’évolution de sa position et de son orientation) est calculé
uniquement à partir de la vitesse angulaire de chaque roue (les vitesses angulaires des roues étant
indépendantes comme sur les véritables robots). Nous devons donc, à chaque nouvel instant de la
 2

______________________________________________________________________________
simulation, mettre à jour ces valeurs. Par exemple, entre chaque instant de la simulation, la roue
droite se déplace de la manière suivante:

La position et l’orientation du robot dans ce contexte évoluent de la manière suivante entre 2

instants:
Δr =(Δg + Δd)∕ 2
Δα =(Δg – Δd)∕ D

La mise à jour se fait en 2 étapes : la première consiste à calculer le déplacement Δr suivant l’axe
frontal xr du robot et d’en déduire la nouvelle position (Xc’, Yc’) du robot dans le repère monde.
La nouvelle orientation du robot est ensuite calculée en fonction de Δα.

De plus, l’accélération angulaire de chaque roue est limitée. A un instant donné, le robot a donc
une vitesse angulaire désirée (fixée par l’utilisateur grâce à l’interface) pour chaque roue. La
vitesse angulaire réelle de chaque roue est mise à jour (dans le cas ou elle n’est pas égale à la
vitesse désirée) en respectant l’accéleration maximum.
Une fois les vitesses réelles calculées, la position et l’orientation du robot peuvent être mises à
jour.
 3

______________________________________________________________________________
3. Obstacles
L’environnement dans lequel se déplace le robot peut contenir des obstacles circulaires.
3.1. Description des obstacles
Chaque obstacle est défini par sa position et son rayon. Les obstacles sont définis dans un fichier
.obs (voir la section sur les Entrées-sorties).
Ce fichier est chargé par l’application qui crée les obstacles
3.2. Collisions
Lors de la simulation, le robot mobile peut entrer en collision avec un obstacle. Dans ce cas, sa
position ainsi que la vitesse réelle de ses roues doivent être mises à jour. Lorsqu’il y a collision
entre un obstacle de centre (Xobs,Yobs) et de rayon Robs et le robot dont la position courante est
(Xr,Yr), ce dernier doit être repoussé sur le bord de l’obstacle. Sa nouvelle position devient donc:

Xr =Xobs+{ (Xr – Xobs)/Dist}×(Robs + Rr)

Yr =Yobs+{(Yr – Yobs)/Dist}×(Robs + Rr)

dist étant la distance courante entre le robot et l’obstacle.

Important : la vitesse angulaire réelle de chaque roue doit de plus être mise à zéro.

4. Les buts
A chaque fois que le robot atteint un but durant la simulation, un nouveau but est créé dans un
cercle de rayon 1m centré sur le robot. Il faut de plus que la position du but reste dans un
cercle de rayon 10m autour de l’origine.
La position de chaque but est générée pseudo-aléatoirement (un ordinateur étant par définition
déterministe, il n’est pas possible de générer des nombres tout à fait aléatoires). Pour obtenir un
nombre compris dans l’intervalle [-1, 1], il faut utiliser la fonction rand():
nb_aleatoire = (rand()/(double)RAND_MAX - 0.5)*2.;
De plus, il faut savoir que la fonction rand() utilise en fait une suite de nombres prédéfinie pour
choisir un nouveau nombre. Il est possible (et même indispensable) de choisir l’endroit où l’on
souhaite commencer dans cette suite: on appelle ça la graine. Pour fixer la graine on utilise la
fonction srand() (voir Cours de C); on peut choisir 2 méthodes:
• On choisit la même graîne pour chaque exécution du programme: dans ce cas, on commence
toujours à la même position dans la suite de nombres. On aura donc toujours la même séquence
de nombres pseudo-aléatoires entre 2 exécutions du programme. Cette méthode est utile lors de la
phase de mise au point du programme.
En effet, elle permet de choisir un but identique à chaque exécution.
• On choisit une graîne différente à chaque exécution du programme: dans ce cas, on commence
toujours (presque) à une position différente dans la suite de nombres. On aura donc toujours une
séquence différente de nombres pseudo-aléatoires entre 2 exécutions du programme. Pour choisir
une graine différente à chaque exécution du programme, on choisit tout simplement le temps
actuel de la machine (qui évidemment est différent entre 2 exécutions du programme) en faisant
srand(time(0);
REMARQUE : au tout début de la phase de mise au point, vous pouvez aussi fixer directement
la position du but avant de commencer à gérer la génération de buts aléatoires.
 4

______________________________________________________________________________
5. Déplacement automatique du robot

La simulation doit fournir 2 modes d’exécution différents:

• le mode manuel qui permet à l’utilisateur de spécifier les vitesses angulaires désirées des roues
du robot pour qu’il se déplace.
• Le mode automatique pour que le robot se déplace tout seul. Dans ce mode, le robot devra se
diriger vers les buts tout en essayant d’éviter les obstacles. Ce problème étant bien plus complexe
qu’il n’y paraît, les tests du mode automatique se baseront uniquement sur des cas avec 2
obstacles maximum. Vous êtes libres d’expérimenter divers algorithmes pilotant au mieux votre
robot (en influant uniquement sur les vitesses angulaires désirées des roues).

ATTENTION: votre algorithme ne devra modifier que les valeurs des vitesses angulaires
désirées du robot. En aucun cas il ne devra faire varier directement les valeurs des positions
ou des vitesses réelles du robot!
6. Format des fichiers d’entrée-sorties
L’application finale devra utiliser 2 fichiers: un fichier permettant de définir la configuration de
l’environnement (positions et rayons des obstacles présents) et un autre fichier permettant de
sauvegarder les différents états du robot au cours de la simulation.

6.1. Fichier pour les obstacles (*.obs)

Chaque ligne du fichier décrivant les obstacles décrit la position en x et y de l’obstacle ainsi que
son rayon de la manière suivante:
<Position_x> <position_y> <Rayon>
Il y a autant de lignes qu’il y a d’obstacles. Le fichier peut de plus contenir des lignes
commençant par "#". Ces lignes sont des commentaires et doivent être ignorées lors de la
création des obstacles.

6.2. Fichier de sauvegarde des états du robot (*.pts)

Ce fichier contient les dernières valeurs (1000 au maximum) des positions en x et en y du robot
ainsi que les vitesses angulaires courantes et les vitesses angulaires désirées des roues du robot.
Chaque ligne du fichier décrit un état du robot à un instant donné de la manière suivante:
<instant> <X> <Y> <Vitesse désirée G> <vitesse désirée D> <vitesse G> <vitesse D>

<instant> est un entier représentant chaque instant (allant de 1 à 1000 au maximum).

7. Fenêtre de simulation:
Cette fenêtre sert à afficher l’état actuel de la simulation. Pour cette partie, vous êtes entièrement
libres de choisir les couleurs, les formes pour les buts et le robots (les obstacles étant circulaires),
...
Il faut de plus être capable d’afficher les N dernières positions du robot. Le nombre de positions
affichées sera défini grâce à l’interface.

ATTENTION! Bien que vous soyez libres de choisir la manière dont vous affichez les objets
dans la fenêtre Graphique, les grandeurs internes c’est-à-dire celles stockées dans le robot
(positions, vitesses, ...), les buts, les fichiers d’entrées-sorties doivent rester cohérentes avec
la donnée.
 5

______________________________________________________________________________
Résumé du travail à faire :
Notations : x, y, Rr=0.05, Dx, Dy, Xobs, Yobs, Robs, Dr, Dt=0.1, D=0.05, Dg, Dd, Rc, alpha,
Dalpha, wg, wd, wr, w0Max=10, Dw0Max=2, R0=0.02, Dist, Vr.
Formules : Dd=wd*Dt*R0; Dg=wg*Dt*R0; Rc=D*(Dd+Dg)/(2*(Dd-Dg)); Dr=(Dd+Dg)/2;
Dalpha=(Dd-Dg)/D; alpha=alpha+Dalpha*180/3.14; Vr=Dr/Dt, wr=Dalpha/Dt,
Dist=sqrt((x-Xobs)*(x-Xobs)+(y-Yobs)*(y-Yobs))

1) Ecrire une méthode « rotation(theta,x,y) » de la classe « figure » qui permet de faire tourner
une figure d’un angle « theta » autour du point (x,y).
Remarque : une rotation autour de (x,y) est équivalente à un déplacement de (-x,-y) suivi d’une
rotation autour de l’origine (0,0) puis d’un déplacement de (x,y).

2) Ecrire une méthode « rotation(theta,x,y) » de la classe « dessin » qui permet de faire tourner
toutes les figures qui composent un dessin d’un angle « theta » autour du point (x,y).

3) Dans un premier temps, vous écrivez le code du programme qui permet de déplacer le robot en
agissant manuellement sur les 2 vitesses angulaires des roues droite et gauche wd et wg à l’aide
des touches (flèches). Un affichage graphique accompagne les déplacements du robot du point de
départ jusqu’au point d’arrivée (mise à jour tous les ∆t=0.1s). Ces coordonnées seront stockées
dans un fichier (voir fichiers d’entrées sorties). Ensuite, reproduire ces déplacements
graphiquement sur l’écran à partir du fichier. (on utilisera la POO)

4) Dans un deuxième temps, Vous écrivez le code du déplacement automatique, nous supposons
qu’il y a un seul obstacle et un seul but, le robot se déplace sur une droite et rencontre l’obstacle
sur sa trajectoire, le robot doit l’éviter et atteindre le but. Pour éviter l’obstacle, on peut choisir
une trajectoire comme un arc de cercle telle que le robot ne heurte pas l’obstacle et se dirige après
vers le but.

Facultatif : pour ceux qui ont fini :

5) Ecrire le programme général : plusieurs obstacles, plusieurs buts, en mode automatique.

Représentation du robot : Dans toutes les étapes du projet, on considère que le robot est
circulaire. Bien que vous ayez le libre choix de la représentation du robot, vous pouvez
considérer que le robot est composé d’un cercle, d’un triangle et de 2 segments (les roues).

Bon courage
Pr S.BENHLIMA