Filtrage de programme

Une fois que le robot a été calibré, il y a deux options pour générer des programmes en utilisant la précision absolue du robot calibré :

●Filtrer les programmes existants : toutes les cibles de robot à l’intérieur d’un programme sont modifiées pour améliorer la précision du robot. Il peut être fait manuellement ou en utilisant l’API.

●Utiliser RoboDK pour la programmation hors ligne pour générer des programmes précis (les programmes générés sont déjà filtrés, y compris les programmes générés à l’aide de l’API).

Pour filtrer manuellement un programme existant : glisser et déposer le fichier de programme robot dans l’écran principal de RoboDK (ou sélectionner Fichier➔ouvrir) et sélectionner Filter only. Le programme sera filtré et enregistré dans le même dossier. Le résumé du filtre indiquera s’il y a eu des problèmes avec l’algorithme de filtrage. Vous avez également la possibilité d’importer un programme si vous voulez le simuler à l’intérieur de RoboDK. Si le programme a des dépendances (repère d’outils ou définitions de base, sous-programmes, ...) ils doivent être situés dans le même répertoire où le premier programme est importé.

En important le programme à l’intérieur de RoboDK, vous pouvez le régénérer avec ou sans précision absolue. Dans les principaux réglages de précision de RoboDK (Outils➔Options➔Précision) vous pouvez décider si vous voulez toujours générer les programmes en utilisant une cinématique précise, si vous voulez demander à chaque fois ou si vous voulez utiliser la cinématique actuelle du robot. La cinématique actuelle du robot peut être modifiée avec un clic droit sur le robot et en activant/désactivant la balise « Utiliser une cinématique précise ». S’il est actif, vous verrez un point vert, s’il n’est pas actif, vous verrez un point rouge.

Filtrer les programmes avec l’API

Il est possible de filtrer un programme complet en utilisant RoboDK, avec un robot calibré et le programme de robot, en utilisant l’option FilterProgram :

robot.FilterProgram(file_program)

Un exemple de macro appelé Filterprogram est disponible dans la section Macros de la bibliothèque. Le code suivant est un exemple de script Python qui utilise l’API RoboDK pour filtrer un programme.

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

Filtrer les cibles avec l’API

Le code suivant est un exemple de script Python qui utilise l’API RoboDK pour filtrer une cible (poser une cible ou une cible commune), en utilisant la commande FilterTarget :

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

Cet exemple est utile si une application tierce (autre que RoboDK) génère le programme de robot en utilisant des cibles 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))