Programa de Filtrado

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 ArchivoAbrir) Y seleccione Sólo Filtrar. El programa se filtra y se guarda en la misma carpeta. El resumen de filtrado mencionará si había algún problema utilizando el algoritmo de filtrado. También tenemos la opción de importar un programa si queremos simularlo dentro de RoboDK. Si el programa tiene cualquier dependencia (sistema de la herramienta o definiciones del sistema base, subprogramas, ...) deben estar ubicados en el mismo directorio donde se importó el primer programa.

Robot Calibration Creaform - Imagen 34

Robot Calibration Creaform - Imagen 35

Una vez que importamos el programa dentro RoboDK podemos regenerarlo con o sin precisión absoluta. En las principales opciones de configuración de precisión de RoboDK (HerramientasOpcionesPrecisión) podemos decidir si queremos generar siempre los programas utilizando la cinemática precisa, si queremos preguntar cada vez, o si queremos utilizar la cinemática actual de robots. La cinemática actual de robots se puede cambiar haciendo clic derecho en el robot y activar/desactivar la etiqueta “Use cinemáticas precisas”. Si está activo veremos un punto verde, si no está activo, veremos un punto rojo.

Robot Calibration Creaform - Imagen 36

Robot Calibration Creaform - Imagen 37


Filtrar programa usando la API

Es posible filtrar un programa completo usando RoboDK dado un robot calibrado y el programa del robot usando el llamado 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 ejemplo de script en Python 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 clic 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()

 

RDK.ShowRoboDK()

Filtrar la posición usando la API

El siguiente código es un ejemplo de script Python que utiliza la API de RoboDK para filtrar un objetivo (posición pose o posición 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 otro fabricante (que no sea RoboDK) genera el programa del robot usando posiciones 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 Sistema

 

# Update the robot TCP and reference sistema

robot.setTool(pose_tcp)

robot.setSistema(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 sistema

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))impresión(Pose_2_XYZWPR(pose_target_filt))