Les post-processeurs constituent une étape clé de la programmation hors-ligne (PHL), car ils permettent de générer des programmes robot pour un contrôleur robot spécifique (baie de contrôle). La programmation robot doit respecter des règles de programmation propres à chaque fabricant. Ces règles sont implémentées dans le post-processeur. Un post-processeur robot définit la manière dont les programmes robot doivent être générés pour un contrôleur robot spécifique.
La conversion d’une simulation RoboDK vers un programme robot spécifique se fait grâce à un post-processeur. Chaque robot est associé à un post-processeur qui définit un style de programmation robot spécifique. Le post-processeur est utilisé au moment de générer le programme hors-ligne. La section Génération de programmes montre 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 de nombreux post-processeurs permettant de prendre en charge plus de 50 fabricants et contrôleurs de robots différents. Les contrôleurs pris en charge sont listés dans la section Liste des post-processeurs. Il est aussi possible de créer un post-processeur « sur mesure » ou de modifier un post-processeur existant. Tous les post-processeurs sont disponibles dans le dossier :
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 RoboDK (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 génère pas des programmes appropriés pour votre contrôleur robot. Dans ce cas, il peut être nécessaire de sélectionner un autre post-processeur afin que les programmes puissent s’exécuter sur votre contrôleur robot.
Vous pouvez facilement sélectionner un post-processeur en faisant un clic droit sur un robot ou un programme. Le choix d'un post-processeur est attribué à un robot ; par conséquent, modifier le post-processeur attribué à un programme mettra à jour le post-processeur utilisé par tous les programmes attribués au même robot. Afin de sélectionner un post-processeur pour un robot :
Pour 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.


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 à un robot spécifique. Changer le post-processeur d'un programme mettra à jour le post-processeur de tous les programmes liés au même robot.
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 votre post-processeur dans la boîte Marque du robot, comme indiqué dans l'image suivante.
Astuce : Il est possible d’avoir rapidement un aperçu des résultats produits par chaque post-processeur en double cliquant sur son fichier PY dans le dossier C:/RoboDK/Posts/. Plus d’information est disponible dans la section suivante.

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


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.
Les post-processeurs doivent être placés dans le dossier C:/RoboDK/Posts/ afin de pouvoir être sélectionnés depuis RoboDK. La section précédente décrit comment lier un robot spécifique à un post-processeur.
Assurez-vous de disposer du code source du post-processeur pour pouvoir le modifier. Contactez-nous si le post-processeur que vous essayez de modifier n'est pas modifiable (compilé).
Il est possible de modifier les post-processeurs existants dans RoboDK afin de personnaliser la sortie de vos programmes robot, ou de créer de nouveaux post-processeurs. La plupart des post-processeurs n’ont pas besoin d’être modifiés : il suffit généralement de changer des paramètres de configuration pour obtenir la sortie de programme souhaitée. Assurez-vous de disposer du code source du post-processeur afin de pouvoir le modifier. Contactez-nous si le post-processeur que vous essayez de modifier n’est pas modifiable (compilé). Tous les post-processeurs doivent être placés dans le dossier C:/RoboDK/Posts/ pour qu’ils puissent être sélectionnés dans RoboDK. La section précédente explique comment associer un robot spécifique à un post-processeur.
Chaque post-processeur est un fichier PY. Il est possible de renommer le fichier ou de copier des fichiers depuis/vers le dossier C:/RoboDK/Posts/ pour partager différents post-processeurs. Afin de supprimer un script de post-processeur existant, il suffit de supprimer le fichier PY correspondant dans le dossier Posts.
Les post-processeurs peuvent être modifiés en utilisant n’importe quel éditeur texte ou un éditeur Python (Python IDLE). L’éditeur Python permet de déboguer rapidement et d’évaluer un programme d’essai à la fin du fichier.
Vidéo : Présentation des post-processeurs (en anglais) : https://www.youtube.com/watch?v=lbycCDjtOnE.
Python doit être installé pour tester et utiliser correctement les post-processeurs (Python est installé par défaut avec RoboDK). Pour modifier un post-processeur existant :
1.Sélectionner Programme➔Ajouter/Modifier Post-processeur.
2.Sélectionner un post-processeur existant.
3.Sélectionner OK. Un éditeur texte s’ouvre avec le programme.
4.Sélectionner Go Debug (F5) pour prévisualiser le résultat. Modifier le post-processeur si nécessaire. Selon l’éditeur de texte utilisé, il peut être nécessaire de sélectionner Run➔Run module (F5) à la place.

Sinon, il est possible d’éditer un post-processeur manuellement :
1.Aller dans le dossier des post-processeurs : C:/RoboDK/Posts/
2.Ouvrir un fichier PY avec Python IDLE (clic droitEdit with IDLE) ou un autre éditeur texte.
3.Effectuer les modifications.
4.Exécuter le fichier pour tester le résultat : Sélectionner Run➔Run module (F5 par défaut) 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.

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.
Important : vous ne devez pas remplacer les post-processeurs par défaut. Vous pouvez en revanche utiliser vos propres noms uniques lorsque vous créez vos propres post-processeurs. Les post-processeurs par défaut seront rétablis à leur valeur d'origine si vous réinstallez RoboDK.

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 tel que Notepad++ et Python 3.6 ou une version antérieure, il est important de remplacer les tabulations par 4 espaces. Sinon, vous rencontrerez une erreur TabError indiquant une utilisation incohérente de tabulations et d’espaces dans l’indentation.
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.
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).

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.

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

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.
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('; --------------------------')
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.
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.
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 de fraisage 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 du préhenseur 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.
Vidéo : La vidéo suivante montre un résumé de comment utiliser les post processeurs dans RoboDK :
https://robodk.com/help#PostProcessor
Vous trouverez la liste complète des post-processeurs pris en charge dans la bibliothèque de post-processeurs : https://robodk.com/posts. Vous pouvez sélectionner un post-processeur pour en savoir plus sur les contrôleurs pris en charge et les paramètres que vous pouvez personnaliser.
La documentation de référence de chaque méthode du post-processeur est disponible dans la section API de RoboDK de la documentation : http://robodk.com/doc/en/PythonAPI/postprocessor.html
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
Une documentation est disponible en ligne pour en savoir plus sur la programmation Python :
https://docs.python.org/3/.
Lorsque vous générez un programme dans RoboDK, un programme Python universel prétraité est généré et enregistré dans un dossier local temporaire. Le programme prétraité est lié au post-processeur approprié (sélectionné par l'utilisateur dans RoboDK). Le post-processeur possède une classe RobotPost qui définit comment le programme doit être généré pour votre contrôleur de robot.
Les programmes précompilés sont exécutés avec Python.
Astuce : Les fichiers Python prétraités que vous utilisez sont disponibles dans votre dossier temporaire lorsque l'option Debug est activée dans RoboDK. Vous pouvez activer l'option de débogage en exécutant RoboDK-Debug.bat dans le dossier d'installation. Juste après avoir généré un programme, vous pouvez trouver le post-processeur Python prétraité dans C:/Users/username/AppData/Local/Temp (sous Windows par exemple). Ces programmes peuvent également être utilisés pour déboguer vos post-processeurs personnalisés.