Una vez que el robot ha sido calibrado, tenemos dos opciones para generar programas que utilizan la exactitud absoluta del robot calibrado:
●Filtrar los programas existentes: todos los objetivos del robot dentro de un programa se modifican para mejorar la precisión del robot. Se puede hacer manualmente o usando la API.
●Utilice RoboDK para la Programación Fuera de Línea para generar programas precisos (los programas generados ya se filtraron, incluyendo programas generados mediante la API).
Para filtrar un programa existente de forma manual: arrastre y suelte el archivo de programa de robot en la pantalla principal de RoboDK (o seleccione Archivo➔Abrir) y seleccione Sólo Filtrar. El programa se filtra y se guarda en la misma carpeta. El resumen de filtrado mencionará si hubo algún problema utilizando el algoritmo de filtrado. También tiene la opción de importar un programa si desea simularlo dentro de RoboDK. Si el programa tiene alguna dependencia (definiciones del sistema de herramienta o del sistema base, subprogramas, ...) deben estar ubicadas en el mismo directorio donde se importa el primer programa.


Una vez que importe el programa dentro de RoboDK puede regenerarlo con o sin precisión absoluta. En las principales opciones de configuración de precisión de RoboDK (Herramientas➔Opciones➔Precisión) puede decidir si desea generar siempre los programas utilizando la cinemática precisa, si desea que RoboDK le pregunte cada vez o si desea utilizar la cinemática actual del robot. La cinemática actual del robot se puede cambiar haciendo clic derecho en el robot y activando/desactivando la etiqueta “Usar cinemática precisa”. Si está activa verá un punto verde; si no está activa, verá un punto rojo.


Es posible filtrar un programa completo usando RoboDK dado un robot calibrado y el programa del robot usando la llamada FilterProgram:
robot.FilterProgram(file_program)
Un ejemplo de macro llamado FilterProgram está disponible en la sección Macros de la biblioteca. El código siguiente es un script de Python de ejemplo que utiliza la API de RoboDK para filtrar un programa.
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)
if not 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)
if not 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()
El código siguiente es un ejemplo de script Python que utiliza la API de RoboDK para filtrar un objetivo (objetivo de pose u objetivo de articulación), utilizando el comando FilterTarget:
pose_filt, joints = robot.FilterTarget(nominal_pose, estimated_joints)
Este ejemplo es útil si una aplicación de terceros (que no sea RoboDK) genera el programa del robot usando objetivos de pose.
from robolink import * # API to communicate with RoboDK
from robodk import * # basic matrix operations
def XYZWPR_2_Pose(xyzwpr):
return KUKA_2_Pose(xyzwpr) # Convert X,Y,Z,A,B,C to a pose
def Pose_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)
if not 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))