Introduction À La Programmation Des Systèmes Robotiques Industriels. Stéphane Bazeille

Introduction à la programmation des
systèmes robotiques industriels
Stéphane Bazeille
Université de Haute-Alsace
E-mail : stephane.bazeille@uha.fr
Mots-clés : Robotique, Informatique, Staubli, VAL 3.

Version du 23 février 2020
Table des matières
1 Introduction 3
1.1 Contenu du cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Volume horaire et contrôle de connaissance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Compétences acquises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 La robotique 4
2.1 Une discipline complexe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Qu’est-ce qu’un robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Des automates aux robots autonomes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3 Programmation des robots industriels 8

3.1 Les bras articulés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.2 Les modèles pour le contrôle des bras articulés . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.3 De l’importance des repères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.4 Programmation d’un robot industriel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.5 Décomposition de la trajectoire en une séquence de mouvements . . . . . . . . . . . . . . . . . . 11
3.6 Deux types de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.7 Un exemple simple de manipulation d’une seule pièce . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.8 Les bras robotisés Staubli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.9 L’environnement de simulation SRS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4 Le langage VAL3 et la programmation des robots Staubli. 15

4.1 Elément de langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.2 Contrôle du robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.3 Communication robot/caméra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5 Travaux dirigés 19
5.1 Ex 1 : Exemple d’utilisation des fonctions de mouvement . . . . . . . . . . . . . . . . . . . . . . 19
5.2 Ex 2 : Dépilement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.3 Ex 3 : Palettisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.4 Ex 4 : Communication avec une caméra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
6 Travaux pratiques 22
6.1 Présentation des Tps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
6.2 TP 1. Prise en main de SRS 2016 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
6.3 TP 2. Dépilement et rangement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
6.4 TP 3. Tri RGB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
6.5 TP 4. Tours de Hanoï . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
6.6 TP 5. Prise de pièce localisée par un système de vision . . . . . . . . . . . . . . . . . . . . . . . . 37
A Exercices de remise à niveau : algorithmique et programmation 40
B Salle Robotique IUT de Mulhouse (details robots) 43
C Salle Robotique IUT de Mulhouse (liste IP) 44
D Table ASCII 45
2
Chapitre 1
Introduction
1.1 Contenu du cours

Ce cours est une introduction à la programmation des robots industriels. Après une initiation aux connais-
sances théoriques fondamentales en robotique, nous apprendrons à programmer des robots industriels de la
marque Staubli. Pour cela nous étudierons le langage propriétaire VAL3 et développerons nos programmes avec
l’environnement de simulation SRS (simulateur sous licence Staubli). Il est important de noter que chaque
constructeur de robot développe en général son propre langage mais qu’ils sont tous basés sur le même modèle.
Les programmes seront développés d’abord en simulation puis implémentés sur le robot réel. Durant les tra-
vaux pratiques nous mettrons en oeuvre différentes applications de prise et dépôt de pièces très utilisées dans
l’industrie en production ou conditionnement. Parmi ces applications, nous verrons entre autres : l’empilement
et le dépilement, la palettisation, le tri de pièces par couleurs, ainsi qu’un jeu de manipulation de pièces. Nous
simulerons aussi l’utilisation de système de vision permettant la localisation en temps réel de la pièce avant la
prise.
1.2 Volume horaire et contrôle de connaissance

Ce cours de robotique industrielle s’adresse aux étudiants de DUT et Licence. Il comprend à peu près 25h de
formation : 4h de cours, 2h de TD, et 15h de TP. A l’issue de ces heures d’enseignements, un TP test (1h30) et
un examen écrit (2h) permettront de valider les notions apprises. Aucun rapport ne sera demandé pendant les
TP.
1.3 Prérequis
Avant de commencer ce cours de robotique il est indispensable d’avoir les notions d’informatique suivantes :
— Algorithmique de base (affectation, condition, boucle...)
— Manipulation des tableaux (parcours, recherche de valeur...)
— Programmation procédurale (fonction, paramètre, valeur de retour, structures...)
Quelques rappels et exercices sont fournis en annexe. Il est recommandé aux étudiants qui ne sont pas à l’aise
avec ces notions de se mettre à niveau avant le début de ce cours.
1.4 Compétences acquises

A l’issue de cette formation, vous serez capable de mettre en place des solutions de robotique industrielle pour
résoudre des problèmes simples de manipulation de pièces. Vous serez capable de programmer un robot industriel,
de le manipuler et de débuguer un programme défaillant. Vous disposerez des connaissances nécessaires pour
vous former et développer par vous-même des tâches plus complexes de robotique comme par exemple des tâches
nécessitant le traitement de données capteurs : caméra, laser...
3
Chapitre 2
La robotique
2.1 Une discipline complexe

Le terme robotique fut introduit dans la littérature en 1942 par Isaac Asimov (écrivain de science-fiction russe
inventeur des 3 lois de la robotique) dans son livre Runaround. La robotique est l’ensemble des techniques per-
mettant la conception et la réalisation de machines automatiques également appelés de robots. Elle rassemble
de nombreuses compétences : des compétences en mécanique, en électronique, et en informatique. Ces compé-
tences sont regroupées sous le terme mécatronique : combinaison synergique et systémique de la mécanique,
de l’électronique, de l’automatique et de l’informatique en temps réel. Pour compléter cette définition, on dé-
finit un roboticien comme un ingénieur, chercheur ou technicien spécialiste de la conception, de l’utilisation et
de la programmation des systèmes automatisés ou robots. Dans les secteurs de l’industrie automobile ou de
l’aéronautique par exemple, ce professionnel travaille dans les bureaux d’études, les services de recherche et
développement ou les ateliers de production. Avec un niveau Licence, les métiers peuvent être : technicien étude
et développement de robots, technicien installation lignes de production automatisées et robotisées, technicien
simulation lignes de production ou bien technicien maintenance systèmes robotiques. Avec un niveau Master ou
Doctorat, vous pourrez devenir ingénieur d’études ou de conception, ingénieur mécatronicien, développeur en
robotique ou bien chercheur en intelligence artificielle par exemple.
2.2 Qu’est-ce qu’un robot

Le terme robot est apparu en 1920 pour la première fois dans la pièce de théâtre (science-fiction) de l’auteur
Karel Capek : R. U. R. (Rossum’s Universal Robots). Le mot robot a été créé à partir du mot tchèque "robota"
qui signifie "travail, corvée". Ces dernières années dans le langage courant, l’usage du terme robot est maladroi-
tement utilisé à la fois pour les automates distributeur, les dispositifs électromécaniques, et les logiciels servant
d’adversaire sur les plateformes de jeu informatique, cet usage est abusif car un automate ou un programme
informatique ne devraient pas être assimilés à des robots. Par définition, un robot est un système nécessaire-
ment constitué de 3 éléments suivants : un ordinateur, un ou plusieurs actionneurs et un ou plusieurs
capteurs. Un robot est un dispositif mécatronique. Il est conçu pour pouvoir accomplir automatiquement diffé-
rentes tâches complexes. Ce système doit être alimenté en énergie et évolue dans un environnement statique ou
dynamique. Le contrôle des mouvements inclut 3 phases distinctes qui se répètent en boucle : la perception,
le traitement de l’information perçue et le mouvement. Un robot fonctionne par l’exécution continue de
son programme informatique écrit dans un langage de programmation choisie par le constructeur. Pour résumer,
on peut décomposer un robot en 3 sous-systèmes :
— la partie opérative (squelette et actionneur du système à dominante Mécanique et Électromécanique),
— la partie intelligence (perception, capteurs, calcul complexe à dominante Mathématiques et Informatique),
— la partie commande (contrôle embarquée à dominante Électronique et Informatique temps réel).
Figure 2.1: Boucle Perception-Décision-Action
4
CHAPITRE 2. LA ROBOTIQUE 5
Mécanique ou partie opérative (action)

Un robot est donc d’abord constitué d’un châssis ou squelette. C’est à dire un cadre rigide destiné à entourer ou
supporter les actionneurs et l’électronique. Le robot est en général équipé de plusieurs actionneurs qui peuvent
être de plusieurs types. Les actionneurs les plus usuels sont :
— les actionneurs rotatifs,
— les actionneurs linéaires,
L’actionneur est le constituant de base de tout système mécanique (exemple : bras, patte, roue motrice...). Il
réalise une action motrice suivant un degré de liberté c’est à dire suivant un axe. On définit un degré de liberté
comme un mouvement suivant un axe (translation) ou autour d’un axe (rotation). Le choix de l’énergie utilisée
pour la réalisation du mouvement d’un actionneur peut être de différents types : soit électrique, soit pneumatique
ou bien hydraulique. Pour information, les actionneurs pneumatiques et hydrauliques sont alimentés par une
pompe et permettent des actions toniques en général longitudinales. Les actionneurs électriques sont largement
les plus répandus, l’avantage principal est la précision de commande et de positionnement.
Electronique ou partie commande (perception/commande)

Sur un robot, l’électronique permet à la fois de commander la partie opérative via l’ordinateur et de collecter de
l’information sur l’environnement à l’aide des capteurs. L’électronique a pour objet le traitement par des com-
posants matériels des signaux électroniques (tension électrique, courant, mais également des champs électriques
ou magnétiques). Traditionnellement, les signaux sont classés en 3 grands types :
— signaux analogiques,
— signaux numériques,
— signaux de puissance,
L’électronique analogique et numérique concerne principalement les capteurs. Les capteurs sont des dispositifs
transformant l’état d’une grandeur physique observée en une grandeur utilisable, telle qu’une tension électrique,
une hauteur de mercure, une intensité ou la déviation d’une aiguille. On peut citer par exemple les capteurs de
position, de vitesse, de fin de courses... ou bien les caméras ou les lasers.
Contrairement à l’électronique analogique ou numérique où on s’intéresse principalement à l’information conte-
nue dans les signaux, l’électronique de puissance s’intéressent à l’énergie contenue dans les signaux électriques.
On parle d’électronique mixte lorsque l’on est en présence d’un système dans lequel coexistent les signaux numé-
riques et analogiques. Le convertisseur analogique-numérique (CAN) et le convertisseur numérique-analogique
(CNA) permettent de transformer un signal analogique en signal numérique et vice versa. Ils réalisent une
interface entre les modules purement analogiques (comme les capteurs) et purement numériques comme les
microprocesseurs. Les microprocesseurs ou les micro-contrôleurs traitent les signaux numériques et permettent
le contrôle des mouvements du robots. Le système de contrôle moteur reçoit un ordre de mouvement envoyé par
le programme principal (en données cartésiennes) puis il calcule et envoie aux actionneurs les signaux (vitesse,
position) permettant d’effectuer le mouvement souhaité (par exemple déplacer le bras ou bien ouvrir la pince).
Ce mouvement est ensuite contrôlé par un système d’asservissement.
Figure 2.2: Boucle d’asservissement pour le contrôle du robot
Informatique ou partie intelligence (décision)

Piloté par l’ordinateur embarqué, la partie informatique gère le comportement global du robot. Pour rappel, un
ordinateur est un système de traitement de l’information programmable qui fonctionne par la lecture séquen-
tielle d’un ensemble d’instructions (organisées en programmes), qui lui font exécuter des opérations logiques
et arithmétiques. Sa structure physique actuelle fait que toutes les opérations reposent sur la logique binaire
et sur des nombres formés à partir de chiffres binaires. Dès sa mise sous tension, un ordinateur exécute, l’une
après l’autre, des instructions qui lui font lire, manipuler, puis réécrire un ensemble de données enregistrées en
mémoire. Des tests et des boucles permettent de passer à l’instruction suivante et donc d’agir différemment en
fonction des données. Le comportement global du robot géré par l’ordinateur peut être plus ou moins complexe.
À un niveau réactif, le robot peut traduire l’information brute d’un capteur directement en commande d’un
actionneur (par exemple un arrêt d’urgence, si un obstacle est détecté alors on arrête les moteurs). Avec des
tâches plus sophistiquées, il faut utiliser des algorithmes. Le programme robotique est en charge de suivre l’évo-
lution du retour des capteurs et prévoir en permanence la séquence d’actions à réaliser par le robot : comme par
exemple recalculer la trajectoire à suivre lorsque la première trajectoire calculée a donné lieu à une collision. Le
programme principal est en général la partie la plus complexe du robot. Plus le robot est autonome plus son
programme informatique doit prendre en compte un nombre important de variables.
2.3 Des automates aux robots autonomes

Développement des robots
Figure 2.3: Le premier robot : Unimate
Contrairement aux automates, machines dont l’origine remonte au XVIIIe siècle (date des premiers automates
mécaniques), les robots sont des systèmes polyvalents et capables d’agir et de réagir de façon autonome. Dans
leur définition générale, les robots sont dotés d’une plus grande liberté d’action, de capteurs pour percevoir leurs
mouvements et l’environnement et d’une capacité de calcul importante qui les rendent capables de prendre "des
décisions". Unimate était le premier robot créé. Il fut créé par George Devol dans les années 1950 et a été utilisé
pour travailler sur les chaînes d’assemblage de General Motors à partir de 1961 (Fig. 2.3). Ce robot avait peu de
capacités de réaction, lui et ses successeurs étaient destinés à exécuter certaines tâches répétitives, éprouvantes
ou toxiques pour un opérateur humain : peinture ou soudage des carrosseries automobiles. Dans les années qui
ont suivi, l’évolution de l’électronique a permis de développer des robots plus faciles à contrôler, plus précis et
plus rapides. Aujourd’hui, grâce à l’accroissement très important de la puissance de calcul les robots deviennent
de plus en plus autonome, au sens qu’ils sont capable de gérer des situations problématiques qui surviennent
lors de l’exécution d’une tâche. Avec ces développements, ils se sont imposés dans de nombreux domaines :
— la robotique industrielle et la robotique domestique,
— la robotique médicale et la robotique militaire,
— la robotique scientifique, par exemple pour l’exploration de l’espace, des fonds marins,
— la robotique de transport (de personnes et de marchandises),
Quelques exemples de robots utilisés aujourd’hui dans différents domaines sont présentés sur la figure 2.4
Programmer un robot pour qu’il soit intelligent

En plus d’être capable de se déplacer, pour qu’un robot ait un comportement "intelligent", il est nécessaire
qu’il perçoive ce qu’il fait (par exemple s’il a saisi l’objet ou non) et ce qui se passe autour de lui (quels sont
les objets et obstacles présents dans son voisinage ?). Dans ce cas si le robot n’a pas réussi sa saisie de l’objet il
pourra recommencer la prise de l’objet au lieu de continuer sa tâche normalement. La phase de perception est
assurée par l’utilisation de capteurs qui permettront au robot de recueillir des informations sur l’environnement
(exteroception) ou sur ses composants internes (proprioception). C’est à partir des informations envoyées par
les capteurs qu’il va traiter et interpréter, que le robot sera capable de prendre une décision pour passer de son
cycle de fonctionnement standard à un autre cycle de fonctionnement. L’intelligence vient de la possibilité qu’a
Figure 2.4: Quelques exemples de robots d’aujourd’hui.
le robot à réagir à des événements. Pour cela, il faut développer un programme qui interprète le retour de tous
ses capteurs et adapte le comportement du robot en conséquence.
Les capteurs de perception et l’intelligence artificielle

La perception peut être divisée en deux catégories : la proprioception et l’exteroception. La proprioception
permet au robot de mesurer : la position de ses actionneurs, les forces appliquées sur ces actionneurs, les ac-
célérations, les vitesses linéaires et angulaires du robot, la position et l’orientation du robot dans l’espace, s’il
est mobile... pour cela le robot utilise des capteurs de positions, de forces et des centrales inertielles. L’exte-
roception permet quant à elle d’obtenir des informations sur l’environnement extérieur à partir de caméras
ou de lasers par exemple. Dans ce cas, l’information est beaucoup plus complexe à traiter puisque le capteur
donne uniquement des informations sur la couleur ou sur les distances de certains points dans l’espace. Cette
information n’a à la base aucun sens sémantique. Il faut donc donner un sens à ces couleurs ou ces points 3D
(est-ce un objet/obstacle ? est-ce statique ou dynamique...) avant de pouvoir prendre une décision. Cette étape
d’extraction d’information à partir des données des capteurs est de loin, la plus compliquée, elle nécessite des
calculs complexe. Le traitement de ces données et la fusion des informations provenant des différents capteurs
permettent d’obtenir des informations de haut niveau sur l’environnement exploitable par le robot pour prendre
des décisions. A noter que beaucoup de recherches en perception concerne le domaine de l’intelligence artifi-
cielle. Les robots de demain dotés de nombreux capteurs et d’une puissance de calcul importante auront une
plus grande autonomie (Fig. 2.5).
Figure 2.5: Quelques exemples de robots futuristes.
Dans la suite de ce cours, nous nous intéresserons aux robots industriels. Les robots industriels peuvent être
téléguidés à l’aide d’une télécommande, on appelle ce mode contrôle le mode manuel cependant ce mode est
peu utilisé. Les robots industriels sont en général programmés pour effectuer une suite de mouvement automa-
tiquement (mode automatique). Dans la prochaine partie, nous allons-nous apprendre comment programmer
des robots industriels.
Chapitre 3
Programmation des robots industriels
3.1 Les bras articulés

Un bras manipulateur est un robot programmable, avec des fonctions similaires à celles d’un bras humain (il est
dit anthropomorphe). Il permet notamment de manipuler des objets. Les différentes parties de ce robot (aussi
appelés corps) sont connectés entre eux par des articulations (ou liaisons mécaniques). Ces liaisons permettent :
soit du mouvement de rotation (articulation rotoïde symbolisée par la lettre R) ou de translation (articulation
prismatique symbolisée par la lettre P). Au bout du bras on fixe généralement un outil (pince, ventouse, fer
à souder...). Ils sont utilisés pour effectuer une grande variété de tâches répétitives avec vitesse et précision.
Dans le domaine de l’industrie ils permettent de réaliser du perçage, du vissage, du soudage, de la peinture,
de l’assemblage, de l’encollage ou bien l’empaquetage. Ils sont très présents dans les industries du bâtiment, de
l’aéronautique, de l’automobile et de la logistique. L’utilisation de robots dans l’industrie permet en général de
réduire les délais de fabrication, d’améliorer la qualité et la traçabilité des produits, d’augmenter la sécurité au
travail en remplaçant les hommes pour les taches simples mais très répétitives.
Différents types de robot articulés

Parmi les bras robots anthropomorphes différents types peuvent être distinguer en fonction de leur structure
mécanique et du type des axes. Les principales configurations des bras articulés industriels à chaîne cinématique
ouvert sont :
— structure cartésienne (ou robot portique) = PPP
— structure cylindrique = RPP,
— structure SCARA (bi-cylindrique) = RRP,
— structure sphérique = RRP,
— structure bi-sphérique = RRR.
Pour rendre le robot plus agile, on augmente le nombre de degrés de liberté du bras. Le nombre de degrés de
liberté d’une chaîne cinématique correspond aux nombres de paramètres nécessaires pour décrire complètement
une configuration de la chaîne. D’une manière générale, la redondance augmente la dextérité du robot. Un robot
est dit redondant lorsque le nombre de degrés de liberté de l’outil est inférieur au nombre d’articulations. Ce
genre de robot a donc plus d’actionneurs que nécessaire.
Contrôle des mouvements d’un bras industriel

Un bras robotisé est donc constitué d’une chaîne de corps reliés par des articulations. Chaque articulation
doit être contrôlée pour faire un déplacement. Le contrôle du mouvement de chaque articulation se fait dans
l’espace articulaire par contre le contrôle de la position de l’outil peut se faire dans deux espaces : dans l’espace
articulaire ou dans l’espace cartésien. La destination de l’outil peut donc être envoyé soit sous forme articulaire
dans ce cas la position contient la position de chaque articulation, soit sous forme cartésienne et dans ce la
position contient la position et l’orientation de l’outil. Dans ce second qui est le plus commun, il faut donc avant
d’effectuer le mouvement calculer les mouvements des différentes articulations. Pour calculer la trajectoire vers
un point cartésien et contrôler le mouvement le long de cette trajectoire, différents modèles mathématiques sont
nécessaires :
8
CHAPITRE 3. PROGRAMMATION DES ROBOTS INDUSTRIELS 9
— les modèles de transformation entre l’espace opérationnel (dans lequel est définie la situation de l’outil) et
l’espace articulaire (dans lequel est définie la configuration du robot). Parmi ces modèles, on distingue :
+ les modèles géométriques direct et inverse qui expriment la situation de l’outil en fonction des variables
articulaires du mécanisme et inversement,
+ les modèles cinématiques direct et inverse qui expriment la vitesse de l’outil en fonction des vitesses
articulaires et inversement.
— les modèles dynamiques définissant les équations du mouvement du robot, qui permettent d’établir les
relations entre les couples ou forces exercés par les actionneurs et les positions, vitesses et accélérations
des articulations.
La trajectoire et les positions articulaires du robot le long de la trajectoire seront calculées à partir des modèles
géométriques, le déplacement du robot incluant les vitesses de déplacement à partir du modèle cinématique et
le contrôle du robot prenant en compte les forces par le modèle dynamique.
3.2 Les modèles pour le contrôle des bras articulés

Modèle géométrique et planification de trajectoire articulaire
Comme on l’a vu précédemment, le but principal de la programmation va être de préparer une
séquence de mouvement permettant de réaliser une tâche. Pour déterminer si un mouvement est réa-
lisable ou non et si oui pour déterminer comment le réaliser il faut utiliser le modèle géométrique. Grâce au
modèle géométrique on va pouvoir étudier tous les mouvements possibles du robot à partir de ses contraintes
mécaniques (longueur des corps, limites de déplacement de chaque articulation). A noter que ce modèle ne prend
pas en compte les vitesses de déplacement et les forces qui causent ces mouvements (qui seront pris en compte
grâce aux modèles cinématiques et dynamiques). On distingue les modèles géométriques direct et inverse. Le
modèle géométrique direct permet de calculer en fonction des positions de chaque articulation la pose 3D ré-
sultante de l’outil. Dans ce cas, il n’y a qu’une seule solution : si les articulations sont réglées sur une position
particulière, l’outil finira toujours dans la même position.
Avec le modèle géométrique inverse, il s’agit de calculer les équations inverses nécessaires pour positionner l’outil
à une position particulière dans l’espace de travail. Ce modèle permet de répondre à la question suivante :
dans quelles positions dois-je régler les articulations du robot pour déplacer l’outil dans une position donnée ?
Cependant, les choses ne sont pas si simples. Contrairement au modèle géométrique direct, la plupart des robots
avec plus de deux actionneurs auront de multiples solutions possibles. La géométrie inverse est compliquée à
résoudre car il y a un grand nombre de solutions possibles pour les chaînes cinématiques complexes. Un robot
1R (par exemple un axe fixé à un moteur) n’aura qu’une seule solution cinématique inverse possible pour décrire
la position du point final. Un robot 2R (par exemple une chaîne de 2 axes avec un moteur chacun) aura deux
solutions possibles pour décrire la même position du point final. Chaque articulation ajoutera plus de complexité
à la géométrie inverse et plus de solutions possibles au choix. Lorsque l’on cherche à résoudre le problème inverse
on a plusieurs possibilités :
— absence de solution lorsque la situation désirée est en dehors de la zone accessible du robot. Celle-ci est
limitée par le nombre de degrés de liberté, les débattements articulaires et la dimension des segments ;
— infinité de solutions lorsque : - le robot est redondant vis-à-vis de la tâche ; - le robot se trouve dans
certaines configurations singulières ;
— solutions en nombre fini, exprimées par un ensemble de solution. On dit dans ce cas que le robot ma-
nipulateur est résoluble. Il est possible de calculer toutes les configurations permettant d’atteindre une
situation donnée. Aujourd’hui, tous les manipulateurs série ayant jusqu’à 6 degrés de liberté et qui ne sont
pas redondants peuvent être considérés comme résolubles.
Cas des positions singulières
Quelque soit le robot (redondant ou non), il se peut que sur certaines trajectoires, le robot passe par des
configurations dites singulières c’est à dire que 2 axes d’articulations prismatiques se retrouvent parallèles
ou deux axes d’articulations rotoïdes se retrouvent confondues. Une singularité est donc définie comme "un
problème causé par l’alignement colinéaire de deux ou plusieurs axes du robot, ce qui peut entraîner sur un tout
petit mouvement, des déplacements articulaires très grand et donc des vitesses imprévisibles du robot". Les
singularités des robots se produisent parce que les robots sont contrôlés par les mathématiques (ou des résultats
égaux à l’infini sont possibles), mais dans le monde réel, les robots sont faits de mobiles physiques qui ont des
limites de vitesse. Si une équation commande à une articulation de robot de "tourner de 180 degrés à une vitesse
angulaire infinie", l’articulation du robot ne pourra effectuer le mouvement. Dans ce cas le contrôleur affichera
un message d’erreur. Il faudra déplacer un peu le point de destination pour sortir de cette position particulière
qui pose problème.
Modèle cinématiques et dynamiques et exécution du mouvement

Lorsque qu’une trajectoire articulaire a été trouvé on peut utiliser les modèles cinématiques et dynamiques pour
contrôler les vitesses des articulations sur la trajectoire.
3.3 De l’importance des repères

Environnement et repère fixe
Dans nos exemples, nous nous concentrerons sur la manipulation de pièces à partir de bras articulés. Avant
d’attraper une pièce il faut la localiser dans l’environnement du robot c’est à dire dans un repère fixe global.
Pour les bras manipulateurs, ce repère global est généralement appelé "repère world". Il est situé au centre de
la première articulation du bras articulé. La première articulation est l’articulation la plus éloignée de l’outil.
Ce repère est orienté de la façon suivante : l’axe X vers l’avant du robot, l’axe Y vers la droite et l’axe Z vers
le haut. Dans ce repère, une pièce (voir Figure 3.1) est localisée en 3 dimensions par 6 paramètres (3 pour la
position et 3 pour l’orientation). La position est décrite par 3 valeurs qui représentent le déplacement du centre
de masse de l’objet par rapport au centre du repère. L’orientation est relative et est décrite par rapport à une
orientation de référence par 3 valeurs. Les trois valeurs d’orientations sont appelées angle d’Euler. La rotation
autour de l’axe X : le lacet (yaw), la rotation autour de l’axe Y : le tangage (pitch), la rotation autour de l’axe
Z : le roulis (roll). On appelle les coordonnées dans le repère world les coordonnées opérationnelles.
Figure 3.1: Les repères liés au robot (repère world et repère outil) et le repère lié à l’objet.
Déplacement du bras et repère outil

On désire attraper une pièce avec un bras robotisé. Dans ce cas, on veut déplacer l’outil jusqu’à la pièce pour
ensuite l’attraper. En Staubli, chaque objet est lui aussi équipé d’un repère (voir Fig. 3.1) dit repère de prise.
Ce repère de prise indique la position et l’orientation que l’on a décidé pour la prise de l’objet. Ce repère est
donc considéré comme la destination de l’outil avant la prise de la pièce. L’outil est lui aussi représenté par
un repère situé au bout de l’outil (voir figure 3.1). Pour attraper l’objet il suffit donc de déplacer le repère
outil à la position du repère de prise. Pour cela, un programme va calculer un ensemble de mouvements pour
les différents corps constituant le robot. Une position du robot associée à la position de ses différents corps
est appelée coordonnées articulaires. Cette partie est transparente pour l’utilisateur en robotique industrielle
puisque les fabricants de robots fournissent avec le robot une librairie de contrôle des mouvements. Lorsque
l’on commande un déplacement, on a juste besoin d’envoyer au robot la destination et il se chargera du reste.
A noter que le déplacement vers la point de prise se fait de manière à aligner en fin de mouvement calcule la
trajectoire entre le repère outil et le repère objet. Ensuite la librairie contrôle le mouvement le long de cette
trajectoire jusqu’à ce que ces deux repères se retrouvent superposés.
3.4 Programmation d’un robot industriel

Le rôle du programme robotique est de contrôler l’exécution de la tâche. Un programme de manipulation de
pièces contient donc la séquence de mouvements unitaires qui s’enchaîne les uns après les autres. Par mouvement
unitaire, on sous-entend ici une action simple de déplacement point à point du bras ou bien changement de
l’état de l’outil (fermeture ou ouverture de la pince par exemple). Dans notre cas, ou la perception n’est pas
prise en compte, la trajectoire du bras robotisé d’un point vers un autre en 3 dimensions se fait "au plus court".
Ce calcul prend en compte la position actuelle du robot et ses capacités de mouvements. Ensuite le robot
estime et contrôle le bon déroulement de la trajectoire qui sera suivi pour ce déplacement entre les deux points.
L’utilisateur n’a donc pas la main sur la trajectoire du robot. Pour effectuer une trajectoire complexe il faut
considérer des points de passage. A noter que sur le type de robot industriel que nous utiliserons, la collision
du bras avec un obstacle entraîne un arrêt d’urgence du système nécessitant le redémarrage manuel par un
opérateur humain. Lorsque qu’un déplacement est impossible (point non atteignable) le robot ne se déplace pas
et renvoie une erreur qui nécessite aussi un redémarrage manuel du robot.
3.5 Décomposition de la trajectoire en une séquence de mouvements

Le but de la programmation va être de préparer une séquence de mouvement permettant de
réaliser la tâche. A compléter.
3.6 Deux types de programmation

Programmation par apprentissage
La programmation par apprentissage consiste à enregistrer les points et/ou les trajectoires à suivre directement
en télé-opérant le robot, L’opérateur pilote le robot en mode manuel à l’aide du teach. Il écrit le code sur le
teach et enregistre des points 3D au fur et à mesure du déplacement du robot.
Programmation hors ligne

Une autre manière de programmer un robot est d’utiliser la programmation hors ligne. Cela consiste à pro-
grammer les mouvements du robot en simulation (CAO robotique) et, une fois cette étape terminée, à charger
le programme sur le robot réel. Cette méthode est privilégiée dès que les tâches à programmer sont complexes.
En général puisque la position des objets par rapport au robot dans l’environnement simulé ne correspond pas
exactement à la situation réelle les points de référence doivent être repris sur le robot réel lors de la première
exécution.
3.7 Un exemple simple de manipulation d’une seule pièce

En supposant que le robot parte d’une position initiale connue et que l’ensemble des points soient accessibles
pour le robot. Sur la figure 3.2, on présente un exemple de prise et dépose d’un objet. On prendra l’objet en P3
pour ensuite l’emmener en P5.
Début du programme
1. Déplacer vers P1 (point de départ)
2. Déplacer vers P2 (point de dégagement)
3. Déplacer vers P3 (point de prise)
4. Fermer la pince
5. Déplacer vers P2 (point d’approche du point de prise)
6. Déplacer vers P4 (point d’approche du point de dépose)
7. Déplacer vers P5 (point de dépose)
Haute vitesse
Faible vitesse
P1
P2 P4
P3
P5
Figure 3.2: Décomposition des mouvements pour la prise et la dépose d’une pièce.
8. Ouvrir la pince
9. Déplacer vers P4 (point de dégagement)
10. Déplacer vers P1
Fin du programme
On voit dans cet exemple une tâche simple qui consiste à prendre un objet cubique (en P3) puis le déposer (en
P5). Cette tâche nécessite 10 étapes et ne fonctionnera qu’avec le type d’objet pour lequel elle a été programmée.
Le robot ne sera capable de prendre l’objet que s’il est exactement à la place prévue dans le programme. A noter
également que les points d’approches (P2 et P4) sont très importants pour forcer le robot à arriver sur l’objet
par le haut et ne pas heurter et déplacer l’objet lors de la phase d’approche. On peut comprendre aisément que
pour que le robot soit plus autonome et soit capable de prendre l’objet quelle que soit sa position il faudrait
faire intervenir un système de vision qui donnerait au robot la position de l’objet.
Figure 3.3: Les bras robotisés Staubli.
3.8 Les bras robotisés Staubli

Un bras robotisé Staubli est composé de 4 éléments (voir Fig. 3.4) :
— Le bras articulé lui-même,
— Le contrôleur,
— La télécommande (ou teach),
— Un outil placé au bout du bras,
Figure 3.4: Le bras robotisé, le contrôleur, le teach (ou télécommande) ; et l’outil (pince ou ventouse).
Le bras articulé est l’élément mécanique qui sera en mouvement qui est caractérisé par son nombre de degré
de liberté. Le contrôleur est le cerveau du robot, il permet de piloter les mouvements. Il est composé d’un
calculateur et d’un boitier de puissance. La télécommande permet de téléguider le robot ou bien d’écrire lancer
des programmes. L’outil quant à lui est attaché au bout du bras robotisé et est dédié à la tâche que le robot va
exécuter. Les robots sont en général vendus sans outil, c’est à l’utilisateur d’équiper son robot avec l’outil de
son choix.
Figure 3.5: Ecran de démarrage de SRS
3.9 L’environnement de simulation SRS

En général le code n’est pas écrit directement sur le teach, il est écrit sur un ordinateur connecté en réseau avec
le robot. SRS ou Staubli Robotic Suite est une suite logicielle permettant le développement et la maintenance
d’applications robotiques. SRS permet :
— de modéliser une cellule robotisée avec tous ses éléments : robots, outils, objets, obstacles (l’outil de
modélisation permet également d’importer des modèles CAO),
Figure 3.6: Exemple d’environnement simulé
— de simuler en 3D les mouvements du bras dans des tâches de prise et dépôt d’objets. Ce mode simulé
utilise les librairies de planification de trajectoire et de contrôle basé sur les modèles du robot réel. Le code
simulé est donc fonctionnel sur le robot. A noter que le simulateur permet aussi de prendre en compte les
collisions avec l’environnement,
— d’écrire et vérifier le code avec des outils tel que : un débuggeur, une assistance à la saisie, un formatage
automatique du code,
— de transférer le code du PC vers le robot ou bien du robot vers le PC,
Dans SRS, les programmes sont écrits dans un langage propriétaire appelé VAL3. Le programme VAL3 utilise
le contrôleur du robot réel. A la fin de la simulation il suffit juste de transférer le code simulé sur un robot réel
pour ensuite l’exécuter.
Chapitre 4
Le langage VAL3 et la programmation des

robots Staubli.
4.1 Elément de langage

VAL3 est un langage de programmation proche du C/C++. Il est dédié à la programmation robotique. Un
programme VAL3 est composé au minimum de deux fonctions : une fonction appelée start et une fonction
appelée stop. L’utilisateur peut ensuite créer autant de fonctions qu’il le souhaite.
Fonction start() and stop()

Les fonctions start et stop sont créées automatiquement lors de la création d’une application VAL3. Elles sont
aussi appelées automatiquement lors du démarrage et lors de l’arrêt de l’application. La fonction start doit
contenir le programme principal et l’initialisation des variables globales. La fonction stop doit contenir les
instructions permettant de quitter le programme proprement.
Fonctions et paramètres
L’appel à des sous fonctions se fait via le mot-clé call suivi du nom de la fonction.
Exemple : call triTableau(Tab).
Dans ce cas, le paramètre Tab est passé par valeur il ne peut être modifier dans la fonction triTableau Cependant,
les paramètres peuvent aussi être envoyé à la fonction par référence comme en C. L’envoie d’un paramètre par
référence permet dans ce cas de modifier la valeur de la variable dans la fonction. Une référence est notée du
symbole & après le type de données dans la définition de la fonction. Pour finir, les fonctions ne renvoient rien
en VAL3 mais le mot clé return peut être utilisé pour sortir directement d’une fonction.
Commentaires et affichage d’une variable ou du texte

Une ligne est en commentaire si elle commence par un // comme en C. L’équivalent du printf est la fonction
putln qui permet d’afficher du texte ou bien la valeur d’une variable dans la console d’affichage.
Exemple : putln("bonjour") ou bien putln(n).
Un commentaire ne doit pas être sur une ligne de code.
On ne peut pas commenter un bloc comme en C avec /* */.
Types de données en VAL3.

Les types simples sont les suivants :
— Type bool : pour les valeurs booléennes,
— Type num : pour les nombres entiers ou nombres à virgules flottantes,
— Type string : pour les chaînes de caractères,
Les types structurés sont les suivants (équivalent des structures C ou des classes C++) :
— Type joint (6 éléments sur un TX40) : pour les valeurs des articulations (coordonnée articulaire)
— Type point (6 éléments) : pour une position et orientation en 3D (coordonnée opérationnelle)
15
CHAPITRE 4. LE LANGAGE VAL3 ET LA PROGRAMMATION DES ROBOTS STAUBLI. 16
— Type trsf (6 éléments) : pour une transformation géométrique (translation et rotation)

— Type mdesc : pour décrire un mouvement (vitesse, accélération...),
Quelques exemples :
A=true
//A est un booléen
Pi=3.14159
// Pi est un num
s="Bonjour"
//s est une chaîne de caractère
P1=[100 100 100 0 0 0]
//P1 est de type \textit{point} en VAL3. P1 a 6 coordonnées car c’est un point 3D
//Il est défini à la fois par une position 3D (x y z) et une orientation dans l’espace
//(rx, ry rz).
J1=[50 90 50 0 0 0]
//J1 est de type \textit{joint} en VAL3. J1 a 6 valeurs correspondant au 6 positions
//angulaires des 6 articulations qui compose le robot.
Pour modifier un attribut d’une classe ou d’une structure on utilise le "." comme en C. Par exemple pour
modifier l’attribut "x" d’une variable de type "point" on écrit :
P1.trsf.x=0 (mise à zéro du x de P1)
ou
P1.trsf.x=P1.trsf.x+100 (ajout de 100 au x de P1)
Les boucles et structures de contrôle

La boucle for s’écrit de la manière suivante :
for i = 1 to 10
...
endFor
La boucle while s’écrit comme ceci :
i=0
while (i<10)
...
i=i+1
endWhile
La boucle do until s’écrit comme ceci :

i=0
do
i=i+1
...
until (i==10)
Le contrôle if s’écrit de la manière suivante :
if (i<10)
...
else
...
endIf
Enfin le contrôle case s’écrit comme ceci :
switch i
case 0
...
break
case 1
...
break
case 2
...
break
endSwitch
4.2 Contrôle du robot

Fonctions de mouvements
Trois fonctions existent pour déplacer le bras du robot : movej pour les mouvements point à point généraux, le
movel pour les mouvements en ligne droite et movec pour les mouvements circulaires. Le movej est la fonction
à utiliser en priorité, elle est optimisée pour enchaîner les mouvements de manière rapide. Elle peut recevoir une
position finale définie dans l’espace articulaire (type joint) ou une position finale définie dans l’espace cartésien
(type point). Par exemple pour un mouvement dans l’espace articulaire, on envoie à cette fonction les 6 positions
des 6 articulations du robot (J1, J2, J3 et J4, J5, J6 pour un robot 6 axes). Pour un mouvement vers un point
cartésien (3D) on envoie à la fonction directement les 6 coordonnées du point d’arrivée de l’outil défini dans
le repère world (x, y, z et rx, ry, rz ). Dans tous les cas, le robot part de la position courante du bras pour
finir dans la position envoyée en paramètre. La trajectoire est calculée au plus court sans éviter les obstacles
sur le parcours. Dans un mouvement point à point, seule la position finale est importante. Entre le point de
départ et d’arrivée, le centre outil suit une courbe définie par le système de manière à optimiser la vitesse de
mouvement. Au contraire le mouvement en ligne droite (fonction movel ) et le mouvement circulaire (fonction
movec) forcent le déplacement du centre outil sur une ligne droite ou sur un cercle. Ces deux fonctions sont
utilisées dans les situations où l’on désire connaître à l’avance la trajectoire du robot. Par exemple, on utilise
généralement préférentiellement movel pour les actions précédant la prise et le dépôt de pièces. Par exemple,
suivant la Fig. 3.2 l’appel à la fonction movej(P2,tool,vitessse) emmènera le robot en P2 quelle que soit sa
position. Le paramètre tool est utilisé pour définir le repère que l’on déplace ici celui de l’outil et le paramètre
vitesse permet de définir la vitesse du mouvement.
Anticipation du mouvement et lissage

Le système de contrôle du robot commande le bras pour effectuer les différents mouvements du robot mais il
anticipe les déplacements suivants. Du coup il lisse la trajectoire pour accélérer la vitesse d’exécution (si on utilise
un robot industriel on veut donc que la tâche soit effectuée le plus rapidement possible). Par exemple si l’on
enchaîne un movej entre P1 et P2 puis un movej entre P2 et P3 le bras robotisé ne passera pas obligatoirement
par le point P2, il pourra passer par un point proche de P2. Pour s’assurer lorsque c’est nécessaire de passer
précisément par des points de passage il est nécessaire d’utiliser des commandes qui forcent la fin complète du
mouvement avant d’enchaîner le suivant (ou annule le lissage). Par exemple la fonction WaitEndMove() permet
de faire cela au prix d’une exécution un peu plus lente de la tâche. L’appel des fonctions liées à l’outil que nous
verrons dans la section suivante forcent elles aussi la fin du mouvement précédent.
Gestion de l’outil et phase d’approche et de dégagement

Pour utiliser un outil (pince ou ventouse) c’est-à-dire prendre un objet ou le relâcher, on utilise les fonctions
open(tool) et close(tool). Par contre, bien que le robot soit forcé à finir son déplacement avant l’exécution de
open ou close, il faut tout de même s’assurer que la trajectoire ne traverse l’objet ou un obstacle en allant
prendre ou déposer l’objet. En effet, la méthode de calcul de la trajectoire du robot suppose qu’il n’y a pas
d’obstacle sur la trajectoire. Donc pour éviter d’avoir ce problème de collision avec l’objet que l’on veut prendre
ou que l’on vient de déposer il faut anticiper la phase d’approche et la phase de dégagement. En bref, on force
le robot à passer par un point de passage au-dessus de l’objet si on vient attraper l’objet par le haut. Pour cela
nous disposons de la fonction appro qui permet de définir un point d’approche ou de dégagement directement
par rapport au point de prise ou de dépose. Cette fonction renvoie un point modifié par un transformation
géométrique de type trsf. Par exemple : P2=appro(P3,{0,0,-100,0,0,0}). P2 est donc situé 100mm au-dessus de
P3. Le vecteur {0,0,-100,0,0,0} est de type trsf.
Exemple d’enchaînement de mouvements

Cette suite de mouvement correspond à la Fig. 3.2. Avec pPrise=P3 et pDepose=P5, et translationZ une trsf
avec pour valeur 0 0 -100 0 0 0.
begin
//Se positionner en position initiale
movej(jOrigin,pince,rapide)
//Se déplacer vers l’objet
movej(appro(pPrise,translationZ),pince,rapide)
open(pince)
movel(pPrise,pince,lent)
//prendre l’objet
close(pince)
movel(appro(pPrise,translationZ),pince,lent)
//se déplacer
movej(appro(pDepose,translationZ),pince,rapide)
movel(pDepose,pince,lent)
//déposer l’objet
open(pince)
movel(appro(pDepose,translationZ),pince,lent)
//retour à l’origine
movej(jOrigin,pince,rapide)
//en raison du problème d’anticipation du robot le code doit se terminer par WaitEndMove().
WaitEndMove()
end
4.3 Communication robot/caméra

Le standard TCP/IP est l’ensemble des protocoles utilisés pour le transfert des données sur Internet. Il est
appelé TCP/IP, d’après le nom de ses deux premiers protocoles : TCP (Transmission Control Protocol) et IP
(Internet Protocol). Les données sont envoyées par paquet ou trame. Chaque paquet ou trame sur termine par
un caractère spécial spécifiant la fin de la chaîne à envoyer.
Le protocole TCP/IP est conçu de manière à ce que chaque ordinateur ou périphérique d’un réseau ait une
adresse IP unique (adresse de protocole Internet) et que chaque adresse IP puisse communiquer sur plus de 65535
ports différents pour l’envoi et la réception de données. L’adresse IP identifie de manière unique l’ordinateur ou
le périphérique sur le réseau et un numéro de port identifie une connexion spécifique entre un ordinateur ou un
périphérique et un autre (c’est-à-dire entre deux adresses IP).
Les connexions TCP/IP fonctionnent de manière similaire à un appel téléphonique dans lequel une personne
doit établir la connexion en composant le numéro. À l’autre extrémité de la connexion, une personne doit
écouter les appels, puis décrocher la ligne lorsqu’un appel arrive. Le "client" dans une connexion TCP/IP est
l’ordinateur ou le périphérique qui se connecte à l’autre (dans notre cas la caméra par exemple) et le "serveur"
est l’ordinateur qui attend une connexion (dans notre cas le robot). En d’autres termes, le client doit connaître
l’adresse IP et le port du serveur sur lequel il souhaite se connecter. Le serveur doit uniquement écouter les
connexions sur le port en question et les initier ou les conclure.
Une fois qu’une connexion TCP/IP sur un port spécifique a été établie entre un client et un serveur, les données
peuvent être envoyées dans les deux sens. La connexion entre un client et un serveur reste ouverte jusqu’à ce que
le client ou le serveur mette fin à la connexion. Un avantage extrêmement intéressant du protocole TCP/IP est
qu’il y a une vérification des erreurs sur toutes les données afin que vous soyez assuré qu’il n’y aura pas d’erreur
dans la transmission des données. Le couple (192.168.0.70 :3000, 192.168.0.101 :100) est appelé un socket. Un
socket identifie de façon unique une communication entre deux logiciels. En VAL3 un type dédié appelé sio
(entrées-sorties sur liaison série et socket TCP/IP) permet de récupérer sous forme d’une chaîne de caractère un
paquet envoyée sur le réseau. Cette donnée de type sio est liée à un socket qui doit être crée avant la création
de la variable.
Chapitre 5
Travaux dirigés
5.1 Ex 1 : Exemple d’utilisation des fonctions de mouvement

Il existe deux fonctions de mouvements en VAL3 : movej et movel. Ces fonctions peuvent prendre deux types
de paramètres pour la position de destination (jointrx et pointrx ).
— Q1. Peut-on déplacer le robot en 0 0 0 0 0 0 de type jointrx ?

— Q2. Peut-on déplacer le robot en 0 0 0 0 0 0 de type pointrx ?
— Q3. Dans quels cas utilisent-on les déplacements vers des jointrx ?
Etudier les deux exemples suivants.
Cas 1. Cas 2.
begin begin
movej(P2,pince,rapide) movej(P2,pince,rapide)
close(pince) movel(P3,pince,lent)
movej(P3,pince,rapide) close(pince)
open(pince) movel(P2,pince,lent)
movej(P1,pince,rapide) movej(P4,pince,rapide)
end movel(P5,pince,lent)
open(pince)
movel(P4,pince,lent)
movej(P1,pince,rapide)
end
P1
P2 P3
Figure 5.1: Cas 1 : Mouvement d’une pièce en 3 étapes. Cas 2 : Mouvement prenant en 7 étapes.
— Q4. A quoi sert le passage par un point intermédiaire dans le cas 2 ?

— Q5. Quand peut-on utiliser le cas 1 ?
19
CHAPITRE 5. TRAVAUX DIRIGÉS 20
5.2 Ex 2 : Dépilement
On suppose maintenant que l’on a plusieurs pièces empilées les unes sur les autres comme sur la Fig. 5.2.
P1
P2
P3
Figure 5.2: Mouvements de 5 pièces.
— Q1. En se basant sur l’exemple de code précédent (cas 1), écrire un programme qui récupère 5 pièces
cubiques (de côté 100) sur une pile en P2 et qui dépose ces pièces en ligne à partir du point P3. Les pièces
doivent être empilées au départ et alignées sur la table à la fin de l’exercice. On rappelle que le structure
point qui définit P1, P2 et P3 contient 1 champ trsf qui contient lui-même 6 champs : x y z rx ry rz. On
modifie donc un point par le code suivant :
P1.x=P1.x+100
— Q2. Pour être sûr que le robot ne percute pas les pièces en se déplaçant. On appliquera pour chaque
déplacement d’une pièce le code suivant correspondant à la Fig. 5.1.b (cas 2). On définira un point situé
au-dessus d’un autre par rapport à celui-ci en faisant appel à la fonction appro. Réécrire le code demandé
dans l’exercice 1 en utilisant les movej, movel, et appro. Dans le code les point P2 et P4 ne doivent donc
plus exister.
Exemple d’utilisation de appro : appro(P,0,0,-100,0,0,0)) renvoie le point situé à 100mm au-dessus de P.
— Q3. Sachant que ce code de déplacement va être utilisé à plusieurs reprise. Ecrire une fonction qui prend
en paramètre un point P1 et un point P3 et qui déplace un objet.
— Q4. Reprendre la Q1 de l’exercice 1 et écrire une fonction qui calcule les points de prise et de pose puis
appelle la fonction précédente.
5.3 Ex 3 : Palettisation
On suppose que l’on a une pile de 9 cubes et que l’on veut ranger ces cubes sur une palette en 3x3.
Figure 5.3: gauche. position de départ. droite. position finale.
— Q1. Ecrire un code qui place les 9 cubes sur une palette comme sur la Fig. 5.3. Ce code réutilisera la
fonction déplacement créée dans l’exercice précédent.
CHAPITRE 5. TRAVAUX DIRIGÉS 21
— Q2. Modifier ce code pour que le robot se déplace plus doucement avant la prise et la dépose de la pièce.
— Q3. Forcer le robot à partir d’une position initiale de type jointrx et à finir aussi sur cette position initiale.
5.4 Ex 4 : Communication avec une caméra
Figure 5.4: Image obtenue à l’aide d’une caméra.
Une caméra est placée à 1 mètre au-dessus d’un objet à déplacer. Par traitement d’image on suppose qu’on est
capable de calculer la position du centre de gravité de l’objet dans l’image par rapport au point P (voir Fig. 5.4).
Le système de vision envoie cette information de position dans une trame TCP. La chaîne de caractères (par
exemple 123,018 !) est reçue par le robot et on suppose que le caractère de séparation est le caractère virgule
et le point d’exclamation le caractère de fin de chaîne (on a donc 123 pixels en colonne et 18 pixels en ligne).
On suppose aussi que la position en pixel envoyée par le traitement d’image est codée sur maximum 3 caractères.
— Q2. Ecrire une fonction qui reçoit la chaîne de caractère en paramètre et met à jour deux variables entières
x et y qui code la position de l’objet comme par exemple : x = 123 et y = 18.
— Q3. Compléter la fonction pour obtenir la position du jeton dans le repère du robot. On suppose que le
point P est connu.
Ex 5 : Les tours de Hanoï (exercice supplémentaire)

Pour le TP4, nous allons faire une implémentation robotique du problème des tours de Hanoï.
— Q1. Lire la définition du problème et en particulier l’étape 12 du TP 4.
— Q2. Nous vous donnons la fonction qui calcule automatiquement les déplacements à faire. Ecrire la fonction
qui calcule au fur et à mesure le nombre de disque par pile. Le nombre de disque par pile étant nécessaire
pour savoir à quelle hauteur il faut fermer ou ouvrir la pince.
— Q3. Ecrire une deuxième fonction qui affiche l’état complet du jeu au fur et à mesure des mouvements de
disques.
Chapitre 6
Travaux pratiques
Les Tps peuvent se faire seul ou en binôme. Les Tps se développé sous SRS (Staubli Robotiques Suite), une
suite logicielle sous licence Staubli permettant le développement et la maintenance d’applications robotiques
dédiées aux robots de la marque Staubli. Vous devrez faire valider votre code de simulation pour chaque TP
par l’enseignant présent. La durée de chaque TP est seulement donnée à titre indicatif, passez au TP suivant
lorsque vous avez terminé et fait valider.
6.1 Présentation des Tps

Les Tps de robotique seront décomposés comme suite :
— TP1 : Prise en main de SRS (3h)
— TP2 : Dépilement et rangement (3h)
— TP3 : Tri de pièces respectant un modèle utilisateur (3h)
— TP4 : Résolution du problème des Tours de Hanoï (3h)
— TP5 : Prise de pièce localisée par un système de vision (3h)
Pour tous les Tps, on s’efforcera d’utiliser le minimum de point de référence possible. Ceci dans le but d’accélérer
la procédure de prise de point lors du test du code sur le robot réel. Si possible, on définira un point de
référence par exemple la position du premier objet dans le repère world puis tous les autres points seront définis
relativement à celui-ci. Les Tps sont long, pensez à les préparer à l’avance. Lisez aussi le sujet complètement
avant de commencer.
6.2 TP 1. Prise en main de SRS 2016

Le but de ce TP est de manipuler l’environnement de travail SRS. Il est important de bien maîtriser ce TP
puisque qu’il faudra le refaire à chaque fois.
Les étapes à suivre pour construire un environnement de travail.

— Création d’un projet (SRS)
— Test du projet en simulation
— Dessin de l’outil et d’un objet à manipuler
— Configuration de l’outil et test de la prise d’une pièce.
— Exemples d’erreur courantes.
PARTIE 1. Création d’un projet
Étape 1 : Loguez-vous sur le PC (compte : formation, mot de passe : formation). Sur le disque D, dans le dossier
Robotique créez un nouveau dossier à votre nom. Puis dans ce dossier créez un dossier TP1. Pour rappel, dans la
salle B4 il n’y a pas d’accès au réseau pour des raisons de sécurité avec les robots. Vous travaillerez donc en local.
22
CHAPITRE 6. TRAVAUX PRATIQUES 23
Étape 2 : Lancez SRS et cliquez sur l’icône rond Staubli en haut à gauche et cliquez sur "Créer une nouvelle
cellule avec contrôleur".
−→ Nom : MaPremiereApplication. Sauvez l’application dans le dossier que vous avez créé appelé TP1.
Étape 3 : Cliquez sur "Ajouter un contrôleur local".
−→ Laissez le nom Controller1.
Étape 4 : Sélectionnez un robot TX60 avec la fixation sol, la connexion horizontale, voyant et butée.
−→ Ne pas modifier les options du contrôleur local. Cliquez directement sur "Terminer".
−→ En haut de la fenêtre, observez les différents onglets : Accueil, VAL3, Modeleur, Simulation.
Étape 5 : Dans l’onglet "Accueil" cliquez sur "Afficher la vue 3D".

−→ Toujours dans l’onglet "Accueil" cliquez sur "Fenêtres" puis sur "Positions articulaires".
−→ Une nouvelle fenêtre doit s’ouvrir et vous pouvez faire varier les positions de chaque articulation.
−→ Le robot doit se déplacer.
Pour la suite s’il vous manque des fenêtres parce qu’elle ont été fermé, retourner dans Accueil
puis "Général" et vous pourrez retrouver toutes les fenêtres (Cellule, Données, Géométrie, Pro-
priétés...).
Étape 6 : Dans le menu cellule (à droite, voir Fig. 6.2), faites un clic droit sur Controller1 et cliquer sur "Nou-
velle application".
−→ Nom : Depalettisation. Surtout ne rien remplir dans la zone "Destination" ! (voir Fig. 6.1).
Figure 6.1: Création d’une application sous SRS.
Étape 7 : Observez sur la figure 6.2 les différentes fenêtres de SRS.
PARTIE 2. Test du projet en simulation
Étape 8 : Dans le menu "Données" (voir Fig. 6.2) nous allons créer les variables nécessaires à notre programme.
−→ Sous SRS on ne déclare pas les variables dans le code comme en C.

−→ Faites un clic droit sur le nom de l’application puis "Ajouter nouvelle donnée" pour les variables
suivantes :
— rapide (type mdesc), initialiser avec vel = 80.

— jDepart (type JointRx), initialiser avec 6 zéros : 0 0 0 0 0 0.
— jFinal (type JointRx), initialiser avec 90 90 90 0 0 0.
— ventouse (type tool ), initialiser avec des zéros pour l’instant.
Étape 9 : Dans le menu cellule, cliquez sur le fonction start. Une fenêtre va s’ouvrir.
Figure 6.2: Environnement SRS.
−→ Ecrivez le code suivant dans la fonction start. Pour rappel la fonction start est la fonction princi-
pale automatiquement appelée lors du lancement de l’application (la fonction start est équivalent du main en C).
begin
movej(jDepart,ventouse,rapide)
movej(jFinal,ventouse,rapide)
waitEndMove()
end
Pour rappel : La fonction start doit toujours se terminer par waitEndMove().
Étape 10 : Dans l’onglet "VAL3", cliquez sur "Vérifier la syntaxe".
−→ Vous devez obtenir aucune erreur ce qui veut dire que la syntaxe du code est bonne.
Étape 11 : S’il n’y a pas d’erreur, lancer la simulation, sinon lisez la description de l’erreur et corrigez la...
−→ Dans l’onglet "Simulation" (Fig. 6.3.a), cliquez sur le PLAY.

−→ Dans le menu cellule, faites un clic droit sur l’application puis cliquez sur "Démarrer l’application".
−→ Une fenêtre présentée sur la Fig. 6.3.b doit s’ouvrir.
−→ S’il y une erreur... reportez-vous à la partie 5 quelques pages plus loin.
Étape 12 : Dans le simulateur de teach (Fig. 6.3.b) cliquez 3 fois sur le cercle blanc et jaune.
−→ Le logo bleu doit changer. Sélectionnez le carré bleu indique que le mode sélectionné est : automatique.
Étape 13 : Dans le simulateur de teach. Mettre le robot sous tension (rond blanc trait noir) et cliquer sur "move".
−→ Le bras doit se déplacer. Vous avez créé votre première application de robotique !
−→ Si le robot ne bouge pas... reportez-vous à la partie 5 quelques pages plus loin.
PARTIE 3. Dessin de l’outil et d’un objet à manipuler

Figure 6.3: Vue de SRS onglet simulation.
Étape 14 : Nous allons maintenant créer l’outil et un objet dans le simulateur. A l’aide de l’outil de dessin
(onglet Modeleur), créez la ventouse nécessaire à la manipulation d’objet. Elle sera représentée par un cylindre
dans votre cas pour simplifier.
−→ Créez un cylindre jaune (Rayon dessus 20 mm Rayon dessous 20 mm Hauteur 50 mm).
Étape 15 : Lorsque le cylindre a la bonne taille (fenêtre Propriétés), le définir en tant qu’outil (clic droit).
Étape 16 : En mode édition placez le repère handler (côté prise) et le repère handle (côté robot).
−→ Les 2 repères doivent être centrés sur les faces avant et arrière de l’outil et avoir l’axe Z dans le même
sens. L’axe Z doit être parallèle à la longueur du cylindre (voir exemple Fig. 6.4).
Étape 17 : Sortez du mode édition et attachez l’outil au robot (clic droit sur l’outil).
−→ Vérifiez que le repère handler de l’outil est bien placé. Le handler doit correspondre à la figure 6.5.
Étape 18 : Initialisez la donnée outil dans la variable de type tool ventouse avec les données de l’outil. (faites
un clic droit sur le handler de l’outil puis cliquez sur "copier les données de l’outil" et collez dans ventouse).
Étape 19 : Créez un objet avec le modeleur (côté 50 mm) et le définir en tant que nouvelle pièce (clic droit).
−→ Placez son handle comme sur la figure 6.6.
PARTIE 4. Configuration de l’outil et test de la prise d’une pièce
Étape 20 : Placez l’objet dans une bonne position dans la scène. Faites un clic droit sur l’objet et cliquez sur
"Editer la position" (voir Fig. 6.7). Lorsque l’objet est placé, vérifiez que le robot peut l’atteindre en déplaçant
(a) (b)
Figure 6.4: Un dessin du handle et du handler de la ventouse tel qu’ils doivent être. a) handle, b) handler.
Figure 6.5: Un exemple de ventouse complexe attachée au robot.
Figure 6.6: L’objet cubique que l’on va manipuler avec son repère handle.
automatiquement le bras sur l’objet (clic droit sur le handle de l’objet et "Déplacer à".
−→ Si le robot ne se positionne pas sur l’objet avec la partie basse de la ventouse (le hand-
ler ). Faites un clic droit sur handler et cliquez sur définir comme TCP courant.
Étape 21 : Dans les données, créez une donnée pPrise (type PointRx ) puis (clic droit sur votre point de prise)
puis cliquez sur "ici" pour affecter la position courante du robot simulé dans la variable pPrise.
−→ Vous avez fait l’apprentissage d’un point en simulation !.

Figure 6.7: Placement de l’objet et prise de point.
Étape 22 : Ajoutez un movej vers pPrise entre les movej vers jDepart et jFinal. Lancez la simulation.
−→ Le bras doit se déplacer sur l’objet.
Étape 23 : Sauvegardez la position initiale de l’objet dans l’onglet "Simulation". Vous pourrez ainsi le replacer
au point de départ facilement avant la réexécution du code en cliquant sur "ramener l’objet en position initiale"
s’il a été déplacé.
Étape 24 : Dans la fenêtre "Environnement de simulation" faites un clic droit sur tool, et cliquez sur "Configurer
l’équipement" pour définir les fonctions open et close (Fig. ?? et 6.8).
−→ Cliquez sur le "+" de couleur verte (Fig. 6.11).

−→ Sélectionnez "Machine à état Ventouse", Déclencheur Valve 1 sur ON (voir Fig. 6.11).
−→ Pour finir, dans le sous menu handler, sélectionnez le mode magnétique avec distance= 20 mm.
Étape 25 : Ajoutez dans la fonction start un open(ventouse) après le movej vers pPrise. L’objet doit avoir été
attrapé.
−→ Cliquez sur ramener l’objet en position initiale pour pouvoir le reprendre.
Étape 26 : Déplacez manuellement l’objet à une autre position et amenez le robot sur ce point.
Étape 27 : Définissez une variable pDepose (type pointRx ) et cliquez sur "ici" pour enregistrer cette position
du robot.
Étape 28 : Modifiez le code en ajoutant un appel à la fonction : close(ventouse) pour lâcher l’objet.
Étape 29 : Testez votre programme qui prend l’objet et le dépose en un autre point. Faire valider votre simula-
tion par l’enseignant présent.
PARTIE 5. Principaux problèmes sous SRS
Lors de la programmation de vos applications, vous aurez principalement deux types de problèmes :
— des problèmes de compilation qui empêche le fonctionnement de l’application.
— des problèmes de destination impossible lors de l’exécution due à une erreur dans les coordonnées d’un
point 3D à rejoindre.
Figure 6.8: Configuration de l’équipement

Problème de compilation : Sous SRS, la compilation est faite implicitement lors de l’exécution du programme.
Si vous avez un problème de compilation, le programme affichera une erreur comme celle présentée sur la figure
6.9.a. Ce problème provient la plupart du temps d’une erreur de syntaxe :
— nom de variable ou nom de fonction erronés,
— variable ou fonction non déclarée,
— paramètre manquant ou en trop lors de l’appel à une fonction,
— boucle ou structure de contrôle non fermée,
— attribut non existant pour un type donné...
Problème de destination : En VAL3, les fonctions de déplacements movej et movel prennent en paramètres
des jointrx ou pointrx. Dans le cas du pointrx la fonction doit calculer les positions des articulations pour
rejoindre la position de l’outil envoyée en paramètres. Si cette position/orientation n’est pas possible pour le
robot vous obtiendrez l’erreur présentée sur la figure 6.9.b. L’exemple le plus courant est d’envoyée à la fonction
movej une variable de type point non initialisée c’est à dire contenant le point 0 0 0 0 0 0. Ce point étant situé
dans le robot lui-même (au centre du repère world) un déplacement de l’outil à cet endroit est impossible.
Figure 6.9: Les deux erreurs les plus courantes sous SRS.
6.3 TP 2. Dépilement et rangement

On cherchera dans ce premier TP à construire des 9 objets cubiques, à les positionner côte à côte sur une palette
ou bien de prendre 4 objets et de les ranger dans un meuble.
Étape 1 : A partir du TP1, faites un copier-coller la première pièce et construisez une pile de pièce respectant
une distance constante entre les pièces dans le but de pouvoir modifier les points de prise et dépose dans une
boucle (voir Fig. 6.10).
Figure 6.10: Présentation de la position de départ et de la position finale de la simulation
Étape 2 : Créez deux autres variables de type pointrx appelés pPriseTemp et pDéposeTemp. On y affectera la
valeur de pPrise et pDepose au début de la fonction start.
Étape 3 : N’utilisez plus pPrise et pDepose par la suite. Utiliser seulement pPriseTemp et pDeposeTemp que
l’on modifiera pour aller chercher un autre objet de cette manière :
pPriseTemp.trsf.z=pPriseTemp.trsf.z+50
Étape 4 : Complétez ce code de simulation pour prendre 9 objets empilés et les placer sur une palette (voir Fig.
6.10).
Étape 5 : Ajoutez un mdesc lent (vitesse 5) pour les passages par les points d’approche et de dégagement que
nous allons créer par la suite. Dans l’aide cherchez le détail de la fonction appro.
Haute vitesse
Faible vitesse
P1
P2 P4
P3
P5
Figure 6.11: Déplacement à faire pour bouger un objet.
Étape 6 : Modifiez la fonction Mouvement en ajoutant le passage par des points d’approches (voir Fig. 6.11).
Pour passer par le point P2 sans ajouter un niveau point on utilisera la fonction appro comme dans l’exemple
suivant :
movej(appro(P3,{0,0,-100,0,0,0},ventouse,rapide)
movel(P3,ventouse,rapide)
Étape 7 : Faites valider votre code qui palettise 9 objets.
Étape 8 : Modifiez le code pour prendre maintenant 4 objets pour les placer dans un meuble comme sur la figure
6.12.
Figure 6.12: Pile de 4 cubes à côté d’un meuble.
Étape 9 : Faites valider votre code qui range 4 objets dans un meuble.
.
6.4 TP 3. Tri RGB

Le but de ce TP est d’écrire un code de simulation pour prendre 6 objets de couleur placés sur 3 piles distinctes
puis les aligner dans un porte pièce. Nous y apprendrons l’utilisation d’une chaîne de paramètres envoyés par
un utilisateur, et l’importation de modèle CAO.
Étape 1 : Créez un nouveau projet suivant la procédure du TP1.
Figure 6.13: Illustration de la pince et son handler
Étape 2 : Importez le modèle de l’outil pince (voir figure 6.13) et l’attachez au robot.
Étape 3 : Configurez l’outil pince.
Étape 4 : Créez un objet cylindrique (R 30 mm, H 30 mm) et construisez vos piles en les espaçant de 100mm.
Chaque pile d’objet contiendra 3 objets et sera de couleur distincte (Rouge, Vert, Bleu). Voir figure 6.14.
Figure 6.14: Position de départ de la simulation
Étape 5 : Sauvegardez les positions initiales. Faites la prise de point des points de prise et de dépose.
Étape 6 : Créez une nouvelle fonction (clic droit "Ajouter nouveau programme"). Attention juste écrire le
nom de la fonction sans rien spécifier la variable Disk. On appellera cette fonction Deplacer. Copier-
coller le code de manipulation d’un objet du TP précédent (étape 16).
Étape 7 : Modifiez la fonction start en ajoutant :
Début
movej(jDepart,pince,rapide)
call Deplacer(pPrise,pDepose)
movej(jFinal,ventouse,rapide)
waitEndMove()
Fin
Étape 8 : Testez votre prise et dépose d’un seul objet.
Étape 9 : Créez une donnée de type chaîne de caractères (string) qui encode les couleurs demandées.
−→ On l’appellera sChaine et on l’initialisera par "RGBRGB" au début de la fonction start par :

schaine="RGBRGB"
Étape 10 : Afficher le code ASCII de toutes les lettres de la chaîne avec la fonction put pour vérifier votre code.
Le code ASCII des caractères est : R=82, G=71, B=66.
−→ Pour obtenir le code ASCII d’une lettre utilisé la fonction asc. Voir dans l’aide l’utilisation de la
fonction asc.
Étape 11 : En fonction du code ASCII de la lettre de la chaîne mettre à jour le point de prise et en fonction de
l’indice du caractère traité mettre à jour le point de pose.
Étape 12 : Testez la prise et la dépose du premier objet. Modifiez la chaîne de caractère et vérifier que la couleur
de la pièce prise correspond à la couleur demandée dans la chaîne.
Étape 13 : Modifiez le point de dépose après la dépose d’une pièce. Le point de dépose des pièces suivantes sera
espacé de 20mm. Effectuez le déplacement des 6 pièces demandée par l’utilisateur.
Étape 14 : Demandez à l’utilisateur d’entrer la chaîne de caractères en utilisant la fonction get.
−→ Regardez dans l’aide pour obtenir les détails sur la fonction get.
Étape 15 : Testez puis faites valider votre code l’enseignant. Vous devez obtenir un résultat similaire à celui
présenté figure 6.15.
Figure 6.15: Position finale de la simulation

6.5 TP 4. Tours de Hanoï

Le but de ce TP est d’écrire un code de simulation pour résoudre le jeu des tours de Hanoï. Pour rappel ce jeu
consiste à déplacer des disques de diamètres différents d’une tour de départ à une tour d’arrivée en passant par
une tour intermédiaire, et ceci en un minimum de coups, tout en respectant les deux règles suivantes :
— on ne peut déplacer plus d’un disque à la fois ;
— on ne peut placer un disque que sur un autre disque plus grand que lui ou sur un emplacement vide.
On suppose que cette dernière règle est également respectée dans la configuration de départ. On considère dans
notre cas que les 3 tours sont notés 0, 1 et 2 (commencé à 0 est important), et que le nombre de disques est 3
que l’on suppose placés initialement par taille décroissante sur la tour 0. Pour n=3 disques, on peut déplacer la
tour du piquet 0 à l’emplacement 2 en effectuant 7 mouvements comme illustré ci-dessous.
Figure 6.16: Les différentes étapes pour la résolution du problème des tours de Hanoï avec 3 disques.
Ce TP a pour but de vérifier votre maîtrise des points de prise et de dépose. On écrira un code général qui
permet la résolution pour n disques. L’algorithme qui vous est fourni vous donnera directement le nombre de
coup minimum.
Étape 1 : Créez un nouveau projet suivant la procédure du TP1.
Étape 2 : Créez 4 objets cylindriques (R 30-45-60-75 mm, H 50 mm) et construire votre pile de départ sur le
piquet 0.
Figure 6.17: Position initiale de la simulation
Étape 3 : Sauvegardez les positions initiales des disques.

Étape 4 : Créez une ventouse simple (un cylindre), attachez la au robot et configurez la.
Étape 5 : Attrapez puis déposez le premier objet à 100 mm dans la direction de votre choix pour vérifier que la
prise d’objet fonctionne (voir figure 6.17). Le troisième point de dépôt sera placé à 200mm de la première pile
dans la même direction.
Étape 6 : Copiez le code suivant dans la fonction start. Ce code met le robot en position initiale, initialise les
variables et appelle la fonction récursive Hanoï pour 4 disques. La pile de départ étant la pile 0, la pile finale la
pile 2 et la pile intermédiaire la pile 1.
begin
cls()
call Hanoi(3,0,2,1)
waitEndMove()
end
Étape 7 :Créez une nouvelle fonction appelée Hanoï avec les 4 paramètres suivant : num nb, num D, num A,
num I.
−→ Clic droit "Ajouter nouveau programme" pour créer la fonction puis clic droit sur la fonction et
"Ajouter nouveau paramètre" pour créer les paramètres. Attention ! L’ordre des paramètres est très im-
portant ! Pour rappel lors de la création de la fonction ne rien spécifier la variable Disk.
Étape 8 : Copiez le code suivant dans la fonction récursive Hanoï.
begin
if(nb>0)
call Hanoi(nb-1,D,I,A)
call Deplacement(D,A)
call Hanoi(nb-1,I,A,D)
endIf
end
Étape 9 : Créez la fonction Deplacement avec les paramètres suivants : num D, num A.
Étape 10 : Dans la fonction Deplacement, copiez le code suivant :
Début
put(D)
put(A)
put(" ")
Fin
−→ Les éléments affichés le sont dans le menu simulation ou s’affiche aussi les messages d’exécution (par
exemple "mouvement invalide") mais dans la partie utilisateur. Pour obtenir l’affichage utilisateur cliquer sur
le bouton "user". Pour revenir à l’affichage d’erreur d’exécution cliquer sur "menu".
−→ Pour illustration, l’appel à la fonction Hanoi avec les paramètres 3,1,3,2 entraîne les appels récursifs
suivants :
Hanoi(3, 0, 2, 1)
Hanoi(2, 0, 1, 2)
Hanoi(1, 0, 2, 1)
Hanoi(0, 0, 1, 2)
Déplacer 0 vers 2
Hanoi(0, 1, 2, 0)
Déplacer 0 vers 1
Hanoi(1, 2, 1, 0)
Hanoi(0, 2, 0, 1)
Déplacer 2 vers 1
Hanoi(0, 0, 1, 2)
Déplacer 0 vers 2
Hanoi(2, 1, 2, 0)
Hanoi(1, 1, 0, 2)
Hanoi(0, 1, 2, 0)
Déplacer 1 vers 0
Hanoi(0, 2, 0, 1)
Déplacer 1 vers 2
Hanoi(1, 0, 2, 1)
Hanoi(0, 0, 1, 2)
Déplacer 0 vers 2
Hanoi(0, 1, 2, 0)
Vous devez obtenir donc 02 01 ce qui signifie "Déplacement d’un disque de la pile 0 vers la pile 2, déplacement
d’un disque de la pile 0 vers la pile 1..." Cette information permet de savoir au fur et à mesure la colonne ou
l’on prend et la colonne ou l’on dépose le disque. Pour résoudre le jeu en simulation, il nous manque la hauteur
de prise et de dépose.
Étape 11 : Créez un tableau de dimension 3 contenant des num appelé TabHauteur. Ce tableau contiendra le
nombre de disques par pile au fur et à mesure de la résolution du jeu. Dans la fonction start initialiser ce tableau
avec les valeurs suivantes :
TabHauteur[0]=3
TabHauteur[1]=0
TabHauteur[2]=0
Étape 12 : Modifiez le code de la fonction Deplacement de manière à calculer puis afficher le nombre de disque
par pile au fur et mesure que l’on déplacer les disques. On affichera donc le nombres de disque par pile de la
manière suivante :
−→ 300 201 ...
Étape 13 : Le nombre de disque par pile donne une information sur la hauteur de prise. Compléter la fonction
Déplacement pour calculer à chaque étape la valeur du point de prise et du point de dépose.
Étape 14 : Dans cette fonction, faites ensuite appel à une nouvelle fonction Mouvement qui déplace une pièce
en utilisant des movej et movel et des appro. Cette fonction aura 2 paramètres : un pointrx pPriseHanoi et un
pointrx pPoseHanoi.
Étape 15 : Testez votre code. Une étape intermédiaire et l’étape finale sont présentées ci-dessous.
Figure 6.18: Gauche : position intermédiaire de la simulation, Droite : position finale de la simulation
Étape 16 : Faire valider votre code.

6.6 TP 5. Prise de pièce localisée par un système de vision

Le but de ce TP est d’écrire un programme capable d’aller une pièce localisée par un système de vision. On
supposera que la coordonnée Z des objets est toujours la même. A la demande du robot on supposera que la
caméra prendra une image, la traitera et renverra une chaîne de 9 caractères contenant :
— la couleur de la pièce 1 (pour blanc), 0 (pour noir) et 2 pour l’absence de pièce,
— la position en mm suivant l’axe X sur 3 caractères,
— la position en mm suivant l’axe Y sur 3 caractères,
Ces trois données sont séparées par des espaces. Par exemple : 1 238 123 ou 2 000 000 s’il n’y a pas d’objet.
Étape 1 : Créez un nouveau projet SRS et choisir le robot TP80 (n’importe quelle version).
Étape 2 : Créez votre application et faire bouger le robot. Faites ensuite varier les positions cartésiennes pour
vérifier l’espace de travail du robot.
−→ Attention avec le robot TP80 qui est un robot 4 axes, on n’utilisera pas des pointrx ou
jointrx comme sur les robot 6 axes mais des pointrs ou jointrs. Attention également à la faible portée
du robot en Z seulement 50mm.
Étape 3 : Créez une ventouse cylindrique (R 25mm, H 50mm), l’attacher au robot et la configurer.
Étape 4 : Créez 2 pièces (une blanche et une noire) à attraper en simulation (R 25mm, H 10mm). Voir exemple
figure 6.20.
Étape 5 : Créez un pointrs pPriseBlanc (jeton blanc) et pPriseNoir (jeton noir) et faire une prise de point.
Sauvegardez les positions initiales des 2 pièces.
Figure 6.19: Jeton à attraper sur la paillasse.
Étape 6 : Créez 2 pointrs pDeposeBlanc et pDeposeNoir et faire une prise de point.
Étape 7 : Testez la prise de la pièce blanche et sa dépose sur le point de dépose correspondant. Ensuite testez
la prise de la pièce noire et sa dépose sur le point de dépose correspondant.
Étape 8 : Créez une chaine de caractère contenant la couleur de la pièce qui servira à choisir le point de dépose.
−→ Si la chaîne contient le caractère 1 on déposera la pièce à pDeposeBlanc, si elle contient le caractère

0 on déposera la pièce à pDeposeNoir. Pour vérifier la valeur de la pièce on utilisera la fonction asc et la table
ascii en annexe D).
Étape 9 : Créez une variable pointrs pRef qui représente le point P sur la figure 6.19. Déplacez la pièce blanche
et faire la prise de point. Ensuite replacer la pièce blanche à sa place.
−→ Ce point pRef doit être positionné en haut à gauche des deux pièces.
Étape 10 : Créez des variables de type num appelées couleur, xposblanc, yposblanc, xposnoir, yposnoir. Cal-
culez les différences en xposblanc et yposblanc entre pRef et pPriseBlanc, et xposnoir et yposnoir entre pRef
et pPriseNoir. Ces décalages qui seront ajouter à pRef attraper la pièce blanche ou la pièce noire sans utiliser
pPriseBlanc et pPriseNoir.
Étape 11 : Créez des variables de type num appelées couleur, x et y. Créez pour chacun une variable chaîne
de caractère contient chaque valeur. Par exemple, ch1 = [300]. Ensuite écrire une fonction pour extraire leurs
valeurs numériques à partir de la chaîne de caractères de taille 3. Vérifier en affichant les num dans la console.
−→ Pour convertir une suite de caractères numériques en num on utilisera encore la fonction asc auquel
on retranchera 48 (48 étant le code ASCII de zéro).
Étape 12 : Créez une chaîne qui contiendra 9 caractères : la couleur de la pièce, un espace, le décalage en x
sur trois caractères, un espace, et le décalage en y sur 3 caractères pour attraper la pièce blanche à partir de pRef.
−→ Par exemple [1 238 134].
Étape 13 : Mettre à jour une nouvelle variable pPrise en fonction des décalages et une nouvelle variable pDepose
en fonction de la couleur. Vérifier le bon fonctionnement en vérifiant que le programme change la position de
prise et de dépose lorsque la chaîne change. Testez aussi la prise en envoyant la chaîne qui permettra de prendre
le jeton blanc.
Figure 6.20: Prise de pièce en simulation
Étape 14 : Ajoutez une boucle pour répéter ce comportement à l’infini. Testez votre code et le faire valider par
l’enseignant présent.
Etape supplémentaire avec système de vision

Etape 15 : On suppose que la partie traitement d’image sur InSight (Cognex) a été faite. On suppose que l’on
a mis en place ce traitement d’image déclenché par trigger software et qui renvoie la chaîne de caractères pré-
cédemment utilisée en TCP/IP. Le client TCP/IP sera le robot, le serveur sera la caméra et le port 1025.
Étape 16 : Dans la console simulé du robot. Créer un socket TCP/IP, mode client avec l’adresse IP de la caméra,
le caractère de fin de chaîne 13, le délai maximum de 5s.
Étape 17 : Dans les données de l’application créer maintenant une variable de type sio.
Étape 18 : Pour déclencher une prise d’image on va envoyer la chaîne de caractère "snap".
−→ Pour envoyer une donnée chaîne via le socket on fera : nom_sio = chaine_envoyee.
Étape 19 : Récupérer ensuite la chaîne envoyée par la caméra.
−→ Lorsque la caméra enverra une donnée, nous la récupérerons dans une variable de type string en
faisant : chaine_recue = nom_sio.
Étape 20 : Lorsque vous récupérez la chaîne, utilisez la ensuite pour modifier le comportement du robot. Testez
votre code et le faire valider par l’enseignant présent.
Annexe A
Exercices de remise à niveau :

algorithmique et programmation
Ces exercices de TD ont pour but de réviser les notions d’algorithmique nécessaire au bon déroulement des Tps.
Vous devez savoir faire ces exercices avant le début des Tps. Répondez aux questions en pseudo code.
Rappel : Algorithmique et tableaux 1D

Ex 1 : Moyenne et maximum
On dispose du tableau de 16 notes suivant : T= [12 11 8 6 14 9 18 13 12 11 8 10 7 7 16 12].
— Q1. Ecrire une fonction qui parcourt le tableau et affiche les notes,
— Q2. Ecrire une fonction qui calcule et affiche la moyenne,
— Q3. Ecrire une fonction qui calcule la note maximum.
Ex 2 : Moyenne glissante
L’idée de moyenne glissante sur 3 valeurs est de créer à partir d’un signal de taille n, un nouveau signal de
même taille et d’associer à la valeur d’indice i du nouveau tableau, la moyenne des cases i-1 i et i+1 du tableau
initial (avec i allant de 1 à n-1 pour éviter les problèmes aux bords).
On suppose que l’on a un signal numérique représentant un Dirac défini par un vecteur de dimension 19 composé
de zéros partout sauf en position 9. On a donc S=[0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0].
— Q1. Ecrire une fonction qui permet à partir du signal d’entrée de construire une gaussienne comme sur la
figure A.1 avec une moyenne glissante de taille 3.
— Q2. Modifier votre fonction pour avoir une moyenne glissante de taille 5.
— Q3. Modifier votre fonction pour prendre en compte les effets de bords. Pour un élément du bord du
tableau on fera la moyenne sur les éléments existants seulement.
Ex 3 : Tri Bulle
Le tri à bulles ou tri par propagation est un algorithme utilisé pour classer par ordre croissant ou décroissant un
tableau de valeur. Il consiste à comparer répétitivement les éléments consécutifs d’un tableau, et à les permuter
lorsqu’ils sont mal triés. Il doit son nom au fait qu’il déplace à chaque parcours du tableau le plus grand élément
en fin de tableau, comme une bulle d’air qui remonterait à la surface d’un liquide. On répète ce parcours du
tableau tant que des déplacements sont nécessaires. Le tri à bulles est souvent enseigné en tant qu’exemple
d’algorithmique, car son principe est simple. Mais c’est le plus lent des algorithmes de tri, il n’est donc guère
utilisé en pratique.
40
ANNEXE A. EXERCICES DE REMISE À NIVEAU : ALGORITHMIQUE ET PROGRAMMATION 41
Figure A.1: 1 Dirac et 3 gaussiennes.
Ex 4 : Fibonacci
Du point de vue de la programmation, une fonction récursive est une fonction qui s’appelle elle-même dans sa
définition ; on parle également de définition récursive ou d’appel récursif de fonction.
La suite de Fibonacci est définie de la façon suivante :
— F0 = 0
— F1 = 1
— Fn = F (n − 2) + F (n − 1)
C’est une suite d’entiers dans laquelle chaque terme est la somme des deux termes qui le précèdent. Ses premiers
termes sont :
0, 1, 1, 2, 3, 5, 8, 13, 21...
— Q1. Ecrire un programme en C qui calcule puis affiche la suite de Fibonacci jusqu’au nombre n envoyé en
paramètre.
— Q7. Ecrire une fonction qui trie un tableau selon la méthode du tri bulle.
Rappel : Algorithmique et tableaux 2D (images)

Une image est un tableau 2D contenant des valeurs entières entre 0 et 255. Un tableau en 2 dimensions permet
de stocker seulement une image noire et blanc. La valeur 0 code la couleur noire et la valeur 255 code la couleur
blanche. Pour accéder à une case d’une tableau 2D on utilise 2 indices d’abord un indice pour indiquer la ligne
puis un deuxième pour indiquer la colonne. On suppose que l’on dispose d’une image de Nao (voir Fig. A.2.a),
cette image comporte 200 lignes et 100 colonnes. On désire modifier cette image et créer de nouvelles images à
partir de celle-ci.
Ex 1 : Seuillage et moyenne sur une image

— Q1. Ecrire une nouvelle fonction qui associe 255 (blanc) à tous les pixels supérieurs à 128 et 0 (noir) à
tous les pixels inférieurs à 128. Le résultat est présenté sur la figure 1.
— Q2. Ecrire une nouvelle fonction qui associe à chaque pixel la moyenne de son intensité et de celle de ces
8 voisins. Le résultat est présenté sur la figure A.2.b.
— Q3. Améliorer ces fonctions pour prendre en compte les effets de bords.
— Q4. Calculer le centre de gravité des points noirs.
Ex 2 : Convolution sur une image

La convolution généralise le concept de moyenne glissante. On associe à un élément du tableau résultat, la
somme pondérée par des coefficients (fourni dans une matrice) du pixel courant et de ses voisins.
— Q1. Ecrire une nouvelle fonction qui implémente la convolution avec le filtre gradient vertical de Sobel [-1
0 1 ;-2 0 2 ;-1 0 1].
ANNEXE A. EXERCICES DE REMISE À NIVEAU : ALGORITHMIQUE ET PROGRAMMATION 42
Figure A.2: Filtrage simple d’une image. a) image originale, b) image filtrée avec un filtre moyenne, c) image
de Sobel binarisée. On garde toutes les valeurs supérieures à un seuil.
— Q2. Ecrire une nouvelle fonction qui implémente la convolution avec le filtre gradient horizontal de Sobel
[-1 -2 -1 ;0 0 0 ;1 2 1].
— Q3. Ecrire une nouvelle fonction qui calcule la moyenne des deux images de gradients. Le résultat est
présenté sur la figure A.3.b.
— Q4. Ecrire une nouvelle fonction qui garde tous les pixels supérieurs à 200. Le résultat est présenté sur la
figure A.3.b.
Figure A.3: Filtrage convolutif sur une image. a) image originale, b) image filtrée avec un filtre de Sobel c)
image de Sobel binarisée.
Annexe B
Salle Robotique IUT de Mulhouse (details

robots)
Liste et détails des robots en salle B004

Nous disposons de 4 robots.
— Robot Staubli TX40 (6 axes)

— Charge max : 2 kg,
— Poids : 27 kg,
— Zone de travail maximum : 0,450m,
— Robot Staubli TX60 (6 axes)

— Charge max : 4,5 kg,
— Poids : 51 kg,
— Zone de travail maximum : 0.60m,
— Robot Staubli TP80 (4 axes)

— Poids : 71 kg,
— Vitesse max : 200 prises/minute,
— Robot Kuka 6 R900 (6 axes)

— Poids : 52 kg,
43
Annexe C
Salle Robotique IUT de Mulhouse (liste

IP)
Liste des adresses IP sur le réseau local en B004

Postes automatique et robotique étudiant :
— Poste Etudiant IUT 1 : 192.168.0.110, 192.168.0.10, 192.168.0.12, 192.168.0.14.
Postes robotique supplémentaire étudiant :
— Poste Etudiant IUT 8 : 192.168.0.172.
— Poste Enseignant : 192.168.0.175.
Caméras :
— Caméra Insight 2000 : 192.168.0.91.
— Caméra Insight 7802C : 192.168.0.90.
— Caméra Insight 7905 : 192.168.0.92.
Robots :
— Poste TX40 : 192.168.0.81.
— Poste TP80 : 192.168.0.70.
— Poste TX60 : 192.168.0.254.
— Automate Sécurité : 192.168.0.227.
— IHM Sécurité : 192.168.0.228.
— Portable : 192.168.0.229.
Raspberry PI :
— PI Serveur Image : 192.168.0.69.
— PI Rob TX60 : 192.168.0.4.
Brasserie :
— Automate 1 : 192.168.0.67.
— Automate 2 : 192.168.0.68.
44
Annexe D
Table ASCII
Figure D.1: Table ASCII
45
46

Introduction À La Programmation Des Systèmes Robotiques Industriels. Stéphane Bazeille

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Introduction À La Programmation Des Systèmes Robotiques Industriels. Stéphane Bazeille

Transféré par

Droits d'auteur :

Formats disponibles

Introduction à la programmation des

systèmes robotiques industriels

Mots-clés : Robotique, Informatique, Staubli, VAL 3.

3 Programmation des robots industriels 8

4 Le langage VAL3 et la programmation des robots Staubli. 15

A Exercices de remise à niveau : algorithmique et programmation 40

B Salle Robotique IUT de Mulhouse (details robots) 43

C Salle Robotique IUT de Mulhouse (liste IP) 44

1.1 Contenu du cours

1.2 Volume horaire et contrôle de connaissance

1.4 Compétences acquises

2.1 Une discipline complexe

2.2 Qu’est-ce qu’un robot

Figure 2.1: Boucle Perception-Décision-Action

Mécanique ou partie opérative (action)

Electronique ou partie commande (perception/commande)

Figure 2.2: Boucle d’asservissement pour le contrôle du robot

Informatique ou partie intelligence (décision)

2.3 Des automates aux robots autonomes

Figure 2.3: Le premier robot : Unimate

Programmer un robot pour qu’il soit intelligent

Figure 2.4: Quelques exemples de robots d’aujourd’hui.

Les capteurs de perception et l’intelligence artificielle

Figure 2.5: Quelques exemples de robots futuristes.

Programmation des robots industriels

3.1 Les bras articulés

Différents types de robot articulés

Contrôle des mouvements d’un bras industriel

3.2 Les modèles pour le contrôle des bras articulés

Modèle cinématiques et dynamiques et exécution du mouvement

3.3 De l’importance des repères

Déplacement du bras et repère outil

3.4 Programmation d’un robot industriel

3.5 Décomposition de la trajectoire en une séquence de mouvements

3.6 Deux types de programmation

Programmation hors ligne

3.7 Un exemple simple de manipulation d’une seule pièce

Figure 3.3: Les bras robotisés Staubli.

3.8 Les bras robotisés Staubli

Figure 3.5: Ecran de démarrage de SRS

3.9 L’environnement de simulation SRS

Figure 3.6: Exemple d’environnement simulé

Le langage VAL3 et la programmation des

4.1 Elément de langage

Fonction start() and stop()

Commentaires et affichage d’une variable ou du texte

Types de données en VAL3.

— Type trsf (6 éléments) : pour une transformation géométrique (translation et rotation)

P1.trsf.x=0 (mise à zéro du x de P1)

P1.trsf.x=P1.trsf.x+100 (ajout de 100 au x de P1)

Les boucles et structures de contrôle

La boucle do until s’écrit comme ceci :

4.2 Contrôle du robot

Anticipation du mouvement et lissage

Gestion de l’outil et phase d’approche et de dégagement

Exemple d’enchaînement de mouvements

4.3 Communication robot/caméra

5.1 Ex 1 : Exemple d’utilisation des fonctions de mouvement

— Q1. Peut-on déplacer le robot en 0 0 0 0 0 0 de type jointrx ?

Etudier les deux exemples suivants.

— Q4. A quoi sert le passage par un point intermédiaire dans le cas 2 ?

Figure 5.2: Mouvements de 5 pièces.

Figure 5.3: gauche. position de départ. droite. position finale.