WIKI de Bertrand VANDEPORTAELE

Merci de remplir la colone D du document suivant en indiquant jusqu'où vous êtes arrivés. Ceci n'est pas pour vous évaluer individuellement mais pour repérer qui a des difficultés.

Vous pouvez également indiquer ce que vous avez apprécié ou qui mériterait des améliorations. Si vous souhaitez le faire de manière anonymes, mettre vos remarques à partir de la ligne 34.

https://toulouse3-my.sharepoint.com/:x:/g/personal/bertrand_vandeportaele_iut-tlse3_fr/EcsEvNvIR35NvbJRkBHX7NYBfT64FixPZSNddgl8X6Fm0Q?e=p7KQr7

Utiliser Firefox pour visualiser cette page!

Documentation du langage VAL3 (à ouvrir dans un nouvel onglet pour l'avoir toujours disponible): https://bvdp.inetdoc.net/files/iut/robotiqueBUT2/Manuel_de_ref_VAL3.PDF

Cours de robotique BUT2: https://bvdp.inetdoc.net/files/iut/robotiqueBUT2/cours_ROBOTIQUE_BVDP_2024.pdf

Documentation du bras TX2-60: https://bvdp.inetdoc.net/files/iut/robotiqueBUT2/TX2-60.pdf

Documentation du contrôleur CS9: https://bvdp.inetdoc.net/files/iut/robotiqueBUT2/CS9.pdf

Documentation utilisation du pendant et repères: https://bvdp.inetdoc.net/files/iut/robotiqueBUT2/Utilisation_robot_indus_Staubli-Robotics_2020.pdf

https://bvdp.inetdoc.net/files/iut/robotiqueBUT2/BUTAII.wrl

Former des binômes et récupérer un numéro fourni par l'enseignant. Ce numéro vous servira à identifier vos programmes sur le contrôleur du robot durant les différents TP. Le sujet des TP se trouvera à l'adresse de cette page, je vous invite donc à la mettre en raccourci pour la retrouver à chaque séance.

Le TP se déroulant sur plusieurs séances, vous devez garder une trace de votre progression pour ne pas perdre de temps à chaque séance (dans un cahier et/ou dans votre code).

Télécharger et décompresser le fichier: https://bvdp.inetdoc.net/files/iut/robotiqueBUT2/CellStylo_vide.zip

Vous devez dézipper le dossier CELLStylo afin qu'il soit dans le dossier P:\s3aii\s3aii“X”\“nom_prenom”\staubli

Les positions cartésiennes fournies dans le sujet s'entendent dans l'ordre: (tx, ty, tz, rx, ry, rz) avec les translations en mm et les angles de rotations en degrés.

Les positions articulaires sont exprimées sous la forme (j1, j2, j3, j4, j5, j6) en degrés.

Les config du robots sont exprimées dans l'ordre (épaule, coude, poignet)

Nous n'utiliserons qu'un robot de type 6R. Par conséquent, dans SRS, vous utiliserez les types JointRx et PointRx uniquement. Pour information, les types JointRs et PointRs sont réservés pour des robots de type SCARA, dotés de 4 articulations seulement.

Dans SRS, les variables uniques sont en réalité stockées dans des tableaux de taille 1 (dont le premier indice est 0). Ainsi, une variable numérique nCompteur est équivalente à nCompteur[0].

Vous veillerez à respecter les règles de nommages des variables en fonction de leurs types (voici ce que nous manipulerons):

• variable bool (booléen) commençant par b
• variable frame (repère) commençant par f
• variable jointRx (position en articulaire) commençant par j
• variable pointRx (position en cartésien) commençant par p
• variable mdesc (descripteur de mouvement) commençant par m
• variable num (valeur numérique) commençant par n
• variable string (chaîne de caractères) commençant par s
• variable tool (outils) commençant par t
• variable trsf (transformation) commençant par tr
• variable sio (ressource de communication) commençant par si

Ceci permettra notamment d'ajouter automatiquement une variable à partir du code en faisant clic droit sur la variable puis “ajouter donnée”. Le type de la variable est alors inféré d'après la convention de nommage.

Les noms des variables locales sont de plus préfixés par l_ à ajouter en tant que nouvelle variable locale (pas donnée).Nous utiliserons les variables locales pour les variables qui n'ont pas à être réglées depuis le pendant (par exemple les variables numériques de compteurs). Dans le projet, les variables locales n'apparaissent pas dans les “Données” mais dans “Cellule”→Controller1→Projet→start()→Variables locales.

Les nom des paramètres de programmes sont préfixés par x_.

Ouvrir l'application SRS et mettre sa fenêtre en plein écran sur l'écran à la meilleure résolution et le sujet du TP sur l'autre écran. Ensuite charger votre projet dans SRS en faisant Fichier→Ouvrir, puis explorer les différentes fenêtres et onglets décrits ci dessous. Vous pourrez laisser quelques secondes la souris sur les boutons de l'interface graphique pour faire apparaître le texte correspondant. Vous pourrez également déplier (en cliquant sur les icônes +) les arbres pour en explorer les contenus.

L'environnement de développement (IDE) SRS est entièrement paramétrable (et donc (dé)réglable en cas de fausse manip). Vous pouvez configurer le positionnement des fenêtres en les glissant-déposant après avoir saisi le haut des fenêtre ou bien les onglets. L'organisation conseillée pour les fenêtre est la suivante (la fenêtre d'émulation du pendant à droite pouvant être affichée sur le second écran):

Dans le cas ou vous feriez disparaître une fenêtre ou un onglet, vous pourrez la retrouver via l'onglet Accueil→Général ou Accueil→Vue 3D.

Différents onglets sont présents en haut de la fenêtre et font apparaître des fonctionnalités qu'il faudra aller chercher au moment opportun. Notez que certains réglages sont (des)activables et apparaissent bleutés lorsque activés (par exemple Déplacements articulaires et Déplacements cartésiens dans l'onglet Simulation ou bien les filtres de messages d'erreurs dans l'onglet Maintenance). Sachant ceci, vous pourrez réactiver des fonctionnalités si besoin.

• Fichier:
• Accueil:
• VAL3:
• Modeleur:
• Simulation:
• Maintenance CS9:
• Fonction de sécurité:
• Général:

La fenêtre montre un arbre de scène visible en haut à gauche. En cliquant sur les icônes + vous pouvez faire apparaître les détails. Cet arbre contient les différents modèles 3D de la scène: Objet à manipuler par le robot, les robots et les outils. Il contient également les caméras de base plus les caméras créées par l'utilisateur, permettant de positionner la caméra de la vue 3D afin d'afficher les éléments utiles. Pour créer une caméra, faire clic droit sur la vue 3D puis ajouter une caméra. Ceci permet d'éviter de perdre du temps à retrouver manuellement des vues 3D convenables, quand vous en trouver une convenable, vous pouvez la sauver, puis la retrouver simplement en faisant clic gauche sur la caméra dans l'arbre. Vous pouvez également mettre à jour une caméra en réglant la vue 3D souhaitée puis en faisant clic droit sur la caméra dans l'arbre puis mettre à jour la caméra.

Vous pouvez afficher simultanément plusieurs vues 3D depuis différentes caméras dans la même fenêtre en faisant par exemple: clic droit sur Vue3D, affichage→Deux Vues

Pour interagir avec la vue 3D et régler la caméra, vous pourrez faire clic gauche maintenu et déplacer la souris ainsi qu'utiliser la molette. Vous pourrez également faire clic droit sur un élément 3D pour faire apparaître un menu.

Les repères sont affichés avec le code couleur suivant Rouge/Vert/Bleu respectivement pour x,y et z.

Les différentes icônes sont expliquées ci dessous:

• Icône centrer la vue sur l'objet sélectionné (cube avec 4 traits)
• Icône sélection (flèche) pour sélectionner des objets
• Icône mouvement de translation caméra (main)
• Icône de rotation caméra (point entouré de 2 flèches). Faire clic hors du cercle pour tourner autour de l'axe de visée de la caméra et clic dans le cercle pour tourner autour des 2 autres axes. (horizontaux et verticaux)
• Icône zoom (loupe)
• Icône ajuster le zoom à la scène (rectangle avec 4 flèches)

Liste les erreurs lors de l'analyse ou de l'exécution du programme

Cette fenêtre apparaît lorsque l'on double clique sur un programme pour en afficher et éditer le contenu. Elle est également utilisée pour le debug de l'application, pour placer des points d'arrêt ou bien observer la ligne en cours d’exécution.

En réalité 3 fenêtres différentes accessibles sous forme d'onglets dont le détail est donné ci-dessous:

Contient une arborescence: Cellule→controller(s)→robots→application(s)→programmes→paramètres et variables locales

Cette fenêtre permet de naviguer entre les différents programmes, notamment les 2 programmes obligatoires pour chaque application: start et stop. Elle permet également de manipuler les variables locales de ces programmes ainsi que les paramètres des programmes qui en acceptent (utilisés alors comme sous programmes).

Contient une arborescence: Cellule→controller(s)→robots→application(s)→types de variables→nom de variables→contenu des cases des variables

Permet de définir et régler les variables globales (communes aux différents programmes). Les variables sont rangées par types.

Contient une arborescence de repères: Cellule→controller(s)→robots→application(s)→world→frame

Dans cette fenêtre, vous devrez positionner vos repères (frame) et points pour les lier. Ceci est réalisé en glissant déposant les repères et points dans l'arborescence.

L'image suivante montre une application appLogo dans laquelle le repère robot world[0] contient:

• un repère fLogo[0] contenant 5 tableaux de points pLogoContour et pLogo…Tous ces points suivent le frame fLogo[0] lorsqu'on le déplace. Le nombre de points dans chacun des tableaux est indiqué entre crochets à droite du tableau.
• un tableau de point pTest contenant un unique point pTest[0]. Ce point est défini dans le repère robot et n'est pas lié au frame fLogo dans l'image de gauche. Dans l'image de droite, par contre, le point pTest[0] a été déplacé dans le frame fLogo, il subira alors les modifications appliquées à ce repère:

Cette fenêtre apparaît lorsque l'on fait double-clic sur une donnée (variable globale) dans la fenêtre Données. Elle est visible sur l'image d'exemple suivante et affiche une vue tabulaire de la variable sélectionnée (ici le tableau de points pLogo2 de l’application applLogo) avec chaque ligne du tableau correspondant à un indice et chaque colonne à un champ. Les noms des différents champs apparaissent en première ligne, et il peut être nécessaire de déplacer l’ascenseur horizontal pour les voir tous si la fenêtre n’est pas assez large.

Permet d'afficher/régler la pose du robot, en articulaire et en cartésien (en utilisant le TCP courant comme outils).

Cette partie de la fenêtre permet d'afficher et de choisir parmi les différentes configurations du robot quand plusieurs sont possibles (dans l'ordre épaule (shoulder), coude (elbow), poignet (wrist)). Elle affiche également la pose cartésienne du TCP par rapport au repère robot. Attention si vous réglez manuellement la position cartésienne à un valeur non atteignable, un minuscule panneau “Warning” apparaît à droite de “Position cartésienne”.

Cette partie de la fenêtre affiche (et permet de régler la position articulaire avec les curseurs épais déplaçables) l'angle en degrés correspondant à chaque articulation J1 à J6. Les plages articulaires (ré-initialisables à 0 avec l’icône croix rouge en haut de la fenêtre) sont affichées pour vérifier si le robot s'approche ou atteint des limites pendant l'exécution du programme.

Il est possible de faire se déplacer le robot en cartésien en cliquant/déplaçant les axes de son TCP dans la vue 3D.

Il est également possible de faire se déplacer le robot en articulaire en faisant double clic gauche sur le robot pour faire apparaître des cercles autour de chacune de ses articulations, puis en cliquant/déplaçant sur ces cercles.

Cette fenêtre reproduit le fonctionnement du vrai pendant, à l'exception de la “poignée de l'homme mort” et en simplifiant l'accès aux fichiers de l'application en cours de développement dans SRS.

Vous pourrez donc piloter le robot en simulation de la même manière que le vrai robot en jouant sur l'interface du pendant, explorer les différents modes de fonctionnement, commander manuellement le robot, vous entraîner à apprendre des points et des repères etc.

La vue 3D de SRS utilise un repère de référence pour la simulation et la visualisation 3D et le positionnement des objets dans la cellule, ce qui permet notamment de gérer plusieurs robots dans une même cellule. Dans notre utilisation, Ce repère de référence est positionné à la base du robot, alors que le repère robot (aussi appelé World) est positionné à l'intersection des axes j1 et j2. Avec le robot TX2-60, le repère robot est positionné à 375mm en z du repère de référence. Le repère de référence pour la simulation et la visualisation 3D n'est pas utilisé pour les variables et n'est pas connu du contrôleur d'un robot. Seuls le repère robot et les repères définis par l'utilisateur (frames) sont utilisés dans les programmes.

Il est donc nécessaire de jongler entre ces différents repères, selon que l'on soit en train de modéliser la cellule, ou bien de programmer le robot.

La figure suivante montre le repère robot (World), fixé par rapport à la base du robot :

Faire clic droit sur le robot dans la vue 3D puis “déplacements manuels”. Dans la fenêtre déplacements manuels, cliquer sur l’icône “Zéros” (en haut à gauche) pour remettre le robot à la pose articulaire avec toutes les articulations à 0. Observer que ceci correspond à la pose cartésienne pour le repère outil (0,20, 839.45, 0 , 0 ,0). Observer la figure suivante et en déduire la longueur de l’outil Stylo (translation en z entre le handle et le handler)

Dans la fenêtre Vue 3D, Faire clic droit sur Scène→Robots→Controller1 puis cocher “Afficher l'espace de travail Lefty”. Ceci permet d'afficher le volume englobant les positions par le point à l'intersection des 3 axes du poignet (ni par la bride, ni par le TCP), afin de vérifier (très approximativement) que les objets sont atteignables par le robot.

En pratique, cet affichage ne tient compte ni du changement de repère entre le handle et le handler de l'outil, ni de l'orientation du poignet, et il faudra donc vérifier que chacun des points de la trajectoire est bien atteignable par le robot en simulation..

Pour illustrer cela, mettre les articulations toutes à 0 dans la fenêtre déplacements manuels et observer le volume de travail par rapport à l'outil.

Dans la fenêtre déplacement manuels, régler la pose cartésienne (300,0,0,180,0,0) en configuration (Lefty, positive,Négative) et observer sur la caméra de Face si le TCP est compris dans le volume de travail affiché. Avec la souris, manipuler le TCP pour le déplacer le plus haut possible en maintenant l'orientation de l'outil et observer que vous ne pouvez pas déplacer librement l'outil dans le volume affiché.

Vous pouvez maintenant décocher “Afficher l'espace de travail Lefty” dans clic droit sur Scène→Robots→Controller1.

Vous allez créer votre première application pour stocker des données (positions cartésiennes et articulaires, repères etc…) et un programme simple. Dans ce développement, vous expérimenterez en simulation en écrivant du code qui ne respectera pas les bonnes pratiques qui seront données plus tard dans le sujet. Il faudra par contre intégrer ces bonnes pratiques avant de programmer le vrai robot.

Créer votre application: Dans fenêtre Cellule, faire clic droit sur CellStylo→Controller1 puis nouvelle application. Régler uniquement le Nom à “BUT2TP”+votre numéro de binôme sur 2 chiffres, complété à gauche avec des 0. Par exemple, si vous avez le numéro 5: BUT2TP05 . Dans la suite votre application sera appelée BUT2TPXX dans le sujet. LAISSER L'APPLICATION A L'EMPLACEMENT PROPOSÉ PAR DÉFAUT!

Vous veillerez à ne jamais nommer votre application avec des caractères spéciaux (_ - / …: caractères interdits)

NB: Nous suivrons la même démarche pour ajouter des sous programme à notre application. Après avoir fait clic droit sur votre application, puis ajouter→nouvelle application, et donné un nom puis sauver, il peut être nécessaire de faire clic droit sur votre application, puis “recharger l'application” pour que le nouveau programme apparaisse dans la liste.

Deux approches sont possibles pour ajouter des variables à une application:

• Depuis la fenêtre Données, faire clic droit dans Cellule→Controller1→application→type puis “nouvelle donnée” (ou CTRL+N,D)
• Depuis la fenêtre d'édition du code, en faisant clic droit sur une variable (correctement nommée) puis Ajouter→Nouvelle donnée

Dans les deux cas vous veillerez à ce que:

• Le type choisi soit le bon.
• Le Conteneur soit Tableau.
• Le préfixe de la variable respecte les règles de nommage
• Les dimensions soient correctes (mettre 1 pour une variable à une seule valeur, il est possible d'ajouter des cases plus tard, en faisant clic droit sur le tableau dans la fenêtre données puis Ajouter une valeur)

Une fois la variable créée, vous pourrez facilement ajouter des cases aux tableaux en cliquant droit sur le nom du tableau dans la fenêtre Données puis Ajouter une valeur.

Pour éditer une variable, double cliquer sur elle dans la fenêtre Données ou Géométrie, puis éditer les valeurs dans les tableaux. Pour éditer des fichiers de programme, cliquer sur le programme dans la fenêtre cellule, puis éditer le texte.

ATTENTION, après édition, une * apparaît à droite du nom de la variable ou du fichier pour indiquer qu'elle est modifiée mais non sauvée. Il faut faire CTRL+S pour la sauver sur disque et pouvoir l'utiliser dans l'application.

Nous commençons par une application simpliste réalisant des aller-retours dans l'espace articulaire.

Copier/coller ce programme simple dans le programme start (déjà existant) de votre application

start.pgx

begin
  resetMotion()
       movej(jBrasBaisse,tStylo[0],mNormal)
       waitEndMove()
  while true
  movej(jEssuie[0],tStylo[0],mNormal)
      waitEndMove()
          delay(1)
  movej(jEssuie[1],tStylo[0],mNormal)  
    waitEndMove()
       delay(1)
  endWhile
end

Le code fourni est volontairement mal indenté, vous allez le formater automatiquement en faisant: Onglet Général→Reformater le document

Consulter la documentation du langage VAL3 pour comprendre ce que fait ce programme: https://bvdp.inetdoc.net/files/iut/robotiqueBUT2/Manuel_de_ref_VAL3.PDF

Vous pourrez ajouter des commentaires commençant par deux barres obliques dans le code EN DEBUT DE LIGNE seulement.

//Ceci est un exemple de commentaire
delay(1) //attendre 1 seconde   <- ceci n'est pas considéré comme un commentaire

Il n'existe pas de commentaire multiligne en langage VAL3, pour (dé)commenter rapidement plusieurs lignes consécutives, les encadrer puis faire Onglet Texte→(ne pas) Commenter la sélection.

Ajouter des commentaires dans le code fourni pour expliquer ce que font les instructions.

• Créer la variable de type joint (position articulaire) appelée jBrasBaisse et l'éditer manuellement à j2=j3=+50° et j1=j4=j5=j6=0 degrés
• Créer la variable tableau de type joint jEssuie[2]
• Créer la variable descripteur de mouvement nommée mNormal de type mdesc ( Accel=Vel=Decel=100, TVel=99999, RVel=99999, Blend=cartesian, Leave=Reach=2mm)
• Créer la variable tStylo de type tool et initialiser tous ses champs à 0 sauf le champ z=169.45, afin d'indiquer le changement de repère entre le handle et le handler correspondant à la valeur calculée plus haut.

Choisir une position articulaire dans la fenêtre déplacements manuels et l'enregistrer dans la jEssuie[0] en cliquant droit sur la variable dans la fenêtre Données puis “ici”. Faire de même avec une autre position pour jEssuie[1].

Vous pouvez également positionner le robot dans la vue 3D en cliquant droit sur une variable joint puis “aller à”

Cliquer sur la fenêtre contenant le code à exécuter.

Dans l'Onglet VAL3, cliquer sur Vérifier la syntaxe (F6) et vérifier la présence d'erreurs de syntaxe affichées dans la fenêtre Liste des erreurs. Les corriger si besoin et itérer.

Deux modes sont ensuite possibles selon que l'on souhaite exécuter en continu l'application ou bien l'exécuter avec des points d'arrêts (mode debug). Selon le choix, cliquer dans l'Onglet VAL3 sur “Démarrer l'application (CTRL+R,X)” ou “Démarrer et déboguer l'application” (CTRL+R,D). Dans un premier temps, nous exécuterons l'application en continu.

Une fois lancée, l'application est exécutée par l'émulateur de contrôleur du robot, dont l'affichage est disponible dans la fenêtre de l'émulateur de pendant. Cette dernière reproduit le fonctionnement du vrai pendant, et il est donc nécessaire d'activer le bouton de mise sous tension (en haut à droite du pendant, entouré de violet quand actif) puis de maintenir le bouton pause enfoncé.

Vous pourrez changer le mode de fonctionnement du contrôleur entre manuel et automatique en cliquant sur l’icône au dessus du texte SP2. En mode Automatique le maintien du bouton pause n'est plus nécessaire après le mouvement de connexion (resetMotion())

Afin que la vue 3D soit pilotée par l'émulateur, il faut dans l'onglet Simulation, cliquer sur le triangle vert (Démarrer la synchro). Il faudra penser à cliquer sur le carré rouge (Arrêter la synchro) pour redonner le contrôle de la vue 3D à l'éditeur.

Observer le déplacement du robot dans la vue 3D.

Éditer manuellement jEssuie[1] pour avoir j1=-600 et relancer une simulation. Observer l'erreur affichée dans le pendant “ERR520…”. Il s'agit d'une erreur d’exécution, et non pas de syntaxe. Elle survient ici car nous avons demandé au robot d'aller à une position articulaire inatteignable.

Dans la vue 3D, cliquer sur Cameras→Camera pour utiliser la caméra préréglée fournie avec le projet. Dans Déplacements manuels, régler une position cartésienne à (360, 350, 400, -75, 45, -10)

Relever la valeur de l'articulation J5.

Attraper avec la souris l'arc rouge du repère TCP pour faire tourner le repère autour de l'axe X

Observer la rotation rapide de l'avant bras pour une toute petite rotation du TCP et noter le changement de configuration du bras.

Vous allez maintenant faire en sorte que le programme du robot permette de passer d'une configuration à l'autre. Pour cela:

• Régler avec la fenêtre déplacements manuels une position cartésienne pour le robot pour laquelle plusieurs configurations sont possibles : (-50,50,35,200,0,-200).
• Choisir parmi les configurations du bras proposées (Lefty,Positive,Positive) puis enregistrer la position articulaire correspondante dans la variable jEssuie[0].
• Choisir parmi les configurations du bras (Righty, Négative,Positive) et enregistrer la position articulaire correspondante dans la variable jEssuie[1].

Exécuter le programme et observer le mouvement du bras en simulation. Vous devriez en conclure que ce n'est pas une bonne idée de changer inopinément de configuration du bras si l'on souhaite éviter les collisions avec la cellule…

Remarque: Nous observerons plus tard dans ce TP un problème lié aux singularités lorsque nous ferons des déplacements dans l'espace cartésien car le robot “perd des degrés de libertés” à proximité des singularités. Pour cette raison, il faudra donc privilégier des ordres de déplacement dans l'espace articulaire dans ces cas.

Votre application va maintenant permettre au robot de tracer un logo en manipulant un stylo qui est un outils simple, à symétrie de révolution autour de l'axe z, sans actionnement contrairement à une pince par exemple (open et close).

Comme nous l'avons vu plus haut, l'affichage de l'espace de travail n'est pas suffisant pour garantir que le logo pourra être tracé simplement car il est inclus dans cet espace. Nous allons vérifier cela de manière plus approfondies ici.

Afin de vérifier que le robot pourra dessiner le logo, nous allons déplacer manuellement le repère de l'outil sur la surface à dessiner.

Orienter l'outil verticalement vers le bas (pose cartésienne avec rx=180,ry=0,rz=0), en contact avec le logo (z=-184). En utilisant la vue de Haut, balayer la surface du logo en manipulant le TCP selon les axes x et y de l'outil. Vérifier que le robot est capable d'atteindre toute la zone, sans changer de config, et avec l'articulation J5 non proche de 0 degrés pour éviter les problèmes de singularités.

Nous devons aussi vérifier que le TCP est capable de se déplacer dans un plan situé au dessus de cette surface, que nous appellerons plan d'approche, afin de pouvoir lever et baisser le stylo entre les différentes lettres.

Pour cela, élever le TCP de 15mm (dans la fenêtre déplacement manuels) et vérifier par la même méthode que précédemment que tous les points du logo sont atteignables.

Vous allez créer une variable tableau de points par lettre du logo à dessiner.

Les primitives de trajectoire en espace cartésien disponible en VAL3 sont:

• segments de droites (définis par 2 extrémités) : instruction movel(…)
• cercles (définis par 3 points) : instruction movec(…)

Le tracé d'une lettre sera obtenu par différents tronçons de trajectoire paramétrés par les points que vous allez apprendre (et aussi par des descripteurs de mouvement et un choix d'interpolation comme expliqué dans le cours).

Afin de positionner finement le TCP dans la scène, nous allons tout d'abord masquer certains éléments qui bloquent la vue.

Masquer la cellule en la sélectionnant (elle devient verte) puis clic droit et décocher afficher. Vous pourrez la faire apparaître de nouveau, dans la Vue 3D, arbre de Scène→Géométrie→cellule_simplifiée, clic doit puis cocher afficher.

Masquer le robot: dans la Vue 3D, arbre de Scène→Robots→Controller1, clic doit puis décocher afficher. Seuls le repère TCP et le logo restent visibles, ce qui va vous permettre de déplacer le TCP à différents emplacements du logo pour apprendre des points.

(Note pour plus tard: nous dessinerons avec le vrai robot sur une surface surélevée).

Pour apprendre un point:

• Amener le TCP à la position souhaitée (6 degrés de libertés)
• dans la fenêtre Données, sélectionner le point (la bonne case dans le cas d'un tableau)
• cliquer droit sur le point et puis “ici”

Pour l'instant, ne pas cliquer sur “ici avec config”, afin d'avoir (ssame,esame,wsame) dans la config du point et d'éviter les changements de configuration du bras.

Vous allez dans un premier temps tracer la lettre T. Pour cela, apprendre les 4 points pour les 2 segments de la lettre dans le tableau pLettreT, commentez le code de la boucle while du programme start et la remplacer par:

while true
  movej(pLettreT[0],tStylo[0],mNormal)  
  movej(pLettreT[1],tStylo[0],mNormal)  
  movej(pLettreT[2],tStylo[0],mNormal)  
  movej(pLettreT[3],tStylo[0],mNormal)  
endWhile

Simuler et observer les mouvements du robot.

Afin de pouvoir mieux observer la trajectoire de la pointe du stylo, nous allons afficher dans la vue 3D des repères échantillonnés sur la trajectoire du TCP. Pour cela, alors que la simulation est lancée, cliquer sur Onglet simulation→Démarrer les traces

Pour augmenter la densité du tracé des repères, vous pouvez:

• soit réduire la vitesse de déplacement du robot, en cliquant sur le bouton - (sous le bouton pause) du pendant jusqu'à ce que la vitesse affichée en bas à gauche soit de 10%
• soit changé la cadence de simulation (alors qu'elle est inactive), en cliquant sur l'horloge 100ms dans l'onglet Simulation et en remplaçant par exemple par 10ms.

Pour effacer les traces, cliquer sur Onglet simulation→Effacer les traces

Simuler et observer les mouvements du robot sur la vue de face, de haut, et la caméra fournie.

Comparer la trajectoire obtenue à la trajectoire espérée, vous devriez obtenir une trajectoire proche de ceci:

Même si l'affichage semble correct à première vue, la trajectoire du TCP ne suit pas des lignes droites. Ici, nous sommes dans un cas très particulier où malgré les movej, le TCP reste approximativement dans le plan de la table, mais ceci uniquement parce-que le tracé se fait dans un plan particulier avec une orientation particulière de l'outil.

Pour mieux appréhender les différences entre l'interpolation dans les espaces cartésien et articulaire, écraser votre programme start avec le programme suivant:

start.pgx

begin
  resetMotion()
  movej(jBrasBaisse,tStylo[0],mNormal)
  //réglage des 2 points depuis le programme, seule la composante translation en Z change.
  pLettreT[0]={{-532.632478,-132.754742,-183.952521,0,-90,-90},{righty,enegative,wpositive}}
  pLettreT[1]={{-532.632478,-132.754742,485.438945,0,-90,-90},{righty,enegative,wpositive}}  
  while true
    //mouvement "point à point" avec interpolation dans l'espace articulaire
    movej(pLettreT[0],tStylo[0],mNormal)
    waitEndMove()
    delay(1)
    movej(pLettreT[1],tStylo[0],mNormal)  
    waitEndMove()
    delay(1)
    //tracé d'une ligne en interpolation dans l'espace cartésien
    movel(pLettreT[0],tStylo[0],mNormal)
    waitEndMove()
    delay(1)
    movel(pLettreT[1],tStylo[0],mNormal)  
    waitEndMove()
    delay(1)
  endWhile 
end

Lire le programme pour comprendre ce qu'il fait puis lancer la simulation en affichant les traces. Observer la différence entre les mouvements reliant les mêmes points mais avec des interpolations différentes. L'image suivante montre une capture d'écran de la trajectoire avec les movej:

Comprendre qu'au lieu de tracer un trait sur la vitre, ce programme l'aurait brisé.

CONCLUSION: En général, il ne faut jamais utiliser d'instruction movej (interpolation en articulaire) lorsque le robot est proche d'un objet ou au contact AVANT ou APRÈS l'instruction de déplacement car sa trajectoire n'est pas contrainte entre les 2 points et le robot risque d'entrer en collision avec l'environnement!

Reprendre le programme précédent du tracé du T et remplacer toutes les instructions movej par des instructions movel sauf pour la première qui amène le bras en position articulaire jBrasBaisse. Ajouter une instruction waitEndMove() juste après le movej vers jBrasBaisse.

Simuler et observer les mouvements du robot sur la vue de face, de haut, et la caméra fournie.

Vous devriez obtenir une erreur de singularité à l'exécution, ceci est dû à la position articulaire de départ jBrasBaisse, pour laquelle j5 est à 0. Ceci est une position singulière, et le mouvement movel n'est pas possible depuis cette position. Éditer la variable et régler j5 à 10 degrés. Simuler de nouveau.

Lire la documentation de la fonction waitEndMove(). Ajouter une instruction waitEndMove() après chaque movel pour obliger le TCP à atteindre le point (avec une vitesse de TCP nulle). Ceci permet de désactiver le lissage de trajectoire et permet d'obtenir les trajectoires linéaires souhaitées, au prix d'un mouvement saccadé.

Simuler et observer les mouvements du robot sur la vue de face, de haut, et la caméra fournie.

Vous allez devoir maintenant programmer des mouvements verticaux permettant de n'écrire que les 2 barres du T et donc de relever le stylo.

Pour cela vous pourriez apprendre manuellement d'autres points à la verticale des points de pLettreT mais VAL3 propose une fonction pour calculer un nouveau point à partir d'un point existant et d'une transformation.

Lire la documentation de la fonction point appro(point pPosition, trsf trTransformation).

Ajouter des instructions de déplacements à votre programme, chacune suivi d'un waitEndMove() pour relever et abaisser le stylo. Vous utiliserez la fonction movel dès lors que le point de départ ou d'arrivée d'une instruction de mouvement est au contact (ici de la table). Pour le paramètre trTransformation, vous passerez une valeur permettant de relever le stylo de 30mm. Vous pourrez le faire en passant une valeur:

• soit {0,0,-30,0,0,0}. L’intérêt de cette approche est que vous pourrez spécifier une distance différente pour chaque appro()
• soit une donnée trApproStylo créée de type trsf et initialisée à (0,0,-30,0,0,0). L’intérêt de cette approche est que vous pourrez changer la distance d'approche en une seule fois.
• soit {0,0,nTzApproStylo,0,0,0} en ayant créé une donnée de type num nommée nTzApproStylo et initialisée à -30. L’intérêt de cette approche est que vous pourrez changer la distance d'approche en une seule fois, en imposant une translation uniquement sur l'axe Z.

Simuler et observer les mouvements du robot sur la vue de face, de haut, et la caméra fournie.

Vous allez maintenant ranger le code de tracé de la lettre T dans un sous programme.

Pour cela, dans la fenêtre Cellule, cliquer droit sur CellStylo→Controller→appLogo→votre application puis ajouter→Nouveau programme.

Saisir tracelettret et ne pas cocher Publique, puis OK.

Si le programme tracelettret n’apparaît pas sous le programme stop(), vous pouvez faire clic droit sur CellStylo→Controller→appLogo→votre application puis Recharger l'application

Couper/coller le code compris dans la boucle du programme start() entre begin et end de tracelettret. Ce programme a accès à toutes les données (variables globales) de votre application.

Assurez vous que le code de tracelettret commence par un déplacement vers un point AU DESSUS du premier point à tracer et se termine par un déplacement qui relève le stylo.

Appelez tracelettret dans la boucle du programme start() en utilisant l'instruction call tracelettret()

Simuler et observer les mouvements du robot sur la vue de face, de haut, et la caméra fournie.

Vous allez maintenant devoir tracer la lettre U, en étant beaucoup moins guidé. La seule nouveauté est la présence d'un tronçon (approximativement) circulaire que vous pourrez tracer à l'aide d'une instruction movec en utilisant un point à la base du U.

Procéder comme pour la lettre T et créer un programme tracelettreu (EN COPIANT COLLANT et modifiant!). Simuler et observer les mouvements du robot sur la vue de face, de haut, et la caméra fournie.

Nous allons maintenant tracer la lettre A afin d’illustrer le lissage de trajectoire. En plus de l’aspect esthétique, cela permet de générer des trajectoires fluides, plus rapides et provoquant potentiellement moins d'usure sur le robot.

Procéder comme pour les lettres précédentes, en respectant l'ordre des points indiqué sur l'image suivante:

Ne pas mettre d'instruction waitEndMove() au niveau du point 1.

Régler la variable mNormal à la valeur par défaut avec Leave et Reach à 50 mm.

Simuler et observer les mouvements du robot sur la vue de face, de haut, et la caméra fournie.

Vous devriez obtenir un tracé tel que visible sur la figure suivante pour les 2 premiers segments:

Le lissage par défaut est trop important pour notre application. Nous allons le régler via la donnée mNormal qui est un descripteur de mouvement.

Consulter la documentation Val3 à la page 134 pour comprendre le fonctionnement du lissage et le rôle des paramètres leave et reach.

Double cliquer sur fenêtre Données→CellStylo→Controller1→application→mdesc→mNormal pour l'éditer et régler:

• Blend à cartesian afin de garantir que le TCP restera dans le plan défini par les 2 segments entre lesquels le lissage a lieu. Ceci est très important ici car l'outil est au contact de la table et ne doit ni passer sous le plan (écrasement du stylo), ni dessus (arrêt du tracé). De manière général blend ne sera autorisé à la valeur joint que lorsque le robot ne sera pas proche ou au contact.
• Leave et Reach à 10 mm

Penser à faire CTRL+S pour sauver la donnée et relancer une simulation pour observer la nouvelle trajectoire.

Vous devriez obtenir une trajectoire proche de celle ci:

Débrouillez vous pour les tracer.

Appeler chacun des programmes de tracé de lettre dans start pour enchaîner les tracés.

Nous allons mutualiser le code de tracelettret pour tracer le T et les 2 I avec un seul programme appelé tracedeuxsegments(point x_pTab)

Créer le programme tracedeuxsegments en copiant le code de tractelettreT

Nous allons lui ajouter un paramètre d'entrée de type tableau de points, pour cela:

clic droit dans fenêtre Cellule sur tracedeuxsegments puis Ajouter→nouveau paramètre

Choisir :

• Type: pointRx
• Conteneur: tableau
• Nom: x_pTab
• Dimensions 1

Ok

Remplacer dans tracedeuxsegments les utilisations de la variable pLettreT par le paramètre x_pTab

Remplacer dans start les appels de tracelettret et de tracelettrei par 2 appels de tracedeuxsegments en lui fournissant les bons tableaux en paramètres.

Simuler et observer les mouvements du robot sur la vue de face, de haut, et la caméra fournie.

Réfléchir au tracé de la lettre B en utilisant 2 appels à tracelettreu

Si vous avez le temps, le coder et le tester.

Commencer par positionner au moins un point d'arrêt en cliquant à gauche d'un numéro d'une ligne du programme qui sera exécutée (la ligne). Pour commencer, fait cette opération sur le premier movej de votre programme. Une boule rouge doit apparaitre.

cliquer sur Onglet Val3→Démarrer et “Deboguer l'application”

Une flèche jaune doit apparaitre sur la boule rouge indiquant la prochaine ligne du programme qui sera exécutée.

• F10 permet d’exécuter une ligne du programme sans rentrer dans les appels de sous programmes
• F11 permet d’exécuter une ligne du programme en entrant dans le détail des appels de sous programmes

Le reste de la procédure reste identique à la simulation simple: il faut cliquer sur le bouton permettant de synchroniser la vue 3D avec le simulateur et utiliser le pendant virtuel pour mettre en route le robot (on préférera le mode auto pour éviter de devoir cliquer sur pause en continu).

Noter que la flèche jaune avance, sans que le robot ne se déplace. C'est logique si l'on se rappelle que votre programme ne fait pas bouger le robot mais remplie une file d'ordre qu'un autre programme utilise pour faire bouger le robot! Seule l'instruction waitEndMove bloque l'exécution de votre programme jusqu'à ce que le robot ait terminé la trajectoire en attente dans la file d'ordre.

Ceci est très important à comprendre pour appréhender le débogage. Il peut être opportun, dans la phase de développement, de rajouter des waitEndMove afin de permettre de déboguer la trajectoire du robot séquentiellement (un mouvement après l'autre) et d'observer quel mouvement pose problème. Il faut néanmoins comprendre que le programme ainsi modifié ne génère plus les mêmes trajectoires car le lissage est désactivé par les waitEndMove.

Pendant le debug, vous pourrez observer:

• dans la fenêtre Tâches, le programme en cours d’exécution et les éventuelles erreurs.
• dans la fenêtre Variables locales et Paramètres les variables dont les noms commencent par l_ et x_. Vous pouvez également, dans l'onglet Espions, saisir des expressions, par exemple le nom d'une variable tableau[indice] pour afficher la valeur de la case indice.

Pour sortir du mode Débogage, il faut cliquer sur l'onglet Déboguer, puis sur le bouton “Arrêt du débogage”.

A tour de rôle: Un des membre du binôme doit modifier un des points de votre programme pour le rendre non accessible. Ensuite l'autre membre doit utiliser le débogueur pour déterminer quel point pose problème.

Nous allons dans la suite utiliser le concept de frame pour définir des points dans un (ou plusieurs) repère local, les points étant liés au repère et bougeant avec lui.

• Un frame est un trsf (pose à 6 degrés de liberté)
• Un point contient un trsf qui est exprimé relativement au frame parent auquel le point est lié (repère World par défaut).

Nous utiliserons la convention suivante pour définir des frames et des points de manière simple:

• Le frame fL est un trsf de l'outil pour une position de référence
• Un point dont le trsf est à 0 par rapport au frame fL place l'outils à la position (6ddl) du frame. Les 3 axes de l'outil pointent alors dans les 3 directions du frame.

L'apprentissage d'un frame peut se faire de deux manières:

• Soit simplement en positionnant l'outils (6ddl) à l'emplacement du frame. L'apprentissage du frame est alors très sensible à l'orientation de l'outil, et la moindre erreur angulaire peut avoir des répercussions importante pour des points éloignés de l'origine du frame (effet bras de levier).
• Soit en apprenant 3 points: Le premier situé à la position de l'origine du frame pour en apprendre les 3 composantes en translation. Les deux points suivants servent quand à eux à estimer précisément l'orientation du frame, en prenant des points suffisamment éloignés pour avoir une bonne mesure. Le second est déplacé dans la direction x du frame relativement à son origine, et le troisième, quelconque dans le plan (x,y) du frame. Noter que la positon du troisième point doit être du coté y>0 (du frame) car elle impacte sur la direction des axes y et z du frame. (Pour rappel, le z du frame doit être orienté vers la tâche comme indiqué plus haut).

Vous allez maintenant ajouter un élément 3D dans la cellule, sur lequel le robot va devoir agir.

Télécharger ce fichier: https://bvdp.inetdoc.net/files/iut/robotiqueBUT2/plaque_200x200.stl

Importer le modèle dans le projet:

• Onglet Modeleur→Ajouter un modèle CAO
• Chercher le fichier plaque_200x200.stl à l'aide du bouton …
• Régler la résolution sur Standard et cocher l'option “Copier et insérer le fichier”
• Dans la vue 3D, cliquer sur Scène→Géométrie→plaque_200x200.stl, puis dans l'onglet modeleur sur “Éditer le repère de référence” (devient bleuté). Saisir en position RELATIVE: (-100,-100,0,0,0,0) afin de positionner le repère sur le coin étiqueté 0. NB: SRS a la très mauvaise manie de changer le repère des modèles 3D importés en recentrant les modèles. Nous venons ici juste de corriger le repère d'importation pour le remettre à sa position telle que stockée dans le fichier 3D. Une fois le réglage fait, cliquer à nouveau sur “Éditer le repère de référence” pour qu'il ne soit plus bleuté.
• Dans la vue 3D, cliquer sur Scène→Géométrie→plaque_200x200.stl, puis clic droit puis “éditer la position”

Éditer la position absolue suivante: ( 200, -100, 375, 180, 0, -90 ) (Ces positions dans le simulateur 3D sont exprimées dans le repère cellule, centré sur la base du robot)

Comprendre les 6 paramètres de pose de l'objet que vous venez de placer dans la cellule, et être capable de l'exprimer par 6 transformations successives). Observer la cellule depuis différentes caméras pour bien comprendre le positionnement de la plaque.

Changer la pose de la plaque en éditant la position absolue suivante: ( 350,-60,190,-150,-12,-120)

Créer une donnée fPlaque de type frame et l'initialiser à ( 350,-60,-185,-150,-12,-120)

la composante tz est cette fois exprimée dans le repère robot, d'où la différence de 375mm par rapport à la position absolue que vous avez réglée précédemment.

Dans la fenêtre Données, cliquer droit sur frame→fPlaque→fPlaque[0] et “aller à”. Ceci va permettre de placer le TCP du robot à la pose du frame.

Vous devriez observer une scène telle que visible sur l'image suivante:

Créer une nouvelle donnée de type Point pPlaque contenant 5 cases. (la cinquième case contenant le même point que la première pour l'instant).

Lier ce tableau de point au frame fPlaque. Pour cela, dans la fenêtre Géométrie, faire glisser le tableau pPlaque, qui se trouve initialement dans le frame World, vers le frame fPlaque[0] afin d'obtenir l'affichage suivant.

La plaque faisant 200mm de coté, remplir les 4 premières cases du tableau pPlaque pour positionner le TCP sur chacun des 4 coins de la plaque à partir de l'origine du repère et en tournant dans le sens des aiguilles d'une montre lorsque l'on regarde la plaque d'en haut. (La config pour les points sera réglée à same pour les 3 articulations)

Vérifier les points et leur atteignabilité en faisant “Aller à” sur chacun d'eux.

Écrire un programme permettant de tracer répétitivement le contour de la plaque, en abaissant et en relevant le stylo perpendiculairement à la plaque au niveau du point d'indice 0.

Vous avez déjà utilisé l'instruction while dans le programme pour répéter le tracé. Vous allez maintenant utiliser l'instruction for pour balayer les différents points du tableau.

Pour cela, vous allez créer une variable locale de type num appelée l_nindex: Dans la fenêtre Cellule, faire clic droit sur start et ajouter→nouvelle variable locale et choisir le bon type et nom. Ces variables n'apparaissent pas dans la fenêtre données mais uniquement dans la fenêtre Cellule, dans le programme dans lequel elles sont définies. Elles ne sont pas éditables avec le pendant et doivent être utilisées pour tout ce qui n'a pas vocation à être appris par l'opérateur du robot avec le pendant.

Ensuite, dans le programme, vous allez pouvoir faire varier la variable l_nindex entre min et max compris en faisant:

for l_nindex=min to max
   Instructions à répéter max-min+1 fois
endFor

Vous pourrez déterminer le nombre de cases d'un tableau grâce à size(nom_du_tableau).

Vous devrez notamment copier le premier point du tableau à la dernière case pour fermer le contour en faisant:

pPlaque[size(pPlaque)-1]=pPlaque[0]

Modifier votre programme pour utiliser les instructions for et size afin d'en réduire la taille.

Transformer votre programme précédent en un sous programme tracecontours prenant en paramètre le tableau de points pPlaque et l'appeler depuis start. (Ceci signidie que dans le programme tracecontours, le tableau pPlaque sera accessible via le paramètre x_pContour et pPlaque ne devra pas apparaître pour pouvoir utiliser tracecontours sur d'autres tableaux.)

Lors de l'ajout du paramètre x_pContours, vous prendez garde à bien régler Conteneur à: Tableau (Si vous l'avez oublié lors de la création du paramètre, vous pourrez faire le réglage en cliquant droit sur fenêtre Cellule→application BUT2TPXX→tracecontours→paramètres→x_pContour puis propriétés)

Un programme permettant de tracer un point en levant et abaissant le stylo perpendiculairement à la plaque à chaque point est fourni ci dessous:

traceunpoint.pgx

begin
  movej(appro(x_pPoint,{0,0,-30,0,0,0}),tStylo[0],mNormal)
  movel(x_pPoint,tStylo[0],mNormal)  
  waitEndMove()
  movel(appro(x_pPoint,{0,0,-30,0,0,0}),tStylo[0],mNormal)
end

L'ajouter à votre application et créer le paramètre x_pPoint en tant que Elément.

Créer maintenant un sous programme tracepoints pour tracer un point tous les 5cm sur la plaque en appelant le programme traceunpoint fourni.

Vous devrez utiliser deux instructions for imbriquées ainsi qu'une variable locale de type point (appelée l_pPoint) qui servira à contenir temporairement les coordonnées du point dans le frame pPlaque

Pour initialiser l_pPoint et faire en sorte qu'il soit aussi lié au frame pPlaque vous devrez faire:

l_pPoint=pPlaque[0]

Vous pourrez ensuite modifier individuellement les coordonnées du point en faisant par exemple:

l_pPoint.trsf.x=100
l_pPoint.trsf.y=100

Vous devriez observer une trajectoire via la caméra fournie telle que visible sur cette image:

Ecrire un programme qui trace une rosace telle que visible sur l'image suivante, centrée sur la plaque et dont le diamètre du cercle extérieur fait 150mm.

Si vous avez le temps, le coder et le tester.

Nous allons maintenant utiliser le simulateur pour afficher les collisions détectées pendant l'exécution du programme. Pour activer cette fonction, aller dans l'onglet Simulation et cliquer sur Collision pour qu'il devienne bleuté.

Remplacer votre programme start par ce programme:

start.pgx

begin
  resetMotion()
  movej(jBrasBaisse,tStylo[0],mNormal)
  waitEndMove()
  call traceunpoint(pLettreT[0])
  call tracecontours(pPlaque)
  call tracepoints()
  movej(jBrasBaisse,tStylo[0],mNormal)
  waitEndMove()
 
end

Lancer la simulation et observer la vue 3D. Lorsque l'outil entre en collision avec la plaque pour atteindre le point 0 de la lettre T, l'outil s'affiche en rouge comme visible sur l'image suivante:

Nous allons maintenant montrer la procédure d'apprentissage au pendant, dans un premier temps avec le pendant simulé puis sur le vrai robot.

Pour cela, nous allons tout d'abord déplacer la plaque dans la vue 3D, en éditant sa position absolue à: (330,-10,220,-150,-3,-100)

Puis nous allons utiliser le pendant pour déplacer manuellement le robot afin d'apprendre un point et un repère.

• Synchroniser la vue 3D avec le simulateur
• Sur le pendant, sélectionner le mode Manuel (1) pour avoir accès aux menu JOG puis cliquer sur l’icône en forme de maison (2), puis sur JOG (3) afin d'entrer dans le mode de pilotage manuel du robot pour l'apprentissage comme sur l'image suivante:

L'image suivante montre le pendant en mode JOG:

• 1: le mode Jog
• 2: l'application
• 3: l'outils selectionné comme TCP
• 4: le repère de référence utilisé pour les déplacements cartésiens
• 5: le point ou joint selectionné: noter qu'appuyer sur pause permet d'amener le robot au point/joint
• 6: le réglage de vitesse de déplacement
• 7: les commandes de déplacements

Cliquer ensuite sur Joint pour pouvoir déplacer le robot avec des commandes de vitesses articulaires, et jouer sur les boutons de J1 a J6, en réglant la vitesse de déplacement avec les boutons +/- situé tout en haut.

Pour apprendre une position articulaire, cliquer sur les boutons 1 et 2 indiqués sur l'image suivante:

Cliquer ensuite sur 3, sélectionner Joint en 3b puis sur le joint à apprendre en 4, puis sur 5 et finalement sur Ok dans la fenêtre qui s'ouvre si la position convient:

Noter qu'il est possible de cliquer sur le stylo en bleu en haut pour rentrer les valeurs numériques du joint.

Cliquer sur Repère ou Outils pour pouvoir déplacer le robot avec des commandes de vitesses cartésiennes, et jouer sur les boutons de X,Y,Z,RX,RY,RZ, en réglant la vitesse de déplacement avec les boutons +/- situé tout en haut.

• En mode Repère: vous déplacez l'outil par rapport au repère de référence, par des mouvements exprimés dans le repère de référence (z vers le haut pour world).
• En mode Outils: vous déplacez l'outil par rapport au repère de référence, par des mouvements exprimés dans le repère de l'outil (z vers la tache).

Pour les positions cartésiennes, il est primordial de choisir l'outil (TCP) dont la pose est réglée. Par défaut, c'est flange (bride) qui est réglée. Pour changer l'outil, cliquer sur 1 puis 2, après quoi l'outil sélectionné deviendra visible en 3 sur l'image suivante:

Cliquer ensuite sur 3, sélectionner Point en 3b puis sur le point à apprendre en 4, puis sur 5 et finalement sur Ok dans la fenêtre qui s'ouvre si la position convient:

Noter que dans la fenêtre qui s'ouvre pour apprendre le point, il est possible de conserver la config (slider “Apprendre la configuration” vers la gauche) ou d'en apprendre une nouvelle (droite):

Noter qu'il est possible de cliquer sur le stylo en bleu en haut pour rentrer les valeurs numériques du point.

Pour apprendre un frame, cliquer sur les boutons 1 et 2 puis 3 indiqués sur l'image suivante:

• Déplacer l'outil à la position de l'origine du frame à apprendre (l'orientation de l'outil n'est pas importante ici), puis cliquer sur 1 puis 2 indiqués sur l'image suivante:

Déplacer l'outil dans la direction Ox du frame à apprendre, puis cliquer sur 1 puis 2 indiqués sur l'image suivante:

Déplacer l'outil dans le plan Oxy du frame à apprendre, puis cliquer sur 1 puis 2 indiqués sur l'image suivante. Il est important que ce troisième point soit du coté y>0 par rapport au vecteur Ox afin d'orienter correctement les axes y et z du frame appris (qui est un trièdre direct):

Finalement, le pendant affiche les coordonnées du frame appris, cliquer sur appliquer si il vous convient:

Cliquer finalement sur le bouton Arrêt pour quitter le mode JOG et laisser le programme VAL3 avoir le contrôle des mouvements du robot.

Nous allons maintenant créer un nouveau programme startlogo dans votre application.

Copier coller le contenu du programme start dans le programme startlogo pour le conserver. Vous pouvez maintenant modifier le programme start pour cette partie du TP.

Vous allez maintenant devoir réaliser une tâche de Saisie et dépose de pièces avec le robot. Pour cela, vous aller ajouter une pince au robot à la place du stylo.

L'objectif est de déplacer de manière répétitive 2 pièces initialement placées en pA et pC sur une palette comme montré sur l'image suivante:

Télécharger les modèles 3D suivants dans un dossier autre que celui du projet SRS: https://bvdp.inetdoc.net/files/iut/robotiqueBUT2/SchunkEGP40.wrl

https://bvdp.inetdoc.net/files/iut/robotiqueBUT2/pion_rouge.wrl

https://bvdp.inetdoc.net/files/iut/robotiqueBUT2/PALETTE_INCLINEE.wrl

Informations sur les dimensions de la palette: https://bvdp.inetdoc.net/files/iut/robotiqueBUT2/PALETTE.pdf

Pour ajouter la pince au robot:

1. L'outil stylo Tool1 est déjà attaché au handler du robot: Vue 3D→Scene→Robot→Controleur→Base→Tool1 clic droit et Détacher
2. Déplacer l'outil inutilisé hors de la zone utile du robot
3. Masquer le robot: cliquer droit sur l'arborescence de scène sur Controller et décocher “Afficher le robot”. Faire de même sur la cellule du robot.
4. Onglet Modeleur→Ajouter un modèle CAO
5. Sélectionner le fichier SchunkEGP40.wrl
6. choisir Copier et insérer le fichier, puis Ok
7. l'objet apparait dans l'arbre en tant que Géométrie, cliquer droit dessus et faire “nouvel outils”
8. NE PAS déplacer l’outil (car il est normalement bien positionné)
9. choisir dans l'arbre l’outil et son handle
10. cliquer sur “Édition” dans l'onglet Modeleur
11. cliquer droit sur handle et “Éditer la position”
12. Régler tout à 0 dans la position absolue
13. cliquer droit sur handler et “Éditer la position”
14. Régler tout à 0 dans la position absolue sauf Z à 160.00
15. Sortir du mode Édition: Onglet modeler→Édition ne doit plus être bleu
16. Cliquer droit sur Tool2 dans l'arborescence, attacher à et choisir le handler du robot
17. réactiver l'affichage du robot et de la cellule

Ensuite il faut créer une donnée tPince de type Tool et associer l’outil à la variable tPince, pour cela:

1. Sélectionner le Tool2 dans l'arborescence de la vue 3D puis faire CTRL+C
2. Pour utiliser un outils de la géométrie graphique vers une variable val3, il faut clic gauche sur le handler de l’outil, CTRL+C et coller dans la ligne de la variable tPince[0] dans l'onglet données. Vous devriez obtenir un vecteur dont toutes les composantes sont à 0 à l’exception du champ Z à 160.00.

Ensuite, cliquer droit sur le handler de l’outil puis définir comme TCP (Tool Center Point= Centre De l’Outil) pour pouvoir déplacer l’outil.

Vous devriez voir la pince solidaire de la bride du robot, comme sur la figure suivante, dans laquelle le repère du haut est le handler du robot connecté au handle de la pince (sur la bride), alors que le repère du bas est le handler de la pince, situé au centre des mors:

Le modèle 3D de la pince n'est pas animé, elle ne s'affichera donc pas ouverte ou fermée, c'est normal!

Nous allons maintenant indiquer (via la variable tPince utilisable par l'application) comment le robot pilote l'ouverture/fermeture de la pince et de combien de temps la pince a besoin pour effectuer l'action.

Dans la fenêtre Données, choisir tPince[0] et double cliquer en dessous de la colonne gripper pour ouvrir la configuration d'entrées sorties physiques comme visible sur l'image suivante:

Choisir FastIO\fOut1 .

Saisir 1 pour les 2 champs suivants (OTime et CTime) qui permettent de régler les durées de délais en seconde(s) pour que la pince s'ouvre et se ferme après que la commande lui soit envoyée.

Nous allons maintenant configurer le simulateur de pince, qui va permettre l'utilisation de la pince dans la vue 3D, pour interagir avec des pièces virtuelles.

1. Dans Vue3D→Tool2→clic droit puis Configuration d'outil
2. Dans la fenêtre Configuration d'outil qui apparait, cliquer sur l’icône + bleue.
3. Sélectionner Créer “une machine à état de pince” sur “Tool2.handler”.
4. Déclencheur, choisir fOut1 et Off

Configurer le simulateur comme montré sur les images suivantes:

Attention, ici les délais de transitions sont en ms, donc mettre 500 et pas 0.5.

1. Importer le modèle CAD de PALETTE_INCLINEE.wrl
2. Dans Vue3D→Géométrie→Palette_INCLINEE.wrl, cliquer droit et éditer la position, régler (320, 100, 200, 30 ,0, 0) en position absolue.
3. Importer le modèle CAD de pion_rouge.wrl
4. Dans Vue3D→Géométrie→pion_rouge.wrl, cliquer droit et éditer la position, régler (220, 37, 250, 30 ,0, 0) en position absolue.
5. Dans Vue3D→Géométrie→pion_rouge.wrl, cliquer droit et Nouvelle pièce : la pièce apparait maintenant dans Scène→Pièces Mobiles et va pouvoir être manipulée par le robot après que nous ayons configuré son handle:
6. Onglet Modeleur→Édition, puis dans Vue3D→Pièces Mobiles→Part→Handle cliquer droit puis Éditer la position, régler (220, 33.24, 257.26, 210 ,0, 0) en position absolue.
7. Sortir du mode Édition: Onglet modeleur→Édition ne doit plus être bleu

Vous noterez que le handle qui vient d'être configuré correspond au handler de la pince lorsque celle ci vient saisir la pièce, avec l'axe z vers le bas.

Nous allons maintenant dupliquer la pièce et placer la copie en position pC:

1. Vue3D→Pièces Mobiles→Part cliquer droit et copier
2. Vue3D→Pièces Mobiles cliquer droit et coller
3. Vue3D→Pièces Mobiles→Part→pion_rouge.wrl clic droit et éditer la position, régler (200, 0, 0, 0, 0, 0) en position relative, afin d'amener la copie en pC.

Comme les pièces mobiles vont être déplacées par le robot, il est judicieux de mémoriser les positions initiales des pièces pour pouvoir les repositionner à chaque nouvelle simulation.

Pour chaque pièce, Vue3D→Scène→Pièces Mobiles→Part clic droit et Enregistrer position initiale

Pour remettre en position initiale, il suffira de faire Vue3D→Scène→Pièces Mobiles→Part clic droit et Mettre en position initiale.

Il est également possible d'enregistrer/remettre en position initiale TOUTES les pièces dans l'onglet Simulation.

Pour chaque pièce, Cliquer droit sur le handle de la pièce dans la vue 3D puis Déplacer ici→Controller tx2_60 et vérifier que la pince se positionne correctement sur les pièces.

Si dans l'onglet Simulation→Collision est bleuté alors la pince doit apparaître en rouge car elle rentre en collision avec la pièce. C'est normal car le modèle CA0 est celui de la pince est fermée!

Créer 3 données de type PointRX pA, pB et pC. Ces points seront appris dans le repère World (par défaut) mais il aurait été possible de créer un frame associé au plan de la palette pour pouvoir accéder à n'importe quel emplacement, ce qui sera illustré à l'exercice suivant (Kapla). Une fois la pince du robot positionnée sur la pièce, apprendre pA en faisant Données→..→pointRX→pA→pA[0] clic droit et Ici. Faire de même pour pB et pC. (Pour pB vous pourrez déplacer temporairement une des pièces et régler sa position relative)

Écrire le programme start qui doit:

1. Amener le robot à la position articulaire jBrasBaisse
2. Ouvrir la pince (consulter la documentation VAL3 pour les fonctions open(tTool) et close(tTool)
3. Appeler en boucle un programme cycle

Il ne faut surtout pas amener la pince saisir la piece avec la pince fermée!

Le programme cycle doit enchainer Etape1, Etape2 et Etape3 comme visible sur l'image. Toutes ces étapes partagent le même comportement et uniquement les points de saisie et de dépose changent… Il convient donc de mutualiser le code dans un sous programme et de faire varier ses paramètres. Pour cela vous allez écrire le programme picknplace(point x_pSaisie,point x_pDepose) qui doit réaliser le cycle en U ainsi que la commande de la pince.

Simuler votre programme et observer le robot qui déplace les pièces sur la palette. Il est important de démarrer la synchronisation de la vue 3D rapidement après avoir lancé votre programme pour que le robot puisse saisir les pièces dans la vue 3D avant qu'il ne se soit déplacé.

Pendant la simulation, il est possible d’observer la simulation de la pince en ouvrant la fenêtre: Accueil→Vue3D→État de la simulation. Ainsi, malgré que le modèle de la pince ne soit pas animé, vous pourrez savoir à chaque instant si elle est ouverte ou fermée dans la simulation.

Dans start, ajouter avant l'appel de cycle:

l_nDateDepart=clock()

Rajouter après l'appel de cycle:

l_nDuree=clock()-l_nDateDepart
//affichage d'un message sur le pendant
popUpMsg("duree du cycle:"+toString(".3",l_nDuree))

Ajouter les variables locales l_nDateDepart et l_nDuree à start

Simuler votre programme et mesurer le temps de cycle en mode manuel avec le réglage de vitesse à 100%. L'affichage se fait sur le pendant dans la fenêtre Information, accessible en cliquant sur l’icône I en haut à gauche de l'écran.

Observer la reproductibilité de la mesure de temps de cycle.

Jouer sur le descripteur de mouvement pour essayer de diminuer le temps de cycle.

A partir de 7 kapla disposés à intervalle régulier sur une palette (tous les 50mm), le robot devra constituer une tour de kapla à un autre endroit sur le plan de travail.

Les dimensions d’un Kapla sont : 𝐿 × 𝑙 × ℎ = 110 × 22 × 7 (mm) . Ils seront disposés sur la tranche sur la palette et dans la tour.

Les Kapla sont initialement disposés dans une palette avec 15 emplacements. Le premier emplacement (numéroté 0) est utilisé pour l'apprentissage du frame et sert à ranger l'outil d'apprentissage (une pièce en forme de kapla mais avec des cales permettant de contraindre sa position dans la pince.

Il faut remplir avec des kapla un emplacement tous les 2 seulement car les mors de la pince risque d'entrer en collision avec un kapla placé dans l'emplacement adjacent.

Créer le programme kapla ainsi que les données les données/variables locales suivantes:

Données à créer pour la Saisie:

• Un repère pour la saisie fSaisieKapla centré sur la position de la pince pour saisir le premier (outil d'apprentissage) Kapla de la palette.
• Un tableau de points de saisie des Kapla pSaisieKapla attaché au frame fSaisieKapla[0] et dont le premier est situé à l’origine du repère de pose et avec son champ trsf à 0. Le tableau suivant montre les premières valeurs et vous devez le compléter:

L'axe X du frame fSaisieKapla est donc dirigé dans le sens des pièces d'indice croissant. L'axe Z est quant à lui orienté vers le bas (comme l’outil).

Données à créer pour la Dépose:

• Un repère de pose fPoseKapla centré à la base de tour
• Un tableau de points de pose pPoseKapla attaché au frame fPoseKapla[0] et dont le premier est situé à l’origine du repère de pose et avec son champ trsf à 0. On donne ci-dessous la disposition avec les transformations pour constituer la tour pour les premiers points et vous devez le compléter:

L'apprentissage a été réalisé par l'enseignant et voici les valeurs à affecter:

• fPoseKapla[0]={181.42543, -350.642119, -168.982315, -179.999965, 0.00585465, -0.000150845}
• fSaisieKapla[0]={-318.167237, -335.317881, -159.955252, -179.0402669, 0.171573, -0.905223}

Données à créer:

• Une Variable numérique pour le nombre de Kapla à manipuler dans un cycle: nKapla=7

Variable locale à créer:

• Une variable numérique pour compter le Kapla courant l_nKaplaCourant

La boucle du programme principal consiste simplement à appeler un programme kapla qui itère (faire une boucle) sur toutes les cases du tableau pSaisieKapla pour faire la saisie de pSaisieKapla[l_nKaplaCourant] et la dépose vers pPoseKapla[l_nKaplaCourant]. Vous devrez bien sûr utiliser le programme picknplace fait à l'exercice précédent!

Appeler le programme kapla depuis start une fois avant la boucle while. Simuler votre programme “à vide” sans les pièces dans la Vue 3D pour vous assurer du bon fonctionnement puis appeler un enseignant pour valider sur le robot réel.

Les points d'indice 0 des tableaux pSaisieKapla et pPoseKapla servent à l'apprentissage et à la vérification en début de cycle. Il conviendra de ne pas mettre de kapla dans le premier emplacement de la palette.

Pour apprendre les repères fSaisieKapla et fPoseKapla, nous utilisons un outillage en forme de Kapla avec un centreur sur la pince.

La procédure pour l'apprentissage est indiquée ici pour information:

Pour fSaisieKapla, il conviendra de positionner cet outillage:

• Dans le premier emplacement de la palettes pour apprendre l'origine de fSaisieKapla.
• Dans le dernier emplacement de la palettes pour apprendre l'axe OX de fSaisieKapla.
• Dans le plan OXY en utilisant une cale d'épaisseur (de même épaisseur que le fond de la palette) posée sur le plan de la table, afin d'avoir OZ=OX^OY orienté vers la table.

Pour fPoseKapla, il conviendra de positionner cet outillage:

• Au centre de la position pour constuire la tour, en contact avec la table.
• Puis à 2 positions distantes d'au moins 10cm dans les directions OX et OY, en contact avec la table, afin d'avoir OZ=OX^OY orienté vers la table.

Utiliser openscad pour modeliser un kapla (faire F6 puis exporter vers STL pour générer un modèle CAO importable dans SRS).

Faire de même pour la palette (en utilisant difference() et for pour décrire le modèle facilement).

Importer les modèles CAO dans SRS, définir un handle sur le modèle de Kapla avant de le dupliquer. Utiliser Editer la position et régler des positions relatives disantes de 25mm en X pour positionner les Kapla avant d'enregistrer leurs posisitons initiales puis simuler!

Après avoir sauvé une version de votre programme, vous allez devoir le modifier pour qu'il remplisse lui même les valeurs des tableaux pSaisieKapla et pPoseKapla de nKapla points. Vous pourrez le faire à l'aide d'une simple boucle et en utilisant les opérateurs division entière et modulo. Il est conseillé de rajouter en tête de votre programme le calcul des points et de vérifier le bon remplissage des points à l'aide de l'outil de débug.

, vous êtes arrivés à la fin du TP!

Régulièrement, sauver l'état de votre projet, pour pouvoir revenir en arrière par exemple, ou pour pouvoir observer les changements de fichiers.

Ouvrir une fenêtre de commande powershell dans le dossier de votre projet staubli: faire shift+clic droit sur le dossier du projet dans explorer puis cliquer sur powershell (ou cliquer sur Fichier puis ouvrir avec powershell).

L'outil de gestion de version a déjà été utilisé pour configurer un suivi dans le dossier fourni, il ne vous reste qu'à ajouter vos versions.

A la première utilisation, pour configurer votre identité, copier-coller dans une console Windows en adaptant:

git config --global user.name "Bertrand Vandeportaele"   
git config --global user.email secret@meninblack.jupiter

ATTENTION, l'outils git sauvegarde l'état des fichiers tels qu'ils sont sur le disque. Il faut donc veiller à sauver tous les fichiers depuis SRS avant chaque sauvegarde avec git!

Ensuite pour enregistrer une version de TOUS les fichiers du projet (nous verrons plus tard comment sélectionner uniquement certains fichiers), et voir les différentes versions, copier dans la fenêtre de commande powershell depuis le dossier du projet:

git add * 
git commit -m"un commentaire indiquant ce que fait cette version, entre guillemets"
gitk
 

Configurer dans l'outil de téléversement:

IP du cs9: 172.16.8.250
utilisateur: default
mdp: default

Choisir ensuite dans la partie gauche votre application (code + données + interface graphique) puis cliquer sur la flèche supérieure (orientée de gauche à droite).

Pour rapatrier les données apprises sur le robot il convient:

• de sauver sous GIT votre projet en commitant une version nommée “avant apprentissage”.
• de sélectionner dans la fenêtre de droite votre Projet→application→données
• de cliquer sur la flèche supérieure (orientée de droite à gauche).
• de recharger votre application dans SRS (dans Cellule→Contrôleur→application clic droit puis recharger l'application) afin de prendre en compte les fichiers de données téléchargés.
• de sauver sous GIT votre projet en commitant une version nommée “après apprentissage”