COMMANDE D’UN BRAS

ROBOTISE AVEC UNE

APPLICATION ANDROID
Université de Lorraine Faculté des sciences et technologies de Nancy

2018/2019
YACINE TAZEROUT
SOMMAIRE

TABLE DES FIGURES .................................................................................................................................0

INTRODUCTION GENERAL .......................................................................................................................1

CHAPITRE I................................................................................................................................................2
INTRODUCTION ....................................................................................................................................2
DEFINITION D’UN ROBOT INDUSTRIEL .................................................................................................2
LES DIFFERENTS TYPES DE BRAS MANIPULATEUR ...............................................................................2
DEUX GROUPES ................................................................................................................................3
AXES DE LA ROBOTIQUE ...................................................................................................................3
LES CLASSES ......................................................................................................................................3
CHAINE CINEMATIQUE .....................................................................................................................4
ARCHITECTURE .................................................................................................................................5
DOMAINES D’APPLICATION DES ROBOTS MANIPULATEUR .............................................................. 10
CONSTITUTION D’UN ROBOT MANIPULATEUR ................................................................................. 10
CONCLUSION ..................................................................................................................................... 14

CHAPITRE II ........................................................................................................................................... 15
INTRODUCTION ................................................................................................................................. 15
CONCEPTION MECANIQUE ................................................................................................................ 15
SOLIDWORKS ................................................................................................................................. 15
L’IMPRESSION 3D .......................................................................................................................... 18
LE MONTAGE ................................................................................................................................. 19
REALISATION DE L’APPLICATION ANDROID....................................................................................... 22
MIT APP INVENTOR ....................................................................................................................... 22
REALISATION DE L’APPLICATION ................................................................................................... 22
PARTIE ELECTRONIQUE ..................................................................................................................... 28
ARDUINO ....................................................................................................................................... 28
LE MODULE HC-05 ......................................................................................................................... 29
LES SERVOS MOTEURS .................................................................................................................. 29
SCHEMA GENERAL......................................................................................................................... 32
CONCLUSION ..................................................................................................................................... 32
CHAPITRE III .......................................................................................................................................... 33
INTRODUCTION ................................................................................................................................. 33
EXPLICATION DU CODE ARDUINO ..................................................................................................... 33
PARTIE DECLARATION DES VARIABLE ........................................................................................... 33
PARTIE CONFIGURATION............................................................................................................... 34
PARTIE DE BOUCLE ........................................................................................................................ 35
TEACH MODE ..................................................................................................................................... 39
HACK DES MOTEURS ..................................................................................................................... 39
COMMANDE DES MOTEURS ......................................................................................................... 40
UTILISATION DES BOUTONS .......................................................................................................... 41
SCHEMA GENERAL......................................................................................................................... 41
CONCLUSION ..................................................................................................................................... 42

CONCLUSION GENERAL ........................................................................................................................ 44

BIBLIOGRAPHIE ..................................................................................................................................... 45
ANNEXES ............................................................................................................................................... 46
CHAPITRE I :

Figure I.1 Structure ouverte simple ........................................................................................................ 4

Figure I.2 Structure arborescente ........................................................................................................... 4
Figure I.3 Structure fermée ..................................................................................................................... 5
Figure I.4 Structure fermée simple ......................................................................................................... 5
Figure I.5 Robot parallèle ........................................................................................................................ 5
Figure I.6 Structure anthropomorphe..................................................................................................... 6
Figure I.7 Robot anthropomorphe .......................................................................................................... 6
Figure I.8 Structure SCARA ...................................................................................................................... 6
Figure I.9 Robot anthropomorphe .......................................................................................................... 6
Figure I.10 Structure cartesienne ............................................................................................................ 6
Figure I.11 Robot cartésien ..................................................................................................................... 6
Figure I.12 Structure sphérique .............................................................................................................. 7
Figure I.13 Robot sphérique Unimate0 ................................................................................................... 7
Figure I.14 Strucutre cylindrique............................................................................................................. 7
Figure I.15 Robot cylindrique .................................................................................................................. 7
Figure I.16 Example structure de robot pleinement paralleles plans ..................................................... 8
Figure I.17 Structure Delta ...................................................................................................................... 8
Figure I.18 Robot type Delta ................................................................................................................... 8
Figure I.19 Structure hexapode............................................................................................................... 9
Figure I.20 Robot simulateur de vol type hexapode ............................................................................... 9
Figure I.21 Constituant d’un bras manipulateur ................................................................................... 11
Figure I.22 Exemple de SMA ................................................................................................................. 11
Figure I.23 Exemple de liaisons mécanique .......................................................................................... 12

CHAPITRE II :

Figure II.1 Logo SolidWorks ................................................................................................................... 16

Figure II.2 Vue sur coté du bras ............................................................................................................ 17
Figure II.3 Vue de haut du bras ............................................................................................................. 17
Figure II.4 Vue éclaté du bras................................................................................................................ 18
Figure II.5 Rendu final du bras .............................................................................................................. 18
Figure II.6 logiciel ideaMaker ................................................................................................................ 19
Figure II.7 Impression 3D ...................................................................................................................... 19
Figure II.8 base du bras Figure II.9 dessous de l'épaule ...................................................................... 20
Figure II.10 base et épaule du bras ....................................................................................................... 20
Figure II.11 avant-bras .......................................................................................................................... 21
Figure II.12 Pince du bras ...................................................................................................................... 21
Figure II.13 poignet du robot ................................................................................................................ 21
Figure II.14 bras principal ...................................................................................................................... 21
Figure II.15 App Inventor LOGO ............................................................................................................ 23
Figure II.16 Partie Designer d'AppInventor........................................................................................... 23
Figure II.17 Partie Blocks de AppInventor ............................................................................................. 24
Figure II.18 Block Bluetooth 1 ............................................................................................................... 24
Figure II.19 Block Bluetooth 2 ............................................................................................................... 24
Figure II.20 Block Bluetooth 3 ............................................................................................................... 25
Figure II.21 Block Bluetooth 4 ............................................................................................................... 25
Figure II.22 Block Bluetooth 5 ............................................................................................................... 25
Figure II.23 Block Contrôle 1 ................................................................................................................. 26
Figure II.24 Block Contrôle 2 ................................................................................................................. 26
Figure II.25 Block Contrôle 3 ................................................................................................................. 26
Figure II.26 Block bouton SAVE ............................................................................................................. 27
Figure II.27 Block bouton RUN .............................................................................................................. 27
Figure II.28 Block bouton RESET ........................................................................................................... 28
Figure II.29 Robot Arm Command APP ................................................................................................. 28
Figure II.30 Arduino UNO ...................................................................................................................... 29
Figure II.31 Branchement du HC-05 ...................................................................................................... 30
Figure II.32 système boucle ferme servo moteur ................................................................................. 30
Figure II.33 composition d'un servo moteur ......................................................................................... 31
Figure II.34 Contrôle en PWM............................................................................................................... 32
Figure II.35 Schéma branchement servo moteur ................................................................................. 32
Figure II.36 Schéma fonctionnel final ................................................................................................... 33

CHAPITRE III :

Figure III.1 Logo Arduino ....................................................................................................................... 33

Figure III.2 Partie d'déclaration des variables ....................................................................................... 34
Figure III.3 fonction initBroches ............................................................................................................ 35
Figure III.4 fonction initPositionInitial ................................................................................................... 35
Figure III.5 Partie configuration ............................................................................................................ 35
Figure III.6 Fonction rotation() .............................................................................................................. 36
Figure III.7 fonction save() .................................................................................................................... 37
Figure III.8 fonction Run() ..................................................................................................................... 38
Figure III.9 fonction Reset()................................................................................................................... 39
Figure III.10 Section loop() .................................................................................................................... 39
Figure III.11 Soudure sur le MG996R .................................................................................................... 40
Figure III.12 Soudure sur le SG90 .......................................................................................................... 40
Figure III.13 Schéma moteur avec feedback ......................................................................................... 41
Figure III.14 Schéma branchement boutons ......................................................................................... 42
Figure III.15 Schéma final du montage ................................................................................................. 43
 Introduction
L’homme a toujours cherché à améliorer sa condition, à alléger son travail, à suppléer à ses
défaillances et a ses faiblesses.
Depuis la Préhistoire, l’homme a créé puis perfectionné ses outils prolongeant son bras pour
la chasse, la pêche, la manipulation d’objet lourds. Dans l’antiquité grecque et byzantine,
Archytas et Heron l’Ancin ou d’Alexandrie conçoivent déjà des automates. Descartes dessine
des automates, mot que l’on doit sans doute à Rabelais. Léonard de Vinci nous laisse une
multitude de plans de machines et de divers mécanismes.
Vers 1770, la construction de machines simple et leur mécanisation marquent le départ de la
révolution industrielle en Europe. Au début du vingtième siècle, des machines automatiques
fixes et des chaines de montage permettent de développer la production de masse. Les cycles
d’usinage et de montage sont simples, répétitifs, a cadences fixes.
Après la seconde guerre mondiale, tout s’accélère. Des conceptions de plus en plus complexes
naissent, elles associent un grand nombre de technologies pour créer des systèmes qui
remplacent l’homme dans toutes ses taches. Apparaissent alors, les machines-outils munies de
commandes automatiques rudimentaires
Au début des années 1950 une nouvelle ère de l’automatisation voit le jour, avec la
conception des premières machines à commande numérique a changement de programmes.
Avec le développement de la technologie des micro-ordinateurs, de l’informatique, de la
commande, et des systèmes de transmission et communication, La robotique voit le jour en
1960.
Dans les dernières années, la robotique a connu un essor tout à fait exceptionnel. Ainsi,
diverses organisations dans le secteur public et privé se sont orientées davantage vers le
domaine de la recherche et du développement des applications en robotique.
Cela s’explique par les avantages qu’elle apporte dans différents domaines économiques et
scientifiques.
Plus précisément les robots industriels, qui sont l’outil incontournable aux entreprises pour se
développer. Ces robots, sont exceptionnels en termes de polyvalence, de fiabilité, de sécurité
ou encore de rentabilité. Ces machines entraînent une destruction massive des emplois dans la
plupart des pays qui les utilisent. Pour les entreprises, les robots industriels sont à l’image du
salarié parfait. Ils travaillent rapidement et peuvent réaliser des tâches répétitives tout au long
de la journée mais aussi pendant la nuit, et dans des conditions qui ne sont pas toujours facile
à vivre pour les salariés
L’acquisition d’un robot industriel (bras robotisé) à des fins de développement et de recherche
revient très cher. Ceci est dû essentiellement au cout élevé de la conception de tels systèmes.
Il devient intéressant et nécessaire de développer son propre bras robotisé. Ce qui conférera
une certaine autonomie et permettra d’acquérir une compétence certaine, qui contribuera à un
gain énorme sur plusieurs niveaux

1
 Chapitre I

I.1 Introduction :
En grec ancien, automate signifie : « machine imitant les mouvements et les fonctions d’un
corps ». Le terme « robot » quant à lui vient du tchèque « robota » : travail forcé, pour
désigner des ouvriers artificiels. Il apparait en 1924 dans la piece « les robots universels de
Rosseum » de karel Capek, auteur tchèque de nouvelle, de romans, de drames, satires des
travers humains.
Le dictionnaire nous donne plusieurs définitions du mot robot : Dans les œuvres de science-
fiction, machine à l'aspect humain, capable de se mouvoir, d'exécuter des opérations, de
parler. Appareil automatique capable de manipuler des objets ou d'exécuter des opérations
selon un programme fixe, modifiable ou adaptable. Personne qui agit de façon automatique.
De nombreux ouvrages ont déjà donné des informations sur l’origine de la robotique et du
terme robot. Ce mot est tombé dans le sens commun. Pour beaucoup, il s’agit d’une machine
anthropoïde qui, par sa forme, tente de ressembler à un être humain et par ses capteurs
intégrés à son comportement. Depuis plus d’une décennie ces machines, qui existent aussi
sous la forme de jouets donnent une fausse idée sur ce qu’elles sont réellement aujourd’hui,
sur leur développement, tout particulièrement dans le domaine industriel ou elles ont pris leur
essor.
Dans ce premier chapitre, nous allons introduire quelques notions générales relatives aux
robots manipulateurs, notamment leur définition, leur classification, leurs structures, leurs
applications, ensuite, nous présenterons la fonction perception de l’environnement dans la
robotique industriel et les différents capteurs et moteurs utilisés pour l’accomplissement de
cette fonction.

I.2 Définition d’un robot industriel :

D’une façon plus générale, nous pouvons utiliser la définition du robot manipulateur donnée
par la norme ISO 8373 [ISO 94b]. Celle-ci définit le manipulateur comme : « une machine, un
mécanisme constitué normalement d’une série de segments qui sont reliés par une articulation
assurant une rotation ou une translation relative entre segments, dont le but est de prendre et
déplacer des objets (pièces ou outils) avec plusieurs degrés de liberté. Il peut être commandé
par un opérateur, une unité de commande électronique ou un système logique (dispositif a
cames, relais, câbles, etc.) [1]

I.3 Les différents types de bras manipulateur :

Nous pouvons regrouper les types de bras manipulateur d’après plusieurs critères ou
caractéristiques comme, les axes d’utilisation, les classes et catégories, par rapport aux degrés
de liberté, aux types d’architectures, et aux différentes structures générées.

2
I.3.1 Deux groupes :
On peut déjà distinguer en général deux groupes de robots
- Le premier passif, est aveugle, accomplissant son devoir sans recourir aux
informations du monde extérieur, et évolue en boucle ouverte par rapport à son
environnement, une fois la phase d’apprentissage terminé, il reproduit toujours les
mêmes gestes, dans le même ordre, ce sont des manipulateur dépourvus de tout sens.
- Le deuxième actif, est interactif, une fois la phase d’apprentissage termine il
s’adapte suivant les paramètres désirés, et les paramètres de l’environnement, dans le
quelle il évolue en boucle fermée, Ce sont ces machines que l’on peut appeler robots,
c’est le début de l’intelligence artificielle. [2].

I.3.2 Axes de la robotique :

a) Les robots de coopérations : sont sous le contrôle direct de l’homme
b) Les robots de substitution : peux intelligent, opèrent seuls après programmation
c) Les robots d’aide à la conception : conception et fabrication d’autres machines ou
robot, assistés par ordinateur
d) Les robots à architecture spéciale : conçus à partir d’observations de l’homme et des
animaux.
I.3.3 Les classes :
Les classes énumérées ci-dessous sont données par les institutions suivante :
- J.I.R.A (Japan industriel Robot – Industry Association)
- R.I.A (Robot Institute of America)
- A.F.R.I (Association Française de Robots Industriels)
Les classes sont les suivantes :
• Le manipulateur manuel
• Le robot à séquences de travail fixes
• Le robot à séquences de travail variable, évolutives
• Le robot copieur ou play-back
• Le robot à commande programmable numérique
• Le robot intelligent capable de s’adapter aux changements des conditions de travail et
de l’environnement tout en continuant à accomplir sa tache
Cette dernière catégorie de robots est dotée d’un grand nombre de capteurs proprioceptifs,
et extéroceptifs : capteurs d’efforts, de position, de vitesse, d’accélération, de vision
tridimensionnelle, de reconnaissance de formes, de couleurs, de sons, de température…
Une reconnaissance olfactive est possible grâce a des réactions ou analyses chimiques.
Des capteurs spécifiques étudient la saisie, le maintien, le glissement, le renversement.
L’intelligence artificielle permet la gestion complète des trajectoires avec adaptation aux
événements imprévus, ainsi que la résolution de problèmes, voire la démonstration de
théorèmes. [2]

3
I.3.4 Chaine cinématique :
Un robot-manipulateur est constitué par deux sous-ensemble distinct, un (ou plusieurs)
organe terminal et une structure mécanique articulée :
- Un organe terminal est tout dispositif destiné à manipuler des objets ou a le
transformer, il permet au robot d’interagir avec son environnement, il peut être
multifonctionnel (plusieurs dispositifs avec fonctionnalité différentes),
monofonctionnel interchangeable, ou multi-bras.
- La structure mécanique articulée amènera l’organe terminal dans une position et
orientation donnée. Son architecture est une chaine cinématique de corps généralement
rigides, assemblés par des articulations. Les chaines peuvent être :
o Structure ouverte simple

Figure I.1 Structure ouverte simple

o Structure arborescente ou polyarticulaire

Figure I.2 Structure arborescente

o Structure fermée : En général, on distingue deux classes de boucles fermées

 Les chaines cinématique composées ou complexes (au moins deux
liaisons)

Figure I.3 Structure fermée

4
  Les chaines cinématique élémentaires ou simples (au plus deux
liaisons)

Figure I.4 Structure fermée simple

o Robots parallèles : Une génération différente de robots, ici l’organe terminal

est relié à la base du mécanisme par plusieurs chaines parallèles, assurant une
plus grande rigidité et donc une plus grande précision. [3]

Figure I.5 Robot parallèle

I.3.5 Architecture :
En complément au titre précédant, nous pouvons parler d’architecture et de structure plus
détaillé toujours en rapport avec ces les chaines cinématiques.
Dans ce qui suit nous allons voir pour chaque famille de robots manipulateur les différentes
structures existantes. Nous pouvons définir trois grandes classes d’architecture
1. Robot manipulateur sériels (Architecture série ou chaine cinématique ouverte)
La plupart des robots industriels sont de type sériel, et ils ne possèdent généralement
pas plus de six axes articulaires. On distingue dans cinq grandes familles.

a) La structure anthropomorphe
Ces robots possèdent pour la plupart six articulations rotoïdes, la
deuxième et troisième articulations parallèles, induisant un mouvement
de l’outil dans le plan vertical, La première, d’axe verticale décrivant
un arc de cercle lors du mouvement de l’outille dans le plan horizontal.

5
Figure I.6 Structure anthropomorphe Figure I.7 Robot anthropomorphe

b) La structure SCARA
SCARA veut dire « Selective Compliance Assembly Robot Arm ». Ce
sont des manipulateurs sphériques a géométrie spéciale, ces robots sont
précis et rapides, composé de deux articulations rotoïde et une
articulation prismatique, ils sont bien adaptés aux taches de montage
vertical et à la manipulation de montage.

Figure I.8 Structure SCARA Figure I.9 Robot type SCARA

c) La structure Cartésienne
La structure cartésienne offre une très bonne rigidité mécanique et une
grande précision, mais une faible dextérité car elle est composée de
trois articulation prismatiques dont les axes sont typiquement
mutuellement orthogonaux.

Figure I.10 Structure cartésienne Figure I.11 Robot cartésien

6
 d) La structure sphérique
La structure du porteur sphérique dont les deux premiers axes rotoïde
sont orthogonaux et le troisième prismatique permet de positionner
l’outil dans un volume accessible sphérique.

Figure I.12 Structure sphérique Figure I.13 Robot sphérique Unimate0

e) La structure cylindrique
Afin de le positionner dans un volume cylindrique, le porteur
cylindrique présente quant à lui, un premier axe rotoïde vertical suivi
de deux axes prismatiques orthogonaux en série respectivement
vertical et horizontal. [1]

Figure I.14 Structure cylindrique Figure I.15 Robot cylindrique

2. Robots manipulateurs parallèles

Les manipulateurs parallèles sont apparus à la fin des années 70 et ne sont encore que
relativement peu répandus. Les avantages apportés par une structure parallèle sont
principalement. La rigidité structurelle (qui augmente de beaucoup le rapport charge
utile sur masse propre du robot) ; les propriétés dynamiques ; la possibilité de déporter
les actionneurs vers la base du robot. [4]
Plusieurs formes d'architectures parallèles sont possibles, mais nous ne citerons que les
plus connues et ayant un potentiel industriel intéressant

7
a) La structure planes
Les robot parallèles planes ont surtout été utilisé au niveau de la recherche,
l’organe terminal de ces structures est lié a la base par trois chaines cinématiques
indépendante, chaque une constitué de deux corps rigides liés par une articulation
dont le nombre total est de trois, articulation qui peut être soit rotoïde (R), soit
prismatique (P), dont une motorisée, et pour des raisons de dynamique, elle est
classiquement solidaire de la base du robot de façons a alléger la partie de la
structure en mouvement.

Figure I.16 Example structure de robot pleinement parallèles plans

b) La structure Delta
Ce robot pleinement parallèle comprend une base et une plate-forme liée par trois
chaines cinématiques identiques. Chacune comprend une articulation motorisée
solidaire de la base qui met en rotation un bras. Ce bras est lié via une autre
articulation rotoïde passive au petit côté d’un parallélogramme (P) qui est parallèle
à l’axe de l’articulation motorisée. L’autre petit coté du parallélogramme qui peut
ainsi se mouvoir en translation parallèlement a (P) est lié a son tour en son milieu
par une autre articulation rotoïdes passive a la plate-forme mobile portant
l’effecteur. [1]

Figure I.17 Structure Delta Figure I.18 Robot type Delta

8
c) La structure Hexapode (plate-forme de Stewart)
Plusieurs formes d'architectures parallèles sont possibles et la plus répandue est la
plate-forme de Gough-Stewart. Il s'agit d'un manipulateur à six degrés de liberté,
dont la plate-forme est déplacée par l'élongation de six actionneurs linéaires. Son
application la plus connue est le simulateur de vol en raison, entre autres, de la
masse élevée de la cabine (jusqu'à 15 000 kg) à laquelle on doit faire subir des
mouvements. Les simulateurs de vol sont utilisés pour l'entraînement des pilotes
au sol

Figure I.19 Structure Hexapode Figure I.20 Robot simulateur de vol type
hexapode

9
I.4 Domaines d’application des robots manipulateur
La robotique permet de réaliser des taches répétitives, pénible, dangereuse et dans des milieux
hostiles, avec précision et fiabilité, dans tout environnement, a des cadences élevées et
continue, tout en palliant au manque de main-d’œuvre, favorisant la haute productivité, et
donnant ainsi à la robotique un fort intérêt humain, technique et économique. Ce qui lui a
permis de se diversifier dans de nombreux domaines d’utilisation qui sont les suivants.
• Domaines industriels
o La transformation de pièces : moulage, usinage, perçage, rectification,
enlèvement de matière
o La préparation de surface : peinture, enduction, projection thermique/plasma,
grenaillage
o L’assemblage : rivetage, vissage, soudage, insertion, collage
o Les manutentions : manipulation de pièces, chargement/déchargement de
machine, positionnement
o La distribution
o La palettisation et le conditionnement
o L’inspection et le test
o Le nettoyage
• Domaine médical
o Opérations
o Diagnostiques
o Radiothérapie
o Prothèses
• Domaine militaire
o Désamorçage
o Déminage
• Autres domaines
o Nucléaire
 Manipulation des produits radioactifs
o Spatial
 Exploration des planètes
o Sous-marin
 Forage
o Musique
 Chef d’orchestre
o Dessin
 Robographe (imitation de gestes humain)

I.5 Constitution d’un robot manipulateur

La robotique est un domaine d’intégration ou interviennent plusieurs disciplines différentes :
la mécanique, les actionneurs (électromagnétiques, piézoélectriques, hydrauliques,
pneumatiques, etc.), les capteurs (position, vitesse, force, vision, etc.), l’électronique,
l’automatique, l’informatique, la robotique « pure » (génération de trajectoires, planification,
placement d’un robot, manipulabilité, etc.)., tous ces domaines jouent un rôle fondamental
dans la constitution et la commande d’un robot manipulateur

10
 Figure I.21 Constituant d'un bras manipulateur

Les différents éléments d’un robot industriel sont :

1. Une structure mécanique qui supporte l’organe terminale à situer.

Figure I.22 exemple de SMA

o Base : support sur lequel est située le bras

o Porteur (bras) : chaine constituée d’élément de translation et/ou rotation
o Poignet : ensemble mécanique de l’extrémité du bras d’un robot
o Liaison (articulation) :
• Rotoïde (ou pivot)
• Prismatique (ou glissière)
• Rotule S (sphérique)
• Cardan U (joint universel)
 Liaison active : liaison motorisée entre deux corps successifs d’un
robot
 Liaison passive : liaison non motorisée

11
 Figure I.23 exemple de liaisons mécanique

o Organe terminal (effecteur) : tout dispositif destiné a manipulé des objets ou à

les transformer (qui porte l’outil)

2. Des actionneurs qui servent à agir sur la structure mécanique pour changer la
situation de l’organe terminal. (Ensemble de moteurs et de transmissions)

o Moteurs électriques

 A aimant permanent
 A courant continue
 A commande par l’induit
 A commutation électronique (sans balais)
 Pas à pas
 Servo-moteur (Le terme « servo » induit un asservissement)

o Actionneur hydraulique
 Vérin hydraulique pour la translation
 Moteur hydraulique pour la rotation
o Actionneurs pneumatiques
 Usage général pour le manipulateur a cycles (tout ou rien)

3. Des capteurs divers nécessaires à la commande.

o Capteurs proprioceptifs : mesurent l’état interne du robot

 Position
• Linéaire : potentiométrique
• Angulaire : potentiométrique, capteur de contact, capteur
magnétique, capteur optique incrémentaux et absolue

12
  Vitesse
• Linéaire : tachymètres linéaires, tachymètres linéaires à ondes
• Angulaire : Tachymètres à impulsion, Génératrices
tachymétriques, Gyromètres
 Accélération
• Accéléromètre
• Gyroscope
• Magnétomètre
o Capteurs extéroceptifs : recueillent des informations sur l’environnement
 Capteur de contact
• Détection de collision, température, texture, relief, forme,
détection de dommages
 Capteur sans contact
• Capteur de proximité
• Capteur d’image
• Caméras standards
• Caméras stéréoscopiques
• Caméras panoramiques

4. Un système de commande qui pilote les actionneurs du robot manipulateur.

o La partie commande synthétise les consignes des asservissements pilotant les

actionneurs, à partir de la fonction de perception et des ordres de l'utilisateur.

S'ajoutent à cela :
 L'interface homme-machine à travers laquelle l'utilisateur programme
les tâches que le robot doit exécuter
 Le poste de travail, ou l'environnement dans lequel évolue le robot.

5. Un système décisionnel qui assure la fonction de raisonnement et élabore le

mouvement du robot manipulateur. (La programmation)

o Par apprentissage : les trajectoires et actions du robots sont apprises

manuellement pendant d’apprentissage
o Hors-ligne (PHL) : un logiciel permet de programmer et de simuler le
fonctionnement du robot dans la cellule virtuelle sur un ordinateur. Les
programmes sont ensuite transférés sur la baie de commande

6. Un système de communication qui gère le message transmis entre le système

décisionnel et l’opérateur via une console de visualisation

o A distance : l’homme et le robot sont séparé spatialement ou temporellement

 La téléopération ou le contrôle supervisé d’un robot placé à distance
 La télémanipulation lorsqu’un robot manipulateur est utilisé pour
réaliser des tâches de manipulation à distance
o Proche : l’homme et le robot sont colocalisé

13
  L’interaction proche avec un robot mobile pouvant servir d’assistant
 Interaction sociale, émotive ou cognitive où l’homme et le robot sont
le plus souvent proches
o Interaction physique : la robotique collaborative

-Les moyens d’interaction :

 De L’homme vers le robot : clavier, souris, bouton, joystick, capteur
de mouvement, capteur de proximité
 Du robot vers l’homme : écran, voyant, alarme
 Dans les deux sensé : écran tactile, joystick a retour de force, dispositif
haptique

I.6 Conclusion :
Nous avons donné dans ce chapitre une vue général sur les bras robotisé en passant par leur
définition, leurs types, catégories, groupes, classes, architectures et leur structure, à savoir les
structures, anthropomorphe, cartésienne, SCARA, sphérique, cylindrique, plane, DELTA, et
hexapode, nous avons cité les domaines d’applications les plus répondue, et décrit sa
constitution, notamment sa structure mécanique ainsi que les différant capteur et actionneur
utilisé dans le domaine des bras robotisé

14
 Chapitre 2

II.1 Introduction :
Dans ce chapitre, nous allons nous attaquer à la réalisation d’un bras robotisé, a cinq degrés
de liberté. Nous commencerons par présenter la technologie utilisée, c’est-à-dire les logiciels
utilisé pour la modélisation et l’impression 3D, ainsi que le hardware de commande du bras
Nous allons montrer tout le processus de construction, depuis la conception et l’impression
3D des pièces du robot, la connexion des composants électroniques et la programmation de
l’Arduino, au développement de notre propre application Android pour le contrôle du bras.
La première étape fut de trouver un modèle de bras à modéliser, ensuite de le modéliser sous
le logiciel SolidWorks, de l’exporter, et de l’imprimer avec une imprimante 3D, puis de le
monter, de placer les servos moteurs, et raccorder les fils électriques.
La deuxième étape consiste à se familiariser avec le « MIT App Inventor » pour réaliser
l’application Android, qui envoie les données nécessaires à l’Arduino via Bluetooth.
Pour finir la réalisation du circuit électrique, composé de l’Arduino, du module HC-05, des
servos moteurs, et d’une source d’alimentation.

II.2 Conception mécanique :

II.2.1 SolidWorks :
SolidWorks est un logiciel de conception assistée par ordinateur, appartenant à la société
Dassault Systèmes. Il utilise le principe de conception paramétrique et génère trois types de
fichiers qui sont liés : la pièce, l'assemblage, et la mise en plan. Ainsi toute modification sur
un de ces trois fichiers sera répercutée sur les deux autres.

Figure II.1 Logo SolidWorks

Pour la réalisation mécanique nous avons opté pour le logicielles SolidWorks qui propose un
système de contrainte mécanique réaliste. Le bras a 5 degrés de liberté, pour les 3premiers

15
axes, la base, l’épaule et le coude, nous avons opté pour le servo MG996R, et pour le poignet
et la pince, nous avons utilisé les micros-servos SG90.
Ci-dessous les vues du bras depuis le SolidWorks.

Figure II.2 Vue sur coté du bras

Figure II.3 Vue de haut du bras

16
Figure II.4 Vue éclaté du bras

Figure II.5 Rendu final du bras

17
II.2.2 Impression 3D :
Une fois le model terminé, il faut exporter le model en fichier STL vers le logiciel de l’imprimante 3D.
L’imprimante utilisée et une « Raise3D pro2 » de ideaMaker, de l’AIP de la FST a l’université de
Lorraine
Nous importons les fichier STL dans le logiciel ideaMaker, puis nous générons le fichier G-CODE
pour l’impression 3D

Figure II.6 logiciel ideaMaker

L’impression des pièces a durée 35h, pour 340g de matière PLA avec une qualité d’impression
standard

Figure II.7 Impression 3D

18
II.2.3 Le montage :
Le montage est simple, la base est fixée sur une planche en bois, un servo moteur MG996R
est fixé à l’intérieur de la base avec des vis incluses dans l’emballage, ou vient se poser
l’épaule a là vertical, a l’aide d’un boulon a corne ronde fixé avec deux vis.

Figure II.8 base du bras Figure II.9 dessous de l'épaule

Figure II.10 base et épaule du bras

Un servo moteur MG996R est fixé sur l’épaule et l’avant-bras, les cornets ronds sont attachés
sur le bras principale avec deux vis, qui vient joindre l’épaule et l’avant-bras.

19
A l’intérieur de l’avant-bras est attaché un micros servo avec deux vis, ou vient ce fixé le
poignet qui lui-même contient un micros servo qui sera attaché à la pince du robot, pour la
pince nous avons utilisé des boulons et des écrous pour la monter et un micros servos pour
contrôler son ouverture et fermeture.

Figure II.14 bras principal Figure II.11 avant-bras

Figure II.13 poignet du robot Figure II.12 Pince du bras

20
Une fois le tout assemblé on obtient le résultat suivant

21
II.3 Réalisation de l’application Android :
II.3.1 MIT APP INVENTOR :
App Inventor est une application développée par Google. Elle est actuellement entretenue
par le Massachusetts Institute of Technology (MIT), est un IDE qui permet la création
d’applications destinées à des systèmes Android

Figure II.15 App Inventor LOGO

Son principal atout est la facilité de développement, même pour des débutants, grâce à une
interface graphique similaire à Scratch. Il se présente sous la forme d’une application en ligne,
accessible depuis le site web d’App Inventor
II.3.2 Réalisation de l’application :
La réalisation de l’application sous AppInventor ce fait divise en deux parties, la partie
Designer, pour le graphique de l’application, et la partie Blocks, pour la programmation de
l’application

Figure II.16 Partie Designer d'AppInventor

Designer : Dans cette partie nous disposons de divers blocks graphiques comme des bouton,
des champs de texte, des images, des sliders, mais aussi des layout qui servent à délimiter les
zones de notre application, des sensors pour exploiter les capteurs du téléphone, et quelques
autres fonctionnalités utiles de multimédia, de GPS, et de communication Bluetooth.
Blocks : Dans la partie blocks nous retrouvons toutes les fonction mathématique, logique, ou
évènementiel, ce rapportant aux objets utilisés dans la partie graphique, ce qui nous permet de
tirer profit d’une simplicité de programmation orienté objet sous la forme de blocks près
programmé, qu’ils ne restent plus qu’a organiser en fonction du programme souhaité.

22
 Figure II.17 Partie Blocks de AppInventor

Lorsque ces outilles sont utilisé correctement, nous pouvons réaliser une application simple et
efficace, avec un designe propre, et qui répond à nos besoins. Dans ce qui suit nous allons
expliquer le fonctionnement des blocks de programme, et leur utilité dans le programme
Arduino de control du bras.
1. Pour commencer les blocks permettant de connecter le smartphone au module
Bluetooth

Figure II.18 Block Bluetooth 1

• Ici définissons les éléments de l’objet bluetooth de type BluetoothListe comme

périphériques Bluetooth disponible.

Figure II.19 Block Bluetooth 2

• Ensuite nous établissons la connexion entre le périphérique et l’application

23
 Figure II.20 Block Bluetooth 3

• Quand nous appuyons sur le bouton « deconnecte », le Bluetooth se déconnecte

Figure II.21 Block Bluetooth 4

• Ici nous indiquons seulement l’état de connexion de notre appareil en changeant le

contenue et la couleur du texte

Figure II.22 Block Bluetooth 5

• S’il y a une erreur de connexion avec l’appareil, l’état est mis à déconnected

24
2. Ensuite les blocks de contrôle de position et vitesse des servos moteur

Figure II.23 Block Contrôle 1

• Si nous changeons la position du curseur, en utilisant la fonction Bluetooth.SendText,

nous envoyons un texte à l'Arduino. Ce texte se compose d'un préfixe qui indique quel
curseur a été modifié, dans ce cas « 1 » qui est l’indice du moteur 1, ainsi que la valeur
actuelle du curseur qui est « thumbPosition ».

Figure II.24 Block Contrôle 2

• Et on répète cela pour les six curseurs associer aux six servos moteurs

Figure II.25 Block Contrôle 3

25
• De la même manière on attribue le préfixe « s » suivie de la valeur du curseur, et nous
l’envoyons au programme Arduino
3. Pour finir les blocks de fonctionnalité des boutons SAVE, RUN, et RESET

Figure II.26 Block bouton SAVE

• Quand le bouton « save » est appuyé, nous envoyons le préfixe « SAVE » à l’Arduino,
et nous incrémentons le nombre de positions sauvegardées

Figure II.27 Block bouton RUN

• Quand nous cliquons sur le bouton « run », nous changeons la couleur du bouton et
nous envoyons le préfixe « STOP » ou « RUN » a l’Arduino, et si il est initialement
sur « STOP », le texte est modifié en « RUN », sinon, si il est initialement en
« RUN », le texte est modifié en « STOP ».

26
 Figure II.28 Block bouton RESET

• Ici en appuyons sur le bouton « reset » nous envoyons le préfix « RESET » à

l’Arduino, le texte et la couleur du bouton « run » est réinitialisé aux valeurs initiales,
et le nombres de positions sauvegardées est remis à 0.
Au Final voilà à quoi ressembleras notre application

Figure II.29 Robot Arm Command APP

27
II.4 Partie électronique :
L’étape suivante consiste à connecter l’électronique, pour ce projet nous aurons besoin d’une
carte Arduino Uno pour la commande, d’un module Bluetooth HC-05 pour la communication
avec le smartphone, et d’une source d’alimentation de 5V.
Dans ce qui suit, nous allons décrire le matériel utilisé, et montrer comment nous pouvons
associer les différent composant en eux.

II.4.1 Arduino :
La carte Arduino UNO est un microcontrôleur ATmega328 programmable permettant de faire
fonctionner des composants (moteur, LED…). Elle possède des « ports » permettant par
exemple de se connecter à un ordinateur ou de s’alimenter.
Peut être alimentée via la connexion USB ou avec une alimentation externe. La source
d'alimentation est automatiquement sélectionnée. Une alimentation externe peut provenir soit
d'un adaptateur AC-DC ou d’une batterie. L'adaptateur peut être connecté en branchant une
prise 2.1mm dans la prise d'alimentation de la carte ou à partir d'une batterie connectée dans
le pin (ou broche) GND et V-in (alimentation externe). Le processeur peut fonctionner sur
une alimentation externe de 6 à 20 volts. Cependant, si la tension est inférieure à 7V, le pin
5V peut fournir moins de cinq volts et le processeur peut devenir instable. Si la tension est
supérieure à 12V, le régulateur de tension peut surchauffer et endommager la carte. La plage
recommandée est de 7 à 12 volts.[5]

Figure II.30 Arduino UNO

28
II.4.2 Le module HC-05 :
Le module HC-05 est un module Bluetooth SPP (Serial Port Protocol), ce qui signifie qu'il
communique avec l'Arduino via la communication série.

Figure II.31 Branchement du HC-05

Le peut être alimenté de 3,6 à 6 volts, car il vient sur une carte de dérivation contenant un
régulateur de tension. Cependant, le niveau de tension logique des broches de données est de
3,3V. Ainsi, la ligne entre le Arduino TX (broche de transmission, qui a une sortie 5V) et le
module Bluetooth RX (broche de réception, qui supporte seulement 3,3V) doit être connectée
via un diviseur de tension afin de ne pas graver le module. D'autre part, la ligne entre la
broche TX du module Bluetooth et la broche Arduino RX peut être connectée directement car
le signal 3,3 V du module Bluetooth est suffisant pour être accepté comme une logique haute
sur la carte Arduino
II.4.3 Les servos moteurs :
II.4.3.1 Vue d’ensemble :
Il existe de nombreux types de servomoteurs et leur principale caractéristique est la possibilité
de contrôler avec précision la position de leur arbre. Un servo-moteur est un système en
boucle fermée qui utilise un retour d'information pour contrôler son mouvement et sa position
finale

Figure II.32 système boucle ferme servo moteur

29
Dans les servomoteurs de type industriel, le capteur de retour de position est généralement un
codeur de haute précision, tandis que dans les servos RC ou passe-temps plus petits, le capteur
de position est généralement un simple potentiomètre. La position réelle capturée par ces
dispositifs est renvoyée au détecteur d'erreur où elle est comparée à la position cible. Ensuite,
en fonction de l'erreur, le contrôleur corrige la position réelle du moteur pour qu'elle
corresponde à la position cible

II.4.3.2 Fonctionnements des servos :

Dans un servo amateur, il y a quatre composants principaux, un moteur à courant continu, une
boîte de vitesses, un potentiomètre et un circuit de contrôle. Le moteur à courant continu a
une vitesse élevée et un couple faible, mais la boîte de vitesses réduit la vitesse à environ 60
tr/min tout en augmentant le couple.

Figure II.33 composition d'un servo moteur

Le potentiomètre est fixé sur le pignon final ou sur l’arbre de sortie. Ainsi, lorsque le moteur
tourne, le potentiomètre tourne également, produisant ainsi une tension liée à l’angle absolu
de l’arbre de sortie. Dans le circuit de commande, cette tension de potentiomètre est comparée
à la tension provenant de la ligne de signal. Si nécessaire, le contrôleur active un pont en H
intégré qui permet au moteur de tourner dans un sens ou dans l'autre jusqu'à ce que les deux
signaux atteignent une différence de zéro.
Un servomoteur est contrôlé en envoyant une série d'impulsions à travers la ligne de signal.
La fréquence du signal de commande doit être de 50Hz ou une impulsion doit avoir lieu
toutes les 20 ms. La largeur de l'impulsion détermine la position angulaire du servo et ce type
de servo peut généralement pivoter à 180 degrés (ils ont une limite physique de déplacement)

30
 Figure II.34 Contrôle en PWM

Généralement, les impulsions d'une durée de 1 ms correspondent à une position de 0 degré,

une durée de 1,5 ms à 90 degrés et de 2 ms à 180 degrés. Bien que les durées minimum et
maximum des impulsions puissent parfois varier selon les marques, elles peuvent être de 0,5
ms pour 0 degré et de 2,5 ms pour une position à 180 degrés
II.4.3.3 Contrôle des servo moteurs avec Arduino :
Nous utiliserons le micro servo SG90 et le servo MG996R, un servo qui contrairement au
SG90, est à couple élevé comportant un engrenage en métal avec un couple de décrochage de
10 kg-cm. Le couple élevé a un prix, et c'est le courant de décrochage du servo, qui est de
2.5A. Le courant de fonctionnement est de 500 mA à 900 mA et la tension de fonctionnement
est de 4,8 à 7,2 V
Les valeurs nominales actuelles indiquent que nous ne pouvons pas connecter directement ce
servo à l’Arduino, mais nous devons utiliser une alimentation séparée pour celui-ci.

Figure II.35 Schéma branchement servo moteur

Nous devons simplement connecter la broche de contrôle du servo à une broche numérique de
la carte Arduino, connecter la terre et les fils positifs à l’alimentation externe 5 V, et
également connecter la terre Arduino à la masse du servo
31
II.4.4 Schéma général :
Donc pour résumer nous utiliserons 3 servos MG966R, 3 micro servo SG90, un module
Bluetooth HC-05, une carte Arduino Uno, , le tout connecté a notre application Android pour
le contrôle. Ci-dessous le schéma électrique complet.

Figure II.36 Schéma fonctionnel final

II.5 Conclusion :
Dans ce chapitre nous avons fait le tour de la conception de notre bras robotisé, en passant par
la modélisation, impression et conception mécanique de notre bras, la création d’une
application Android pour le contrôle de ce dernier, et la réalisation du circuit électronique
pour la commande du robot, nous avons aussi fait un bref rappelle sur les composants de ce
circuit et la méthode de contrôle des servo moteur, notamment de la commande par PWM.
Dans le prochain chapitre nous aborderons l’algorithme de commande du bras avec Arduino
via l’application Android.

32
 Chapitre 3

III.1 Introduction :
Dans ce chapitre nous allons aborder la programmation de notre Arduino Uno, pour la
commande de notre bras avec l’application mobil vue précédemment.
Nous verrons les bibliothèques utilisées, les fonctions essentielles au control des servos
moteurs, et a la connexion Bluetooth, ainsi que la méthode de communication utilisée pour
interpréter les données de l’application en commande compréhensible pour l’Arduino.

III.2 L’IDE 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

Figure III.1 Logo Arduino

Le logiciel Arduino est un IDE open source et gratuit, qui permet d’éditer un programme : des
croquis (sketch en Anglais), de compiler ce programme dans le langage « machine » de
l’Arduino, de téléverser le programme dans la mémoire de l’Arduino, et
de communiquer avec la carte Arduino grâce au terminal.

III.3 Explication du code Arduino :

III.3.1 Partie déclaration des variables :

Dans cette partie nous devons :

• Inclure la bibliothèque SoftwareSerial pour la communication série du module

Bluetooth ainsi que la bibliothèque Servo, qui sont incluses dans l'IDE Arduino
• Définir les six servos moteur qui sont des objets de type Servo
• Définir le module Bluetooth HC-05 de type SoftwarSerial en lui attribuant les
broches RX et TX
• Définir les tableaux de type int pour stocker la position actuelle ps[], précédente _ps[]
des servos, ainsi qu’un tableaux pour stocker les positions ou les étapes du mode
automatique pos[p]
• Et enfin les variables pour la vitesse de déplacement v, et de donnée reçue via
Bluetooth Data de type String

33
 Figure III.2 Partie d'déclaration des variables

III.3.2 Partie configuration :

Dans la section de configuration, nous devons :

• Initialiser les servos et le module Bluetooth

• Déplacer le bras du robot dans sa position initiale, en utilisant la fonction write () qui
déplace simplement le servo dans n’importe quelle position de 0 à 180 degrés

Pour l’initialisation nous créerons deux fonctions :

• « initBroches ()» ne prend pas de paramètre, et qui attache chaque servo du tableau
servo, au broches du tableau broches, a l’aide de la fonction attach()

Figure III.3 fonction initBroches

• « positionInitiale() » ne prend pas de paramètre, et qui d’une part copie les position
initiale du tableau pi[] dans le tableau _ps[] des positions précédentes, et d’autre part
place les servos moteurs dans la position souhaitée grâce à la fonction write()

Figure III.4 fonction initPositionInitial

34
Sans oublier l’initialisation du module Bluetooth voici ce que l’on obtient :

Figure III.5 Partie configuration

III.3.3 Partie de boucle :

Pour la section loop il faut :

• Vérifier en permanence, s’il existe des données entrantes en provenance du

Smartphone avec la fonction available()
• Utiliser la fonction readString (), pour lire les données sous forme de chaîne et les
stocker dans la variable Data

o La variable Data recoit les données du smartphone sous forme d’une chaine de
caractère de la forme « num+deg » le num est un préfix désignant le numéro
du servo moteur à contrôler, et deg, le degré souhaité provenant de la position
du slider de l’application

• À l’aide de la fonction startsWith (), nous vérifions le préfixe de chaque donnée

entrante afin de savoir ce quel moteur contrôler
• Nous extrayons le degré envoyé a partir de la variable Data à l’aide de la fonction
substring(), et nous la convertissons en entier avec la fonction toInt()
• Pour finir nous exécutons la fonction rotation() décrite ci-dessous

o « rotation(int num ,int deg) », prend en paramètre deux donnée, le numéro du

servo a contrôler, et la position souhaitée

 D’abord, nous stockons deg dans notre tableau de position ps[]

 Ensuite nous vérifions si la position actuel ps[] et plus grande ou plus
petite que _ps[]
 En conséquence nous incrémenterons, ou décrémenterons un indice
dans une boucle for, et avec la fonction write() de l’objet Servo, pour
contrôler les moteurs, suivie de la fonction delay(v) avec v une valeur
en ms, pour contrôler sa vitesse.
 Enfin nous définissons la position actuelle ps[] comme position
précédente _ps[]

35
 Figure III.6 Fonction rotation()

• Ensuite viens la fonction Save(), associée au bouton SAVE de l’application

• En appuyant sur le bouton SAVE l’application envoie le préfix ‘SAVE’
• Toujours avec la fonction statsWith(), nous vérifions le contenue du préfix, si il
correspond, nous exécutons la fonction

o « Save() », ne prend aucun paramètre, en appuyions sur SAVE la position de

chaque servomoteur est stockée dans une matrice. À chaque pression, l'index p
augmente, de sorte que le tableau est rempli pas à pas
 Pour chaque servo moteur, nous remplissons le tableau de position
pos[i][p], ou i correspond au numéro du moteur, et p l’indice du
tableau de positions qui est aussi le nombre de positions sauvegardées
 Puis nous incrémentons l’indice p

Figure III.7 fonction save()

36
• Pour la fonction Run(), associé au bouton RUN de l’application
• En appuyant sur le bouton RUN, l’application envoie le préfix ‘RUN’
• Toujours avec la fonction statsWith(), nous vérifions le contenue du préfix, si il
correspond nous exécutons la fonction

Figure III.8 fonction Run()

• La fonction Run() lis les position contenu dans le tableau pos[i][p], et déplace les
moteur avec une vitesse v
• Elle écoute aussi la réception des Data, ‘RESET’ du bouton RESET, et ‘STOP’ du
bouton RUN/STOP, pour dans l’ordre, arrêter (avec la fonction Reset()), ou mètre en
pause la fonction jusqu’à réappuyer sur le bouton RUN
• Pour finir elle permet de modifier la vitesse de déplacement à la réception de Data ‘vi’

37
• Pour la fonction Reset(), associé au bouton RESET de l’application
• En appuyant sur le bouton RESET, l’application envoie le préfix ‘RESET’
• Toujours avec la fonction statsWith(), nous vérifions le contenue du préfix, si il
correspond nous exécutons la fonction

Figure III.9 fonction Reset()

• Pour finir, voici ce qu’on obtient dans la section loop

Figure III.10 Section loop()

38
III.4 Teach mode :
Pour aller plus loin sur le contrôle de notre robot, nous avons décider de lui inclure un mode
d’apprentissage manuel en contact direct avec l’opérateur ; pour ce faire nous avons besoin de
récupérer la position des moteurs a chaque position, de les enregistrer dans un tableau, pour
les réexécuter.
III.4.1 Hack des moteurs :
• Le problème est que les moteurs à notre disposition ne nous permettent pas de
récupérer la position des moteurs, pour résoudre ce problème, nous avons trouvé une
astuce. Souder un fil à la sortie du potentiomètre des moteurs pour récupérer la valeur
analogique de ce dernier en feedback.

Figure III.11 Soudure sur le MG996R

Figure III.12 Soudure sur le SG90

39
III.4.2 Commande des moteurs :
• Maintenant nous pouvant récupérer les valeurs des potentiomètres des moteurs, en les
branchant aux entrées analogiques de l’Arduino.
• Un autre problème apparait, les valeurs lues sont limitées a moins de 300 pas, cela est
dut à la tension de référence du CAN de l’Arduino, pour remédier a cela, nous
pouvons réduire la tension de référence, avec un diviseur de tension, à l’aide d’un
potentiomètre relier entre le GND, le +5V, et le A-REF de l’Arduino, comme le
montre le schéma ci-dessous.

Figure III.13 Schéma moteur avec feedback

• En jouant sur la valeur du potentiomètre, nous avons pu passer de 300 à plus ou moins
700 pas, ce qui a doublé la précision de positionnement de nos moteurs.
• Pour finir nous dressons un tableau de valeurs max et min des degrés limites des
moteurs, associer à la valeur que retourne le potentiomètre interne de ces derniers.
Analogue Max Analogue Min Degré Max Degré Min
Base 990 249 180 0
Epaule 1014 365 180 20
Coude 1015 260 180 0
Poigné latéral 995 250 180 0
Poigné frontal 896 190 180 0
Pince 977 750 180 105

Les valeurs suivante nous servirons a lire la positions des moteurs par analogie avec la
fonction map(valeur analogique, Analogue Min, Analogue Max, Degré Min, Degré Max), qui
prend une valeur d’entré, et pour une plage précise, retourne une nouvelle valeur, dans une
plage voulue, en d’autre terme elle convertira la valeur du potentiomètre en degré, qui
correspond à la position du moteur.

40
III.4.3 Utilisation des boutons :
Pour contrôler notre bras, cette fois nous avons opté pour des boutons poussoir. Nous
utiliserons quatre boutons, pour chaque partie du Teach mode, c’est-à-dire
1. Détacher les moteurs
2. Enregistrer la position des moteurs à partir des potentiomètres
3. Lancer le mouvement du robot
4. Réinitialiser le tableau de position
Les boutons devront être brancher sur l’Arduino en utilisant des résistances de pull-down de
10k Ohm, comme le montre le schéma ci-dessous.

Figure III.14 Schéma branchement boutons

Si le poussoir est baissé, le courant va du +5V au pin de l'Arduino. Il ne prendra pas le chemin
du GND car la résistance lui demande un effort. Le pin de l'Arduino recevra du +5V et
indiquera HIGH (ou 1). Si le poussoir est levé, donc le circuit ouvert, le très faible courant
résiduel qui sortira du pin de l'Arduino sera absorbé par le GND, le pin sera donc bien en
LOW (ou 0).
III.4.4 Schéma général :
Pour finir nous allons expliquer rapidement l’algorithme utilisé, le code sera disponible en
Annex
• D’abord déclarer la référence analogique en « EXTERNAL » (pin A-Ref), pour
modifier la tension de référence du CAN d l’Arduino
• Initialiser les diffère bouton en Boolean, et les affecter à leurs pins respectifs
• Affecter pour chaque bouton en position HIGH la fonction adéquate, c’est-à-dire :
o Detacher () : qui détache tous les moteurs de leurs pins pour permettre de les
mouvoir manuellement
o Lecture () : lis la valeur du potentiomètre interne de chaque moteur, le
convertie en degré avec la fonction map(), et l’enregistre dans un tableau de
position.
o Commancer () : attache tous les moteurs a leur pin, puis parcoure le tableau
de position, et positionne les moteur du bras en fonctions de ce dernier.

41
Enfin voici le schéma électrique final, regroupant les moteurs, les boutant, et le module
Bluetooth de notre montage.

Figure III.15 Schéma final du montage

III.5 Conclusion :
Dans ce chapitre nous avons expliqué le code servant à contrôler le bras via Bluetooth, avec
une application Android, ou nous avons fait le lien avec les données transmise par
l’application, et leur interprétation dans le code Arduino.
Pour aller plus loin, nous avons ajouter à notre bras un mode d’apprentissage a contacte direct
avec l’opérateur, commandé par des boutons poussoir, et avons vue, et expliqué les grandes
lignes de son code.

42
43
 Conclusion Général

Lors de ce projet intitulé « Commande d’un bras robotisé avec application Android via
Bluetooth », nous avons dans un premier temps, dans le premier chapitre, introduit quelques
notions générales relatives aux robots manipulateurs, notamment leur définition, leur
classification, leurs structures, à savoir les structures, anthropomorphe, cartésienne, SCARA,
sphérique, cylindrique, plane, DELTA, et hexapode, ainsi que leurs domaines d’application,
en finissant par les différents capteurs et actionneurs dans le domaine.
Le second chapitre nous somme entré dans le vif du sujet, nous avons vue, la modélisation,
l’impression, la conception et le montage mécanique de notre bras, la création d’une
application Android, et la réalisation du circuit électronique composé d’un Arduino, de six
servo moteur, et d’un module Bluetooth
Enfin, dans le dernier chapitre, nous avons fais le lien entre l’application Android et
l’électronique, via Bluetooth, avec un code simple et efficace, tout en expliquant les
bibliothèques, et les fonctions utilisé. Nous avons finis en ajouton un mode Teach ; un mode
de commande a contacte direct entre le robot et l’opérateur.

Dans ce projet, j’ai essayé de toucher à un maximum de domaines possible, la modélisation,

la mécanique, l’électronique, le développement mobile. Je me suis efforcé de tirer le
maximum du potentiel de l’Arduino en l’utilisant de différentes façons. J’ai énormément
appris durant la réalisation de ce projet, tout en m’amusant, et tout en essayant de faire le plus
de manipulation possible.
Néanmoins j’aimerais approfondir le sujet de la robotique des bras manipulateurs.
En perspective, pour aller plus loin dans ce domaine :
• Conception d’un nouveau modèle de bras a six ou sept degrés de liberté
• Utiliser des moteurs a courant continue, avec asservissement en vitesse et position
• Utiliser les équations de rotation
• Choix de composants électroniques plus adaptés
• Ajouter une caméra pour la visualisation
• En apprendre plus sur l’apprentissage par intelligence artificiel

44
 BIBLIOGRAPHIE

[1] Patrick Maurine, Jean-François Quinet. (2013). L’étalonnage des robots manipulateurs industriels
(Hermes Science publications). Paris/France.
[2] Charles BOP. (2010). Traité de robotique 1 « Les architectures ». (Edition ellipses). Paris/France.
[3] Wisama Khalil, Etienne Dombre. (1999). Modélisation identification et commande des robots.
(Hermes Science publications). Paris/France.
[4] Laboratoire de robotique, Université Laval, Pavillon Adrien Pouliot [Introduction aux mécanismes
parallèles], Récupéré le 10/02/2019 sur https://robot.gmc.ulaval.ca/recherche/theme-de-
recherche/mecanismes-paralleles/introduction-aux-mecanismes-paralleles/ .

[5] Le grand livre d'Arduino, Patrick Chantereau et Erik Bartmann, éd. Eyrolles, 2014

45
ANNEXE

46
#include <Servo.h>

Servo servo[6]; // déclaration du tableau d'aubjet servo

int ps[6],_ps[6],pos[6][50],post[6][50]; // tableau des

position
int pi[] = {90,120,85,85,100,55}; // tableau des position
initial
int broches[] = {3,4,5,6,7,8}; // tableau des broches
utilisées par les servos
int v=20; // vitesse de deplacement
int p=0,t=0; // indice de position
String Data=""; // données recu par Bluetooth
int val0,val1,val2,val3,val4,val5;
int pin9 = 9,pin10=10,pin11=11,pin12=12;
bool state=0;

void setup()
{
initBroches(); // fonction d'initialisation des broches
Serial.begin(9600); // débit en bauds par défaut du module
Bluetooth
Serial.setTimeout(50);
delay(20); // retard pour eviter les erreur
initPositionInitiale(); // fonction d'initialisation des
position des servos
analogReference(EXTERNAL);
pinMode(pin9,INPUT);
pinMode(pin10,INPUT);
pinMode(pin11,INPUT);
pinMode(pin12,INPUT);
}

void loop()
{

boolean bD=digitalRead(pin9);
boolean bL=digitalRead(pin10);
boolean bC=digitalRead(pin11);
 boolean bS=digitalRead(pin12);

if(bD==1) detacher();
else if(bL==1) lecture();
else if(bC==1) commancer();
else if(bS==1) effacer();

if(Serial.available() > 0)// Vérifier les données entrantes

{
Data = Serial.readString();// Lire les données sous forme
de chaîne
if(Data.startsWith("m1")) // servo1
{
int deg = Data.substring(2,Data.length()).toInt();//
Extrait uniquement le nombre,Convertit la chaîne en entier
if(deg!=0) rotation(0,deg);
}
else if(Data.startsWith("m2")) // servo 2
{
int deg = Data.substring(2,Data.length()).toInt();
if(deg!=0) rotation(1,deg);
}
else if(Data.startsWith("m3")) // servo 3
{
int deg = Data.substring(2,Data.length()).toInt();
if(deg!=0) rotation(2,deg);
}
else if(Data.startsWith("m4")) // servo 4
{
int deg = Data.substring(2,Data.length()).toInt();
if(deg!=0) rotation(3,deg);
}
else if(Data.startsWith("m5")) // servo 5
{
int deg = Data.substring(2,Data.length()).toInt();
if(deg!=0) rotation(4,deg);
}
else if(Data.startsWith("m6")) // servo 6
{
int deg = Data.substring(2,Data.length()).toInt();
 if(deg!=0) rotation(5,deg);
}
else if(Data.startsWith("SAVE")) Save(); // si le bouton SAVE
est appuyé
else if(Data.startsWith("RUN")) Run();// si le bouton RUN est
appuyé
else if(Data.startsWith("RESET")) Reset();// si le bouton
RESET est appuyé
else {}
}
else{}
}

//////////////////////////////// Declaration des fonction

//////////////////////////////////////

void initBroches()
{
for(int i=0;i<6;i++)
{
servo[i].attach(broches[i]);
}
}

void initPositionInitiale()
{
for(int i=0;i<6;i++)
{
_ps[i]=pi[i];
servo[i].write(_ps[i]);
}
}

void rotation(int _the,int _deg)

{
ps[_the] = _deg;
if(_ps[_the] > ps[_the] )
{
 for(int j = _ps[_the]; j>= ps[_the] ; j--)
{
servo[_the].write(j);
delay(v);
}
}
else if(_ps[_the] < ps[_the])
{
for(int j = _ps[_the]; j<= ps[_the]; j++)
{
servo[_the].write(j);
delay(v);
}
}
_ps[_the] = ps[_the];
}

void Save()
{
for(int i=0;i<6;i++) // boucle pour parcourire tous les
servos moteurs
{
pos[i][p] = _ps[i]; // sauvegarde de la positions dans le
tableu
}
p++; // incrementations de l'indice
}

void Run()
{
while(Data!="RESET") // Répétez l'opération jusqu'à ce que
vous appuyiez sur le bouton "RESET"
{
for(int j=0;j<=p-2;j++) // Exécute toutes les étapes
(index)
{

//////////////////////////////////////////////////////////////
/////////////////
if(Serial.available()>0) // Vérifier les données entrantes
{
 Data = Serial.readString();
///////////////////////////////// si STOP est appuyé
if(Data=="STOP")
{
while(Data!="RUN") // Attendre d'appuyier de nouveau
sur "RUN"
{
if(Serial.available()>0)
{
Data = Serial.readString();
if(Data=="RESET") break;
}
}
}
///////////////////////////////// si la vitesse est
modifiée
if(Data.startsWith("vi")) v = Data.substring(2,
Data.length()).toInt(); // Changer la vitesse du servo
}
///////////////////////////////////// Pour chaque moteur
du tableau servo, deplacer les moteur en fonction
///////////////////////////////////// des positions
sauvegardées
for(int i=0;i<6;i++)
{
if(pos[i][j]>pos[i][j+1])
{
for(int k = pos[i][j];k>=pos[i][j+1];k--)
{
servo[i].write(k);
delay(v);
}
}
else if(pos[i][j]<pos[i][j+1])
{
for(int k = pos[i][j];k<=pos[i][j+1];k++)
{
servo[i].write(k);
delay(v);
}
}
 else{}
}
}
}
}

void Reset()
{
memset(pos,0,sizeof(pos)); // Effacer les données du tableau
p=0;
}

void detacher()
{
effacer();
for(int i=0;i<6;i++)
{
servo[i].detach();
}
}

void lecture()
{
val0=analogRead(A0);
pos[0][p]=map(val0,249,990,0,180);
val1=analogRead(A1);
pos[1][p]=map(val1,365,1014,20,180);
val2=analogRead(A2);
pos[2][p]=map(val2,260,1015,0,180);
val3=analogRead(A3);
pos[3][p]=map(val3,250,995,0,180);
val4=analogRead(A4);
pos[4][p]=map(val4,190,896,0,180);
val5=analogRead(A5);
pos[5][p]=map(val5,977,750,105,180);

for(int i=0;i<6;i++)
{
Serial.println(post[i][p]);
}
t++;
}

void commancer()
{
for(int i=0;i<6;i++)
{
servo[i].attach(broches[i]);
}

for(int j=0;j<p-1;j++)
{
for(int i=0;i<6;i++)
{
if(post[i][j]>post[i][j+1])
{
for(int k = post[i][j];k>=post[i][j+1];k--)
{
servo[i].write(k);
delay(v);
}
}
else if(post[i][j]<post[i][j+1])
{
for(int k = post[i][j];k<=post[i][j+1];k++)
{
servo[i].write(k);
delay(v);
}
}
else{}
}
}
}

void effacer()
{
memset(post,0,sizeof(post));
t=0;
}