Université Moulay Ismail

L’Ecole Supérieur de Technologie

Filière génie électrique : Option ET/EN

Rapport de PFE :
Robot éviteur d’obstacle avec
un bras robotique.

Encadré par : M.Nakheli Réalisé par :

Khadija El Amoury
Amin El Kayoues
Abdesamad El Quadiri

Année universitaire : 2019/2020

 REMERCIEMENT :

Avant d’entamer la rédaction de ce rapport, il nous est agréable de présenter une

dette de reconnaissance à toutes les personnes qui, par leur intervention ont favorisé
l’aboutissement de ce projet de fin d’étude.

Nous tenons à remercier infiniment notre encadrant Monsieur A.Nakheli, qui

nous a informé et accompagné tout au long de cette expérience professionnelle
avec beaucoup de patience et de pédagogie. Nous sommes très reconnaissants à
Monsieur Nakheli de nous avoir donné l’opportunité de travailler sur un projet qui
était tellement bénéfique. Nous la remercions pour tous ses efforts et ses conseils
précieux et son soutien pour réussir un tel sujet et de nous avoir guidé dans
l’élaboration de ce travail et contribuer largement à sa réalisation.

Nous tenons aussi à exprimer nos gratitudes et nos remerciements aux membres
du jury. Veuillez accepter dans ce travail nos sincères respects et nos profondes
reconnaissances.

1
 TABLE DES MATIERES :
Remerciement ____________________________________________________________ 1
Liste des figure ____________________________________________________________ 4
Introducion _______________________________________________________________ 5
CHAPITRE 01 : GENERALITE SUR LA ROBOTIQUE MOBILE ________________ 6
I. Définition ___________________________________________________________ 7
II. Robot mobile : _______________________________________________________ 7
III. Architecture d’un robot mobile: ________________________________________ 7
a) Structure mécanique: ________________________________________________ 7
b) Structure instrumentale : ____________________________________________ 7
c) Structure informatique ______________________________________________ 7
d) Exemple de robot mobile :____________________________________________ 7
CONCLUSION ___________________________________________________________ 8
CHAPITRE 02 : GENERALITES SUR LA PLATEFORME ARDUINO ____________ 9
A. Historique du projet Arduino : ________________________________________ 10
B. Découverte de la carte Arduino :______________________________________ 122
a) ça sert à quoi ? ___________________________________________________ 122
b) qu'est-ce que c'est ? _______________________________________________ 122
c) comment ça marche ? _____________________________________________ 133
d) Arduino : faut-il des connaissances en électronique ? ___________________ 144
CHAPITRE 03 :ETUDE ET REALISATION _________________________________ 155
I. L'objectif : ____________________________________________________ 166
II. Diagramme structurel : __________________________________________ 166
III. Matériel nécessaire : ____________________________________________ 166
A. Mesurer une distance avec un capteur à ultrason : _______________________ 177
a) Comment mesurer une distance : ________________________________________ 177
b) Le capteur HC-SR04 : __________________________________________________ 188
c) Principe de fonctionnement du capteur : ___________________________________ 188
d) Le montage : ___________________________________________________________ 19
e) Le code :_______________________________________________________________ 21
B. Piloter des moteurs DC avec une carte TB6612FNG : _____________________ 25
a. Le montage : ___________________________________________________________ 25
C. Instructions pour les moteurs : ________________________________________ 266
a. les moteurs DC: _______________________________________________________ 266
b. Le montage :__________________________________________________________ 266
D. Code complet :_____________________________________________________ 288
CHAPITRE 04 Chapitre 04:PRÉ-ÉTUDE de bras robot MeArm _________________ 34
A. Introduction : _____________________________________________________ 355
B. Pièces et composants : ______________________________________________ 355
1) Partie mécanique :_____________________________________________________ 355
2) Partie électrique et électronique : ________________________________________ 366
a. Carte Arduino Mega2560 : __________________________________________ 366
2
 b. Servomoteur Tower Pro SG90 : ____________________________________ 366
c. Joystick (manette) : ______________________________________________ 366
d. Module d’alimentation YwRobot : _________________________________ 377
e. Source d’alimentation : ___________________________________________ 377
3) Assemblage du MeArm : ____________________________________________ 388
a) Câblage des servomoteurs: _______________________________________ 388
b) Calibrage des servomoteurs : _____________________________________ 388
c) Assemblage des pièces : ___________________________________________ 39
4) Programmation du MeArm : ________________________________________ 422
a) Partie déclarative : ______________________________________________ 422
b) La fonction de configuration setup : _______________________________ 433
c) La boucle principale loop : _______________________________________ 433
5) Commande autonome de MeArm : ____________________________________ 44
CONCLUSION __________________________________________________________ 46
CONCLUSION GENERALE _______________________________________________ 47
REFERECES ____________________________________________________________ 48

3
 Liste des figures :

Figure 1: Robot mobile de type voiture.

Figure 2: Interagir avec le monde réel.
Figure 3: Diverses Cartes Arduino.
Figure 4: Scratch pour Arduino.
Figure 5: Illustration du signal TRIGGER et ECHO.
Figure 6: Matériel nécessaire.
Figure 7: Vue prototypage du montage.
Figure 8: Le montage fini.
Figure 9: Montage avec une LED.
Figure 10: Moteur DC.
Figure 11: Les pièces de MeArm.
Figure 12: Le servomoteur Tower Pro SG90.
Figure 13: Joystick analogique à 2 axes.
Figure 14: Module d’alimentation YwRobot.
Figure 15: Batterie 9 volts.
Figure 16: Schéma de câblage des servomoteurs.
Figure 17: le tracé de centre des servomoteurs.
Figure 18: les pièces à assembler.
Figure 19: La base du bras MeArm.
Figure 20: La pince de MeArm.
Figure 21: Les quatre parties qui portent les servomoteurs.
Figure 22: MeArm avant le montage de la pince
Figure 23: MeArm final.

4
 INTRODUCTION GENERALE :

La robotique est un ensemble de disciplines (mécanique, électronique, automatique,

informatique), elle se subdivise en deux types : les robots industriels et les robots mobiles.
Les robots industriels sont généralement fixes, ils sont utilisés dans des nombreuses
applications industrielles : l'assemblage mécanique, la soudure, la peinture... Les robots
mobiles ne sont pas fixes, ils sont classifies selon la locomotion en robots marcheurs, à
roues, à chenilles... comme ils peuvent être classifié selon le domaine d'application en robots
militaires, de laboratoire, industriels et de services.
L'aspect particulier de la mobilité impose une complexité technologique (capteurs,
motricité, énergie) ct méthodologique tel que le traitement des informations par utilisation
des techniques de l'intelligence artificielle ou de processeurs particuliers (vectoriels,
cellulaires).
L'autonomie du robot mobile est une faculté qui lui permet de s'adapter ou de prendre une
décision dans le but de réaliser une tache même dans un environnement peu connu ou
totalement inconnu.
En vue de bien vouloir comprendre le fonctionnement d’un robot mobile nous allons passer
à la réalisation d’un robot détecteur de présence qui circule dans un espace et évite les
obstacles lorsqu’il en rencontre.

5
 CHAPITRE 01 :
GENERALITE SUR LA
ROBOTIQUE MOBILE

6
 I. Définition :
Le terme (Robot) prend son origine du mot slave (Paboma) (se prononce robota) qui veut
dire en russe travail ou en tchèque corvée ou travail forcé.
II désigne aussi une machine à l'aspect humain, capable de se mouvoir et d'agir, qu'un
mécanisme automatique pouvant effectuer certaines opérations, et capable par fois de
modifier de lui-même son cycle de fonctionnement et d'exercer un certain choix.

II. Robot mobile :

Contrairement au robot industriel qui est généralement fixé, le robot mobile est doté de
moyens qui lui permettent de se déplacer dans son espace de travail. Suivant son degré
d'autonomie ou degré d'intelligence, il peut être dote de moyens de perception et de
raisonnement. Certains sont capables, sous contrôle humain réduit, de modéliser leur
espace de travail et de planifier un chemin dans un environnement qu'ils ne connaissent pas
forcément d'avance. Actuellement, les robots mobiles les plus sophistiqués sont
essentiellement orientés vers des applications dans des environnements variables ou
incertains, souvent peuplés d'obstacles, nécessitant une adaptabilité à la tâche.

III. Architecture d’un robot mobile:

a) Structure mécanique: elle assure le mouvement du robot par des roues

motrices placées selon le type de mouvement et la précision de la tache voulue.
b) Structure instrumentale : un robot est équipé d'un certain nombre de
capteurs de sécurité afin de leur donner une certaine connaissance de
l'environnement.
c) Structure informatique : une commande numérique est impérative, afin de
bien analyser les différentes informations, soit du système de perception ou de
localisation. Cette commande peut être à base d'un microprocesseur ou
microcontrôleur.
d) Exemple de robot mobile :

Figure 1: robot mobile de type voiture.

7
 CONCLUSION :
Nous avons présenté, dans ce chapitre les robots mobiles qui sont des
véhicules, les robots sont utiliser à jouer un rôle de plus en plus important dans
notre vie maie ceci n'annule pas l'existence de certains problèmes pour assurer
une bonne application de ces robots Comme exemples de ces problèmes nous
citons l'analyse de l'environnement, planification, navigation.

8
Chapitre 02 : Généralités sur
la Plateforme Arduino

9
 I. Historique du projet Arduino :

Au début des années 2000, l’initiateur et cofondateur du projet, Massimo Banzi, enseignait
la physique informatique dans l’école Interaction design Institute Ivrea (IDII), dans le nord-
ouest de l’Italie, il apprenait aux étudiants comment utiliser l’électronique pour prototyper
des objets de robotique en utilisant des cartes électroniques assez compliquées, conçues à
l’origine pour des ingénieurs et comptables uniquement avec Windows.
Comme beaucoup de ses collègues, Banzi se reposait sur le BASIC Stamp, un microcontrôleur
crée et utilisé par l’entreprise californienne Parallax, depuis près de 10 ans.

Codé avec langage BASIC, le Stamp était un circuit embarquant essentiellement :

une alimentation, un microcontrôleur, de la mémoire et des ports d’entrée/sortie pour y
connecter du matériel. Mais il n’avait pas assez de puissance de calcul, et il était
relativement cher, de plus Banzi avait besoin de quelque chose qui puisse tourner sur
Macintosh, qui se trouve être omniprésent à l’école.

En 2001, Casey Rea et Ben Fry, deux anciens étudiants du MIT, avaient développé un langage
de programmation intuitif de nom de Processing. Ce langage gagna rapidement en
popularité, parce qu’il permettait aux programmeurs sans expérience de créer des
infographies complexes dans un environnement de développement extrêmement facile à
utiliser, Banzi se demanda s’il pourrait créer un logiciel de développement pour programmer
un microcontrôleur, plutôt que des images sur écran.

Un peu plupart, en 2003 Hernando Barragan, pour sa thèse de fin d’étude, développa un
prototype de plateforme, le Wiring, qui comprenait un environnement de développement
facile à apprendre et une carte électronique prête à l’emploi. C’était un projet prometteur
encore en activité à ce jour. Mais Banzi pensait déjà plus grand, il voulait faire une
plateforme encore plus simple, moins cher et plus facile à utiliser.

Il convia donc David Cuartielles, un confrère qui enseignait en suède, ensemble, ils
réalisèrent la première carte à usage pédagogique. Deux autres étudiants de Banzi se
joignirent au projet. Nicholas Zambetti et David Mellis, ce dernier devient cofondateur et
développeur en chef de la partie logiciel d’Arduino, et ensemble ils ont commencé à
développer le logiciel en s’inspirant du langage Processing et de la carte Wiring.

L’objectif étant de mettre au point une plate-forme rapide et facile d’accès, l’équipe Arduino
croyait fermement et l’open source, puisque elle a longtemps été utilisée pour aider à
l’innovation logiciel. Ils ont aussi eu recourt à une licence Créative Commons, une

10
organisation à but non lucratif dont les contrats sont habituellement utilisés pour les travaux
artistiques.
Grace à ces deux perceptives, ils entamèrent en construisant et en remettant 300 circuits
imprimés vierge (sans composants) aux étudiants de l’IDII avec une consigne simple regarder
les instructions de montage mise en ligne, construire sa propre carte et l’utiliser pour faire
quelque chose. Un des premiers projets était un réveil fait maison suspendu au plafond par
un câble. Chaque fois qu’on pousse le bouton snooze, le réveil montait plus haut d’un ton
railleur jusqu’à ce qu’on ne puisse plus rendormir.

Rapidement, l’histoire d’Arduino se répondait sur la toile. Elle attira l’attention de Tim Igoe,
connu pour être le premier à avoir mis l’ensemble de ses outils pédagogiques en ligne pour
accès libre public. Gianluca Matino fut la dernière pièce du puzzle, un ingénieur d’Ivrea qui a
aidé à l’industrialisation de la production Arduino. Le premier prototype commercialisé était
au cours de l’année 2005, un modèle basé sur l’ATmega8, un microcontrôleur Atmel de la
famille AVR.

Pour accélérer l’adoption d’Arduino, l’équipe cherchait à l’ancrer plus profondément dans le
monde de l’éducation. Plusieurs universités, dont Carnegie Mellon et Stanford, utilisent déjà
Arduino, Mellis a observé comment les étudiants et profanes abordaient l’électronique lors
d’une série d’ateliers au MIT Media lab.
Il a ainsi invité des groupes de 8 à 10 personnes à l’atelier ou le projet à réaliser devait tenir
dans une seule journée. Parmi les réalisations, on peut noter des enceintes pour IPod, des
radios FM, et une souris d’ordinateur utilisant certains composants similaires à ceux
d’Arduino. En 2010 un ces projets furent dévoilés au congrès de New York, leur première
carte à processeur 32 bits, une puce ARM à la place du processeur 8 bits.
Cela a permis de répondre à la demande de puissance des périphériques plus évolués
comme l’imprimante 3D à monter soi-même, basée sur l’Arduino.

11
 II. Découverte de la carte Arduino :
a) ça sert à quoi ?

Figur.2: Interagir avec le monde réel.

b) qu'est-ce que c'est ?
Une plate-forme de développement et de prototypage Open Source.

➢ Le rôle de la carte Arduino est de stocker un programme et de le faire fonctionner.

➢ Shields (cartes d'extension) avec des fonctions diverses qui s'enfichent sur la carte
Arduino :

 Relais, commande de moteurs, lecteur carte SD, ...

 Ethernet, WIFI, GSM, GPS, …
 Afficheurs LCD, Écran TFT, ...

➢ IDE (Environnement de Développement Intégré) multi OS :

 édition du programme
 compilation du programme
 transfert du programme dans la carte via le port USB

12
 Figure 3: Diverses Cartes Arduino.
Un environnement de développement intégré fonctionnant sur divers systèmes
d’exploitation (Windows, Mac OS, Gnu/Linux) qui permet d'éditer le programme sur un
ordinateur et de le transférer via le port usb.
c) comment ça marche ?

Programmation
Langage proche du C.
➢ Programme structuré :
➢ Une section « setup » 1 seule exécution après RàZ ;
➢ Une section « loop » exécutée indéfiniment en boucle.

De très nombreuses librairies logicielles disponibles.

13
Il existe d'autres outils facilitant la programmation.

➢ Ardublock (programmation en mode graphique)

➢ C'est un outil qui se greffe au logiciel Arduino. Il suffit de créer des blocs et de les
paramètrer. Ce logiciel est vraiment un outil de qualité pour démarrer facilement sur
Arduino, sans connaissances en programmation.

Scratch pour Arduino (programmation en mode graphique) Permet de piloter Un Arduino à

partir du code SCRATCH et de ce fait rend accessible à tout public la programmation d’un
robot à partir d’un environnement aussi ludique, visuel et intuitif que celui de SCRATCH.

Figure 4: Scratch pour Arduino.

d) Arduino : faut-il des connaissances en électronique ?
➢ Pas ou peu si on utilise des cartes et des modules tout faits.

➢ La communauté francophone est très active sur le forum. => entraide, tutoriels,
exemples de réalisations, ...

➢ Il faut des connaissances en électronique si on veut optimiser ou faire du sur-mesure.

14
CHAPITRE 03: ETUDE
ET REALISATION.

15
 I. L'objectif :
L'objectif de ce projet d'électronique est de créer un robot détecteur de présence qui se
déplace dans une pièce et évite les obstacles lorsqu'il en rencontre. Les “yeux” du robot sont
un capteur à ultrasons (par exemple HC-SR04). Ce capteur est connecté à une carte Arduino.
Lorsque le capteur envoie l'information à l'Arduino qu'il y a un obstacle devant lui, l'Arduino
doit envoyer une instruction aux moteurs qui contrôlent les roues pour éviter l'obstacle.

II. Diagramme structurel :

III. Matériel nécessaire :

L'idée est d'utiliser une carte Arduino pour lire les données reçues par un, ou plusieurs,
capteur(s) à ultrasons. Lorsque le capteur détecte un obstacle devant lui, l'Arduino doit
envoyer des instructions aux moteurs qui pilotent les roues du robot pour l'éviter.

 1 Arduino Uno
 1 capteur à ultrasons HC-SR04
 un châssis + roue à bille
 Des moteurs DC pour piloter les roues du robot(4)
 Un driver de moteurs DC (par exemple, Dual TB6612FNG (1A))
 Un petit servo-moteur pour faire pivoter le capteur à ultrasons (la tête du robot)
 Une pile de 9V et des connecteurs pour alimenter les moteurs DC.
 des câbles jumper, résistances, LED, une breadboard pour tester le circuit
électronique.

16
 A. Mesurer une distance avec un capteur à ultrason :
a) Comment mesurer une distance :
Pour mesurer des distances, il faut un capteur de distance (s’en blague !). Il existe sur le
marché un grand nombre de capteurs de distance : infrarouge (réflectif), laser (par temps de
parcours ou par calcul d'angle), physique (règles optiques absolues ou incrémentielles), ou
ultrason.

 Les capteurs infrarouges ont l’avantage d’être bon marché, relativement précis et
disponibles à peu près partout. Malheureusement, ils sont assez complexes à mettre
en œuvre du fait de leurs non-linéarités. Il faut appliquer une formule complexe pour
obtenir une mesure utilisable. De plus, ils sont très sensibles à la lumière ambiante et
au coefficient de réflexion lumineuse de la surface en face du capteur.

 Les (vrais) capteurs de distance laser sont extrêmement précis, mais aussi
extrêmement chers. Un capteur de distance laser (par mesure de temps de parcours)
coûte facilement plus de 200€, mais fait des mesures à plus de 30 mètres sans
problème pour certains modèles. C'est donc au final une question de budget /
utilisation.
PS Il existe des (faux) capteurs de distance laser fonctionnant par triangulation. Au lieu de
mesurer le temps d'aller-retour d'un faisceau laser, ces modules calculent l'angle entre le
point du laser et le capteur. Ces modules sont moins chers, mais aussi beaucoup moins
précis.

 Les capteurs physiques, le plus souvent un duo comportant une règle graduée et un
capteur optique, sont à la fois bon marché et très précis. Mais ils sont très limités en
distance mesurable et se retrouvent donc généralement dans des imprimantes.
Reste les capteurs ultrasons, un capteur de distance à ultrason utilise le même principe
qu’un capteur laser, mais en utilisant des ondes sonores (inaudible) au lieu d’un faisceau de
lumière. Ils sont bien moins chers qu’un capteur laser, mais aussi bien moins précis.
Cependant, contrairement aux capteurs à infrarouge, la lumière ambiante et l’opacité de la
surface en face du capteur ne jouent pas sur la mesure.

17
 b) Le capteur HC-SR04 :

Le capteur qui nous intéresse est un capteur à ultrason made in chinois, bien connu des
amateurs de robotique et d'Arduino : le HC-SR04 (aussi disponible sous d'autres références
en fonction du vendeur).
Le capteur HC-SR04 est un capteur à ultrason low cost. Ce capteur fonctionne avec une
tension d'alimentation de 5 volts, dispose d'un angle de mesure de
15° environ et permet de faire des mesures de distance entre 2 centimètres et
4 mètres avec une précision de 3mm (en théorie, dans la pratique ce n'est pas tout à fait
exact).
N.B. Il existe des capteurs à ultrason bien plus haut de gamme (donc précis). Un capteur à
ultrason mono capsule de qualité coûte entre 20€ et 30€. Un capteur
HC-SR04 revient seulement à 3€.

c) Principe de fonctionnement du capteur :

Figure 5: Illustration du signal TRIGGER et ECHO.

 Le principe de fonctionnement du capteur est entièrement basé sur la
vitesse du son.

18
Voilà comment se déroule une prise de mesure : On envoie une impulsion HIGH de 10µs sur
la broche TRIGGER du capteur.
1) Le capteur envoie alors une série de 8 impulsions ultrasoniques à 40KHz (inaudible
pour l'être humain, c'est quand plus agréable qu'un biiiiiiiip).
2) Les ultrasons se propagent dans l'air jusqu'à toucher un obstacle et retourne dans
l'autre sens vers le capteur.
3) Le capteur détecte l'écho et clôture la prise de mesure.
4) Le signal sur la broche ECHO du capteur reste à HIGH durant les étapes 3 et 4, ce qui
permet de mesurer la durée de l'aller-retour des ultrasons et donc de déterminer la
distance.

 N.B. Il y a toujours un silence de durée fixe après l'émission des ultrasons pour éviter
de recevoir prématurément un écho en provenance directement du capteur.

d) Le montage :

Figure 6: Matériel nécessaire.

Pour réaliser ce premier montage, il va nous falloir :

• Une carte Arduino UNO (et son câble USB),

• Un capteur HC-SR04,
• Une plaque d'essai et des fils pour câbler notre montage.

19
 Figure 7: Vue prototypage du montage.
Le montage est d'une simplicité déconcertante :
• L'alimentation 5V de la carte Arduino va sur la broche VCC du capteur.

• La broche GND de la carte Arduino va sur la broche GND du capteur.

• La broche D2 de la carte Arduino va sur la broche TRIGGER du capteur.
• La broche D3 de la carte Arduino va sur la broche ECHO du capteur.

Figure 8: Le montage fini.

20
 e) Le code :

/* Constantes pour les broches */

const byte TRIGGER_PIN = 2; // Broche TRIGGER
const byte ECHO_PIN = 3; // Broche ECHO
/* Constantes pour le timeout */
const unsigned long MEASURE_TIMEOUT = 25000UL; // 25ms = ~8m à 340m/s /* Vitesse du
son dans l'air en mm/us */
const float SOUND_SPEED = 340.0 / 1000;

On commence le code avec quatre constantes : deux constantes pour les broches TRIGGER
et ECHO du capteur, une constante qui servira de timeout pour la prise de mesure et une
constante pour définir la vitesse du son.
Le timeout correspond au temps nécessaire avant de considérer qu'il n'y a pas d'obstacle,
donc pas de mesure possible. J'ai choisi d'utiliser une timeout de 25 millisecondes (4 mètres
aller-retour à 340m/s).
N.B. Vous remarquerez que j'ai déclaré la vitesse du son en millimètres par microseconde.
Cela est nécessaire, car la mesure du temps se fait en microsecondes et je souhaite avoir un
résultat en millimètres en sortie du calcul.

void setup()
{ /* Initialise le port série */
Serial.begin(115200); /* Initialise les broches */
pinMode(TRIGGER_PIN, OUTPUT);
digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
pinMode(ECHO_PIN, INPUT);
}

La fonction setup() initialise le port série, met la broche TRIGGER du capteur en sortie et
à LOW, et met la broche ECHO du capteur en entrée. Rien de bien palpitant.

void loop() {
/* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche T
RIGGER */
digitalWrite(TRIGGER_PIN, HIGH);
delayMicroseconds(10);

21
 digitalWrite(TRIGGER_PIN, LOW);
/* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);
/* 3. Calcul la distance à partir du temps mesuré */
float distance_mm = measure / 2.0 * SOUND_SPEED;
/* Affiche les résultats en mm, cm et m */
Serial.print(F("Distance: "));
Serial.print(distance_mm);
Serial.print(F("mm ("));
Serial.print(distance_mm / 10.0, 2);
Serial.print(F("cm, "));
Serial.print(distance_mm / 1000.0, 2);
Serial.println(F("m)"));

/* Délai d'attente pour éviter d'afficher trop de résultats à la s

econde */
delay(500);
}

La fonction loop() s'occupe de la mesure et de l'affichage.

Elle génère d'abord l'impulsion HIGH de 10µs qui déclenche la prise de mesure. Elle mesure
ensuite le temps nécessaire a pour un aller-retour du signal ultrason avec la fonction pulseIn().
Pour finir, elle calcule la distance avant de l'afficher sur le port série.
N.B. La fonction pulseIn() retourne 0 si le temps de timeout est atteint. Il est donc possible de
gérer l'absence d'obstacle si vous le souhaitez avec un if (measure == 0) { ... } par exemple.
PS La valeur retournée par pulseIn() doit être divisée par deux avant de faire le calcul de
distance. Un aller-retour est égal à deux fois la distance mesurée.

Le code complet avec commentaires : /*

* Code d'exemple pour un capteur à ultrasons HC-SR04.
/* Constantes pour les broches */
const byte TRIGGER_PIN = 2; // Broche TRIGGER
const byte ECHO_PIN = 3; // Broche ECHO
/* Constantes pour le timeout */

22
const unsigned long MEASURE_TIMEOUT = 25000UL; // 25ms = ~8m à 340m/s
/* Vitesse du son dans l'air en mm/us */
const float SOUND_SPEED = 340.0 / 1000;/** Fonction setup() */
void setup() { /* Initialise le port série */
Serial.begin(115200); /* Initialise les broches */
pinMode(TRIGGER_PIN, OUTPUT);
digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
pinMode(ECHO_PIN, INPUT);}/** Fonction loop() */
void loop() { /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur
la broche TRIGGER */
digitalWrite(TRIGGER_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(TRIGGER_PIN, LOW); /* 2. Mesure le temps entre l'envoi de l'impulsion ultraso
nique et son écho (si il existe) */
long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);
/* 3. Calcul la distance à partir du temps mesuré */
float distance_mm = measure / 2.0 * SOUND_SPEED;
/* Affiche les résultats en mm, cm et m */
Serial.print(F("Distance: "));
Serial.print(distance_mm);
Serial.print(F("mm ("));
Serial.print(distance_mm / 10.0, 2);
Serial.print(F("cm, "));
Serial.print(distance_mm / 1000.0, 2);
Serial.println(F("m)")); /* Délai d'attente pour éviter d'afficher trop de résultats à la second
e */
delay(500);
}

23
Figure 9: Montage avec une LED.
La LED doit s'allumer lorsque le capteur “voit” un obstacle à moins de 10 cm.
(ou n'importe quelle distance entre 10 cm et 4 m fixée dans le programme).

24
 B. Piloter des moteurs DC avec une carte TB6612FNG :
a. Le montage :
A l'aide d'une carte électronique Dual TB6612FNG (1A) (motor driver), on peut piloter deux
moteurs DC avec la carte Arduino et leur envoyer des instructions de vitesse et de sens de
rotation.

 Les ports GND doivent être connectés au GND de l'Arduino

 Le port VCC est connecté au port 5V de l'Arduino pour alimenter la puce.
 Pour piloter les moteurs, on utilise une pile de 9V, le + de la pile est connecté à VM et
le - au GND de l'Arduino.
 Les deux connecteurs des moteurs DC doivent branchés sur A01 et A02 pour le
moteur A et B01 et B02 pour le moteur B.
 Les ports de gauche sont les ports qui permettent de contrôler la vitesse et le sens de
rotation des moteurs. Ils sont connectés à des ports digitaux en sortie de l'Arduino.
Notez que les ports PWMA et PWMB contrôlent la vitesse des moteurs en envoyant
une valeur entre 0 et 255 (0 pour une vitesse nulle et 255 pour une vitesse
maximale). Ces ports de sortie doivent donc être des ports PWM de l'Arduino (avec
un ~). Les ports AIN1, AIN2, BIN1 et BIN2 contrôlent le sens de rotation des moteurs
(voir le code ci-dessous).
25
 C. Instructions pour les moteurs :
a. les moteurs DC:
Un moteur DC est un convertisseur électromécanique permettant la conversion
bidirectionnelle d’énergie entre une installation électrique parcourue par un courant continu
et un dispositif mécanique. Les moteurs DC ont ainsi la particularité de pouvoir fonctionner
dans les 2 sens, suivant la manière dont le courant lui est soumis. Les moteurs DC sont
pilotés par un contrôleur moteur. Les contrôleurs de moteurs électriques permettent de
piloter un moteur en vitesse, en position ou en couple en fournissant la puissance électrique
et le signal adéquat.

Figure 10: Moteur DC.

b. Le montage :
Maintenant que l'on sait comment lire les données de distance du capteur à ultrasons et
comment piloter les moteurs, nous pouvons maintenant combiner les scripts précédents
pour donner les instructions aux moteurs du robot. Il faut aussi modifier le montage pour
incorporer le capteur à ultrasons et les moteurs.

26
Lorsqu'il ne voit pas d'obstacles devant lui, c'est-à-dire si le capteur à ultrasons retourne une
distance supérieure à 20 cm (par exemple), le robot avance tout droit. Les instructions à lui
donner sont donc :

move(1, 100, 1); //motor 1, full speed, left

move(0, 100, 1); //motor 2, full speed, left
Lorsque le robot voir un obstacle, on le fait s'arrêter avec l'instruction stop, puis reculer
pendant 3s en faisant tourner les moteurs dans le sens opposé :

move(1, 50, 0); //motor 1, recule

move(0, 50, 0); //motor 2, recule
delay(3000); // recule pendant 2s
Enfin, on fait tourner le robot en faisant tourner ses deux roues dans un sens opposé
pendant 1.5s, avant de s'arrêter et de repartir tout droit. Pour chaque manœuvre, on calcule
un nombre aléatoire entre 0 et 100. Si le nombre est inférieur à 50, on tourne à gauche
sinon on tourne à droite.

randNumber = random(100.0); // On fait tourner le robot dans une direction aléatoire

if (randNumber < 50.0) {
move(1, 100, 1); //motor 1, tourne à gauche
move(0, 100, 0); //motor 2, tourne
} else {
move(1, 100, 0); //motor 1, tourne à droite
move(0, 100, 1); //motor 2, tourne
}
delay(1500); // tourne pendant 1s
stop(); // Stopper les moteurs
La partie programmation est maintenant presque terminée. On peut à l'avenir rajouter un
servo-moteur sur lequel on fixe le capteur à ultrasons pour balayer une zone plus large de
vision devant le robot. On peut aussi rajouter un capteur à ultrasons derrière le robot pour
éviter que le robot ne recule sur un mur. En effet, tel que le code est maintenant écrit, le
robot ne “regarde” pas lorsqu'il manœuvre.
Placer le capteur à ultrasons en hauteur par rapport au sol (au moins 10 cm) sinon le capteur
verra le sol comme un obstacle.

27
Les deux roues motrices du robot sont situées à l'avant du robot. Pour la stabilité, il faut
mettre au moins une roue à l'arrière. Il est en fait plus judicieux de ne mettre qu'une seule
roue et avec une petite surface de contact avec le sol pour qu'il y ait peu de frottement
lorsque le robot fait une manoeuvre. S'il y a trop de frottement, le robot risque de
mal tourner, voire de ne pas tourner du tout…
J'ai utilisé un module d'alimentation 5V pour Arduino que l'on peut alimenter
avec une pile 9V, ce qui permet au robot d'être indépendant (sans connection
avec l'ordinateur).
D. Code complet :
/* Code pour piloter des moteurs quand le capteur à ultrasons détecte un obstacle */
/* Robot éviteur d'obstacles */

//Moteur A connecté entre les pins A01 et A02 du Motor Driver TB6612FNG
//Moteur B connecté entre les pins B01 et B02 du Motor Driver TB6612FNG

int STBY = 10; // standby Pin (si HIGH alors on peut faire tourner les moteurs, si LOW, les
moteurs s'arrêtent)

//Motor A
int PWMA = 5; //Pin qui contrôle la vitesse du moteur A (nombre entre 0 et 255 donc on
doit le mettre sur un port PWM)

// AIN1 et AIN2 sont les pins de sens de rotation du moteur A

// Le moteur A tourne dans le sens horaire si le pin AIN1 est LOW et le pin AIN2 est HIGH
// Inversement, si AIN1 est HIGH et AIN2 est LOW, il tourne dans le sens antihoraire
// (si les deux sont LOW ou les deux sont HIGH, il ne tourne pas)
int AIN1 = 9; //Sens de rotation

int AIN2 = 8; //Sens

//Motor B
int PWMB = 6; //Pin qui contrôle la vitesse du moteur B
// Pins de sens de rotation du moteur B
int BIN1 = 11; //Sens

28
int BIN2 = 12; //Sens

/* Constantes pour les broches */

const byte TRIGGER_PIN = 2; // Broche TRIGGER
const byte ECHO_PIN = 3; // Broche ECHO
const byte LED_PIN = 7; // Broche LED

/* Constantes pour le timeout */

const unsigned long MEASURE_TIMEOUT = 50000UL; // 25ms = ~8m a 340m/s

/* Vitesse du son dans l'air en mm/microsecondes */

const float SOUND_SPEED = 340.0 / 1000;

long randNumber;

/** Fonction setup() */

void setup() {

/* Initialise le port serie */

Serial.begin(115200);

/* Capteur Ultrasons */
// Initialise les broches pour le capteur à ultrasons

pinMode(TRIGGER_PIN, OUTPUT);
digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit etre LOW au repos
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
pinMode(ECHO_PIN, INPUT);

/* Moteurs */
// On définit tous les ports comme sorties pour piloter les moteurs

29
 pinMode(STBY, OUTPUT);
// Commandes Moteur A

pinMode(PWMA, OUTPUT);
pinMode(AIN1, OUTPUT);
pinMode(AIN2, OUTPUT);
// Commandes Moteur B
pinMode(PWMB, OUTPUT);

pinMode(BIN1, OUTPUT);
pinMode(BIN2, OUTPUT);

void loop() {
move(1, 100, 1); //motor 1, full speed, left
move(0, 100, 1); //motor 2, full speed, left

/* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10 microsec sur
la broche TRIGGER */

digitalWrite(TRIGGER_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(TRIGGER_PIN, LOW);
/* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son echo (s'il existe) */
long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);

/* 3. Calcule la distance à partir du temps mesuré */

float distance_mm = measure / 2.0 * SOUND_SPEED;

if (distance_mm / 1000 < 0.2) {

digitalWrite(LED_PIN, HIGH); // si un obstacle est à moins de 30 cm

stop(); // Stopper les moteurs

delay(2000); //hold for 250ms until move again

30
 move(1, 50, 0); //motor 1, recule
move(0, 50, 0); //motor 2, recule

delay(3000); // recule pendant 2s

stop(); // Stopper les moteurs
delay(1000); //hold for 250ms until move again

// On fait tourner le robot dans une direction aléatoire

randNumber = random(100.0);
if (randNumber < 50.0) {
move(1, 100, 1); //motor 1, tourne à gauche
move(0, 100, 0); //motor 2, tourne
} else {

move(1, 100, 0); //motor 1, tourne à droite

move(0, 100, 1); //motor 2, tourne
}
delay(1500); // tourne pendant 1s
stop(); // Stopper les moteurs

delay(1000); //hold for 250ms until move again

digitalWrite(LED_PIN, LOW);
}
// // Affiche les résultats en m

// Serial.print(F("Distance: "));
// Serial.print(distance_mm / 1000.0, 2);
// Serial.println(F("m)"));

/* Délai d'attente pour éviter d'afficher trop de résultats à la seconde */

delay(200);

31
}

void move(int motor, int speed, int direction) {

// Function move(): Move specific motor at speed and direction
//
// Inputs:
// motor: 0 for B and 1 for A

// speed: number between 0 and 255: 0 is off, and 255 is full speed
// direction: 0 clockwise, 1 counter-clockwise

// DEMARRAGE
digitalWrite(STBY, HIGH); //On met ce Pin sur HIGH avant de démarrer les moteurs

// SENS DE ROTATION
// Sens Horaire
// Le moteur A tourne dans le sens horaire si le pin AIN1 est LOW et le pin AIN2 est HIGH
(si les deux sont LOW ou les deux sont HIGH, il ne tourne pas)
boolean inPin1 = LOW;

boolean inPin2 = HIGH;

// Sens Anti-Horaire
if (direction == 1) { // Si on change la direction dans le sens antihoraire
inPin1 = HIGH;
inPin2 = LOW;

// ENVOI DES INSTRUCTIONS DE SENS DE ROTATION ET DE VITESSE AUX MOTEURS

if (motor == 1) { // MOTEUR A
digitalWrite(AIN1, inPin1);

digitalWrite(AIN2, inPin2);
analogWrite(PWMA, speed);
} else { // if motor == 0 (MOTEUR B)
32
 digitalWrite(BIN1, inPin1);
digitalWrite(BIN2, inPin2);

analogWrite(PWMB, speed);
}
}

void stop() {

//Function stop(): Appeler cette fonction dans le programme pour stopper les moteurs
digitalWrite(STBY, LOW);
}

33
Chapitre 04:PRÉ-ÉTUDE de
bras robot MeArm

34
 A. Introduction :
MeArm est une version miniature d’un bras de robot industriel. Il a été conçu pour rendre
accessible la robotique, l’électronique et la programmation, en réduisant le coût de la
possession du bras robot. C’est l’outil d’apprentissage robotique le plus accessible au
monde. Il peut être contrôlé par n’importe quel microcontrôleur qui peut gérer les
servomoteurs (qui fournit un signal PWM). Le MeArm est composé d’une structure en
acrylique (ou bois, etc.) d’une quantité de boulons écrous (40 boulons et 11 écrous) de
diamètre 3mm, de quatre servomoteurs 9g, qui sert d’actionneurs, d’une carte de contrôle
(carte Arduino dans notre cas), et d’un moyen de contrôle tel que joystick (ou peut être
potentiomètres ou boutons).
Dans ce chapitre, nous allons présenter les étapes de réalisation de notre bras de robot
MeArm, qui est un prototype d’un système embarqué open source.

Après l’acquisition de tout le matériel et logiciel, nous pouvons enfin passer à l’assemblage,
mais avant cela il faut comprendre les schémas de câblage et nous devonscalibrer les
servomoteurs, puis nous pouvons passer à l’assemblage des pièces en suivant les
instructions fournit par le guide de MeArm.
Il y a plusieurs moyens de contrôler le MeArm, nous allons proposer quelques une en
exemples d’application et d’autre en perspectives.

B. Pièces et composants :
Dans cette partie nous allons présenter les composants et pièces nécessaires pour la
réalisation de bras articulé MeArm et leurs rôles dans ce prototype. Cette partie comporte
trois aspects, aspect mécanique, électronique et logiciel.

1) Partie mécanique :

Figure 11: Les pièces de MeArm.

35
 2) Partie électrique et électronique :
Dans cette partie nous allons présenter les composants électriques et électroniques utilisés
pour la réalisation de notre projet.

a. Carte Arduino Mega2560 :

Nous avons choisi d’utiliser la carte Arduino Mega2560, vu qu’elle répond suffisamment à
nos exigences et l’évolutivité du projet. Cette carte sera utilisée pour le contrôle des quatre
servomoteurs, par deux Joysticks.

b. Servomoteur Tower Pro SG90 :

Les caractéristiques du SG90 sont les suivantes :

- Dimensions : 22*11.5*27mm.
- Poids : 9 grammes.
- tension d’alimentation : 4.8 à 6 V.
- Vitesse : 0.12 s / 60°sous 4.8V.
- couple : 1.2 Kg/Cm sous 4.8V.

- Amplitude : de 0° à 180°.

Figure 12: Le servomoteur Tower Pro SG90.

Marron Masse
Rouge +5V
Orange Commande

c. Joystick (manette) :
Le joystick est composé de deux potentiomètres qui nous permettent de régler le
mouvement (des servomoteurs dans notre cas). Le Joystick analogique à 2 axes fournit un
moyen simple et pratique d’ajouter le contrôle sur deux axes X et Y. Un potentiomètre
attaché à chaque axe fournit une rétroaction proportionnelle des positions Haut/Bas et
Gauche/Droit.

36
Le Joystick est chargé par un ressort, de sorte qu’il revient toujours dans sa position centré
lorsque nous le relâchons. De plus, un commutateur est inclus dans le Joystick.

Figure 13: Joystick analogique à 2 axes et son branchement à la carte Arduino.

d. Module d’alimentation YwRobot :
C’est un module d’alimentation basé sur un régulateur de tension qui offre deux
connecteurs de tension double 5V et 3,3V et une prise USB. La tension d’entrée doit se situer
entre 6.5 à 12 V. Il s’agit d’un modèle d’alimentation fixe non réglable. Le courant de sortie
maximum est de 700 mA.

Figure 14: Module d’alimentation YwRobot.

e. Source d’alimentation :
Nous allons utiliser une pile de 9V comme source d’alimentation.

Figure 15: Batterie 9 volts.

37
 3) Assemblage du MeArm :
a) Câblage des servomoteurs:

Figure 16: Schéma de câblage des servomoteurs à la carte Arduino et à

l’alimentation.
Attention, prévoir une puissance suffisante sur cette seconde alimentation : le traditionnel
boitier de piles est un peu juste, il vaut mieux lui préférer un bloc prise 200VAC / 6VCC.
Attention, au moment des branchements, il vaut mieux tout brancher sauf l’alim des
servomoteurs, télé verser le code et ensuite seulement alimenter les servomoteurs.

b) Calibrage des servomoteurs :

Avant de commencer l’assemblage des pièces, nous devons effectuer une étape très
importante, calibrer les quatre servomoteurs à des angles précises. Nous positionnons les
servomoteurs à ces angles : middle, left et right à 90 degré et claw à 35 degré à l’aide de
programme suivant :

38
A l’aide d’un marqueur, nous traçons le centre de l’axe et de corps de chaque servomoteur
(comme indiquer sur la figure ci-dessous).

Figure 17: le tracé de centre des servomoteurs.

c) Assemblage des pièces :
Nous arrivons maintenant à l’assemblage des pièces. Pour cette patrie nous n’avons qu’à
suivre les étapes expliquer dans le guide d’assemblage fournit par le constructeur de
MeArm.
Les figures Illustrent les étapes principales de montage.

39
 Figure 18: les pièces à assembler.

Figure 19: La base du bras MeArm.

Figure 20: La pince de MeArm.

Figure 21: Les quatre parties qui portent les servomoteurs.

40
Figure 22: MeArm avant le montage de la pince

Figure 23: MeArm final.

41
 4) Programmation du MeArm :
Le contrôle de MeArm est très simple, il se fait à l’aide des deux joysticks, chaque axe gère
un servomoteur. Pour bouger un des servomoteurs il suffit d’actionner l’axe correspondant.
Les servomoteurs middle, left et right bouge dans l’intervalle de 0 à 180 degré, mais le servo
claw ne bouge que dans l’intervalle de 0 à 70 degré. Ils bougent dans les deux sens. Ce
programme nous permet de contrôler le bras articulé par deux Joysticks, il comporte trois
parties.

a) Partie déclarative :
Dans cette partie nous commencer par l’inclusion de librairie <Servo> pour pouvoir utiliser
ses fonctions. Puis :

 Déclaration de quatre variables de type Servo ; middle, left, right et claw.

 Déclaration de quatre variables entières qui vont nous servir pour stocker les valeurs
lue sur les axes joysticks.
 Déclaration de quatre variable entières vont stocker les valeurs précédentes après
conversion en angles en degré.

42
 b) La fonction de configuration setup :
Dans cette étape nous activons le port série, puis nous attachons les objets Servo créé
précédemment à leurs broches numériques correspondantes.

c) La boucle principale loop :

Dans cette boucle nous effectuons la lecture des valeurs analogiques renvoyés par les axes
de deux joysticks, puis nous les convertirons aux angles en degré et en enfin nous les
affichons sur le moniteur série.

43
 5) Commande autonome de MeArm :
Le but ici est de programmer le MeArm pour qu’il procède d’une manière autonome en
exécutant une tâche répétitive. Connaissant la position d’objets à prendre et la position ou
le déposer, nous pouvant le programmer pour déplacer des objets automatiquement.
Dans la partie déclarative, la première chose est toujours l’inclusion de la librairie « Servo »,
puis la déclaration des quatre objets Servo, et final la déclaration des quatre variable
entières.
La fonction d’initialisation se résume ici à l’attachement des variables de type <Servo> à
leurs broches numériques correspondantes.

La boucle principale loop :

Création d’une boucle incrémentale pour chaque servomoteurs (allant de 0 à 180 pour
middle, left et right et 0 à 70 degré pour claw) qui a pour paramètre un entier, que nous
utilisons comme angle consigne envoyer aux servo. Ensuite, on fait l’inverse de chemin avec
des boucles décri mentale.

44
45
 Conclusion :

Grace à sa philosophie d’open source, MeArm se propage de plus en plus dans le

monde, et il a connu un développement remarquable d’une version à une autre.
Cette philosophie et le faible coût de la réalisation, lui permettent d’être à porter de
l’éducateur, étudiant, etc.
Nous avons présenté les aspects matériel et logiciel d’Arduino, en insistant sur les
méthodes de commande des servomoteurs. Et la dernière partie nous apprend
comment réaliser son propre prototype de bras Articulé MeArm contrôlé par Arduino.
Ce projet nous a permis de réaliser une maquette de travaux pratique pour
l’apprentissage de l’Arduino et des bras robot. Arduino et MeArm sont nés dans les
mêmes objectifs, deux outils (plate-forme et prototype) d’apprentissage open source,
qui ont remédié aux problèmes majeurs d’apprentissage.

46
 Conclusion générale :

L'objectif de notre travail est la réalisation d'un robot mobile type voiture avec évitement
d'obstacles en utilisant des capteurs de distances (ultrason) ainsi que l'application d'une
intelligence artificielle, la logique floue dans notre cas. Notre robot se déplace sous une
trajectoire programmée d'avance.

Pour réaliser ce travail, on est passé par différentes étapes :

On a utilisé un capteur ultrasonique HC-SR04 pour la détection des obstacles et le calcul de
la distance entre le robot et l'obstacle. Le robot réalisé se déplace par 2 roues ; les deux
roues s’occupent du mouvement par deux moteurs DC.
Nous avons utilisé ce type de moteur pour la précision dans le déplacement et la rotation
vers la cible.

Des circuits de commande son réalisés afin de contrôler les moteurs associes. L'ensemble de
système de perception et de déplacement est commandé par un microcontrôleur qui doit en
utilisant les informations actuelles, décider l'action à prendre. Pour notre cas ; on a utilisé le
microcontrôleur célèbre, la carte arduino uno, dont ses caractéristiques particulières nous
ont aidé à faciliter les taches surtout en ce qui concerne sa programmation.
Ce travail nous a permis de traiter des problèmes d'ordre pratique et de vérifier des
connaissances théoriques acquises toute le long de notre formation.
Grâce au travail continu, on a peu atteindre notre but et satisfaire le cahier de charge, mais
cela ne veut pas dire qu'il est complet, nous proposons que le robot réalisé soit la base de
toute une série d'améliorations que nous n'avons pas eu la chance de les faire par manque
de temps et de matériel. Le nombre d'améliorations que peuvent être ajoutes sont :
Utilisation de capteurs plus performants comme les capteurs laser ou les caméras et d'utilisé
plus de capteurs ou un plateau de capteurs rotatif pour couvrir l'environnement pour choisir
meilleur trajectoire, L'utilisation d'un microcontrôleur de nouvelle génération comme le uC
Atemel (atmega), l'utilisation des moteurs pas à pas avec plus de pas pour avoir une grande
précision dans le mouvement du robot.

47
 Références :

https://www.tubefr.com/
https://fr.scribd.com/presentation/371275588/
http://robotique.e-monsite.com/annuaire/
https://arduino.stackovernet.com/
https://www.tutorialspoint.com/arduino/
https://create.arduino.cc/projecthub/benoitdr/max009-
7888a4?ref=platform&ref_id=424_trending___&offset=137

48