Robot Workbench/it

Il modulo robot è uno strumento per simulare un Robot a 6 assi di tipo industriale, come per esempio i robot Kuka. È possibile eseguire le seguenti operazioni:

Impostare un ambiente di simulazione con un robot e dei pezzi in lavorazione
Creare e compilare traiettorie
Scomporre le componenti di una Parte CAD in una traiettoria
Simulare il movimento del robot e il raggio d'azione
Esportare la traiettoria in un file di programma robot

Alcuni esempi sono disponibili in Example files oppure nel tutorial Robot.

Strumenti

Ecco i principali comandi utilizzabili per creare il set-up di un robot.

Robot

Gli strumenti per creare e gestire i robot a 6 assi

Inserisci un robot: Inserisce un nuovo robot nella scena
Simula una traiettoria: Apre la finestra di simulazione e permette di simulare un percorso
Esporta una traiettoria: Esporta un file di programmazione robotica
Imposta la posizione iniziale: Imposta la posizione iniziale di un robot
Ripristina la posizione iniziale: Sposta il robot nella posizione di partenza

Traiettorie

Strumenti per creare e modificare i percorsi. Ci sono due tipi di strumenti, quelli parametrici e quelli non parametrici.

Traiettorie non parametriche

Crea traiettoria: Inserisce un nuovo oggetto traiettoria vuoto nella scena
Imposta l'orientamento predefinito: Imposta il modo in cui vengono creati i punti di orientamento di default
Imposta i valori predefiniti: Imposta i valori predefiniti per la velocità
Inserisci in traiettoria: Inserisce il punto della posizione corrente del robot in una traiettoria
Inserisci in traiettoria: Inserisce il punto della posizione corrente del mouse in una traiettoria

Traiettorie parametriche

Da bordo a traiettoria: Genera un percorso da un insieme di spigoli
Vesti una traiettoria: Permette di modificare una o più proprietà di un percorso
Raggruppa le traiettorie: Raggruppa alcune traiettorie in un unico percorso

Script

Questa sezione è ricavata da: https://github.com/FreeCAD/FreeCAD_sf_master/blob/master/src/Mod/Robot/RobotExample.py Volendo, è possibile utilizzare la fonte originale.

Esempio di come utilizzare la classe di robot di base Robot6Axis che rappresenta un robot industriale a 6-assi. Il modulo Robot dipende solo dal modulo Parte e non da altri moduli di FreeCAD. Funziona soprattutto con basi di dati di tipo Placement, Vector e Matrix. Quindi serve solo:

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

Elementi base di Robot

Creare il robot. Se non viene specificata una cinematica diversa, viene utilizzato un robot 560 Puma

rob = Robot6Axis()
print rob

accedere all'asse e al TCP (Punto centro di lavorazione). Gli assi vanno da 1 a 6 e sono in grado di:

Start = rob.Tcp
print Start
print rob.Axis1

spostare il primo asse del robot:

rob.Axis1 = 5.0

il Tcp è cambiato (cinematica in avanzamento)

print rob.Tcp

muovere il robot nella posizione di partenza (cinematica in ritorno):

rob.Tcp = Start
print rob.Axis1

stessa cosa per l'asse 2:

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

Punti del percorso:

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

generarne altri. La traiettoria trova sempre automaticamente un nome univoco per i punti del percorso

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

creare un percorso

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"))

visualizzare un elenco di tutti i punti del percorso:

print t.Waypoints
 
del rob,Start,t,l,w

Lavorare con gli oggetti del documento

Lavorare con oggetti documento del robot: innanzitutto creare un robot nel documento attivo

if(App.activeDocument() == None):App.newDocument()
 
App.activeDocument().addObject("Robot::RobotObject","Robot")

Definire la rappresentazione visiva e definire la cinematica, per dettagli su questo aspetto vedere Robot a 6 assi e Preparazione del file VRML per la simulazione del robot

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"

posizione iniziale dell'asse (solo quelli che differiscono da 0)

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

richiamare la posizione Tcp

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

muovere il robot

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

creare un oggetto Traiettoria vuota nel documento attivo

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

ottenere la traiettoria

t = App.activeDocument().Trajectory.Trajectory

aggiungere la posizione TCP attuale del robot alla traiettoria

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

inserire altri punti del percorso e, alla fine, nuovamente il punto iniziale:

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

Simulazione

Da fare.....

Esportare la traiettoria

La traiettoria viene esportata da Python. Ciò significa che per ogni sezione di controllo c'è un modulo post-processore Python.

Quì è descritto in dettaglio il post-processore Kuka

from KukaExporter import ExportCompactSub

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

e questo è il modo in cui si esegue:

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))