Post Prozessoren
Postprozessoren sind ein wichtiger Schritt in der Offline-Programmierung, da sie die Flexibilität bieten, jede Robotersteuerung zu unterstützen. Ein Roboterpostprozessor definiert, wie Roboterprogramme für eine bestimmte Robotersteuerung erzeugt werden müssen.
Das Umwandeln von einer RoboDK-Simulation in ein bestimmtes Roboterprogramm erfolgt durch einen Postprozessor. Jedem Roboter ist standardmäßig ein Postprozessor zugeordnet. Der Postprozessor wird verwendet, wenn das Programm offline erstellt wird, wie im Abschnitt Programm generieren gezeigt(durch Rechtsklick auf ein Programm und anschließendes Auswählen von Roboterprogrammen).
RoboDK wird mit vielen Postprozessoren geliefert, die unterschiedliche Robotersteuerungen unterstützen, die im Abschnitt Verfügbare Postprozessorenaufgeführt sind. Alternativ ist es möglich, selbst einen angepassten Postprozessor zu erstellen oder einen vorhandenen Postprozessor zu modifizieren. Alle verfügbaren Postprozessoren befinden sich im Ordner:
C:/RoboDK/Posts/
Ein Postprozessor ist eine PY-Datei (jeder Postprozessor wird durch ein Python-Skript definiert). Es ist möglich, Dateien in den Posts Ordner von RoboDK manuell einzufügen, zu ändern oder zu löschen. Wenn Sie einen RoboDK-Postprozessor (PY-Datei) erhalten haben, sollte dieser in den Posts-Ordner abgelegt werden, um ihn aus RoboDK auswählen zu können.
In diesem Abschnitt erfahren Sie, wie Sie einen Postprozessor auswählen, bearbeiten oder erstellen können und ihn in RoboDK mit Ihren Robotern verwenden. Eine kurze Einführung ist im folgenden Video verfügbar: https://robodk.com/help#PostProcessor
Die Auswahl eines Post Prozessors
Um einen bestimmten Postprozessor auszuwählen gehen Sie wie folgt vor:
1.Klicken Sie mit der rechten Maustaste auf einen Roboter oder ein Programm:
2.Wählen Sie Einen Postprozessor auswählen
3.Wählen Sie einen Postprozessor aus der Liste aus
4.Klicken Sie OK.
Die Änderung wird jetzt angewendet und das Programm kann erneut generiert werden, um das Ergebnis zu sehen.
Alternativ ist es auch möglich, einen Postprozessor auszuwählen, indem Sie folgende Schritte ausführen:
1.Öffnen Sie das Roboter Panel (doppelklicken Sie auf einen Roboter)
2.Wählen Sie Parameter
3.Wählen Sie den gewünschten Postprozessor im Feld Robotermarken aus, wie es in der folgenden Abbildung dargestellt ist.
Postprozessor-Editor
Sie können die Einstellungen des Postprozessors einfach über eine grafische Benutzeroberfläche ändern. Der Postprozessor-Editor ermöglicht es Ihnen, im Postprozessor definierte Variablen zu ändern, die spezifisch für Ihre Robotersteuerung sind.
Der Postprozessor-Editor ist ein Plugin, das Ihnen hilft, Ihre Postprozessoren anzupassen. Sie können das Plugin ganz einfach über die folgende Seite herunterladen und installieren: https://robodk.com/addin/com.robodk.plugin.postprocessoreditor.
Befolgen Sie diese Schritte, um den Postprozessor-Editor zu öffnen:
1.Wählen Sie Program→Post Processor Editor.
2.Wählen Sie den Postprozessor aus, den Sie anpassen möchten.
3.Wählen Sie OK. Ein neues Fenster wird geöffnet, in dem Sie die änderbaren Variablen sehen.
4.Wählen Sie Save Post Processor as…
5.Geben Sie den Namen ein, unter dem gespeichert werden soll.
Wenn Sie beispielsweise den Postprozessor Fanuc R30iA auswählen, sehen Sie das im vorherigen Bild gezeigte Fenster.
Abändern eines Post Prozessors
Es ist möglich, vorhandene Postprozessoren zu ändern oder neue Postprozessoren zu erstellen. Postprozessoren müssen in den Ordner C:/RoboDK/Posts/ abgelegt werden, damit sie in RoboDK ausgewählt werden können. Im vorherigen Abschnitt wurde beschrieben, wie Sie einen bestimmten Roboter mit einem Postprozessor verknüpfen können.
Jeder Postprozessor ist eine PY-Datei. Es ist möglich, die Datei umzubenennen oder Dateien in den Ordner C:/RoboDK/Posts/ zu kopieren, um verschiedene Postprozessoren zu nutzen. Um ein vorhandenes Postprozessor-Skript zu löschen, löschen Sie einfach die entsprechende PY-Datei im Posts Ordner.
Postprozessoren können mit einem beliebigen Texteditor oder einem Python-Editor (Python IDLE) bearbeitet werden. Mit dem Python-Editor können Sie schnell ein Beispielprogramm Datei debuggen und auswerten.
Python sollte installiert werden, um die Postprozessoren ordnungsgemäß zu testen und zu verwenden (Python wird standardmäßig mit RoboDK installiert).
Um einen existierenden Postprozessor zu bearbeiten gehen Sie wie folgt vor:
1.Wählen Sie Programm➔ Postprozessor hinzufügen/bearbeiten
2.Wählen Sie einen bestehenden Postprozessor
3.Wählen Sie OK. Ein Texteditor und ein Programm öffnen sich.
4.Wählen Sie Ausführen➔Modul ausführen(F5) um eine Vorschau zu erhalten. Nehmen Sie gegebenenfalls Änderungen vor..
Alternativ ist es möglich, einen Postprozessor manuell zu bearbeiten:
1.Wechseln Sie zum Postprozessordner: C:/RoboDK/Posts/
2.Öffnen Sie eine PY-Datei mit Python IDLE (Rechtsklick ➔ Mit IDLE bearbeiten) oder einem anderen Texteditor
3.Nehmen Sie die gewünschten Änderungen vor
4.Führen Sie die Datei aus, um das Ergebnis zu testen: Wählen Sie Ausführen➔Modul ausführen (alternativ F5) via Python IDLE aus.
Alternativ ist es möglich, diese Datei mit einem Texteditor zu bearbeiten und mit Python durch Doppelklick auszuführen.
Beispiel einer Abänderung
In diesem Abschnitt wird gezeigt, wie Sie kleine Änderungen für einen vorhandenen Postprozessor vornehmen.
Als Beispiel werden die folgenden 3 Änderungen am bestehenden KUKA KRC4 Postprozessor vorgenommen:
●Überschreiben Sie die maximale Geschwindigkeit auf 500 mm/s. Selbst wenn der Roboter so programmiert wird, dass er sich schneller bewegt, ist die Geschwindigkeit im Postprozessor somit auf 500 mm/s begrenzt.
●Generieren Sie jedes Programm als separate Datei und beschränken Sie die Programme auf maximal 3000 Codezeilen. Große Programme werden dadurch in kleinere Programme unterteilt und nacheinander aufgerufen
Der vorherige Abschnitt zeigt, wie Sie einen vorhandenen Postprozessor zur Bearbeitung öffnen:
1.Wählen Sie Program➔Postprozessor hinzufügen/ändern
2.Wählen Sie KUKA_KRC4
3.Wählen Sie OK. Der Postprozessor wird im IDLE-Editor von Python angezeigt.
In den folgenden Abschnitten wird gezeigt, wie Sie diese Änderungen im Texteditor vornehmen.
Erstellen eines separaten Programms pro Datei
Machen Sie die folgenden Änderungen, um zu vermeiden, dass Sie mehr als ein Programm pro Datei hinzufügen und höchstens Programme mit 3000 Zeilen Code erstellen:
1.Setzen Sie die Variable MAX_LINES_X_PROG auf 3000
2.Setzen Sie die Variable INCLUDE_SUB_PROGRAMS auf False
Erzwingen eines Geschwindigkeitlimits
Befolgen Sie diese Schritte, um eine Geschwindigkeitsbegrenzung von 500 mm/s festzulegen und unterbinden Sie die Einstellung höherer Geschwindigkeiten in RoboDK:
1.Suchen Sie die setSpeed Funktionsdefinition (def setSpeed)
2.Fügen Sie die folgende Zeile hinzu, bevor Sie die Ausgabe $VEL.CP erzeugen, die die Geschwindigkeit in m/s ändert:
speed_mms = min(speed_mms, 500)
Benutzerdefinierter Filter für Bezugssysteme
Dieser Abschnitt zeigt, wie Sie das Festlegen des Bezugssystems eines bestehenden Postprozessors anpassen können. Zum Beispiel das Festlegen eines benutzerdefinierten Bezugssystems für einen KUKA-Roboter.
Sie können kompilierte Postprozessoren verwenden und dabei ganz einfach nur die notwendigen Funktionen neu implementieren (zum Beispiel setFrame, setTool oder setSpeed).
In diesem Beispiel gehen wir davon aus, dass wir anpassen möchten, wie die Basis für eine KUKA-Steuerung definiert wird. Wenn Sie zum Beispiel beim Festlegen des Bezugssystems die folgende Zeile ausgeben möchten:
BASE_DATA[8] = {FRAME: X:2000, Y:0, Z:0, A:0, B:0, C:0}
BAS (#BASE,8)
Sie müssen lediglich eine neue Datei mit dem Namen KUKA_Custom_Post.py im Ordner C:/RoboDK/Posts/ mit den folgenden wenigen Zeilen erstellen, die den Standard-Postprozessor KUKA_KRC2 verwendet und das Festlegen des Bezugssystems (Funktion setFrame) überschreibt:
from KUKA_KRC2 import RobotPost as MainPost
class RobotPost(MainPost):
def setFrame(self, pose, frame_id, frame_name):
"""Change the robot reference frame"""
self.addline('; BASE_DATA[8] = {FRAME: %s}' % (self.pose_2_str(pose)))
self.addline('BAS (#BASE,8)')
Wir könnten jedoch benutzerdefinierte Filter basierend auf bestimmten Kriterien hinzufügen, um zwischen dem Standardverhalten und einer benutzerdefinierten Implementierung zu unterscheiden. Die Postprozessor-Datei könnte dann wie folgt geändert werden:
from KUKA_KRC2 import RobotPost as MainPost
class RobotPost(MainPost):
def setFrame(self, pose, frame_id, frame_name):
"""Change the robot reference frame"""
if frame_name == "Frame 4": # Enter any condition here
# Trigger the call to the default method (same as not overriding the function)
super(MainPost, self).setFrame(pose, frame_id, frame_name)
return
# Implement a custom setFrame
self.addline('; ---- Setting reference: %s ----' % frame_name)
self.addline('; BASE_DATA[8] = {FRAME: %s}' % (self.pose_2_str(pose)))
self.addline('BAS (#BASE,8)')
self.addline('; --------------------------')
Beim Generieren von Programmen für KUKA-KRC-Steuerungen gibt es viele Möglichkeiten, das Koordinatensystem bzw. Bezugssystem festzulegen. Die folgende Definition von setFrame zeigt eine alternative Implementierung mit verschiedenen Optionen:
def setFrame(self, pose, frame_id, frame_name):
"""Change the robot reference frame"""
self.addline('; ---- Setting reference: %s ----' % frame_name)
# option 1: Build the kinematics based on the MACHINE_DEF array and the provided offset
#self.addline('$BASE = EK (MACHINE_DEF[2].ROOT, MACHINE_DEF[2].MECH_TYPE, { %s })' % self.pose_2_str(pose))
# option 2: Build the kinematics based on the EX_AX_DATA array and the provided offset
#self.addline('$BASE=EK(EX_AX_DATA[1].ROOT,EX_AX_DATA[1].EX_KIN, { %s })' % self.pose_2_str(pose))
# Option 3: Build the kinematics based on the EX_AX_DATA array and the pre-defined offset
#self.addline('; Using external axes')
#self.addline('; $BASE=EK(EX_AX_DATA[1].ROOT,EX_AX_DATA[1].EX_KIN,EX_AX_DATA[1].OFFSET)')
#self.addline('; $ACT_EX_AX= %i' % (self.nAxes - 6))
# Option 4: Use the BAS(#ex_BASE) init function from the BAS.src file
#self.addline('; BASE_DATA[%i] = {FRAME: %s}' % (self.BASE_ID, self.pose_2_str(pose)))
#self.addline('BAS(#ex_BASE,%i)' % self.BASE_ID)
# Option 5: Use the BAS(#BASE) init function from the BAS.src file
self.addline('; BASE_DATA[%i] = {FRAME: %s}' % (self.BASE_ID, self.pose_2_str(pose)))
self.addline('BAS (#BASE,%i)' % self.BASE_ID)
# Option 6: Directly take the base from the BASE_DATA array (usually what the BAS(#BASE) does)
# self.addline('$BASE=BASE_DATA[%i]' % self.BASE_ID)
self.addline('; --------------------------')
Erzwingen einer Bewegung mittels Achswinkel
Dieser Abschnitt zeigt Ihnen, wie Sie einen bestehenden Postprozessor so anpassen können, dass eine Achsbewegung anhand von Achswerten anstelle von kartesischen Werten erzwungen wird.
In diesem Beispiel wenden wir diese Änderung auf eine ABB-IRC5-Robotersteuerung an.
1.Suchen Sie das Programmierhandbuch Ihrer Robotersteuerung. In diesem Beispiel verwenden wir das ABB-IRC5-RAPID-Programmierhandbuch.
2.Suchen Sie nach den Befehlen für Achsbewegungen. In diesem Fall lautet der Befehl für die absolute Achsbewegung bei ABB MoveAbsJ. Dieser Befehl benötigt eine jointtarget-Variable, die die Achsen definiert.
3.Wählen Sie Program→Add/Edit Post Processor und wählen Sie den Postprozessor aus, den Sie derzeit verwenden, um ihn zu bearbeiten. Wenn Sie derzeit einen anpassbaren Postprozessor verwenden, wird dieser standardmäßig ausgewählt.
4.Suchen Sie im Postprozessor nach der Funktion MoveJ. Diese Funktion legt fest, wie der Postprozessor die Befehle für Achsbewegungen erzeugt. Für lineare Bewegungen verwendet RoboDK stattdessen MoveL. Ändern Sie mithilfe von Python die Zeile, die der Programmdatei hinzugefügt wird, sodass sie die Achswinkelinformationen bereitstellt, wie im folgenden Bild gezeigt.
5.Abschließend müssen Sie möglicherweise anpassen, wie der Postprozessor die Achswinkel oder die Pose in eine Zeichenkette umwandelt. Die Funktionen angles_2_str und pose_2_str legen fest, wie die Achswinkel bzw. eine Pose in Text umgewandelt werden.
Die meisten RoboDK-Postprozessoren verwenden für Achsbewegungen Achsdaten und für lineare Bewegungen kartesische Koordinaten. Es wird empfohlen, den ersten Punkt einer Sequenz linearer Bewegungen stets als Achsbewegung mit Angabe von Achskoordinaten zu beginnen. Dadurch wird vermieden, dass ein Programm mit einer falschen Roboterkonfiguration startet und eine Singularität oder Achsgrenzen erreicht.
Verfügbare Post Prozessoren
Standardmäßig sind in RoboDK folgende Postprozessoren vorhanden:
●ABB_RAPID_IRC5: für ABB IRC5 Roboter Steuerungen
●ABB_RAPID_S4C: für ABB S4C Roboter Steuerungen
●Adept_Vplus: für Adept V+ Programmiersprache
●Allen_Bradley_Logix5000: für Allen Bradley Logix5000 PCL
●CLOOS: for CLOOS robot controllers
●Comau_C5G: für Comau C5G Roboter Steuerungen
●Denso_RC8: für Denso RC8 Roboter Steuerungen
●Dobot: für Ausbildungszwecke Dobot robots
●Fanuc_R30iA: für Fanuc R30iA und R30iB Roboter Steuerungen
●Fanuc_R30iA_Arc: für Fanuc Bogenschweißen
●Fanuc_RJ3: für Fanuc RJ3 Roboter Steuerungen
●GCode_BnR: für B&R Roboter Steuerungen
●GSK: für GSK Roboter
●HIWIN_HRSS: für HIWIN Roboter
●KAIRO: für Keba Kairo Roboter Steuerungen
●KUKA_IIWA: für KUKA IIWA sunrise programming in Java
●KUKA_KRC2: für KUKA KRC2 Roboter Steuerungen
●KUKA_KRC2_CamRob: für KUKA CamRob Fräsanwendungen
●KUKA_KRC2_DAT: für KUKA KRC2 Roboter Steuerungen inklusive DAT data files
●KUKA_KRC4: für KUKA KRC4 Roboter Steuerungen
●KUKA_KRC4_Config: für KUKA KRC4 Roboter Steuerungen mit Konfigurationsdaten in jeder Zeile
●KUKA_KRC4_DAT: für KUKA KRC4 Roboter Steuerungen inklusive DAT data files
●Kawasaki: für Kawasaki AS Roboter Steuerungen
●Mecademic: für Mecademic Meca500 Roboter
●Mitsubishi: für Mitsubishi Roboter Steuerungen
●Motoman/Yaskawa: für Motoman Roboter Steuerungen (Inform II & Inform III - JBI)
●Nachi_AX_FD: für Nachi AX und FD Roboter Steuerungen
●OTC: für Daihen OTC Roboter Steuerungen
●Panasonic: für Panasonic Roboter Steuerungen
●Precise: für Precise Scara Roboter
●Siemens_Sinumerik: für Siemens Sinumerik ROBX Roboter Steuerungen
●Staubli_VAL3: für Staubli VAL3 Roboter Programme (CS8 Steuerungen oder nachfolgende)
●Staubli_VAL3_InlineMove: um Stäubli VAL3 Programme mit inline Bewegungen zu erstellen
●Staubli_S6: für Staubli S6 Roboter Steuerungen
●Toshiba: für Toshiba Roboter
●Universal_Robots: für UR robots, erstellt Linearbewegungen als Pose Ziele
●Universal_Robots_RobotiQ: für UR robots inclusive Support für RobotiQ Grefer
●Universal_Robots_joints: für UR Roboter, erstellt Linearbewegungen als PTP Ziele
●Yamaha: für Yamaha Roboter
Referenzen
Das folgende Video zeigt eine Übersicht der RoboDK Post Prozessoren:
https://robodk.com/help#PostProcessor
Eine Referenzdokumentation für jede Methode ist online verfügbar unter:
https://robodk.com/doc/en/PythonAPI/postprocessor.html
Alle Post Prozessoren basieren auf dem robodk.py Modul:
https://robodk.com/doc/en/PythonAPI/robodk.html#robodk.robomath.Mat
Das robodk.py Modul stellt unter anderem Werkzeuge für Matrixoperationen (Multiplikationen, inverse Kinematiken,…) und Transformationen zwischen Euler Winkeln und diversen anderen Formaten.
Eine Dokumentation bezüglich der Programmierung in Python ist online verfügbar:
https://docs.python.org/3/
Sobald ein Programm erstellt wird, wir ein universelles vorverarbeitetes Python Programm generiert und in einem lokalen, temporären Verzeichnis abgelegt. Dieses Programm ist mit dem korrekten Post Prozessor (durch den Benutzer in RoboDK ausgewählt) verbunden. Der Post Prozessor bestimmt eine RobotPost Klasse, welche anschließend den gewünschten Code erstellt.
Die vorverarbeiteten Programme werden mit Python ausgeführt.
