RoboDK est un simulateur axé sur les applications de robots industriels. Cela signifie que les programmes robot peuvent être créés, simulés et générés hors ligne pour un bras robotique et un contrôleur de robot spécifiques. En d’autres termes, RoboDK est un logiciel de Programmation Hors Ligne.
Afin de créer un programme robot, il est nécessaire de sélectionner un robot, charger les outils du robot et d’utiliser une ou plusieurs fonctionnalités de conversion CAO vers trajectoire afin de créer des programmes en ajoutant des cibles ou en utilisant des outils spécifiques (tels que la conversion d’un programme CNC vers un programme robot).
Une vaste bibliothèque de robots industriels est disponible. Les robots industriels sont modélisés dans RoboDK de la même manière qu’ils se comportent avec les contrôleurs spécifiques des marques, incluant les limites d’axes, sens des mouvements et les liaisons des axes.

Cette section montre comment un programme robot est créé, simulé et généré pour un contrôleur de robot spécifique en utilisant l’interface utilisateur graphique (GUI / Graphical User Interface) de RoboDK.
Note : Cette section décrit uniquement comment créer un programme robot en utilisant l’interface utilisateur graphique (GUI). L’API de RoboDK peut être utilisée en complément de ces programmes ou pour créer complètement un programme robot. Consultez la section API de RoboDK pour plus d’informations.
La PHL - Programmation Hors-Ligne (Offline Programming) veut dire que l’on programme le robot hors environnement de production. La programmation hors-ligne évite les arrêts de production causés par la programmation en ligne sur le robot. (Programmation utilisant le teach pendant).
La simulation et la programmation hors-ligne permettent d’étudier de multiples scénarios pour une cellule robot avant de démarrer en production. D’éventuelles erreurs de conception d’une cellule peuvent alors être prédites et corrigées par avance.
La programmation hors-ligne est le meilleur moyen de maximiser les retours sur investissement de systèmes robotisés mais nécessite toutefois des outils de simulation appropriés. Le temps pour la mise au point de nouveaux programmes peut être réduit de plusieurs semaines à une seule journée. Ceci permet la robotisation de productions en petites séries.
Une simulation peut être réalisée en ajoutant toute une suite d’instructions dans un programme. Chaque instruction représente du code pour un contrôleur spécifique donné. RoboDK propose à travers son environnement et son interface utilisateur (GUI) de construire facilement un programme robot de manière générique, sans avoir besoin d’écrire de code.
Le code spécifique pour un contrôleur robot donné sera généré automatiquement lorsque le programme est généré. Pour créer un nouveau programme vide à l’aide de l’interface utilisateur graphique de RoboDK :
1.Sélectionner un programme➔
Vous pouvez également cliquer sur le bouton correspondant dans la barre d'outils.
2.Sélectionner Outils➔Renommer l’objet… (F2) pour renommer le programme
Note : Les programmes sont automatiquement créés si une instruction est ajoutée alors qu’aucun programme n’est disponible dans la station.
Cette action va créer un programme vide et va autoriser l’ajout de nouvelles instructions en faisant un clic droit sur le programme ou en sélectionnant une instruction depuis Menu Programme. La section suivante Instructions de programmeapporte plus de détails sur comment ajouter des instructions.

Note : Les simulations et programmes peuvent aussi être complètement créés en utilisant l’API RoboDK et un langage de programmation spécifique tel que Python, C# ou Matlab. La section API RoboDK vous apportera plus de précisions.
Il est possible d’ajouter de nouvelles instructions en effectuant un clic droit sur un programme ou depuis le menu Programme, comme indiqué dans la section précédente.
Cette section décrit les instructions prises en charge par l’interface utilisateur graphique de RoboDK pour la programmation hors ligne de robots.
Sélectionnez Programme➔
A moins qu’une cible ne soit sélectionnée avant d’ajouter l’instruction, l’instruction de mouvement va créer une nouvelle cible et elles seront liées. Si la cible change de position, le mouvement sera modifié aussi.
S’il s’agit de la première instruction ajoutée au programme, deux instructions supplémentaires seront ajoutées avant l’instruction de mouvement : une sélection du repère de référence (Définir Ref.) et une sélection du repère outil (Choisir Outil). Cela permettra de s’assurer que lorsque le programme atteint l’instruction de mouvement, le robot utilise le même repère de référence et le même repère outil que ceux utilisés pour créer cette nouvelle cible.

Sélectionnez Programme➔
À moins qu’une cible ne soit sélectionnée avant d’ajouter l’instruction, l’instruction de mouvement va créer une nouvelle cible et elles seront liées. Si la cible est déplacée, le mouvement sera également modifié.
Les mouvements articulaires et les mouvements linéaires se comportent de la même manière et peuvent facilement être changés d’un type à l’autre.
De la même façon que pour l’instruction de mouvement articulaire, s’il s’agit de la première instruction ajoutée au programme, deux instructions supplémentaires seront ajoutées avant l’instruction de mouvement : Définir Ref. et Choisir Outil.
Important : Il est recommandé de garder le premier mouvement de chaque programme comme un mouvement articulaire utilisant une cible articulaire. Cela permettra de définir correctement la configuration souhaitée dès le premier mouvement et de s’assurer que le vrai robot se déplace de la même façon qu’il a été simulé.
Contrairement aux mouvements articulaires, les mouvements linéaires sont sensibles aux singularités du robot et aux limites d’axes. Par exemple, la plupart des bras robotiques ne peuvent pas traverser une singularité lors d’un mouvement linéaire. L’image suivante montre un exemple indiquant que l’articulation 5 est trop proche d’une singularité (0 degré). Envisagez plutôt un mouvement articulaire.

Si un mouvement linéaire n’est pas strictement nécessaire, faire un clic droit sur l’instruction de mouvement et la changer en une instruction de mouvement articulaire.

En parallèle, la cible, le TCP ou la position du repère de référence doit être modifié afin de n’avoir aucune singularité.
Sélectionnez Programme➔ 
Le repère est une variable également connue sous le nom de Work Object (robots ABB), UFRAME (robots Fanuc), FRAME (robots Motoman) ou $BASE (robots KUKA).

Note : Certains contrôleurs acceptent le réglage des repères à l’aide d’un repère numéroté (tels que les contrôleurs Fanuc et Motoman). Dans ce cas, le nom du repère peut se terminer par un chiffre (tel que Frame 4 pour choisir le repère d’indice 4).
Sélectionnez Programme➔ 
Le repère outil est une variable également connue sous le nom de ToolData (robots ABB), UTOOL (robots Fanuc), TOOL (robots Motoman) ou $TOOL (robots KUKA).

Note : Certains contrôleurs acceptent le réglage des repères outil à l’aide d’un numéro d’outil (tels que les contrôleurs Fanuc et Motoman). Dans ce cas, le nom du repère outil peut se terminer par un chiffre (tel que Tool 4 pour choisir l’outil indexé 4).
Sélectionnez Programme➔
Sélectionner Programme➔ Instruction Move Circular afin d’ajouter une nouvelle instruction de mouvement circulaire. Il est possible de sélectionner cette fonction dans la barre d’outils.
À moins que deux cibles ne soient sélectionnées avant d’ajouter l’instruction, l’instruction de mouvement ne va pas créer de nouvelle cible. Il faut donc créer deux cibles supplémentaires séparément et les lier depuis l’instruction de mouvement circulaire, tel que montré dans l’image ci-dessous.

La trajectoire circulaire est un arc créé du point où le robot est localisé, passant par le premier point circulaire (Cible liée 1) et terminant au point final (Cible liée 2).
Important : Il n’est pas possible d’accomplir un cercle complet avec une seule instruction circulaire. Un cercle complet doit être divisé en deux mouvements circulaires distincts.
Sélectionnez Programme➔
Activer la case correspondante pour définir une vitesse et/ou une accélération spécifique dans le programme. Le robot applique la nouvelle vitesse à partir du moment où l’instruction est exécutée.
La vitesse du robot peut aussi être changée dans le menu des paramètres du robot : Double-clic sur le Robot, sélectionner Paramètres.
Note : Certains contrôleurs robots ne supportent pas le paramétrage précis des accélérations.
Important : Paramétrer les bonnes vitesses est important pour calculer de manière précise le temps du programme (temps de cycle). Plus d’informations sont disponibles dans la section des temps de cycle.

Sélectionner Programme➔

Sélectionnez Programme➔

Note : Mettre la valeur du délai de pause à -1 pour mettre en pause le programme jusqu’à ce que l’opérateur décide de le relancer. Dans ce cas, l’instruction sera automatiquement nommée « Arrêter ».
Important : Dans la simulation, une pause de 5 secondes prendra 1 seconde à simuler avec le ratio de simulation par défaut de 5. Plus d’informations sont disponibles dans la section Simulation.
Sélectionnez Programme➔
Par défaut, il s’agit d’un appel bloquant vers un programme spécifique. Cependant, il est possible de choisir Insérer code afin d’entrer un code spécifique à l’emplacement de cette instruction. Cela peut être utile pour une application spécifique et un contrôleur spécifique.
Astuce : Sélectionner Sélectionner programme pour remplir automatiquement le champ de texte. Sinon, une correspondance de texte devrait également fonctionner. S’il y a une correspondance de nom avec le sous-programme utilisé dans l’instruction, ce sous-programme sera simulé dans RoboDK.
Astuce : Entrer plusieurs lignes pour créer automatiquement plusieurs instructions d’appel de programme à la suite.


Changer de Appel Programme vers Démarrer Thread pour provoquer un appel non bloquant d’un sous-programme. Dans ce cas, le contrôleur démarrera un nouveau Thread. Cette option n’est disponible que pour certains contrôleurs et fonctionne seulement pour des opérations spécifiques.
Astuce : Un programme principal utilisé seulement pour la simulation peut utiliser l’option Démarrer Thread pour démarrer la simulation de plusieurs programmes en même temps (par exemple lorsque deux robots ou plus sont simulés).
Sélectionnez Programme➔
Le nom IO peut être un nombre ou un texte s’il s’agit d’une variable nommée. La valeur IO peut être un nombre (0 pour False et 1 pour True) ou un texte s’il s’agit d’un état nommé.
Note : Cette instruction permet aussi de définir des Sorties Analogiques (AO) ou d’attendre des Entrées Analogiques (AI) sur certains contrôleurs de robot. Dans ce cas, il est possible d’indiquer un nombre décimal ou un texte spécifique à la place d’un nombre.

Paramétrer à Attendre Entrée Digitale (DI) pour stopper l’exécution du programme jusqu’à ce qu’une entrée spécifique passe à une valeur spécifique. De plus, la plupart des contrôleurs de robot ont un « timeout delay » qui déclenche une erreur si le temps attendu dépasse une certaine valeur. Activer la case Timeout (ms) pour actionner cette option.

Astuce : Il convient, si par exemple le robot dispose d’un équipement spécifique dans la cellule (tel qu’un préhenseur ou une broche de fraisage), d’activer cet équipement par le biais d’une Sortie Digitale (DO), puis d’attendre qu’une Entrée Digitale (DI) spécifique passe à un état spécifique.
La modification des Entrées Digitales et Sorties Digitales simulées créera de nouvelles variables de station. Pour vérifier l’état de ces variables, faire un clic droit sur la station et sélectionner Paramètres de station. Il est également possible de lire ou de modifier ces variables via l’API.
Sélectionner Programme➔
Sans instructions de lissage, le robot va atteindre une vitesse de 0 à la fin de chaque mouvement (sauf si le mouvement suivant est tangent avec le mouvement précédent). Cela provoque de grosses accélérations et des changements rapides de vitesse afin d’assurer la meilleure précision de chaque mouvement.
Cette valeur est aussi connue comme Blending radius (Universal Robots), ZoneData (ABB robots), CNT/FINE (Fanuc robots), Cornering (Mecademic robots) ou $APO.CDIS/$APO.CPTP/Advance (KUKA robots).
Note : Paramétrer la valeur de lissage à -1 pour avoir des mouvements fins. Cela implique que le robot n’arrondira pas les angles de la trajectoire.

Astuce : Une grosse valeur de lissage va permettre au robot de garder une vitesse constante le long de la trajectoire, en contrepartie d’une perte de précision dans les angles de la trajectoire. Selon chaque application, il est d’usage de trouver un bon compromis entre précision et fluidité de la vitesse.
Certains contrôleurs nécessitent de définir cette valeur sous forme de pourcentage. Par exemple, sur un contrôleur Fanuc, pour obtenir la commande CNT5, vous devez entrer la valeur 5.
Vous pouvez également spécifier le paramètre de lissage dans la fenêtre Program Events si vous générez vos programmes pour de l’usinage robotisé, de l’impression 3D ou du suivi de courbes/points.

Vous pouvez créer des évènements spécifiques destinés à la simulation à l’aide d’une instruction d’évènement de simulation. Les évènements de simulation n’ont aucun impact sur le robot réel ni sur le programme robot généré. Sélectionnez Programme➔Instruction Évènement de simulation pour ajouter un évènement de simulation personnalisé. Ce type d’instruction provoquera un évènement spécifique uniquement à des fins de simulation, comme attacher un objet à un préhenseur, le déposer sur une table ou créer des objets pour simuler un dispositif d’alimentation.
Vous pouvez utiliser l’interface utilisateur pour déclencher les actions suivantes en tant qu’évènements de simulation :
3.Attacher un objet à un outil.
4.Détacher un objet d’un outil et le déposer sur un système de coordonnées.
5.Afficher un ou plusieurs objets ou outils.
6.Cacher un ou plusieurs objets ou outils.
7.Définir la position absolue d’un ou plusieurs objets ou repères.
8.Définir la position relative d’un ou plusieurs objets ou repères.
9.Mettre les articulations du robot à la position d’origine (home).
10.Déplacer un convoyeur.
11.Créer un objet.
12.Supprimer des objets.
13.Attendre un objet.
Note : Les évènements suivants ont été ajoutés depuis la version 6 de RoboDK et ne sont pas disponibles ou compatibles avec les versions précédentes de RoboDK : ramener le robot en position home, créer, supprimer et attendre un objet (évènements 7 à 10).

Par exemple, si le robot bouge à un endroit spécifique pour attraper un objet, il est possible de paramétrer un évènement Objet Attaché (Attach object) pour bouger cet objet en même temps que le robot. Après que le robot ait terminé son mouvement, il peut laisser l’objet. Il est possible de paramétrer Détacher objet (Detach object) pour laisser l’objet que l’outil a précédemment attrapé.

L’évènement de simulation Attacher un objet permet d’attacher un objet à un outil pour simuler une action de prise.
Lorsque l’action d’attacher un objet à un outil est déclenchée, l’objet le plus proche de l’outil sélectionné est attaché. Une tolérance par défaut de 200 mm est utilisée pour ignorer tout objet plus éloigné que cette distance.

Si vous ne spécifiez pas de tolérance de distance, la valeur par défaut globale est utilisée (vous pouvez la modifier dans Outils Options Distance maximum pour attacher un objet à un outil de robot). De plus, par défaut, la distance est vérifiée entre l’emplacement du CDO et la référence de l’objet. Il est également possible d’utiliser la distance entre le CDO et la géométrie de l’objet en sélectionnant Vérifier la distance la plus courte entre le CDO et la forme de l’objet.
L’évènement de simulation Détacher un objet permet de détacher un objet d’un outil vers un autre objet ou système de coordonnées.
Vous devez choisir l’outil duquel les objets doivent être détachés, ainsi que le système de coordonnées ou l’objet auquel ils doivent être attachés ensuite.
L’évènement de simulation Détacher un objet permet de simuler une opération de dépose dans une application de prise et dépose (il effectue l’action opposée à l’évènement Attacher un objet).
Par exemple, si le robot se déplace vers un emplacement spécifique pour saisir un objet, vous pouvez paramétrer un évènement Attacher un objet pour déplacer cet objet en même temps que le robot. Ensuite, une fois que le robot s’est déplacé et qu’il est prêt à déposer les objets saisis, vous pouvez déclencher un évènement Détacher un objet pour libérer tous les objets que l’outil du robot a saisis.

L’évènement Afficher des objets ou des outils permet de rendre visibles un ou plusieurs objets, outils ou robots dans l’environnement de simulation.
Vous pouvez sélectionner un ou plusieurs éléments en maintenant la touche Ctrl enfoncée.

L’évènement Masquer des objets ou des outils permet de rendre invisibles un ou plusieurs objets ou outils dans la simulation.
Vous pouvez sélectionner un ou plusieurs éléments en maintenant la touche Ctrl enfoncée.

L’évènement Définir la position de l’objet (absolue) permet de mettre à jour la position de chaque objet sélectionné lorsque cette action est déclenchée. Le repère parent auquel chaque élément est attaché n’est pas modifié : seule la position de chaque objet est mise à jour.
Vous pouvez sélectionner un ou plusieurs éléments en maintenant la touche Ctrl enfoncée. La position actuelle de l’élément est enregistrée lorsque vous cliquez sur OK.

L’évènement Définir la position de l’objet (relative) permet de mettre à jour la position et le parent de chaque objet sélectionné lorsque cette action est déclenchée. Le repère parent auquel chaque élément est attaché est également modifié, et la position de chaque objet est aussi mise à jour.
Vous pouvez sélectionner un ou plusieurs éléments en maintenant la touche Ctrl enfoncée. La position actuelle de l’élément ainsi que l’élément parent auquel il est attaché sont enregistrés lorsque vous cliquez sur OK.
La différence entre cette instruction et l’instruction de position absolue est que celle-ci met également à jour l’élément parent auquel chaque objet est attaché.

L’évènement Définir les articulations en position home déclenche le déplacement immédiat du robot ou des mécanismes sélectionnés vers leurs positions d’articulations « home » définies (le mouvement n’est pas simulé dans le temps).
Ceci est utile lorsque vous devez réinitialiser une simulation et replacer les convoyeurs à leur position de départ.
Vous pouvez sélectionner un ou plusieurs éléments en maintenant la touche Ctrl enfoncée.

L’évènement Déplacer le convoyeur simule le déplacement du convoyeur sur une distance spécifique, en simulant l’effet du mouvement dans le temps.
Ceci est utile lorsque vous devez simuler un incrément spécifique pour traiter un objet sur le convoyeur une fois qu’il a parcouru une distance donnée.

L’instruction Créer un objet permet de simuler un alimentateur (feeder) en créant un nouvel objet dans l’environnement de simulation.
Vous devez sélectionner l’objet modèle à créer ainsi que le repère parent auquel les éléments doivent être attachés.
Cette action est utile pour créer de nouveaux objets sur un convoyeur.

L’instruction Supprimer des objets retire des objets de l’environnement de simulation.
Vous devez sélectionner un objet modèle que vous souhaitez supprimer. Tout objet correspondant au nom et à la géométrie de cet objet est supprimé lorsque cette action est déclenchée. L’objet modèle sélectionné ainsi que tout objet verrouillé ne sont pas supprimés.
Cette instruction permet de nettoyer une simulation terminée lorsque de nombreux objets ont été créés par l’instruction Créer un objet.

L’instruction Attendre un objet attend qu’un objet entre en contact avec un autre objet pour déclencher une action spécifique.
Cet évènement est utile lorsque vous souhaitez déclencher une action en fonction d’un contact entre objets. Il est courant de placer cette instruction seule dans un programme exécuté en boucle, qui effectue une action spécifique lorsqu’un objet entre en contact avec un capteur.

Les actions que vous pouvez effectuer lorsqu’un objet est en contact avec le capteur sont les suivantes :
Arrêter un robot : vous devez sélectionner le robot ou le mécanisme qui doit s’arrêter.
Supprimer un objet : l’objet doit être retiré de la station.
Attendre uniquement l’objet (par exemple, vous pouvez déclencher la prise d’un objet par un robot).
Déplacer un objet vers un autre système de coordonnées. Par exemple, pour transférer un objet d’un convoyeur à un autre.

Pour démarrer la simulation d’un programme, il suffit de double-cliquer sur le programme dans l’arborescence. Vous pouvez également faire un clic droit sur le programme et sélectionner Exécuter.
Vous pouvez également :
1.Cliquez avec le bouton droit sur le programme
14.Sélectionnez Exécuter
Une barre de simulation apparaît en bas de la fenêtre si le programme est lancé par un double-clic. Il est possible de faire avancer ou reculer la simulation en faisant glisser le curseur de la barre de simulation.

Astuce : sélectionnez Programme➔
RoboDK simule 5 fois plus vite qu’en vrai par défaut. Cela veut dire que si un programme prend 30 secondes pour s’exécuter, le simulateur va le faire durer 30/5 = 6 secondes. L’accélération de la simulation augmente ce ratio à 100. Les vitesses de simulation normale et rapide peuvent être modifiées dans Outils➔Options➔Mouvement.
Astuce : Sélectionner Programme➔ Pause pour mettre en pause la simulation (ou appuyer sur la touche Retour arrière).
Astuce : Appuyer sur la touche Echap pour stopper la simulation ou double-cliquer à nouveau sur le programme.
Astuce : Faire un clic droit sur une instruction de mouvement et sélectionner Démarrer d’ici afin de reprendre l’exécution du programme à partir de cette instruction, comme illustré dans l’image suivante.

Astuce : maintenez la touche Ctrl enfoncée pour sélectionner plusieurs programmes à la fois et les générer tous en même temps.
Remarque : vous pouvez également sélectionner Programme➔Générer un ou plusieurs programmes (F6) pour générer un ou plusieurs programmes de robot lorsque vous avez sélectionné un ou plusieurs programmes.
Le programme du robot devrait alors s'afficher dans un éditeur de texte.
Lorsque vous avez un programme prêt à être exporté vers le robot, vous pouvez générer le fichier programme requis par votre contrôleur de robot. Suivre ces instructions pour générer le programme robot :
1.Sélection du Programme (Par exemple WeldProgram)
2.Sélectionner Générer programme robot (F6). Le programme robot s’affiche alors dans un éditeur de texte. Note : vous pouvez également sélectionner Programme➔Générer Programme(s) (F6) pour générer un ou plusieurs programmes robot lorsque un ou plusieurs programmes sont sélectionnés.

Note : Vous pouvez également sélectionner Programme Générer Programme(s) (F6) pour générer un ou plusieurs programmes robot lorsque un ou plusieurs programmes sont sélectionnés. Astuce : Maintenez la touche Contrôle (Ctrl) enfoncée pour sélectionner plusieurs programmes en même temps et les générer tous à la fois. Vous pouvez aussi faire un clic droit sur un programme et sélectionner Générer programme robot sous… (Shift+F6) pour générer le programme en spécifiant l'emplacement où vous souhaitez l'enregistrer.
Par défaut, les programmes robot sont enregistrés dans le dossier Documents (C:/Users/VotreNom/Documents/RoboDK/Programs/). Vous pouvez modifier ce dossier en sélectionnant Outils➔Options, en sélectionnant l’onglet Programme, puis en cliquant sur Définir à côté de Dossier des programmes robot.
Note : Pour certains contrôleurs robot, il est recommandé d’intégrer le programme généré et les sous-programmes requis dans un seul et même fichier programme. RoboDK gère déjà ce détail : pour les contrôleurs qui prennent en charge cette fonctionnalité (par exemple : ABB, Universal Robots ou KUKA), les sous-programmes sont directement inclus dans le programme principal. En revanche, pour les robots qui ne prennent pas en charge cette fonctionnalité, vous devrez générer plusieurs fichiers et les transférer vers le contrôleur du robot afin d’exécuter correctement tous les programmes (par exemple, sur les contrôleurs Fanuc ou Yaskawa/Motoman). Certains post processeurs permettent de configurer ce comportement. Vous trouverez plus de paramètres dans Outils➔Options, onglet Programme.
Vous pouvez également cliquer avec le bouton droit sur un programme et sélectionner Générer programme robot sous… (Maj+F6) pour générer le programme en indiquant l'emplacement où vous souhaitez l'enregistrer.
Il est possible de transférer un programme de l’ordinateur directement sur le robot. Normalement, cette option envoie le programme au robot au travers du protocole FTP ou d’autres protocoles spécifiques, tels que l’utilisation de messages par socket ou d’une connexion série. Tout d’abord, il est nécessaire d’entrer l’adresse IP du robot et les paramètres FTP dans le menu de connexion du robot :
1.Faire un clic droit sur un robot
2.Sélectionner Connecter au robot… Une fenêtre apparaîtra sur la gauche.
3.Entrer l’adresse IP du robot
4.Sélectionner Plus d’options… pour entrer les paramètres FTP et les identifiants FTP (si nécessaire)


Une fois que les paramètres du réseau ont été renseignés et que le robot est correctement connecté, suivre les étapes suivantes pour transférer le programme au robot directement depuis RoboDK :
1.Faire un clic droit sur un programme
2.Sélectionner Envoyer Programme au robot (Ctrl+F6)

Une fenêtre pop-up va apparaitre pour indiquer le succès ou l’échec de l’envoi.
Note : Les programmes peuvent aussi être transférés au moyen d’une clé USB ou d’autres supports. La section Astuces Robot (section spécifique par marque) apporte plus d’informations pour certaines des marques de robots prises en charge.
Important : Le bouton Connecter est uniquement utile lorsque l’on utilise le pilote du robot. Il est possible de réaliser un transfert de programme sans connecter le pilote du robot. Le pilote du robot permet de déplacer le robot point par point depuis RoboDK et de déboguer des programmes de manière simple (option Run on Robot). Le pilote du robot permet aussi de déplacer le robot directement au travers de l’API.
La conversion depuis la simulation RoboDK vers un programme robot spécifique est réalisée par un post-processeur. Le post-processeur définit comment les programmes robots devraient être générés pour un robot spécifique. Chaque robot possède un post-processeur spécifique par défaut dans RoboDK.
Afin de sélectionner un post-processeur spécifique pour un robot :
1.Faire un clic droit sur un programme ou robot
2.Sélectionner Sélectionner le post-processeur
3.Choisir un post-processeur dans la liste
4.Sélectionner OK


Le changement est maintenant appliqué et le programme peut être généré de nouveau afin de voir le résultat.
Note : Un post-processeur est lié à un robot spécifique. Changer le post-processeur d’un programme changera le post-processeur de tous les programmes liés au même robot.
Les post-processeurs dans RoboDK apportent une flexibilité totale pour générer des programmes robots en fonction des exigences spécifiques. RoboDK fournit des post-processeurs pour la plupart des marques de robots. Les post-processeurs peuvent facilement être créés ou modifiés. Pour plus d’information à propos des post-processeurs, consultez la section dédiée aux post-processeurs.
Vous pouvez personnaliser la manière dont les programmes sont générés pour votre robot.
Suivez ces étapes pour accéder aux paramètres de génération de programme :
5.Sélectionner Outils➔Options.
6.Sélectionner l’onglet Programme.

Ce menu permet de personnaliser la génération de programme, notamment :
7.Découper les mouvements articulaires en petits pas.
8.Découper les mouvements linéaires en petits pas.
9.Convertir les mouvements circulaires en petits mouvements linéaires.
10.Découper les longs programmes robot en sous-programmes.
11.Spécifier l’emplacement par défaut pour enregistrer vos programmes robot.
12.Spécifier l’éditeur de texte par défaut pour les programmes robot.
Astuce : Des paramètres supplémentaires peuvent être définis ou remplacés par le post-processeur sélectionné.
Vous pouvez facilement convertir les mouvements circulaires en petits mouvements linéaires lors de la génération des programmes de votre robot. Ceci est utile si votre contrôleur ne prend pas en charge les mouvements circulaires (arcs).
Suivez ces étapes pour générer les arcs sous forme de petits mouvements linéaires :
13.Sélectionner Outils➔Options.
14.Sélectionner l’onglet Programme.
15.Sélectionner Éviter les arcs.
16.Spécifier la Taille maximale de l’arc (mm), qui définit la taille des mouvements linéaires le long de l’arc.

Les programmes de robotique volumineux peuvent dépasser les limites de votre contrôleur de robot. Ces limites peuvent concerner la taille du fichier ou le nombre de lignes par programme. Par exemple, un programme de robotique destiné à l'usinage robotisé ou à l'impression 3D peut comporter des milliers de lignes de code.
Les longs programmes robot peuvent dépasser les limites du contrôleur du robot. La limite du contrôleur peut être la taille du fichier ou le nombre de lignes par programme. Par exemple, un programme robot créé pour l’usinage robotisé ou l’impression 3D peut comporter des milliers de lignes de code. Dans ce cas, il est plus astucieux de découper les programmes longs en plusieurs sous-programmes, incluant un programme principal qui permet de faire fonctionner les sous-programmes.
Pour découper automatiquement un programme long :
1.Sélectionner Outils➔Options➔Programme
2.Cocher Limiter le nombre maximal d’instructions par programme et renseigner le nombre maximal de lignes par programme à générer par fichier.
Astuce : La plupart des post-processeurs ont une limite par défaut du nombre maximal de lignes par programme, qui peut être modifiée ou remplacée grâce à cette procédure (une variable nommée MAX_LINES_X_PROG).

Lorsque vous générez un programme qui appelle un sous-programme, RoboDK crée automatiquement une instruction pour appeler ce sous-programme. Il est cependant possible de personnaliser la génération du programme afin d’inclure les sous-programmes directement dans le programme principal et d’éviter les appels de programme.
Note : Certains post-processeurs incluent les sous-programmes dans le fichier du programme principal par défaut (comme le post-processeur ABB par défaut), tandis que d’autres ne les incluent pas car il s’agit généralement de fichiers séparés dans le contrôleur du robot (comme le post-processeur Fanuc par défaut).
Suivez ces étapes pour inclure les sous-programmes en ligne et éviter les appels de programmes hors-ligne :
3.Sélectionner Outils➔Options.
4.Sélectionner l’onglet Programme.
5.Cocher l’option Sous-programmes en ligne.
Désormais, lorsque vous générez des programmes contenant des sous-programmes, vous obtiendrez directement le contenu de ces sous-programmes dans le premier programme (programme principal).

Les post-processeurs et les pilotes de robot utilisent des méthodes différentes pour faire bouger les robots. Alors qu’un post-processeur permet de générer des programmes hors-ligne, un pilote permet d’avoir une communication en temps réel avec le robot.
Un post-processeur est utilisé pour la programmation hors-ligne et se charge de convertir le programme robot RoboDK dans le langage de programmation natif du contrôleur du robot associé. Par exemple, le post-processeur ABB génère des fichiers .mod pour les contrôleurs IRC5. Le post-processeur inclut également le transfert du programme vers le contrôleur du robot, souvent par FTP. Les fonctionnalités suivantes d’un programme sont gérées par le post-processeur :
6.Générer le programme robot
7.Générer le programme robot sous…
8.Envoyer le programme au robot
9.Démarrer sur le robot (en combinaison avec le pilote)

Un pilote de robot permet de contrôler à distance votre robot depuis votre ordinateur en utilisant RoboDK. Cela vous permet d’exécuter les instructions de programme depuis RoboDK sur le contrôleur du robot en temps réel, y compris la possibilité d’appeler des programmes à distance sur le contrôleur. Par exemple, le pilote ABB envoie les commandes de mouvement via une communication socket. Les fonctionnalités suivantes sont gérées par le pilote :
10.Activer l’option Exécuter sur le robot, puis double-cliquer pour exécuter le programme sur le robot à l’aide du pilote.
11.Démarrer sur le robot (en combinaison avec le post-processeur)

Note : Les pilotes de robot envoient chaque instruction individuellement et attendent que le contrôleur ait terminé. Pour les commandes de mouvement, cela signifie qu’un léger délai (à-coup apparent) se produira.
Astuce : Vous pouvez utiliser une combinaison hybride du post-processeur et du pilote, où les trajectoires complexes sont transférées vers le contrôleur puis appelées à distance par le pilote. Cela est particulièrement efficace lors de l’utilisation de l’API RoboDK.