From free-cad

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.

Contents 1 Tools 1.1 Robots 1.2 Trajectories 1.2.1 non parametric 1.2.2 parametric 2 Scripting 2.1 Basic robot stuff 2.2 working with the document 2.3 Simulation 2.4 Exporting the trajectory

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

• Create a robot: Insert a new robot into the scene
• Simulate a trajectory: Opens the simulation dialog and let you simulate
• Export a trajectory: Export a robot program file

• Set home positon: Set the home position of an robot
• Restore home positon: move the robot to its home position

Trajectories

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

non parametric

• Create a trajectory: Insert a new robot into the scene
• Set the default orientation: Set the orientation way-points gets created by default
• Set the default speed parameter: set the defaults for way-point creation
• Insert a waypoint: Insert a way-point from the current robot position into a trajectory
• Insert a waypoint: Insert a way-point from the current mouse position into a trajectory

parametric

• Create a trajectory out of edges: Insert a new object which decompose edges to a trajectory
• Dress-up a trajectory: Let you override one or more properties of a trajectory
• Trajectory compound: create a compound out of some single trajectories

Scripting

This section is generated out of: http://free-cad.svn.sourceforge.net/viewvc/free-cad/trunk/src/Mod/Robot/RobotExample.py?view=markup 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))