UNIVERSITÉ DU QUÉBEC À TROIS-RIVIÈRES

COMMANDE PID ET PAR LOGIQUE FLOUE POUR L'AMÉLIORATION DE LA

FINESSE ET DE LA PRÉCISION DES MOUVEMENTS D'UN BRAS ROBOTISÉ À
PLUSIEURS AXES ET DEGRÉS DE LIDERTÉ.

MÉMOIRE PRÉSENTÉ
COMME EXIGENCE PARTIELLE DE LA

MAÎTRISE EN GÉNIE ÉLECTRIQUE

PAR
HAMDI FRIKHA

JUIN 2021
 Université du Québec à Trois-Rivières

Service de la bibliothèque

Avertissement

L’auteur de ce mémoire ou de cette thèse a autorisé l’Université du Québec

à Trois-Rivières à diffuser, à des fins non lucratives, une copie de son
mémoire ou de sa thèse.

Cette diffusion n’entraîne pas une renonciation de la part de l’auteur à ses

droits de propriété intellectuelle, incluant le droit d’auteur, sur ce mémoire
ou cette thèse. Notamment, la reproduction ou la publication de la totalité
ou d’une partie importante de ce mémoire ou de cette thèse requiert son
autorisation.
 11

UNIVERSITÉ DU QUÉBEC À TROIS-RIVIÈRES

MAÎTRISE EN GÉNIE ÉLECTRIQUE (M . Sc . A .)

Direction de recherche:

Alben Cardenas, Professeur Directeur de recherche

Jury d'évaluation

Alben Cardenas, Professeur Évaluateur

Mamadou Doumbia, Professeur Évaluateur

Tahar Tafticht, Professeur Évaluateur externe

 III

Résumé

La majorité des processus industriels nécessite le contrôle d'un certain nombre de

grandeurs telles que la tempérahlre, la pression, la vitesse, la position, etc.

Ce projet de Maitrise concerne, tout d'abord, l'éhlde des méthodes de la commande des bras

robotisés pour améliorer la finesse et la précision des mouvements et la réalisation d'un bras

robot manipulateur à trois degrés de liberté. Puis, nous avons effectué une exploration

générale du domaine de la robotique dans laquelle nous avons abordé le vif du sujet en

étudiant les différents organes constihlant le robot manipulateur. Par la suite, nous nous

sommes penchés sur sa modélisation en procédant à l'étude pratique et l' implémentation.

Afin de réaliser ce travail , plusieurs techniques ont été utilisées pour contrôler les

grandeurs physiques, de telle sorte que celles-ci gardent constamment leurs valeurs ou restent

près des valeurs désirées, quelles que soient les perhlrbations qui peuvent subvenir. La

régulation d'un système physique est basée sur trois opérations fondamentales , à savoir,

Mesure, Décision et Action. Quant à la quatrième partie de ce travail, elle a pour but

d'appliquer les commandes PID et Logique Floue sur le robot manipulateur, c'est ce que

nous avons, d' ailleurs, testé directement sur le bras robot. Nous avons, donc, réalisé une étude

comparative sur l'efficacité de chaque commande ayant un lien avec l'objectif d'améliorer

la finesse des mouvements .

Ainsi , cette étude a pern1is de mettre en évidence, par voie expérimentale, les avantages

de la commande par Logique Floue pour l' amélioration de la finesse des mouvements dans

le contexte des bras robots à faible co lit.

 IV

Remerciement

Je tiens d'abord à remercier mon directeur de recherche M. Alben Cardenas, qui a joué

un rôle important dans la réalisation de ce travail, pour la qualité dans l' enseignement, le

suivi, les conseils judicieux, sa dispo nibi lité permanente et surtout ses qualités pro-

pédagogiques et humaines typiques.

Mes remerciements s'adressent également à Mme. Nathalie Tourigny, pour ses conseils

toujours très utiles, son soutien, ainsi que son aide et disponibilité en ce qui concerne les

démarches et orientations relatives à la scolarité et au suivi administratif des étudiants.

J'exprime ensuite ma gratitude au personnel et aux professeurs de l'Université du Québec

à Trois-Rivières et en particulier du département de génie électrique et génie informatique

(GEGI) .

Je tiens à remercier mon père Mohamed Frikha et ma mère Nedra Frikha pour leur soutien

bienveillant et financier, je souhaiterais remercier également mes deux frères Imed Frikha,

Skander Frikha et ma sœur Randa Frikha pour leur soutien inconditionnel tout au long de la

réalisation de ce mémoire.
 v

Table des matières

Résumé ................................................................................................................................. iii

Remerciement ...................................................................................................................... iv

Table des matières ................................................................................................................ v

Liste des tableaux ................................................................................................................. x

Liste des figures ................................................................................................................... xi

Liste des symboles .............................................................................................................. xv

Chapitre 1 - Introduction .................................................................................................... 1

1.1 Contexte général .. ... ............ .. ...... ...... ........ ..... ........ ......... .............. ... ........... .... .... ... .. 1

1.2 Problématique ............................ .... ... ...... .. ............ ....... ...... ....... ...... ..... ... .... ....... ...... 1

1.3 Objectifs ............................................ ......... ............. .... ... .. ..... .................................. 4

1.4 Méthodologie ................. ....... .. .... ................ ........................... .................................. 5

Chapitre 2 - État de l 'Art .................................................................................................... 6

2.1 Introduction ........ ........ .. ................ .................. ... .. ...... ..... ... ......... ...... .......... ....... ...... 6

2.2 Définitions .................. ......................... ................ ....................... .. .............. ........ ..... 6

2.2.1 Définition d'un robot .. ....... ... .... ...... ................... ..................... .. ........ ......... 6

2.2.2 Définition de la robotique ..... .. .......... .... ..... .... ..... ..... ................. .... ....... .... .. 6

2.3 Histoire de la robotique ...... .................. ................. ... .. ...... ............. ............... ... .... .... 7
 VI

2.4 Types de robots .. ... ..... ... .. ................... ... .... ..... ....... ........................ ..... ... .... ..... ....... . Il

2.4.1 Robots mobiles ...... .. ...... .... ...... .. .... ..... .... ...... ........ ... .. .............................. . Il

2.4.2 Robots manipulateurs ... ........ .. ... ........... ......................... .......................... Il

2.5 Constituant d'un robot ................ ...................... .... .......................................... ....... 12

2.5.1 Les actionneurs .............. ..... ... ............................................... .... .. .............. 13

2.5.2 Système mécanique articulé ......... .. ............................................ .. ........ ... 13

2.5.3 Les articulations .............. .. ............ .. .............. ... ............................ ............ 14

2.5.4 Organe terminal ................. ........ .... ................ ........ .......... ....... .. ............. .. 15

2.5.5 Les capteurs ... ............... ................ ... ............. ............. .. .... ....... .................. 15

2.5.6 La commande ....................... ......... ........................................................... 16

2.6 Classification des robots ....................................... ............. .... ..... ................. ... ..... .. 16

2.6.1 Point de vue fonctionnel ........ ......... ..................... .............. .. ... ..... ..... ...... . 17

2.6.2 Classification géométriq ue ......................................... .... .... .... .......... .... ... 19

2.7 Méthodes de commande de servomoteurs ........................... ....... ................... ........ 23

2.8 Conclusion .. ....... .. ..... ........ ... ..... .. ................... ....... ........ .... ..... ..... .. ............... ... ....... 24

Chapitre 3 - Description et modélisation du bras manipulateur ................................... 25

3. 1 Introduction .... .. ............ .................... .......... ..... .... ....... .... ..................... .......... .... .... 25

3.2 Description de la partie mécanique du notre bras manipulateur .............. .. ......... .. 25

3.2.1 La base ............. ... ... ........ .. ...... ... ... .... .... ........ .. ............ .............. ........ ......... 25
 VII

3.2.2 L'épaule ........................................... ....... ... .... ........................ ... ....... ......... 26

3.2.3 Le coude ..... ............... ... .. ..... ..................................... ......... .... ... .. .. ...... ....... 26

3.2.4 La pince ... ....... .. .. .. ... .... .... ............ .............................. ........... .. ... .......... .. .... 27

3.3 Le bras manipulateur assemblé .............. .. .. .................................... .. ..................... 27

3.4 Description des parties constitutives du bras manipulateur ..... .............. ...... ......... 28

3.4.1 Les actionneurs du bras manipulateur ... ... .... ..... .. ...... ........................... 28

3.4.2 Les capteurs ................................ ... ..................................................... ...... 30

3.5 Modélisation ... ................ .. ......... ..... .. ..... ... .. ..... ....... ....... ... .......... ........................... 31

3.5.1 Repères et référentiels ............................................ .. ...... .. ........ .... ... ... ..... 31

3.5.2 Modèle Géométrique Direct (MGD) ........... ............ .. ............ ... ............ .. 35

3.5.3 Le modèle géométrique inverse (MGI) ......... .................. .... .......... ......... 41

3.5.4 Modélisation cinématique directe (MCD) .. ....... ........ ........... .... ............ . 44

3.5.5 Modèle cinématique directe du robot étudié .......... ............................... 44

3.5.6 Modèle cinématique inverse (MCI) ....................... ..... ..... .................... .. . 47

3.6 Conclusion .... ...... .... ... .... .... ...... .... ... .. .. ... ......... ........................ .. .............. .. ........... .. 48

Chapitre 4 - Commande du Bras Manipulateur ............................................................. 48

4.1 Introduction ....................................................................... ... ... ... .......... .... ............. 48

4.2 Matériel utilisé ........................ ... ....... ..... ................ ................. ........................... .... 48

4.2.1 Raspberry Pi 4 B ...... ............. ....... .. .. .... .... .... ............ ................................ 48
 VIII

4.2.2 LSS - Carte adaptateur Lynxmotion Smart Servo ......................... .... .. 50

4.3 Logiciels utilisés: L ' environnement de programmation en Python .. ...... ........ ..... 52

4.4 Commande du bras manipu lateur.. .... ......... .......... .... ... ..... ........................... ........ .. 53

4.4.1 Régulateur PID ......................................................................................... 53

4.4.2 Double asservissement position-vitesse d'un servomoteur

avec PID ..... .. .... .......... ......... ................ .............. ..... ............................. .. .... 61

4.4.3 Régulation par la Logique Floue ........... ........ .. .................................... ... 63

4.4.4 Double asservissement par Logique Floue d'un

servomoteur .. ... ........... ....... .. ............ .. ...... ......... ....................... ........ .. ....... 67

4 .5 Conclusion ........... ................. ........ .... ........................... .... .......................... ...... ...... 69

Chapitre 5 - Interprétations et Comparaison .................................................................. 70

5.1 Introduction ................................................. ... .......... ........ ..... ..... ..... .. .. ................. . 70

5.1.1 Commande de position ..... ........... ...... ....... ................. .......... .......... .......... 70

5.1.2 Commande de vitesse ............................................................................... 71

5.1.3 Double asservissement position-vitesse ........ ............... .. .......... .. ........ ..... 73

5.2 Conclusion ..... ........................................................................ ............... .... ............. 74

Chapitre 6 - Application de contrôle du robot sous Logiciel LABVIEW ..................... 75

6.1 Introduction ........................................................................................................... 75

6.2 Présentation du logiciel Labview .... .... ...... ...... ... .... ..... ..... ...... ..... ... ............. .......... 75
 ix

6.3 Types de commande du bras manipulateur .............. ....... ... ....... ...... .. .... ............... . 76

6.4 Conclusion .. .. .................. ....... ............. .................... .. .. ..... ..... .. ............................... 79

Chapitre 7 - Conclusion Générale .................................................................................... 80

 x

Liste des tableaux

Tableau 3-1 Paramètres techniques des servomoteurs utilisés ... ............. ................... .... ..... 29

Tableau 3-2 Caractéristiques techniques du notre bras manipulateur. ....... ........... .. .... ...... ... 39

Tableau 3-3 Tableau des paramètres de DENAVIT - HATENBERG de notre

réalisation . ....... .. .............. ... ......................... ....................... ............. ............. 40

Tableau 4-1 les règles de base pour la position du mouvement dans le

servomoteur ................... .................................................. ... ....... .... .... .. ...... ... 64

Tableau 4-2 les règles de base pour la vitesse du mouvement dans le

servon1oteur ............................................... .............. ........... .......................... 66

Tableau 4-3 les règles de base pour la position et la vitesse du mouvement dans
le servomoteur ............. ..... .................... ......... ....... .. .......... ............................ 68
 Xl

Liste des figures

Figure 2-1 Les robots de fiction ........ .......... ...... .. .... ...... .............. .. ................................ ......... 7

Figure 2-2 UNIMATE [13], premier robot industriel. .... .. ............ .. ............................ ..... ...... 8

Figure 2-3 Le premier robot mobile (rover) sur la planète Mars [14] ................................... 9

Figure 2-4 Une table d'opération surmontée des bras d'un Da Vinci [15]. .......... .................. 9

Figure 2-5 Big Dog un Quadrupède [16]. .. ................................................... ....................... 10

Figure 2-6 Graphique représentant l' estimation des expéditions annuelles

mondiales de robots industriels par régions [17] ............ ... ..... ....... .. ..... ........ 10

Figure 2-7 Robot mobile OMRON [18] ..... .. ..... .. ...................... .... ......................... ..... ...... .. Il

Figure 2-8 Bras Manipulateur [19] ..................... ......................... ...... ........ .... ....... ............... 12

Figure 2-9 Éléments d' un robot manipulateur ............ .. ............. ..... ......... .. ... ...... ... .. .. .. ....... . 12

Figure 2-10 Schématisation d'un système mécanique articulé [21]. ...... ....... .... .... ......... .. .... 14

Figure 2-11 Représentation d' une articulation rotoïde [20]. ......................... ... ... .............. ... 14

Figure 2-12 Représentation d' une articulation prismatique [20]. ... .. .... ..... ....... ...... ............ . 15

Figure 2-13 Système de télé chirurgie [15] ....... ........ ..... ...... ..... ...... ...... .... .... ... .......... ....... ... 17

Figure 2-14 Manipulateur à cycle préréglé [23]. ......... .. ............... ................ ....................... 18

Figure 2-15 Programmation des mouvements d'un bras robotique sur un

ordinateur [24]. ................................. ......... .. .... ....... ....... .......... .............. ..... .. 19

Figure 2-16 Robot intelligent [44]. ..... .. ....................... .. ... .. ... .. ..................... ........... ............ 19

Figure 2-17 Structure PPP [45]. .......... ..................... ........ ...... .............................................. 20

Figure 2-18 Structure RPP [45]. .......... .. .......................................... .. .... ....... .............. .... ...... 21

Figure 2-19 Structure RRP [45]. ......... ... .. ......... ........ .. .... .. .... .. ...... .... ................... ... .... ..... ... . 21

Figure 2-20 Structure SCARA [45] .... .. .................... .. ... ............... ..... ............ .... ..... .. ........... 22

Figure 2-21 Structure RRR [45] .... ........ ... .. .............. .. ... ..... ... ........... .......... .................... ...... 22
 xii

Figure 3-1 Base du robot [21]. .................. ...... .................... .. ........ ... ...... ............................. . 25

Figure 3-2 Épaule du robot [21]. ..... ........ .. .... ... .......... .... .......... .. ..................... ... ..... .. ........... 26

Figure 3-3 Le coude du robot [21]. ........... .... .. ... .... .................... .... .. ........ ............................ 26

Figure 3-4 La pince du robot [21]. .... .......................... ... ................. ..... ....... .... ............ ....... .. 27

Figure 3-5 Le robot assemblé [21]. .......................... ......................................... ......... .......... 27

Figure 3-6 Servomoteur intelligent Lynxmotion (LSS) [21] ..................... ......... ................. 28

Figure 3-7 Schéma d'un engrenage du servomoteur Lynxmotion [21]. .... .. ......... .... ......... .. 30

Figure 3-8 Capteur absolu magnétique [21]. .... .. ..... ... ..... ...... .......................... .... .... ......... .... 30

Figure 3-9 Le système de coordonnées cartésiennes [32]. ..... ... ... .......................... .............. 32

Figure 3-10 Le système de coordonnées cylindriques [32]. .... .......................... ... ............... . 33

Figure 3-11 Le système de coordonnées sphériques [3 3]. .... ...... .... ......... ..... .... ... ................ 34

Figure 3-1 2 Position d'un solide dans l'espace et son repère associé [34]. ......................... 35

Figure 3-13 Schématisation du lien entre le corps i-l et i [28]. ............ ........ ................ ..... .. 37

Figure 3-14 La relation entre le modèle géométrique direct et le modèle

géométrique inverse avec paramètre Denavit-Rartenberg (DR) ........ ... .... .. . 38

Figure 3-15 Placement des repères selon le modèle DR ... ................... ....... .. .... .. .. .... .. .. .. ..... 39

Figure 3-16 Placement des angles de rotation des joints du bras de Robot selon
le modèle Denavit-Rartenberg .................................................. ......... ... ....... 41

Figure 3-17 Placement de l'angle de rotation 81 selon le modèle Denavit-

Rartenberg ..... ...................... .............. .... ...... ......... ........................................ 42

Figure 3-18 la loi des cosinus et sinus ..... ............................... ...... .. .... .... ... .. ........... .. ........ ... 42

Figure 3-19 Calculer 82, 83.......... .... .... ..... ...... ... .... .. .. ............ .................. ................ .. ........... 43

Figure 4-1 Carte Raspberry Pi 4 B .......... ......... .................. ....................... .. ................... ...... 49

Figure 4-2 LSS - Carte adaptateur Lynxmotion Smart Servo ............. .... ............ .............. ... 51

Figure 4-3 Environnement de développement en Python ... .... ......................... ... ............... .. 52

Figure 4-4 Schéma du régulateur PID [39]. ........ .............. .... ... ......... ... ........ ..... ... ........ ........ 54
 xiii

Figure 4-5 Schéma-bloc de l'implantation du PID en régulation de position ....... ... ............ 54

Figure 4-6 Réponse d ' un servomoteur du bras dans un asservissement

proportionnel , passage de la position zéro à la position 600 =
60° .......... .......... ... ........... .............................. .... ... .......... ... ........ ....... ... .......... 55

Figure 4-7 Réponse d 'un servomoteur du bras dans un asservissement Kp et Ki ,

passage de la position zéro à la position 600 = 60° ......... ............ ...... ..... ...... 56

Figure 4-8 Réponse d' un servomoteur du bras dans un asservissement PID,

passage de la position zéro à la position 600 = 60° ...................................... 58

Figure 4-9 Gain ajusté P Kp=0.9 en position 600 = 60 .. ............... .......... .... .. ...... .... .. ...... ... .. 59

Figure 4-10 Gains ajustés PI Kp=0.9, Ki=1O-5en position 600 = 60 ................................ .... 59

Figure 4-11 Gains ajustés pour PID : Kp=0.9, Ki= 1O-5, Kd=0.3, en position 600
= 60° ................................. .. ............................................ .. ... ... .............. ... ... .. 59

Figure 4-12 Schéma-bloc de l'implantation du PID en régulation de v itesse ..... ... ............. . 60

Figure 4-13 Gains ajustés pour PID : Kp=2 , Ki= 1, Kd= 1, trois vitesses
différentes ........ ...... ........... ...... ........ ........... .................... ........ .................... ... 60

Figure 4-14 Modèle trapézoïdale de la vitesse .......... .......... _....... .... .. _......... ......................... 61

Figure 4-15 Schéma-bloc de la double implémentation de PID tenant compte ............ ....... 62

Figure 4-16 Résultat du double asservissement PID ......... ... ................................................ 62

Figure 4-17 Schéma représentatif du fonctionnement d'lm système par Logique

Floue [41]. .......... ...................................................................................... .... 63

Figure 4-18 Variables linguistiques (8, f1.(8)) pour décrire la position ................................. 64

Figure 4-19 Réponse d ' un servomoteur du bras dans un asservissement avec

logique floue . Passage de la position zéro à la position 1200 =
120° .. ... .... .......... .. ............... ........... .. ...... .... ............................ .. ........ .. ........... 65

Figure 4-20 Variables linguistiques (n , f1.(n)) pour décrire la Vitesse ...... ...... .... .. ............. 66

Figure 4-21 Réponse de la commande de vitesse utilisant la Logique Floue ....... ... ..... ....... 67

Figure 4-22Variables linguistiques pour décrire la position (8, f1.(8)) et lavitesse

(n , f1.(n)) ....... .................... .......... ................ ..... ... .. ................ .. ..................... 68

Figure 4-23 Résultat du double asservissement par la Logique Floue sur la

position (bleu) et sur la vitesse (rouge) . .... .. ................................................. 69
 xiv

Figure 5-1 Logique Floue sur la position, passage de 0° à 60° ................................. ........... 70

Figure 5-2 PID sur la position, passage de 0° à 60°............. ........ .. ................................... .. 71

Figure 5-3 Résultats avec correcteur PID pour trois différentes consignes de
vitesse angulaire 20 0 /s, 40 0 /s, 60 0 /s ............ ............... ....... ... ......................... 72

Figure 5-4 Résultats avec la Logique Floue pour trois différentes consignes de
vitesse angulaire 20 0 /s, 40 0 /s, 60 0 /s ..... .... ................................................ ..... 72

Figure 5-5 Résultats pour le double asservissement position-vitesse avec PID . ..... ......... ... 73

Figure 5-6 Résultats pour le double asservissement position-vitesse avec

Logique Floue ............................................................................................... 73

Figure 6-1 Interface de commande ...................................................................................... 76

Figure 6-2 Interface de commande, rectangle pointillé : configurer le mode et

marche automatique ......... ........... ..................................... ......... ...... ... ....... .... 77

Figure 6-3 La commande par angles avec les potentiomètres ............................................. 78

Figure 6-4 Diagramme bloc de l'interface LabVIEW avec Python .................. ................... 78
 xv

Liste des symboles

SMA Système Mécanique Articulé

CAO Conception Assistée par l'Ordinateur

C Cosinus

S Sinus

8 Vecteur de variable articulaire du bras manipulateur

è Vecteur de vitesse articulaire

w Vitesse angulaire

q Vecteur de position

Matrice de transformation homogène.

DH Denavit -Hartenberg

Distance entre zi-l et zi , le long de xi .

Angle entre zi-l et zi , autour de xi.

8i Angle entre xi-l et xi, autour de zi-l.

di Distance de Oi-l à l'intersection de zi-l avec xi.

Ec Erreur

MGD Modèle Géométrique Direct

MGI Modèle Géométrique Inverse

 xvi

J(q) Matrice Jacobienne

MCD Modélisation cinématique direct

MCI Modèle cinématique inverse

PID Proportionnel, Intégral, Dérivé

Kp Gain Proportionnel.

Ki Gain Intégral.

Kd Gain Dérivé.

PWM Pulse Width Modulation

A.F .R.I Association Française de Robotique Industriel

RPP ouPRP Une articulation Rotoide et deux articulation Prismatiques

RRP Deux articulations Rotoides et une articulation Prismatique

RRR Trois articulation Rotoide consécutives

SCARA Selective Compliance Articulated Robot for Assemblage

 Chapitre 1 - Introduction

1.1 Contexte général

Lorsque nous parlons de la robotique, plusieurs idées viennent à l'esprit de chacun de

nous. Historiquement, nous pourrions nous référer aux premiers concepts et automates de

l' antiquité ou aux premiers robots comme à des personnages de la mythologie.

Même le mot 'robot' a sa propre histoire. Séparer la science-fiction n ' est pas une chose

aisée, notamment qu ' en robotique, nous cherchons parfois à faire réaliser la fiction, un

exemple de l'influence des fictions nous est donné par les lois de la robotique [1].

Depuis la révolution industrielle, la robotique comme discipline a marqué l' évolution du

monde technologique. L ' avènement des robots dans l' industrie a permis de soulager

l'homme des travaux répétitifs et difficiles tels que : le déplacement d ' objets lourds, les

tâches d'assemblages, les microsoudures, etc. [2].

1.2 Problématique

Depuis leur introduction dans l' industrie, les robots manipulateurs ont beaucoup

évolué, et aujourd ' hui deviennent de plus en plus complexes, intelligents et utilisés dans

plusieurs domaines . Il existe plusieurs types de robots conçus pour des tâches bien

spécifiques. Ces dernières sont associées généralement à des travaux qui peuvent être

pénibles, fatigants, dangereux ou irréalisables par l'homme. Citons à titre d' exemple, ceux

devant être exécutés dans les environnements hostiles dont l'air est irrespirable, à savoir, dans
 2

les centrales nucléaires, dans l'espace, dans les océans, ou certains travaux répétitifs faisant

intervenir les capacités intellectuelles de l'être humain. Diverses raisons ont, également,

contribué au développement de l'intelligence artificielle et de la robotique.

Dans la plupart des processus industriels, il est indispensable de maîtriser certains

paramètres physiques. En automatique, lorsque nous souhaitons atteindre une certaine

vitesse, température, position, angle ... , il est souvent nécessaire d' avoir recours à un

asservissement, c' est à dire un système capable d' atteindre et de maintenir une consigne en

utilisant une mesure. Les nouvelles applications des robots offrent des performances très

élevées notamment en termes de précision. Toutefois, elles demandent des coûts de plusieurs

milliers de dollars par servomoteur. En revanche, la finesse et la précision des mouvements

sont souvent une limite dans les robots à faible coût en raison de la qualité des

servomécanismes, de la qualité des encodeurs et des conditions variantes de l' environnement

d' action du robot. Ceci limite leur déploiement à des prix accessibles au grand public.

Les techniques de contrôle dont le contrôle proportionnel-intégral-dérivée (PID), et

plusieurs types de contrôleurs PID non linéaires (NPID) ont été présentés et utilisés

efficacement. Bohn et Atherton [3] ont développé un contrôleur NPID avec un schéma anti-

emballement (anti-windup) qui peut résoudre le problème d'enroulement de l'intégrateur.

Han [4] a proposé un nouveau contrôleur NPID avec une structure simple, dans lequel trois

paramètres de contrôleur étaient des fonctions de puissance concernant l'erreur, l'intégrale de

l'erreur et la dérivée de l'erreur, respectivement. Afin d'améliorer la capacité de rejet des

perturbations du contrôle PD linéaire lorsqu'il était dans un système d' ordre deux typique.

Xu et al. [5] ont proposé un contrôleur PD non linéaire (NPD) et l'ont appliqué au contrôle

de force des robots. Armstrong et al. [6] ont étendu le contrôleur proposé par Xu et al. à un
 3

système à trois ordres qui a prouvé la stabilité asymptotique du système en boucle fermée par

la méthode de Lyapunov. De plus, avec le développement de la théorie du contrôle, des

stratégies de contrôle intelligentes telles que le contrôle flou et le système expert sont

combinées avec le contrôleur PID conventionnel, et les performances du contrôleur PID

conventionnel sont considérablement améliorées.

Le contrôle par Logique floue est l'un des résultats les plus importants de la recherche

dans le domaine de l'intelligence artificielle à faible complexité [46]. Ce type de contrôleur

a été introduit efficacement dans une vaste gamme d' applications, de la reconnaissance

vocale et d'image aux grille-pains et aux transmissions automobiles.

La logique floue est une technique pour incarner la pensée humaine dans un système de

contrôle [47-48]. Le contrôle flou a été principalement appliqué au contrôle de processus à

travers des performances linguistiques floues , car il donne les meilleures performances

dynamiques ainsi que la réduction des erreurs.

Lorsque le contrôleur PID est utilisé dans le contrôle de position pour contrôler le

système d'asservissement, certains obstacles apparaissent tels que les comportements en

termes de système de non-linéarité, de temps de réponse et enfin d'objectifs d'ingénierie tels

que le coût et la fiabilité . Les non-linéarités et le fait de ne pas connaitre certains paramètres

sont de facteurs qui motivent nombreux chercheurs à utiliser la théorie et les teclmiques de

contrôle non conventionnelles. Ces paramètres peuvent ne pas être estimés avec précision en

l'absence de données expérimentales fiables, et les retards présents dans le processus du

système peuvent compliquer la réalisation d'un contrôle de haute performance. Le contrôleur

à logique floue est utilisé dans le système de contrôle lorsque le modèle mathématique du
 4

processus concerné est vague ou présente des incertitudes. Un avantage d'utiliser la

commande à logique floue est que le contrôleur développé peut gérer un système de plus en

plus complexe. Il peut également se mettre en œuvre sans connaissances précises de la

stmcture du modèle de système dynamique . Néanmoins, le problème essentiel est d'étudier

le problème du robot manipulateur sous deux aspects : le premier est la modélisation

mathématique du manipulateur et des actionneurs, qui comprend une analyse pour la

cinématique directe, la cinématique inverse et la modélisation du servomoteur car c'est une

question importante dans un robot manipulateur. Le deuxième problème concerne la

conception d'un contrôleur pour le mouvement du robot manipulateur afin de répondre à

l'exigence de l'entrée de la trajectoire souhaitée avec des valeurs d'erreur et de perturbation

appropriées.

1.3 Objectifs

Dans ce travail de recherche, nous nous sommes concentrés à déterminer la fonction

pennettant de corriger la commande en fonction de la consigne initiale et de l'erreur mesurée,

tout en nous intéressant aux commandes; afin d'obtenir de meilleures performances et plus

de robustesse pour générer un mouvement doux dans les bras robotisés à faible coût.

La précision (p.ex. manipulation des objets de petite taille), la rapidité (p.ex. dans une

chaine de montage) , et la finesse (p .ex. applications médicales ou manipulation de produits

dangereux) des actions et des mouvements ont été alors l' objet d'analyse dans ce mémoire

de maîtrise sur l' asservissement de la position et la vitesse des bras robotisés. Ayant dans

l'esprit l' utilisation finale des robots à faible coût, nous analyserons dans ce mémoire la

commande PID (classique) et la commande par Logique Floue (moderne) et présenterons des
 5

résultats de simulation et expérimentaux des tests réalisés avec chaque méthode. Cette

analyse est faite dans le contexte d'un robot manipulateur à faible coût que nous avons

constmit au laboratoire.

1.4 Méthodologie

Dans tout projet de recherche, la mise en position de la problématique et des objectifs fait

suite à l'analyse de la littérature et à l'étude bibliographique. Nous continuons ainsi la

recherche à partir des résultats antérieurs , nous pouvons ainsi ouvrir de nouvelles pistes de

la recherche. En même temps, c 'est un moyen d'analyse critique des travaux de recherches

précédents qui rapportent les diverses méthodes de modélisation et les multiples techniques,

classiques et modernes, de commande des manipulateurs robotiques flexibles présentées dans

la littérature du domaine étudié.

Puis, et dans le but de compléter l'étude théorique par une étude expérimentale de

différentes stratégies de contrôle, nous disposons d'un manipulateur constitué d'un moteur à

courant continu, un bras flexible, un encodeur qui mesure l'angle. La description du montage

suivie d'une étude détaillée sur les différentes méthodes de modélisation développées est

présentée au troisième chapitre de ce rapport.

Les diverses techniques de commande peuvent être regroupées en deux catégories : les

méthodes classiques et les méthodes modernes. Les techniques de contrôle classiques comme

le contrôle proportionnel-intégral-dérivé (PID), les techniques de contrôle modernes comme

le contrôle par Logique Floue. Dans ce chapitre sont aussi présentés : les résultats de

simulation et les résultats expérimentaux obtenus suite à l'application de ces techniques de

commande. Nous clôturons, ce chapitre par une comparaison entre les résultats obtenus par
 6

les méthodes classiques et ceux obtenus par les techniques modernes . Après cette

comparaison, nous déterminerons la commande la plus robuste, et proposerons une

application sous LabVIEW pour contrôler le bras robotique.

Finalement, ce travail se termine par une conclusion générale qui résume les résultats

obtenus et une brève description du travail funIT pouvant avoir lieu dans ce domaine de

recherche comme une suite à ce projet.

 Chapitre 2 - État de l'Art

2.1 Introduction

Dans le domaine passionnant de la robotique, les exigences dans la commande des

machines deviennent de plus en plus importantes en fonction des particularités de chaque

application. L'utilisation de la robotique consiste à l'automatisation de nombreux secteurs de

l'activité humaine afin, par exemple, d'augmenter la productivité dans les entreprises des

domaines médical, spatial , industriel, militaire et dans le domaine de l' agriculture. Celle-ci

permet de manipuler, avec beaucoup de précision et par conséquent, de manière plus sùre,

divers produits ou objets, neutres ou dangereux.

Dans ce chapitre, nous donnerons un bref historique sur l'évolution de la robotique

industrielle et un aperçu non exhaustif sur les robots.

2.2 Définitions

2.2.1 Définition d'un robot

Appareil automatique capable de manipuler des objets ou d'exécuter des opérations

selon un programme fixe , modifiable ou adaptable [7] .

2.2.2 Définition de la robotique

La branche de la technologie qui traite la conception, la constmction, l'exploitation

et l' application des robots [7].

 7

2.3 Histoire de la robotique

Soldats, musiciens, ou aides-soignants, les robots sont de plus en plus présents et

humanisés, ils nous fascinent mais également nous inquiètent comment sont-ils nés et quel

est leur futur. La Figure 2-1 montre quelques exemples de robots de fiction.

Robot Tas [8] Robot maria dans le film Le Robot Robby [10]
Fritz Lang métropolies [9]

Le Robot R2D2 [11] La Saga Terminator [12] Le Robot WALL-E [10]

Figure 2-1 Les robots de fiction.

Les robots de fiction: C' est en 1920 qu' apparait pour la première fois le mot robot dans

une pièce de théâtre de science-fiction écrite par l'écrivain tchèque Karel Capek [8]. Le terme

robot dérive de mot slave « robot tas» qui signifie travail corvée utilisé pour nommer un des

personnages comme un serviteur mécanique à l'aspect humain.

 8

En 1927, d'autres figures robotisées apparaissent, les spectateurs découvrent le robot

Maria dans le film de Fritz Lang Metropolis [9]. Avant de devenir des acteurs du monde réel,

les robots sont en premier lieu des stars de la littérature des arts graphiques et du cinéma

souvent pleins d' humanité comme Robby [10], le robot WALL-E [6] ou R2D2 [11] ; ils sont

aussi parfois les destructeurs et des ennemis, parfois amis, du genre humain comme les robots

de la saga Terminator [8].

Aux années 1950, les mathématiciens et les ingénieurs se sont intéressés avec les

robots de manipulation au sujet tel l' américain Joseph Engelberger [13]. C'est ainsi qu'une

nouvelle science a vu le jour: la robotique; le robot est désormais une machine qui bouge,

commandée par un ordinateur. Elle se distingue des autres machines par une capacité propre

à décider de son mouvement. Au fil des décennies, le robot a trouvé sa place dans nombreux

domaines d'application industriels, d'exploration spatiale et maritime, médecine etc ...

En 1969, le premier robot du monde réel s'appelle UNIMATE (Figure 2-2), il s'agit d'un

robot industriel crée par Victor Scheinman de l'Université de Stanford qui inventa un bras

articulé sur 6 axes. Sheinman venda son concept à UNIMATE plus tard [13].

Figure 2-2 UNIMATE [13], premier robot industriel.

 9

En 1996, le robot part dans l'espace, Sojourner (Figure 2-3) explore la planète Mars,

découvre son sol et l'analyse des roches [14].

Figure 2-3 Le premier robot mobile (Rover) sur la planète Mars [14].

En 2000, le Da VinCi (Figure 2-4) est un robot assistant du chirurgien qui apparaît dans
les blocs opératoires [15].

Figure 2-4 Une table d'opération surmontée des bras d'un Da Vinci [15].
 10

Par la suite, aujourd ' hui , des robots mobiles sont conçus pour intervenir dans des milieux
hostiles comme Big Dog (Figure 2-5) un quadrupède porteur de charges lourdes testé par
l'armée américaine en Afghanistan [16] .

Figure 2-5 Big Dog un Quadrupède [16].

Tel que montré par la Figure 2-6, les expéditions annuelles de robots industriels ont vu

une croissance assez importante au cours des dernières années. Plus particulièrement, en

provenance des pays asiatiques.

EStlmaled worldwldl Innu 1sl'upments or InduSlllal robots by

raglon.

Figure 2-6 Graphique représentant l' estimation des expéditions annuelles mondiales de

robots industriels par régions [17].

 Il

2.4 Types de robots

Il existe deux grandes catégories de robots : les robots mobiles et les robots

manipulateurs. Toutefois, il peut avoir des configurations hybrides mobiles+manipulateurs

pour des applications spécifiques, p.ex. , agricoles, d' exploration, sauvetage.

2.4.1 Robots mobiles

Les robots mobiles ont la capacité de se déplacer dans leur environnement et ne sont pas

fixés à un seul emplacement physique. Les robots mobiles peuvent être « autonomes », ce

qui signifie qu'ils sont capables de naviguer dans un environnement incontrôlé sans avoir

besoin de dispositifs de guidage physiques ou électromécaniques. Un exemple est illustré

dans la Figure 2-7.

Figure 2-7 Robot mobile OMRON [18] .

2.4.2 Robots manipulateurs

Un bras manipulateur est le bras d'un robot généralement programmable, avec des

fonctions simi laires à un bras humain. Les liens de ce manipulateur sont reliés par des axes

permettant, soit de mouvement de rotation (comme dans un robot articulé) et/ou de

translation (linéaire) de déplacement.

 12

Dans le cas d'une imitation complète d'un bras humain, un bras manipulateur a donc 3

mouvements de rotation et 3 mouvements de translation sur son élément terminal.

Il peut être autonome ou contrôlé manuellement et peut être utilisé pour effectuer une

variété de tâches avec une grande précision selon la qualité des servomécanismes et des

méthodes de contrôle employées [19]. Un exemple est illustré par la Figure 2-8 .

Figure 2-8 Bras Manipulateur [19].

2.5 Constituant d'un robot

Tel que montré par la Figure 2-9, nous distinguons classiquement 4 parties principales

dans un robot manipulateur [20] : les actionneurs, le système mécanique articulé et organe

tenninal, les capteurs et la commande.

Système mècanique
Actionneurs articulé (S.M.A) + Capteur
organe terminal

r--------,~
~ \

Environnement
Système de commande
et de traitement de
l'information ( Informations extéroceptives

Figure 2-9 Éléments d'un robot manipulateur.

 13

2.5.1 Les actionneurs

Les composants permettant de mettre en mouvement les organes des machines sont

appelés actionneurs. Ce sont essentiellement des moteurs et des vérins. Ils produisent de

l'énergie mécanique à partir d'énergie électrique, hydraulique ou pneumatique, mais sont

presque toujours contrôlés par des signaux de commande électriques. Avec l'évolution

technologique progressive dans le domaine de l'informatique et l'électronique tel que les

micro-ordinateurs, l'automate programmable, les microprocesseurs et les microcontrôleurs

ainsi que les composantes semi-conductrices, etc. ; les actionneurs électriques sont de plus

en plus utilisés dans le domaine de la robotique [20].

2.5.2 Système mécanique articulé

Le système mécanique articulé (SMA) est un mécanisme ayant une structure plus ou

moins proche de celle du bras humain, il peut être représenté par une architecture composée

de plusieurs chaînes de corps rigides assemblés par des liaisons appelées articulations,

généralement les uns à la suite des autres où chaque solide est mobile par rapport au

précédent. Cette mobilité s' exprime en termes de degrés de liberté (d.d.l) qui est par

définition le nombre de mouvements indépendants possibles d'un solide Sn-l par rapport au

solide qui lui est directement relié Sn (Fig. 2-10). Le rôle du SMA est d'amener l'organe

terminal dans une situation (position et orientation) donnée, selon des caractéristiques de

vitesse et d'accélération données. Sa motorisation est réalisée par des actionneurs électriques,

pneumatiques ou hydrauliques qui transmettent leurs mouvements aux articulations par des

systèmes appropriés [20].

 14

Segment Organe Terminal

Articulation

Figure 2-10 Schématisation d'un système mécanique articulé [21] .

2.5.3 Les articulations

Une articulation lie deux corps successifs en limitant le nombre de degrés de liberté de

l'un par rapport à l'autre, peut se ramener à une combinaison d'articulations prismatiques ou

rotoïdes.

2.5.3.1 Articulation Rotoïde

Il s'agit d'une articulation de type pivot, notée R, réduisant le mouvement entre deux

corps à une rotation autour d'un axe qui leur est commun. La situation relative entre les deux

corps est donnée par l'angle autour de cet axe (Fig.2.l1).

--a=J-t-. El------+--.

Figure 2-11 Représentation d'une articulation rotoïde [20].

 15

2.5.3.2 Les articulations prismatiques

Il s'agit d'une articulation de type glissière (translation), notée P, réduisant le mouvement

entre deux corps à une translation le long d'un axe commun. La situation relative entre les

deux corps est mesurée par la distance le long de cet axe (Fig.2.12).

Figure 2-12 Représentation d 'une articulation prismatique [20].

2.5.4 Organe terminal

Nous regroupons tous les dispositifs destinés à manipuler des objets (dispositifs de

serrage, dispositifs magnétiques, à dépression, . . . ), ou à les transformer (outils, torche de

soudage, pistolet de peinture, ... ). En d'autres termes, il s'agit d'une interface permettant au

robot d'interagir avec son environnement. Un organe terminal peut être multifonctionnel , au

sens où il peut être équipé de plusieurs dispositifs ayant des fonctionnalités différentes . Il

peut aussi être monofonctionnel, mais interchangeable. Un robot, enfin, peut-être multi-bras :

chacun des bras portant un organe terminal différent. On utilise, indifféremment, le terme

organe terminal, préhenseur, outil ou effecteur pour nommer le dispositif d'interaction fixé à

l'extrémité mobile de la structure mécanique [20].

2.5.5 Les capteurs

Les informations extéroceptives ou plus simplement les perceptions permettent de gérer les

relations entre le robot et son environnement. Les organes de perception sont des capteurs
 16

dits proprioceptifs lorsqu ' ils mesurent l'état interne du robot (positions et vitesses des

articulations) et extéroceptifs lorsqu'ils recueillent des infOlmations sur l'environnement

(détection de présence, de contact, mesure de distance, vision artificielle) [20].

Les principales sortes de capteurs sont:

• Les sondeurs (ou télémètres) à ultrason ou Laser. Ces derniers sont à la base des

scanners laser permettant à l'unité centrale du robot de prendre « conscience» de son

environnement en 3D.

• Les caméras sont les yeux des robots. Il en faut au moins deux pour permettre la

vision en trois dimensions. Le traitement automatique des images pour y détecter les

formes, les objets, voire les visages, demande en général un traitement matériel car

les microprocesseurs embarqués ne sont pas assez puissants pour le réaliser.

• Les roues codeuses permettent au robot se déplaçant sur roues, des mesures de

déplacement précises en calculant les angles de rotation (infomlation proprioceptive)

[22] .

2.5.6 La commande

La partie commande synthétise les consIgnes des asservissements pilotant les

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

2.6 Classification des robots

La classification des systèmes robotiques est difficile, car il existe de nombreux critères

pour leurs descriptions. Toutefois, nous allons les classer selon deux structures qui sont les

suivantes :

• Point de vue fonctionnel.

 17

• Point de vue géométrique.

2.6.1 Point de vue fonctionnel

Le nombre de classes et les distinctions entre celles-ci varient de pays à pays (6 classes

au Japon, 4 en France). L' AF.R.I. distingue 4 classes illustrées ci-dessous [23] :

2.6.1.1 Manipulateur à commande manuelle

La figure suivante (Figure 2-13) représente un manipulateur à commande manuelle d' un

système de télé chirurgie.

Figure 2-13 Système de télé chirurgie [15].

2.6.1.2 Manipulateur automatique à cycles préréglés

Le réglage se fait mécaniquement par cames, butées. La commande peut se faire par

automate programmable (Figure 2-14) ; Nous pouvons ainsi faire la distinction entre

manipulateurs à cycle fixe et entre manipulateurs à cycle programmable.

 18

l'

Figure 2-14 Manipulateur à cycle préréglé [23].

2.6.1.3 Robots programmables

Les mouvements d'un robot industriel sont programmés à travers deux grandes

méthodes :

La méthode par apprentissage est la première historiquement appame. Elle consiste à

créer les trajectoires en faisant mémoriser au robot des points correspondant à des

coordonnées cartésiennes et qui détermineront sa position. Celle-ci s'effectue directement sur

le robot en utilisant le boitier de contrôle.

La seconde méthode, plus récente, est la programmation hors-ligne. Sur un ordinateur

de travail dédié, l'opérateur pourra programmer la prochaine tâche via un logiciel de

programmation hors-ligne en important un modèle CAO grâce auquel il pourra générer les

mouvements . Tel que montré dans la Figure 2-15 , il pourra par la suite visualiser le résultat

de sa programmation grâce à un simulateur intégré qui est tille représentation virtuelle de

l'environnement de travail du robot avec toutes ses composantes [24].

 19

Figure 2-15 Programmation des mouvements d'un bras robotique sur un ordinateur [24].

2.6.1.4 Robots intelligents

Nous trouvons actuellement des robots de seconde génération qui sont capables d'acquérir et

d'utiliser certaines informations sur leur environnement (systèmes de vision, détecteurs de

proximité, capteurs d'efforts, ... ). Nous étudions des robots de troisième génération, capables

de comprendre un langage oral proche du langage naturel et de se débrouiller de façon

autonome dans un environnement complexe, grâce à l'utilisation de l' intelligence artificielle

[25]. Un exemple de robot « intelligent» est montré dans la Figure 2-16.

Figure 2-16 Robot intelligent [44] .

2.6.2 Classification géométrique

Il existe différentes architectures du porteur : la structure cartésienne (PPP), la structure

cylindrique (RPP ou PRP), la structure sphérique ou polaire (RRP), la structure dite SCARA

(RRP) et enfin la structure anthropomorphe (RRR).

 20

2.6.2.1 Structure cartésienne (PPP)

Les caractéristiques d'une structure cartésienne (PPP) sont : trois axes, deux à deux en

série avec trois degrés de liberté, une très bonne précision et une grande lenteur. Le volume

de travail est un parallélépipède dont les dimensions sont les translations permises par les

trois liaisons prismatiques [26]. Un schéma simplifié d'une structure cartésienne (PPP) est

présenté dans la Figure 2-17.

Figure 2-17 Structure PPP [45].

2.6.2.2 La str ucture cylindrique (RPP) ou (PRP)

Les caractéristiques d 'wle structure cylindrique (RPP ou PRP) sont : trois axes non

perpendiculaires en série avec trois degrés de liberté et une grande rapidité. Le volume de

travail est un cylindre plein ou creux, autrement dit un tore à section rectangulaire, dont la

hauteur L est la translation permise par une liaison prismatique [27]. Un schéma simplifié

d'une structure cylindrique (RPP ou PRP) est présenté dans la Figure 2-18.
 21

Figure 2-18 Structure RPP [45].

2.6.2.3 La structure sphérique ou polaire à axe de rotation orthogonale (RRP)

Le volume de travail est une sphère creuse, dont les rayons intérieur et extérieur sont

fixés soit par la disposition de la liaison prismatique et la translation qu 'elle permet, soit par

les longueurs des deux parties du bras [28]. Un diagramme simplifié d 'une structure polaire

à axe de rotation orthogonale (RRP) est présenté dans la Figure 2-19.

Figure 2-19 Structure RRP [45].

2.6.2.4 La structure dite SCARA

Les caractéristiques d' une structure SCARA (Selective Compliance Articulated Robot

for Assemblage) sont : 3 axes en série cylindrique (RRP) ayant trois degrés de liberté. Les
 22

particularités de cette structure sont qu' elles sont précises et très rapides [28] . Un exemple

de structure SCARA est illustré dans la Figure 2-20.

Figure 2-20 Structure SCARA [45].

2.6.2.5 La structure anthropomorphe (RRR)

Cette structure à une architecture plus généraliste reproduisant le bras humain. Son

enveloppe de travail a une cinématique et dynamique complexe, mais sa configuration est

plus flexible [29]. Un diagramme simplifié de la structure anthropomorphe (RRR) est

présenté dans la Figure 2-21.

Figure 2-21 Structure RRR [45].

 23

2.7 Méthodes de commande de servomoteurs

La méthode la plus courante pour réaliser un asservissement de servomoteurs est la

commande PID qui est aujourd'hui l'un des asservissements les plus utilisés et ce pour

plusieurs raisons. Tout d' abord, il est très simple à mettre en place et s'avère efficace pour la

plupart des systèmes réels. Ensuite, le calcul des coefficients laisse le choix entre plusieurs

méthodes de difficulté croissante. De plus, c'est une méthode expérimentale très facile à

mettre en place, permet d'obtenir rapidement des coefficients corrects pour des systèmes ne

nécessitant pas de très grandes précisions dans l'asservissement. Cependant, il est important

de noter que ce type d'asservissement est limité par un certain nombre de contraintes. En

effet, il peut s'avérer inefficace pour certains systèmes qui contiennent du bruit (coefficient

Dérivé) ou qui ne sont pas linéaires (l'asservissement PID étant linéaire, la non-linéarité d'un

système peut entraîner des pertes de performance et des instabilités).

Il existe diverses méthodes pour commander une boucle d'asservissement. La méthode

moderne de contrôle par logique floue réunit un certain nombre d'avantages et

d'inconvénients . Les avantages essentiels sont [30] :

- Pas de modèle mathématique requis pour le procédé à réguler ;

- La théorie est simple et peut s'appliquer à des systèmes complexes ;

- La commande peut facilement être auto-adaptative ;

- La commande floue conduit à un code informatique clair et lisible.

Par contre, les inconvénients sont:

- La technique de réglage est totalement empirique ;

 24

La précision du réglage est souvent peu élevée ;

- La cohérence des inférences n' est pas garantie à priori ; il est possible l'apparition

de règles d'inférence contradictoires.

Nous nous intéressons alors à l 'étude expérimentale comparative de la commande PID et

la Logique Floue dans l'objectif d'assurer une réponse acceptable pour des signaux de

consigne définis en fonction du temps.

2.8 Conclusion

Dans ce chapitre, nous avons donné un aperçu général sur la robotique. Nous avons

présenté, également, une description sur le domaine de la robotique en mettant l'accent sur

les domaines applicatifs des robots industriels, l 'historique des robots, l'architecture

mécanique générale des bras manipulateurs, leurs stmctures, leurs utilisations, leurs

différents types, leurs classifications ainsi que leurs domaines d'application ce qui va nous

servir pour la constmction de notre bras. Nous avons fini le chapitre par l'étude des avantages

et des inconvénients des deux méthodes de commande utilisées selon littérature. Nous allons

par la suite commencer la partie technique et la plus concrète de cette étude.

 Chapitre 3 - Description et modélisation du bras
manipulateur

3.1 Introduction

L' une des premières étapes dans la réalisation d' un robot consiste à définir le mode de

locomotion à mettre en œuvre ainsi que les différents éléments qui le composent, ceci se

matérialise par l' étude des actionneurs des chaînes cinématiques associées et aussi par l' étude

des capteurs qui constituent la source d'information.

Dans ce chapitre, nous présenterons l' architecture mécanique générale du bras

manipulateur et nous donnerons également des notions théoriques qui nous aideront à

l' aboutissement de la modélisation de notre système.

3.2 Description de la partie mécanique du notre bras manipulateur

3.2.1 La base

La base est le socle fixe du bras. Elle possède un servomoteur qui permet au bras de

tourner un tour complet sur un angle de 360 0 autour de la verticale.

Figure 3-1 Base du robot [21].

 26

3.2.2 L'épaule

Elle est liée à la base à travers la deuxième articulation (servomoteur), qui permet la

rotation de 0° à 180° .

.......... ,.......
........... .....

Figure 3-2 Épaule du robot [21].

3.2.3 Le coude

Il est lié à l'épaule par la troisième articulation, qui permet la rotation de 0° à 180°.

Figure 3-3 Le coude du robot [21] .

 27

3.2.4 La pince

La pince est l'organe terminal de notre robot manipulateur, un servomoteur qui permet

l'ouverture et la fermeture de la pince de rotation de 0 0 à 1800 .

...
Figure 3-4 La pince du robot [21].

3.3 Le bras manipulateur assemblé

Après avoir vu les différentes pièces constituant le bras manipulateur, nous sommes passé
à leur assemblage. La figure ci-dessous montre le bras manipulateur après l'assemblage.

Figure 3-5 Le robot assemblé [21] .

 28

3.4 Description des parties constitutives du bras manipulateur

Pour que le bras manipulateur puisse exécuter une tâche, il a besoin des actionneurs et

des transmetteurs, ces derniers servent à transmettre de l'énergie des actionneurs des

articulations rotoïdes. De plus, pour asservir ces actionneurs, nous avons besoin également

de capteurs.

3.4.1 Les actionneurs du bras manipulateur

Il s' agit d'organes qui permettent au robot d' exécuter une tâche. Leur but est de produire

assez de force pour provoquer le mouvement du robot. Nous avons choisi d'utiliser comme

actionneurs quatre servomoteurs qui sont des moteurs à courant continu (MCC), asservis en

position à l'aide d'un capteur de position et d'un circuit électronique interne au moteur. Les

servomoteurs de positionnement angulaire permettent de déplacer précisément un objet dans

une plage de 0° à 360° [21].

Ils sont pilotés par un fil de commande et alimentés par deux autres fils, le premier est

relié à l'alimentation positive +6 ou + 12 V selon le servo, le deuxième est relié à la masse

(GND) [31].

Figure 3-6 Servomoteur intelligent Lynxmotion (LSS) [21] .

 29

3.4.1.1 Les paramètres techniques des servomoteurs

Les paramètres des servomoteurs utilisés dans le bras robot sont présentés au Tableau 3-

l [21].

Tableau 3-1 Paramètres techniques des servomoteurs utilisés

~
Spécifications
ST1 HT1

Tension 6V à 12.6 6V à 12.6

Couple Max. couple

dynamique 12V 2,8 kg-cm 5,8 kg-cm
(- 25%)
Angle
Jusqu'à 360 0 Jusqu'à 360 0
de fonctionnement

Poids 58,0 g 80,0 g

0
Vitesse Maximal 360 0
/ s 360 / s

3.4.1.2 Transmission entre articulations: engrenage

Un moteur à courant continu tourne normalement à des vitesses de l'ordre de plusieurs

milliers de tours par minute et produit un couple très faible. Afm de diminuer cette vitesse de

rotation tout en augmentant significativement le couple disponible, nous plaçons entre l'axe

du moteur et l'axe articulaire un réducteur par les transmissions des engrenages qui sont des

organes mécaniques situés à l'intérieur de la partie supérieure du boîtier. Tel que montré dans

la Figure 3-7. Le train d'engrenages est composé d'une variété d'engrenages droits en métal

[21 ].
 30

Figure 3-7 Schéma d'un engrenage du servomoteur Lynxmotion [21] .

3.4.2 Les capteurs

L'élément qui donne l' information de rétroaction au servomoteur est le capteur de

position. Notre capteur est un capteur absolu magnétique couplé sur la partie avant du moteur

(voir Figure 3-8). Le rôle des capteurs est de gérer les relations entre le robot et son

environnement, ils permettent ainsi de contrôler plus facilement les tâches que nous leur

ordonnerons.

Figure 3-8 Capteur absolu magnétique [21].

 31

3.5 Modélisation

La modélisation des robots consiste à établir un modèle mathématique. Outre une

fonction générale d'aide à la conception, la modélisation a de multiples utilisations pour la

prévision (ou anticipation) des mouvements, l' adaptation des actiotmeurs, la planification des

taches, l'établissement des lois de commande, l'incorporation du robot dans des simulations

informatiques, etc.

Dans le langage courant, la modélisation précède la simulation sans que nous puissions

faire une séparation nette entre ces deux activités. Il est souvent acceptable de se contenter

d' une modélisation simplifiée dans laquelle nous ne tenons pas compte des aspects qui sont,

ou paraissent, secondaires tels que : les vibrations, les défom1ations élastiques, les jeux

mécaniques, les tolérances de fabrication , etc. La modélisation des robots manipulateurs

nécessite le calcul de certains modèles mathématiques, tels que: Le modèle géométrique et

le modèle cinématique [49].

3.5.1 Repères et référentiels

Comme il est illustré dans la Fig.3.9, pour repérer un point M dans l' espace, il faut 3

coordonnées pour le définir parce que l'espace contient 3 dimensions, ce dernier est

représenté par les valeurs algébriques des projections sur une base orthonoffi1ée [32].

3.5.1.1 Coordonnées cartésiennes

Soit un point fixe 0 (appelé origine), constitué de trois axes rattachés, à ce repère, nous

associons tille base orthonormée directe (Ux, Uy, Uz). Les vecteursUx, Uy, Uz sont alors les

vecteurs unitaires des axes OX, OY et OZ respectivement. Les coordonnées cartésiennes sont
 32

les référentiels les plus utilisées en robotique, car elles sont les plus simples pour la mesure

des distances.

z
zH,
,
-_ M

y y

m
x

Figure 3-9 Le système de coordonnées cartésiennes [32].

3.5.1.2 Coordonnées cylindriques

La position du point M est définie dans un repère (0, Up, Ue.Uz). Nous introduisons
la base (U p, Ue. Uz) orthonormée directe, associée aux coordonnées cylindriques (p, 8, z). Les

relations entre les coordonnées cylindriques et cartésiennes sont les suivantes [32].

x = p cos(9)

{ y =p sin(8)

z=z
 33

~---+=---f---Y

x
Figure 3-10 Le système de coordonnées cylindriques [32].

3.5.1.3 Coordonnées sphériques

Prenons comme exemple un point M repéré à la surface de la Terre (0, Ûp, Ûs, Û<p).

La méthode la plus facile pour repérer ce point est de repérer M par 3 coordonnées qui sont:

• La distance depuis O.

• Deux angles de rotation autour de O.

Les relations entre les coordonnées sphériques et cartésiennes sont les suivantes [33] :

x=p sine S)cos(<p )

y=p sin(S)sin(<p)

z = p cos(S)
 34

~
i
i Z

.. _.. _.. _. ..

1Ix;
-------~ ._--~-----
i
---
i

i
i
i
,/

Figure 3-11 Le système de coordonnées sphériques [33].

3.5.1.4 Position et orientation d'un solide

Nous pouvons facilement paramétrer la position d'un point dans un repère avec 3 trois

dimensions quel que soit le système de coordonnées utilisé par contre le repérage de la

position d'un solide nécessite plus de dimensions . Il faut trois coordonnées pour positionner

le centre d' inertie des solides et trois autres coordonnées pour son orientation dans l'espace.

Six coordonnées sont donc nécessaires pour placer un objet dans l'espace [33].
 35

Figure 3-12 Position d' un solide dans l'espace et son repère associé [34].

3.5.2 Modèle Géométrique Direct (MGD)

Le modèle géométrique direct d'un robot permet de calculer les coordonnées

opérationnelles donnant la situation de l'organe terminal en fonction des coordonnées

articulaires, l'expression de la situation de l'organe terminal du bras manipulateur en fonction

de sa configuration est obtenue à l' aide de l'équation suivante :

X= f(q) [35]

Où X est le vecteur des coordonnées opérationnelles exprimées dans le repère de

référence Ro et q les variables articulaires.

Dans le cas d'une chaine cinématique simple ouverte, il peut être représenté par la matrice

TO.n qui se calcule par :

TO,n = TO,I (ql) X TO,2 (q2) x ... . .. X Tj_l ,j (qj)

La matrice TO,n représente la position et l'orientation, elle est exprimée dans le repère de

référence Ro de l'organe terminal (effecteur) du robot.

 36

3.5.2.1 Paramètre de Denavit-Hartenberg (DH)

Les paramètres DH sont utilisés pour systématiser la modélisation de n'importe quel type

de robot série. Elle fut introduite par Jacques DENAVIT et Richard HARTENBERG [35] .

En génie mécanique, les paramètres Denavit - Hartenberg (également appelés paramètres

DH) sont les quatre paramètres associés à une convention particulière pour attacher des

cadres de référence aux maillons d'une chaîne cinématique spatiale, ou manipulateur de

robot. Les paramètres DH permettent de simplifier le modèle géométrique, mais également

d'établir une non11e reconnue par tous .

Afin d' établir les paramètres de DH, chacun des repères est établi en se basant sur trois

règles :

• L' axe Zi-l est selon l' axe de mouvement de l' art-l.

• L' axe Xi-l est aligné entre les articulations i et (i+ 1). Si ai est nul, alors Xi-l est

perpendiculaire à Zi-l et Zi.

• L' axe Yi complète le repère i pour fOn11er un repère « main droite ».

Pour passer de Ri-l a Ri, nous pouvons SUlvre les quatre paramètres géométriques les

suivants :

1- Rotation (Zi-l , 8i) Avec, ai : Distance entre Zi-l et Zi, le long de Xi .

2- Translation (Zi-l , di) ai : Angle entre Zi-l et Zi, autour de Xi.

3- Translation (Xi, ai) 8i : Angle entre Xi-l et xi, autour de Zi-l.

4- Rotation (Xi, ai) di : Distance de Oi-l à l'intersection de Zi-l avec Xi .

 37

l ·
1

Art i {li
, i
Zi_
- 1
1

1
--
COrpS i-I , i
"-
./
1-1
~
j

8;

Figure 3-13 Schématisation du lien entre le corps i-l et i [28].

La matrice de passage d' une articulation est la suivante donc :

rl- 1 = RoI (x, ai) x Trans (x, di) X RoI (z, 8i) X Trans (z, ri) (3. 1)

C8i - S8i 0 di

Ca ;. S8; Cu;.C8; -Sa; -f;.Sa;

T~- l = (3.2)
1
Sai. S8i Sa i.C8i Ca i [ iCa i

0 0 0 1

Pour systématiser la modélisation et simplifier le modèle géométrique de notre bras

manipulateur, nous utilisons les paramètres de Denavit Hartenberg (DH) par la relation entre

le modèle géométrique direct et le modèle géométrique inverse afin de suivre une trajectoire

précise lors du déplacement d 'un objet à un endroit désigné par les coordonnées X, Y, et Z.
 38

91 r1O
) )
r2l
9_
93 )
l
Modèle géométrique direct r 32
)

1 v.
1
p .. )
1 OSluon
Joint \'ariablel
1
1 Modèle géométrique inverse l Effectrice
e· 1
1
)
TOn(x, y, z)
)
rnO

Figure 3-14 La relation entre le modèle géométrique direct et le modèle géométrique inverse

avec paramètre Denavit-Hartenberg (DH) .

3.5.2.2 Modélisation du notre bras manipulateur

Notre bras manipulateur réalise des mouvements avec 3 degrés de liberté et il est

constitué de deux sous-ensembles distincts ;

- Un organe tenninal : c' est un servomoteur qui contrôle l' ouverture et la fermenlre de

la pince.

Structure mécanique articulée contient trois servomoteurs qui contrôlent les

articulations de types rotoïdes. Le rôle de cette stmcnlre est d'amener l'organe

terminal dans une sinlation défLl1ie par une position et orientation donnée.
 39

Tableau 3-2 Caractéristiques techniques du notre bras manipulateur.

Caractéristiques techniques du bras manipulateur

Nombre d' articulations 3
Nombre d' actionneurs 4 servomoteurs
Rotations Angles Types
La base 360 0 Rotoïde
L'épaule 1800 Rotoïde
Le bras
Le coude 180 0 Rotoïde
Ouverture de la pince (en degré) 120 0

3.5.2.3 Identification des paramètres de DH de notre bras manipulateur

Nous affectons des repères fictifs à chaque articulation représentée dans la figure ci-

dessous :

-' -'
-' -'
-' -'
-' -'
-' -'
-' -'
-' 1...2 -' 1..3
/~~--------""":Y'1,~:------=-------?:
)/-'

f7\;
6:z / A ~-'
( // ///
/
-' Y2 -' Y3 -'
.- -'
-'
.-.-
-'

~~+.I'----------:;-!-'---+ X3

-~Xo

Figure 3-15 Placement des repères selon le modèle DH.

Les paramètres, selon DH, sont présentés au Tableau 3-3

 40

Tableau 3-3 Tableau des paramètres de DENA VIT-HA TENBERG de notre

réalisation.

Segment Oi di ai ai

1 el dl 0 90°

2 e2 0 L2 0

3 e3 0 L3 0

cel -Cal.se l sal .se l al.Cel

se l Cal .Ce l -Sa1.Cel al.Se l

(3.3)
o
o

ce2 -Ca2.Se2 Sa2.Se2 a2 .Ce2

se2 Ca2.Ce2 -Sa2.Ce2 a2.Se2

T 2} = (3.4)
0 Sa] Ca2 d2
0 0 0 1

ce3 -Ca3. e3 Sa3. Se3 a3 .Ce3

se, Ca,.ce, -Sa, .Ce, a3.Se,

T32 = (3.5)
0 Sa3 Ca3 d3
0 0 0 1
 41

La matrice de transformation homogène du repère Ro jusqu' au repère R4 s' obtient par la

multiplication successive des matrices du passage précèdent :

Cm -Cl .S23 Sl Ct.( a3C23 + a2C2)

T3 0 = Tlo T2 I T32= SlC23 -Sl.S23 -Cl St.( a3C23 + a2C2)

(3.6)
S23 C23 0 a3S23 + a2S2 + dl
0 0 0 1

3.5.3 Le modèle géométrique inverse (MGI)

Nous avons constaté que le MGD d'un robot permettait de calculer les coordonnées

opérationnelles donnant la situation de l'organe terminal en fonction des coordonnées

articulaires.

Le modèle géométrique inverse consiste à calculer les coordonnées articulaires

correspondant à une situation donnée de l'organe terminal [35].

r ~".•.••.•.
= ..Jx~+yl Y.
!/O
'.
"
" ,
...... .. : ....
............. ................. ...... ...... .. - .....~.":~ ..

Figure 3-16 Placement des angles de rotation des joints du bras de Robot selon le modèle

Denavit -Hartenberg.
 42

La figure suivante présente comment calculer el par la projection sur les deux axes (x, y) :

r x~ +yl
,
»'-

, (Ji = Atan2(x c,Yc)

•

'~--------------. ' .

Figure 3-17 Placement de l' angle de rotation el selon le modèle Denavit-Hartenberg

Calculer el

r = .Jx 2 + y2 (3 .7)

=> (Ji = tan- i (~) (3.8)

el = Atan2(x, y) (3 .9)

La figure suivante présente les formules utilisées pour faciliter l'obtention des équations des

Loi des sinus :

Sin A Sin B Sin C

(3.10)
La Lb Le

Loi de cosinus :

Lc2 =Lb 2 + La2 - 2Lb x La cos(C) (3.11) La

Figure 3-18 la loi des cosinus et sinus.

 43

La figure suivante présente comment calculer 82, 83par la projection sur les deux axes

(x,z) on utilisant les fonnules précédentes

Loi des sinus et cosinus :

On cherche 83 avec la loi de cosinus :

Lc2 =Lb2+ La2- 2Lb x La cos(C) (3.12)

83 = arccos ((x2 + z2 -La2 - Lb 2) /2 La Lb (3.14) Figure 3-19 Calcul des 82, 83.

On cherche 8 avec la loi de sinus :

(3.15)

Z
a = arctan (-) (3.16)
x

Sin A Sin B Sin C

(3 .17)
La Lb Le

Sin () _ Sin (180 - (}3)

(3.18)
Lb "';X 2 +Z 2

Sin () Sin ((}3)

(3.19)
Lb "';X2+Z2

. Sin (03 )
8 = arcsm (Lb x rxz+zï ) (3.20)
x +z
(3.21 )
. (b Sin (9 3)
82=arctan (-Z) - arcsm L X rxz+zï ) (3.22)
x X +z
Donc les coordonnées articulaires correspondant à une situation donnée de l'organe terminal

de notre bras manipulateur sont:

8 1 = tan- 1 (~) (3.23)

8 - t
2 - an
-1 (~) _
x
. -1
sm
(a3xSin93)
../X 2 +Z 2 (3 .24)
 44

- -1 x 2+z 2a 22a 3 2)
83 - COS ( (3 .25)
2 a 2 a3

3.5.4 Modélisation cinématique directe (MeD)

Le MCD d'un robot manipulateur décrit les vitesses des coordonnées opérationnelles en

fonction des vitesses articulaires . Il est noté :

X=J(q)q [35] (3.25)

Avec, J(q) : Matrice Jacobienne.

Nous pouvons obtenir la matrice Jacobienne par une méthode de calcul direct, fondée

sur la relation entre les vecteurs des vitesses de translation et de rotation Vil et COn du repère

Rn, et les vitesses articulaires ci :

[~~]=Jll(l (3.26)

3.5.5 Modèle cinématique directe du robot étudié

Nous commençons par le calcul des vitesses angulaires :

(3.27)

w 1 =wo + () Z =
° ° ° °° [0]°.
1 ()
(3 .28)

(3.29)
 45

(3.30)

(3 .31 )

(3 .32)

(3 .33)

Cl C23 -Cl S23

W~ = R~ W~ = Sl C23 -Sl S23 (3 .34)
[
S23 C23

Ensuite, on poursuit par les vitesses linéaires :

(3.35)

° ° ° °° [0]°.
w l = WO + () Z =
1 ()
(3 .36)

(3.37)

(3.38)
 46

(3 .39)

C2 S2
2 - R1 V2 -
V2 - 2 1 - -S2 2C (3.40)
[
o 0

(3 Al)

(3.42)

C1 C23 -C1S23
VJ= RJ V;= [ S3 C23 -Sl S 23 (3.43)
S23 C23

_ [-L3 C23 S 1 L 2 C1 (S3 C 23 - C3 S 23) - L 3 c 1 S 23

- L 3 C23 C1 L 2 s 1 (S3 C23 - C3 S 23) - L 3 s 1 S 23 (3.44)
o L2(S3S23 - C3C23) - L3C23

Le modèle cinématique dans R3 est donnée par :

0 L 2s 3 0
0 L3 + L 2 C3 L3

[~tl =
-L 3 C23 0 0
(3.45)
S23
c23
0
0
0
0
[::1
0 1 1
 47

Le modèle cinématique finale dans Ro est donnée par :

-L 3 C23 S 1 L2 Cl (S3 C2 r C3 S 23)- L3 c l S 23 -L 3 C1 S 23

0 L2 s 1 (S3 C2 r C3 S 23)- L3 s 1 S 23 -L 3 s 1 S 23

[~tl =
0
0
L2 (S3 S 2 r C3 C23)- L3 C23
Sl
L3 C23
Sl [::] (3.46)

0 -Cl -Cl
1 0 0

3.5.6 Modèle cinématique inverse (MCI)

L'objectif du MCl est de calculer, à partir d'une configuration q donnée, les vitesses

articulaires q qui assurent au repère terminal une vitesse opérationnelle X imposée.

Pour obtenir le modèle cinématique inverse, nous inversons le modèle de cinématique

direct en résolvant un système d'équations linéaires. La mise en œuvre peut être faite de façon

analytique ou numérique. Les solutions analytiques réduisent le nombre d ' opérations de

façon remarquable par rapport aux solutions numériques. Mais, il faut traiter les cas singuliers

distinctement. Les solutions numériques sont plus générales et traitent tous les cas de la même

manière [35].

3.5.6.1 Modèle cinématique inverse du robot étudié

Nous pouvons déterminer la solution au système de façon itérative en utilisant un Jacobien,

en se servant de la matrice J O(3x3) réduite, que nous obtenions du MCD en supprimant les

lignes 3, 4 et 6 ;

L 2 cl (53 C23 - C3 5 23) - L 3 C1 5 23

L 2 5 1 (53 C23 - C3 5 23) - L 3 5 1 5 23 (3.47)
-Cl
 48

Son MCl est obtenu en calculant JO-1(3x3) réduite avec le nouveau vecteur Xr = [vx vy wy]T:

• -1 .
8 = Jo (3x3)Xr (3.48)

L 2 Cl(S3 C23 - C3 S 23) - L 3 C1S23

L 2 s 1 (S3 C23 - C3 S 23) - L 3 s 1 S 23 (3.49)
-Cl

Ce qui nous donne:

(3.50)

2
L 2 c1 (S3 C23 - C3 S 23 )

L 3 s 1 Cl C23

L3 C23 (-L3 S2 3 + L 2 (S3 C23 - C3 S 2 J)

3.6 Conclusion

Dans ce chapitre, nous avons commencé par décrire les différents organes constituant le

bras manipulateur étudié. Par la suite, nous avons donné une représentation aussi simpliste

que possible de son modèle géométrique et son modèle cinématique.

Nous débuterons dans ce qui suit, la partie concernant la commande du robot. Nous

généralement recherchons toujours le modèle le plus simple qui permet d'expliquer, de

manière satisfaisante, le comportement du processus dans son domaine d'application et celui

offrant plus de facilité d'utilisation pour ses usagers.

 Chapitre 4 - Commande du Bras Manipulateur

4.1 Introduction

Ce chapitre a pour objet l' application des différentes commandes citées précédemment

sur le robot manipulateur. Nous introduisons la modélisation d'un servomoteur du bras sous

Python dans un asservissement dans un premier temps avec la commande PID, et dans un

deuxième temps, avec la commande par Logique Floue avec la présentation des résultats de

simulations obtenus pour chaque type de commande.

4.2 Matériel utilisé

4.2.1 Raspberry Pi 4 B

Le Raspberry Pi 4 B est un nano-ordinateur pouvant se connecter à un moniteur, à un

ensemble clavier/souris et disposant d'interfaces Wi-Fi , Bluetooth et Ethernet.

Il fonctionne depuis une carte micro-SD et utilise un système d'exploitation basé sur

°
Linux ou Windows 1 loT. Il est fourni sans boîtier, alimentation, clavier, écran et souris

dans le but de diminuer le coût et de favoriser l'utilisation du matériel de récupération.

Cette nouvelle version de la carte Raspberry Pi 4 B est basée sur [37] un Processeur ARM

Cortex-A 72 64 bits q~latre cœurs à 1,5 GHz, 1 GB de mémoire RAM (il existe également en

version 2 et 4 GB de RAM), interfaces Wi-Fi, Bluetooth, et ports USB 2.0, USB 3.0, Ethernet

Gigabit, HDMI, micro-SD, et multiple GPIO .

Les interfaces Ethernet et Bluetooth ont été améliorées par rapport aux verSIOns

précédentes et supportent maintenant l'Ethernet Gigabit ainsi que le Bluetooth 5.0. Cette carte
 49

est basée sur un processeur ARM et permet l'exécution du système d'exploitation

GNUlLinux/Windows 10 loT et des logiciels compatibles.

Le Raspberry Pi peut effectuer des tâches d'un PC de bureau (feuilles de calcul,

traitement de texte, jeux). Il peut également diffuser des vidéos en haute définition grâce à

son circuit BroadcomVideoCore VI (permet le décodage des flux vidéo 4k H.265 et 1080p

H.264). Cette nouvelle version supporte également le 4k en natif via ses sorties micro-HDMI.

La Raspberry Pi 4 B nécessite une carte SD munie d'un OS, une alimentation, un clavier

USB, une souris USB, un boîtier et des câbles (non inclus). Pour préparer une carte SD

bootable, il faut disposer d'un PC avec lecteur de carte SD .

• Raapberry PI

Figure 4-1 Carte Raspberry Pi 4 B.

4.2.1.1 Caractéristiques de la Carte Raspberry Pi 4 B

Caractéristiques Raspberry Pi 4 B :

• Alimentation: 5 V cc/maxi 3 A * via prise USB Type C, Intensité maximale si toutes

les fonctions sont utilisées.

• CPU : ARM Cortex-A72 quatre cœurs 1,5 GHz

 50

• Wi-Fi : Dual-band 2,4 et 5 GHz, 802.11b/g/n/ac

• Bluetooth: Bluetooth 5 compatible BLE (Broadcom BCM43438)

• Mémoire: 1 GB LPDDR4

• Circuit vidéo: VideoCore VI à 500 MHz

• Les ports :2 ports USB 2.0 et 2 ports USB 3.0 et Port Ethernet Gigabit RJ45

• Bus: SPI, I2C, série

• Sorties: 2 x micro-HDMI (4K @ 60 fps maxi), Jack 3,5 mm (partagé avec audio)

• Dimensions : 88 x 58 x 17 mm

• Version : Raspberry Pi 4 B - 1 GB

• Poids : 46 g

• Les Interfaces : CSI pour caméra, DSI pour écran

• Sorties audios : 2 x micro-HDMI avec gestion du 5.1 et Jack 3,5 mm en stéréo

(partagé avec vidéo)

4.2.2 LSS - Carte adaptateur Lynxmotion Smart Servo

4.2.2.1 Description

La carte adaptateur Lynxmotion Smart Servo (LSS) est une carte électronique qui permet

une connexion et un contrôle faciles des servomoteurs « intelligents» Lynxmotion. La carte

comprend une variété de caractéristiques et de fonctions en tant que carte de distribution

d'alimentation centrale via six connecteurs LSS . L'adaptateur LSS est idéalement conçu pour

être alimenté par une batterie LiPo via le connecteur XT60 mâle embarqué, ou avec un
 51

adaptateur mural équipé d'un connecteur XT60 femelle . Il existe de nombreuses façons de

s'interfacer avec cette carte, comme décrit ci-dessous.[21]

Figure 4-2 LSS - Carte adaptateur Lynxmotion Smart Servo.

4.2.2.2 Fonctionnalités

• Contrôle des actionneurs LSS sur le même bus via 6 connecteurs.

• Prise Bee intégrée (XBee, modules Bluetooth Bee ou WiFi Bee).

• Peut fonctionner comme une carte d'exploration USB XBee.

• Compatible avec le blindage Arduino en utilisant des en-têtes d'empilage.

• Méthode de contrôle sélectionnable : USB, Arduino ou XBee.

• Compatibilité des trous de montage du Raspberry Pi B + / A + / 3.

• Connecteur XT60 pour l'entrée d'alimentation.

• Sélection automatique de l'alimentation logique (USB / externe).

4.2.2.3 Caractéristiques

• Courant continu par connecteur : 3A (max).

• USB vers série intégré (puce de port COM virtuel FTDI).
• Régulateur SV intégré.
• Régulateur 3.3V intégré.
 52

• Mini connecteur USB.

• Dimensions: 64 x 64 x 15 mm.
• Diamètre du trou de montage : 3,1 mm.

4.3 Logiciels utilisés: L'environnement de programmation en Python

Python est un environnement de développement IDLE « Integrated

DeveLopmentEnvironment » est un environnement de développement intégré spécialement

pour Python qui nous permet d'exécuter directement du code Python. Il s' agit d' un langage

Open Source et gratuit, téléchargeable sur le site officiel dans la rubrique téléchargement.

Python Launcher permet lui d' exécuter du code Python créé dans des fichiers séparés .py en

double cliquant simplement sur ces fichiers [38].

Arrêt
D ébogage

Programme

Figure 4-3 Environnement de développement en Python.

 53

4.4 Commande du bras manipulateur

L'objectif est d' étudier et proposer la commande du bras robotisé pour améliorer la

finesse et la précision de son mouvement.

Nous cherchons à faire atteindre une certaine valeur à une variab le du système. Dans le

cas d'un servomoteur, il s' agit principalement d' une vitesse ou d' une position.

- Les effets des perturbations doivent être minimisés, voire effacés, et ce le plus vite

possible (régulation).

- Les changements de consigne doivent être SUIVIS rapidement et avec une bonne

précision, si possible sans dépassement (poursuite).

Néanmoins, ces critères de perfonnance sont souvent antagoniques, et nous verrons que

le réglage de l' asservissement en détermine un compromis.

4.4.1 Régulateur PID

Régulateur PID (Proportionnel, Intégral, Dérivé) est une méthode d'auto régulation (en

boucle fermée), qui cherche à réduire l'erreur entre la consigne et la mesure [39].

E = Consigne - Mesure

Le régulateur PID sert à atteindre la valeur souhaitée pour une des variables du

système (vitesse, position ... ).

- Régulation : minimiser rapidement les perturbations.

- Poursuite: s'adapter rapidement aux nouvelles consignes. Ceci s'appelle

l'asservissement.
 54

Action
PropOitionnelle

Action Intégrale Système 1Procèdè

Action DérIVée

Figure 4-4 Schéma du régulateur PID [39].

4.4.1.1 Asservissements en régulation de la position et influence des coefficients sur

le servomoteur du bras robotisé

Tel que mentionné précédemment, le régulateur PID est un régulateur, en boucle fermée

(Figure 4-5), qui a pour rôle de diminuer l'erreur entre la consigne et la mesure et d'atteindre

la position souhaitée.

Sen·omolalr

o kd du (t )
de

Figure 4-5 Schéma-bloc de l'implantation du PID en régulation de position.

 55

4.4.1.1.1 L'action proportionnelle sur la position

L'asservissement de type proportionnel (P) est le plus simple qUI soit. Il s' agit

d'appliquer une correction proportionnelle à l'erreur corrigeant de manière instantanée tout

écart de la grandeur à régler :

Pc (t) =kp. Ec (t) [39]

- 11>...... "':- 11>_. ~ ~------------------

",.

.....
lOO·
lOO r

~ .... ~ .... ~
..
0

]li)
,
"]li).
s
.. JCO.

,...
200- "".
1OO· 100-
IDO -

,.
lOO llIOO l\OO
temps on, "'"
+UOI6641Zt12
-1"
tUa_Hlel2
11000 20000
temps en s
22000
+U0I669Stl2

Figure 4-6 Réponse d 'un servomoteur du bras dans un asservissement proportionnel,

passage de la position zéro à la position 600 = 60°.

Alors, d'après les signaux de la figure 4.6, le rôle du proportionnel est d ' amplifier

virtuellement l'erreur pour que le système réagisse plus vivement, comme si l'erreur était

plus grande qu'elle ne l'est en réalité, il permet de vaincre les grandes inerties du système et

diminue le temps de montée en donnant de la puissance au servomoteur (plus l'erreur est

 56

grande, plus nous donnons de puissance au servomoteur). Lorsque nous augmentons Kp, le

système réagit plus vite et l'erreur statique s'en trouve améliorée, mais en contrepartie, le

système perd en stabilité. Le dépassement se fait de plus en plus grand, et le système peut

même diverger dans le cas d'un Kp démesuré. Un ajustement du gain est donc requis pour

permettre une réponse acceptable. Toutefois, l'utilisation de méthodes classiques, basées sur

le modèle ou sa fonction de transfert, est difficile à appliquer car les caractéristiques du

système changent en fonction de la charge et de la position des différentes articulations.

4.4.1.1.2 L'action proportionnelle intégrale PI sur la position

L'erreur est intégrée sur un intervalle de temps, puis multipliée par une constante Ki.

t
Ic(t)= kif Ec(t).dt [39]

- Kf-O.J. ~-o.OOl -1tpO.2.Ki><CLOOl

1000 -
1000 ·

100 ·
. ..
G ·

200 - 200-

,-
~~~-=~-~ ~~~ ~~ ~ 52000 54000 5iODO 6000 :JIDOO DIO !OOO
temps; en 5 +L6OI!I67nt:l2 ttmpun 5 +1.60111I1e.12 temps en 5 tl.6086754tll

5DOO 6000 JIXIO IOU)

temps en 5 tl6086mlf12

Figure 4-7 Réponse d'un servomoteur du bras dans un asservissement Kp et Ki, passage de
la position zéro à la position 600 = 60°.
 57

Le terme intégral complète l'action proportionnelle puisqu ' il permet de compenser

l'erreur statique et d'augmenter la précision en régime permanent. L'idée est d'intégrer

l'erreur depuis le début et d' ajouter cette erreur à la consigne: lorsque nous nous rapprochons

de la valeur demandée, l'erreur devient de plus en plus faible. L' intégrale agissant comme

un filtre sur le signal intégré, permet de diminuer l'impact des perturbations (bmit, parasites),

et il en résulte alors un système plus stable. Malheureusement, le terme intégral sur notre

système ici d' après la figure 4.7 est mal adapté pour les conditions du système. Notons que

plus le terme intégral est important plus il entraînera de dépassement de la consigne, une

stabilisation plus lente, voire même des oscillations divergentes.

4.4.1.1.3 L'action PID sur la position

La dérivée dépend des variations de l' erreur Ec(t) :

dEc(t)
Dc(t) = Kd dt [39]
 58

"".
j œ·

lOO·

Or
- - ....
temps en s +L6086I62t12

- ~Ki=o.ool, 16aO.4 ,... . - " ..1. "-0,001, U-OJ

....
-.,. .
.g
~
œ·

lOO· lOO· lOO -

O· O· O·

lIlOOO
'=="==1lOO
= .....
== ""..
:'-=:
"""'
='=="=1lOO""'......
=:':::-.."..
='=-:::
."...
'=' 66000 6IODO 1000CI 12000 140DII 62OCIO IGO 66000 6aJOO XIOOO 12000 J.4OOO
en s tUœ6I6tU temps en 5 tl6086864e12 temps en s +UOI6IUf:U

Figure 4-8 Réponse d'un servomoteur du bras dans un asservissement PID, passage de la
position zéro à la position 600 = 60°.

Comme nous l' avons vu précédemment, l'introduction que la composante intégrale

entraine également un risque de dépassement de la consigne. En calculant la variation de

l'erreur à chaque itération, la partie dérivée permet de limiter ce phénomène en ralentissant

la commande lorsque la valeur de la sortie s'approche de la consigne, elle freine alors le

système.

4.4.1.1.4 Réglage des coefficients PID sur la position

Le réglage d'un PID consiste à trouver les meilleurs coefficients Kp, Ki et Kd dans le but

d'obtenir une réponse adéquate du procédé et de la régulation. L' objectif est d'obtenir une

réponse robuste, rapide et précise tout en limitant les dépassements.

 59

En absence d'un modèle du système, nous avons utilisé une approche manuelle

(empirique) d'ajustement des gains du correcteur. On a augmenté Kp à volonté pour choisir

une valeur relativement grande de Kp, puis nous avons ajusté Ki et Kd pour éliminer l' erreur

statique, limiter le dépassement et atteindre la consigne le plus vite possible .

...
...
~-
i-
...
t
,..
....
mo 1SOO mo
.u
+l.iIOIM747•

Figure 4-9 Gain ajusté P Kp=0.9 en position 600 = 60.

Figure 4-10 Gains ajustés PI Kp=0.9, Ki=1O- 5en position 600 = 60.

_---1

~~u~...~.~--------------------------------------~
_J\U • ....~1IU71 •
• J\U. -"rl'" . .

I ...'i" ... - 1'

Figure 4-11 Gains ajustés pour PID : Kp=0.9, Ki=10- 5, Kd=0.3, en position 600 = 60°.
 60

4.4.1.2 Asservissements en régulation de vitesse et influence des coefficients sur le

servomoteur du bras robotisé

De la même manière que pour l'asservissement de position (angle), le régulateur PID

peut être employé pour diminuer l'erreur entre la consigne et la mesure et ainsi atteindre une

vitesse souhaitée tel que montré dans la Figure 4-12.

p kp.Ee ( t )

t O m(t)
1 l.:JEe(t).dt SMvomou

dEC
0 kd (t)
dt

Figure 4-12 Schéma-bloc de l'implantation du PID en régulation de vitesse.

4.4.1.2.1 Réglage des coefficients PID sur la vitesse

Comme nous avons fait sur le réglage d'un PID sur la position, c'est le même principe

d'ajustement les coefficients sur la vitesse consiste à trouver les meilleurs coefficients Kp,

Ki et Kd dans le but d' obtenir une réponse adéquate du procédé et de la régulation.

IO· ~~~--~--~~----
50·

~-
50·

10 - 40·
~-
10 ·
lO·
10- JI.

s· 10 -
10·
- ".2. .L ...·l - ".2. iGoL ...-1
0- • -- ~ 0- • - - CIIOOIIN 0-
-201)0 -1000 toêo lIlÔo lIlÔo l'lSOO 1)000 aoioo 11000 11500 mOoo IlSOO HÔoo Itno ttSoo Itno _ lDMo Wo mno nooo
+l 6147OntU +UI47OntU +UI41Otl.U

Vitesse 20 0 /s Vitesse 40°/s Vitesse 60 0 /s

Figure 4-13 Gains ajustés pour PID : Kp=2, Ki=I , Kd=l , trois vitesses différentes.
 61

Nous remarquons d'après la Figure 4.13 que plus nous ralentissons ou diminuons la

vitesse, plus le signal de mesure de vitesse est bruité.

Toutefois, visuellement la rotation du servomoteur n' est pas saccadée comme le suggère

la courbe.

4.4.2 Double asservissement position-vitesse d'un servomoteur avec PID

L'objectif d'un double asservissement à la fois en position et en vitesse, est de maîtriser

la vitesse de déplacement dans un asservissement de position et de permettre de définir une

courbe de vitesse au cours d'un déplacement indépendamment de la distance à parcourir. En

effet, un simple asservissement PID de position modifie la tension à appliquer selon la

distance du déplacement. Or il est souvent préférable de se déplacer à une vitesse globalement

constante quelle que soit la distance à parcourir, en accélérant progressivement jusqu' à un

palier, puis en décélérant juste avant d' atteindre la position fmale afin d' éviter de la dépasser

(ce que fait naturellement un conducteur de véhicule). Typiquement, nous implémentons une

commande trapézoïdale, c'est-à-dire que nous appliquons un seuil à la fois sur la vitesse et

l' accélération [40] :

Accélération iVitesse constante

o
Décélération

Vite se

Temps

Figure 4-14 Modèle trapézoïdale de la vitesse.

 62

4.4.2.1 Modélisation du double asservissement PID

Se!vomo1eur

Mc(t)

Figure 4-15 Schéma-bloc de la double implémentation de PID tenant compte

des écrêtages [40].

Le principe est simple : un asservissement PID de position modifie la tension à appliquer

selon la distance du déplacement: l'évolution de la vitesse se fait selon 3 phases, une phase

d'accélération, une de vitesse constante et enfin une phase de décélération. Ainsi , plus nous

nous rapprochons de la position de référence, plus la vitesse diminue afin d'atteindre une

précision d'autant plus grande que la position de référence est proche.

lU -

15 -
...
a ...
:~
10 -
~-
5-
...
!DO

0-
!DO lOOO 1100 lAOO l600 l8DO :DM»
+1 61.U5n.1l

Figure 4-16 Résultat du double asservissement PID.

Le résultat obtenu par un double asservissement ne possède pas beaucoup d' ondulation

au niveau de la courbe de vitesse (ondulation faible). Nous remarquons que le signal de sortie
 63

MLI (PWM) au cours de la vitesse constante est maximal, ce qui signifie aussi que la vitesse

est maximale et suit de près la valeur limite prédéfinie.

4.4.3 Régulation par la Logique Floue

Le terme d ' ensemble flou apparaît pour la première fois en 1965 lorsque le professeur

Lotfi A. Zadeh, de l'université de Berkeley aux USA, publie un article intitulé « Ensembles

flous» (Fuzzy sets) [41].

Un régulateur flou est un système à base de connaissance particulière composé de quatre

modules principaux à savoir : la base de règle, la fuzzification, le moteur d'inférence et la

défuzzification comme il est montré par la Figure 4.17.

p~ numérique
de sortie

Fuzzification Moteur Défuzzification Résultat

d' inférence
Variable linguistique
induites par les règles

Figure 4-17 Schéma représentatif du fonctionnement d 'un système par Logique Floue [41].

4.4.3.1 Régulation par la Logique Floue sur la position

4.4.3.1.1 La fuzzification de position

Conversion des valeurs d'entrée (grandeurs physiques) en grandeurs floues réunies dans

le vecteur x, cette partie consiste à traduire les données numériques quantitatives provenant

d'un capteur, alors dans notre cas l' entrée est la position du servomoteur, en variables
 64

linguistiques qualitatives grâce à une fonction d' appartenance utilisée. Alors, l'entrée est

partitionnée dans notre cas en 8 variables linguistiques sur un intervalle de position [-1800,

1800], représentant une variation d'angle entre -180° et 180°, par les fonctions

d'appartenance représentées sur la figure [41].

10
~ ~
1 - ~
01 · - ~I.'l:f'l:tiEn'
-~~rr

H' = ~
1"-
o. ·
1
- ~

02 ·

00
- 1500 - 1000 -soo
Il
0 500 1000 1SOO
l'OsErr

Figure 4-18 Variables linguistiques (8, 1l(8)) pour décrire la position.

4.4.3.1.2 Inférence floue de la position

Le contrôleur par Logique Floue utilise une forme de quantification d'informations

imprécises (ensembles flous d'entrée) à générer par un schéma d'inférence, qui est basé sur

une base de connaissances de la force de contrôle à appliquer sur le système. Avec la base

des règles, la prise des décisions pour chaque règle activée donne un sous-ensemble flou de

sortie, alors les règles de base pour la position du mouvement dans le servomoteur

s'expriment comme suit :

Tableau 4-1 Les règles de base pour la position du mouvement dans le servomoteur

Les règles Erreur de Position Résultat PWM

Règle 1 Grande Positive Grande Positive
Règle 2 Moyenne Positive Moyenne Positive
Règle 3 Petite Positive Petite Positive
Règle 4 Très petite Positive Très petite Positive
Règle 5 Grande Négative Grande Négative
 65

Règle 6 Moyenne Negative Moyenne Negative

Règle 7 Petite Negative Petite Negative
Règle 8 Très petite Negative Très petite Negative

4.4.3.1.3 La défuzzification

Le résultat de l'inférence en utilisant une des méthodes d'implication floue ne peut être

utilisée directement. Une transformation doit être prévue à la sortie du bloc d'inférence pour

convertir les sous-ensembles flous de sortie en valeurs déterminées, cette transformation

étant connue par le terme défuzzification (concrétisation) [41]. La figure suivante représente

l' influence de la logique floue sur la position:

1000 •

lIDO -

0-
.
li500 7000 7500 11100
+1 . 614]991~U

Figure 4-19 Réponse d'un servomoteur du bras dans un asservissement avec logique floue.

Passage de la position zéro à la position 1200 = 1200 .

4.4.3.2 Régulation de vitesse par la Logique Floue

4.4.3.2.1 La fuzzification de la vitesse

L'entrée maintenant est la vitesse angulaire du servomoteur, nous traduisons ces données

numériques quantitatives en 3 variables linguistiques sur un intervalle de vitesse [-60, 60]

par les fonctions d'appartenance représentées sur la figure 4-20 [41] .

 66

10

08 -

Ol ;
/
00
~O
-
40 - 20 0 20
Spee-dErr

Figure 4-20 Variables linguistiques (n, f1(n)) pour décrire la Vitesse _

4.4.3.2.2 Inférence Floue de la Vitesse

Le schéma d'inférence généré par le contrôleur par logique floue de la vitesse angulaire

du servomoteur permet la prise des décisions pour chaque règle activée _ Celui-ci donne le

sous-ensemble flou de sortie suivant

Tableau 4-2 les règles de base pour la vitesse du mouvement dans le servomoteur

Les règles Erreur de vitesse Résultat PWM

Règle 1 Negative Negative
Règle 2 Zero Zero
Règle 3 Positive Positive

4.4.3.2.3 La défuzzification

L'étape finale, appelée défuzzification (ou concrétisation), consiste à utiliser la

transformation à la sortie du bloc d' inférence et à réaliser la conversion des sous-ensembles

flous de sortie en valeurs déterminées [41l La figure suivante représente la réponse de la

logique floue pour trois exemples de commande de vitesse_

 67

10 - --------
lO -
J) -
IS - e-
J) -
»- 1O -
lO -
s- ID -
»-
0-
.000 _ eOoo eôoo _ SlOoo S?Ôoo 9Ôoo
0-
J1Ôoo J1SOO . . . .soo
lIOOO __ '-4IOO.oo_5IIÔo12Ôo~SIOo5llÔoào
,
+16141Ontll +16141014412 +16111010111

0
Vitesse 20 /S Vitesse 40 0 /S Vitesse 60 0 /S

Figure 4-21 Réponse de la commande de vitesse utilisant la Logique Floue.

Nous remarquons d'après le Figure 4.23 que plus nous ralentissons ou diminuons la

vitesse, plus le signal de mesure de vitesse est bruité. Ce phénomène a été observé aussi pour

la commande de vitesse avec PID.

Dans la section suivante, nous appliquons le double asservissement par Logique Floue

d'un servomoteur, passant par la méthode de freinage en douceur avant la position souhaitée

pour minimiser l'erreur de la position.

4.4.4 Double asservissement par Logique Floue d'un servomoteur

L'objectif d'un double asservissement du servomoteur, à la fois en position et en vitesse,

est de maîtriser la vitesse de déplacement dans un asservissement de position pour permettre

de définir une courbe de vitesse au cours d' un déplacement indépendamment de la distance

à parcourir. En effet, l'asservissement par Logique Floue sur les deux variables (position et

vitesse), facilite le freinage à appliquer (sur la tension) selon la distance du déplacement pour

ralentir avant d' arriver à la position souhaitée. Or il est souvent préférable de se déplacer à

une vitesse globalement constante quelle que soit la distance à parcourir, en décélérant juste
 68

avant d' atteindre la position flnale afln d' éviter de la dépasser. Typiquement, on implémente

une commande trapézoïdale [40].

4.4.4.1.1 La fuzzification de la position et de la vitesse

Les entrées sont maintenant la position et la vitesse angulaire du servomoteur. Nous

traduisons ces données numériques quantitatives chacun en 3 variables linguistiques

triangulaires sur un intervalle de position [-1800, 1800] et la vitesse [-60, 60] par les fonctions

d'appartenance représentées sur les deux figures sui vantes [41] .

LO

o.. -
Cl.
~ 0.6

j 0.4 -

0.2

0.0
-tG -10 - 20 0 20 40
spndErr

Figure 4-22 Variables linguistiques pour décrire la position (8, J.l(8)) et la vitesse (n, J.l(n)).

4.4.4.1.2 Inférence Floue de la position et de la vitesse

Le schéma d'inférence généré par le contrôleur flou de la position et de la vitesse

angulaire du servomoteur permet la prise des décisions pour chaque règle activée et donne le

sous-ensemble flou de sortie suivant.

Tableau 4-3 les règles de base pour la position et la vitesse du mouvement dans le

servomoteur

Les entrées La sortie

Les règles Erreur de Position Erreur de Vitesse Résultat PWM
Règle 1 Négative Négative Grande Négative
Règle 2 Négative Zéro Négative
 69

Règle 3 Négative Positive Zéro

Règle 4 Zéro Négative Négative
Règle 5 Zéro Zéro Zéro
Règle 6 Zéro Positive Positive
Règle 7 Positive Négative Zéro
Règle 8 Positive Zéro Positive
Règle 9 Positive Positive Grande Positive

4.4.4.1.1 La défuzzification

Après, dans le processus de défuzzification (ou concrétisation), il s'agit d'utiliser la

transformation à la sortie du bloc d' inférence et convertir les sous-ensembles flous de sortie

en valeurs déterminées [41]. La figure suivante représente la réponse de commande de

position et vitesse parla Logique Floue.

600 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 10 -

500 - 50-

«lO -

300 - )0-

2DO -

100 • 10-

0- 0-
GOO 4400 4600 4IlOO 5000 5lOO 5400 56GO 5000 1000 6!100 7000
+1 6141l52el2 +1 .61S0297el2

Figure 4-23 Résultat du double asservissement par la Logique Floue sur la position
(bleu) et sur la vitesse (rouge).

4.5 Conclusion

Dans ce chapitre, nous avons abordé les différents aspects (matériel et logiciel) relatifs à

la réalisation du projet, notamment les différents composants du bras robot. Nous avons

étudié également la commande d'un servomoteur du bras robot utilisant des correcteurs de

type PID et la commande par Logique Floue. Nous avons présenté des exemples des résultats

expérimentaux obtenus pour chaque type de commande.

 Chapitre 5 - Interprétations et Comparaison

5.1 Introduction

Dans un but comparatif, les différentes approches de commande étudiées et évaluées

auparavant sont testées sur le prototype de servomoteur d'un bras manipulateur Lynxmotion.

La procédure de comparaison consiste à vérifier les performances des lois de commande sous

des conditions similaires d' opération (positions initiale et finale). Notons que bien que dans

la simulation ceci est possible dans l'étude expérimentale deux conditions identiques de test

ne seront jamais réalisables.

5.1.1 Commande de position

Les figures 5.1 et 5.2 montrent les résultats de tests des deux méthodes pour une

commande de position en imposant une variation de 0° à 60°.

liOO - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

500 -

100 -

2DO -

100 •

0-
ClOO 4400
. .
4600 4IlOO 5000 ~ 5400 5600
+1 614m2.l2

Figure 5-1 Logique Floue sur la position, passage de 0° à 60°.

 71

100 ...
------------':-=-=--::;-~ a.--

Figure 5-2 PID sur la position, passage de 0° à 60°.

Nous constatons que la rapidité du système (temps de réponse, temps de monté) dans la

réponse obtenue par la commande par Logique Floue est meilleure que celle obtenue par la

commande avec PID. Dans la commande par Logique Floue, la réduction de l' erreur et la

stabilisation se font plus rapidement par contre avec la commande PID l' atténuation de

l' erreur se fait lentement et présente une certaine oscillation (typique dans les correcteurs de

type PID). Les deux régulateurs permettent d' éliminer l'erreur et le dépassement, donc

peuvent être employés pour obtenir une bonne précision sans mouvements brusques ou

saccadés.

5.1.2 Commande de vitesse

Les figures 5.3 et 5.4 montrent les résultats de tests des deux méthodes pour une

commande de vitesse en imposant des variations de 0 à 20 0 /s, de 0 à 40 0 /s et de 0 à 60 0 /s.

 72

JI- 50-

15-

JO -
IS- JI-
/0-
Ill- JO-
5- 111-
10-
- 1;I-2.Ki-LJ(d-1 - Kpal. Ki-\. 1Cd-\ - Kpa2.II-\. ICd-\
0- ,
-2000 -1000 1000
-- CIIMIp
lDOO JIOO
0-
19500
,
lIlOOO lIl500 81000
-- ........
ll500 lIlOOO lIlSOO
0- • • ! l ,
--
1
........
• • j
19000 19250 19500 19150 lOOOO J0250 lO5OO J0150 Zlooo
tlUn_1l +1 i1410910ll
"" ""NI"'"

Figure 5-3 Résultats avec correcteur PID pour trois différentes consignes de vitesse
angulaire 20 0 /s, 40 0 /s, 60 0 /s.

10- ---------
§o -

lS-
JO- 40-

lO- JO-
Ill-
lO ·
s- ID ·
ID-

0- , l , 1 1 1 1 • , , 0-. 1 1 1 • 1 1 1 •
4iOOO 47000 l1OOO 4!1000 50000 51000 52000 5lOOO J1000 J1500 _ 11500 .l1OOO 11500 _ 4IOO4lOO4IIOO 500052005400 56OO5IIOO1iDOO
,n 5U1Olltn .... "1.lf11fi~1)

Figure 5-4 Résultats avec la Logique Floue pour trois différentes consignes de vitesse

Nous remarquons que les résultats obtenus avec la Logique Floue (d'après la figure 5.4)

présentent moins de perturbation dans la vitesse du servomoteur par rapport aux résultats

obtenus avec la commande PID (Figure 5-3)_ En revanche, le temps de réponse dans les

faibles vitesses des mouvements de la commande PID plus rapide par rapport à la commande

de vitesse par Logique Floue 20 0 /s, 40 0 /s_Mais dans les grandes vitesses 60 0 /s le temps de

réponse de la vitesse de mouvement de la commande par logique Floue est plus rapide_
 73

5.1.3 Double asservissement position-vitesse

Les figures 5.5 et 5.6 montrent les résultats de tests des deux méthodes pour une

commande avec double asservissement position-vitesse en imposant des variations de 0 à 60°

pour la commande PID et la commande par Logique Floue.

- r-:----=::;:::::=;:-:J
lfl-

IS ·
-
10 -

5-

0- - Kp-O 1. _0 01.1Cd-0 01
2!1600 2!1100 30000 30100 30400 _ lO8OO l2000
+l.IOI)4~12
+15l42296f!12

Figure 5-5 Résultats pour le double asservissement position-vitesse avec PID.

10 - 000- -----------------------------

50- 500 •

lD- 100 -

le · 200 -

100 -

0-
4SOO
. .
sooo
.
li500 JOOO
0-
C2004400
.
16004Il00 sooo 520054005600

Figure 5-6 Résultats pour le double asservissement position-vitesse avec Logique Floue.

Nous constatons que la commande par la Logique Floue donne des meilleurs résultats à

savoir: un bon suivi de la position et vitesses articulaires, ainsi qu' une meilleure convergence

asymptotique de l'erreur. La commande avec PID peut être aussi un bon choix. Toutefois, la

réponse risque d' être affectée si la charge mécanique du servomoteur varie. Dans ce cas, nous

serons obligés de rajuster les paramètres (gains) du correcteur.

 74

Selon les résultats obtenus, nous pouvons affirmer que la commande par la Logique

Floue, en plus de donner des bonnes performances et assurer une convergence asymptotique

de l' erreur, son ajustement n' est pas basé sur les caractéristiques ou paramètres du système.

De sorte qu ' elle peut rester fonctionnelle même si la charge du servomoteur change, ce qui

est souvent le cas dans une application de robotique. La commande par la Logique Floue

garantit à la fois l' atteinte du point de consigne et l' atténuation des oscillations.

La commande avec correcteur PID prend juste une seule vitesse constante qUI est

inférieure à la vitesse maximale du servomoteur, et si les changements de paramètres ne sont

pas trop importants, elle peut rester fonctionnelle .

5.2 Conclusion

Dans ce chapitre, nous avons fait une comparaison des résultats expérimentaux entre le

correcteur PID et la commande par la Logique Floue pour réguler la position et la vitesse

d'une articulation (servomoteur) d' un bras robot.

Nous remarquons que la commande par la Logique Floue est très efficace, très

performante (rapidité, stabilité et précision) par rapport au correcteur PID. Elle n'est pas

affectée par les retards et les oscillations souvent rencontrées dans les correcteurs de type

PID.
 Chapitre 6 - Application de contrôle du robot sous
Logiciel LABVIEW

6.1 Introduction

Un système numérique de contrôle-commande est un système de contrôle d'un procédé

industriel doté d'une interface homme-machine pour la supervision et d'un réseau de

communication numérique. Dans le but de commander notre bras manipulateur, nous avons

proposé une application développée sous le logiciel Labview et l' environnement de

développement ID LE Python. Celle-ci permet la commande manuelle et automatique des

angles des organes du robot.

6.2 Présentation du logiciel Labview

Abréviation de LabVIEW (Laboratory Virtual Instrument Engineering Workbench) est

le cœur d' une plate-forme de conception de système de mesure et de contrôle.

Lab VIEW offre une approche de programmation graphique qui aide à visualiser tous les

aspects de différentes applications, y compris la configuration matérielle, les données de

mesure et le débogage.

Une des différences fondamenta les de LabVIEW est que ce langage suit un modèle de

flux de données, et non de flux d' instmctions. Cela signifie que pour un langage textuel, ce

sont les instructions qui ont la priorité, alors qu ' avec LabVIEW, ce sont les données. Une

fonction s' exécutera donc uniquement si elle dispose à ses entrées de toutes les données dont

elle a besoin. Lorsqu ' un langage classique est ainsi séquentiel, Lab VIEW est naturellement
 76

prédisposé au parallélisme. Ce qui augmente encore sa puissance et la rapidité d'exécution

du code [42] .

6.3 Types de commande du bras manipulateur

Afin de faciliter la communication entre l' homme et la machine, nous avons créé une

interface permettant à l'utilisateur de commander le bras . Nous allons utiliser la méthode de

programmation par auto-apprentissage [43].

Pour commander les quatre servomoteurs du bras manipulateur, nous avons réalisé deux

modes de commande: une commande pour configurer la trajectoire du bras et une commande

de marche automatique, la commande par des potentiomètres pour varier les angles des

organes du robot, programmés directement via l'application LabVIEW.

_. .....
palinltdl ·1D.llOO pœllrwCdtOUIOO

=1~,
posliMde ·900UCXI pos411111dtQiUao

::1 ....
U.]
•.: 1
pool pooIl

- ,. 0
0 0
,..
-.
• 0
"
~t
arreVmarche •
"",1- POIl inttmlltdlln 1"""" POI .. int~

_Io-
POf J ..
. ·1100.110) dt011100
_
dt .1900
.
de"OIUlSC»

=1
::1 ....... 5 ::1 pean". -1 po&inllf )
pœintft'

-,
"
""
0

:1 • "
0

:1" ..
ll.......-..,.....
I l . . . . . -.. , . . . . . -

".......- , - - -
--.....
postllndt ·tait.lOO pol 2 in de -SOI)' 1600 posJlndt-",i900 pol 41n dt a HSOO

::1 :1 pool,

- :1 •
potI pool' potIl

"
~t
0

-, =
..:1
..;

Figure 6-1 Interface de commande.

Partie 1 :

Cette partie consiste à :

Un interrupteur (switch) qui permet d'activer ou désactiver l'application;

 77

Un sélecteur (switch) de 4 positions qui permet de donner l' accès de configurer

la trajectoire du bras par : une case (1) accès pour configurer les positions initiales

des servomoteurs, (2) accès pour les positions intermédiaire, (3) accès pour les

positions finales , accès (4) marche automatique toutes les positions des

servomoteurs.

pas 1 init do ·1800 11800 pas 1 init do 0 11800 pas) init do ·9OO 1900 pas" init dt «ID a1500
...-:~·1 ~ :.1
• posil
0
:~I
.;.~
posi)
0 :II~' 1------
nt ~
.~ . ... '
..;
pas .. int.nneciaife
1 arret/marche •
pœ 1 irttermdiaîre pas 21niermediHe pas) Intennediair.
do ·1800 11800 doOII800 de ·9OO 1900 do 400 11500

:~I pas Inter" :~I posinttr 3 ··1

.~ pas intft"

-,
.~]I 0 .....
t:

~
.;
0

...~ll' 0

pas 1 lin do ·1800 11800

...
- ;·.· 1
"
post :1
pas 1 lin do·5OO à1600

'"
post 1
0
pas) lin do ·9OO 1900

:1
~
.~
post)

...'
. UIt~
.~ .
....'

Figure 6-2 Interface de commande, rectangle pointillé configurer le mode et marche

automatique.

Partie 2 :

La commande par angles préprogrammés est un programme qui va nous permettre de

suivre directement des trajectoires désirées. Nous pouvons ainsi , définir les différentes

positions à l' aide de variation des potentiomètres (Figure 6-4), qui eux désignent des angles

pour les servomoteurs, ce qui nous fournit une séquence de mouvement (par les positions des

articulations) et nous définit une trajectoire à réaliser lors de la mise en marche automatique.
 78

1;:1i; :.I: I1: -----------

pos l init de 0 à 1800 pos 1 iniI de ·900 à 900 pos 4 iM de 400 à l scxt

1 :jl
"
I ·...j
posi
0
~· I ~l ~jl :11~4 1 poOl

-1D= -~- I :~ a~1

"". 1
1pos 1 Înlerrndiaire pos 2 inlermediair. pos 1 inlermedia.e pos 4 inlermediai.. 1 arreVmarche •
1de-\800 11800 de 0 à1800 de ·900 à 900 de 400 à 1500

1 :'1 pos inler 5

:)1 posinler4 :jl posinl .. l
"'1
,., ~ pos inler 6
dIoIoIrlo_
1 COIIfIgundon .... .....-1nItWos
....~'II
" 0 ,, 0

:ll
1)
" 0
1 .,.,~ 0
l) COIIfIgundon .... . . . . . - - -
I1/ COIIfIgundon .... .....- ftnIIos
....' ~-1UIDmIIIqut
1 pos 1 fin de ·1800 11800 pos4finde400à ~
:1
pos l fin de ·500 à 1600 pos l fin de ·900 à 900 l 1

1 : jl posl posll "'J

.. ; posl 1 :11 posl4 l ,, :,
l 'j 0 .. 0 'i 0
"'1 1
.~ .
-1000:
.laI!
-- --"'- J

Figure 6-3 La commande par angles avec les potentiomètres.

Partie 3 : La séquence étant définie par les angles préprogrammés, dès que nous mettons

le système en marche automatique, l' application exécute le programme sous Python pour

exécuter la séquence de mouvement (prendre, déplacer et déposer des objets) avec le bras

robot selon les positions sauvegardées. Dans ce sous-programme, nous illustrons une

séquence répétitive pour réaliser le mouvement préprogrammé en faisant appel au

programme Python (Figure 6-5).

Des 6--. -r

potentiomètres

Appel programme Python

applique type de commande
mouvement
Séquence
répétitive

Figure 6-4 Diagramme bloc de l' interface LabVIEW avec Python.

 79

6.4 Conclusion

Dans ce chapitre, nous avons proposé une application sous Labview et Python pour la

commande du robot. Cette application permet essentiellement de :

- Configurer manuellement, à l' aide de potentiomètres, les positions souhaitées

pour définir la trajectoire de mouvement à réaliser par le bras robot.

- Exécuter, de manière automatique et répétitive, les séquences de mouvements

souhaitées.
 80

Chapitre 7 - Conclusion Générale

L' objectif de ce mémoire était essentiellement d'étudier les lois de commande afin

d'obtenir de meilleures performances et plus de robustesse pour générer un mouvement doux

dans les bras robotisés à faible coût. Ce mémoire présente, donc de manière résumée, le

travail qui concerne l'étude et la réalisation d' un bras manipulateur à trois degrés de liberté

à faible coût, avec l' hypothèse d'un environnement de travail sans obstacles. Nous avons

présenté une exploration générale du domaine de la robotique, les différents organes

consti tuant le bras manipulateur, et la modélisation et l' élaboration des modèles

géométriques, cinématiques, qui ont pour rôle respectivement de générer des trajectoires de

références. Enfin, nous nous sommes intéressés à l' étude expérimentale de la commande de

position et vitesse du robot en vue de vérifier les performances en termes de douceur ou

finesse des mouvements.

Des résultats expérimentaux obtenus lors de l' étude pratique et l' implémentation des

techniques de cornnlande par correcteur PID et par Logique Floue nous ont permis de

déterminer certains avantages et inconvénients de ces méthodes par rapport à l' objectif

d'améliorer la douceur ou fmesse des mouvements.

En termes généraux, la commande par la Logique Floue, dans le contexte de cette étude

et sous les contraintes associées au matériel, offre des meilleures performances en termes de

vitesse et atténuation de l'erreur soit par une commande simple de position ou soit par une

conunande considérant simultanément la vitesse et la position du servomoteur.

 81

Afin de pouvoir réaliser les tests et contrôler le mouvement du bras robotique avec les

régulateurs étudiés, une application d'interface utilisateur a été développée sous le logiciel

LabVIEW.

Le prototype réalisé peut servir de base pour des travaux futurs qui seront destinés à

l' amélioration du robot et de la fonctionnalité de ses diverses parties.

Les perspectives et recommandations suivantes permettront d' aller plus loin dans cette

recherche dans des travaux futurs :

• Utiliser un matériau plus solide pour la réalisation du bras robot;

• Conduire l' étude sur différents types et qualités de servomoteurs;

• Faire une étude plus détaillée sur la modélisation dynamique directe et inverse,

utilisant une commande via les observateurs robustes en présence des perturbations;

• Utiliser des servomoteurs offrant un couple moteur plus important, dans le but de

soulever des objets plus lourds.

 82

Bibliographie

[1] Bréan, Simon La science-fiction en France: théorie et histoire d'une littérature, PUPS ,
coll.« Lettres fran çaise» (2012).

[2] Liu, Lili. L' ergothérapie à l' ère de la quatrième révolution industrielle. Canadian
Journal ofOccupational Therapy. 85(4), EI-E14 (2018).

[3] C. Bohn and D. P. Atherton, an analysis package comparing PID anti-windup strategies,
IEEE Control Syst.Mag. 15, 34-40 (1995).

[4] Jingqing, Han. Acta Automatica Sinica. Nonlinear PID controller. 20(4) , 487-490
(1994) .

[5] Xu, Yangming, Hollerbach, John M, & Ma, Donghai. A nonlinear PD controller for
force and contact transient control. IEEE Control Systems Magazine. 15(1), 15-21 (1995) .

[6] Armstrong, Brian, McPherson, Joseph, & Li , Yonggang. A Lyapunov stability prooffor
non/inear-stiffness PD contro/. Paper presented at the Proceedings ofIEEE International
Conference on Robotics and Automation. (1996) .

[7] « Robotics », dans English Oxford Living Dictionaries. [En ligne]. Disponible:
https:llen.oxforddictionaries.com/definition!robotics

[8] Capek, Karel. R UR (Rosswn's llniversal robots) : Penguin. (2004).

[9] Huyssen, Andreas. After the great divide: Modernism, mass culture, postmodernism.
The vamp and the machine: Fritz Lang's Metropolis. 65 -81 (1986).

[10] Bessette, Juliette. Les Cahiers de l'École du Louvre. Recherches en histoire de l' art,
histoire des civilisations, archéologie, anthropologie et muséologie. John McHale,
l' Amérique passée à la machine. (13) (2019).

[Il] Noh, Sun Young, & Jeong, Kyungmin. Design Concepts ofEmergency
Respo17se Robot Platform K-R2D2. Paper presented at the Trans. of the Korean Nuclear
Society, Autumn Meeting. (2016).
 83

[12] Hurlbut, Shane, Snow, Ben, Gibson, Charlie, Alzmann, Christian. Engineering, &
Technology. Terminator treatment. 4(19), 45-47 (2009).

[13] Engelberger, Joseph F. Robotics in practice: management and applications

of indus trial robots: Springer Science & Business Media. (2012).

[14] Official website « IFR INTERNA TTONAL FEDERA TTON OF ROBOTTCS »

[15] Germain, Michel A, & Livernaux, Philippe. Bulletin de l'Académie Vétérinaire de

France. Utilisation du robot Da Vinci-S® pour les sutures vasculaires et nerveuses chez
l' animal : rat et porc. (2010) .

[16] Raibert, Marc, Blankespoor, Kevin, Nelson, Gabriel, & Play ter, Rob . Bigdog, the
rough-terrain quadmped robot. IFAC Proceedings Volmnes. 41(2), 10822-10825. (2008).

[17] Karastoyanov, D, & Karastanev, S. Reuse ofIndustrial Robots . IF AC -PapersOnLine.

51(30), 44-47 (2018).

[18] Ornron Adept Technologie, Inc. Plat-Fonne LD. In. États-Unis d'Amérique. (2018).

[19] Salameen, Laith, Estatieh, Abdelkarim, Darbisi, Salman, Tutunji, Tarek A, &

Rawashdeh, Nathir A. Intet:facing l omputing Platforms f or Dynamic lontrol and

Identification of an Industrial K UKA Robot Arm. Paper presented at the 2020 21 st

International Conference on Research and Education in Mechatronics (REM). (2020) .

[20] Boimond, Jean-Louis. « ROBOTIQUE » Cours, ISTIA, Université Angers, 2017.

[21] Lynxmotion, Official website. (2018). Retrieved from

https://www.robotshop.com/info/wiki/lynxmotionlview/servo-erector-set-robots-kits/

[22] Barbulescu, Vlad, Marica, Ioan, Gheorghe, Viorel, Nistor, Mircea, & Patras cu,
Monica. Encoder-based path tracking with adaptive cascaded control f or a three
omni-wheel robot. Paper presented at the 2017 16th RoEduNet Conference: Networking in
Education and Research (RoEduNet). (2017).
 84

[23] Boukli Hacene Lotii Fazil « Commande et supervisio"n d' un ensemble de robots via
internet », Mémoire en vue de l'obtention de Magister, Université Des Sciences Et De La
Technologie D 'oran, 26 avril 2012.

[24] Ni, Zhichen, Liu, Juan, & Chu, Zhaoqi. Multifunctional TrajectolY Control
System of Robot Based on Pc. Paper presented at the 2020 IEEE 3rd International
Conference on Information Systems and Computer Aided Education (ICISCAE). (2020) .

[25] Luqman, Hafiz Muhammad, & Zaffar, Mubeen . Chess Brain and Autonomous Chess
Playing Robotic System. Paper presented at the 2016 International Conference on
Autonomous Robot Systems and Competitions (ICARSC). (2016).

[26] Fisette P., Buyse H. , Samin le. « Introduction à la robotique » Cours, 19 février 2004

[27] Craig, John l « Introduction to robotics : mechanics and control », Pearson Education
International, Livre, 2009.

[28] Gangloff Jacques « Cours de Robotique », Cours, ENSPS 3A Master ISTI, 2018.
[29] Angelles Jorge « Fundamentals of robotic mechanical systems », Springer, Livre,
2002.

[30] Emmanuel Godoy & Coll, Régulation industrielle. Dunod, Paris 2007.

[31] Zestedesavoir, Official website. (2021). Retrieved from ;

https://zestedesavoir.com/tutoriels/686/ arduino-premiers-pas-en- infonnatique-
embarqueel7 4 7_le-mouvement -grace-aux -moteurs/343 8_un-moteur -qu i-a-de-la-tete-le-
servomoteur/# 1-10705yrincipe-du-servomoteur.

[32] Gautron Laurent « PHYSIQUE TOUT LE COURS EN FICHES », Dunod, Livre,

[33] Pasquier Claude « Mécanique », Cours, Polytech Paris-Sud,20 12.

[34] Lafond Roger « Analyse dynamique du mouvement », Cours,2018.

[35] Jacques GangloffCours de robotique de manipulation de Télécom Physique Strasbourg

/ master IRIV

[36] W.Khalil et E. Dombre, Modélisation identification et commande des robots , 2eéd.

Paris : Hermès Sciences, 1999.
 85

[37] Gotronic, Official website, Retrieved from;

https://www.gotronic.fr/art-carte-raspben).-pi-4-b-I-gb-
30752 .htm#:- :text=Cette%20carte%2 Oest%20bas %C3 %Age%2 Osur,traitement%20de%20t
exte%2C%20jeux).

[38] Python, Official website. (2021). Retrieved from ;

https://www.python.org/downloads/

[39] M. Camus, E. Deguine et D. Ross, Régulation par PID, Paris: TELECHOM Tech,
2010

[40] Martinez, José Roman Garcia, Reséndiz, Juvenal Rodriguez, Prado, Miguel Angel
Martinez, & Miguel, Edson Eduardo Cmz. Assessment ofjerk performance s-curve and
frapezoidal velo city profiles. Paper presented at the 2017 XIII International Engineering
Congress (CONIIN). (2017).

[41] Zadeh, Lotfi Asker, Klir, George J, & Yuan, Bo. F~t=zy sefs,jilzzy logic, and
jilz=y systems: selected papers (Vol. 6): World Scientific. (1996).

[42] Cottet, Francis, Pinard, Michel et Desmelle, Luc, LabVIEW Programmation et

applications, 3e éd. Paris: DUNOD, 2015.

[43] Igus, Official website. (2021). Retrieved from ;

https://www.igus.fr/info/robot-software

[44] lGraham, « CES 2017: Cars, robots are expected to star" dans USA TODA Y, 2017.
[Enli gne]. Disponible : https://www.usatoday.com/story /tech/2 016/12/30/ cars-
robotsexpected-star-ces20 17/95890122/

[45] R. Gourdeau, ELE4203 - Robotique : Modélisation des Robots Manipulateurs,

Département de génie' électrique, Ecole Polytechnique de Montréal, 4 novembre 2010.

[46] Soria-Olivas, Emilio, Martin-Guerrero, José David, Camps-Valls, Gustavo, Serrano-

Lapez, Antonio J, Calpe-Maravilla, Javier, & Gomez-Chova, Luis %J IEEE Transactions
on Neural Networks. (2003). A low-complexity fuzzy activation function for artificial
neural networks. 14(6), 1576-1579.
 86

[47] R. W. Erickson, Fundamentals of Power Electronics, 2nd ed. Secaucus,NJ: Kluwer,

2000.

[48] Fuzzy logic Too lbox user guide .Natick, MA : Mathworks, 1997.

[49] Ghoul, Abdallah. Chapitre l Modélisation des robots manipulateurs, 2016.

 87

Annexe

Annexe 1 : Code PID Position pour un seul servomoteur ... ... ......... ... ........ ... ... 100

Annexe 2 : Code PID Vitesse pour lin seul servomoteur .. . .......... .... . ... .... .. ... .. .. 101

Annexe 3 : Code double PID sur la position et la vitesse (trapézolâale) pour un seul

servomoteur ... .... .... . ....... .... . ..... ...... . ... .... .. ......... ... ... .. . .. . .. . .... ... ... ..... .. . ... 103

Annexe 4 : Code Fuzzy_Iogie sur la Position .. . .... ... ... .. ... ... .. ..... ..... ..... ....... ... 105

Annexe 5: Code Fuzzy_logie sur la Vitesse .. . .. ....... .. .. .... .. ... ... .. ... .. . ..... . ... .... 108

Annexe 6 : Code double Ftczy_Iogie sur la position et la vitesse (trapé:=oldale)pour

un seul servomoteur .. . .. . .. . ... ... ... .. ..... .... . ... .. ..... .... .. .. .... .......... . .... ....... . ... .. 111

Annexe 7 : Code double Fuzzy_Iogie sur la position et la vitesse (trapézoïdale) pour

tous les servomoteurs du bras ... .... .. ..... .. ... .. ... .. ... . ... ... ... ........ .. .. .. . .... .. ...... 112
 88

Annexe 1 · Code PID Position pour un seul servomoteur.

irnport lss
irnport numpy as np
irnport matplotlib.pyplot as plt
irnport lss const as lssc
irnport time
irnport serial

eST LSS Port = "( )M4"

eST LSS Baud = 15 C
eST LSS Baud = lssc.LSS DefaultBaud
lss.initBus(eST_LSS Port, eST LSS Baud)
myLSSl = lss.LSS( )
#myLSS1.leset() #reset le servo moteur
time.sleep( 5 ) # il prend 5 seconde apres le r~set pour redémarrer

Kp= G.09
Ki= .000l,1
Kd= C.3

i=J

myLSS1.move (

while(i < ):
i=i+ ~
time. sleep ( )
Setpoint = 12 a
#myLSS1.setMaxSpeed(6G)
pos i tion= []
temps= []
cons igne= []
plt.style.use( 'b~h' )
pl t . xlabel ( " èl1'PS [1!', " )

plt.ylabel( "::'J,it. r " )

plt. ion ()

pos=
Erreur= ()
pos=int(myLSS1.getPosition(»
Erreur= Setpoint-int(myLSS1.getPosition(»
period= O
X= I

while(Setpoint-pos<- 50r Setpoint-pos> ):

pos =int(myLSSl.getPosition(»
position.append(pos)
consigne. append (Setpoint)
ErreurI= Setpoint-int(myLSS1.getPosition(»
print( "t-> ~ellr" ,ErreurI, ' l' )
x=x+Erreur
millis =int«time.time()* lOOO »
temps.append(millis)
 89

print( "I.) " ,int(myLSSl.getPosition ())

print ( " SpE :l" , int (myLSSl. getSpeed () ) )
print ( "" )1 t <-le: " , int (myLSSl. getVol tage () ) )
print ( " ~ ,'n "+str (myLSSl. getCurrent ())
print( " ll~:-" ,millis)
print( " ")

print( "n_ 1._ -pe __ ..1" , millis-period )

Output=Kp*ErreurI+Ki*x+Kd*(ErreurI-Erreur)
print( " tr t" ,Output)
Erreur=ErreurI
period=millis

myLSSl.moveRelative(round(Output»

print ( "p" r " ,str (myLSSl. getPosi tion () ) , '\ ' )

plt.plot(temps,position, 'l' ) # trace la courbe
plt.plot(temps,consigne, "b ")
pl t . legend ()
plt.draw()
plt. show ()
plt.ioff() # on quitte le mode intera=tif pour rendre la main a
l ' utillsateur sur la courbe
plt. show ()
lss. closeBus ()
 90

Annexe 2 : Code PID Vitesse pour un seul servomoteur.

irnport lss
irnport numpy as np
irnport matp l ot lib.p yplot as plt
irnport lss const as lssc
irnport time
irnport serial

eS T LSS Port = " )M4"

eST LSS Baud = 115
eS T LSS Baud = lssc.LSS DefaultBaud
l ss.initBus (eST_L SS Port, eST LSS Baud)
myLSSl = lss.LSS ( )
#myLSSl.reset() #reset le servo moteur
time.sleep ( S ) ~ il prend 5 seconde apres le reset pour redemarrer

#partie de la courbe

plt.style.use ( ' ~ l ' )

#plt . xlabel( " temps en s " )
#plt . ylabel( " valeur " )
#pl t . ion ()
#les valeurs du régulateur
Kp=
Ki = l
Kd=
#~eer étape positiJn 0
myLSSl.move( ü )
#initlalisation de la variable previous position à 0 pour mémoriser la
posi ion précédente
prev_pos =
#bouble while touJours vraie
while 1 :
valeurs =[] #on y stoque les valeurs pour dessiner les courbes
temps= []
vitesse= []
consigne=[]
print ( " L 1. tr,l:' np;(t t: L~~()n:" ) #l angle en degre x 10 qu ' on veut
atteindre
Setpoint =int (input ()) #lecture de la valeur écrite par l ' utilisateur
print ( ". ~r rr " ) #Speed degré par seconde
set_speed =int (input ()) #lecture de la valeur érrite par l ' utilisateur
pv_speed=int(myLSSl.getSpeed()) # la vitesse du servo
pos =int(myLSSl.getPosition()) #la position du servo
e_speed_ sum= J#somme des erreurs
e_speed_ pre= C#mémorisation de l ' erreur précedent
possomme= #les degrés parcourus par le servo
print ( " otp" t-" ,Setpoint, "prOH_p s" , prev_ pos, "l,r Jllli,~" ,possomme)
while (Setpo i nt-pos <- bor Setpoint -pos > 6 ) and (p ossomme<abs (Setpoint-
prev_pos)) :
#condition d'arret (erreur entre -30 et 30 degrés)
#les degres parcours < la d~fférence entre la derniere position et la
nouvelle
 91

pv_speed=int(myLSSl.getSpeed(» #la vitess( Ju servo

pos =int(myLSSl.getPosition(» #la prSlti 'n d~ servo
e_speed = set_speed - pv_speed # a12J~ j~ ' ~~rp r jp vitpsse
pwm_pulse = e_speed*Kp + e speed_sum*Ki + e speed - e speed_pre
*Kd #la f rm le iu ~égula~eJl LII
e speed_pre = e_speed ~rr~r. risctti)n clp ::' t->rre.H precedent
e speed_ sum += e speed lie Ol"lIT'e dF's erLE lrs

if e speed_sum >
e speed_sum #11.mlt'l.ti0n a ' int.=.r"alh' .a SOl'1ll1'" ne depassp
pas 3JO

if e speed_sum <- (
e speed_sum n# ::'lmit ati~,n d ' intervall~' la s :)mme ne depasse
pas -30~

Erreur= Setpoint-int(myLSSl.getPosition(» t alcul de l ' erreur de

position

if(pwm_pulse < and pwm_pulse >- ) : ftaffe~tatiùn je la pwm a~ moteur si

elle est- Jan",
myLSSl.moveRDM(int(pwm_pulse» #un intprvall~ 1,ceptable de
300 et 300

elif pwm pulse> 1 : tlimitati n l ' intervalle pwm ne dépasse pas 300
myLSSl.moveRDM(
pwm_pulse=

elif pwm_pulse<- : ~~lm~tal' r ' intervalle pw~ n~ (ep~sse pas -30G

myLSSl.moveRDM(- 1
pwm_pulse=-

myLSSl.moveRDM(int(pwm_pulse»

valeurs.append(pos) # l t des valpurs pour dessiner la courbe

vitesse.append(pv_speed) Jajnu r des valeurs pour dessiner la
courbe
consigne.append(set_speed)
millis =int«time.time()* l »
temps. append (millis) #p r ~~ L "lCag'" j Iv lrl
possomme= possomme +abs(pos-int(myLSSl.getPosition(»)
#calcule d!:" 11 s 'mm'" des dpgr-"_ p r~ ur lS à ha'1 terat~oL de la bO,J..;l(:-'
while

print ( " " , str (myLSSl. getPosi tion () ) , , ,)

prev_pos=Setpoint #mt->no 3 t. n dp la dernie pos'r~on dans la
variable p~e··_p' s
#traçage de l~ ~0 rbe
plt.plot(temps,vitesse, label= " . L , l < ' ci " ) 4 trace la
courbe
pl t . plot (temps, cons igne, , , ,label= " i rr
r

pl t . legend ()
 92

myLSS1. hold ()
plt.ioff() # on quitte le mode interactif pour rendre la main a
l ' utilisateur sur la courbe
pH. show ()
Iss. c l oseBus ()
 93

Annexe 3 : Code double PID sur la position et la vitesse

(trapézoïdale)pour un seul servomoteur
import lss
import numpy as np
import matplotlib.pyplot as plt
import lss eonst as lsse
import time
import serial

eST LSS Port = " ~'4"

eST LSS Baud = 11
eST LSS Baud = lsse.LSS DefaultBaud
lss.initBus(eST_LSS Port, eST_LSS_Baud)
myLSSl = lss.LSS( )
#myLSS1.reset() #rLset le servo mvte~r
#time . sleep(~) # II prpni r Sp O~ e apres le reset pour redemlrrer
myLSS1.setAngularAeeeleration( ) ~l'aceeleratun ~~X
myLSS1.setAngularDeeeleration( ) rIa dé~pleration MAX
#myLScl.setMax(lO)#_a vi~ sSP lffir

1fpu --Ir _e t 1 age" ie la cc aLe

plt.style.use( 'r ')
#pl .>(~abp~("temr:.'s r s")
#pl . 'y labe~ ("vale'lr")
plt. ion ()

#une fonct~on qUl prends des p05ltlvn dans u~ lnt~rvalle ~n min,in mdX et
fait
#la regle de trois p ur 'Qs ~al uler dans l'int clalle cJuc-ir,out max
def ( x, in min, in max, out min, out max) :
return(x - in - mi;)*(out - m~x - out - min)/(in - max - in- min)+ out min;

,,
Kp=
Ki= l
Kd= 1
#ler eLape p')siticn 0
myLSS1.move ( )
time. sleep ( )
#in~tlallsa+ion de la variab:e previous poSitlO~ à 0 pour memorispr :a
position pLeeédente
pree_pos=
#bo ble ~~_le touj"urs vrdie

while :
position=[]
voltage=[] #on y 5toque les positlon pour -,~ssin.r les c~urbes
temps= []
Vitesse= []
 94

courant= []
temperature= []
consigne=[]
erreur_posit i on=[]

print ( " rit .. C')wn +h "wx+- positi'""r:" ) #l angle en degre x 10 qu ' on veut
atteindre
Setpoint =int (input (» #lecture de la valeur ecrite par l ' utilisateur

print ( " ~' r l l ... " )

pos = int (myLSS 1.getPosi ti on (»
rpm=int(myLSS1.getSpeedRPM(»
curr =int (myLSS1 .getCurren t(»
volt = int (myL SS1 .getVo ltage(»
temp =int (myLSS1 . getTemperature (»

pwm_pulse=O
e_pos_sum= O#somme des erreurs
e_pos_pre= J#mémorisation de l ' erreur précedent
possomme= #les deqres parcourus par le servo ,c'est ~ne condition de
sécurité
prec_pos=O#initialisation de la position précedente a (
print ( " nr-" ,Setpoint, "pr!:' _ pu " ,prec_pos, "1 0'3'3. mm. " ,possomme)
V=
prec_pwm= J
while (Setpoint -pos <- or Setpoint -pos > <) and (possomme< abs (Setpoint -
prec_pos» :
#condltion d ' arret (erreur entre 2 et 2 degres)
#les degres parcours < la différence entre la derniere position et la
nouvelle

rpm=int(myLSS1.getSpeedRPM(» #la Vitesse du servo

pos =int (myLSS1.getPositi on (» #la position du servo
e_pos = Setpoint - pos #~al ul dp l ' prreur de p si+-i n
pwm_pulse = e_pos*Kp + e_pos sum*Ki + e_pos - e_pos_pre *Kd #la
formule du régulateur pro
e_pos_pre = e_pos #mémorisation de l ' erreur précedent
e_pos_sum += e_pos #somme des erreurs
print ( "p n t l r ~" ,pwm_pulse) #affichage de la sortie du pro
# if pwm_pulse >500 :
# pwm _pulse = SC #limitation d ' intervalle pwm ne depasse pas 300

# if pwm_pulse<-5JO :
# pwm_pulse - -500 #limitation d ' intervalle pwm ne depasse pas -300

if (pwm_pulse > ):
pwm=mapnbr( pwm_pulse, ~ , 700 , 1'0 , 700 ) #calcul des valeur de sortie
du pro dans
#l ' intervalle de tonctionnement du servo moteur
elif (pwm_pulse < ):
pwm=mapnbr( pwm_pulse,- 5 ,- 700 ,- 1'O ,- 700 ) #de meme pour les
position negatives

print ( "~'rJr " ,pwm ) #affichage du résultat de la conversion

if e_pos sum >

 95

e_pos sum '#llml tat' ~r d ' in'::.ervall riE 13. '3("mme du rIO (nE:
dépasse pas 0'1)

if e_pos sum <-

e_pos sum l#l'mlt~t:~n ~ ' interval:ç ~e la somme du PlO (~e
dépasse p~~ - )

Erreur= Setpo int- int (myLSSl . getPosi ti on (» alc~l de l ' erreur de

pOSl tl Il

#encrét~ge de :a Vltesse

if pwm> : #llmitation d ' intervalle pwm ne depasse pas 3JJ

pwm=

if pwm<- . : #llmltation d ' int~rval:0 pwm ne jepas~~ pas -300

pwm=-

#encrètag e de ~ ' accèleratiQn

if pwm-prec_pwm>
pwm = prec_pwm+ 0
if pwm-prec_pwm<- "J :
pwm = prec_ pwm- )0

myLSSl.moveRDM(int(pwm» ~ }. ,'vmmande cie rrruv'!mE'nt du serva !T,oteur

print ( " , r . ' LUT r :1 ,)

print( " .IS t il n (L l ,( "+ str (pos ) ) ;
print( " , ...., c; E:~ \ r ,,1'" ) " +str (rpm» ;
print( " lr ut (mA) "+str (cu rr» ;
print( " ct- J.Q'> (m'!) " +str (vo lt»;
print ( " ,n,p' 'ut' (1 (Cl " +str (temp» ;
#print ( " pos= ", int (myLSSl. getP' si ~ n () ) )
*print ( " V!. tE's~e ", lnt (myLSS. get SpE'edRt-M () ) )
#print ( " Curent (mA) " + str (c.Jrr))
#print ( " ~empE.·.rature (lllr C) "+ str (temp))

vo ltage. append (vo lt) inb~rer da~s la CC)lr~~

position.append(pos) ~~jollt des position peur dessiner la -..::"urbe
#Vitesse . append(rpm)
courant .append ( curr )
temperature.append(temp)
cons igne.append( Setpoint )
Vitesse.append (rpm)
millis = int ((time.time ()* »
temps.append(millis) it[ >-> ! ~a_age de Id ,r)'ube

#err_p, s = ln (abs(pre pos e p in ))

erreur_position.append(e_pos)
possomme= possomme +abs (pos - int (myLSSl .getPosition (»)
 96

#calcule de la somme des degres parcourus a chaque itération de la boucle

while

myLSSl. hold ()
print( " r " ,str(myLSSl.getPosition (») " ' )
prec_pos=Setpoint #memorisdtion de la derniere posirion dans la
vari3b:e pre r pos
#traçag p i p la rourbe
plt.figure( "-- ~t- plO )
plt.plot(temps,voltage, " ." , label= " ~Jn ")
plt.figure( "r:; ",~t " )
plt.plot(temps,position, '" " , label= "~'\p~ ' .l, Y_ , Y'i-J.'1~" )
plt.plot(temps,consigne, " " ,label= " on~igne ")
plt .legend ()
plt.figure( "· oso.;e" )
plt.plot(temps,Vitesse, "" label= "'\p= ( .1, K~ l . l, Y-i 1 . ~" ) # tracE'
la rourbe #plt.subplot(3,:,3)
pl t . legend ()
plt.figure( " a_ " )
plt.plot(temps,courant, ".j:" , label= " ilLP :" )
plt.figure( " IpP~ rp " )
plt.plot(temps,temperature, " " ,label=" Lgn<2 ")
pl t . legend ()
plt.figure( "p_1011r:r ~ rIO )

pl t. plot (temps, erreur _posi tion, "y" , label= " ~ _ :f,'t::' " )
myLSSl. hold ()
plt.ioff() # on quitte le mode interactlf pour rendre la maln a
l'utilisa eUL sur la courbe
plt. show ()
lss.closeBus()
 97

Annexe 4 : Code Fuzzy_logic sur la Position

irnport lss
irnport numpy as np
irnport matplotlib.pyplot as plt
irnport lss const as lssc
irnport time
irnport serial
irnport skfuzzy as fuzz
frorn skfuzzy irnport control as ctrl

eST LSS Port = " )1'4"

eST LSS Baud = l~
eST LSS Baud = lssc.LSS DefaultBaud
lss.initBus(eST_LSS Port, eST LSS Baud)
myLSSl = lss.LSS( )
myLSS1.move( )
_attente y~ ndes
time. sleep ( )
_les entre s

Setpoint= t

#p ur le tra age de la ~üurb~

plt.style.use( ' ')
plt.xlabel( " ")
pl t. ylabel ( " ,de' " )

#fon~t~ n r e freinaqe
def (speed) :
i=
if(speed >= L and speed <= ):
i= .~a marge d'erLeur n ~.gres que le serva dc~t ~'drreter avant
les atteindre
if(speed > 1 and speed <= ):
i=
if(speed > and speed <= ) :
i= 4
if(speed > and speed <= ) :
i= ~
return(i)

#on ) s =Il e les valt"ur s pO..!I ries,,", i nt=> Iles 'vur bes
Vitesse=[]
posi tion= []
temps= []
correction=[]
voltage=[] #o~ y stoque les p~sltion pour dessi'p· ~es courbes

courant= []

consigne=[]
xl=
*entrée erreur de vltesse entre -qO ft ~)
 98

PosErr= ctrl.Antecedent (np.arange(- 180C , 18 0 , 1 ), 'ro~Er~' )

#sortie re tification erreur PWM entre -50 et 50
RDMrectif=ctrl.Consequent(np.arange(- 3JO , 30C , 1 ) , 'PDMrE,·t __ ' )

fla définition des interva_les de l'entrée

PosErr[ ' iqNF~PosEr ' ]=fuzz.trapmf(PosErr .universe, [- lBOO ,- I~ ,- OC ,-
0 ])
PosErr[ '''':i\=lPo;fr ' ]=fuzz.trimf(PosErr.universe,[- 0 ,- Ol ,- l ])
PosErr[ ' r l~LNeqF_fLr_' ]=fuzz.trimf(P os Err.uni verse, [- ~J ,- o) ,- ~ ])
PosErr[ ' ~ry':-mdll~J 1F ' ]=fuzz .trimf (PosErr.universe, [- ( ,- 1 ) , 0 ])

PosErr[ ' ery.m~l:!_dF ' ]=fuzz .trimf(PosErr.uni verse, [ , 1 , ~O ])

PosErr[ ' ,[1 l~lPosI )!..~_ ' ]=fuzz.trimf(PosErr.universe, [ 2 , 0 , _ 0 ])
PosErr[ 'MerjPa::-pr'sFr ' ]=fuzz.trimf(PosErr.universe, [ lCO , "1 0 , 300 ])
PosErr[ '~~)fo~FogEr ' ]=fuzz.trapmf(PosErr.universe, [ , SlO , 1 r , lEOO ])

fla définition des intervalles de la sortie

RDMrecti f [ ' igNû JI<~)Mre -+- -:. ' ] =fuzz . trapmf (RDMrectif . uni verse, [- 3 JO , - 3 J ,-
~R5 ,- J ])
RDMrectif[ 'I1:,dNelK)Mre;t~f' ]=fuzz.trimf(RDMre cti f.uni verse, [- 70 ,- 235 ,-
2 CJ ] )
RDMrectif[ ' T'al:"N. JrJ!:.1r tif' ]=fuzz.trimf(RDMrec tif.uni verse, [- 2., ,- _90 ,-
1 ])
RDMrectif [ ' ~ 't'S'ni'! lIN ' ~K:->Mre ·t ,! ' ] =fuzz . trimf (RDMrectif . uni verse, [- 1 ... 0 ,-
1 ])

RDMrectif [ , r yS'nd 1 lE vsK.JM' e,+- l ' ] =fuz z . trimf (RDMrectif . uni verse, [ 1 0 , 17"
, 1 Q ])
RDMrectif [ , 1:1Pr ,R[I~1rE ct i ~ ' ] =fuzz. trimf (RDMrectif . universe, [ 1 QO , 1 C , L. (

] )
RDMrectif[ ' ' ... dPù.· ..h'Mre·ti ' ]=fuzz.trimf(RDMre ct if.universe ,[ 0, 5 , 70 ])
RDMrectif[ 'biq~o~~[Mre tl! ' ]=fuzz.trapmf(RDMrectif.universe, [ "70 , ~ 5 , 30J ,
3 ( ])

#dessiner les courbes des définitions

PosErr. view ()
RDMrectif. view ()
Iles lois a appliquer entre la sortie et l'entrée
rule1 ctrl.Rule(PosErr[ 'l:igNegPosEr ' ] ,RDMrectif[ 'l igNo=:gRDMre'L ' ])
rule2 = ctrl. Rule (Pos Err [ ' 'edl'.eqPosEr_' ] , RDMrectif [ ' M::odNegRDMre::':l ' ])
rule3 =
ctrl. Rule (Pos Err [ ' èrr",llNt'qF'-'sEr ' ], RDMrectif [ ' 3rr,a1~NegR[lMrf'ct if' ])
rule4 =
ctrl . Rule (Pos Err [ ' :,r 't :ma: ~NerJPosEr ~ , ] , RDMrectif [ ,~, ~rySn,lllNt'gRDMr ~c t i _ ' ]
)
rule5 =
ctrl.Rule (P osErr [ ' "'r/Srra_ PO.::iPusEr~ ' ] ,RDMrectif[ ' ':!r'.'Sl"lallPosRDMrectir' ]
)
rule6 =
ctrl.Rule(PosErr[ '2m III 2o~Err' ] ,RDMre c tif[ '5rral sRDMrectif' ])
rule7 ctr l.Rule(PosErr [ ' ledP(.; , sEr ' ] ,RDMrectif[ 'M.:dPosRDMrect f' ])
ruleS = ctrl .Rule(Pos Err[ ' .LgPo'lPosEr_' ],RDMrectif [ ' ilPOdKDM r t'c+-i ' ])

#faire entrer les lois dans le systeme fuzzy

 99

pe rf_ctrl =ctr l .Contro l System ([ rulel , rule2 , rule3,rule4,ru l e5,ru l e6 , rule7,r

ule 8 ])
pe rf=ctr l. Contro l SystemS i mu l ation (perf ctr l)

pos =int (myLSSl.ge t Pos i tion () H 3. P(SLtlon du se,v

pwm_ pu l se=
possomme=
#prev p s

while (Setpoint - pos< - or Setpoint-pos> ) and (possomme<abs (Setpo i nt »:

#aJout des valeurs pour dpsslnpr la - urbe
pos iti on . append (int (myLSS1 . getPosit i on (»)
Vitesse.append (int (myLSS1.getSpeed (»)
cur r =int (myLSS 1 .getCurrent (»
milli s = int «t ime .time ()* »
t emps . append (mi l lis )
correction. a ppend (pwm_pulse )
consigne . append (Setpo i nt )
couran t. append (curr )

#l'entrèe au fuzzy l ' crreur J~ p s.t. n

per f. input [ ' )sEr ' ]=( Setpoint - int (myLSS1 . getPosit i on (»)

print ( " h, " , int (myLSS1. getPosi tion () ) )

if (abs (Setpoint -
int (myLSS1 . getPosition (»)<=test (abs (int (myLSS1.getSpee d (»»):
myLSS1.moveRDM ( )
myLSS1 . hold ()
print ( . " , int (myLSS1 . getPosi tion () ) , "
" ,tes t( int (myLSS1 . ge t Speed (»»
break

#fuzzy rommLnce le calcul

per f .compute ()

print ( " " , int (myLSS1 . getPosi tion () ) )

if (abs (Setpoint -
int (myLSS1 . getPosition (»)<=test (abs (int (myLSS1.getSpeed (»»):
myLSS1.moveRDM ( )
myLSS1 . hold ()
print ( " " , int (myLSS1.getPosition (» , "
" ,tes t( int (myLSS 1 .getSp eed (»»
break

#la somme dP5 rèctificatins t l.zy

pwm_ pulse=int (perf . output [ ' ,ln' E • ] )

if pwm_ pulse> : rtllrl'ltatl n :i ' ~ tE'rvalle pwm ne rj"pasc,E' pdS i'lO

myLSS1.moveRDM (
pwm_pu l se=
 100

elif pwm pulse<- : #limitatlon d ' intervalle pwm ne dépasse pas -30u
myLSSl.moveRDM(- )
pwm_pulse=- 700

#affp~ta~ion de la sortie au servo moteur

myLSSl.moveRDM(int(pwm_pulse»

#conditi)n , atteinte de la position

d ' arr~t
print ( "1 'O,j" , int (my LSS l.getP os iti on (»)
if (abs (Se tp o int-
int(myLSSl.getPosition(»)<=test(abs(int(myLSSl.getSpee d(»»):
myLSSl.moveRDM( O)
myLSS l. hold ()
print ( " lt~" ,int(myLSSl.getPosition(», " i
" ,test ( int (myLSSl. getSpeed () ) ) )
break

possomme= possomme +abs (pos - int (myLSSl.getPosition (»)

#calcule de la somme des degres palC< urus à chaque itération de la boucle
while
pos =int(myLSSl.getPosition(» #la position du servo

myLSSl. ho ld ()
possomme= possomme +abs (p os - int (my LSS l.getPosition (»)
print ( "1 ; t~ ~~-" , int (myLSSl. getPosi tion () ) )
print ( " Ar mt "+ str (curr ) ) ;
xl= l

plt.figure( "r in" )

plt.plot(temps,position, 'r' )
plt.plot(temps,consigne, " ")
#pl t . legend ( )
plt.figure( " _ ")
plt.plot(temps,Vitesse, '~' ) # trace la courbe #plt . subplot(3 , l , 3)
#pl t . lpgend ()
plt.figure( " (' '-" )
pl t. plot (temps, courant, ' ' )
#plt . l r'gend ()
plt.figure( " ~ ·n" )
plt.plot(temps,correction, '~ ' )
#pl t . legend ( )
plt. show ()
lss.closeBus()
 101

Annexe 5 · Code Fuzzy_logic sur la Vitesse

irnport lss
irnport numpy as np
irnport matplotlib.pyplot as plt
irnport lss const as lssc
irnport time
irnport serial
irnport skfuzzy as fuzz
frorn skfuzzy irnport control as ctrl

CST LSS Port = "' )A~ Il

CST LSS Baud = llS~(

CST LSS Baud = lssc.LSS DefaultBaud
lss.initBus(CST_LSS Port, CST LSS Baud)
myLSSl = lss.LSS( l )
myLSS1.move ( 1 )
#attente 3 secondes
time.sleep( 3 )
#les entrées

SetSpeed=tù

Setpoint= OC

#polr le traçage de la ccurbe

plt.style.use( 'bI'" ' )
plt.xlabel( ">-PHtr p ~" )
plt.ylabel( " vüeù " )

def ~ (speed):
i=O
if(speed >=1 and speed <= 1 ):
i= "
if(speed > l ' and speed <=23 ) :
i= q
if(speed >23 and speed <= ):
i= lO
if(speed > ~ and speed <= 1):
i= 13
return(i)

#on y stoque les valeurs po~r dessiner les rourbes

Vitesse=[]
position=[]
temps= []
consigne=[]
correction= []
#entrée erreur de vitesse entr p RO et q
SpeedErr= ctrl.Antecedent(np.arange(- t , 0 ,1), ' !-<;-' iE.r~' )
#sortie re-tification erreur PWM entre -5 et sa
RDMrectif=ctrl. Consequent (np. arange (- 7('(1 , 7(11 , 1) , 'P[ nr - t i ' )
#la définition des intervalles de l'entrée
SpeedErr[ ' p~~pe d~'~' ]=fuzz.trimf(SpeedErr.universe,[- ~ ,- 0( , ])
 102

SpeedErr[ ' eroSp~edS L' ]=fuzz.trimf(SpeedErr.universe , [- bO , ( , 60 ])

SpeedErr[ 'f~sfpe~dErr' ]=fuzz.trimf(SpeedErr.uni verse, [ O, bO , bO ])

#la défin':"+ion dps intervdlles de la sortie

RDMrectif [ "'"'-1RD~lYF>'-'~ 1 +" ] =fuzz. trimf (RDMrectif. uni verse, [- 7 0 , - r 0 , L] )
RDMrectif[ ' _ro_<DEr _~ ~' ]=fuzz.trimf(RDMrectif.universe, [- l , C , ])
RDMrectif [ ' ,~<r)tv'Yt' ~ i~ ' ] =fuz z . trimf (RDMre ctif. universe, [ -, il , Il ])

#dessinLl les _ 'urbi';'s des définitions

SpeedErr. view ()
RDMrecti f . view ()
#les lois a appllquer entre la sortie et l'entrée
rulel = ctr l.Rule( SpeedErr [ '~~qSpp~~Er ' ],RDMrecti f[ '~ J8DMrectit' ])
rule2 ctr l.Rule(SpeedErr[ 'Z~r~SpEldEl ' ] ,RDMrecti f[ ' ,er0RDMre~tl~' ])
rule3 ctr l . Rule (SpeedErr [ ' l )c,Sf.t..E.. dE.:: ' ], RDMrectif [ " '38[IMrectit' ])

#faire entrer les lois dans le systeme fuzzy

perf_ctrl=ctrl.ControlSystem([rulel,rule2,rule3])
per f=ctrl.ControlSystemSimulation (perf ctr l)

pos =int (myLSSl.getPosition (» #la position du servo

pwm_pulse= J
possomme= r
#prev pos=O

while ( Setpoint -p os <- ~ or Setpoint-pos> ~ ) and (p ossomme < abs ( Setpoint »:

#l'pntr = au fU 7 zy l'erreul d~ ~ esse

perf.input [ ' p~<dErl' ]=( SetSpeed - int ( my LS Sl.getSpeed (»)

print ( " _" ,int (myLSSl. getPosi tion () ) )

if (Setpoint - int (myLSSl . getPosition (»<=test( int (myLSSl.getSpeed (»»:
myLSSl.moveRDM( O)
myLSSl. hold ()
print ( " t _ .1." ,int (myLSSl . getPosi ti on () ) , "
" ,test (int (myLSSl. ge t Speed () ) ) )
break

#fuzzy commence le calcul

perf.compute ()
print ( " " ,int (myLSSl . getPosi tion () ) )
if (Setpoint-int (myLSSl.getPosition (»<=test (int (myLSSl .getSpeed (»»:
myLSSl . moveRDM ( J )
myLSSl . hold ()
print ( " " , int (my LSSl .getPos iti o n(» , " :
" ,test ( int (myLSSl. getSpeed () ) ) )
break

#ajout des ~aleurs pour dessiner la courbe

position .append (int (myLS Sl.getPos iti on (»)
Vitesse .append ( int (myLSSl.getSpeed (»)
millis = int «time.time()* ~O J »
temps.append(millis)
 103

consigne . append (SetSpeed)

correction . append (int (perf.output [ ' tl ' ]»

print ( "l " , int (myLSS1 . getPos i tion () ) )

if (Setpoint - int (myLSS1.getPosition (»<=test ( int (my LSSl.getSpeed (»»:
myLSS 1. moveRDM ( )
myLSS 1 . hold ()
print ( " ~-'- " , int (myLSS1.getPosition( » , " l
" , test ( int (myLSS1 . ge t Speed () ) ) )
break

#la s 'mIrP des rp, tifirat~ n t ZZ'y

pwm_pu l se=pwm_pulse+int (perf . output [ ' [';u ·t i ])

if (pwm_ pu l se < J and pwm_pu l se >- JU ) : ~affectati)n de la pwm au mcteur si

ell st- dans
myLSSl.moveRDM ( int (pwm_ pulse » Jrun l'1t~rvallé' iccepLible Jt' -
30C et 31)(

elif pwm pu l se > : ~limitd ct' int-ervalle pwm n2 depasse pas 3 l1Q
myLSS1.moveRDM (
pwm_ pu l se =

elif pwm_pu l se<- le : #limlt~tl~n j';n~(rvalle pw~ n~ dépasse pas -30l)

myLSS1 . moveRDM ( - )
pwm_ pulse=-

#afft-rtation de ct 0rtiE. ~u , r - ["ut" 'Ar

myLSS1 . moveRDM (int (pwm_ pulse »

lt,-ond~tiJn d'"1r~pt ,atte~ __ te de 1. P ,,~ti n

print ( " _" , int (myLSS1 . getPosi t i on () ) )
if (Setpoint - int (myLSS 1. getPosition (»<=test (int (myLSSl.getSpeed (»»:
myLSS1 . moveRDM ( J )
myLSS 1 . ho l d ()
print ( " t L " ,int (myLSS1.getPosition (» , "
" , test ( int (myLSS1. getSpeed () ) ) )
break

possomme= possomme +abs (pos - int (myLSS1.getPosition (»)

#ralcule de 1'1. somme des Jp;)"res par urus à haqcle itéra+-i n de la bOcl-::le
while
pos =int (myLSSl.getPosition (» Jtll. position de! s_rvo

print ( liE =" ,int (myLSS1. getPos i t i on () ) )

if (Setpoin t- int (myLSS 1. getPos it ion (»<=test (int (myLSS l. getSpeed (»»:
myLSS 1 .moveRDM ( C)
myLSS 1 . hold ()
print ( " " ,int (myLSS1.getPosition (» , " l
" ,test (int (myLSS1 . getSpeed (»»
break

myLSS1 . hold ()
possomme= possomme +abs (p o s-int (myLSS1.getPosition (»)
 104

print( " "'s " ,int(myLSS1.getPosition(»)

plt.figure( " r: '3l l n " )

plt.plot(temps,position, ' r ' )
plt.figure( " · i LS " )
plt.plot(temps,Vitesse, ' _ ' )
pl t . plot (temps, consigne, " ")
plt.figure( " -r " )
pl t. plot (temps, correction, ' ' )
plt. show ()
lss.closeBus()
 105

Annexe 6 : Code double Fuzzy_logic sur la position et la

vitesse(trapézoïdale) pour un seul servomoteur
irnport lss
irnport numpy as np
irnport matplotlib.pyplot as plt
irnport lss c o nst as lssc
irnport time
irnport serial
irnport skfuzzy as fuzz
frorn skfuzzy irnport control as ctrl

eST LSS Port = " "1."

eST LSS Baud
eST LSS Baud = lssc.LSS DefaultBaud
lss.initBus(eST_LSS Port, eST LSS Baud)
myLSSl = lss.LSS( ~ )
myLSSl . mov e ( )
#atten rp 1 s~ rdes
time. sleep ( )
#les entree
#-5(;0 = >aou
Setpoint= l )('

#pour lp rrac,gp
plt.style.use(
plt.xlabel( " ")
plt.ylabel( " d. ")

#fonrtion po ~ ~e frein'3.ge
def (speed) :
i=l
if(speed >=_ and speed <= ):
i= O#la marge d ' erreuL en ~egres que le serv~ doit s ' arreter avant
les atrelndre
if(speed > and speed <= ):
i= )
if(speed > and speed <= ) :
i=
if(speed > and speed <= ) :
i=
return(i)

#on y stoque les valeurs pour jessiner les courbes

Vi tesse= []
position=[]
temps= []
correction= []
voltage=[] #or " strqt.e -,-ps ~'»Sltlon po"r dessL~pr :E5 -ourbes

courant= []

cons igne= []
 106

#xl-i)
#entrée erreur de position entre -1800 et 1800
PosErr= ctrl.Antecedent(np.arange(- 1BOO , 1800 , 1 ), 'fl)~ErL' )

#entrée erreur je vitesse entre -80 et 80

SpeedErr= ctrl.Antecedent(np.arange(- ~; , rJ , ) , " ,<0dEr~' )

#sortrp rectifr~a+ron erreur PWM entre -50 et ~

RDMrectif=ctrl.Consequent(np.arange(- 700 , 700 , 1 ) , '-DMrectiE' )

#la deflnltion des lntervalles de l'entrée Position

PosErr[ ' "gF..,sEr ' ]=fuzz.trimf(PosErr.universe,[- lPO~ ,- ·:' ,])

PosErr[ ' "'IC[0JE_ ' ]=fuzz.trimf(PosErr.universe, [- loC , 0 , luOO ])
PosErr[ ' J'3f sf"r ' ]=fuzz.trimf(PosErr.universe, [ , lQ , 1 }(, ])

#la defrniti,n des interva:les de l ' entrée Speed

SpeedErr [ ",-, rc.;pe",dEr ~ , ] =fuz z . trimf (SpeedErr. uni verse, [- 60 , - 6( , n ] )

SpeedErr[ ' "·rcfpEAdE_~' ]=fuzz.trimf(SpeedErr.universe, [- bO , O, oO ])
SpeedErr[ '~_SSpEE'dFr ' ]=fuzz.trimf(SpeedErr.universe, [ , r , 60 ])

#la défLnition des intervalles de la sortie

RDMrecti f [ 'l: :jNE'gR[J'1rE'd _ ' ] =fuzz . tr imf (RDMrecti f . uni verse, [- OC , - 700 ,-
1])
RDMrectif[ ': lR:'tv:rutL:,' ]=fuzz.trimf(RDMrectif.universe, [- ,- 5 ,])
RDMrectif[ 'u~ro~CArtctl~' ]=fuzz.trimf(RDMrectif.universe, [- " ~_ ])
RDMrectif[ '2 ,.R.['Vr ti_' ]=fuzz.trimf(RDMrectif.universe, [ , JI , 0 ])
RDMre c tif[ 'trgPü>RDMu'" ' ]=fuzz.trimf(RDMrectif.universe, [ 00 , ( , 1)0 ])

#de sin r les ~ourbes des définitions

PosErr. v iew ()
SpeedErr.view()
RDMrectif. view ()

#les _ lS a app_lquer entr ~a sort le et l'entrée

rulel = ctrl. Rule (PosErr [ 'l, 'gP sE_ ' ] &
SpeedErr [ '~'~. r _' ], RDMrectif [ '~ "J-J JRDi-1H'ct i ' ])
rule2 = ctrl.Rule(PosErr[ ' SEI~' ]&
SpeedErr[ 'uer '::pt. ..J.En ' ] ,RDMrectif[ 't1"' •.:(hDMr~cti ' ])
rule3 = ctrl. Rule (PosErr [ , 4 ':J sE_ 1. ' ] &
SpeedErr [ , .., , ] ,RDMrectif [ , ~- Vlr"'.-t 1 ' ])
rule4 = ctrl. Rule (PosErr [ ' :'03"'! ' ] &
SpeedErr[ '.-el...>!_ '~r' ],RDMrectif[ ', gP 're'~l ' ])
rule5 = ctrl.Rule(PosErr[ ' r Po Er1.' ]&
SpeedErr[ '~e 'r ~jrYr' ],RDMrectif[ '''' _ <'DMrccti ' ])
rule6 = ctrl.Rule(PosErr[ ' _ Po E __ ' ]&
SpeedErr [ , ~ _' ], RDMrectif [ , [' 're, t i ' ])
rule7 = ctrl.Rule(PosErr[ '~ sL_ ' ]&
SpeedErr [ ' "-1 '! '" '".i.E 1.' ], RDMrectif [ ''''el r DMrect i _ ' ] )
rule8 = ctrl.Rule(PosErr[ '''' 'rùsErr' ]&
SpeedErr [ ' Z'" ! r:' ], RDMrectif [ , .t RDMrect i ' ])
rule9 = ctrl. Rule (PosErr [ , ~ • sL~:::.' ] &
SpeedErr [ , P SI _ ' ] ,RDMrectif [ '1 - sRDt-lrf'ct i ' ])
 107

#faire pntrpr les lois d-oms l' tpn f 11ZZy

perf_ctrl=ctrl.ControlSystem([rulel,rule2,rule3,rule4,ruleS,rule6,rule7,r
ule8,rule9])
perf=ctrl.ControlSystemSimulation(perf ctrl)

pos =int(myLSSl.getPosition(» _d pu~ition du serve

pwm_ pulse=
possomme=
prec_pwm= r
#prev pos=O

if(Setpoint-int(myLSSl.getPosition(»<= J) :
SetSpeed=-

if(Setpoint-int(myLSSl.getPosition(»> ):
SetSpeed= ':l

while(Setpoint-pos<- or Setpoint-pos> ):
if(Setpoint-int(myLSSl.getPosition(»<= J) :
SetSpeed=- J

if(Setpoint-int(myLSSl.getPosition(»> ):
SetSpeed=
#a'o t le ~leurs pour les _n~r _1 urbe
position.append(int(myLSSl.getPosition(»)
Vitesse.append(int(myLSSl.getSpeed(»)
curr =int(myLSSl.getCurrent(»
millis =int«time.time()* »
temps.append(millis)
correction. append (pwm_pulse)
consigne.append(Setpoint)
courant.append(curr)

#l'ent:rét. al fuzzy : ' errpur "le ·"_tp'3

perf. input [ ' :.>ee 1Er ' ] = (SetSpeed-int (myLSSl. getSpeed () ) )
#l ' entrpe al fuzzy l ' erreur de p si'-_ n
perf. input [ ' . <,Er ' ] = (Setpoint-int (myLSSl . getPosition () ) )

print( " ~te ,c,~" , int(myLSSl.getSpeed() »

if(abs(Setpoint-
int(myLSSl.getPosition(»)<=test2(abs(int(myLSSl.getSpeed(»»):
myLSSl.moveRDM( )
myLSS 1 . hold ()
print( " " ,int(myLSSl.getPosition (» , " l
" , test2 (int (myLSSl. getSpeed () ) ) )
break

#fuzz,," COffiI'1en~e _e ralcu:

perf. compute ()
 108

print ( " _ s2=" , int (myLSS1 . getPosi tion () ) )

if (abs (Setpoint-
int (myLSS1.getPosition (»)<=test 2 (abs (int (myLSS1.getSpeed (»») :
myLSS1.moveRDM ( )
myLSS 1 . ho l d ()
print ( " i~ " ,int(myLSSl.getPosition(», " l
" , te st2 (int (myLSS1. getSpeed () ) ) )
break

#la s Irnrr,e des re, tifications fuzzy

pwm_pulse=pwm_pulse+int (per f. output [ '~Dr.lrecti _ ' ] )
print ( " rr =" , pwm_p u l se )
print ( " l è d " ,int(myLSSl.getSpeed(»)
if pwm_pulse > 50 : #limitation d'intervalle pwm ne dépasse pas 300
myLSS1.moveRDM( CO )
pwm_ pulse= 7

elif pwm_pulse<- ~0C : #limitation d'intervalle pwm ne dépasse pas -300

myLSS1.moveRDM(- 700 )
pwm_pulse=- 70)

#affe~t~tion de la sortie au servo moteur

myLSSl.moveRDM(int(pwm_pulse»
print ( "~ NI' _=" ,pwm_pul se )
#condiLion d'arret ,atteinte de la position
print ( "p <=" ,int(myLSSl.getPosition (»)
if (abs (Se tpo int-
int (myLSSl .getPos iti on (»)<=tes t 2 (abs (int (my LSSl . ge t Speed (»»):
myLSS l. moveRDM ( O)
myLSS l. hold ()
print ( " L " ,int(myLSSl.getPosition(», " i
" , test2 (int (myLSSl . getSpeed () ) ) )
break

possomme= possomme +abs (p os - int (my LSS l.get Pos iti on (»)
#calcul de la s ,mme des degres parcourus à chaque itération de la boucle
whlle
pos =int (myLSSl .get Pos iti on (» #la position du servo

myLSS 1 . ho Id ()
#possomme= possomme +abs(pos-int(myLSSl . getPosition()))
»
print ( " :'l, i 1- 0r fi n,ll( " , int (my LS S l. getPos i tion ()
print ( " .arriDt. ) " +str (curr » ;
#xl=l

plt.figure( "l n" )

plt.plot(temps,position, 'l ' )
plt.plot(temps,consigne, "... ")
#pl .legend ()
plt.figure( W- ")
plt.plot(temps,Vitesse, 'r' ) # trace la courbe #plt.subplot(3,1,3)
#pl t . legend ()
plt.figure( " ")
plt.plot(temps,courant, ' J' )
#pl t . legend ( )
 109

plt.figure ( " ~ 1" )

pl t. plot (t emps 1 correction l ' ' )

#pl t . legend ()
plt. show ()
lss . closeBus ()
 110

Annexe 7 : Code double Fuzzy_logic sur la position et la

vitesse(trapézoïdale) pour tous les servomoteurs du bras
import lss
import numpy as np
import matplotlib . pyplot as plt
import lss const as lssc
import time
import serial
import skfuzzy as fuzz
from skfuzzy import control as ctrl

eST LSS Port = " eOM4 "

eST LSS Baud = 115200
eST LSS Baud = lssc . LSS DefaultBaud
lss . initBus (eST_LSS Port , eST_LSS_Baud )

myLSS1 lss . LSS (l )

myLSS2 = lss . LSS (2 )
myLSS3 = lss . LSS (3 )
myLSS4 lss . LSS (4)

deftest2 (speed ) :
i =O
if( speed >=20 and speed <=30 ) :
i =20
if( speed > 10 and speed <=20 ) :
i =20
if( speed > 40 and speed <=50 ) :
i =30
if( speed > 50 and speed <= 60 ) :
i =40
return ( i )

deftest ( speed ) :
i =O
if( speed >=10 and speed <=17 ):
i =5
if( speed >17 and speed <=23 ):
i =8
if( speed >23and speed <=27 ) :
i =10
if( speed >27 and speed <=33 ) :
i =13
return( i )

Setpoint= 1000

PosErr= ctrl . Antecedent (np . arange (- 3600 , 3600 , 1 ) , ' PosErr ' )

SpeedErr= ctrl . Antecedent (np . arange (- 60 , 60 , 1 ) , ' SpeedErr ' )

 111

RDMrectif=ctrl . Consequent (np . arange (- 700 , 700 , 1 ), ' RDMrectif ' )

PosErr [ ' NegPosErr ' ]=fuzz . trimf ( PosErr . universe , [- 3600 ,- 3600 , 0 ])
PosErr [ ' ZeroPosErr ' ]=fuzz . trimf ( PosErr . universe ,[- 3600 , 0 , 3600 ])
PosErr [ ' PosPosErr ' ]=fuzz . trimf ( PosErr . universe ,[ 0 , 3600 , 3600 ])

SpeedErr [ ' NegSpeedErr ' ]=fuzz . trimf (SpeedErr . universe ,[- 60 ,- 60 , 0 ])

SpeedErr [ ' ZeroSpeedErr ' ]=fuzz . trimf (SpeedErr . universe ,[- 60 , 0 , 60 ])
SpeedErr [ ' PosSpeedErr ' ]=fuzz . trimf (SpeedErr . universe ,[ 0 , 60 , 60 ])

RDMrectif [ ' bigNegRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[- 700 ,-
700 ,- 500 ])
RDMrectif [ ' NegRDMrectif ' ]=fuzz . trimf (RDMrectif . universe , [- 700 ,-
500 , 0 ])
RDMrectif [ ' ZeroRDMrectif' ]=fuzz . trimf (RDMrectif . universe ,[-
500 , 0 , 500 ])
RDMrectif [ ' PosRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[ 0 , 500 , 700 ])

RDMrectif [ ' bigPosRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[ 500 , 700 , 700 ])

rulel = ctrl . Rule ( PosErr [ ' NegPosErr ' ]&

SpeedErr [ ' NegSpeedErr ' ], RDMrectif [ ' bigNegRDMrectif' ])
rule2 = ctrl . Rule ( PosErr [ ' NegPosErr' ]&
SpeedErr [ 'ZeroSpeedErr ' ], RDMrectif [ ' NegRDMrectif ' ])
rule3 = ctrl . Rule ( PosErr [ ' NegPosErr ' ]&
SpeedErr [ 'PosSpeedErr ' ], RDMrectif [ ' ZeroRDMrectif' ])
rule4 = ctrl . Rule ( PosErr [ ' ZeroPosErr ' ]&
SpeedErr [ ' NegSpeedErr ' ], RDMrectif [ ' NegRDMrectif ' ])
rule5 = ctrl . Rule ( PosErr [ ' ZeroPosErr ' ]&
SpeedErr [ ' ZeroSpeedErr ' ] , RDMrectif [ ' ZeroRDMrectif ' ])
rule6 = ctrl . Rule ( PosErr [ ' ZeroPosErr ' ]&
SpeedErr [ ' PosSpeedErr ' ], RDMrectif [ ' PosRDMrectif ' ])
rule7 = ctrl . Rule ( PosErr [ ' PosPosErr' ]&
SpeedErr [ 'NegSpeedErr ' ], RDMrectif [ ' ZeroRDMrectif ' ])
rule8 = ctrl . Rule ( PosErr [ ' PosPosErr ' ]&
SpeedErr [ ' ZeroSpeedErr ' ] , RDMrectif [ ' PosRDMrectif' ])
rule9 =
ctrl . Rule ( PosErr [ ' PosPosErr ' ]&SpeedErr [ ' PosSpeedErr ' ], RDMrectif [ ' bigPosRD
Mrectif ' ])

perf_ctrl= ctrl . ControlSystem ([ rulel , rule2 , rule3 , rule4 , rule5 , rule6 , rule7 , r
ule8 , rule9 ])
perf= ctrl . ControlSystemSimulation (perf_ctrl )

pos =int (myLSS1 . getPosition (»

pwm_pulse= O
 112

possomme= O
pre c _pwm= O

if( Setpoint - int (myLSS1 . getPosition (»<=O) :

SetSpeed=- 30

if( Setpoint - int (myLSS1 . getPosition (»>O) :

SetSpeed= 30

while( Setpoint - pos<- Sor Setpoint - pos >S) :

if( Setpoint - int (myLSS1 . getPosition (»<=O) :
SetSpeed=- lO

if( Setpoint- int (myLSS1 . getPosition (»>O) :

SetSpeed= lO

perf . input [ ' SpeedErr ' 1=( SetSpeed- int (myLSS1 . getSpeed () »

perf . input [ ' PosErr ' 1=( Setpoint - int (myLSS1 . getPosition ( »)

print ( " vitesse " , int (myLSS1 . getSpeed (»)

if( abs (Setpoint -

int (myLSS1 . getPosition (»)<=test2 (abs (int (myLSS1 . getSpeed (»»):
myLSS1 . moveRDM ( O)
myLSS1 . hold ()
print ( " out ifl " , int (myLSS1.getPosition (», " i
" , test 2 ( int (myLSS1 . getSpeed () ) ) )
break

perf . compute ()

print ( "pos2= " , int (myLSS1 . getPosi tion () ) )

if( abs (Setpoint -
int (myLSS1 . getPosition (»)<=test2 (abs (int (myLSS1 . getSpeed (»»):
myLSS1 . moveRDM ( O)
myLSSl . hold ()
print ( " out if2 " , int (myLSS1 . getPosition (», " i
" , test2 ( int (myLSS1 . getSpeed () ) ) )
break

pwm_pulse=pwm_pulse+int (perf . output [ ' RDMrectif ' l)

print ( " pwml= " , pwm_pulse )
print ( " speed= " , int (myLSS1 . getSpeed () ) )
if pwm_pulse >700 :
myLSS1 . moveRDM ( 700 )
pwm_ pulse= 700
 113

elif pwm_pulse<- 700 :

myLSS1 . moveRDM (- 700 )
pwm_pulse=- 700

myLSSl . moveRDM (int (pwm_pulse »

print ( " pwm2= " , pwm_pulse )

print ( "pos3= " , int (myLSS1 . getPosi tion () ) )

if( abs (Setpoint -
int (myLSS1 . getPosition (»)<=test2 (abs (int (myLSS1 . getSpeed (»»):
myLSS1 . moveRDM ( 0 )
myLSS1 . hold ()
print ( " out if3 " , int (myLSS1 . getPosition (», " i
" , test2 (int (myLSS1 . getSpeed (»»
break

possomme= possomme +abs (pos - int (myLSS1 . getPosition (»)

pos =int (myLSS1 . getPosition (»

myLSS1 . hold ()

print ( "posi tion finale= " , int (myLSS1 . getPosi tion () ) )

lss . closeBus ()
return (pos )

Setpoint= 1000

PosErr= ctrl . Antecedent (np . arange (- 1800 , 1800 , 1 ) , ' PosErr ' )

SpeedErr= ctrl . Antecedent ( np . arange (- 60 , 60 , 1 ) , ' SpeedErr ' )

RDMrectif= ctrl . Consequent (np . arange (- 700 , 700 , 1 ) , ' RDMrectif ' )

PosErr [ ' NegPosErr ' ]=fuzz . trimf ( PosErr . universe ,[- 1800 ,- 1800 , 0 ])
PosErr [ ' ZeroPosErr ' ]=fuzz . trimf ( PosErr . universe ,[- 1800 , 0 , 1800 ])
PosErr [ ' PosPosErr ' ]=fuzz . trimf ( PosErr . universe , [ 0 , 1800 , 1800 ])

SpeedErr [ ' NegSpeedErr ' ]=fuzz . trimf (SpeedErr . universe ,[- 60 ,- 60 , 0 ])

SpeedErr [ ' ZeroSpeedErr ' ]=fuzz . trimf (SpeedErr . universe ,[- 60 , 0 , 60 ])
SpeedErr [ ' PosSpeedErr ' ]=fuzz . trimf (SpeedErr . universe ,[ 0 , 60 , 60 ])

RDMrectif [ ' bigNegRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[- 700 ,-
700 ,- 500 ])
 114

RDMrectif [ ' NegRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[- 700 ,-
500 , 0 ])
RDMrectif [ ' ZeroRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[-
500 , 0 , 500 ])
RDMrectif [ ' PosRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[ O, 500 , 700 ])

RDMrectif [ ' bigPosRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[ 500 , 700 , 700 ])

rulel = ctrl . Rule ( PosErr [ ' NegPosErr ' ]&

SpeedErr [ ' NegSpeedErr' ], RDMrectif [ ' bigNegRDMrectif ' ])
rule2 = ctrl . Rule ( PosErr [ ' NegPosErr ' ]&
SpeedErr [ ' ZeroSpeedErr ' ], RDMrectif [ ' NegRDMrectif ' ])
rule3 = ctrl . Rule ( PosErr [ ' NegPosErr ' ]&
SpeedErr [ ' PosSpeedErr ' ], RDMrectif [ ' ZeroRDMrectif ' ])
rule4 = ctrl . Rule ( PosErr [ ' ZeroPosErr ' ]&
SpeedErr [ ' NegSpeedErr ' ], RDMrectif [ ' NegRDMrectif ' ])
rule5 = ctrl . Rule ( PosErr [ ' ZeroPosErr ' ]&
SpeedErr [ ' ZeroSpeedErr ' ], RDMrectif [ ' ZeroRDMrectif ' ])
rule6 = ctrl . Rule ( PosErr [ ' ZeroPosErr ' ]&
SpeedErr [ ' PosSpeedErr ' ], RDMrectif [ ' PosRDMrectif ' ])
rule7 = ctrl . Rule ( PosErr [ ' PosPosErr ' ]&
SpeedErr [ ' NegSpeedErr ' ], RDMrectif [ ' ZeroRDMrectif ' ])
rule8 = ctrl . Rule ( PosErr [ ' PosPosErr ' ]&
SpeedErr [ ' ZeroSpeedErr ' ], RDMrectif [ ' PosRDMrectif ' ])
rule9 =
ctrl . Rule ( PosErr [ ' PosPosErr ' ]&SpeedErr [ ' PosSpeedErr ' ], RDMrectif [ ' bigPosRD
Mrectif ' ])

perf_ctrl= ctrl . ControlSystem ([ rulel , rule2 , rule3 , rule4 , rule5 , rule6 , rule7 , r
ule8 , rule9 ])
perf= ctrl . ControlSystemSimulation (perf_ctrl )

pos =int (myLSS2 . getPosition (»

pwm_pulse= O
possomme= O
prec_pwm= O

if( Setpoint - int (myLSS2 . getPosition (»<=0 ) :

SetSpeed=- 30

if( Setpoint - int (myLSS2 . getPosition (»>O) :

SetSpeed= 30

while( Setpoint - pos<- 20 or Setpoint - pos >20 ):

if( Setpoint - int (myLSS2 . getPosition (»<=O) :
SetSpeed=- lO

if( Setpoint - int (myLSS2 . getPosition (»>O) :

SetSpeed= lO

perf . input [ ' SpeedErr ' ]=( SetSpeed- int (myLSS2 . getSpeed () »
 115

perf . input [ ' PosErr ' ]=( Setpoint - int (myLSS2 . getPosition ( »)

print ( " vitesse " , int (myLSS2 . getSpeed (»)

if( abs (Setpoint -

int (myLSS2 . getPosition (»)<=test2 (abs (int (myLSS2 . getSpeed (»»):
myLSS2 . moveRDM ( O)
myLSS2 . hold ()
print ( " out ifl " , int (myLSS2 . getPosition (», " i
" , test2 ( int (myLSS2 . getSpeed () ) ) )
break

perf . compute ()

print ( "pos2= " , int (myLSS2 . getPosi tion () ) )

if( abs (Setpoint -
int (myLSS2 . getPosition (»)<=test2 (abs (int (myLSS2 . getSpeed (»»):
myLSS2 . moveRDM ( O)
myLSS2 . hold ()
print ( " out if2 " , int (myLSS2 . getPosition (», " i
" , test2 (int (myLSS2 . getSpeed (»»
break

pwm_pulse=pwm_pulse +int (perf . output [ ' RDMrectif ' ])

print ( " pwml= " , pwm_pulse )
print ( " speed= " , int (myLSS2 . getSpeed () ) )
if pwm_pulse>700 :
myLSS2 . moveRDM ( 700 )
pwm_pulse= 700

elif pwm_pulse<- 700 :

myLSS2 . moveRDM (- 700 )
pwm_pulse=- 700

myLSS2 . moveRDM (int (pwm_pulse »

print ( " pwm2= " , pwm_pulse )

print ( " pos3= " , int (myLSS2 . getPosition (»)

if( abs (Setpoint -
int (myLSS2 . getPosition (»)<=test2 (abs (int (myLSS2 . getSpeed (»»):
myLSS2 . moveRDM (O)
myLSS2 . hold ()
print ( " out if3 " , int (myLSS2 . getPosition (», " i
" , test2 (int (myLSS2 . getSpeed (»»
break

possomme= possomme +abs (pos - int (myLSS2 . getPosition (»)

pos =int (myLSS2 . getPosition (»

 116

myLSS2 . hold ()

lss . closeBus ()
return( pos )

Setpoint= 900

PosErr= ctrl . Antecedent (np . arange (- 900 , 900 , 1 ) , ' PosErr ' )

SpeedErr= ctrl . Antecedent (np . arange (- 60 , 60 , 1 ) , ' SpeedErr ' )

RDMrectif= ctrl . Consequent (np . arange (- 700 , 700 , 1 ) , ' RDMrectif ' )

PosErr [ ' NegPosErr ' ]=fuzz . trimf ( PosErr . universe ,[- 900 ,- 900 , 0 ])
PosErr [ ' ZeroPosErr ' ]=fuzz . trimf ( PosErr . universe ,[- 900 , 0 , 900 ])
PosErr [ ' PosPosErr ' ]=fuzz . trimf ( PosErr . universe ,[ 0 , 900 , 900 ])

SpeedErr [ ' NegSpeedErr ' ]=fuzz . trimf (SpeedErr . universe ,[- 60 ,- 60 , 0 ])

SpeedErr [ ' ZeroSpeedErr ' ]=fuzz . trimf (SpeedErr . universe ,[- 60 , 0 , 60 ])
SpeedErr [ ' PosSpeedErr ' ]=fuzz . trimf (SpeedErr . universe ,[ 0 , 60 , 60 ])

RDMrectif [ ' bigNegRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[- 700 ,-
700 ,- 500 ])
RDMrectif [ ' NegRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[- 700 ,-
500 , 0 ])
RDMrectif [ ' ZeroRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[-
500 , 0 , 500 ])
RDMrectif [ ' PosRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[ 0 , 500 , 700 ])

RDMrectif [ ' bigPosRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[ 500 , 700 , 700 ])

rulel = ctrl . Rule ( PosErr [ 'NegPosErr ' ]&

SpeedErr [ ' NegSpeedErr ' ], RDMrectif [ ' bigNegRDMrectif ' ])
rule2 = ctrl . Rule ( PosErr [ ' NegPosErr ' ]&
SpeedErr [ ' ZeroSpeedErr ' ], RDMrectif [ ' NegRDMrectif ' ])
rule3 = ctrl . Rule ( PosErr [ ' NegPosErr ' ]&
SpeedErr [ ' PosSpeedErr ' ], RDMrectif [ ' ZeroRDMrectif ' ])
rule4 = ctrl . Rule ( PosErr [ ' ZeroPosErr ' ]&
SpeedErr [ ' NegSpeedErr ' ] , RDMrectif [ ' NegRDMrectif ' ])
rule5 = ctrl . Rule ( PosErr [ ' ZeroPosErr ' ]&
SpeedErr [ ' ZeroSpeedErr ' ], RDMrectif [ ' ZeroRDMrectif ' ])
rule6 = ctrl . Rule ( PosErr [ ' ZeroPosErr ' ]&
SpeedErr [ ' PosSpeedErr ' ] , RDMrectif [ ' PosRDMrectif ' ])
 117

rule7 = ctrl . Rule ( PosErr [ ' PosPosErr ' ]&

SpeedErr [ ' NegSpeedErr ' ] , RDMrectif [ ' ZeroRDMrectif ' ])
rule8 = ctrl . Rule ( PosErr [ ' PosPosErr ' ]&
SpeedErr [ ' ZeroSpeedErr ' ], RDMrectif [ ' PosRDMrectif ' ])
rule9 =
ctrl . Rule ( PosErr [ ' PosPosErr ' ]&SpeedErr [ ' PosSpeedErr ' ] , RDMrectif [ ' bigPosRD
Mrectif ' ])

perf_ctrl =ctrl . ControlSystem ([ rulel , rule2 , rule3 , rule4 , ruleS , rule6 , rule7 , r
ule8 , rule9 ])
perf= ctrl . ControlSystemSimulation (perf_ctrl )

pos =int (myLSS3 . getPosition (»

pwrn_pulse= O
possomme= O
prec_pwm= O

if( Setpoint - int (myLSS3 . getPosition (»<=O) :

SetSpeed=- 30

if( Setpoint - int (myLSS3 . getPosition (»>O) :

SetSpeed= 30

while( Setpoint - pos<- 20or Setpoint - pos>20 ):

if( Setpoint - int (myLSS3 . getPosition (»<=O) :
SetSpeed=- lO

if( Setpoint - int (myLSS3 . getPosition (»>O) :

SetSpeed= lO

perf . input [ ' SpeedErr ' ]=( SetSpeed- int (myLSS3 . getSpeed () »

perf . input [ ' PosErr ' ]=( Setpoint - int (myLSS3 . getPosition ( »)

print ( "vi tesse " , int (myLSS3 . getSpeed () ) )

if( abs (Setpoint -

int (myLSS3 . getPosition (»)<=test2 (abs (int (myLSS3 . getSpe ed (»»):
myLSS3 . moveRDM ( O)
myLSS3 . hold ()
print ( "out ifl " , int (myLSS3 . getPosition (», " i
" , test2 (int (myLSS3 . getSpeed (»»
break

perf . compute ()

print ( "pos2= " , int (myLSS3 . getPosi tion () ) )

 118

if( abs (Setpoint -

int (myLSS3 . getPosition (»)<=test2 (abs (int (myLSS3 . getSpeed (»»):
myLSS3 . moveRDM (O)
myLSS3 . hold 0
print ( " out if2 " , int (myLSS3 . getPosition (», " i
" , test2 ( int (myLSS3 . getSpeed 0) ) )
break

pwm_pulse=pwm_pulse +int (perf . output [ ' RDMrectif ' ])

print ( " pwml= " , pwm_pulse )
print ( " speed= " , int (myLSS3 . getSpeed 0) )
if pwm_pulse >700 :
myLSS3 . moveRDM (700 )
pwm_pulse= 700

elif pwm_pulse<- 700 :

myLSS3 . moveRDM (- 700 )
pwm_pulse=- 700

myLSS3 . moveRDM (int (pwm_pulse »

print ( "pwm2= " , pwm_pulse )

print ( "pos3= " , int (myLSS3 . getPosition 0) )

if( abs (Setpoint -
int (myLSS3 . getPosition (»)<=test 2 (abs (int (myLSS3 . getSpeed (»»):
myLSS3 . moveRDM (O)
myLSS3 . hold ()
print ( " out if3 " , int (myLSS3 . getPosition O), " i
" , test 2 ( int (myLSS3 . getSpeed 0) ) )
break

possomme= possomme +abs (pos - int (myLSS3 . getPosition (»)

pos =int (myLSS3 . getPosition (»

myLSS3 . hold ()

return (pos )
lss . c loseBus 0

Setpoint= lOOO

PosErr= ctrl . Antecedent (np . arange (- lOO , lSOO , l ) , ' PosErr ' )

SpeedErr= ctr l . Antecedent ( np . arange (- 60 , 60 , 1 ), ' SpeedErr ' )

RDMrectif=ctrl . Consequent ( np . arange (- SOO , SOO , l ), ' RDMrectif ' )

 119

PosErr [ ' NegPosErr ' ]=fuzz . trimf ( PosErr . universe , [- 100 ,- 100 , 0 ])
PosErr [ ' ZeroPosErr ' ]=fuzz . trimf ( PosErr . universe ,[- 100 , 0 , 1500 ])
PosErr [ ' PosPosErr ' ]=fuzz . trimf ( PosErr . universe ,[ 0 , 1500 , 1500 ])

SpeedErr [ ' NegSpeedErr ' ]=fuzz . trimf (SpeedErr . universe ,[- 60 ,- 60 , 0 ])

SpeedErr [ ' ZeroSpeedErr' ]=fuzz . trimf (SpeedErr . universe ,[- 60 , 0 , 60 ])
SpeedErr [ ' PosSpeedErr ' ]=fuzz . trimf (SpeedErr . universe ,[ 0 , 60 , 60 ])

RDMrectif [ ' bigNegRDMrectif ' ]=fuzz . trimf (RDMrectif . universe , [- 500 ,-

500 ,- 300 ])
RDMrectif [ ' NegRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[- 500 ,-
300 , 0 ])
RDMrectif [ ' ZeroRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[-
300 , 0 , 300 ])
RDMrectif [ ' PosRDMrectif ' ]=fuzz . trimf (RDMrectif . universe , [ 0 , 300 , 500 ])

RDMrectif [ ' bigPosRDMrectif ' ]=fuzz . trimf (RDMrectif . universe ,[ 300 , 500 , 500 ])

rule1 = ctrl . Rule ( PosErr [ ' NegPosErr ' ]&

SpeedErr [ ' NegSpeedErr ' ], RDMrectif [ ' bigNegRDMrectif ' ])
rule2 = ctrl . Rule ( PosErr [ ' NegPosErr ' ]&
SpeedErr [ ' ZeroSpeedErr ' ], RDMrectif [ ' NegRDMrectif' ])
rule3 = ctrl . Rule ( PosErr [ ' NegPosErr ' ]&
SpeedErr [ ' PosSpeedErr ' ], RDMrectif [ ' ZeroRDMrectif ' ])
rule4 = ctrl . Rule ( PosErr [ ' ZeroPosErr ' ]&
SpeedErr [ ' NegSpeedErr ' ], RDMrectif [ ' NegRDMrectif ' ])
rule5 = ctrl . Rule ( PosErr [ ' ZeroPosErr ' ]&
SpeedErr [ ' ZeroSpeedErr ' ] , RDMrectif [ ' ZeroRDMrectif ' ])
rule6 = ctrl . Rule ( PosErr [ ' ZeroPosErr ' ]&
SpeedErr [ ' PosSpeedErr ' ], RDMrectif [ ' PosRDMrectif ' ])
rule7 = ctrl . Rule ( PosErr [ ' PosPosErr ' ]&
SpeedErr [ ' NegSpeedErr ' ], RDMrectif [ ' ZeroRDMrectif ' ])
rule8 = ctrl . Rule ( PosErr [ ' posPosErr ' ]&
SpeedErr [ ' ZeroSpeedErr ' ], RDMrectif [ ' PosRDMrectif ' ])
rule9 =
ctrl . Rule ( PosErr [ ' PosPosErr ' ]&SpeedErr [ ' PosSpeedErr ' ], RDMrectif [ ' bigPosRD
Mrectif ' ])

perf_ctrl= ctrl . ControlSystem ([ rule1 , rule2 , rule3 , rule4 , rule5 , rule6 , rule7 , r
ule8 , rule9 ])
perf= ctrl . ControlSystemSimulation (perf_ctrl )

pos =int (myLSS4 . getPosition (»

pwm_pulse= O
possomme= O
prec_pwm= O
 120

if( Setpoint - int (myLSS4 . getPosition (»<=O) :

SetSpeed=- 30

if( Setpoint - int (myLSS4 . getPosition (»>O) :

SetSpeed= 30

while( Setpoint - pos<- 20 or Setpoint - pos >20 ):

if( Setpoint - int (myLSS4 . getPosition (»<=O) :
SetSpeed=- lO

if( Setpoint - int (myLSS4 . getPosition (»>O) :

SetSpeed= lO

perf . input [ ' SpeedErr ' ]=( SetSpeed- int (myLSS4 . getSpeed () »

perf . input [ ' PosErr ' ]=( Setpoint - int (myLSS4 . getPosition ( »)

print ( "vi tes se " , int (myLSS4 . getSpeed () ) )

if( abs (Setpoint -

int (myLSS4 . getPosition (»)<=test2 (abs (int (myLSS4 . getSpeed (»»):
myLSS4 . moveRDM (O)
myLSS4 . hold ()
print ( " out ifl " , int (myLSS4 . getPosition (», " i
" , test2 (int (myLSS4 . getSpeed (»»
break

perf . compute ()

print ( "pos2= " , int (myLSS4 . getPosi tion () ) )

if( abs (Setpoint -
int (myLSS4 . getPosition (»)<=test2 (abs (int (myLSS4 . getSpeed (»»):
myLSS4 . moveRDM ( O)
myLSS4 . hold ()
print ( " out if2 " , int (myLSS4 . getPosition (» , " i
" , test2 ( int (myLSS4 . getSpeed () ) ) )
break

pwm_ pulse=pwm_pulse +int (perf . output [ ' RDMrectif ' ])

print ( " pwml= " , pwm_pulse )
print ( " speed= " , int (myLSS4 . getSpeed (»)
if pwm_pulse> 500 :
myLSS4 . moveRDM (500 )
pwm_pulse= 500

elif pwm_pulse<- 500 :

myLSS4 . moveRDM (- 500 )
pwm_pulse=- 500

myLSS4 . moveRDM (int (pwm_pulse »

 121

print ( " pwm2= " ,pwm_pulse)

print ( "pos3= " , int (myLSS4. getPosi tion () ) )

if( abs (Setpoint-
int (myLSS4.getPosition(»)<=test2( abs (int (myLSS4.getSpe ed(»»):
myLSS4.moveRDM( Q)
myLSS4 . hold ()
print ( "out if3 " , int (myLSS4 .getPosition (» , i Il

" ,test2( int (myLSS4.getSpeed(»»

break

possomme= possomme +abs (pos- int (myLSS4.getPosition(»)

pos =int (myLSS4.getPosition(»

myLSS4 . hold ()

lss . closeBus ()
return (pos)