Un pilote de robot peut contrôler un vrai robot qui est connecté à un ordinateur. Les pilotes de robot utilisent des interfaces logicielles spécifiques pour contrôler et surveiller un contrôleur de robot spécifique, permettant à un ordinateur de contrôler directement un bras robotique.
Les pilotes de robot fournissent une alternative à la programmation hors ligne (où un programme est simulé, généré, puis, transféré au robot et exécuté). Avec les pilotes de robot, vous pouvez déplacer un robot pendant qu’il est simulé (programmation en ligne).
L’article suivant montre un exemple de projet de programmation en ligne utilisant des pilotes de robot :
https://robodk.com/blog/online-programming/
Toute simulation de robot programmée dans RoboDK peut être exécutée sur le robot à l’aide d’un pilote de robot. Le mouvement de robot dans le simulateur est alors synchronisé avec le vrai robot et il est possible de déboguer les programmes de robot en temps réel.
Note : Les pilotes de robot sont situés dans le dossier /RoboDK/api/Robot/ par défaut. Les pilotes de robot peuvent être des fichiers Python (format PY) ou des fichiers EXE.
La liste suivante définit certains des pilotes de robot pris en charge dans RoboDK :
Annin Robotics
AUBO
Automata
Borunte
Comau
Dobot
Doosan
Elephant Robotics
Elite Robots
Epson
FAIRINO
Han’s Robot / Huayan Robotics
Hanwha
IGUS
JAKA
Kawasaki
KEBA
Kinova
KUKA KRC
KUKA IIWA
Mecademic
Mitsubishi
Niryo
Productive Robotics
Siemens
Staubli
uFactory xArm
Wlkata
Remarque : toutes les fonctionnalités ne sont pas prises en charge par tous les pilotes de robot (par exemple, la surveillance en temps réel ou le sondage). Cela dépend fortement du contrôleur du robot et des fonctionnalités que celui-ci prend en charge à distance.
Note : Toutes les fonctionnalités ne sont pas prises en charge par tous les pilotes de robot (par exemple, la surveillance en temps réel ou le palpage). Cela dépend fortement du contrôleur de robot et des fonctionnalités que le contrôleur de robot prend en charge à distance. Note : Les utilisateurs finaux peuvent ajouter ou modifier des pilotes de robot existants, puis, lier les nouveaux pilotes dans le menu Robot Connection. Plus d’informations dans la section sur la personnalisation d’un pilote.
Cette section montre comment se connecter à un vrai bras robotique depuis RoboDK à l’aide des pilotes de robot et effectuer quelques opérations simples.
1.Faire un Clic droit sur un robot
2.Sélectionner 
3.Entrer l’adresse IP du robot
4.Sélectionner Connecter
Un message vert affichant Ready apparaîtra si la connexion a réussi, comme le montre l’image suivante.

Astuce : Sélectionner Get robot joints pour récupérer la position actuelle du robot à partir du robot et mettre à jour la position du robot virtuel dans RoboDK.
Astuce : Double-cliquer deux fois sur Déconnecter pour forcer le processus du pilote à s’arrêter. Le pilote peut ne plus répondre si le robot s’arrête inopinément (en raison d’une collision ou des limites d’axe par exemple), dans ce cas, le pilote peut être redémarré en double-cliquant sur Déconnecter, puis sur Connecter à nouveau.
Note : Les programmes créés à l’aide de l’API de RoboDK peuvent aussi être utilisés pour déplacer le robot en temps réel. Plus d’informations dans Utiliser les pilotes avec l’API.
Un programme de robot qui a été créé à l’aide de l’interface utilisateur graphique (GUI) peut être exécuté sur le robot en suivant les étapes suivantes :
1.Faire un clic droit sur un programme
2.Sélectionner l’option Exécuter sur le robot
3.Double-cliquer sur le programme pour le démarrer
Le programme devrait démarrer sur le vrai robot et le simulateur suivra les mouvements du robot. L’état de connexion affichera Working… en jaune lorsque le robot est occupé.

Il est possible de contrôler le mouvement d’un robot à partir de l’API RoboDK, par exemple, pour programmer un robot à partir d’un programme Python ou d’une application C#.
L’option Exécuter sur le robot est gérée automatiquement lorsqu’un programme Python est exécuté à partir de RoboDK. Suivre ces étapes pour exécuter un programme Python sur le robot :
1.Sélectionner « Exécuter sur le
2.Cliquez avec le bouton droit sur un programme 
Le programme devrait commencer à fonctionner sur le robot et l’état de connexion du robot sera mis à jour en conséquence.

Si le programme est exécuté en dehors de l’interface graphique de RoboDK (à des fins de débogage, ou si nous utilisons l’API RoboDK pour C# par exemple), nous pouvons définir le RunMode en utilisant RDK.setRunMode à RUNMODE_RUN_ROBOT. Cela forcera le programme à fonctionner sur le robot. Il est également possible d’établir la connexion à l’aide de robot.Connect().
Note : RoboDK définit automatiquement le RunType à RUNMODE_SIMULATE par défaut lorsque l’API RoboDK est démarrée, sauf si un programme Python est généré ou est défini sur Exécuter sur le robot à l’aide de l’interface graphique.
Le code suivant montre un bref exemple pour établir une connexion avec le robot directement à partir de l’API :
# Start the RoboDK API
RDK = Robolink()
robot = RDK.Item('',ITEM_TYPE_ROBOT)
# Connect to the robot using default connection parameters
success = robot.Connect()
status, status_msg = robot.ConnectedState()
if status != ROBOTCOM_READY:
# Stop if the connection did not succeed
raise Exception("Failed to connect: " + status_msg)
# Set to run the robot commands on the robot
RDK.setRunMode(RUNMODE_RUN_ROBOT)
# Note: This is set automatically if we use
# robot.Connect() through the API
# Move the robot:
robot.MoveJ([10,20,30,40,50,60])
Astuce : Sélectionner le fichier macro SampleOnlineProgramming.py dans le dossier C:/RoboDK/Library/Macros/ pour un exemple plus complet. De plus, d’autres exemples de programmation en ligne utilisant l’API Python et l’API C# sont disponibles dans la section API RoboDK.
prog = RDK.Item('MainProgram', ITEM_TYPE_PROGRAM)
prog.setRunType(PROGRAM_RUN_ON_ROBOT) # Set the run on robot option
# Set to PROGRAM_RUN_ON_SIMULATOR to run on the simulator only
prog.RunProgram()
while prog.Busy() == 1:
pause(0.1)
print("Program done")
Les pilotes de robot sont situés dans le dossier /RoboDK/api/Robot/ par défaut. RoboDK établit des liens vers un pilote spécifique dans les paramètres de connexion du robot :
1.Faire un clic droit sur un robot
2.Sélectionner 
3.Sélectionner Plus d’options…
4.Trouver ou entrer le chemin du pilote dans la section Chemin du pilote
Un pilote de robot est une application de console autonome. Les pilotes de robot peuvent être développés en utilisant n’importe quelle plate-forme de programmation, par exemple, ils peuvent être un module Python (format PY) ou n’importe quel programme exécutable construit sous n’importe quel environnement de développement.

Le pilote de robot permet de communiquer avec un robot via la ligne de commande. Les mêmes commandes qui peuvent être exécutées manuellement sont également utilisées par RoboDK pour piloter le robot à partir du PC. Chaque pilote de robot peut être exécuté en mode console pour le tester.
Un exemple de pilote Python (apimecademic.py) avec son code source afin de contrôler un robot Mecademic est disponible dans C:/RoboDK/bin/robot/.
Double-cliquer sur le fichier apimecademic.py pour lancer le module en mode console (Python doit être installé). Le pilote attendra les nouvelles commandes. Par exemple, nous pouvons taper la commande suivante pour se connecter au robot en fournissant une adresse IP et un port de communication :
CONNECT 192.168.100.1 10000
Si la connexion réussit, vous devriez voir un message SMS:Ready. Ensuite, taper la commande suivante pour récupérer les articulations actuelles du robot :
CJNT
Il est possible aussi de taper d’autres commandes comme MOVJ, MOVL ou SETTOOL pour déplacer le robot ou mettre à jour le CDO :
MOVJ 10 20 30 40 50 60

Certains robots permettent la surveillance de la position articulaire en temps réel. Dans ce cas, il est possible d’avoir un retour de position articulaire lorsque le robot se déplace en envoyant la commande JNTS_MOVING. Lorsque le pilote est exécuté à partir de RoboDK, le robot virtuel suivra le mouvement du robot réel en temps réel. Une nouvelle commande ne sera pas traitée tant que le message Ready n’aura pas été envoyé.
Note : Lorsque le pilote est exécuté à partir de RoboDK, tout message envoyé avec le préfixe SMS: sera affiché dans la barre d’état de connexion. Les messages spécifiques sont affichés avec une coloration spécifique comme Ready (vert), Working (jaune) ou Waiting (bleu). Tous les autres messages seront affichés en rouge.
L’interaction avec la console et la connexion au robot sont gérées par un seul module Python pour le pilote Mecademic. L’interaction avec la console doit être la même pour tous les robots, comme décrit dans cette section. Cependant, l’interaction avec chaque robot dépend du fabricant du robot ; dans ce cas, nous nous sommes référés au manuel de programmation Meca 500 pour envoyer les commandes appropriées. Ces commandes permettent de déplacer et de surveiller le robot Meca 500.
La configuration du pilote de robot peut ne pas être aussi simple que la génération de programmes hors ligne (Programmation hors ligne). Si la connexion ne fonctionne pas, les étapes suivantes donnent quelques astuces pour trouver la source des problèmes :
1.S’assurer que l’adresse IP du robot est correcte et accessible : sélectionner le bouton ping dans le menu de connexion du robot (ou envoyer un ping au robot à travers la ligne de commande) pour s’assurer que le robot et l’ordinateur sont dans le même réseau.
2.Définir une adresse IP statique pour l’ordinateur si le robot et l’ordinateur ne sont pas sur le même réseau.
3.Si usage de Windows : s’assurer que le pare-feu Windows est désactivé pour éviter de bloquer les connexions.
4.S’assurer que le port de communication est approprié et disponible du côté du robot.
5.S’assurer que les instructions appropriées sont suivies sur le contrôleur du robot, selon le modèle du contrôleur.
6.Double-cliquer sur Déconnecter dans la fenêtre de connexion du robot pour forcer le pilote à s’arrêter, puis sélectionner à nouveau Connecter pour essayer une nouvelle connexion.
Note : Vous pouvez avoir besoin des privilèges d’administrateur sur Windows pour effectuer certaines de ces opérations.
Un test de ping testera l’accessibilité d’un robot sur un réseau de protocole Internet (IP).
Suivre ces étapes pour effectuer un test de ping sur Windows :
1.Ouvrez une nouvelle fenêtre de console en appuyant sur (touche Windows
2.Entrer cmd et sélectionner OK
3.Entrer ping IP, où IP correspond à l’adresse IP de votre robot. Exemple : ping 192.168.125.2
Vous devriez voir une réponse similaire à l’image avec une perte de signal de 0%

S’il n’y a pas de communication, vérifier que l’IP du robot et du PC sont dans le même réseau local (LAN). Il peut être nécessaire d’éteindre le pare-feu Windows ou d’ajouter une règle pour permettre la communication.
Suivre ces étapes pour modifier l’adresse IP d’un ordinateur :
1.Sélectionner Windows Start➔Panneau de Configuration➔Réseau et Internet➔Centre réseau et partage➔Modifier les paramètres de la carte
2.Double-cliquer l’icône de la carte de connexion (connexion au réseau local)
3.Sélectionner Propriétés.
4.Sélectionner Internet Protocol Version 4 (TCP/IPv4), puis sélectionner Propriétés
5.Saisissez l'adresse IP de l'ordinateur en fonction de l'adresse IP du robot et du masque de sous-réseau.
6.Entrer l’adresse IP et le masque sous-réseau de l’ordinateur afin de se trouver sur le même réseau que celui du robot.
