RoboDK unterstützt die Brooks PreciseFlex-Roboter unter Verwendung der GPL (Guidance Programming Language). Benutzer können fortschrittliche Laborautomatisierungsprogramme mit einer Auswahl ihrer Roboterarme, Greifer und Linearschienen erstellen.
Um die Brooks PreciseFlex IntelliGuide-Greifer, einschließlich des IntelliGuide s23D-Doppelgreifers, von einer Simulation aus zu steuern, folgen Sie den in diesem Abschnitt beschriebenen Schritten.
1.Klicken Sie mit der rechten Maustaste auf Ihr Programm, und fügen Sie eine Programmaufruf-Anweisung hinzu.
2.Geben Sie "Gripper(Greifer-ID, Greiferwert)" ein. Zum Beispiel "Gripper(2, 50)", um den Greifer #2 eines Doppelgreifers auf 50 mm zu bewegen.
a.Bei einem einzelnen Greifer können Sie den Aufruf zu "Gripper(Greiferwert)" abkürzen.
b.Wenn mehr als ein Roboter vorhanden ist, verwenden Sie "Gripper(Greifer-ID, Greiferwert, item.ptr)". Beispiel: "Gripper(2, 50, item.ptr)" bewegt den Greifer #2 eines Doppelgreifers auf 50 mm und stellt sicher, dass der übergeordnete Roboter mit dem Programm verknüpft ist.
3.Fügen Sie die Anweisung Gripper() als erste Anweisung aller Unterprogramme und nach allen Unterprogrammaufrufen ein. Dies dient der Kompatibilität mit dem Postprozessor. Doppelte Gripper()-Anweisungen werden erwartet.
4.Fügen Sie ein Python-Skript hinzu und benennen Sie es in "Gripper" um.
5.Bearbeiten Sie das Python-Skript "Gripper" und fügen Sie Folgendes ein:
from robodk import robolink
import sys
if len(sys.argv) < 2:
quit()
def get_item(ptr_item, RDK):
item = robolink.Item(RDK, str(ptr_item), robolink.ITEM_TYPE_PROGRAM)
if not item.Valid(True):
return None
return item
RDK = robolink.Robolink()
gripper_id = -1
gripper_value = 0
prog_item = None
# Get the gripper ID, value, possibly the caller
if 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)
if prog_item:
gripper_value = float(sys.argv[1])
else:
gripper_id = int(sys.argv[1])
gripper_value = float(sys.argv[2])
# Get candidates
grippers = [x for x in RDK.ItemList(robolink.ITEM_TYPE_ROBOT_AXES) if 'intelliguide' in x.Name().lower() and len(x.Joints().tolist()) == 1]
if len(grippers) > 1 and prog_item:
robot_item = prog_item.getLink(robolink.ITEM_TYPE_ROBOT)
if not robot_item.Valid():
robot_item = RDK.ItemUserPick("Select the linked robot", robolink.ITEM_TYPE_ROBOT)
prog_item.setRobot(robot_item)
def get_flat_childs(item):
childs = item.Childs()
for child in item.Childs():
childs.extend(get_flat_childs(child))
return childs
childs = get_flat_childs(robot_item)
grippers = [x for x in childs if x.Type() == robolink.ITEM_TYPE_ROBOT and len(x.Joints().tolist()) == 1]
if not grippers:
RDK.ShowMessage('Unable to find a gripper!', False)
# Try to find the right gripper id (i.e. Dual Gripper 1)
gripper = grippers[0]
if gripper_id > 0:
gripper_ids = [g for g in grippers if g.Name().endswith(str(gripper_id))]
if gripper_ids:
gripper = gripper_ids[0]
gripper.MoveJ([gripper_value])
Beachten Sie, dass diese Methode auch mit dem Brooks Postprozessor kompatibel ist.
Da das Basis-Bezugssystem des PreciseFlex-Roboters nicht an der physischen Basis des Roboters liegt, sind bestimmte Versätze zwischen den PreciseFlex-Robotern und den PreciseFlex-Linearschienen erforderlich.
Brooks PreciseFlex Linearschiene 0-Grad-Konfiguration:
a.Brooks PreciseFlex 400: [118, 0, 45.6, 0, 0, 0]
b.Brooks PreciseFlex 3400: [118, 0, 62.6, 0, 0, 0]
Brooks PreciseFlex Linearschiene -90-Grad-Konfiguration:
a.Brooks PreciseFlex 400: [101.6, 0, 45.6, 0, 0, 0]
b.Brooks PreciseFlex 3400: [101.6, 0, 62.6, 0, 0, 0]
Die Linearschiene muss synchronisiert werden, damit der Postprozessor die Position der Achse berücksichtigen kann. Weitere Informationen finden Sie im Abschnitt https://robodk.com/doc/en/General.html#SyncAxes.
Um Ziele korrekt im Weltbezugssystem des Roboters zu speichern und sie später in einem mit dem Postprozessor erstellten GPL-Projekt zu verwenden, muss der Benutzer ein neues Bezugssystem definieren. Dieses muss in Bezug auf das Bezugssystem der Station definiert werden, mit denselben Versätzen, die zuvor zwischen der Roboterbasis und der Linearschiene verwendet wurden (wie oben angegeben). Die Ziele müssen in Bezug auf dieses Bezugssystem definiert werden.
Nachfolgend ist ein Bild zu sehen, das einen PreciseFlex 400 Roboter zeigt, der auf einer 1 m langen Linearschiene (in 0-Grad-Konfiguration) montiert ist, sowie das als Weltbezugssystem des Roboters definierte Bezugssystem.
Öffnen Sie nach der Erstellung des GPL-Projekts die Datei Main.gpl mit einem beliebigen Texteditor und kommentieren Sie die Zeile aus, in der das Basis-Bezugssystem des Roboters definiert wird:

Aufgrund der einzigartigen Kinematik des Brooks PreciseFlex c8A Roboters wurde sein Modell in RoboDK durch die Kombination der Modelle zweier Roboter entwickelt, um die 3+3 Freiheitsgrade des Roboterarms zu verarbeiten.

Durch diese Entwicklung ist es nicht möglich, die Modelle der Brooks PreciseFlex c8A Roboter in Kombination mit dem Brooks Postprozessor zu verwenden.
Die Brooks PreciseFlex c8A Roboter sind mit keinem der Brooks PreciseFlex IntelliGuide Greifer kompatibel.
Wenn ein Tool Center Point (TCP) hinzugefügt werden muss, muss dieser in Bezug auf den Flansch des Handgelenkmechanismus des Roboters definiert werden. Beachten Sie die im Abschnitt "Tool Center Point (TCP)" angegebenen Informationen, um die Pose des TCP so einzustellen, wie er in der Steuerung des Roboters konfiguriert ist.
Ähnlich wie beim Brooks PreciseFlex c8A Roboter wurden die Brooks PreciseFlex 100 XZTS Roboter durch die Kombination der Modelle zweier Roboter entwickelt, denen der Greifer hinzugefügt wurde. Dies ermöglicht die Verarbeitung der 3 Freiheitsgrade des Arms (lineare Bewegungen entlang der X- und Z-Achse sowie die Rotation Theta um die Z-Achse) sowie des Freiheitsgrads des Greifers.
Der Brooks PreciseFlex 100 XZTS mit einem Bewegungsbereich von 685 mm auf der X-Achse wird nachfolgend dargestellt.

Wie der Brooks PreciseFlex c8A Roboter sind auch die Brooks PreciseFlex 100 XZTS Roboter nicht mit dem Postprozessor kompatibel.
Wenn ein Tool Center Point (TCP) hinzugefügt werden muss, muss dieser in Bezug auf den Flansch des Theta-Mechanismus (Rotation um die Z-Achse) des Roboters definiert werden.

Beachten Sie die im Abschnitt "Tool Center Point (TCP)" angegebenen Informationen, um die Pose des TCP so einzustellen, wie er in der Steuerung des Roboters konfiguriert ist.
In diesem Abschnitt finden Sie einige Tipps zur Erstellung von Programmen für Brooks-Roboter.
Der Tool Center Point (TCP) in RoboDK und der in der Robotersteuerung definierte TCP müssen übereinstimmen. Wenn Sie einen Greifmechanismus verwenden, müssen Sie mit "Werkzeug hinzufügen (TCP)" einen TCP hinzufügen, der sich an der erwarteten Position befindet. Der TCP des neuen Werkzeugs sollte mit dem TCP des Greifmechanismus übereinstimmen. Informationen zum Tool Center Point (TCP) des Brooks PreciseFlex Roboters finden Sie, indem Sie das Webinterface aufrufen und die folgenden Schritte ausführen:
1.Admin
2.Einrichtung - Parameterdatenbank
3.Roboter
4.Gelenk-/kartesische Steuerung
5.Dynamische Parameter
6.DataID 16051

Bei den Brooks PreciseFlex DD 4-Achsen- und c10-Robotern muss der in der Robot Bibliothek verfügbare IntelliGuide-ISO-Flansch zu Visualisierungszwecken zum Roboter hinzugefügt werden (beim DD 4-Achsen-Roboter muss die Geometrie des IntelliGuide-ISO-Flansches um 9 mm nach oben verschoben werden).

Das Basis-Bezugssystem jedes der oben genannten Greifer ist eindeutig definiert. Um die Greifer korrekt in Bezug auf das Flansch-Bezugssystem der Roboter zu positionieren, müssen die folgenden Referenzpositionsdaten verwendet werden:
6.Brooks PreciseFlex IntelliGuide s23
7.Brooks PreciseFlex IntelliGuide s60
8.Brooks PreciseFlex IntelliGuide s23D
9.Brooks PreciseFlex IntelliGuide v23
1.Brooks PreciseFlex IntelliGuide v60
Folgende Brooks PreciseFlex IntelliGuide-Greifer sind erhältlich:
Im vorherigen Abschnitt Greifersimulation erfahren Sie, wie Sie die mit dem Postprozessor kompatiblen Greiferanweisungen richtig definieren. Auf diese Weise werden die Positionen im GPL-Projekt richtig definiert und unerwartete Bewegungen der Greiferachse(n) vermieden.
Ein Eingabewert von -1 bedeutet, dass der Roboter am Ende der Bewegung anhält und eine strenge Positionsfehlerbeschränkung angewendet wird (GPL-Code: prof1.InRange = 100).
Ein Eingabewert von 0 bedeutet, dass der Roboter am Ende der Bewegung anhält, aber eine kleine Positionsfehlerbeschränkung angewendet wird (GPL-Code: prof1.InRange = 10).
Ein Eingabewert größer als 0 bedeutet, dass der Roboter am Ende der Bewegung nicht anhält und eine überschliffene Bewegung ausgeführt wird (GPL-Code: prof1.InRange = -1).
Informationen zu den maximalen Linear-, Winkel- und Gelenkgeschwindigkeiten/Beschleunigungen der Brooks PreciseFlex-Roboter finden Sie, indem Sie das Web-Interface aufrufen und die folgenden Schritte ausführen:
1.Admin
2.Einrichtung - Parameterdatenbank
3.Roboter
4.Gelenk-/kartesische Steuerung
5.Dynamische Parameter
6.DataIDs 2700, 2701, 2702 und 2703
Der Benutzer kann die Eingaben der RoboDK Geschwindigkeits-/Beschleunigungsanweisungen festlegen, indem er die Werte der oben genannten DataIDs als Referenzen verwendet. Der Precise-Postprozessor verwendet dann diese Werte, um die Geschwindigkeit/Beschleunigung als Prozentsatz der maximalen Geschwindigkeit/Beschleunigung für jeden Roboter zu berechnen, wie von der GPL-Profilklasse gefordert.
Um die vom Postprozessor verwendeten Grenzwerte zu ändern, können Sie den Postprozessor entsprechend dem von Ihnen verwendeten Roboter anpassen. Standardmäßig verwendet der Postprozessor die Grenzwerte der PF400- und PF3400-Roboter. Lesen Sie den Abschnitt https://robodk.com/doc/en/Post-Processors.html#PPEditor in der Dokumentation, um den Postprozessor zu ändern.
Wenn bei linearen und Winkelbeschleunigungsanweisungen Eingabewerte kleiner als 1 verwendet werden, werden diese Eingaben als Dauer in Sekunden für das Hochfahren auf die Spitzenbeschleunigung/-verzögerung verwendet (GPL-Code: prof1.AccelRamp/prof1.DecelRamp = inputvalue).
Die folgende Abbildung enthält weitere Informationen zu den oben beschriebenen Konzepten und dazu, wie die Steuerung die Bahnen plant, denen der Roboter folgen muss.

Wenn Sie einen Eingabewert größer als 0 eingeben, wird ein GPL-Befehl generiert, der das Programm für die durch den Eingabewert definierte Zeit unterbricht. Ein negativer Eingabewert öffnet ein Popup-Dialogfeld im Operator Control Panel der Webschnittstelle und das Programm wird angehalten, bis der Benutzer auf die Schaltfläche "Continue" im Dialogfeld klickt. Um das Dialogfeld anzuzeigen, muss der Benutzer auf die Schaltfläche "Dialog Active" im Operator Control Panel klicken.
Programme können einfach per FTP von RoboDK an Brooks-Roboter übertragen werden:
1.Klicken Sie mit der rechten Maustaste auf den Roboter in RoboDK
2.Wählen Sie Mit Roboter verbinden...
3.Geben Sie die IP und den Port des Roboters ein (die Standardeinstellung ist 192.168.0.1 mit Port 21)
4.Geben Sie den entfernten FTP-Pfad ein (normalerweise /flash/projects)
Sobald ein RoboDK-Programm bereit ist, an den Roboter gesendet zu werden:
1.Klicken Sie mit der rechten Maustaste auf ein Programm in RoboDK
2.Wählen Sie Programm an Roboter senden (Strg+F6)
Dadurch wird das Programm generiert und versucht, es an die Robotersteuerung zu übertragen. In einem Fenster wird angezeigt, ob die FTP-Übertragung erfolgreich war oder nicht.
Das Webinterface des Roboters muss zum Laden und Starten des GPL-Projekts verwendet werden (Sie können auf das Webinterface des Roboters mit einem beliebigen Browser zugreifen, indem Sie nach der IP-Adresse des Roboters suchen). Unten sehen Sie ein Bild der Startseite des Webinterface.
1.Öffnen Sie einen Webbrowser
2.Geben Sie die IP-Adresse des Roboters ein
So starten Sie das Programm über das Webinterface:
1.Wählen Sie Admin -> Control Panels -> Operator Control Panel -> „Load“.
2.Wählen Sie das mit RoboDK erstellte GPL-Projekt
3.Klicken Sie auf „Select“.
4.Klicken Sie auf „Start“.
An diesem Punkt wird der Roboter das Programm ausführen. Die folgende Abbildung zeigt die Benutzeroberfläche des Operator Control Panels und das Fenster, in dem der Benutzer das benötigte GPL-Projekt auswählen und laden kann.