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.

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.

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.