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