universite djillali liabes de sidi bel abbes faculte de

République Algérienne Démocratique et Populaire

Ministère de L’Enseignement Supérieur et de la Recherche

UNIVERSITE DJILLALI LIABES DE SIDI BEL ABBES

FACULTE DE TECHNOLOGIE

DEPARTEMENT DE GENIE MECANIQUE

Laboratoire Mécanique des Structures et des Solides

Mémoire

Présente En Vue De L’obtention Du Diplôme De

Magister En Mécanique

Option : Robotique

Thème :

Analyse des paramètres d’optimisation de la

structure fonctionnelle et leurs effets sur la

performance des robots

Présenté Par :

Bousmaha Omar

Encadreur :

Dr. LOUSDAD abdelkader

Jury : Mr .MEGUENI Abdelkader PROF Université de sidi bel abbès Président

Mr .LOUSDAD Abdelkader MCA Université de sidi bel abbès Encadreur

Mr .REFASSI Kadour PROF Université de sidi bel abbès Examinateur

Mr .ELAJRAMI Mohamed MCA Université de sidi bel abbès Examinateur

Année Universitaire 2013/2014

Remerciements

Ce travail a été effectué au laboratoire Mécanique des structures et des solides de

l’Université Djilali Liabes de Sidi Bel Abbes.

Tout d’abord, j’aimerai remercier Monsieur LOUSDAD Abdelkader Maitre de

conférence à l’Université Djilali Liabes de Sidi Bel Abbes, de m’avoir donné l’occasion de

réaliser ce travail, de m’avoir soutenu et conseillé tout au long de ce travail, grâce à son

support et sa rigueur scientifique.

Ensuite, je tiens à remercier les membres du jury, Monsieur MEGUENI Abdelkader

Professeur à l’Université Djilali liabes de Sidi Bel Abbes pour l’honneur qu’il m’a fait en

acceptant de présider le jury.

J’adresse mes remerciements les plus sincères à Messieurs REFASSI Kaddour,

Professeur à l’Université Djilali Liabes de Sidi Bel Abbes, Mr ELAJRAMI Mohamed Maître

de conférence à l’Université Djilali Liabes de Sidi Bel Abbes et Mr AZZEDINE Abdelwahab

pour leur contribution d’accepter de faire partie de mon jury.

Mes remerciements à Messieurs les enseignants de l’université Djilali liabes de Sidi Bel

Abbes qui, durant mes études, ont contribué à enrichir mes connaissances dans de nombreux

domaines, à tous ceux qui m’ont aidé, de près ou de loin, à la réalisation de ce mémoire.

A mon ami Kadem Mohamed pour son support informatique.

DEDICACE

A mes parents,

A mes frères et ma sœur,

A mes très chers amis.

Table des matières

Introduction générale ...................................................................................... 1

CHAPITRE I :

Considérations générales sur la robotique

I.1. Introduction .......................................................................................................................... 4

I.1.1. Définition ...................................................................................................................... 4

I.2. Historique des robots manipulateurs industriels .................................................................. 4

I.3. Vocabulaire d’un robot ........................................................................................................ 6

I.3.1. Base ............................................................................................................................... 6

I.3.2. Porteur ........................................................................................................................... 6

I.3.3. Actionneur de l’effecteur .............................................................................................. 8

I.3.4. L’organe terminal .......................................................................................................... 8

I.4. Types des chaines cinématiques .......................................................................................... 8

I.5. Morphologie des robots manipulateurs ................................................................................ 9

I.6. Classification des robots manipulateurs............................................................................. 12

I.6.1. Classification fonctionnelle ........................................................................................ 12

*Classe A : manipulateurs à commande manuelle ou télécommande ............................ 13

*Classe B : manipulateurs automatiques : ........................................................................ 13

*Classe C : robots programmables ................................................................................... 14

*Classe D : robots ”intelligents” ...................................................................................... 15

I.6.2. Classification géométrique .......................................................................................... 15

I.6.2.1. Robots sériels ....................................................................................................... 15

I.6.2.2. Robots parallèles .................................................................................................. 18

I.7. Domaines d'application des robots industriels ................................................................... 19

I.8. Conclusion ......................................................................................................................... 21

CHAPITRE II :

Les différentes modèles et caractéristiques des robots

II.1. Introduction ...................................................................................................................... 23

II.2. Modélisation géométrique : .............................................................................................. 23

II.2.1. Méthode de Denavit-Hartenberg : ............................................................................. 24

II.2.2. Modèle géométrique direct ....................................................................................... 26

II.2.3. Modèle géométrique inverse .................................................................................... 27

II.2.3.1. Principe de la méthode de Paul ........................................................................... 28

II.3. Modélisation cinématique................................................................................................. 29

II.3.1. Modèle cinématique direct ........................................................................................ 29

II.3.2. Modèle cinématique inverse ...................................................................................... 30

II.3. Modélisation dynamique ................................................................................................. 31

II.3.1. Modèle dynamique direct ......................................................................................... 31

II.3.2. Modèle dynamique inverse ........................................................................................ 31

II.4. Caractéristiques techniques des robots manipulateurs : ................................................... 32

II.4.1. Espace de travail ........................................................................................................ 32

II.4.2. Capacité de charge ..................................................................................................... 33

II.4.3. Performance en vitesse .............................................................................................. 33

II.4.4. Précision, répétabilité ................................................................................................ 34

II.5. Mode de programmation des robots industriels ............................................................... 35

II.5.1. Programmation par enseignement (en ligne) ............................................................. 35

II.5.2. Programmation hors ligne ......................................................................................... 36

II.5.3. Langages de programmation ..................................................................................... 37

II.5.3.1. Niveau actionneur .............................................................................................. 37

II.5.3.2. Niveau manipulation ou niveau effecteur .......................................................... 37

II.5.3.3. Niveau objet ........................................................................................................ 37

II.5.3.4. Niveau objectif .................................................................................................. 37

II.5.4. Avantages de programmation hors ligne ................................................................... 38

II.5.4.1. Disponibilité de la cellule de production ........................................................... 38

II.5.4.2. Amélioration de la qualité .................................................................................. 38

II.5.4.3. Minimisation de l’effort de programmation en termes de préparation des

données ............................................................................................................................. 38

II.5.4.4. Optimisation des tâches ...................................................................................... 39

II.6. Précision absolu de pose ................................................................................................... 39

II.7. Source de manque de précision des robots industriels ..................................................... 41

II.7.1. Facteurs articulaires .................................................................................................. 41

II.7.2. Facteurs géométriques .............................................................................................. 41

II.7.3. Facteurs non géométriques ........................................................................................ 42

II.8. Conclusion : ...................................................................................................................... 42

CHAPITRE III :

Etude Analytique , Programmation et Simulation

III.1. Introduction ..................................................................................................................... 44

III.2. Introduction aux mécanismes .......................................................................................... 44

III.2.1. Définition ................................................................................................................. 44

III.2.2. Synthèse des mécanismes ......................................................................................... 44

III.2.2.1. Différents types de problèmes de synthèse dimensionnelle .............................. 45

III.3. Choix des mécanismes a leviers ...................................................................................... 46

III.4. Erreur des mécanismes .................................................................................................... 46

III.5. But de problème .............................................................................................................. 47

III.6. Approche du problème .................................................................................................... 47

III.6.1. Cas d’une chaine cinématique ouverte .................................................................... 48

III.6.1.1. Enonce de problème .......................................................................................... 48

III.7. Présentation des logiciels de simulation de problème ..................................................... 52

III.7.1. Aperçu sur langage C Scharp .................................................................................. 53

III.7.1.1. Introduction ....................................................................................................... 53

III.7.1.2. Les types C Scharp ............................................................................................ 53

III.7.1.3. Les boucles ........................................................................................................ 53

III.7.1.4. Les classes en C Scharp..................................................................................... 54

III.7.1.5. Avantages de C Scharp ..................................................................................... 54

III.7.2. Présentation de logiciel Visual studio ...................................................................... 54

III.7.2.1. Platforme.NET .................................................................................................. 55

III.7.2.2. CLS (Common Language System) ................................................................... 55

III.7.2.3. La notion de classe ........................................................................................... 56

III.7.2.4. Les classes de base ........................................................................................... 56

III.7.2.5. Les services du CLR ............................................................................................. 56

III.7.3. Aperçus sur logiciel MATLAB ............................................................................... 57

III.7.4. Définition et explication des fichiers dll ................................................................. 57

III.7.5. Matlab builder.ne .................................................................................................... 57

III.7.6. MATLAB compiler ................................................................................................. 58

III.7.7. MATLAB Compiler Runtime ................................................................................. 58

III.8. Conclusion ....................................................................................................................... 58

CHAPITRE IV :

Simulation et Résultats

IV.1.Introduction ...................................................................................................................... 60

IV.2.Description de problème ................................................................................................. 60

IV.3.Etapes de simulation de problème ................................................................................... 60

IV.3.1.Lancement de logiciel VISUAL STUDIO 2010 ...................................................... 60

IV.3.2.Création d’un nouveau projet ................................................................................... 61

IV.3.3.Conception de l’interface graphique de notre projet ................................................. 62

IV.3.4.Programmation C Scharp ........................................................................................ 64

IV.3.5.Matlab ....................................................................................................................... 64

IV.3.6.Programmation de la présentation graphique par MATLAB .................................... 65

IV.3.7.Exécuter l’application dehors de l'environnement MATLAB .................................. 66

IV.3.8.Génération de dll ....................................................................................................... 66

IV.3.9.Exécution de dll de Matlab au C Scharp ................................................................... 67

IV.3.10. DLL MATLAB transféré et exécuté au Visual Studio .......................................... 67

IV.3.11.Interface graphique exécutable ............................................................................... 68

IV.4. Résultats .......................................................................................................................... 70

IV.5.Comparaison et discussions ............................................................................................. 78

IV.6.Conclusion ....................................................................................................................... 81

Conclusion générale ................................................................................................................. 83

Référence

Annexes

Liste des figures

CHAPITRE I :


Figure. I. 1: Vocabulaire d’un robot .......................................................................................... 6 Figure. I. 2: Représentation d’une articulation rotoïde. ............................................................. 7

Figure. I. 3: Représentation d’une articulation prismatique ....................................................... 7 Figure. I. 4:Types des chaines .................................................................................................... 9 Figure. I. 5: Morphologie de porteurs ...................................................................................... 10

Figure. I. 6: Types de poignets ................................................................................................. 11 Figure. I. 7: Robot à poignet Staubli RX-90[4] ........................................................................ 12 Figure. I. 8: Manipulateur à commande manuelle ................................................................... 13 Figure. I. 9: Manipulateur automatique .................................................................................... 13

Figure. I .10: Robot programmable .......................................................................................... 14 Figure. I. 11:Robot sériel a)- ABB IRB 2400 b)- KUKA KR 30 jet ....................................... 16

Figure. I. 12:structure PPP ....................................................................................................... 17 Figure. I. 13: Structure RPP ..................................................................................................... 17 Figure. I. 14: Structure RRP ..................................................................................................... 18

Figure. I. 15: structure SCARA ................................................................................................ 18

Figure. I. 16: Robot Delta(a) ABB IRB 340 (3ddl) (b) Fanuc M-3iA ..................................... 19 Figure. I. 17: Robot de palettisation ......................................................................................... 19

CHAPITRE II :


Figure. II. 1:Modélisation géométrique .................................................................................... 23 Figure. II. 2: Robot à structure ouverte simple......................................................................... 24 Figure. II. 3: Paramètre géométrique dans le cas structure ouverte simple ............................. 25 Figure. II. 4: paramètre de robot............................................................................................... 27 Figure. II. 5: Modèle cinématique directe ................................................................................ 29

Figure. II. 6: Modèle cinématique inverse ............................................................................... 30 Figure. II. 7: espace de travail robot IRB 2400/16 ................................................................... 33 Figure. II. 8 : précision et répétabilité ..................................................................................... 34 Figure. II. 9: Méthodologie de programmation hors ligne des robots par CAO ...................... 36

Figure. II. 10: Illustration 2D (a) d’une mauvaise et (b) une bonne valeur de précision de

position .................................................................................................................................... 39 Figure. II. 11: Source de manque de précision des robots industriels. ..................................... 41

CHAPITRE III :

Etude Analytique, Programmation et Simulation

Figure. III. 1:Génération de fonction ....................................................................................... 45

Figure. III. 2:Génération de trajectoire ..................................................................................... 45 Figure. III. 3:Génération de mouvement .................................................................................. 46

Figure. III. 4: trajectoire de mécanisme de robot ..................................................................... 48 Figure. III. 5 : Framework .NET .............................................................................................. 55

CHAPITRE IV :


Figure. IV. 1: Visual Studio 2010 ............................................................................................ 61 Figure. IV. 2:Visual C# ........................................................................................................... 62

Figure. IV. 3 : Conception de l’interface graphique................................................................. 63 Figure. IV. 4 : Interface de sélection du type de projet Visual C# ........................................... 64

Figure. IV. 5: MATLAB 2013 ................................................................................................. 65

Figure. IV. 6: Programmation par MATLAB .......................................................................... 65 Figure. IV. 7: MATLAB compiler ........................................................................................... 66

Figure. IV. 8: Création de dll ................................................................................................... 85 Figure. IV. 9:Transfère du dll au Visual C# ............................................................................. 67 Figure. IV. 10: Génération du dll au Visual C#. ...................................................................... 67

Figure. IV. 11: MATLAB Interop.dll au Visual Studio ........................................................... 68 Figure. IV. 12: Interface graphique .......................................................................................... 69

Figure. IV. 13: Interface graphique avec schéma détaillé ........................................................ 70 Figure. IV. 14 Interface graphique et résultat d’erreur de cas n°1 .......................................... 71

Figure. IV. 15: Interface graphique et résultat d’erreur de cas n°2 .......................................... 73 Figure. IV. 16: Interface graphique et résultat d’erreur de cas n°3 .......................................... 74 Figure. IV. 17: Interface graphique et résultat d’erreur de cas n°4 .......................................... 76

Figure. IV. 18: Interface graphique et résultat d’erreur de cas n°5 .......................................... 77

Figure. IV. 19:Trajectoire circulaire de mécanisme optimale………………………………...80

Figure. IV. 20: Représentation graphique de mécanisme optimale pour le robot plan à deux

degré de liberté ......................................................................................................................... 80

Liste des tableaux :

CHAPITRE II :


Tableau. II. 1:Précision demandé pour chaque processus ........................................................ 49 Tableau. IV. 1: Les valeurs pour lancer simulation (R=0.75) .................................................. 92 Tableau. IV. 2: Résultats pour la longueur de deuxième bras 0.75m ...................................... 93 Tableau. IV. 3: Les valeurs pour lancer simulation (R=0.85) .................................................. 93

Tableau. IV. 4: Résultats pour la longueur de deuxième bras 0.85m ...................................... 94 Tableau. IV. 5: Les valeurs pour lancer simulation (R=0.95) .................................................. 95

Tableau. IV. 6: Résultats pour la longueur de deuxième bras 0.95m ...................................... 96 Tableau. IV. 7: Les valeurs pour lancer simulation (R=1.05) .................................................. 96 Tableau IV. 8: Résultats pour la longueur de deuxième bras 1.05m ....................................... 97 Tableau. IV. 9: Les valeurs pour lancer simulation (R=1.15) .................................................. 98

Tableau. IV. 10: Résultats pour la longueur de deuxième bras 1.15m .................................... 99 Tableau. IV. 11: Comparaison des résultats ........................................................................... 100

CHAPITRE IV :


Tableau. II. 1:Précision demandé pour chaque processus ........................................................ 49 Tableau. IV. 1: Les valeurs pour lancer simulation (R=0.75) .................................................. 92

Tableau. IV. 2: Résultats pour la longueur de deuxième bras 0.75m ...................................... 93 Tableau. IV. 3: Les valeurs pour lancer simulation (R=0.85) .................................................. 93 Tableau. IV. 4: Résultats pour la longueur de deuxième bras 0.85m ...................................... 94 Tableau. IV. 5: Les valeurs pour lancer simulation (R=0.95) .................................................. 95

Tableau. IV. 6: Résultats pour la longueur de deuxième bras 0.95m ...................................... 96 Tableau. IV. 7: Les valeurs pour lancer simulation (R=1.05) .................................................. 96 Tableau IV. 8: Résultats pour la longueur de deuxième bras 1.05m ....................................... 97

Tableau. IV. 9: Les valeurs pour lancer simulation (R=1.15) .................................................. 98 Tableau. IV. 10: Résultats pour la longueur de deuxième bras 1.15m .................................... 99 Tableau. IV. 11: Comparaison des résultats ........................................................................... 100

Introduction Générale

INTRODUCTION GENERALE

Depuis la révolution industrielle, une discipline à marqué l’évolution du monde

technologique : la Robotique. L’avènement des robots dans l’industrie à permis de soulager l’homme

des travaux répétitifs et difficiles tels que : le déplacement d’objets lourds, les taches d’assemblages,

les microsoudures… etc. Ceci avec plus d’efficacité et de précision.

La compétition incessante dans l'industrie conduit à une nécessaire augmentation de la

productivité en préservant la qualité et en diminuant le coût de revient des produits. Cependant, les

robots manipulateurs existants souffrent encore de faiblesses qui les empêchent de mener à bien

certaines tâches et limitent leurs champs d’action.

Bien que la conception et à la réalisation des robots se font avec attention, les paramètres

géométriques nominaux fournis par les constructeurs sont entachés d’erreurs. Ces erreurs peuvent

en particulier être attribuées à des défauts d’usinage ou d’assemblage, au transport ou à l’usure tout

au long de la durée de vie du robot.

Notre domaine de recherche est consacré à la conception optimale de la structure

fonctionnelle des robots industriels.

L’étude traite les paramètres de conception et leurs effets sur la performance des robots industriels.

Pour atteindre cet objectif, nous présentons notre contribution, organisée dans ce présent mémoire

en quatre chapitres :

Le premier chapitre de ce mémoire présente les notions de base de robotique.

L'objet du ce chapitre est d’apportera quelques définitions de base et décrire les constituants

technologiques d'un robot, définir les principaux termes du domaine.

Dans le deuxième chapitre en présente quelques méthodes permettant d'établir les modèles

géométriques et cinématiques pour le cas des robots à structure ouverte simple, ces méthodes sont

basées sur la détermination des paramètres de Denavit-Hartenberg, ainsi que les différentes

caractéristiques des robots manipulateurs et leurs modes de programmations.

Ensuite on présente les sources de manque de précision des robots industriels.

Dans le troisième chapitre on parle sur les mécanismes pour les robots manipulateurs et ces

différents types de problème de synthèses dimensionnelles.

On présente un modèle mathématique pour diminuer les erreurs à une valeur admissible successible

d’assurer le fonctionnement de mécanisme pour un robot manipulateur. Ainsi qu’une représentation

des logiciels (VISUAL STUDIO, MATLAB) et langage de programmation C#, l’interface entre MATLAB

et C# pour la résolution de problème posé.

Dans le dernier chapitre on présente les étapes de simulations numériques. Les résultats obtenus

sont analysés pour l’obtention de la structure optimale du mécanisme avec les erreurs minimales

pour une meilleure précision de robot plan à deux degré de liberté.

CHAPITRE I :


I.1. Introduction :

Dans ce premier chapitre nous commençons par quelques définitions de base et historique des

robots manipulateurs pour facilité la lecture de ce mémoire. Ensuite, nous présentons la

morphologie des robots manipulateurs, ainsi que la classification des robots et on terminera ce

chapitre par la présentation des différents domaines d’application des robots manipulateurs.

I.1.1. Définition :

En général, un robot est un dispositif mécanique articulé capable d’imiter certaines fonctions

humaines telles que la manipulation d’objets ou la locomotion, dans le but de se substituer à

l’homme pour la réalisation de certaines tâches matérielles. Cette réalisation est plus ou moins

autonome selon les facultés de perception de l’environnement dont est doté le robot.

Une définition officielle d’un tel robot vient du ‘Robot Institute of America’ (RIA) : [1]

Un robot est un manipulateur reprogrammable multifonctionnel conçu pour déplacer des matériaux,

pièces, outils ou des dispositifs spécialisés grâce à des mouvements variables programmés pour

l’exécution de tâches variées. L’élément clé dans la définition ci-dessus est la reprogrammation des

robots.

Les différences majeures, principalement en ce qui a attrait à la souplesse, à l’adaptabilité et à

l’autonomie, font du robot une machine plus perfectionnée et plus complexe que le manipulateur

programmable.

Le robot industriel est le robot qui, par sa robustesse et ses caractéristiques techniques, peut être

utilisé dans un processus de fabrication industriel et dans des conditions difficiles et dangereuses

propres à certains milieux industriels. Plusieurs caractéristiques du robot sont attrayantes dans un

environnement industriel. Les avantages souvent cités sont la diminution du coût du travail,

l’augmentation de la précision et de la productivité, la flexibilité accrue par rapport à des machines

spécialisées, et les travaux répétitifs, ennuyeux ou dangereux sont effectués par des robots.

I.2. Historique des robots manipulateurs industriels :

En 1954, George Charles Devol invente le premier robot industriel programmable. Il fonde en

1956 la première entreprise de robot, Unimation, avec l’ingénieur Joseph Engelberger. Leur

robot, appelé Unimate, était capable de manipuler des objets avec des actionneurs

hydrauliques [2].

General Motors a été le premier acheteur et le premier Unimate fut installé dans leur usine au

New Jersey en 1961. Ils ont utilisé ce robot pour manipuler des pièces moulées encore

chaudes et pour le soudage par point.

En 1969, Victor Scheinman de l’Université de Stanford invente un bras articulé sur 6 axes.

Sheinman vende son concept à Unimation plus tard.

Dans les années 70, quelques entreprises ont du flair et se lancent dans le design et la

fabrication de robots industriels. Voici quelques dates importantes de cette époque :

1973 : KUKA, une entreprise allemande, crée le premier robot industriel avec 6 axes

contrôlés électro mécaniquement.

1974 : Sheinman fonde Vicarm Inc. Commercialise un robot contrôlé par un ordinateur qui

utilise des capteurs de pression destinés à des applications industrielles.

1977 : Le Motoman L10, un robot 5 axes capable de soulever une charge de 10 kg, est lancé

sur le marché par Yaskawa.

1978 : Unimation propose le PUMA, un robot d’assemblage encore utilisé de nos jours dans

plusieurs laboratoires de recherche.

Les années 80 sont le début d’une croissance accélérée de l’industrie de la robotique avec une

nouvelle entreprise ou un nouveau robot qui voient le jour chaque mois.

1981 : Takeo Kanade construit le premier robot muni de moteurs installés directement aux

articulations du bras. Cela a permis des robots plus rapides et plus précis qu’auparavant.

1987 : Asea de Suède et Brown Boveri Ltd de Suisse fusionnent pour former ABB, un des

plus importants fabricants de robots industriels.

Les années subséquentes ont vu des améliorations de tout genre et des robots de plus en plus rapides,

précis et flexibles. En 1998, par exemple, les systèmes de contrôle pouvaient gérer jusqu’à 27 axes et

synchroniser le contrôle de 4 robots.

I.3. Vocabulaire d’un robot :

Figure. I. 1: Vocabulaire d’un robot [3]

I.3.1.Base :

La base du manipulateur est fixée sur le lieu du travail. Ceci est le cas de la quasi-totalité des robots

industriels.

I.3.2. Porteur :

Le porteur représente l’essentiel du système mécanique articulé, il à pour rôle d’amener l’organe

terminal dans une situation donnée imposée par la tache (la situation d’un corps peut être définie

comme la position et l’orientation d’un repère attaché à ce corps par rapport à un repère de

référence). Il est constitué de :

- Segment : corps solides rigides susceptibles d’être en mouvement par rapport à la base du porteur,

et les uns par rapport aux autres,

- Articulation : Une articulation lie deux corps successifs en limitant le nombre de degré de

liberté, de l'un par rapport à l'autre. Soit m le nombre de degré de liberté résultant, encore

appelé mobilité de l'articulation. La mobilité d’une articulation est telle que :

0≤m≤6 (I-1)

Lorsque m = 1, ce qui est fréquemment le cas en robotique, l'articulation est dite simple : soit

rotoïde, soit prismatique.

*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 commun. La situation relative entre les deux corps est donnée par l'angle

autour de cet axe (voir la figure I.2)

Figure. I. 2: Représentation d’une articulation rotoïde.

* Articulation prismatique :

Il s'agit d'une articulation de type glissière, 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 (voir la figure I.3).

Figure. I. 3: Représentation d’une articulation prismatique

I.3.3. Actionneur de l’effecteur :

L’actionnement de l’effecteur peut être :

- électrique

- pneumatique

- hydraulique

- mécanique (dispositif à câbles et poulies)

L’actionnement pneumatique se fait généralement à l’aide d’un vérin pneumatique, réalisant un

mouvement de translation. Il a l’avantage de la simplicité, et d’une certaine élasticité due à la

compressibilité de l’air ; en outre, le contrôle des pressions permet éventuellement un réglage de la

force de serrage.

L’actionnement électrique se fait à l’aide de petits moteurs à courant continu ou pas-a pas; le

contrôle du courant ou l’utilisation de capteurs de force permet un réglage des forces de serrage.

L’actionnement hydraulique est très rare, à cause des inconvénients lies à ce type d’énergie

(nécessité d’une centrale hydraulique, fuites,...).

I.3.4. L’organe terminal :

On regroupe tout dispositif destiné à 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 utilisera 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 [3]

I.4. Types des chaines cinématiques :

On distingue trois types de chaînes:

-Chaînes ouvertes simples(A) (aucun retour mécanique d’un segment à un autre dans la chaîne).

-Chaînes arborescentes(B) (il existe plusieurs organes terminales qui agissent en parallèle)

-Chaînes fermées(C) (il existe un retour mécanique d’un ou plusieurs segments à un autre dans la

chaîne).

Figure. I. 4:Types des chaines

I.5. Morphologie des robots manipulateurs :

Ce paragraphe est relatif aux chaînes ouvertes simples. Afin de dénombrer les différentes

architectures possibles, on ne considère que 2 paramètres : le type d’articulation (rotoïde (R) ou

prismatique (P)) et l’angle que font deux axes articulaires successifs (0° ou 90° ; sauf cas très

particulier, les axes consécutifs d’un robot sont soit parallèles, soit perpendiculaires).

On convient d'appeler les 3 premiers degrés de liberté. Le porteur du robot. Les degrés de liberté

résiduels forment le poignet, caractérisé par des dimensions beaucoup plus petites et une plus faible

masse.

Sont schématisées dans la figure(I.5) qui suit les 12 morphologies possibles de porteur (ces

morphologies sont non redondantes (on élimine a priori les structures limitant les mouvements du

porteur à des déplacements linéaires ou planaires : 3 liaisons prismatiques d'axes parallèles, par

exemple, ou 3 liaisons rotoïdes d'axes parallèles)).

Figure. I. 5: Morphologie de porteurs

Dans la pratique, on trouve les 5 structures suivantes :

-Les porteurs anthropomorphes (RRR), et plus précisément la première structure de cette classe(

figure précédente), comme par exemple les robots :

FANUC (LR, ARC), STÄUBLI RX, ACMA (V80 et SR400), UNIMATION (PUMA), SCEMI (6P-01), AID (V5),

CINCINNATI (T3-7XX), AKR 3000, ASEA (IRB6 et 60), KUKA (IR600), AXEA (V08) ;

- Les porteurs sphériques (RRP) comme par exemple les robots :

STANFORD, UNIMATION (1000, 2000, 4000), PSA (BARNABE) ;

- Les porteurs toriques (RPR) et plus précisément la première structure de cette classe, comme par

exemple les robots :

ACMA (H80), les robots de type SCARA (IBM, AXERA, ADEPT,…);

- Les porteurs cylindriques (RPP) comme par exemple les robots :

ACMA (TH8), MANTEC (A, I et M), CINCINNATI (T3-363) ;

- Les porteurs cartésiens (PPP) comme par exemple les robots :

ACMA (P80), IBM (7565), SORMEL (CADRATIC), OLIVETTI (SIGMA).

La structure RRR dont les 3 axes sont concourants forme ainsi une rotule et s'utilise plus

généralement comme un poignet. D'autres types de poignets de un à trois axes sont représentés sur

la figure(I.6) suivante :

Figure. I. 6: Types de poignets

Dans la pratique, le poignet de type rotule est très répandu. Le robot, obtenu en lui associant un

porteur à 3 d.d.l. est la structure la plus classique à 6 d.d.l. Elle permet d'assurer un découplage entre

la position et l'orientation de l'organe terminal :

- Le porteur a pour rôle de fixer la position du point d'intersection, noté P, des axes des 3 dernières

articulations (centre du poignet) ; cette position (P) ne dépend que de la configuration des solides

(corps) 1, 2 et 3 (i.e., du porteur),

- Le poignet est destiné à l'orientation de l'organe terminal (pince, outil).

Voire la Figure(I.7) :

Figure. I. 7: Robot à poignet Staubli RX-90[4]

Cette structure de robot à poignet de type rotule correspond à celle des robots Stäubli RX-90 et

FANUC ARC. [4]

I.6. Classification des robots manipulateurs :

I.6.1. Classification fonctionnelle :

Le nombre de classe et les distinctions entre celles-ci varient de pays à pays (6 classes au Japon, 4 en

France). L’A.F.R.I. distingue 4 classes illustrées ci-dessous :

*Classe A : manipulateurs à commande manuelle ou télécommande (Fig. I.8) :

Figure. I. 8: Manipulateur à commande manuelle

*Classe B : manipulateurs automatiques :

Les manipulateurs 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) ; on peut distinguer entre

manipulateurs à cycle fixe et manipulateurs à cycle programmable.

Figure. I. 9: Manipulateur automatique

*Classe C : robots programmables :

C’est la première génération de robots industriels ; ils répètent les mouvements qu’on leur a appris

ou programmés, sans informations sur l’environnement ou la tâche effectuée. On peut aussi faire la

distinction entre robots ”play-back” qui reproduisent la tâche apprise et robots à commande

numérique qui peuvent être programmés hors-ligne. Pour de nombreux robots, l’apprentissage de la

tâche se fait à l’aide d’un ”syntaxeur” (”boite à boutons”, ”teach pendant”) qui permet à un

opérateur d’amener le robot en un certain nombre de points, qui sont ensuite mémorisés ; lors de

l’exécution de la tâche, le robot suivra une trajectoire passant successivement par tous les points

programmés, le passage d’un point au suivant se faisant suivant un profil de vitesse en fonction du

temps qui est pré-dé fini (tri angulaire ou trapézoïdal), l’opérateur n’aya nt qu’à choisir la fraction de

la vitesse maximum à laquelle il souhaite que le robot effectue la tâche. Pour certains robots, par

exemple les robots de peinture, qui doivent suivre une trajectoire complexe qu’il est difficile

d’exprimer mathématiquement, un opérateur humain spécialiste de la tâche effectue la trajectoire

en guidant le bras du robot à l’aide d’un ”pantin”, et l’entièreté de la trajectoire est mémorisée par le

robot [5].

Figure. I .10: Robot programmable

*Classe D : robots ”intelligents” :

On trouve actuellement des robots de seconde génération qui sont capables d’acquérir et d’utiliser

certaines informations sur leurs environnements (systèmes de vision, détecteurs de proximité,

capteurs d’efforts, ...). On étudie 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.

En Europe et aux U.S.A., seuls les éléments des classes C et D sont appelés ”robots”, les américains

appellent aussi manipulateurs ou robots ”pick and place” certains manipulateurs de classe B.

I.6.2. Classification géométrique :

Un robot industriel est constitué d’une ou plusieurs chaînes cinématiques, composées d’une multitude

de liens rigides, reliés par des articulations rotatives (rotoïdes) ou linéaires (prismatique). Selon la

structure des chaînes cinématiques, ces mécanismes sont classés en deux principales catégories : les

robots sériels et les robots parallèles.

I.6.2.1. Robots sériel :

Ces robots sont composés de plusieurs liens montés en séries, entre une base et un élément terminal

(Figure I.11), formant ainsi une chaîne cinématique ouverte. Le mouvement de chacun de ces liens est

effectué au niveau d’une articulation par un servomoteur, via un système de réduction de vitesse (boîte

d’engrenages). Les mouvements sont asservis grâce à des signaux de rétroaction provenant

d’encodeurs. La similarité morphologique entre la structure des robots sériels et celle du bras humain,

offre plus de versatilité à ces manipulateurs. Cependant, leur structure sérielle fait en sorte que chacun

des lasser de servomoteurs supporte les liens subséquents, ce qui explique le fait que les actionneurs

sont de plus en plus gros, en allant de l’effecteur vers la base du robot. Ce phénomène d’accumulation

de la charge cause une amplification non-souhaitable des erreurs, en allant de la base vers l’effecteur.

Figure. I. 11:Robot sériel a)- ABB IRB 2400 b)- KUKA KR 30 jet

.

I.6.2 .1.1. Architectures les plus courantes de robot série :

Les seuls liaisons utilisé en robotique sont la liaison rotoïde et la liaison prismatique, réduisent le

mouvement entre deux corps respectivement à une rotation autour et à une translation le long d’un

axe commun. Parmi tout les combinaisons d’empilement de rotation et translation possibles .seules

quelques-unes sont émergé pour les applications industrielles ont peut les classer de la façon

suivante :

-Structure cartésienne PPP (Fig. I.12) :

La structure cartésienne PPP à trois liaisons prismatiques, et la plus ancienne : historiquement, elle

découle logiquement de la conception traditionnelle d’une machine outils à trois axes, type

rectifieuse ou fraiseuse par exemple cette structure et relativement peut utiliser, sauf dans quelques

applications particulières, robot portique robot de magasinage par exemple ;

Figure. I. 12:structure PPP

-Structure cylindrique RPP ou PRP (Fig. I.13) :

La structure cylindrique RPP ou PRP associe une rotation et deux translations .Elle présente

l’inconvénient d’offrir un volume de travail faible devant un encombrement total important elle n’est

pratiquement plus utilisée.

Figure. I. 13: Structure RPP

-Structure sphérique RRP (Fig. I.14) :

Deux rotations (longitude et latitude) autour de La structure sphérique RRP d’axes orthogonaux,

complétées par une translation radiale.

Son espace est sphérique et grande charge utile.

Figure. I. 14: Structure RRP

-Robots SCARA (Selective Compliance Articulated Robot for Assembly) RRP (Fig .15):

La structure dite SCARA à axe de rotation parallèle est l’une des plus utilisé, en particulier pour des

taches de manutention ou d’assemblage très fréquente dans l’industrie.

Figure. I. 15: structure SCARA

I.6.2.2. Robot parallèle :

Ces robots sont composés de plusieurs chaînes cinématiques indépendantes (jambes ou segments)

montées en parallèle. Celles-ci lient la base du manipulateur à son organe terminal, formant par

conséquent une chaine cinématique fermée. Cette structure fermée permet une meilleure répartition

des charges du robot sur ses différentes composantes et lui donne plus de rigidité, tout en restreignant

son espace de travail. En outre, la morphologie de cette catégorie de robots offre une excellente

répétabilité et éventuellement, une meilleure précision.

Figure. I. 16: Robot Delta(a) ABB IRB 340 (3ddl) (b) Fanuc M-3iA

I.7. Domaines d'application des robots industriels :

Les robots industriels peuvent être très utiles dans plusieurs domaines. Ils sont rapides, très fiables et

très précis. On les retrouve dans des domaines :

– Soudage

– Peinture

– Assemblage

– Emballage et palettisation

– Industrie alimentaire

– Industrie biologique

-Robots Industriels de Soudage :

Une des applications les plus courantes de la robotique industrielle est le soudage.

Le soudage robotisé des châssis de voiture améliore la sécurité car un robot ne manque jamais son

point de soudure et réalise toujours de la même manière tout au long de la journée. A peu près 25 %

des robots industriels sont impliqués dans différentes opérations de soudure.

-Robots Industriels d’assemblage :

L’assemblage occupe environ 33% des applications du parc des robots industrielles.

Beaucoup de ces robots peuvent être trouvés dans l’industrie automobile et l’industrie électronique

-Robots Industriels d’Emballage / Palettisation :

L’emballage et la palettisation sont toujours des applications mineures des robots industriels, comptant

seulement pour 2,8% du parc.

Les prévisions pour ce type d’applications sont en croissance significative étant donné que les robots

deviennent de plus en plus faciles à manipuler.

Figure. I. 17: Robot de palettisation

-Robots dans les biotechnologies :

Les applications dans l’industrie pharmaceutique et dans les biotechnologies constituent également un

marché d’avenir encore presque vierge.

I.8. Conclusions :

Dans ce chapitre on a présenté des considérations générales sur la robotique

Avec les différents types des robots manipulateurs et leurs applications. Dans le chapitre suivant on

présentera les modèles et les caractéristiques des robots manipulateurs avec les modes de

programmations et les sources de manque de précision des robots industriels.

CHAPITRE II :

Les différents modèles et caractéristiques des robots

II.1. Introduction :

La conception des robots nécessite des calculs de certain modèles géométriques, cinématiques et

dynamiques dont-t-ils feront l’objet de discussion dans ce chapitre. Les différentes caractéristiques des

robots manipulateurs et leurs modes de programmations ainsi que les différentes sources de manque de

précision des robots industriels sont également discutées.

II.2. Modélisation géométrique :

La modélisation des robots de façon systématique exige une méthode adéquate pour la description et

leurs morphologie, plusieurs méthode et notation on été proposé la plus répondue et celle de Denevilt

Haterbeng[6], ou dans les années 50 ils ont eu l’excellente idée de proposer une méthode simple et

systématique pour placer des référentiel pour chaque lien d’un mécanisme sériel qui facilite

énormément le calcule de matrice de transformation homogène. [7]

Figure. II. 18:Modélisation géométrique

II.2.1. Méthode de Denavit-Hartenberg :

Une structure ouverte simple est composée de n+1 corps notés C0,….,Cn. et de n articulations.

Le corps C0 désigne la base du robot et le corps Cn le corps qui porte l'organe terminal. L'articulation I

connecte le corps Ci au corps Ci-1.

Figure. II. 19: Robot à structure ouverte simple

.

La méthode de description est fondée sur les règles et conventions suivantes :

-Les corps sont supposés parfaitement rigides. Ils sont connectés par des articulations considérées

comme idéales (pas de jeu mécanique, pas d'élasticité), soit rotoïdes, soit prismatiques .

-Le repère Fi est liée au corps Ci .

-L'axe Zi-1 est porté par l'axe de l'articulation i .

-L'axe Xi est porté par la perpendiculaire commune aux axes Zi et Zi+1 .Si les axes Zi et Zi+1 sont

parallèles, le choix de Xi n'est pas unique : des considérations de symétrie ou de simplicité

permettent alors un choix rationnel.

Le passage du repère Fi-1 au repère Fi s'exprime en fonction des quatre paramètres

géométriques suivants : figure (II.3)

- i : angle entre les axes Zi-1 et i correspondant a une rotation autour de l’axe Xi

-di : distance entre Xi-1 et Xi le long de l’axe Zi

-θi : angle entre les axes Xi-1 et Xi correspondant une rotation autour de Zi

-ai : distance entre Zi-1 et Zi le long de Xi

Figure. II. 20: Paramètre géométrique dans le cas structure ouverte simple [7]

La variable articulaire qj associée à la ième

articulation est soit θi , soit ri , selon que cette

articulation est de type rotoïde ou prismatique, ce qui se traduit par la relation[6] :

qi= θi+ iri II.1

Avec :

i=0 si l'articulation j est rotoïde

i=1si l'articulation j est prismatique

=1- i II.2

La matrice de transformation définissant le repère Fi dans le repère Fi-1 est donnée par :

=Rot(Z,θi)Rot(0,0,di)Rot(x, i)Rot(ai,0,0) II.3

II.4

II.2.2. Modèle géométrique direct :

Le modèle géométrique direct (MGD) d’un bras manipulateur exprime la situation de son Organe

Terminal (OT) en fonction de sa configuration. Donc il exprime la position instantanée de l’OT par

rapport au repère fixe lie au bâti.

Dans le cas d'une chaîne ouverte simple, il peut être représenté par la matrice de transformation

[6]:

=

q1) (q2)

qn) II.5

Le modèle géométrique direct du robot peut aussi être représenté par la relation :

X=F(q) II.6

q : le vecteur des variables articulaires tel que :

q=[q1,q2…..qn]T II.7

Les cordonnés opérationnelles sont défini par :

X=[X1,X2…..Xm]T II.8

Figure. II. 21: paramètre de robot

II.2.3. Modèle géométrique inverse :

Le modèle géométrique inverse est le problème inverse qui permet de connaître les variables

articulaires en fonction de la situation de l'organe terminal, ce qui peut se représenter par la relation

q =g(x) II.9

A partir d’une position et une orientation donnes de l’outil, trouver les coordonnées articulaires du

robot.

Ce problème est beaucoup plus complexe que celui de problème géométrique directe car pour une

position donnée, la solution n’est pas unique (plusieurs configurations possibles).

-Méthode de Paul qui traite séparément chaque cas particulier et convient pour la plupart des robots

industriels [6].

II.2.3.1. Principe de la méthode de Paul :

Considérons un robot manipulateur dont la matrice de transformation homogène a pour expression :

=

q1) (q2)

qn) II.10

Soit U0 la situation désirée telle que :

II.11

On cherche à résoudre le système d'équations suivant :

U0= q1)

(q2) qn) II.12

Pour trouver les solutions de l'équation (II.13), Paul à proposé une méthode qui consiste à pré

multiplier successivement les deux membres de l’équation (II.12) par les matrices

pour i

variant de 1 à n-1, opérations qui permettant d’isolé et d’ittentifié l’une après l’autre les variables

articulaire qui l’on recherche

q1)U0=

q2)……….. qn) II.13

Le terme de droite est fonction des variables q2……..qn .Le terme de gauche n'est fonction que des

éléments de U0 et de la variable q0

-identification terme à terme des deux membres de l'équation (II.12). On se ramène à un

système d'une ou de deux équations fonction de q1 uniquement, dont la structure appartient à un

type particulier parmi une dizaine de types possibles.

La succession des équations permettant le calcul de tous les qi est la suivantes :

Ui= =

Ui-1 II.14

II.3. Modélisation cinématique :

II.3.1. Modèle cinématique direct :

Le modèle cinématique direct décrit les vitesses des coordonnées opérationnelles en fonction des

vitesses articulaires

Figure. II. 22: Modèle cinématique directe

dX=J(q)d(q) II.15

Où J = J(q) est la matrice jacobienne de la fonction f, de dimension m × n :

J(q)=

II.16

Avec J(q) la jacobienne du mécanisme donnée par [8] :

II.17

II.3.2. Modèle cinématique inverse :

L’objectif du modèle cinématique inverse est de calculer, à partir d’une configuration q donnée, les

vitesses articulaires qui assurent au repère terminal une vitesse optimale X imposée.

Figure. II. 23: Modèle cinématique inverse

II.3. Modélisation dynamique :

II.3.1. Modèle dynamique direct :

Le modèle dynamique est le modèle des efforts, lorsqu’on prend en compte les effets dynamiques.

Le modèle dynamique direct est celui qui exprime les accélérations en fonction des positions,

vitesses et couples des actionneurs. Il est alors représenté par la relation :

=g(q, ,C,F) II.18

- : C’est le vecteur des accélérations articulaires.

- : C’est le vecteur des positions articulaires.

- : C’est le vecteur des vitesses articulaires.

-C: C’est le vecteur colonne des couples/forces des actionneurs, selon que l’articulation est rotoïde

ou prismatique.

-F : c’est l’effort extérieur (forces et couples), a exercer par l’organe terminal.

Le formalisme de Lagrange est mieux adapté pour le calcul du modèle dynamique.

II.3.2. Modèle dynamique inverse :

Les équations qui donne les couples ou force à appliqué par les actionneur en fonction des position

,des vitesses et des accélérations de variables de ces actionneurs et en fonction des efforts extérieurs

appliqué sur les différents éléments des robot .

Le formalisme de Lagrange permet d’établir un système d’équations différentielles reliant les

coordonnées généralisées aux forces et/ou couples généralisés.

Le formalisme de Lagrange décrit les équations des mouvements en termes de travail et d’énergie du

système :

. II.19

L : lagrangien de système égale à E-U

U : énergie cinétique totale de système

E : énergie potentiel totale de système

II.4. Caractéristiques techniques des robots manipulateurs :

II.4.1. Espace de travail :

La position et l’orientation de l’organe terminal du robot sont décrites par un vecteur à six

composantes, le plus souvent trois pour la position d’un point particulier de l’outil et trois pour son

orientation. L’espace de travail d’un robot manipulateur est défini comme l’ensemble des positions et

orientations accessibles par un repère particulier lié, en général, à l’organe terminal du robot.

L’espace de travail est limité par la géométrie du manipulateur ainsi que par des contraintes

mécaniques sur les articulations. Par exemple, une articulation rotoïde peut être limitée à moins de 360

degrés de rotation.

L’espace de travail est souvent décomposé en un espace de travail accessible et un espace de travail

habile. L’espace de travail accessible est l’ensemble des points accessibles par le manipulateur, alors

que l’espace de travail habile se compose des points que le manipulateur peut atteindre avec une

orientation arbitraire de l’organe terminal. Evidemment, l’espace de travail habile est un sous-

ensemble de l’espace de travail accessible.

La forme et la taille de l’espace de travail sont très importantes, le robot peut ne pas la tâche lorsque

quelques points sur la trajectoire sont dans l’espace de travail où l’organe terminal n’arrive pas. Il est

préférable de mettre la trajectoire dans le milieu d’espace de travail habile afin que le robot puisse

exécuter correctement la tâche. La Figure II.5 illustre l’espace de travail pour le robot IRB 2400/16. [9]

Figure. II. 24: Espace de travail robot IRB 2400/16

II.4.2. La capacité de charge :

La capacité de charge est conditionnée par la taille du robot et par la puissance des actionneurs.

Suivant les tâches, les charges que les robots peuvent être amenés à déplacer, sont très variables. Il

peut s’agir de petites pièces mécaniques sur une ligne d’assemblage, d’un pistolet de projection ou

d’une pince à souder ou, à l’inverse, de pièces relativement lourdes en manutention. Pour des raisons

de sécurité, la capacité de charge est à la plus grande vitesse du robot.

Aujourd’hui, les robots industriels les plus puissants supportent des charges de l’ordre de plusieurs

centaines de kilogrammes. Ils sont très utilisés pour la manutention ou pour traiter une grande surface

de soudage. Pour l’application de projection thermique, la plupart des charges sont limitées, de l’ordre

de 10 à 60 kilogrammes fonctions de la nature de la torche utilisée. La capacité du robot IRB

2400/16 est 16 kilogrammes, elle du robot IRB 4400/45 est 45 kilogrammes.

II.4.3. Performance en vitesse :

La capacité d’un robot à déplacer rapidement son effecteur dans l’espace de travail est une

caractéristique importante de son utilisation dans une cellule de production. Comme pour la charge,

les performances en vitesse dépendent de la taille, de la puissance et de la spécificité du robot. Elles

dépendent aussi du fait que tous les axes ne présentent pas nécessairement les mêmes

performances dynamiques .

Normalement, les fabricants offrent la plus grande vitesse de chaque axe et la vitesse maximale de

l’organe terminal. Toutefois, si la vitesse de travail est plus grande le robot prendra plus de distance

pour augmenter ou diminuer la vitesse. Le robot ne peut pas atteindre une très grande vitesse (par

exemple environ 800 mm/s) quand la distance entre deux positions n’est pas suffisamment grande

(< 10 mm) [9].

II.4.4. Précision, répétabilité :

La précision d’un robot manipulateur est une mesure de la distance entre la position réelle du robot et

la position souhaitée dans l’espace de travail. La précision est affectée par des erreurs de calcul, la

précision du système mécanique, les effets de flexibilité et un grand nombre d’autres effets

dynamiques et statiques. C’est essentiellement pour cette raison que les robots sont conçus avec une

grande rigidité, Des processus différents demandent des précisions différentes du robot en industrie

(voir le tableau II.1)

La répétabilité est une capacité du robot manipulateur à retrouver un point appris. La plupart

des manipulateurs d’aujourd’hui sont très répétitifs, mais pas très précis. La répétabilité du robot

dépend en particulier de sa compacité de ses servomoteurs de la masse embarquée, etc. La répétabilité

du robot IRB 2400 est ±0,06mm, et la répétabilité du robot IRB 4400 est ±0,19mm [9].

Figure. II.25 : précision et répétabilité [10]

Tableau. II. 1:Précision demandé pour chaque processus

II.5. Mode de programmation des robots industriels :

La programmation des robots manipulateurs s’effectue selon deux principaux modes, soit la

programmation par enseignement (en ligne) et la programmation hors ligne. Le choix du type de

programmation dépend principalement de l’application à laquelle le robot est destiné.

II.5.1. Programmation par enseignement (en ligne) :

Une des principales raisons qui pourrait expliqué le peu d’intérêt accordé à la précision des robots, par

certaines industries, est l’approche de programmation adoptée. En effet, plusieurs utilisateurs de robots

industriels ne font recours qu’à la méthode de programmation par enseignement. Cette méthode,

appelée communément teach- in , consiste à déplacer l’effecteur du robot sur plusieurs poses et de les

enregistrer au fur et à mesure. Par la suite, cet ensemble de poses devient la trajectoire du mouvement

du robot. Ainsi, les adeptes de cette méthode sont satisfaits des résultats, à condition que le robot ait

une assez bonne répétabilité pour effectuer ces trajectoires sans trop de variations. Bien que ce type

programmation soit facile, et ne requiert que peu de connaissances en robotique, il n’est approprié que

pour les opérations qui n’exigent pas une précision élevée, comme la soudure ou la peinture. Par

ailleurs, cette approche représente un inconvénient majeur : pendant l’enseignement des poses de la

trajectoire, le robot n’est pas disponible pour la production, ce qui occasionne des coûts élevés pour

les entreprises. En outre, l’utilisation des commandes manuelles rend la programmation des

mouvements de haute précision presqu’impossible [11]

II.5.2. Programmation hors ligne :

La figure (II.9) représente une Méthodologie de programmation hors ligne des robots par CAO.

Pour contrer les désavantages de la programmation par enseignement, il existe une alternative appelée

méthode de programmation hors ligne. Celle-ci consiste à programmer le robot et simuler ses

mouvements en utilisant des logiciels de conception assistée par ordinateur (CAO) dédiés. Le robot

n’est pas physiquement utilisé lors de la programmation, ne causant aucun arrêt de production. Cette

méthode bien qu’avantageuse, particulièrement dans la phase de conception des cellules robotisées,

présente un inconvénient non négligeable : les résultats obtenus par simulation sont difficiles à

reproduire sans erreurs en pratique. Ce désavantage est attribué principalement au fait que les modèles

nominaux des robots, utilisés dans la simulation, ne correspondent pas parfaitement à leurs modèles

réels.

Les différences entre les résultats de la simulation et ceux obtenus affectent la précision des robots

[15].

Figure. II. 26: Méthodologie de programmation hors ligne des robots par CAO [12]

II.5.3. Langages de programmation :

Historiquement, les langages de programmation étaient classés en quatre niveaux indiquant

l’abstraction de description de la tâche et, indirectement, caractérisant les capacités de raisonnement et

de décision mises en œuvre (l’intelligence du robot).

II.5.3.1. Niveau actionneur :

On y spécifie les déplacements dans l’espace articulaire : les langages de ce niveau reprennent les

concepts des langages de programmation des machines outils à commande numérique (MOCN).

II.5.3.2. Niveau manipulation ou niveau effecteur :

On y spécifie des déplacements dans l’espace cartésien, plus naturel pour l’utilisateur que l’espace

articulaire. Les langages de ce niveau s’inspirent des langages de programmation traditionnels.

II.5.3.3. Niveau objet :

On y spécifie des actions constituant une séquence complexe de déplacements et d’opérations sur les

objets. Ces actions doivent ensuite être décomposées en instructions de niveau manipulation.

II.5.3.4. Niveau objectif :

Il désigne l’objectif à atteindre. L’objectif est ensuite traduit en actions intermédiaires.

Les deux derniers niveaux sont parfois regroupés en un seul niveau appelé niveau tâche.

Les robots manipulateurs ne sont plus programmés au niveau actionneur. Il est ainsi plus pertinent de

parler de mode de programmation explicite.

On peut distinguer deux catégories de langages, les langages du type primitives de mouvements et

les langages structurés, ces derniers autorisant, dans une certaine mesure, une modélisation des objets

de l’environnement. On donne dans ce qui suit un exemple de langage dans chacune de ces catégories

[12].

-Langage du type primitives de mouvements :( VAL II)

VAL II est un langage créé pour la robotique.

-Langage structuré : (KAREL)

II.5.4. Avantages de programmation hors lignes :

Les avantages d’une programmation hors ligne par CAO-robotique sont nombreux.

II.5.4.1. Disponibilité de la cellule de production :

Globalement, le temps de programmation d’une gamme reste le même si l’on compare un

apprentissage classique et une PHL. Cependant, la PHL se faisant en temps masqué, le temps

d’immobilisation du site est considérablement réduit.

II.5.4.2. Amélioration de la qualité :

Dans une programmation par apprentissage, la qualité dépend de l’expérience de l’opérateur, ce qui

n’est pas le cas avec la CAO qui permet une définition exacte des poses désirées. Avec le procédé de

soudage par points, en carrosserie automobile, par exemple, les défauts d’aspect dépendent

beaucoup de la précision avec laquelle l’axe des électrodes a été aligné avec la normale locale aux

surfaces en chaque point de soudage : seule l’utilisation d’un modèle numérique permet de

programmer correctement l’orientation de la pince.

II.5.4.3. Minimisation de l’effort de programmation en termes de préparation des

données :

Réutilisation de modèles déjà créés lorsqu’il y a différentes variantes d’un produit ; duplication de

tâches lorsqu’une même tâche est affectée à plusieurs robots ou lorsqu’il s’agit de remplacer un

robot en panne ; programmation des tâches dans des zones difficilement accessibles [12].

II.5.4.4. Optimisation des tâches :

Des temps de cycle et de l’accessibilité sans collision de toutes les poses notamment, grâce à des

outils de placement automatique. En ce qui concerne les coûts, le fait de pouvoir commencer la

programmation des robots très tôt dans le projet d’automatisation permet d’anticiper les problèmes

qui apparaissent au moment du démarrage de la production, donc de diminuer les retards qui ont

une incidence sur les coûts. Cependant, le coût global de la PHL par CAO reste difficile à évaluer car il

dépend de nombreux facteurs matériels et humains.

En résumé, pour profiter des avantages de la programmation hors ligne, il est nécessaire que le

robot soit doté d’une bonne précision absolue.

II.6. Précision absolu de pose :

Figure. II. 27: Illustration 2D (a) d’une mauvaise et (b) une bonne valeur de précision

de position [13]

La précision absolue en positionnement correspond à la capacité du robot d’atteindre, avec le

maximum d’exactitude, une pose (position et orientation) commandée. Notons qu’ici nous parlons de

la précision en mode statique (i.e. évaluation de la pose après un arrêt complet du mouvement de

l’effecteur) et indépendamment de la trajectoire prise pour se rendre à la pose désirée [13].

Géométriquement, la précision du robot dans une position donnée peut être définie comme étant la

distance entre la position commandée ( x c , y c , z c ) et le barycentre des positions effectivement

atteintes (x, y, z), après des mouvements répétitifs de l’effecteur à cette position. La figure II.8 illustre

géométriquement la notion de précision absolue [13].

Mathématiquement, selon la norme ISO9283 (ISO, 1998), le calcul de la précision AP à une position

donnée consiste à calculer l’erreur composée selon les coordonnées cartésiennes x, y et z :

AP =√( – xc)2 +( - yc)

2 +( - zc)

2 II.20

Avec , , correspondent au moyennes des valeurs mesurées en x, y et z.

La précision d’orientation pour une pose donnée, se calcule séparément pour chacune des

orientations angulaires :

APa = - ac

APb = - bc II.21

APc = - cc

ac, bc et cc représentent les coordonnées angulaires de la pose commandée.

II.7. Source de manque de précision des robots industriels :

La figure II.8 représente les sources de manque de précision des robots industriels

Figure. II. 28: Source de manque de précision des robots industriels.

II.7.1. Facteurs articulaires :

Ces facteurs de manque de précision correspondent aux erreurs des capteurs des articulations actives

du robot. Elles représentent les différences entre les valeurs fournies par les encodeurs des actionneurs

et les mouvements articulaires réellement effectués.

II.7.2. Facteurs géométriques :

Les facteurs géométriques sont liés à la précision du modèle cinématique du robot, utilisé par son

contrôleur pour calculer les mouvements de l’effecteur. Un modèle qui ne représente pas exactement

la géométrie réelle du robot est une source fondamentale de manque de précision. Les principales

causes d’erreurs géométriques sont :

-les longueurs nominales des liens différentes de la longueur réelle s. Ceci est causé principalement

par les tolérances de fabrication et d’assemblage

-les caractéristiques géométriques des pièces usinées (parallélisme, orthogonalité, planéité.)

- le positionnement des articulations liées à la base et à l’élément terminal du robot;

- les erreurs de localisation du référentiel de la base du robot par rapport à celui de la cellule;

- les erreurs de localisation du référentiel de l’outil sur l’organe terminal.

II.7.3. Facteurs non géométriques :

Les facteurs non géométriques sont attribués à la qualité des composantes mécaniques du robot. Ils

comptent plusieurs éléments dont voici les principaux :

-l’élasticité des composantes mécaniques

-les jeux mécaniques, notamment ceux des engrenages

-Les effets de la température.

II.8. Conclusion :

Pour modéliser un robot à n articulations, il faut chercher toujours le modèle le plus simple qui

permet d'expliquer, de manière satisfaisante le comportement.

- Les modèles géométriques qui expriment la situation de l'organe terminal en fonction de la

configuration du mécanisme.

-Les modèles cinématiques permettent de contrôler la vitesse de déplacement du robot afin de

connaître la durée d'exécution d'une tâche.

On a aussi présenté les différentes caractéristiques des robots manipulateurs et leurs modes de

programmations. Les différents facteurs de manque de précision des robots manipulateurs et leurs

sources ont été identifiés et discutés.

CHAPITRE III :

Etude Analytique, Programmation et Simulation

III.1. Introduction :

Les robots sériels sont de plus en plus utilisés pour des applications telles que l’usinage ou

l’assemblage grâce à leur grand volume de travail par rapport à leur faible investissement.

Ce pendant, des imprécisions de positionnement peuvent apparaître en raison des erreurs

géométriques de fabrication, comme la longueur des bras, un parallélisme imparfait entre les axes ou

des possibles offset dans l’encodeur des moteurs, ainsi que le frottement.

On parle dans ce chapitre sur les mécanismes pour robots industriels et des différents types de

problèmes des synthèses dimensionnelles. On présente un modèle mathématique pour choisir le

mécanisme optimum avec minimum d’erreur structurale à l’aide d’une programmation et logiciels de

simulation et interface graphique par Visual C# et MATLAB.

III.2. Introduction aux mécanismes :

III.2.1. Définition :

Un mécanisme est un ensemble de pièces, déformables ou non, assemblées entre elles par des

liaisons mécaniques. Dans la suite de ce manuscrit, nous considérons que chacune des pièces

constituant un mécanisme est indéformable. La synthèse de mécanismes consiste à trouver un

mécanisme, le meilleur au sens d’un ou de plusieurs critères prédéfinis, pour accomplir une tâche

donnée.

III.2.2. Synthèse des mécanismes :

Les problèmes considérés par la synthèse des mécanismes sont classés en deux catégories. La

première catégorie inclut toutes les considérations concernant la sélection du type du mécanisme

qui convient le plus à la tâche demandée. On parle alors de la synthèse topologique et c’est la

première étape à réaliser par le concepteur. La deuxième catégorie, dite synthèse dimensionnelle, a

pour but de choisir les valeurs de tous les paramètres géométriques et dimensionnels du mécanisme

pour satisfaire le besoin exigé par la tâche.

III.2.2.1. Différents types de problèmes de synthèse dimensionnelle :

En général, les problèmes traités par la synthèse dimensionnelle sont groupés dans trois familles

différentes : génération de trajectoire, génération de fonction et génération de mouvement. Quand

le mouvement du solide n’est pas lié au bâti, on parle soit de générateur de mouvement lorsque tout

le solide participe à la tâche, soit de génération de trajectoire lorsque seule la trajectoire d’un point

du solide a de l’intérêt. Dans les deux cas, le solide considéré est dit traceur. Quand on considère le

mouvement d’un solide lié au bâti, on parle de génération de fonction. Le mécanisme à quatre barres

suivant illustre (figures

III.1 et III.2 et III.3) chaque type de problème [14].

Figure. III. 29:Génération de fonction

Figure. III. 30:Génération de trajectoire

Figure. III. 31:Génération de mouvement

III.3. Choix des mécanismes a leviers : [15]

Dans les industries mécaniques une considération particulière est donné aux mécanismes à leviers

pour la génération des fonctions, des trajectoires ou de satisfaire une loi de mouvement donné.

Les mécanismes a levier a couples inférieurs sont moins couteux, adaptables à de grandes vitesses et

possèdent moins de frottement d’ou leurs utilisation très fréquente dans l’industrie surtout les

mécanismes à quatre leviers et les mécanismes bielle manivelle dits à coulisseau.

III.4. Erreur des mécanismes : [15]

Il existe plusieurs raison pour que le concepteur puisse accomplir la perfection de la conception d’un

système mécanique son montage, sa fabrication et même la formulation des problèmes ajoutent de

l’erreur à la solution. Ces erreurs doivent être analysées minimisées et prises en considération.

L’erreur qui nous concerne dans le domaine de l’étude de la synthèse structurale des mécanismes est

l’erreur structurale.

L’erreur structurale est :

Es=F(x)-f(x,qi) III.1

Où F(x) est la fonction désiré (fonction théorique)

- f(x,qi) étant la fonction réelle obtenue influencée par tout les paramètres de conception et

conditions opératoires qi .

Les erreurs mécaniques sont les déviations statistiques qui apparaissent lors du fonctionnement des

mécanismes et sont relative aux dimensions paramétriques des mécanismes.

L’analyse de l’erreur permet de déterminer les tolérances qui permettant la réalisation [15].

III.5. But de problème :

Les mécanismes à leviers d’un nombre finis d’éléments possèdent une erreur due à leurs

dimensionnements

C’est le rôle de concepteur de diminuer cette erreur à une valeur admissible susceptible d’assuré le

fonctionnement.

Une procédure de conception réussie doit combiner les considérations analytiques prédominantes

de la synthèse structurale avec les considérations pratiques incluant les avantages mécaniques,

performance dynamique et le meilleurs choix de mécanisme optimum

Le problème essentiel réside dans la conception des schémas cinématiques structuraux du

mécanisme de façon à satisfaire une loi de mouvement donnée et susceptible de reproduire une

trajectoire désirée avec un minimum d’erreur structurale ainsi que la satisfaction des contraintes

cinématiques d’espace et de performance dynamique.

Le but essentiel de cette étude est donc de définir les paramètres optimaux du mécanisme et sa

projection de façon à satisfaire les exigences citées.

III.6. Approche du problème :

L’approche élaborée par A.Lousdad [15+ est utilisée par l’optimisation des mécanismes plans a chaine

cinématique ouverte.

III.6.1. Cas d’une chaine cinématique ouverte :

III.6.1.1. Enonce de problème :

La figure III.4 représente le mécanisme de robot et la trajectoire circulaire :

Figure. III. 32: trajectoire de mécanisme de robot

Soit une courbe définie soit par son expression analytique soit par un ensemble de points

appartenant à cette courbe.

Il faut cherché la position de l’articulation immobile A dans le plan XOY A(Xa,Ya), le rayon optimum

R1 et la longueur optimume R de la bielle connaissant cinq positions en fonction des positions des

points Mi appartenant a la courbe à la fonction d’écrite de façon à ce que l’extrémité M décrit de

manière la plus exacte possible la courbe ou la fonction donnée et que les points Bi décrivent un

cercle de centre A(Xa,Ya) avec minimum d’erreur ou le plus petit écart possible.

Les points Mi définissant les N positions de la bielle en fonction des angles alfa0 et alfa(i)

Les coordonnées des points Bi sont défini en fonction des points Mi par

Xb(i) = Xm(i)-BM .COS(Alfa0+Alfa(i)) III.2

Yb(i) = Ym(i)-BM .SIN(Alfa0+Alfa(i)) III.3

I=1,2, …, N

L’écart quadratique moyen est exprimé par :

qi=(Xa-Xbi)2+(Ya-Ybi)

2-R1

2 III.4

La somme des écarts quadratique moyens est donné par :

∑ )

Pour que q soit minimum, il faut que :

=0,

=0,

=0

=2

III.6

=2 qi.

=0

=2 qi.

=0

Calculant les dérivés partielles par rapport aux paramètres inconnus :

= 2(Xa-Xbi) ,

= 2(Ya-Ybi)

= -2R1 III.7

Compte tenu de :

∑[ ) ) ] )

∑[ ) ) ] )

∑[ ) ) ]

III.8

Tel que R1≠0

La troisième équation peut être mise sous la forme :

∑ )

∑

∑

)

III.9

Ce qui peut s’écrire :

∑[ ) ]

∑[ ) ]

+ - =-2H1

III.10

Apres transformation on obtient :

∑

∑

∑

∑

∑ ∑

∑

∑

∑ ∑

∑

= + III.11

D’où l’on obtient le system d’équation suivant

a1 XA +a2 YA + H1 = b1

a3 XA +a4 YA + a1H1 = b2 III.12

a4 XA +a5 YA + a2H1 = b3

∑

∑

∑

∑

∑

∑

∑

∑

La résolution de ce système donne les valeurs de Xa, Ya et R1.

Le rayon R1 obtenu a partir de H1 :

R1= [Xa + Ya + 2H1]1/2

III.13

Les paramètres A(Xa,Ya),R1 ,BM ,Alfa0 sont déterminé de façon ce que qi est minimum

C'est-à-dire ce sont les paramètres optimaux de la chaine cinématique ouverte susceptible de décrire

la courbe avec une erreur maximale minimale.

III.7. Présentation des logiciels de simulation de problème :

L’approche développé par A.Lousdad [15] décrite ci dessus est programmée et le problème à

résoudre et simulé avec le logiciel Visual Studio 2010 a l’aide de langage C# une partie de la

représentation schématique est faite en utilisant le logiciel MATLAB

-Une aperçus générale sur le langage de programmation est donnée avec la procédure d’utilisation le

logiciel Visual Studio, ainsi que sont interface avec le logiciel MATLAB

-Le problème est simulé avec logiciel Visual Studio, langage C# et une partie de schéma et faite par

logiciel MATLAB.

III.7.1. Aperçu sur langage C# :

III.7.1.1. Introduction :

Sous la demande de Microsoft, Anders Hejlsberg a mis au point un système pour rendre le

développement d'application Windows et Web beaucoup plus aisé. Une nouvelle architecture est

née suivit d'un langage qui devient aussitôt la référence et le principal langage pour Microsoft: c'est

le C Sharp ou encore C#. [16]

Le langage C# en une version simplifiée du langage C++.

III.7.1.2. Les types C# :

- bool (booléens),

- char (caractère Unicode 16 bits),

- string (chaîne de caractères Unicode),

- types intégraux non signés (byte, ushort, uint, ulong),

-types intégraux signés (sbyte, short, int, long),

-types flottants (float, double)

- currency (128 bits, pour les montants),

- object (type de base de tous les objets),

- void (type vide, pour les procédures).

III.7.1.3. Les boucles :

Une boucle permet d'exécuter plusieurs fois de suite une même séquence d'instructions.

Cet ensemble d'instructions s'appelle le corps de la boucle. Chaque exécution du corps d'une boucle

s'appelle une itération, ou plus informellement un passage dans la boucle. Lorsque l'on s'apprête a

exécuter la première itération, on dit que l'on rentre dans la boucle, lorsque la dernière itération est

terminée, on dit qu'on sort de la boucle. Il existe trois types de boucle

Boucle do, Boucle while et Boucle for

III.7.1.4. Les classes en C# :

• Les classes sont introduites avec « class ».

• Les données membres se déclarent comme des variables.

• Les méthodes comme des fonctions inline.

• Plusieurs types de mode d'accès :

- private (accessibles de la classe, par défaut),

- public (accessibles de tout le monde),

- protected (accessibles des classes dérivées),

- internal (accessibles depuis l'assemblée, cf. ci-après).

III.7.1.5. Avantages de C# :

• Le C# est un langage simple mais puissant.

• Il est fortement typé et épuré des constructions complexes ou à risque.

• Il s'appuie sur un environnement et une bibliothèque très riches.

• Il est ouvert vers l'existant.

III.7.2. Présentation de logiciel Visual studio :

La première version de Visual Studio a été publiée en 1997 par Microsoft, afin de rassembler

au sein d'un même environnement de développement plusieurs de ces outils de

programmation.

Visual Studio .NET est un jeu complet d'outils de développement permettant de générer des

applications Web ASP, des services Web XML, des applications bureautiques et des

applications mobiles. Visual Basic .NET, Visual C++ .NET, Visual C# .NET et Visual

J# .NET utilisent tous le même environnement de développement intégré (IDE, integrated

development environment), qui leur permet de partager des outils et facilite la création de

solutions faisant appel à plusieurs langages. Par ailleurs, ces langages permettent de mieux

tirer partie des fonctionnalités du .NET Framework, qui fournit un accès à des technologies

clés simplifiant le développement d'applications Web ASP et de services Web XML [17].

III.7.2.1. Platforme.NET :

Nous sommes aujourd’hui à la version 4.0 du Framework .NET. La première version

exploitable de celui-ci est sortie en 2002

Le Framework .NET regroupe un ensemble d’outils pour le programmeur. En effet les

technologies .Net vont nous permettre de programmer autant des applications console et

WindowsForm que des services Web, des applications Windows mobile et bien d’autres. Un

des avantages du Framework .Net, c’est qu’il est multi-langages. C'est-à-dire que l’on va

pouvoir programmer en VB.NET, en C#, en C++, en J# et aussi en d’autres langages

compatibles.

Figure. III. 33 : Framework .NET

III.7.2.2. CLS (Common Language System):

CLS signifiant Common Language System. Visual Studio.NET permet donc de développer avec

n'importe quel langage compatible avec l'architecture .NET.

Parmi ces langages, citons, en plus de Visual Basic, le C++, mais aussi JScript, une évolution du

langage JavaScript amélioré par MS et le tout dernier né des langages de la firme de Redmond, le

langage C# qui reprend la syntaxe du langage C++ [17].

III.7.2.3. La notion de classe :

Venons-en à présent à la notion de classe. Il existe bien entendu différents types d'objets. En

reprenant les exemples énumérés ci-dessus, les zones de texte et les boutons de commande sont

deux types d'objets différents, qui n'ont pas les mêmes caractéristiques, ni le même comportement.

La notion de classe correspond en fait au type de l'objet. Autrement dit, on ne parle pas de types

d'objets, mais de classes d'objets.

Sachant que nous avons parlé de caractéristiques et de comportement, une classe définit

précisément les caractéristiques et le comportement des objets associés à cette classe.

Cette notion de classe est très importante, car elle sert à créer des objets, un peu comme un moule

qui sert à créer des gâteaux. Finalement, l'action qui consiste de créer un objet à partir d'une classe

s'appelle une instanciation. On peut donc dire que chaque objet est une instance de la classe dont il

est issu [18].

III.7.2.4. Les classes de base :

Si tous les langages disponibles dans Visual Studio.NET sont capables de créer des objets spécifiques,

la plupart des applications reposent cependant sur des objets et donc des classes prédéfinies au

niveau du système, dites classe de base. Ces classes sont réparties en bibliothèques correspondant à

ce que l'on appelle des espaces de noms. Il existe ainsi une bibliothèque de classes de base pour les

applications WinForms, une pour les applications WebForms, une pour gérer la sécurité, une pour

gérer le réseau, etc.

III.7.2.5. Les services du CLR :

Le rôle des différents objets implémentés par le CLR est naturellement d'offrir des services,

que nous devons classifier en familles correspondant aux différents espaces de noms.

Remarque : Sans peut être allé jusqu'à la notion de service, il faut également savoir que le

CLR implémente une bibliothèque de types de données commune à tous les langages

compatibles .NET. Compte tenu du fait que toutes les classes du CLR sont elles aussi

communes à ces mêmes langages, cette remarque signifie que deux composants distincts

écrits avec 2 langages .NET différents seront compatibles, c'est-à-dire mutuellement

accessibles en toute transparence vis à vis du langage utilisé.

III.7.3. Aperçus sur logiciel MATLAB :

MATLAB est l’abréviation de MATrix LABoratory. Né au début des années 80 dans le milieu

universitaire, MATLAB est maintenant développé et commercialisé par la société THE MATHWORKS

INC.

MATLAB est C’est un environnement de travail complet, puissant et performant, ouvert et extensible

qui permet de remarquables gains de productivité et de créativité.

L’application MATLAB offre la possibilité de faire des calculs, de la programmation et de la

visualisation dans un environnement très facile d’utilisation où les problèmes et les solutions

s’expriment avec des notations mathématiques familières [19].

III.7.4. Définition et explication des fichiers dll :

Un fichier DLL (bibliothèque de liaison dynamique) est un fichier exécutable permettant à

des programmes de partager le code et les ressources nécessaires à la réalisation de tâches

données. Microsoft Windows fournit les fichiers DLL contenant les fonctions et ressources

permettant aux programmes basés Windows de fonctionner sous cet environnement.

Les DLL prennent généralement la forme de fichiers avec l'extension .DLL. Toutefois, ces

fichiers peuvent aussi avoir une extension .EXE (ou autre). Shell.dll fournit, par exemple, les

routines OLE (liaison et incorporation d'objets) de glisser-déposer utilisées par Windows et

d'autres programmes [20].

Sous Windows, un pilote installable constitue également une DLL. Un programme peut

ouvrir, activer, interroger, désactiver et fermer ce pilote à partir des instructions contenues

dans le fichier DLL.

III.7.5. Matlab builder.ne :

Mathworks prévoit la possibilité de créer. NET et les composants COM, à partir de propre

programme Matlab, en utilisant le Matlab Builder NE. Ces composants peuvent maintenant être

utilisés dans la propre application. NET, indépendamment de Matlab. Par l'utilisation de MATLAB

Compiler, Matlab Builder NE chiffre le programme Matlab, et génère un fichier

. NET wrapper autour d'elle. Maintenant, on peut l'utiliser comme un. NET natif dans mon application

C #.

III.7.6. MATLAB compiler :

Le MATLAB Compiler permet de partager une application MATLAB. Cela permet d'exécuter mon

application MATLAB dehors de l'environnement MATLAB, avec. NET.

Il est également possible de faire des bibliothèques partagées pour d'autres plates-formes que

. NET, comme Java ou même Excel. Pour exécuter l’application, nous besoin d'un moteur d'exécution

appelé Matlab Compiler Runtime (MCR), qui est fourni avec le compilateur Matlab.

III.7.7. MATLAB Compiler Runtime :

MCR est un moteur d’exécution, ce qui nous permet exécuter l’application MATLAB dehors de

l'environnement MATLAB. Il est très important d'ajouter la MCR.exe à notre programme MATLAB

lorsque nous compilons à un composant. NET. Sinon, nous n’obtiendrons pas la bonne version, et

notre application MATLAB ne fonctionnera pas dans d'autres environnements. Le MCR a beaucoup

de dépendances, qui jouent un grand rôle quand nous voulons développer un système distribué ; car

il doit être installé sur chaque plate-forme où nous accédons à notre programme MATLAB.

III.8. Conclusion:

Dans ce chapitre on a présenté la formule de résolution du problème pour le choix d’un mécanisme

avec les valeurs optimales des paramètres de mécanisme (la formule développé par A.lousdad[15]).

On a aussi présenté les logiciel de simulation de problème (Visual Studio et MATLAB et le langage C#.

La méthode de l’interface C# et MATLAB par transfère des dll sont également discutées.

CHAPITRE IV :


IV.1.Introduction :

Dans ce chapitre la programmation de l’approche ainsi la simulation de problème sont

faites en utilisant le langage C# avec Visual Studio, et le logiciel MATLAB.

La procédure d’utilisation de Visual C# et son interface avec MATLAB pour la résolution de problème

d’optimisation d’une chaîne cinématique ouverte (bras de robot) est exécuté.

La méthode appliquée donne les erreurs maximales aux niveaux des points de précision et la chaine

cinématique optimale est déterminé et présentée graphiquement.

La démarche est décrite dans ce qui suit.

IV.2.Description de problème :

Dans ce chapitre nous allons présenter la simulation de problème pour obtenir la position de

l’articulation immobile A de robot plan a deux liens et la longueur de bras R1 optimum avec les

minimums d’erreur structurale de trajectoire .On présentera les avantages de l’utilisation des DLL

comme une interface de communication entre C# et MATLAB pour la résolution des équations non

linéaire du fait qu’il manipule des variables matricielles et réduit le temps de calcul.

IV.3.Les étapes de simulation de problème :

Pour la simulation de l’approche analytique on suit les étapes suivantes :

IV.3.1.Lancement de logiciel VISUAL STUDIO 2010 :

La figure IV .1 représente Cette version est sortie en version final le 12avril 2010cette nouvelle

version utilise la version 4.0 de NET Framwerk .

Le numéro de version interne de Visual Studio 2010est 10.0(le symbol_mscver etant defini comme

1600)

Lancer Visual Studio 2010.

Figure. IV. 34: Visual Studio 2010

IV.3.2.Création d’un nouveau projet :

La figure IV.2 représente les étapes d’application Windows en C# :

Nous avons sélectionné une application Windows en C#.

Nouveau projet ensuite application Windows forms(on a choisir cette application par ce que le

travail et faite sur Windows 7) et on clique sur Visual C#.

Figure. IV. 35:Visual C#

Type de projet : Visual C#

Net fromwerk4, application Windows forms

Le nom de projet : matlabtest

IV.3.3.Conception de l’interface graphique de notre projet :

Avant de commencer la phase de programmation, on utilise la boite d’outil pour concevoir avant

l’interface graphique (GUI) de notre problème (la figure IV.3).

Figure. IV. 36 : Conception de l’interface graphique

*Boite d’outil :

On utilise dans la boite d’outil :

Textbox : pour l’affichage de valeurs suivantes :

X centre, Y centre et Diamètre de cercle de trajectoire.

Les cinq points de passage par le robot pour effectuer la trajectoire cercle :

Xmi,Ymi

Alfa, la longueur R de deuxième bras de robot et Alfa0

Xbi, Ybi, et les erreurs.

Les valeurs optimales : Xa, Ya, la longueur de premier bras R1.

*Les boutons : dessiner cercle, calculé

IV.3.4.Programmation c# :

Apres la conception de la l’interface, vient la phase de programmation en C#

Figure. IV. 37 : Interface de sélection du type de projet Visual C#

Le programme détaillé : voir annexe1

IV.3.5.Matlab2013 :

On utilise MATLAB 2013 Pour réduit le temps de calcul de résoudre les problèmes de représentation

graphique.

Figure. IV. 38: MATLAB 2013

IV.3.6.Programmation de la présentation graphique par MATLAB :

On a programmé sous MATLAB 2013 pour la représentation graphique la trajectoire de robot

Figure. IV. 39: Programmation par MATLAB

Le programme détaillé : voir annexe2.

IV.3.7.exécuter l’application dehors de l'environnement MATLAB :

La figure IV.7 ci-dessus représente L'exécution de l’application MATLAB en dehors de

l'environnement MATLAB, Pour exécuter l’application, nous avons besoin d'un moteur d'exécution

appelé MATLAB Compiler Runtime (MCR), qui est fourni avec le compilateur MATLAB.

Figure. IV. 40: MATLAB compiler

IV.3.8.Génération de dll :

La figure IV.8 ci-dessus représente la dll générée cette dll est une interface entre MATLAB et des

programmes .NET afin d’utiliser les fonctions plot de MATLAB à partir de C#.

MATLAB compiler .net assembly package

Figure. IV. 41: Création de dll

IV.3.9.Exécution de dll de Matlab au C# :

La figure IV.9 représente le transfert de dll de MATLAB au Visual Studio.

Figure. IV. 42:Transfère du dll au Visual C#

La figure IV.10 présente la génération du dll au Visual Studio :

Figure. IV. 43: Génération du dll au Visual C#.

IV.3.10. dll MATLAB transféré et exécuté au Visual Studio :

Une fois la DLL charger de l’affichage des graphes (plot) générée, on devra la connecter a Visual

Studio afin de l’exploiter a partir de notre programme C#, La figure IV.11 Montre comment on

ajoute une DLL Externe (Dans notre cas générée par MATLAB) a l’environnement Visual Studio :

Figure. IV. 44: MATLAB Interop.dll au Visual Studio

IV.3.11.Interface graphique exécutable :

La figure IV.12 représente l’interface graphique

Interface exécutable :

Les étapes d’exécution sont :

Les valeurs de cercle pour la trajectoire circulaire : centre (x, y) et Diamètre de cercle.

Click sur bouton: dessiner cercle

Ensuite clique sur les 5points sur le cercle pour avoir la trajectoire circulaire des points Mi

Afficher : Xmi et Ymi et les Alfa.

Ensuite l’affichage de R (longueur de bras 2) et Alfa0

Ensuite click sur bouton calculer.

La figure IV.13 représente l’interface graphique Et les valeurs optimales de point fixe A (la base de

robot) et rayon R (la longueur de bras 1)

Avec les cinq points Bi et les erreurs.

Tout représenter en schéma de la figure IV.13

Pour plus de précision on peut le faire de zoom comme la figure IV.14.

Sélection des points Mi : la première interface du programme donne la main à l’utilisateur pour

sélectionne les 5 points que doit atteindre le robot.

Figure. IV. 45: Interface graphique

Remarqué que l’interface principale est celui conçu dans Visual Studio, mais que schéma du

mécanisme est afficher dans une fenêtre MATLAB. Ce qui une flexibilité de représentation graphique.

Figure. IV. 46: Interface graphique avec schéma détaillé

IV.4. Résultats:

Pour une bonne précision de robot plan de deux degré de liberté on a fait la simulation suivante :

But de simulation :

Minimisation de l’erreur structurale.

Volume de travail : de 10° a 70°

Les valeurs :

Le robot suit le chemin de trajectoire d’un cercle passant par cinq points Mi

Tout d’abord on a tracé le cercle : pour une plus de précision des points de la trajectoire circulaire.

Avec : le centre (1.5, 2.5) et le rayon 1m

Click sur les cinq points (M1, M2, M3, M4, M5) de cercle pour trouver une trajectoire circulaire

cercle.

On prendre 5 exemples et on faire une variation de longueur de bras 2 (R) ;

Lancer la simulation :

*Cas n°:1

Le tableau suivant présente les valeurs pour R (Longueur de bras 2) égale à 0.75 m

Xm Ym Les alfas R Alfa0

2.48 2.66 20 0.75 0

2.39 2.95 30

2.15 3.25 40

1.89 3.41 50

1.60 3.49 60

Tableau. IV. 2: Les valeurs pour lancer simulation (R=0.75)

Résultats :

La figure (IV. 47) représente l’interface graphique avec les valeurs des erreurs :

Figure. IV. 14 : Interface graphique et résultat d’erreur de cas n°1

XBi YBi ERREUR

1.78 2.40 0.00051

1.74 2.58 -0.00081

1.58 2.77 -0.00013

1.41 2.84 0.00100

1.23 2.84 -0.00057

Tableau. IV. 3: Résultats pour la longueur de deuxième bras 0.75m

LES VALEURS OPTIMAUX :

XA YA R1

1.32 2.39 0.46

On remarque que L’erreur minimale égale : 0.00013

*Cas n°: 2

Le tableau suivant présente les valeurs pour R (Longueur de bras 2) égale à 0.85m


2.48 2.66 20 0.85 0

2.39 2.95 30

2.15 3.25 40

1.89 3.41 50

1.60 3.49 60


Résultats :

La figure (IV .15) représente l’interface graphique avec les valeurs des erreurs :

Figure. IV. 48: Interface graphique et résultat d’erreur de cas n°2

XBi YBi ERREUR

1.68 2.37 0.00046

1.65 2.53 -0.00071

1.50 2.70 -0.00011

1.34 2.76 0.00085

1.18 2.75 -0.00049


LES VALEURS OPTIMAUX :

XA YA R1

1.28 2.37 0.39


*Cas n°: 3



2.48 2.66 20 0.95 0

2.39 2.95 30

2.15 3.25 40

1.89 3.41 50

1.60 3.49 60


Résultats :


Figure. IV. 49: Interface graphique et résultat d’erreur de cas n°: 3

XBi YBi ERREUR

1.59 2.33 0.00037

1.56 2.48 -0.00056

1.43 2.64 0.00007

1.28 2.69 0.00065

1.13 2.67 -0.00038


Les valeurs optimales :

XA YA R1

1.25 2.35 0.34


*Cas n° : 4



2.48 2.66 20 1.05 0

2.39 2.95 30

2.15 3.25 40

1.89 3.41 50

1.60 3.49 60


Résultats :



XBi YBi ERREUR

1.50 2.30 0.00029

1.48 2.43 -0.00034

1.35 2.57 -0.00003

1.21 2.61 0.00037

1.08 2.58 -0.00022

Tableau IV. 9: Résultats pour la longueur de deuxième bras 1.05m


XA YA R1

1.21 2.32 0.28


*Cas n° : 5



2.48 2.66 20 1.15 0

2.39 2.95 30

2.15 3.25 40

1.89 3.41 50

1.60 3.49 60


Résultats :



XBi YBi ERREUR

1.40 2.26 0.00003

1.39 2.38 -0.00006

1.27 2.51 0.00003

1.15 2.53 0.00001

1.03 2.49 -0.00001



XA YA R1

1.16 2.30 0.23


IV.5.Comparaison et discussions :

On prendre l’intervalle suivant et on faire une comparaison pour trouvez le mécanisme optimale de

robot plan a deux degré de liberté pour avoir une trajectoire circulaire dans l’espace de travail

suivant :

Espace de travail :

10° ≤Alpha≤ 70°

Les longueurs des bras :

R (longueur de bras 2)

R1 (Longueur de bras 1)

Les unités en mètre

0.75 ≤R≤1.15

0.23≤R1≤0.46

R R1 LES ERREURS

0.75 0.46 0.00013

0.85 0.39 0.00011

0.95 0.34 0.00007

1.05 0.28 0.00003

1.15 0.23 0.00001

Tableau. IV. 12: Comparaison des résultats

*Pour R=0.75 et R1=0.46 l’erreur c’est 0.00013





On remarque que si (le deuxième bras de robot) R égale à 1.15 et R1 (premier bras de robot) égale à

0.23 l’erreur sera minimal 0.00001 on dit que c’est le mécanisme optimale de robot plan à deux

degré de liberté.

Figure. IV. 19 : Trajectoire circulaire de mécanisme optimale.

Figure. IV. 52: Représentation graphique de mécanisme optimale pour le robot plan à

deux degré de liberté

IV.6.Conclusion :

Les résultats obtenus permettent l’obtention de mécanismes optimaux satisfaisant les critères de

minimisation d’erreur structurale.

Nous avons obtenu pour les cas traités un mécanisme optimal permettant de suivre une trajectoire

circulaire avec minimum d’erreur. L’approche élaborée par A. Lousdad [15] est utilisée par

l’optimisation des mécanismes plans a chaine cinématique ouverte simulé par le langage C# et

MATLAB avec l’utilisation des DLL comme une interface de communication entre les logiciels facilite

de prendre le mécanisme optimale pour le robot plan à deux degré de liberté.

Conclusion générale

CONCLUSION GENERALE

La présent mémoire a pour objectif la proposition d’une méthode de conception optimale de la

structure fonctionnelle des robots industriels pour amélioré la précision et minimisé les erreurs

structurales.

La conception d’un mécanisme son montage et sa fabrication ajoute des erreurs .Ces erreurs doit

être analysé et minimisé pour avoir une précision satisfaire.

Pour un meilleur choix de mécanisme pour fabriquer un robot plan à deux degré de liberté une

étude sur les mécanismes avec schéma cinématique a été entreprise dans le but de définir les

paramètres optimaux du mécanisme (la position optimale de l’articulation fixe) et les longueurs des

bras.

A partir de l’approche analytique développé par A.lousdad*12+ une programmation a été faite pour

résoudre les problèmes et calculé la position optimale exacte de positon de l’articulation fixe A et la

longueur du premier bras a partir de la longueur de la bielle (deuxième bras).

La simulation de problème est faite en trois étapes :

*Conception de l’interface avec Visual Studio : la conception des boutons et des textbox est faite

avec minimum de temps par apport au logiciel MATLAB

*Programmation de l’approche analytique avec langage C# : le but de programmation trouver les

valeurs optimales de position de l’articulation fixe A(AX ,Ay) et longueur de bras R1

*Pour la représentation graphique de mécanisme on a utilisé le logiciel MATLAB pour la résolution

des équations non linéaires du fait qu’il manipule des variables matricielles et réduit le temps de

calcul par rapport aux Visual C#.

Après la programmation en MATLAB on a trouvé une méthode a été élaborée pour exécuter

l’application en Visual C# (génération d’une dll et exécution en dehors de MATLAB)

Plusieurs mécanismes ont été traités pour décrire trajectoire circulaire

Après la simulation de cinq cas :

Les paramètres A(Xa ,Ya), R1 ,R, et Alpha0 sont déterminés de façon à ce que l’erreur structurale est

minimum. Le mécanisme optimal à été déterminé donnant l’erreur maximale minimale. Cela permet

l’obtention d’un mécanisme optimal pour la conception d’un robot manipulateur plan à deux degrés

de liberté.

Références Bibliographiques

Références Bibliographiques

[1] ANDRE PREUMONT « Théorie Générale des Systèmes Articulés : Introduction `a la

Robotique » 2iem Edition - Laboratoire des Structures Actives Service des Constructions

Mécaniques et Robotique 2001.

[2] L. Sciavicco and B. Siciliano, Modelling and Control of Robot Manipulators, 2nd

Edition, Springer-Verlag, London, 2000.

[3] P. Fisette, H. Buyse, J.C. Samin, MECA 2732 : Introduction à la Robotique, 10 novembre 2004.

[4] R.P. Paul, Robot Manipulators: Mathematics, Programming, and Control MIT Press, Cambridge,

MA, 1981.

[5] Mark W. Spong, Seth Hutchinson, and M. Vidyasagar Robot Modeling and Control.first edition

[6] W. Khalil, E. Dombre, Bases de la Modélisation et de la Commande des Robots-Manipulateurs de

type série, 22 janvier 2012.

[7] I. Bonev, Y. Noiseux, Notes de cours GPA546. 27 mars 2013.

[8] David Daney. Sofia.inria .cours robotique fondamental.

[9] Dadan Fang. Diagnostique et adaptation des trajectoire robotiqueen projection thermique

Université de technologie de belfort.Décembre 2010 .

[10] E. Pernette, “robot de haute précision à 6 degrés-de-liberté pour l’assemblage des

microsystèmes”. Thèse Doctorat, EPFL (N°1909), 1998

[11] CHEDMAIL (P); DOMBRE (E) et WINGER (P): Mécanique et Robotique : Outils et

methodologies pour la CAO ;Edition Hermes. Paris 1998.

[12] Etienne DOMBRE .Laboratoire d’informatique et robotique et microélectronique de Montpellier

.Programmation des robots. 24.02.2014.

[13] Ahmed JOUBAIR. Contribution à l’amélioration de la précision absolue des robots

parallèles.

[14] G. K. Ananthasuresh .1994, Analysis and optimal synthesis of the RSCR spatial mechanism”,

Journal of Mechanical design.

[15] A .Lousdad, « Approche d’optimisation pour la résolution des problèmes des synthèses

structurale des mécanismes plans a couples cinématiques inférieurs. », mémoire de magister université

de sidi bel abbès; 1992.

[16] Alexandre Meslé Introduction à la programmation en C# 7 mars 2014.

[17] Introduction à Visual Studio .NET .Version 2003.

[18] le Laboratoire SUPINFO des technologies Microsoft. Les fonctionnalités de Visual

Studio.NET.

[19]Prof. Abdellah Adib ; Introduction à MATLAB.2011.2012.

[20] Lionel Seinturier. INRIA futurs Lille projet jacquard Université Pierre & Marie Curie.

ANNEXES

ANNEXE 1

Calcule des erreurs et valeurs

optimales

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using Matlba_Interop;

namespace Matlab_Test_V2

public partial class Form1 : Form

/// <summary>

/// Point of the high Left Corner Panel

/// </summary>

// VARIABLE POUR CALCULE MATRICIEL

/// <summary>

/// Valeur matrice parametre

/// </summary>

Matrix3x3 matA = new Matrix3x3();

/// <summary>

/// Valeur matrice resultat

/// </summary>

Vector3 matB = new Vector3();

/// <summary>

/// Valeur matrice solution

/// </summary>

Vector3 matX = new Vector3();

/// <summary>

/// Parametre d'affichage

/// </summary>

bool isResultShown = false;

enum FormatType { Standard, Fixed, Scientific }

FormatType formatType = FormatType.Standard;

//Drapeau pour le dessins

bool _okTodraw; //Drapeau pour valider le dessin

private bool _okToDrawDetails; //Drapeau pour valider le dessin des reste des

partie : Bare et point

private Point _pCCSPosition; // Position du Panel pour de decalage

//Centre Dimension Du Cercle

private double _centreCircleX;

private double _centreCircleY;

private double _diameter;

private double _rayon;

private int _dcentreCircleX;

private int _dcentreCircleY;

private int _dDiameter;

//Largeur et hauteur du paneau de dessin

private int _widthPanel;

private int _heightPanel;

//Coordonné du centre du panneau du dessin

private int _xCenterPanel;

private int _yCenterPanel;

private Color _color;

private Pen _pen;

private int _prusherSize;

private List<Point> _listPoints = new List<Point>();

private List<double> _lesXmi = new List<double>();

private List<double> _lesYmi = new List<double>();

public Form1()

InitializeComponent();

_color = Color.DarkGreen;

private void button1_Click(object sender, EventArgs e)

tbpMi.Visible = true;

_color = Color.DarkBlue;

_okTodraw = true; //Validation du dessin

ClearPoints(); //Clear Points

_lesXmi.Clear();

_lesYmi.Clear();

//Prise des valeurs reeles

_centreCircleX = Convert.ToDouble(tbXCentre.Text);

_centreCircleY = Convert.ToDouble(tbYCentre.Text);

_diameter = Convert.ToDouble(tbRayon.Text);

_rayon = _diameter / 2;

//Calcule de l'echelle

CalculeDeEchelle(pCCS.Width, pCCS.Height, _diameter);

DessinerSchema()

private void button2_Click(object sender, EventArgs e)

//Activé la visibilité des controls => Boutton de dessin et panneau des

valeurs

tbpBi.Visible = true;

ptbOpt.Visible = true;

//Nombre de point

int N = 5;

// Initailisation des Xmi

_lesXmi.Add(Convert.ToDouble(tbXm1.Text));





//Iniatilisation des Ymi

_lesYmi.Add(Convert.ToDouble(tbYm1.Text));





//Initialisation des Alfa

List<double> lesAlfas = new List<double>();

lesAlfas.Add(DegreeToRadian(Convert.ToDouble(tbAlfa1.Text)));





//Alfa 0

double alfa0 = Convert.ToInt32(tbAlfa0.Text);

//R : longeur du bras numero 2

double R = Convert.ToDouble(tbR.Text);

//________________________________________________________________________________

// Etape 1 : calcule des Xbi et mettre les resultat dans une liste lesXbi

List<double> lesXbi = new List<double>();

for (int i = 0; i < N; i++)

double Xbi = _lesXmi[i] - (R * Math.Cos(alfa0 + lesAlfas[i]));

lesXbi.Add(Xbi);

//Affichage des XBi

tbXb1.Text = lesXbi[0].ToString("0.00000");





//________________________________________________________________________________

// Etape 2 : calcule des Ybi et mettre les resultat dans une liste lesybi

List<double> lesYbi = new List<double>();

for (int i = 0; i < N; i++)

double Ybi = _lesYmi[i] - (R * Math.Sin(alfa0 + lesAlfas[i]));

lesYbi.Add(Ybi);

//Affichage des YBi

tbYb1.Text = lesYbi[0].ToString("0.00000");





//________________________________________________________________________________

double invN = (1 / (double)N);

//### A1

double A1 = (invN * SommeDeLaListPasserEnParametre(lesXbi));

//### A2

double A2 = invN * SommeDeLaListPasserEnParametre(lesYbi);

//### A3

List<double> lesCareDesXbi = new List<double>();

foreach (var xbi in lesXbi)

lesCareDesXbi.Add(xbi * xbi);

double A3 = invN * SommeDeLaListPasserEnParametre(lesCareDesXbi);

//### A4

List<double> lesXbiFoisYbi = new List<double>();

for (int i = 0; i < N; i++)

lesXbiFoisYbi.Add(lesXbi[i] * lesYbi[i]);

double A4 = invN * SommeDeLaListPasserEnParametre(lesXbiFoisYbi);

//### A5

List<double> lesCareDesYbi = new List<double>();

foreach (var ybi in lesYbi)

lesCareDesYbi.Add(ybi * ybi);

double A5 = invN * SommeDeLaListPasserEnParametre(lesCareDesYbi);

//________________________________________________________________________________

// calcule des S

List<double> lesSCare = new List<double>();

for (int i = 0; i < N; i++)

{

lesSCare.Add((lesXbi[i] * lesXbi[i]) + (lesYbi[i] * lesYbi[i]));

}

//________________________________________________________________________________

//### B1

double B1 = (invN / 2) * SommeDeLaListPasserEnParametre(lesSCare);

//### B2

List<double> lesSCareFoisXbi = new List<double>();

for (int i = 0; i < N; i++)

lesSCareFoisXbi.Add(lesSCare[i] * lesXbi[i]);

double B2 = ((invN / 2)) *

SommeDeLaListPasserEnParametre(lesSCareFoisXbi);

//### B3

List<double> lesSCareFoisYbi = new List<double>();

for (int i = 0; i < N; i++)

lesSCareFoisYbi.Add(lesSCare[i] * lesYbi[i]);

double B3 = ((invN / 2)) *

SommeDeLaListPasserEnParametre(lesSCareFoisYbi);

//###########################################################

// Calcule des coeficient de la matrice terminer

// on utilisera ces coef pour calculer : Xa , Ya et H 1

// et avec un changement de variable on va obtenir R1

//_________________________________________ Matrice A

//Equation 1

matA[0, 0] = A1;

matA[0, 1] = A2;

matA[0, 2] = 1;

//Equation 2

matA[1, 0] = A3;

matA[1, 1] = A4;

matA[1, 2] = A1;

//Equation 3

matA[2, 0] = A4;

matA[2, 1] = A5;

matA[2, 2] = A2;

//__________________________________________ Matrice B

matB[0] = B1;

matB[1] = B2;

matB[2] = B3;

int iv = Matrix3x3.SolveEquations(out matX, matA, matB);

if (iv == 0)

//ShowResults();

var Xa = matX[0];

var Ya = matX[1];

var H1 = matX[2];

var R1 = Math.Sqrt((Xa * Xa) + (Ya * Ya) + (2 * H1));

//MessageBox.Show(resultat);

tbXa.Text = Xa.ToString("0.00000");

tbYa.Text = Ya.ToString("0.00000");

tbR1.Text = R1.ToString("0.00000");

//________________________________ Calcule des erreurs

List<double> lesErreurs = new List<double>();

for (int i = 0; i < N; i++)

var p1 = (Xa - lesXbi[i]);

p1 = p1 * p1;

var p2 = (Ya - lesYbi[i]);

p2 = p2 * p2;

lesErreurs.Add(p1 + p2 - (R1 * R1));

tbErr1.Text = lesErreurs[0].ToString("0.00000");





//___________________________________ Calcule de l'erreur quadratique

//List<double> lesCareDesErreur = new List<double>();

//for (int i = 0; i < N; i++)

//{

// var care = lesErreurs[i]*lesErreurs[i];

// lesCareDesErreur.Add(care);

//}

//MessageBox.Show(@"Les Carés Des Erreurs de Calcul : " +

Environment.NewLine + ListToString(lesCareDesErreur));

//___________________________________ La somme des caré : erreur

quadratique

//double erreurQuadratique = 0;

//for (int i = 0; i < N; i++)

//{

// erreurQuadratique = erreurQuadratique + lesErreurs[i];

//}

//MessageBox.Show(@"L'erreur quadratique est de : " +

Environment.NewLine + erreurQuadratique);

//erreurQuadratique = erreurQuadratique * erreurQuadratique;

//MessageBox.Show(@"Le caré est : " + Environment.NewLine +

erreurQuadratique);

//Calcule de la nouvelle Echelle de dessin :

//double grandSchema = DimentionnementDeEchelle(0, 0, 0, 0, 0, 0);

//CalculeDeEchelle(pCCS.Width, pCCS.Height, grandSchema);

//MessageBox.Show(ConvertisseurEchelle.Echelle.ToString("0.0000"));

//Forçage du redessinage du graph

DessinerSchema();

//Fin du programme

MessageBox.Show(@"--------------------- PROGRAMME TERMINE ---------------------");

//Test On Matlab Ploting

mainPanel.Enabled = false;

PlotSystem.Plot

(

_centreCircleX, _centreCircleY, _rayon,

_lesXmi[0], _lesXmi[1], _lesXmi[2], _lesXmi[3], _lesXmi[4],

_lesYmi[0], _lesYmi[1], _lesYmi[2], _lesYmi[3], _lesYmi[4],

Xa, Ya, R1,

lesXbi[0], lesXbi[1], lesXbi[2], lesXbi[3], lesXbi[4],

lesYbi[0], lesYbi[1], lesYbi[2], lesYbi[3], lesYbi[4]

);

mainPanel.Enabled = true;

else

MessageBox.Show(@"Pas de solution pour cette equation");

private void Form1_Load(object sender, EventArgs e)

//prise des dimension du panel

_heightPanel = pCCS.Height;

_widthPanel = pCCS.Width;

_pCCSPosition = new Point(pCCS.Location.X, pCCS.Location.Y);

//price des coordinées du centre du panel

_xCenterPanel = _widthPanel / 2;

_yCenterPanel = _heightPanel / 2;

#region Partie Dessin -------------------------------------------------

private void pCCS_Paint(object sender, PaintEventArgs e)

//MessageBox.Show("Location = " + pCCS.Location.ToString());

//MessageBox.Show("Size = " + pCCS.Width + " - " + pCCS.Height);

if (_okTodraw) //Si OK pour le dessin

//Creer le stylo

_pen = new Pen(_color, _prusherSize);

//Convertion

_dDiameter = ConvertisseurEchelle.DuReelVersDessin(_diameter);

_dcentreCircleX =

ConvertisseurEchelle.DuReelVersDessin(_centreCircleX);

_dcentreCircleY =

ConvertisseurEchelle.DuReelVersDessin(_centreCircleY);

//Dessiner

DrawCercle(e.Graphics, _pen, (pCCS.Width/2) - (_dDiameter/2),

(pCCS.Height/2) - (_dDiameter/2),

_dDiameter);

foreach (var point in _listPoints)

//DrawCercle(e.Graphics, _pen, point.X, point.Y, 2);

DrawPoint(e.Graphics, point);

if (_okToDrawDetails)

#endregion

#region Draw Line ____________________________________________________

private void DrawLine(Graphics graphics, Pen pen, Point pointDepart, Point

pointArrive)

graphics.DrawLine(pen, pointDepart, pointArrive);

#endregion

#region Draw Point ____________________________________________________

private void DrawPoint(Graphics graphics, Point point)

Pen pointPen = new Pen(Color.Red, 2);

graphics.DrawEllipse(pointPen, point.X, point.Y, 2, 2);

#endregion

#region Draw Circle _________________________________________________

/// <summary>

/// Dessine un cercle dans l'interface

/// </summary>

/// <param name="graphics">Graphic : sur quel plan dessiner</param>

/// <param name="pen">Le style avec le quel on va dessiner : Epesseur +

Couleur</param>

/// <param name="dcenterY">Y du centre sur echelle reele</param>

/// <param name="drayon">Le rayon du cercle</param>

/// <param name="dcenterX">X du centre sur echelle reele</param>

private void DrawCercle(Graphics graphics, Pen pen, int dcenterX, int

dcenterY, int drayon)

//graphics.DrawEllipse(pen, dcenterX, dcenterY, drayon, drayon);

graphics.DrawEllipse(pen, dcenterX, dcenterY, drayon, drayon);

#endregion

private void ClearPoints()

//Clearing points :

_listPoints.Clear();

private void pCCS_Click(object sender, EventArgs e)

//Adding point

Point point = new Point(MousePosition.X, MousePosition.Y);

point.Offset(-_pCCSPosition.X, -_pCCSPosition.Y - 25);

//dx : decalage sur le dessin

int dx = _xCenterPanel - point.X;

// x : decalage reel

double x = (_diameter * dx) / _dDiameter;

// coordoné reel

double px = _centreCircleX - x;

int dy = _yCenterPanel - point.Y;

double y = (_diameter * dy) / _dDiameter;

double py = _centreCircleY + y;

//Ajouter a la liste des points

_listPoints.Add(point);

double xReel, yReel;

RetourneYduXdansLeCercle(px, py, out xReel, out yReel);

_lesXmi.Add(xReel);

_lesYmi.Add(yReel);

//Remplissage des champs

if (_lesXmi.Count == 1)

tbXm1.Text = Convert.ToString(xReel);

tbYm1.Text = Convert.ToString(yReel);













pCCS.Invalidate();

//____________________________________________________________________________________

//____________________________________________________________________________________

/// <summary>

/// C une procedure qui onvertit une liste en chaine de caractére

/// </summary>

/// <param name="list">list d'onbjet</param>

/// <returns>chaine de carataire</returns>

string ListToString(List<double> list)

var ss = "";

foreach (var i in list)

ss = ss + i.ToString() + Environment.NewLine;

return ss;

#region Somme d'une liste de valeur passée en paramètre

private double SommeDeLaListPasserEnParametre(List<Double> listEnParametre)

double somme = 0;

foreach (var element in listEnParametre)

somme = somme + element;

return somme;

#endregion

private void ShowResults()

var resultat =

"Xa = " + matX[0] + Environment.NewLine +

"Ya = " + matX[1] + Environment.NewLine +

"H1 = " + matX[2] + Environment.NewLine;

MessageBox.Show(resultat);

#region Converstion Degret vers Radian

/// <summary>

/// Convertir Degret to Radui

/// </summary>

/// <param name="angle"></param>

/// <returns></returns>

private double DegreeToRadian(double angle)

return Math.PI*angle/180.0;

#endregion

/// <summary>

/// Dessiner le schema

/// </summary>

private void DessinerSchema()

pCCS.Invalidate(); //Dessin

#region Retourne les valeurs exact du point sur le cercle

/// <summary>

/// Fonction qui retourne La Valeur d'un point exact sur le cercle

/// apartir d'un point proche

/// </summary>

/// <param name="xProcheDuCercle">X du point proche du cercle</param>

/// <param name="yProcheDuCercle">Y du point proche du cercle</param>

/// <param name="xExactSurLeCercle">X du point Exact du cercle</param>

/// <param name="yExactSurLeCercle">Y du point Exact du cercle</param>

private void RetourneYduXdansLeCercle(

double xProcheDuCercle, double yProcheDuCercle,

out double xExactSurLeCercle, out double yExactSurLeCercle)

double r = _rayon;

double vX = xProcheDuCercle - _centreCircleX;

double vY = yProcheDuCercle - _centreCircleY;

double magV = Math.Sqrt((vX*vX) + (vY*vY));

double aX = _centreCircleX + vX/magV*r;

double aY = _centreCircleY + vY/magV*r;

xExactSurLeCercle = aX;

yExactSurLeCercle = aY;

#endregion

#region Calcule de echelle

private void CalculeDeEchelle(int W, int H, double r)

int M = 0;

//MessageBox.Show(@"Le Width : " + Convert.ToString(W));

//MessageBox.Show(@"Le Heith : " + Convert.ToString(H));

//On pren le minimum des deux : W / H

if (W > H)

M = H;

else M = W;

//MessageBox.Show(@"Le minumum : " + Convert.ToString(M));

int M80 = M*80/100;

//MessageBox.Show(@"80% du mumimu : " + Convert.ToString(M80));

double echelle = r/M80;

//MessageBox.Show(@"L'echelle : " + Convert.ToString(echelle));

ConvertisseurEchelle.Echelle = echelle;

#endregion

private void testToolStripMenuItem_Click(object sender, EventArgs e)

private void tbXCentre_TextChanged(object sender, EventArgs e)

Annexe 2

Conception de graph par MATLAB

amespace Matlba_Interop

/// <summary>

/// Class Library Generated By Matlab To Plot The Systeme

/// </summary>

public class PlotSystem

public static void Plot

(

double xCentrep, double yCentrep, double rayonp,

double xM1, double xM2, double xM3, double xM4, double xM5,

double yM1, double yM2, double yM3, double yM4, double yM5,

double xBase, double yBase, double rBase,

double xB1, double xB2, double xB3, double xB4, double xB5,

double yB1, double yB2, double yB3, double yB4, double yB5

)

StreamReader outputReader = null;

StreamReader errorReader = null;

try

//Computing Plot Limit Visibility to center the graphe

double xInf, yInf, xSup, ySup;

CentrageDuGraphe(

xCentrep, yCentrep, rayonp,

xBase, yBase, rBase,

out xInf, out xSup, out yInf, out ySup

);

xInf = -2;

xSup = 10;

yInf = -2;

ySup = 10;

const string command = @"C:\MATLAB .NET COMBINAISON\Exportation

V2\Untitled1\distrib\Untitled1.exe";

var param =

xCentrep + " " +

yCentrep + " " +

rayonp + " " +

xM1 + " " + xM2 + " " + xM3 + " " + xM4 + " " + xM5 + " " +

yM1 + " " + yM2 + " " + yM3 + " " + yM4 + " " + yM5 + " " +

xBase + " " + yBase + " " + rBase + " " +

xB1 + " " + xB2 + " " + xB3 + " " + xB4 + " " + xB5 + " " +

yB1 + " " + yB2 + " " + yB3 + " " + yB4 + " " + yB5 + " " +

xInf + " " + xSup + " " + yInf + " " + ySup;

Clipboard.SetText(param);

//Create Process Start information

ProcessStartInfo processStartInfo =

new ProcessStartInfo(command, param);

processStartInfo.ErrorDialog = false;

processStartInfo.UseShellExecute = false;

processStartInfo.RedirectStandardError = true;

processStartInfo.RedirectStandardInput = true;

processStartInfo.RedirectStandardOutput = true;

//Execute the process

Process process = new Process();

process.StartInfo = processStartInfo;

bool processStarted = process.Start();

if (processStarted)

process.WaitForExit();

catch (Exception ex)

finally

/// <summary>

/// Methode qui redimentionnement l'echelle pour contenir les deux Cercle

/// </summary>

/// <param name="cx1">X : Centre Cercle 1</param>

/// <param name="cy1">Y : Centre Cercle 1</param>

/// <param name="r1">Rayon Cercle 1</param>

/// <param name="cx2">X : Centre Cercle 2</param>

/// <param name="cy2">Y: Centre Cercle 2</param>

/// <param name="r2">Rayon Cercle 1</param>

private static void CentrageDuGraphe(

double cx1, double cy1, double r1,

double cx2, double cy2, double r2,

out double xInf, out double xSup,

out double yInf, out double ySup

)

var xx = new List<double> {cx1 - r1, cx1 + r1, cx2 - r2, cx2 + r2};

var yy = new List<double> {cy1 - r1, cy1 + r1, cy2 - r2, cy2 + r2};

double maxXX = xx.Max();

double minXX = xx.Min();

double maxYY = yy.Max();

double minYY = yy.Min();

double w = 1060;

double h = 500;

double prc = w / h;

var xlenght = maxXX - minXX;

var ylenght = maxYY - minYY;

var yOffset = ylenght * 5 / 90;

yInf = minYY - yOffset;

ySup = maxYY + yOffset;

var yMax = ySup - yInf; //Distance 100%

var xMax = prc * yMax;

var xOffset = (xMax - xlenght) / 2;

xInf = minXX - xOffset;

xSup = maxXX + xOffset;

//MessageBox.Show(yInf.ToString("0.00000"));

//MessageBox.Show(ySup.ToString("0.00000"));

//MessageBox.Show(xSup.ToString("0.00000"));

//MessageBox.Show(xInf.ToString("0.00000"));

//return 0;

universite djillali liabes de sidi bel abbes faculte de

Documents