Programmation hors-ligne

La Programmation hors-ligne (Offline Programming) consiste en programmer les robots sans la nécessité d'arrêter le robot, hors de l'environnement de production. La Programmation hors-ligne permet de réduire le temps de programmation robot avec un logiciel de simulation. Ceci permet d'évaluer plusieurs scénarios avant de construire la cellule automatisé et d'éviter les erreurs faits par méthodes d'apprentissage traditionnels.

La Programmation hors-ligne permet de maximiser le retour d'investissement de robots industriels.

Programmation hors-ligne avec RoboDK

La programmation hors-ligne n'a pas de limites avec le logiciel RoboDK. La simulation et programmation de robots industriels est très facile avec l'interface d'utilisateur graphique (GUI) RoboDK. RoboDK permet d'éviter les singularités et les limites des axes. Il n'est pas nécessaire d'avoir expérience en programmation. Visitez la section de Programmation hors-ligne de la documentation pour plus d'informations.

Avec la API de RoboDK il est aussi possible de programmer des robots avec Python. Python est un langage de programmation qui permet la intégration de façon rapide et facile. En comparaison avec d'autres langages de programmation, Python permet d'arriver au même résultat avec moins lignes de code.

Voir la section de la API de RoboDK pour plus d'information. La API de RoboDK est aussi disponible en C# et Matlab.

Exemple de Programmation hors-ligne:

from robolink import *    # API de RoboDK
from robodk import *      # Toolbox pour la robotique

# Démarrer la API de RoboDK:
RDK = Robolink()

# Prendre le robot (premier robot trouvé):
robot = RDK.Item('', ITEM_TYPE_ROBOT)

# Prendre la cible:
target = RDK.Item('Target 1')
target_pose = target.Pose()
xyz_ref = target_pose.Pos()

# Bouger le robot à la cible:
robot.MoveJ(target)

# Déssiner un hexagone autour de la cible:
for i in range(7):
    ang = i*2*pi/6 #ang = 0, 60, 120, ..., 360
    
    # Calculer la nouvelle position:
    x = xyz_ref[0] + R*cos(ang) # nouvelle coordonnée X
    y = xyz_ref[1] + R*sin(ang) # nouvelle coordonnée Y
    z = xyz_ref[2]              # nouvelle coordonnée Z   
    target_pos.setPos([x,y,z])
    
    # Bouger à la cible:
    robot.MoveL(target_pos)

# Appel de fonction à la fin du programme
robot.RunCode('Program_Done')

# Bouger le robot au point de départ:
robot.MoveL(target)

Une fois on a obtenu le résultat désiré dans la simulation il est très facile de générer le programme robot hors-ligne. Par exemple, le programme suivant sera généré pour un robot ABB.

Résultat de la programmation hors-ligne:

MODULE MOD_HexagonPath

PROC HexagonPath()
	!Programme généré avec RoboDK pour ABB IRB 1600ID-4/1.5. Date 29/11/2014 17:42:31
	ConfJ \On;
	ConfL \On;
	rdkTool.tframe:=[-4,0,371.3],[0.92387953,0,0.38268343,0];
	MoveJ [[1010.634,-114.491,662.29],[0,0,1,0],[-1,0,-1,0],rdkExtax], rdkSpeed, rdkZone, rdkTool, \WObj:=rdkWObj;
	MoveL [[810.634,-114.491,662.29],[0,0,1,0],[-1,0,-1,0],rdkExtax], rdkSpeed, rdkZone, rdkTool, \WObj:=rdkWObj;
	MoveL [[910.634,58.715,662.29],[0,0,1,0],[0,-1,0,0],rdkExtax], rdkSpeed, rdkZone, rdkTool, \WObj:=rdkWObj;
	MoveL [[1110.634,58.715,662.29],[0,0,1,0],[0,-1,0,0],rdkExtax], rdkSpeed, rdkZone, rdkTool, \WObj:=rdkWObj;
	MoveL [[1210.634,-114.491,662.29],[0,0,1,0],[-1,0,-1,0],rdkExtax], rdkSpeed, rdkZone, rdkTool, \WObj:=rdkWObj;
	MoveL [[1110.634,-287.696,662.29],[0,0,1,0],[-1,0,-1,0],rdkExtax], rdkSpeed, rdkZone, rdkTool, \WObj:=rdkWObj;
	MoveL [[910.634,-287.696,662.29],[0,0,1,0],[-1,0,-1,0],rdkExtax], rdkSpeed, rdkZone, rdkTool, \WObj:=rdkWObj;
	MoveL [[810.634,-114.491,662.29],[0,0,1,0],[-1,0,-1,0],rdkExtax], rdkSpeed, rdkZone, rdkTool, \WObj:=rdkWObj;
	Program_Done;
	MoveL [[1010.634,-114.491,662.29],[0,0,1,0],[-1,0,-1,0],rdkExtax], rdkSpeed, rdkZone, rdkTool, \WObj:=rdkWObj;
	ConfJ \On;
	ConfL \On;
ENDPROC
ENDMODULE

Post-Processeur robot

Un post-processeur robot permet de traduire le langage de programmation générique vers un contrôleur spécifique. La conversion d'une simulation à un contrôleur robot spécifique se fait avec un post-processeur. Les post processeurs RoboDK permettent la flexibilité de générer des programmes robot pour des besoins spécifiques.

La plupart des marques robot sont disponibles dans RoboDK. Visitez la section Post-Processeur de la documentation pour plus d'information.