Robot API example: Difference between revisions

From FreeCAD Documentation
(Created page with "<languages/> <translate> == Introduction == This example is based on the [https://github.com/FreeCAD/FreeCAD_sf_master/blob/master/src/Mod/Robot/RobotExample.py RobotExample....")
 
(Marked this version for translation)
Line 2: Line 2:
<translate>
<translate>


== Introduction ==
== Introduction == <!--T:1-->
This example is based on the [https://github.com/FreeCAD/FreeCAD_sf_master/blob/master/src/Mod/Robot/RobotExample.py RobotExample.py] example.
This example is based on the [https://github.com/FreeCAD/FreeCAD_sf_master/blob/master/src/Mod/Robot/RobotExample.py RobotExample.py] example.


<!--T:2-->
You may use this file directly if you want.
You may use this file directly if you want.


<!--T:3-->
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.
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:
It works mostly with the basic types Placement, Vector and Matrix. So we need only:
Line 17: Line 19:
<translate>
<translate>


=== Basic robot stuff ===
=== Basic robot stuff === <!--T:4-->
create the robot. If you do not specify another kinematic it becomes a Puma 560
create the robot. If you do not specify another kinematic it becomes a Puma 560
</translate>
</translate>
Line 26: Line 28:
<translate>
<translate>


<!--T:5-->
accessing the axis and the Tcp. Axes go from 1-6 and are in degree:
accessing the axis and the Tcp. Axes go from 1-6 and are in degree:
</translate>
</translate>
Line 35: Line 38:
<translate>
<translate>


<!--T:6-->
move the first axis of the robot:
move the first axis of the robot:
</translate>
</translate>
Line 42: Line 46:
<translate>
<translate>


<!--T:7-->
the Tcp has changed (forward kinematic)
the Tcp has changed (forward kinematic)
</translate>
</translate>
Line 49: Line 54:
<translate>
<translate>


<!--T:8-->
move the robot back to start position (reverse kinematic):
move the robot back to start position (reverse kinematic):
</translate>
</translate>
Line 57: Line 63:
<translate>
<translate>


<!--T:9-->
the same with axis 2:
the same with axis 2:
</translate>
</translate>
Line 67: Line 74:
<translate>
<translate>


<!--T:10-->
Waypoints:
Waypoints:
</translate>
</translate>
Line 75: Line 83:
<translate>
<translate>


<!--T:11-->
generate more. The trajectory always finds automatically a unique name for the waypoints
generate more. The trajectory always finds automatically a unique name for the waypoints
</translate>
</translate>
Line 84: Line 93:
<translate>
<translate>


<!--T:12-->
create a trajectory
create a trajectory
</translate>
</translate>
Line 94: Line 104:
<translate>
<translate>


<!--T:13-->
see a list of all waypoints:
see a list of all waypoints:
</translate>
</translate>
Line 103: Line 114:
<translate>
<translate>


=== Working with the document objects ===
=== Working with the document objects === <!--T:14-->


<!--T:15-->
Working with the robot document objects:
Working with the robot document objects:
first create a robot in the active document
first create a robot in the active document
Line 115: Line 127:
<translate>
<translate>


<!--T:16-->
Define the visual representation and the kinematic definition (see [[Robot_6-Axis|Robot 6-Axis]] and [[VRML Preparation for Robot Simulation|VRML Preparation for Robot Simulation]] for details about that)
Define the visual representation and the kinematic definition (see [[Robot_6-Axis|Robot 6-Axis]] and [[VRML Preparation for Robot Simulation|VRML Preparation for Robot Simulation]] for details about that)
</translate>
</translate>
Line 123: Line 136:
<translate>
<translate>


<!--T:17-->
start positon of the Axis (only that which differ from 0)
start positon of the Axis (only that which differ from 0)
</translate>
</translate>
Line 131: Line 145:
<translate>
<translate>


<!--T:18-->
retrieve the Tcp position
retrieve the Tcp position
</translate>
</translate>
Line 138: Line 153:
<translate>
<translate>


<!--T:19-->
move the robot
move the robot
</translate>
</translate>
Line 146: Line 162:
<translate>
<translate>


<!--T:20-->
create an empty Trajectory object in the active document
create an empty Trajectory object in the active document
</translate>
</translate>
Line 153: Line 170:
<translate>
<translate>


<!--T:21-->
get the Trajectory
get the Trajectory
</translate>
</translate>
Line 160: Line 178:
<translate>
<translate>


<!--T:22-->
add the actual TCP position of the robot to the trajectory
add the actual TCP position of the robot to the trajectory
</translate>
</translate>
Line 170: Line 189:
<translate>
<translate>


<!--T:23-->
insert some more Waypoints and the start point at the end again:
insert some more Waypoints and the start point at the end again:
</translate>
</translate>
Line 182: Line 202:
<translate>
<translate>


=== Simulation ===
=== Simulation === <!--T:24-->
To be done.....
To be done.....
Line 196: Line 216:
<translate>
<translate>


<!--T:25-->
and that's kind of how it's done:
and that's kind of how it's done:
</translate>
</translate>
Line 206: Line 227:
<translate>
<translate>


<!--T:26-->
{{Robot Tools navi}}
{{Robot Tools navi}}
{{Userdocnavi}}
{{Userdocnavi}}

Revision as of 08:41, 9 April 2019

Introduction

This example is based on the RobotExample.py example.

You may 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 objects

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 Robot 6-Axis 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))