Robot Workbench/fr: Difference between revisions

From FreeCAD Documentation
No edit summary
(Updating to match new version of source page)
Line 1: Line 1:
= Atelier de simulation de robot =

[[Image:KukaKR16FreeCAD.jpg|right|400px]]
[[Image:KukaKR16FreeCAD.jpg|right|400px]]


L'atelier de simulation de robot permet de simuler les [[6-Axis Robot/fr|robots à 6 axes]] industriels, comme par exemple [http://kuka.com/ Kuka].
The robot workbench is a tool to simulate industrial grade [[6-Axis Robot]]s, like e.g. [http://kuka.com/ Kuka].
You can do following tasks:
Vous pouvez accomplir les tâches suivantes :
* set up a simulation environment with a robot and work pieces
* mettre en place un environnement de simulation avec un robot et des pièces de travail
* create and fill up trajectories
* créer et remplir des trajectoires
* decompose features of an CAD part to a trajectory
* décomposer les fonctions d'une pièce CAO en une trajectoire
* simulate the robot movement and reachability
* simuler le mouvement et l'accessibilité d'un robot
* export the trajectory to a robot program file
* exporter la trajectoire vers un fichier programme de robot


An examples you can find here:
Vous pouvez trouver des exemples ici :
[http://www.freecad-project.de/svn/ExampleData/Examples/RobotSimulation/ fichiers d'exemple] ou essayez
[http://www.freecad-project.de/svn/ExampleData/Examples/RobotSimulation/ Example files] or try
le [[Robot tutorial/fr|tutoriel Robot]].
the [[Robot tutorial]].


== Tools ==
__TOC__
Here the principal commands you can use to create a robot set-up.


== Outils ==
Voici les principales commandes dont vous pouvez vous servir pour créer une configuration de robot.
=== Robots ===
=== Robots ===
The tools to create and manage the 6-Axis robots
Les outils pour créer et gérer les robots à 6 axes


* [[Image:Robot_CreateRobot.png|30px]] [[Robot_CreateRobot/fr|Créer un robot]]: Insère un nouveau robot dans la scène
* [[Image:Robot_CreateRobot.png|30px]] [[Robot_CreateRobot|Create a robot]]: Insert a new robot into the scene
* [[Image:Robot_Simulate.png|30px]] [[Robot_Simulate/fr|Simuler une trajectoire]]: Ouvre le dialogue de simulation afin de régler une simulation
* [[Image:Robot_Simulate.png|30px]] [[Robot_Simulate|Simulate a trajectory]]: Opens the simulation dialog and let you simulate
* [[Image:Robot_Export.png|30px]] [[Robot_Export/fr|Exporter une trajectoire]]: Exporte la trajectoire dans un fichier programme robot
* [[Image:Robot_Export.png|30px]] [[Robot_Export|Export a trajectory]]: Export a robot program file
* [[Image:Robot_SetHomePos.png|30px]] [[Robot_SetHomePos/fr|Définir la positon de départ]]: Définit la position de départ d'un robot
* [[Image:Robot_SetHomePos.png|30px]] [[Robot_SetHomePos|Set home positon]]: Set the home position of an robot
* [[Image:Robot_RestoreHomePos.png|30px]] [[Robot_RestoreHomePos/fr|Restaurer la positon de départ]]: Retourne le robot à sa positon de départ
* [[Image:Robot_RestoreHomePos.png|30px]] [[Robot_RestoreHomePos|Restore home positon]]: move the robot to its home position


=== Trajectoires ===
=== Trajectories ===
Tools to creat and manipulate trajectories. There are two kinds, the parametric and non parametric ones.
Les outils pour créer et manipuler les trajectoires. Il y en a deux sortes, paramétriques et non-paramétriques.
==== Non-paramétriques ====
* [[Image:Robot_CreateTrajectory.png|30px]] [[Robot_CreateTrajectory/fr|Créer une trajectoire]]: Créé une nouvelle trajectoire vide
* [[Image:Robot_SetDefaultOrientation.png|30px]] [[Robot_SetDefaultOrientation/fr|Définir l'orientation par défaut]]: Règle l'orientation par défaut des points de passage
* [[Image:Robot_SetDefaultValues.png|30px]] [[Robot_SetDefaultValues/fr|Définir les paramètres de vitesse par défaut]]: Règle les valeurs par défaut pour la création de points de passage
* [[Image:Robot_InsertWaypoint.png|30px]] [[Robot_InsertWaypoint/fr|Insérer dans la trajectoire]]: Insère un point de passage de la position actuelle du robot dans la trajectoire
* [[Image:Robot_InsertWaypointPre.png|30px]] [[Robot_InsertWaypointPre/fr|Insérer dans la trajectoire]]: Insère un point de passage de la position actuelle du pointeur de la souris dans la trajectoire


==== Paramétriques ====
==== non parametric ====
* [[Image:Robot_CreateTrajectory.png|30px]] [[Robot_CreateTrajectory|Create a trajectory]]: Insert a new robot into the scene
* [[Image:Robot_Edge2Trac.png|30px]] [[Robot_Edge2Trac/fr|Générer une trajectoire à partir d'un ensemble d'arêtes]]: Insère un nouvel objet qui dont les arêtes formeront une trajectoire
* [[Image:Robot_SetDefaultOrientation.png|30px]] [[Robot_SetDefaultOrientation|Set the default orientation]]: Set the orientation way-points gets created by default
* [[Image:Robot_TrajectoryDressUp.png|30px]] [[Robot_TrajectoryDressUp/fr|Habiller une trajectoire]]: Créé un habillage qui supplante certaines propriétés d'une trajectoire
* [[Image:Robot_TrajectoryCompound.png|30px]] [[Robot_TrajectoryCompound/fr|Grouper et connecter des trajectoires]]: Groupe et connecte un ensemble de trajectoires
* [[Image:Robot_SetDefaultValues.png|30px]] [[Robot_SetDefaultValues|Set the default speed parameter]]: set the defaults for way-point creation
* [[Image:Robot_InsertWaypoint.png|30px]] [[Robot_InsertWaypoint|Insert a waypoint]]: Insert a way-point from the current robot position into a trajectory
* [[Image:Robot_InsertWaypointPre.png|30px]] [[Robot_InsertWaypointPre|Insert a waypoint]]: Insert a way-point from the current mouse position into a trajectory


== Scripting ==
==== parametric ====
* [[Image:Robot_Edge2Trac.png|30px]] [[Robot_Edge2Trac|Create a trajectory out of edges]]: Insert a new object which decompose edges to a trajectory
* [[Image:Robot_TrajectoryDressUp.png|30px]] [[Robot_TrajectoryDressUp|Dress-up a trajectory]]: Let you override one or more properties of a trajectory
* [[Image:Robot_TrajectoryCompound.png|30px]] [[Robot_TrajectoryCompound|Trajectory compound]]: create a compound out of some single trajectories


== Scripting ==
Cette section est générée à partir de : http://free-cad.svn.sourceforge.net/viewvc/free-cad/trunk/src/Mod/Robot/RobotExample.py?view=markup
This section is generated out of: http://sourceforge.net/p/free-cad/code/ci/master/tree/src/Mod/Robot/RobotExample.py
Vous pouvez utiliser ce fichier directement si vous le désirez.
You can use this file directly if you want.


Example how to use the basic robot class Robot6Axis which represents a 6-axis
Voici un exemple montrant comment utiliser la classe de robot de base Robot6Axis qui représente un robot industriel à 6 axes. L'atelier Robot dépend de l'atelier [[Part Module/fr|Pièce]], mais pas des autres modules. Il fonctionne principalement avec les types de base Placement, Vecteur et Matrice. Nous n'avons donc besoin que de :
industrial robot. The Robot module is dependent on Part but not on other modules.
It works mostly with the basic types Placement, Vector and Matrix. So we need
only:
from Robot import *
from Robot import *
from Part import *
from Part import *
from FreeCAD import *
from FreeCAD import *
=== Éléments de base robot ===
=== Basic robot stuff ===
Créer le robot. Si vous ne spécifiez pas une autre cinématique, il devient un Puma 560
create the robot. If you do not specify another kinematic it becomes a Puma 560
rob = Robot6Axis()
rob = Robot6Axis()
print rob
print rob
Accès à l'axe et au Tcp. Les axes vont de 1-6 et sont exprimés en degrés :
accessing the axis and the Tcp. Axes go from 1-6 and are in degree:
Start = rob.Tcp
Start = rob.Tcp
print Start
print Start
print rob.Axis1
print rob.Axis1
Déplacer le premier axe du robot:
move the first axis of the robot:
rob.Axis1 = 5.0
rob.Axis1 = 5.0
Le Tcp a changé (cinématique avant)
the Tcp has changed (forward kinematic)
print rob.Tcp
print rob.Tcp
Déplacer le robot à sa position de départ (cinématique inverse):
move the robot back to start position (reverse kinematic):
rob.Tcp = Start
rob.Tcp = Start
print rob.Axis1
print rob.Axis1
De même avec l'axe 2:
the same with axis 2:
rob.Axis2 = 5.0
rob.Axis2 = 5.0
print rob.Tcp
print rob.Tcp
Line 77: Line 77:
print rob.Axis2
print rob.Axis2
Waypoints:
Points de passage :
w = Waypoint(Placement(),name="Pt",type="LIN")
w = Waypoint(Placement(),name="Pt",type="LIN")
print w.Name,w.Type,w.Pos,w.Cont,w.Velocity,w.Base,w.Tool
print w.Name,w.Type,w.Pos,w.Cont,w.Velocity,w.Base,w.Tool
generate more. The trajectory always finds automatically a unique name for the waypoints
En générer davantage. La trajectoire trouve toujours automatiquement un nom unique pour les points de passage
l = [w]
l = [w]
for i in range(5):
for i in range(5):
l.append(Waypoint(Placement(Vector(0,0,i*100),Vector(1,0,0),0),"LIN","Pt"))
l.append(Waypoint(Placement(Vector(0,0,i*100),Vector(1,0,0),0),"LIN","Pt"))
create a trajectory
Créer une trajectoire
t = Trajectory(l)
t = Trajectory(l)
print t
print t
Line 92: Line 92:
t.insertWaypoints(Waypoint(Placement(Vector(0,0,i*100+500),Vector(1,0,0),0),"LIN","Pt"))
t.insertWaypoints(Waypoint(Placement(Vector(0,0,i*100+500),Vector(1,0,0),0),"LIN","Pt"))
see a list of all waypoints:
Afficher une liste de tous les points de passage :
print t.Waypoints
print t.Waypoints
del rob,Start,t,l,w
del rob,Start,t,l,w
=== Travailler avec le document ===
=== working with the document ===


Working with the robot document objects:
Travailler avec les objets du document robot : d'abord créer un robot dans le document courant
first create a robot in the active document
if(App.activeDocument() == None):App.newDocument()
if(App.activeDocument() == None):App.newDocument()
App.activeDocument().addObject("Robot::RobotObject","Robot")
App.activeDocument().addObject("Robot::RobotObject","Robot")
Définir la représentation visuelle et la définition cinématique (voir [[6-Axis Robot/fr|robot à 6 axes]] et [[VRML Preparation for Robot Simulation/fr|Préparation VRML pour simulation de robot]] pour plus de détails)
Define the visual representation and the kinematic definition (see [[6-Axis Robot]] and [[VRML Preparation for Robot Simulation]] for details about that)
App.activeDocument().Robot.RobotVrmlFile = App.getResourceDir()+"Mod/Robot/Lib/Kuka/kr500_1.wrl"
App.activeDocument().Robot.RobotVrmlFile = App.getResourceDir()+"Mod/Robot/Lib/Kuka/kr500_1.wrl"
App.activeDocument().Robot.RobotKinematicFile = App.getResourceDir()+"Mod/Robot/Lib/Kuka/kr500_1.csv"
App.activeDocument().Robot.RobotKinematicFile = App.getResourceDir()+"Mod/Robot/Lib/Kuka/kr500_1.csv"
La positon de départ des axes (seulement celles qui diffèrent de 0)
start positon of the Axis (only that which differ from 0)
App.activeDocument().Robot.Axis2 = -90
App.activeDocument().Robot.Axis2 = -90
App.activeDocument().Robot.Axis3 = 90
App.activeDocument().Robot.Axis3 = 90
retrieve the Tcp position
Récupérer la position Tcp
pos = FreeCAD.getDocument("Unnamed").getObject("Robot").Tcp
pos = FreeCAD.getDocument("Unnamed").getObject("Robot").Tcp
Déplacer le robot
move the robot
pos.move(App.Vector(-10,0,0))
pos.move(App.Vector(-10,0,0))
FreeCAD.getDocument("Unnamed").getObject("Robot").Tcp = pos
FreeCAD.getDocument("Unnamed").getObject("Robot").Tcp = pos
Créer un objet de trajectoire vide dans le document courant
create an empty Trajectory object in the active document
App.activeDocument().addObject("Robot::TrajectoryObject","Trajectory")
App.activeDocument().addObject("Robot::TrajectoryObject","Trajectory")
get the Trajectory
Obtenir la trajectoire
t = App.activeDocument().Trajectory.Trajectory
t = App.activeDocument().Trajectory.Trajectory
Ajouter la position TCP actuelle du robot à la trajectoire
add the actual TCP position of the robot to the trajectory
StartTcp = App.activeDocument().Robot.Tcp
StartTcp = App.activeDocument().Robot.Tcp
t.insertWaypoints(StartTcp)
t.insertWaypoints(StartTcp)
Line 126: Line 127:
print App.activeDocument().Trajectory.Trajectory
print App.activeDocument().Trajectory.Trajectory
insert some more Waypoints and the start point at the end again:
Insérer quelques points de passage supplémentaires et le point de départ à nouveau à la fin :
for i in range(7):
for i in range(7):
t.insertWaypoints(Waypoint(Placement(Vector(0,1000,i*100+500),Vector(1,0,0),i),"LIN","Pt"))
t.insertWaypoints(Waypoint(Placement(Vector(0,1000,i*100+500),Vector(1,0,0),i),"LIN","Pt"))
Line 133: Line 134:
App.activeDocument().Trajectory.Trajectory = t
App.activeDocument().Trajectory.Trajectory = t
print App.activeDocument().Trajectory.Trajectory
print App.activeDocument().Trajectory.Trajectory

=== Simulation ===
=== Simulation ===
À compléter... ;-)
To be done..... ;-)
=== Exporter la trajectoire ===
=== Exporting the trajectory ===
The trajectory is exported by Python. That means for every control cabinet type there is a post-processor
La trajectoire est exportée par Python. Cela veut dire que pour chaque type de contrôle cabinet, il y a un module post-processeur Python. Voici en détail la description du post-processeur Kuka :
Python module. Here is in detail the Kuka post-processor described
from KukaExporter import ExportCompactSub
from KukaExporter import ExportCompactSub
ExportCompactSub(App.activeDocument().Robot,App.activeDocument().Trajectory,'D:/Temp/TestOut.src')
ExportCompactSub(App.activeDocument().Robot,App.activeDocument().Trajectory,'D:/Temp/TestOut.src')
Et c'est ainsi que ça se fait :
and that's kind of how it's done:
for w in App.activeDocument().Trajectory.Trajectory.Waypoints:
for w in App.activeDocument().Trajectory.Trajectory.Waypoints:
(A,B,C) = (w.Pos.Rotation.toEuler())
(A,B,C) = (w.Pos.Rotation.toEuler())
print ("LIN {X %.3f,Y %.3f,Z %.3f,A %.3f,B %.3f,C %.3f} ; %s"%(w.Pos.Base.x,w.Pos.Base.y,w.Pos.Base.z,A,B,C,w.Name))
print ("LIN {X %.3f,Y %.3f,Z %.3f,A %.3f,B %.3f,C %.3f} ; %s"%(w.Pos.Base.x,w.Pos.Base.y,w.Pos.Base.z,A,B,C,w.Name))


== Tutorials ==
{{docnav/fr|Raytracing_Module/fr|Sketcher_Workbench/fr}}
* [[6-Axis_Robot|6-Axis_Robot]]
* [[VRML Preparation for Robot Simulation|VRML Preparation for Robot Simulation]]
{{docnav|Arch Module|Macros}}
[[Category:User Documentation]]


[[Category:User Documentation/fr]]


<languages/>
{{languages/fr | {{en|Robot Workbench}} {{es|Robot Workbench/es}} {{it|Robot Workbench/it}} {{ru|Robot Workbench/ru}} {{se|Robot Workbench/se}} }}

Revision as of 17:10, 24 July 2014

The robot workbench is a tool to simulate industrial grade 6-Axis Robots, like e.g. Kuka. You can do following tasks:

  • set up a simulation environment with a robot and work pieces
  • create and fill up trajectories
  • decompose features of an CAD part to a trajectory
  • simulate the robot movement and reachability
  • export the trajectory to a robot program file

An examples you can find here: Example files or try the Robot tutorial.

Tools

Here the principal commands you can use to create a robot set-up.

Robots

The tools to create and manage the 6-Axis robots

Trajectories

Tools to creat and manipulate trajectories. There are two kinds, the parametric and non parametric ones.

non parametric

parametric

Scripting

This section is generated out of: http://sourceforge.net/p/free-cad/code/ci/master/tree/src/Mod/Robot/RobotExample.py You can use this file directly if you want.

Example how to use the basic robot class Robot6Axis which represents a 6-axis industrial robot. The Robot module is dependent on Part but not on other modules. It works mostly with the basic types Placement, Vector and Matrix. So we need only:

from Robot import *
from Part import *
from FreeCAD import *

Basic robot stuff

create the robot. If you do not specify another kinematic it becomes a Puma 560

rob = Robot6Axis()
print rob

accessing the axis and the Tcp. Axes go from 1-6 and are in degree:

Start = rob.Tcp
print Start
print rob.Axis1

move the first axis of the robot:

rob.Axis1 = 5.0

the Tcp has changed (forward kinematic)

print rob.Tcp

move the robot back to start position (reverse kinematic):

rob.Tcp = Start
print rob.Axis1

the same with axis 2:

rob.Axis2 = 5.0
print rob.Tcp
rob.Tcp = Start
print rob.Axis2

Waypoints:

w = Waypoint(Placement(),name="Pt",type="LIN")
print w.Name,w.Type,w.Pos,w.Cont,w.Velocity,w.Base,w.Tool

generate more. The trajectory always finds automatically a unique name for the waypoints

l = [w]
for i in range(5):
  l.append(Waypoint(Placement(Vector(0,0,i*100),Vector(1,0,0),0),"LIN","Pt"))

create a trajectory

t = Trajectory(l)
print t
for i in range(7):
  t.insertWaypoints(Waypoint(Placement(Vector(0,0,i*100+500),Vector(1,0,0),0),"LIN","Pt"))

see a list of all waypoints:

print t.Waypoints

del rob,Start,t,l,w

working with the document

Working with the robot document objects: first create a robot in the active document

if(App.activeDocument() == None):App.newDocument()

App.activeDocument().addObject("Robot::RobotObject","Robot")

Define the visual representation and the kinematic definition (see 6-Axis Robot and VRML Preparation for Robot Simulation for details about that)

App.activeDocument().Robot.RobotVrmlFile = App.getResourceDir()+"Mod/Robot/Lib/Kuka/kr500_1.wrl"
App.activeDocument().Robot.RobotKinematicFile = App.getResourceDir()+"Mod/Robot/Lib/Kuka/kr500_1.csv"

start positon of the Axis (only that which differ from 0)

App.activeDocument().Robot.Axis2 = -90
App.activeDocument().Robot.Axis3 = 90

retrieve the Tcp position

pos = FreeCAD.getDocument("Unnamed").getObject("Robot").Tcp

move the robot

pos.move(App.Vector(-10,0,0))
FreeCAD.getDocument("Unnamed").getObject("Robot").Tcp = pos

create an empty Trajectory object in the active document

App.activeDocument().addObject("Robot::TrajectoryObject","Trajectory")

get the Trajectory

t = App.activeDocument().Trajectory.Trajectory

add the actual TCP position of the robot to the trajectory

StartTcp = App.activeDocument().Robot.Tcp
t.insertWaypoints(StartTcp)
App.activeDocument().Trajectory.Trajectory = t
print App.activeDocument().Trajectory.Trajectory

insert some more Waypoints and the start point at the end again:

for i in range(7):
  t.insertWaypoints(Waypoint(Placement(Vector(0,1000,i*100+500),Vector(1,0,0),i),"LIN","Pt"))

t.insertWaypoints(StartTcp) # end point of the trajectory
App.activeDocument().Trajectory.Trajectory = t
print App.activeDocument().Trajectory.Trajectory

Simulation

To be done..... ;-)

Exporting the trajectory

The trajectory is exported by Python. That means for every control cabinet type there is a post-processor Python module. Here is in detail the Kuka post-processor described

from KukaExporter import ExportCompactSub

ExportCompactSub(App.activeDocument().Robot,App.activeDocument().Trajectory,'D:/Temp/TestOut.src')

and that's kind of how it's done:

for w in App.activeDocument().Trajectory.Trajectory.Waypoints:
	(A,B,C) = (w.Pos.Rotation.toEuler())
	print ("LIN {X %.3f,Y %.3f,Z %.3f,A %.3f,B %.3f,C %.3f} ; %s"%(w.Pos.Base.x,w.Pos.Base.y,w.Pos.Base.z,A,B,C,w.Name))

Tutorials

Arch Module
Macros