Exemple de Modification
Cette section montre comment effectuer de petites modifications à l’intérieur d’un post processeur existant.
Comme exemple, on appliquera les changements suivants au post processeur KUKA KRC4 :
5.Générer un programme avec ses sous-programmes dans un même fichier et limiter chaque programme à 3000 lignes de code au maximum. Les programmes volumineux seront divisés en programmes plus petits, appelés séquentiellement.
6.Définir un mouvement articulaire pour générer la commande de déplacement à partir des valeurs angulaires des axes.
7.Limiter la vitesse maximale à 500 mm/s. Même si le robot est programmé pour se déplacer plus vite, la vitesse sera limitée à 500 mm/s dans le post processeur.
Les sections suivantes montrent comment effectuer ces modifications à l’aide d’un éditeur de texte.
Générer un programme par fichier
Cet exemple montre comment modifier le comportement par défaut du post processeur KUKA KRC4 afin de générer un programme principal incluant ses sous-programmes dans le même fichier.
Assurez-vous que le plugin de l’éditeur de post processeur est activé, puis suivez ces étapes pour effectuer les modifications du post processeur :
8.Sélectionner Programme➔Éditeur de Post Processeur.
9.Sélectionner le post processeur que vous souhaitez personnaliser (KUKA KRC4).
10.Sélectionner OK. Une nouvelle fenêtre s’ouvrira, dans laquelle vous pourrez voir les variables modifiables, comme illustré dans l’image suivante.
11.Définir la variable Include Sub Programs sur True au lieu de False.
12.Sélectionner Enregistrer le Post Processeur sous…
13.Saisir un nouveau nom pour l’enregistrer (le nom par défaut utilise la date de modification).
Vous devriez maintenant avoir un nouveau post processeur dans le dossier Posts de RoboDK. Vous pouvez à présent mettre à jour votre projet pour utiliser ce nouveau post processeur en suivant ces étapes :
14.Faire un clic droit sur votre robot.
15.Sélectionner Sélectionner le Post Processeur.
16.Sélectionner le nouveau post processeur que vous avez créé.
17.Générer à nouveau vos programmes pour voir le résultat.
Vous pouvez également effectuer ces modifications à l’aide d’un éditeur de texte. Suivez ces étapes pour modifier le code Python par défaut du post processeur :
18.Sélectionner Programme➔Ajouter/Modifier Post Processeur
19.Sélectionner votre post processeur. Par exemple, pour KUKA KRC4, sélectionner KUKA_KRC4.
20.Sélectionner OK. Le post processeur s’affichera dans un éditeur de texte.
21.Définir la variable MAX_LINES_X_PROG à 3000.
22.Définir la variable INCLUDE_SUB_PROGRAMS sur True.
Contraindre une vitesse maximale
Cet exemple montre comment imposer une limite de vitesse de 500 mm/s et éviter d’utiliser des vitesses plus élevées lors de la génération d’un programme avec RoboDK.
Dans cet exemple, nous supposons que vous utilisez un contrôleur KUKA KRC2 ou KRC4 :
23.Sélectionner Programme➔Ajouter/Modifier Post Processeur
24.Sélectionner votre post processeur. Par exemple, pour KUKA KRC4, sélectionner KUKA_KRC4.
25.Sélectionner OK. Le post processeur s’affichera dans un éditeur de texte.
26.Trouver la définition de la fonction setSpeed (def setSpeed)
27.Ajouter la ligne suivante afin de limiter la vitesse maximale à 500 mm/s. Cette ligne doit être ajoutée avant de générer la sortie $VEL.CP qui convertira la vitesse en m/s :
speed_mms = min(speed_mms, 500)
Filtre personnalisé pour les systèmes de référence
Cette section montre comment personnaliser la définition du système de référence d’un post processeur existant. Par exemple, définir un système de référence personnalisé pour un robot KUKA.
Vous pouvez utiliser des post processeurs compilés et réimplémenter facilement uniquement les fonctions nécessaires (par exemple, setFrame, setTool ou setSpeed).
Dans cet exemple, nous supposons que vous souhaitez personnaliser la façon dont le repère de base est défini pour un contrôleur KUKA. Par exemple, si vous souhaitez générer la ligne suivante lors de la définition du système de référence :
BASE_DATA[8] = {FRAME: X:2000, Y:0, Z:0, A:0, B:0, C:0}
BAS (#BASE,8)
Il vous suffit de créer un nouveau fichier nommé KUKA_Custom_Post.py dans le dossier C:/RoboDK/Posts/ contenant les quelques lignes suivantes, qui utilisent le post processeur KUKA_KRC2 par défaut et redéfinissent la fonction de configuration du système de référence (fonction setFrame) :
from KUKA_KRC2 import RobotPost as MainPost
class RobotPost(MainPost):
def setFrame(self, pose, frame_id, frame_name):
"""Change the robot reference frame"""
self.addline('; BASE_DATA[8] = {FRAME: %s}' % (self.pose_2_str(pose)))
self.addline('BAS (#BASE,8)')
Vous pourriez toutefois ajouter des filtres personnalisés basés sur certains critères afin de choisir entre le comportement par défaut et une implémentation personnalisée. Le fichier du post processeur pourrait alors être modifié comme suit :
from KUKA_KRC2 import RobotPost as MainPost
class RobotPost(MainPost):
def setFrame(self, pose, frame_id, frame_name):
"""Change the robot reference frame"""
if frame_name == "Frame 4": # Enter any condition here
# Trigger the call to the default method (same as not overriding the function)
super(MainPost, self).setFrame(pose, frame_id, frame_name)
return
# Implement a custom setFrame
self.addline('; ---- Setting reference: %s ----' % frame_name)
self.addline('; BASE_DATA[8] = {FRAME: %s}' % (self.pose_2_str(pose)))
self.addline('BAS (#BASE,8)')
self.addline('; --------------------------')
Lors de la génération de programmes pour des contrôleurs KUKA KRC, il existe plusieurs façons de définir votre système de coordonnées ou système de référence. La définition suivante de setFrame montre une implémentation alternative avec différentes options :
def setFrame(self, pose, frame_id, frame_name):
"""Change the robot reference frame"""
self.addline('; ---- Setting reference: %s ----' % frame_name)
# option 1: Build the kinematics based on the MACHINE_DEF array and the provided offset
#self.addline('$BASE = EK (MACHINE_DEF[2].ROOT, MACHINE_DEF[2].MECH_TYPE, { %s })' % self.pose_2_str(pose))
# option 2: Build the kinematics based on the EX_AX_DATA array and the provided offset
#self.addline('$BASE=EK(EX_AX_DATA[1].ROOT,EX_AX_DATA[1].EX_KIN, { %s })' % self.pose_2_str(pose))
# Option 3: Build the kinematics based on the EX_AX_DATA array and the pre-defined offset
#self.addline('; Using external axes')
#self.addline('; $BASE=EK(EX_AX_DATA[1].ROOT,EX_AX_DATA[1].EX_KIN,EX_AX_DATA[1].OFFSET)')
#self.addline('; $ACT_EX_AX= %i' % (self.nAxes - 6))
# Option 4: Use the BAS(#ex_BASE) init function from the BAS.src file
#self.addline('; BASE_DATA[%i] = {FRAME: %s}' % (self.BASE_ID, self.pose_2_str(pose)))
#self.addline('BAS(#ex_BASE,%i)' % self.BASE_ID)
# Option 5: Use the BAS(#BASE) init function from the BAS.src file
self.addline('; BASE_DATA[%i] = {FRAME: %s}' % (self.BASE_ID, self.pose_2_str(pose)))
self.addline('BAS (#BASE,%i)' % self.BASE_ID)
# Option 6: Directly take the base from the BASE_DATA array (usually what the BAS(#BASE) does)
# self.addline('$BASE=BASE_DATA[%i]' % self.BASE_ID)
self.addline('; --------------------------')
Imposer un mouvement à l’aide des angles articulaires
Cette section montre comment modifier un post processeur existant afin de forcer un déplacement axial à l’aide de valeurs articulaires plutôt que de valeurs cartésiennes.
Dans cet exemple, nous appliquerons cette modification à un contrôleur de robot ABB IRC5.
28.Rechercher le manuel de programmation de votre contrôleur robot. Dans cet exemple, nous utilisons le manuel de programmation RAPID de l’ABB IRC5.
29.Rechercher les instructions de mouvement articulaire. Dans ce cas, la commande de mouvement articulaire absolu d’ABB s’appelle MoveAbsJ. Cette commande requiert une variable jointtarget qui définit les axes articulaires.
30.Sélectionner Programme➔Ajouter/Modifier Post Processeur et sélectionner le post processeur que vous utilisez actuellement pour le modifier. Si vous utilisez actuellement un post processeur personnalisable, il sera sélectionné par défaut.
31.Vous devez rechercher la fonction MoveJ à l’intérieur du post processeur. Cette fonction définit la façon dont le post processeur génère les commandes de mouvement articulaire. RoboDK utilise quant à lui MoveL pour les mouvements linéaires. En Python, modifiez la ligne ajoutée au fichier programme pour fournir les informations d’angles articulaires, comme illustré dans l’image suivante.
32.Enfin, il se peut que vous deviez modifier la façon dont le post processeur convertit les angles articulaires ou la pose en chaîne de caractères. Les fonctions angles_2_str et pose_2_str définissent respectivement la manière dont les angles articulaires et une pose sont convertis en texte.
La plupart des post processeurs RoboDK utilisent des données articulaires pour les mouvements articulaires et des coordonnées cartésiennes pour les mouvements linéaires. Il est recommandé de toujours démarrer le premier point d’une séquence de mouvements linéaires par un mouvement articulaire, en spécifiant des coordonnées articulaires. Cela évite de démarrer un programme avec une mauvaise configuration du robot et d’atteindre une singularité ou une limite d’axe.
