Exemples de modifications

Cette section montre comment effectuer de petites modifications à l’intérieur d’un post-processeur existant. La plupart des post-processeurs disposent de variables pouvant être facilement modifiées afin de changer ou d’activer des fonctionnalités de programmation de robots propres à chaque fabricant.

Comme exemple, on appliquera les changements suivants aux post-processeurs KUKA et ABB existants :

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 angles des articulations.

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 tous les programmes dans un seul 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 plug-in 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).

Post Processors - Image 9

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.

Post Processors - Image 10

Note : La variable MAX_LINES_X_PROG peut être remplacée si le nombre maximum de lignes par programme est spécifié dans le menu Options de programme de RoboDK. Vous pouvez également modifier la section __init__ du post-processeur pour éviter de modifier cette variable dans les réglages de RoboDK.

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)

Post Processors - Image 11

Note : Une vitesse par défaut de 200 mm/s est définie dans la variable HEADER, en haut du post-processeur ($VEL.CP=0.2). Cette vitesse par défaut peut également être modifiée si elle n’est pas imposée par RoboDK.

Note : Si vous ne disposez pas du code source du post-processeur, vous pouvez tout de même ajouter votre propre fonction personnalisée pour redéfinir le comportement par défaut.

Filtre personnalisé pour les systèmes de référence

Cette section montre comment personnaliser la définition du repère d’un post-processeur existant. Par exemple, définir un repère 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).

Note : Assurez-vous que le nom de votre post-processeur personnalisé est différent du nom du post-processeur de référence que vous utilisez. Lors de la mise à jour de RoboDK, l’installateur réinitialise les post-processeurs par défaut à leur version d’origine. Cependant, l’installateur ne supprime ni ne modifie les post-processeurs personnalisés présents dans le dossier Posts.

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 repère :

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 repère (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 repère. 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.

Post Processors - Image 12

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.

Post Processors - Image 13

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.

Post Processors - Image 14

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.

Note : Tous les post-processeurs RoboDK utilisent par défaut le module robodk.py. Ce module inclut des outils utiles pour convertir les poses en angles d’Euler pour de nombreux contrôleurs robot. Utilisez la notation correspondant à votre contrôleur robot. Plus d’informations sont disponibles dans la section Repères de référence et le module robodk.py.