Programm Filterung

Nachdem der Roboter kalibriert wurde, haben Sie zwei Möglichkeiten, Programme mit der absoluten Genauigkeit des kalibrierten Roboters zu erstellen:

●Bestehende Programme filtern: Alle Roboterziele in einem Programm werden modifiziert, um die Genauigkeit des Roboters zu verbessern. Dies kann manuell oder mithilfe der API erfolgen.

●Verwenden Sie RoboDK für die Offline-Programmierung, um genaue Programme zu generieren (generierte Programme sind bereits gefiltert, einschließlich der mit der API generierten Programme).

Auf diese Art und Weise filtern Sie ein vorhandenes Programm manuell: Ziehen Sie die Roboterprogrammdatei per Drag & Drop auf den RoboDK-Hauptbildschirm (oder wählen Sie Datei➔Öffnen) und wählen Sie Nur filtern. Das Programm wird gefiltert und im selben Ordner gespeichert. In der Filterzusammenfassung wird angezeigt, ob Probleme bei der Verwendung des Filteralgorithmus aufgetreten sind. Sie haben auch die Möglichkeit, ein Programm zu importieren, wenn Sie es in RoboDK simulieren wollen. Wenn das Programm irgendwelche Abhängigkeiten hat (Bezugssystem Definitionen, Unterprogramme, ...), müssen sie sich in dem Verzeichnis befinden, in dem das erste Programm importiert wird.

Sobald Sie das Programm in RoboDK importieren, können Sie es mit oder ohne absolute Genauigkeit wiederherstellen. In den Genauigkeitseinstellungen von RoboDK (Extras➔Optionen➔Genauigkeit) können Sie entscheiden, ob Sie die Programme immer mit einer genauen Kinematik erzeugen wollen, ob Sie jedes Mal entscheiden wollen, oder ob Sie die aktuelle Roboterkinematik verwenden wollen. Die aktuelle Roboterkinematik kann geändert werden, indem Sie mit der rechten Maustaste auf den Roboter klicken und die Option "Genaue Kinematik verwenden" aktivieren / deaktivieren. Wenn diese Option aktiv ist, sehen Sie einen grünen Punkt, wenn sie nicht aktiv ist, sehen Sie einen roten Punkt.

Programme mit der API filtern

Es ist möglich, ein komplettes Programm mit RoboDK zu filtern, wenn ein kalibrierter Roboter und das Roboterprogramm FilterProgramm verwenden:

robot.FilterProgram(file_program)

Ein Makrobeispiel namens FilterProgram ist im Abschnitt Makros der Bibliothek verfügbar. Der folgende Code ist ein Python-Beispielskript, das die RoboDK-API zum Filtern eines Programms verwendet.

from robolink import*# API to communicate with RoboDK

from robodk import*# basic matrix operations

import os                 # Path operations

# Get the current working directory

CWD = os.path.dirname(os.path.realpath(__file__))

# Start RoboDK if it is not running and link to the API

RDK = Robolink()

# optional: provide the following arguments to run behind the scenes

#RDK = Robolink(args='/NOSPLASH /NOSHOW /HIDDEN')

# Get the calibrated station (.rdk file) or robot file (.robot):

# Tip: after calibration, right click a robot and select "Save as .robot"

calibration_file = CWD +'/KUKA-KR6.rdk'

# Get the program file:

file_program = CWD +'/Prog1.src'

# Load the RDK file or the robot file:

calib_item = RDK.AddFile(calibration_file)

ifnot calib_item.Valid():

raise Exception("Something went wrong loading "+ calibration_file)

# Retrieve the robot (no popup if there is only one robot):

robot = RDK.ItemUserPick('Select a robot to filter', ITEM_TYPE_ROBOT)

ifnot robot.Valid():

raise Exception("Robot not selected or not available")

# Activate accuracy

robot.setAccuracyActive(1)

# Filter program: this will automatically save a program copy

# with a renamed file depending on the robot brand

status, summary = robot.FilterProgram(file_program)

if status ==0:

print("Program filtering succeeded")

print(summary)

calib_item.Delete()

RDK.CloseRoboDK()

else:

print("Program filtering failed! Error code: %i"% status)

print(summary)

RDK.ShowRoboDK()

Ziele mit der API filtern

Der folgende Code ist ein Python-Beispielskript, das mithilfe der RoboDK-API ein Ziel (Pose-Ziel oder gemeinsames Ziel) mithilfe des Befehls FilterTarget filtert:

pose_filt, joints = robot.FilterTarget(nominal_pose, estimated_joints)

Dieses Beispiel ist nützlich, wenn eine Drittanbieteranwendung (nicht RoboDK) das Roboterprogramm mithilfe von Pose-Zielen generiert.

from robolink import*# API to communicate with RoboDK

from robodk import*# basic matrix operations

defXYZWPR_2_Pose(xyzwpr):

return KUKA_2_Pose(xyzwpr) # Convert X,Y,Z,A,B,C to a pose

defPose_2_XYZWPR(pose):

return Pose_2_KUKA(pose) # Convert a pose to X,Y,Z,A,B,C

# Start the RoboDK API and retrieve the robot:

RDK = Robolink()

robot = RDK.Item('', ITEM_TYPE_ROBOT)

ifnot robot.Valid():

raise Exception("Robot not available")

pose_tcp = XYZWPR_2_Pose([0,0,200,0,0,0]) # Define the TCP

pose_ref = XYZWPR_2_Pose([400,0,0,0,0,0]) # Define the Ref Frame

# Update the robot TCP and reference frame

robot.setTool(pose_tcp)

robot.setFrame(pose_ref)

# Very important for SolveFK and SolveIK (Forward/Inverse kinematics)

robot.setAccuracyActive(False)# Accuracy can be ON or OFF

# Define a nominal target in the joint space:

joints =[0,0,90,0,90,0]

# Calculate the nominal robot position for the joint target:

pose_rob = robot.SolveFK(joints) # robot flange wrt the robot base

# Calculate pose_target: the TCP with respect to the reference frame

pose_target = invH(pose_ref)*pose_rob*pose_tcp

print('Target not filtered:')

print(Pose_2_XYZWPR(pose_target))

joints_approx = joints # joints_approx must be within 20 deg

pose_target_filt, real_joints = robot.FilterTarget(pose_target, joints)

print('Target filtered:')

print(real_joints.tolist())

print(Pose_2_XYZWPR(pose_target_filt))