Les Post Processeurs permettent de générer des programmes hors-ligne pour tout type de baies de contrôle (contrôleur robot). Un Post Processeur permet donc de générer un programme robot pour un contrôleur robot spécifique. Pour cette raison, les post processeurs font partie d’un processus important dans les étapes d’une programmation hors-ligne (PHL)

La conversion d’une simulation RoboDK vers un programme robot se fait grâce à un post processeur. Chaque robot utilise un post processeur par défaut. Le post processeur est utilisé au moment de générer le programme hors-ligne. La section Génération de programmesmontre comment générer un programme hors-ligne (faire un clic droit sur un programme et sélectionner Générer programme robot)

RoboDK possède plusieurs post processeurs pouvant supporter plusieurs contrôleurs robot, la liste est disponible dans la section Liste de Post Processors. Il est aussi possible de créer un post processeur « sur mesure » ou modifier un post processeur existant. Tous les post processeurs sont disponibles dans le dossier :

C:/RoboDK/Posts/

Un post processeur est un fichier PY (chaque post processeur est défini par un script Python). Il est possible de manuellement ajouter, modifier ou supprimer ces fichiers depuis le dossier Posts de RoboDK. Si un post processeur (fichier PY) vous a été fourni, il doit être placé dans le dossier Posts pour qu’il puisse être sélectionné depuis RoboDK.

Cette section montre comment sélectionner, modifier ou créer un post processeur et l’utiliser avec vos robots dans RoboDK. Une présentation rapide est disponible dans la vidéo suivante (Anglais) :

https://robodk.com/help#PostProcessor

Note : La plupart des marques de robots ont des contrôleurs de différentes versions. Il est important de sélectionner le post processeur approprié afin de générer le bon programme robot, supporté par une baie de contrôle donnée.

Important : Chaque robot a un post processeur assigné par défaut. Il est possible que le post processeur sélectionné par défaut ne soit pas approprié pour votre contrôleur. Dans ce cas il est nécessaire de sélectionner manuellement le bon post processeur.

Sélectionner un Post Processeur

Afin de sélectionner un post processeur pour un robot :

1.Faire un clic droit sur un robot ou un programme.

2.Sélectionner Sélectionner le Post Processeur.

3.Choisir un post processeur à partir de la liste qui apparait.

4.Sélectionner OK.

Post Processors - Image 1 Post Processors - Image 2

La modification est maintenant effective et le programme peut être généré à nouveau pour obtenir une nouvelle version de programme.

Note : La sélection d’un post processeur est liée au robot. Changer un post processeur pour un programme donné changera le post processeur pour tous les programmes qui sont liés au même robot dans la station.

Il est aussi possible de sélectionner le post processeur en suivant ces étapes :

1.Ouvrir le panneau/fenêtre du robot (double cliquer sur le robot).

2.Sélectionner Paramètres.

3.Sélectionner la liste post processeur dans la section Post Processeur.

Astuce : Il est possible d’avoir un aperçu des résultats produits par chaque post processeur en double cliquant sur le fichier PY dans le dossier C:/RoboDK/Posts/. Plus d’information est disponible dans la section suivante.

Post Processors - Image 3

Éditeur de Post Processeur

Vous pouvez facilement modifier les paramètres d’un post processeur à l’aide d’une interface graphique. L’éditeur de post processeur permet de modifier les variables définies dans le post processeur qui sont spécifiques à votre contrôleur robot.

L’éditeur de post processeur est un plugin qui permet de personnaliser vos post processeurs. Vous pouvez facilement le télécharger et l’installer à partir de la page suivante : https://robodk.com/addin/com.robodk.plugin.postprocessoreditor.

Procédez comme suit pour ouvrir l’éditeur de post processeur :

4.Sélectionner Programme➔Éditeur de Post Processeur.

5.Sélectionner le post processeur que vous souhaitez personnaliser.

6.Sélectionner OK. Une nouvelle fenêtre s’ouvrira, dans laquelle vous pourrez voir les variables modifiables.

7.Sélectionner Enregistrer le Post Processeur sous…

8.Saisir le nom sous lequel l’enregistrer.

Important : Vous ne devez pas écraser les post processeurs par défaut. Utilisez plutôt des noms uniques lorsque vous créez vos propres post processeurs. Les post processeurs par défaut seront réinitialisés à leur valeur d’origine si vous réinstallez RoboDK.

Post Processors - Image 4 Post Processors - Image 5

Par exemple, si vous sélectionnez le post processeur Fanuc R30iA, vous verrez la fenêtre présentée dans l’image précédente.

Modifier un Post Processeur

Il est possible de modifier un post processeur existant ou de créer de nouveaux post processeurs. Tous les post processeurs doivent être placés dans le dossier d’installation (par défaut C:/RoboDK/Posts/) pour qu’ils puissent être sélectionnés dans RoboDK. La section précédente contient les consignes pour apprendre à assigner un post processeur pour un contrôleur robot spécifique.

Chaque post processeur est un fichier PY. Il est possible de le renommer ou de copier d’autres fichiers dans le dossier C:/RoboDK/Posts/ pour partager différents post processeurs. Afin de supprimer un post processeur, il faut simplement supprimer le fichier PY correspondant.

Les post processeurs peuvent être modifiés en utilisant un éditeur texte ou un éditeur Python (Python IDLE). En utilisant un éditeur Python, cela permet de faire une évaluation rapide d’un programme d’essais à la fin du fichier Python.

Vidéo : Presentation (Anglais) “overview of post processors”: https://www.youtube.com/watch?v=lbycCDjtOnE.

Python doit être installé pour tester ou utiliser les post processeurs (Python est installé par défaut avec RoboDK). Pour modifier un post processeur :

1.Sélectionner Programme➔Ajouter/Modifier Post Processeur.

2.Sélectionner un post processeur existant.

3.Sélectionner OK. Un éditeur texte s’ouvre.

4.Sélectionner Run➔Run module (F5) pour pré-visualiser un résultat. Modifier si nécessaire le post processeur.

Post Processors - Image 6

Sinon, il est possible d’éditer un post processeur manuellement :

1.Aller dans le dossier C:/RoboDK/Posts/.

2.Ouvrir un fichier PY avec Python IDLE (faire un clic droit, puis, Edit with IDLE) ou un autre éditeur texte.

3.Effectuer les modifications.

4.Exécuter le fichier pour effectuer un essai : Sélectionner Run➔Run module (F5) dans Python IDLE.

Alternativement, il est possible d’éditer ce fichier en utilisant un éditeur texte et l’exécuter avec Python en double cliquant dessus.

Post Processors - Image 7

Astuce : Il est possible de changer l’éditeur par défaut pour les post processeurs dans RoboDK en sélectionnant Outils➔Options➔Autres et définir le chemin de l’éditeur dans Commande d’éditeur Python.

Post Processors - Image 8

Important : Vous ne devez pas écraser les post processeurs par défaut. Utilisez plutôt des noms uniques lorsque vous créez vos propres post processeurs. Les post processeurs par défaut seront réinitialisés à leur valeur d’origine si vous réinstallez RoboDK.

Important : Si vous utilisez un éditeur de texte (par exemple : Notepad++), il est important de remplacer les tabulations par 4 espaces. Sinon, vous risquez de rencontrer une erreur TabError. Ceci indique une utilisation incohérente de tabulations et d’espaces.

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

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 modifiée si le nombre maximum de lignes est spécifié dans le menu Program Options 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 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).

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 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.

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.

Note : Plusieurs fabricants de robots peuvent utiliser la même notation d’angles d’Euler. Par exemple, Fanuc et Motoman utilisent tous deux la notation XYZ, tandis que Stäubli et Mecademic utilisent tous deux la notation XY’Z’’, etc.

Important : Si vous spécifiez un mouvement à l’aide d’une pose (par exemple, en utilisant des coordonnées cartésiennes et des informations d’Euler ou de quaternion), la position atteinte par le robot dépendra de l’outil et des systèmes de référence actifs. Les poses de l’outil et des systèmes de référence doivent être correctement spécifiées dans le programme. Cela se fait respectivement à l’aide des fonctions setTool et setFrame.

Liste de Post Processeurs

RoboDK fournit par défaut plus de 100 post-processeurs pour prendre en charge la génération de programmes robot pour plus de 50 fabricants de robots. Certains post-processeurs peuvent être personnalisés davantage pour générer des programmes avec un format spécifique.

Vous pouvez trouver la liste complète des post-processeurs disponibles dans la bibliothèque RoboDK en accédant à https://robodk.com/posts. Vous pouvez également sélectionner Outils→Ouvrir la bibliothèque de robots depuis la barre d'outils principale de RoboDK pour trouver les robots, post-processeurs, Add-ins et plus encore disponibles.

Vous trouverez les post-processeurs suivants disponibles lorsque vous installez RoboDK :

33.ABB RAPID IRC5 : pour les contrôleurs de robot ABB IRC5.

34.ABB RAPID IRC5 Robtargets : pour les contrôleurs de robot ABB IRC5 et génère des noms de robtargets.

35.ABB RAPID S4C : pour les contrôleurs de robot ABB S4C.

36.Adept Vplus : pour le langage de programmation Adept V+.

37.Allen Bradley Logix5000 : pour l’automate Allen Bradley Logix5000.

38.Annin Robotics : pour les robots AR3 et AR4.

39.Aubo : pour les contrôleurs de robot AUBO.

40.Aubo ARCS : génère du code (.lua et .pro) pour les contrôleurs robotiques AUBO ARCS.

41.Automata : pour les robots Automata EVA.

42.Borunte : pour les bras robotiques Borunte. Génère un package zip avec les fichiers nécessaires pour les contrôleurs de robot BRTIRUS.

43.Brooks : pour les robots PreciseFlex.

44.CLOOS : pour les contrôleurs de robot CLOOS.

45.Comau C5G : pour les contrôleurs de robot Comau C5G (fichiers PDL).

46.Comau Nodal : pour les contrôleurs de robot Comau C5G utilisant les programmes Comau Nodal modernes (langage PDL2).

47.CPR : produit du code au format XML adapté aux systèmes robotiques CPR.

48.CSV : génère de simples fichiers au format CSV pour les contrôleurs robotiques et d'automatisation génériques. Ce post-processeur est polyvalent et peut être utilisé dans des applications nécessitant une importation et une exportation de données simples.

49.Denso PAC : pour les contrôleurs de robot Denso RC7 (et plus anciens) (langage de programmation PAC).

50.Denso RC8 : pour les contrôleurs de robot Denso RC8 (et plus récents) (langage de programmation PacScript).

51.Dobot Magician : pour les robots pédagogiques Dobot.

52.Dobot MG400 : pour le robot scara Dobot.

53.Dobot : pour la gamme industrielle de robots Dobot.

54.Doosan : pour les robots collaboratifs Doosan.

55.Elite CS : génère du code pour les contrôleurs de robot Elite CS.

56.Elite EC : génère du code pour les contrôleurs de robot Elite EC.

57.Estun RC : pour les contrôleurs de robot Estun RC.

58.Epson RC : pour les contrôleurs de robot Epson.

59.Fairino : produit des fichiers .lua et prend en charge la série de robots Fairino FR.

60.Fanuc R30iA : pour les contrôleurs de robot Fanuc R30iA et R30iB.

61.Fanuc R30iA Arc : pour le soudage à l’arc Fanuc.

62.Fanuc RJ3 : pour les contrôleurs de robot Fanuc RJ3.

63.Flexiv : génère des fichiers de trajectoire (.traj) pour les contrôleurs Flexiv Hesper.

64.Foxbot : génère des fichiers .pac pour les contrôleurs Foxbot.

65.GCode A3200 : génère des fichiers .cnc spécifiquement formatés pour les contrôleurs A3200 d'Aerotech.

66.GCode BnR : pour les contrôleurs de robot B&R.

67.GCode NCP : génère des fichiers .cnc compatibles avec les contrôleurs prenant en charge le langage NCP.

68.GSK : pour les robots GSK.

69.Hans : pour les contrôleurs de robot HAN’S.

70.HCR : pour les contrôleurs de robot Hanwha.

71.HIWIN HRSS : pour les robots HIWIN.

72.Huayan : pour les robots Huayan Robotics (anciennement Han's Robot), inclut un script et un fichier json.

73.Hyundai : pour les contrôleurs de robot Hyundai.

74.IGUS : génère du code au format XML adapté aux systèmes robotiques igus.

75.IIMT : génère des fichiers .txt que vous pouvez charger facilement dans les contrôleurs de robot IIMT CR.

76.Inexbot : génère des fichiers .JBI spécifiquement conçus pour les contrôleurs Inexbot (Inform III).

77.JAKA : pour les contrôleurs de robot JAKA.

78.Kassow : génère du code pour les contrôleurs Kassow Robots KR2.

79.Kawasaki : pour les contrôleurs de robot Kawasaki AS.

80.KEBA KAIRO : pour les contrôleurs de robot Keba Kairo.

81.Kinova : pour les robots Kinova.

82.Kinova Link6 : génère du code JSON (.json), compatible avec les bras robotiques Kinova Link 6.

83.KUKA app4PostPro : produit des fichiers .csv conçus pour les contrôleurs KUKA KR C4 avec app4PostPro.

84.KUKA CNC : génère des fichiers .nc conçus pour les systèmes KUKA.CNC.

85.KUKA EntertainTech : génère des fichiers .src et .emily pour les contrôleurs robotiques KUKA avec le package Entertain Tech.

86.KUKA IIWA : pour la programmation Sunrise en Java KUKA IIWA.

87.KUKA KRC1 : pour les contrôleurs de robot KUKA KRC1.

88.KUKA KRC2 : pour les contrôleurs de robot KUKA KRC2.

89.KUKA KRC2_CamRob : pour l’option d’usinage CamRob de KUKA.

90.KUKA KRC2_DAT : pour les contrôleurs de robot KUKA KRC2 incluant les fichiers de données DAT.

91.KUKA KRC4 : pour les contrôleurs de robot KUKA KRC4.

92.KUKA KRC4 Config : pour les contrôleurs de robot KUKA KRC4 avec les données de configuration sur chaque ligne.

93.KUKA KRC4 DAT : pour les contrôleurs de robot KUKA KRC4 incluant les fichiers de données DAT.

94.KUKA KRC5 : pour les contrôleurs de robot KUKA KRC5.

95.MARS : génère des fichiers .gpl pour les systèmes MARS.

96.MABI : pour les bras robotiques MABI qui utilisent des contrôleurs de robot Siemens Sinumerik (G-code).

97.Mecademic : pour le code script Mecademic requis par le robot Meca500.

98.Mecademic Python : génère un script Python permettant de contrôler à distance le robot Mecademic Meca500.

99.Mitsubishi : pour les contrôleurs de robot Mitsubishi.

100.Motoman/Yaskawa : pour différents contrôleurs de robot Motoman utilisant Inform II et Inform III (JBI). Nécessite de connaître le rapport pulses/degré de chaque axe. Vous pouvez charger le fichier ALL.PRM dans votre projet pour extraire automatiquement cette information.

101.Motoman Cartesian : pour les contrôleurs de robot Yaskawa/Motoman utilisant des valeurs cartésiennes. Vous pourriez avoir besoin de l’option Relative Job sur le contrôleur du robot si vous souhaitez modifier manuellement ce programme sur le contrôleur.

102.MyCobot : génère du code Python compatible avec les bras robotiques MyCobot.

103.Nachi AX FD : pour les contrôleurs de robot Nachi AX et FD.

104.Neura : génère un script Python NeuraPy compatible avec le contrôleur Neura Robotics Real-Time NR-Motion Master.

105.NEWKer i6 : génère du code conçu pour les contrôleurs CNC NEWKer i6.

106.Niryo : génère du code Python conçu pour les robots pédagogiques Niryo.

107.Omron : pour les contrôleurs de robot Omron-TM.

108.OTC : pour les contrôleurs de robot Daihen OTC.

109.Panasonic : pour les programmes PRG de Panasonic (nécessite les outils Panasonic G2PC pour compiler les fichiers ASCII en fichiers binaires).

110.Precise : pour les robots Precise Scara.

111.QJAR : génère des fichiers .rbg pour les contrôleurs de robot QJAR.

112.Rainbow Robotics : génère des fichiers .wsl pour les contrôleurs Rainbow Robotics.

113.Robostar : pour les contrôleurs de robot Robostar.

114.Rokae : génère des fichiers .mod pour les contrôleurs de robot ROKAE.

115.Rozum RC API : génère des fichiers .py pour s’intégrer aux contrôleurs Rozum RC Series.

116.Rozum RC Pulse : génère des fichiers .rcp conçus pour les contrôleurs Rozum RC Series.

117.Schneider : pour les contrôleurs Schneider Electric Lexium.

118.Siasun : pour les contrôleurs de robot Siasun.

119.Siemens 840D PKM : pour les robots PKM utilisant le contrôleur Siemens Sinumerik.

120.Siemens Sinumerik : pour le contrôleur de robot Siemens Sinumerik ROBX.

121.Staubli S6 : pour les contrôleurs de robot Staubli S6.

122.Staubli VAL3 : pour générer les programmes de robot Staubli VAL3 (contrôleurs CS8 et ultérieurs). Les mouvements du robot sont intégrés en ligne.

123.Staubli VAL3 Machining : pour les contrôleurs Staubli VAL3 disposant de l'option d'usinage HSM.

124.Techman : pour les contrôleurs de robot Techman.

125.Toshiba : pour les robots Toshiba.

126.Turin : produit des fichiers .txt pour les contrôleurs de robot Turin.

127.uArm : produit du code .cnc pour les systèmes robotiques uFactory uArm.

128.Universal Robots : pour les robots UR, génère des mouvements linéaires sous forme de cibles de pose.

129.Universal Robots URP : pour les robots UR, génère un fichier URP qui peut être chargé et modifié dans Polyscope (le contrôleur du robot UR).

130.Universal Robots_RobotiQ : pour les robots UR incluant la prise en charge de la pince RobotiQ.

131.Universal Robots MoveP : pour les robots UR, génère des mouvements linéaires sous forme de commandes MoveP.

132.Wlkata : pour les bras robotiques WLKATA Mirobot.

133.xArm : pour les systèmes robotiques uFactory xArm.

134.Yamaha : pour les robots Yamaha.

Note : Certains contrôleurs de robot, tels que les contrôleurs Fanuc et Panasonic, nécessitent un logiciel spécifique ou des options de contrôleur fournis par le fabricant pour prendre en charge le chargement des fichiers de programme générés par RoboDK. Par exemple, les robots Panasonic nécessitent les outils G2PC pour convertir le fichier de programme généré par RoboDK en un fichier binaire lisible par le contrôleur. Certains robots Fanuc prennent en charge les fichiers ASCII générés par RoboDK. Vous pouvez également compiler les programmes à l’aide de l’utilitaire maketp de Roboguide. En savoir plus dans la section de compilation LS vers TP Fanuc.

Note : La liste et le comportement des post-processeurs RoboDK par défaut évoluent de temps à autre. Cela signifie que le code généré à l’aide du même post-processeur peut différer selon les versions de RoboDK. Pour éviter des changements inattendus de votre code généré, vous devez créer une copie unique ou personnaliser vos post-processeurs afin que votre code généré ne change pas lorsque vous mettez à jour ou réinstallez RoboDK.

Référence

Vidéo : La vidéo suivante montre un résumé de comment utiliser les post processeurs dans RoboDK :
https://robodk.com/help#PostProcessor

Le module robodk.py fourni des outils pour les opérations de matrices (pour des multiplications des poses, inverse, etc.) et aussi les conversions entre poses et angles d’Euler dans différents formats, entre autres.

Note : Par défaut, Python est installé avec RoboDK et le module robodk.py est placé dans le dossier de Python (Python Path).

Une documentation plus technique est disponible en ligne dans la section de l’API (Anglais):
http://robodk.com/doc/en/PythonAPI/postprocessor.html

Tous les post processeurs utilisent le module robodk.py de Python :
http://robodk.com/doc/en/PythonAPI/robodk.html#robodk.Mat

La documentation de Python est disponible en ligne si vous voulez apprendre plus sur la programmation Python :
https://docs.python.org/3/

Lorsqu’un programme est généré, un programme Python générique/universel est généré et sauvegardé dans un dossier local temporaire. Ce programme générique est lié au post processeur approprié (sélectionné par l’utilisateur dans RoboDK). Le post processeur utilise une classe RoboPost définie dans le post processeur et qui génère le programme désiré.

Les programmes précompilés sont exécutés avec Python.

Astuce : Sur Windows, les programmes « pré-processés » sont sauvegardés dans le dossier : C:/Users/username/AppData/Local/Temp (Entrer %TEMP% dans l’explorateur de fichiers Windows). Il est possible d’utiliser ces programmes pour débugger un nouveau post processeur.