Robots Brooks
RoboDK prend en charge les robots PreciseFlex de Brooks en utilisant le GPL (Guidance Programming Language). Les utilisateurs peuvent générer des programmes avancés d'automatisation de laboratoire en utilisant une sélection de bras robotiques, de préhenseurs et de rails linéaires.
Simulation de pince
Pour commander les préhenseurs PreciseFlex Brooks à partir d'une simulation, y compris le préhenseur double, suivez les étapes décrites dans cette section.
1.Cliquez avec le bouton droit de la souris sur votre programme et ajoutez une instruction d'appel de programme.
2.Saisissez "Gripper(gripper ID, gripper value)". Par exemple, "Gripper(2, 50)" pour déplacer la pince n°2 d'une pince double à 50 mm.
a.Vous pouvez raccourcir l'appel à "Gripper(valeur du gripper)" avec un seul gripper.
b.Si plusieurs robots sont présents, utilisez "Gripper(gripper ID, gripper value, item.ptr)". Par exemple, "Gripper(2, 50, item.ptr)" déplacera la pince n°2 d'une pince double à 50 mm, en s'assurant que le robot parent est lié au programme.
3.Ajoutez l'instruction Gripper() comme première instruction de tous les sous-programmes et après tous les appels de sous-programmes. Cela permet d'assurer la compatibilité avec le post-processeur. Les instructions Gripper() dupliquées sont attendues.
4.Ajoutez un script Python, renommez-le "Gripper".
5.Modifiez le script Python "Gripper" et collez ce qui suit :
from robodk import robolink
import sys
if len(sys.argv) < 2 :
quitter()
def get_item(ptr_item, RDK) :
item = robolink.Item(RDK, str(ptr_item), robolink.ITEM_TYPE_PROGRAM)
if not item.Valid(True) :
retournez Aucun
article de retour
RDK = robolink.Robolink()
gripper_id = -1
valeur_pince = 0
prog_item = None
# Obtenir l'ID de la pince, la valeur et l'appelant
si len(sys.argv) == 2 :
gripper_value = float(sys.argv[1])
elif len(sys.argv) >= 4 :
gripper_id = int(sys.argv[1])
gripper_value = float(sys.argv[2])
prog_item = get_item(int(sys.argv[3]), RDK)
elif len(sys.argv) == 3 :
prog_item = get_item(int(sys.argv[2]), RDK)
si prog_item :
gripper_value = float(sys.argv[1])
autre :
gripper_id = int(sys.argv[1])
gripper_value = float(sys.argv[2])
# Obtenir des candidats
grippers = [x for x in RDK.ItemList(robolink.ITEM_TYPE_ROBOT_AXES) if 'gripper' in x.Name().lower() and len(x.Joints().tolist()) == 1]
si len(grippers) > 1 et prog_item :
robot_item = prog_item.getLink(robolink.ITEM_TYPE_ROBOT)
if not robot_item.Valid() :
robot_item = RDK.ItemUserPick("Sélectionnez le robot lié", robolink.ITEM_TYPE_ROBOT)
prog_item.setRobot(robot_item)
def get_flat_childs(item) :
childs = item.Childs()
pour child dans item.Childs() :
childs.extend(get_flat_childs(child))
retour enfants
enfants = get_flat_childs(robot_item)
grippers = [x for x in childs if x.Type() == robolink.ITEM_TYPE_ROBOT and len(x.Joints().tolist()) == 1]
si ce n'est pas des pinces :
RDK.ShowMessage('Unable to find a gripper!', False)
# Essayez de trouver l'identifiant du bon préhenseur (c'est-à-dire le préhenseur double 1).
gripper = grippers[0]
si gripper_id > 0 :
gripper_ids = [g for g in grippers if g.Name().endswith(str(gripper_id))]
si gripper_ids :
gripper = gripper_ids[0]
gripper.MoveJ([gripper_value])
Notez que cette méthode est également compatible avec le post-processeur Brooks.
Rails linéaires
Comme le châssis du robot PreciseFlex n'est pas placé à la base physique du robot, des décalages spécifiques sont nécessaires entre les robots PreciseFlex et les rails linéaires PreciseFlex.
Configuration du rail linéaire PreciseFlex de Brooks :
a.Brooks PreciseFlex 400 : [118, 0, 45.6, 0, 0, 0]
b.Brooks PreciseFlex 3400 : [118, 0, 62.6, 0, 0, 0]
Rail linéaire PreciseFlex de Brooks - configuration à 90 degrés :
a.Brooks PreciseFlex 400 : [101.6, 0, 45.6, 0, 0, 0]
b.Brooks PreciseFlex 3400 : [101.6, 0, 62.6, 0, 0, 0]
Le rail linéaire doit être synchronisé pour que le postprocesseur prenne en compte la position de l'axe. Reportez-vous à la section https://robodk.com/doc/en/General.html#SyncAxes pour plus d'informations.
Pour enregistrer correctement les cibles dans le Système de Référence Mondial du robot et les utiliser ultérieurement dans un projet GPL créé à l'aide du postprocesseur, l'utilisateur doit définir un nouveau système de référence. Celui-ci doit être défini par rapport au système de référence de la station, avec les mêmes décalages utilisés précédemment entre la base du robot et le rail linéaire (comme indiqué ci-dessus). Les cibles doivent être définies par rapport à ce système de référence.
L'image ci-dessous montre un robot PreciseFlex 400 monté sur un rail linéaire de 1 m (en configuration à 0 degré) et le système de référence défini comme le Système de Référence Mondial du robot.
Après avoir généré le projet GPL, ouvrez le fichier Main.gpl avec un éditeur de texte quelconque et mettez en commentaire la ligne où le système de référence de base du robot est défini :
Brooks PreciseFlex c8A
En raison de la cinématique unique du robot Brooks PreciseFlex c8A, son modèle a été développé dans RoboDK en combinant les modèles de deux robots, afin de gérer les 3+3 degrés de liberté du bras robotique.
Ce développement rend impossible l'utilisation des modèles des robots Brooks PreciseFlex c8A en combinaison avec le postprocesseur Brooks.
Les robots Brooks PreciseFlex c8A ne sont compatibles avec aucune des pinces Brooks PreciseFlex IntelliGuide.
Si un Point Central de l'Outil (TCP) doit être ajouté, il doit être défini par rapport à la bride du mécanisme du poignet du robot. Consultez les informations indiquées dans le paragraphe « Point Central de l'Outil (TCP) » pour définir la pose du TCP telle qu'elle est configurée dans le contrôleur du robot.
Brooks PreciseFlex 100 XZTS
De la même manière que le robot Brooks PreciseFlex c8A, les robots Brooks PreciseFlex 100 XZTS ont été développés en combinant les modèles de deux robots, auxquels la pince a été ajoutée. Cela permet de gérer les 3 degrés de liberté du bras (mouvements linéaires le long des axes X et Z, et rotation Thêta autour de l'axe Z), ainsi que le degré de liberté de la pince.
Le Brooks PreciseFlex 100 XZTS avec 685 mm de course sur l'axe X est présenté ci-dessous.
Comme le robot Brooks PreciseFlex c8A, les robots Brooks PreciseFlex 100 XZTS ne sont pas compatibles avec le postprocesseur.
Si un Point Central de l'Outil (TCP) doit être ajouté, il doit être défini par rapport à la bride du mécanisme Thêta (rotation autour de l'axe Z) du robot.
Consultez les informations indiquées dans le paragraphe « Point Central de l'Outil (TCP) » pour définir la pose du TCP telle qu'elle est configurée dans le contrôleur du robot.
Post processeur
Cette section présente quelques conseils relatifs à la création de programmes pour les robots Brooks.
Point central de l'outil (CDO)
Le point central de l'outil (CDO) dans RoboDK et dans le contrôleur doit correspondre. Si vous utilisez un mécanisme de préhension, il est nécessaire d'ajouter un CDO à l'aide de "Add-in (CDO)" qui se trouve à la position prévue. Le nouveau CDO de l'outil doit correspondre au CDO du mécanisme de préhension. Les informations relatives au point central de l'outil (CDO) des robots PreciseFlex de Brooks peuvent être trouvées en allant sur l'interface Web et en suivant les étapes suivantes :
1.Administrateur
2.Setup - Base de données des paramètres
3.Robot
4.Contrôle conjoint/cartésien
5.Paramètres dynamiques
6.DataID 16051
Grippeur
Voir la section précédente Simulation de la pince pour savoir comment définir correctement les instructions de la pince compatibles avec le post-processeur. Cette approche permet de définir correctement les emplacements dans le projet GPL, en évitant les mouvements inattendus de l'axe ou des axes de la pince.
Les pinces Brooks PreciseFlex IntelliGuide disponibles sont :
6.Brooks PreciseFlex IntelliGuide s23
7.Brooks PreciseFlex IntelliGuide s60
8.Brooks PreciseFlex IntelliGuide s23D
9.Brooks PreciseFlex IntelliGuide v23
10.Brooks PreciseFlex IntelliGuide v60
Le système de référence de base de chacune des pinces ci-dessus est défini de manière unique. Pour positionner correctement les pinces par rapport au Système de Référence de la Bride des robots, les informations de position de référence suivantes doivent être utilisées :
En ce qui concerne les robots Brooks PreciseFlex DD 4 axes et c10, la bride ISO IntelliGuide disponible dans la Bibliothèque de Robots doit être ajoutée au robot à des fins de visualisation (pour le robot DD 4 axes, la géométrie de la bride ISO IntelliGuide doit être déplacée de 9 mm vers le haut).
Arrondi
Une valeur d'entrée de -1 détermine que le robot s'arrêtera à la fin du mouvement et qu'une contrainte d'erreur de position stricte sera appliquée (code GPL : prof1.InRange = 100).
Une valeur d'entrée de 0 détermine que le robot s'arrêtera à la fin du mouvement, mais qu'une petite contrainte d'erreur de position sera appliquée (code GPL : prof1.InRange = 10).
Une valeur d'entrée supérieure à 0 détermine que le robot ne s'arrêtera pas à la fin du mouvement et qu'un mouvement mixte sera exécuté (code GPL : prof1.InRange = -1).
Vitesse et accélération
Les informations relatives aux vitesses/accélérations linéaires, angulaires et articulaires maximales des robots Brooks PreciseFlex peuvent être obtenues en allant sur l'interface Web et en suivant les étapes suivantes :
1.Administrateur
2.Setup - Base de données des paramètres
3.Robot
4.Contrôle conjoint/cartésien
5.Paramètres dynamiques
6.DataIDs 2700, 2701, 2702, et 2703
L'utilisateur peut définir les entrées des instructions de vitesse/accélération de RoboDK en utilisant les valeurs des DataID ci-dessus comme références. Le post-processeur Precise utilisera ensuite ces valeurs pour calculer la vitesse/accélération en pourcentage de la vitesse/accélération maximale pour chaque robot, comme le demande la classe de profil GPL.
Pour modifier les limites utilisées par le postprocesseur, vous pouvez modifier le postprocesseur en fonction du robot spécifique que vous utilisez. Par défaut, le postprocesseur utilise les limites des robots PF400 et PF3400. Reportez-vous à la section https://robodk.com/doc/en/Post-Processors.html#PPEditor de la documentation pour modifier le postprocesseur.
Si des valeurs d'entrée inférieures à 1 sont utilisées avec les instructions d'accélération linéaire et angulaire, ces entrées seront utilisées comme la durée en secondes de l'accélération/décélération maximale (code GPL : prof1.AccelRamp/prof1.DecelRamp = valeur d'entrée).
L'image ci-dessous donne plus d'informations sur les concepts décrits ci-dessus et sur la manière dont le contrôleur planifie les trajectoires que le robot doit suivre.
Pause
La définition d'une valeur d'entrée supérieure à 0 génère une commande GPL qui interrompt le programme pendant la durée définie par la valeur d'entrée. Une valeur d'entrée négative ouvrira une boîte de dialogue contextuelle sur le panneau de contrôle de l'opérateur de l'interface Web et le programme sera interrompu jusqu'à ce que l'utilisateur clique sur le bouton "Continuer" de la boîte de dialogue. Pour visualiser la boîte de dialogue, l'utilisateur doit cliquer sur le bouton "Boîte de dialogue active" du panneau de contrôle de l'opérateur.
Transférer des programmes via FTP
Les programmes peuvent être facilement transférés via FTP depuis RoboDK pour les robots Brooks :
1.Cliquez avec le bouton droit de la souris sur le robot dans RoboDK.
2.Sélectionnez Connecter au robot...
3.Entrez l'IP et le port du robot (l'IP par défaut est 192.168.0.1 avec le port 21).
4.Saisissez le parcours FTP distant (généralement /flash/projets)
Une fois qu'un programme RoboDK est prêt à être envoyé au robot :
1.Cliquez avec le bouton droit de la souris sur un programme dans RoboDK
2.Sélectionnez Envoyer le programme au robot (Ctrl+F6).
Cette opération génère le programme et tente de le transférer au contrôleur du robot. Une fenêtre s'ouvre pour indiquer si le transfert FTP a réussi ou non.
Démarrer un programme de robot
L'interface Web du robot doit être utilisée pour charger et démarrer le projet GPL (il est possible d'accéder à l'interface Web du robot en utilisant n'importe quel navigateur et en recherchant l'adresse IP du robot). Vous trouverez ci-dessous une image de la page d'accueil de l'interface Web.
1.Ouvrez un navigateur web
2.Saisissez l'adresse IP du robot
Pour lancer le programme à partir de l'interface Web
1.Sélectionnez Admin -> Panneaux de contrôle -> Panneau de contrôle de l'opérateur -> "Charger".
2.Sélectionnez le projet GPL créé à l'aide de RoboDK
3.Cliquez sur "Sélectionner"
4.Cliquez sur "Démarrer"
Le robot exécute alors le programme. L'image ci-dessous montre l'interface du panneau de commande de l'opérateur et la fenêtre qui permet à l'utilisateur de sélectionner et de charger le projet GPL nécessaire.
