Brooks-Roboter
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-Greifer, einschließlich des 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 "Greifer(Greifer-ID, Greiferwert)" ein. Zum Beispiel "Greifer(2, 50)", um den Greifer #2 eines Doppelgreifers auf 50 mm zu bewegen.
a.Sie können den Aufruf von "Greifer(Greiferwert)" mit einem einzigen Greifer abkürzen.
b.Wenn mehr als ein Roboter vorhanden ist, verwenden Sie "Greifer(Greifer-ID, Greiferwert, item.ptr)". Beispiel: "Greifer(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:
von robodk import robolink
sys importieren
wenn 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 Keine
Artikel zurückgeben
RDK = robolink.Robolink()
gripper_id = -1
gripper_value = 0
prog_item = Keine
# Ermitteln Sie die Greifer-ID, den Wert und den Aufrufer.
wenn 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])
sonst:
gripper_id = int(sys.argv[1])
gripper_value = float(sys.argv[2])
# Kandidaten holen
grippers = [x for x in RDK.ItemList(robolink.ITEM_TYPE_ROBOT_AXES) if 'gripper' in x.Name().lower() and len(x.Joints().tolist()) == 1]
wenn len(Greifer) > 1 und prog_item:
robot_item = prog_item.getLink(robolink.ITEM_TYPE_ROBOT)
if not robot_item.Valid():
robot_item = RDK.ItemUserPick("Wählen Sie den verknüpften Roboter", robolink.ITEM_TYPE_ROBOT)
prog_item.setRobot(robot_item)
def get_flat_childs(Artikel):
childs = item.Childs()
for child in item.Childs():
childs.extend(get_flat_childs(child))
Rückgabe Kinder
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]
wenn nicht Greifer:
RDK.ShowMessage('Es wurde kein Greifer gefunden!', False)
# Versuchen Sie, die richtige Greifer-ID zu finden (z.B. Dualer Greifer 1).
Greifer = Greifer[0]
wenn 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 der Grundrahmen des PreciseFlex-Roboters nicht an der physischen Basis des Roboters platziert ist, sind bestimmte Versätze zwischen den PreciseFlex-Robotern und den PreciseFlex-Linearschienen erforderlich.
Brooks PreciseFlex Linearschienen-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.
In diesem Abschnitt finden Sie einige Tipps zur Erstellung von Programmen für Brooks-Roboter.
Der Tool Center Point (TCP) in RoboDK und in der Steuerung muss ü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.Gemeinsame/kartesische Kontrolle
5.Dynamische Parameter
6.DataID 16051
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 gemischte 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.Gemeinsame/kartesische Kontrolle
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 in der Webschnittstelle Operator Control Panel und das Programm wird angehalten, bis der Benutzer auf die Schaltfläche "Weiter" im Dialogfeld klickt. Um das Dialogfeld zu visualisieren, muss der Benutzer auf die Schaltfläche "Dialog aktiv" im Bedienfeld klicken.
Programme können einfach per FTP von RoboDK für 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 die Webschnittstelle
1.Wählen Sie Verwaltung -> Kontrollfelder -> Bediener-Kontrollfeld -> "Laden".
2.Wählen Sie das mit RoboDK erstellte GPL-Projekt
3.Klicken Sie auf "Auswählen".
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.
