Filtrare Programmi

Una volta che il robot è stato calibrato, abbiamo due opzioni per generare programmi utilizzando l'accuratezza assoluta del robot calibrato.

●Filtrare programmi esistenti: tutti i bersagli robot all'interno del programma sono modificati per migliorare l'accuratezza del robot. Può essere fatto manualmente o utilizzando l'API.

●Usare RoboDK per Programmazione Offline per generare programmi accurati (programmi generati sono già filtrati, inclusi programmi generati tramite l'API)

Per filtrare un programma esistente manualmente: trascinare il programma robot nella finestra principale di RoboDK (o seleziona File➔Apri) e seleziona Filtra solo. Il programma sarà filtrato e salvato nella stessa cartella. Il resoconto menzionerà se ci sono stati problemi utilizzando l'algoritmo di filtro. Abbiamo anche l'opzione di importare un programma se vogliamo simularlo dentro RoboDK. Se il programma ha dipendenze (definizione piani tool, base, subprogrammi, ...) devono essere posizionate nella stessa cartella dove il primo programma è stato importato.

Una volta importato il programma dentro RoboDK possiamo rigenerarlo con o senza accuratezza assoluta. Nelle impostazioni di accuratezza principalo di RoboDK (Strumenti➔Opzioni➔Accuratezza) possiamo decidere se vogliamo sempre generare i programmi usando cinematiche accurate, se vogliamo chiedere ogni volta o se vogliamo usare le cinematiche robot. Le cinematiche robot in uso possono esser modificate cliccando con il tasto destro sul robot e attivando/disattivando Utilizza cinematiche accurate. Se è attivo vedremo un pallino verde, se no, ne vedremo uno rosso.

Filtrare Programmi con l'API

È possibile filtrare un programma completo usando RoboDK dato un robot calibrato e un programma robot utilizzando la chiamata FilterProgram:

robot.FilterProgram(file_program)

Un esempio di macro chiamata FilterProgram è disponibile nella sezione macro della libreria. Il codice seguente è un esempio Python che usa l'API di RoboDK per filtrare un programma.

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()

Filtrare bersagli con l'API

Il seguente codice è un esempio di script Python che usa RoboDK per filtrare un bersaglio (posa o giunti) usando il comando FilterTarget:

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

Questo esempio è utile se un'applicazione di terze parti (oltre a RoboDK) genera il programma robot utilizzando bersagli pose.

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))