ITIS ZUCCANTE — 4IB · ROBOTICA

RoboDK Python API Reference

Reference compatta delle classi principali della Python API di RoboDK: Robolink, Item e il modulo robomath. Metodi, parametri tipati, valori di ritorno ed esempi pronti.

Introduzione e setup

RoboDK è un simulatore di robot industriali. La sua Python API permette di controllare la simulazione (o il robot reale) tramite un canale di comunicazione con la stazione RoboDK in esecuzione. La libreria si chiama robodk e contiene tre moduli centrali.

Modulo	Cosa contiene	Import
`robodk.robolink`	Classe `Robolink` (connessione alla stazione) e classe `Item` (qualsiasi oggetto della stazione: robot, target, frame, programma, tool).	`from robodk.robolink import *`
`robodk.robomath`	Matematica per la robotica: matrici di trasformazione 4×4 (`Mat`), conversioni euleriane, traslazioni e rotazioni.	`from robodk.robomath import *`
`robodk.robodialogs`	Finestre di dialogo per input utente, scelta file, messaggi.	`from robodk.robodialogs import *`

Installazione

terminale

# RoboDK installa automaticamente la libreria, ma puoi forzare con pip
pip install robodk

# Verifica veloce
python -c "from robodk.robolink import Robolink; print(Robolink().Version())"

Primo script: connessione

hello_robodk.py

from robodk.robolink import *      # Robolink, Item, costanti ITEM_TYPE_*
from robodk.robomath import *      # Mat, transl, rotz, ...

RDK = Robolink()                     # apre il canale verso RoboDK
robot = RDK.Item('', ITEM_TYPE_ROBOT) # primo robot disponibile

if not robot.Valid():
    raise Exception('Nessun robot in stazione')

print('Robot trovato:', robot.Name())
print('Posizione corrente:', robot.Pose())

NOTA Tutti gli Item sono handle a oggetti della stazione: se cancelli un oggetto in RoboDK l'handle diventa invalido. Controlla sempre con item.Valid() prima di usarlo.

Costanti più usate

Costante	Significato
`ITEM_TYPE_ROBOT`	Robot industriale
`ITEM_TYPE_FRAME`	Sistema di riferimento
`ITEM_TYPE_TARGET`	Punto bersaglio (cartesiano o giunti)
`ITEM_TYPE_PROGRAM`	Programma robot
`ITEM_TYPE_TOOL`	Tool / end-effector
`ITEM_TYPE_OBJECT`	Oggetto / mesh / pezzo
`RUNMODE_SIMULATE`	Esecuzione in simulazione
`RUNMODE_RUN_ROBOT`	Esecuzione sul robot reale

Classe `Robolink`

Rappresenta la connessione alla stazione RoboDK in esecuzione. Da un'istanza di Robolink recuperi gli Item della stazione, carichi file, cambi modalità di esecuzione e leggi lo stato della simulazione.

Item()recupera un oggetto ItemList()lista oggetti AddFile()importa file AddFrame()nuovo frame AddTarget()nuovo target setRunMode()sim / reale Render()aggiorna viewport CloseRoboDK()chiudi RoboDK

classRobolink(robodk_ip='localhost', port=None, args='', robodk_path=None)

Apre la connessione TCP con la stazione RoboDK. Se RoboDK non è in esecuzione, lo avvia. Gli argomenti più comuni: robodk_ip per connettersi a una stazione remota, args='-NOSPLASH /NOUI' per modalità headless.

Item(name: str = '', itemtype: int = None) → Item

Restituisce l'Item con il nome indicato. Se name='' restituisce il primo elemento del tipo richiesto. Verifica sempre .Valid() sul risultato.

name str — nome esatto come appare nell'albero della stazione
itemtype int — una delle costanti ITEM_TYPE_*

ItemList(filter: int = None, list_names: bool = False) → list[Item] | list[str]

Elenca tutti gli oggetti della stazione, eventualmente filtrati per tipo. Con list_names=True torna i nomi invece degli handle.

AddFile(filename: str, parent: Item = 0) → Item

Importa un file nella stazione: .robot, .tool, .stl, .step, .rdk. Ritorna l'handle all'oggetto creato.

AddFrame(name: str, parent: Item = 0) → Item

Crea un nuovo sistema di riferimento. Il parent può essere la stazione (0) o un altro frame.

AddTarget(name: str, itemparent: Item = 0, itemrobot: Item = 0) → Item

Crea un target nella stazione, agganciato al frame itemparent e collegato al robot indicato.

setRunMode(run_mode: int = RUNMODE_SIMULATE) → None

Cambia la modalità di esecuzione. Con RUNMODE_RUN_ROBOT i comandi vanno al robot reale via driver; con RUNMODE_MAKE_ROBOTPROG si genera codice nativo del controllore senza eseguire.

Render(always_render: bool = False) → None

Forza l'aggiornamento del viewport 3D. Utile dentro loop dove Render automatico è disattivato per velocità.

CloseRoboDK() → None

Termina il processo RoboDK collegato.

Esempio: iterare i robot della stazione

list_robots.py

from robodk.robolink import *

RDK = Robolink()
for r in RDK.ItemList(ITEM_TYPE_ROBOT):
    print(r.Name(), '->', r.Joints().tolist())

Classe `Item`

Un Item è un handle a un oggetto della stazione (robot, frame, target, tool, programma, mesh). I metodi disponibili variano in base al Type() dell'oggetto: di seguito i più usati per i robot.

Valid()handle vivo? Name()nome Type()tipo oggetto Pose()TCP corrente setPose()imposta pose Joints()angoli giunti setJoints()muovi a giunti MoveJ()movimento giunti MoveL()movimento lineare setSpeed()velocità setPoseFrame()frame attivo setPoseTool()tool attivo

classItem

Handle a un oggetto della stazione RoboDK.

Valid() → bool

Ritorna True se l'handle punta a un oggetto ancora esistente.

Name() → str getter

Nome dell'oggetto. Esiste anche setName(name) per rinominarlo.

Type() → int

Una delle costanti ITEM_TYPE_*.

Pose() → Mat solo robot/target

Pose del TCP rispetto al frame di riferimento attivo, come matrice omogenea 4×4 (Mat).

setPose(pose: Mat) → None

Per un target imposta la pose. Per un frame/tool ne ridefinisce la trasformazione rispetto al parent.

Joints() → Mat

Angoli (gradi) dei giunti del robot come vettore Mat di forma N×1.

setJoints(joints: list | Mat) → None

Posiziona istantaneamente il robot nella configurazione indicata (no movimento simulato).

MoveJ(target: Item | Mat | list, blocking: bool = True) → None

Movimento giunti (interpolazione nello spazio dei giunti). Accetta un Item target, una matrice di pose oppure una lista di angoli.

target — destinazione
blocking bool — se True attende il completamento

MoveL(target: Item | Mat | list, blocking: bool = True) → None

Movimento lineare nello spazio cartesiano. Solleva eccezione se la traiettoria attraversa una singolarità.

setSpeed(speed_linear: float = -1, speed_joints: float = -1, accel_linear: float = -1, accel_joints: float = -1) → None

Imposta velocità e accelerazioni del robot. -1 lascia il valore corrente. Unità: mm/s e deg/s.

setPoseFrame(frame: Item | Mat) → None

Imposta il frame di riferimento attivo per i movimenti successivi del robot.

setPoseTool(tool: Item | Mat) → None

Imposta il tool (TCP) attivo per i movimenti successivi.

ATTENZIONE MoveJ/MoveL verso una pose cartesiana usano il frame e il tool attivi al momento della chiamata: imposta sempre setPoseFrame e setPoseTool prima del primo movimento.

Modulo `robomath`

Matematica delle trasformazioni rigide. Il tipo centrale è Mat: una matrice (in genere 4×4) che rappresenta una posa cartesiana, supporta moltiplicazione, inversa, conversioni euleriane.

classMat(rows=4, cols=4)

Matrice numerica con interfaccia tipo NumPy semplificata.

inv() → Mat

Inversa della matrice (per pose 4×4 usa la formula chiusa).

Pos() → list[float]

Vettore traslazione [x, y, z] in mm estratto dalla colonna 4.

setPos(xyz: list) → Mat

Modifica la sola componente di traslazione.

tolist() → list

Converte in lista Python (o lista di liste se 2D).

Funzioni di costruzione

Funzione	Significato
`transl(x, y, z)`	Matrice di pura traslazione (mm).
`rotx(a)` / `roty(a)` / `rotz(a)`	Rotazione attorno all'asse, angolo in radianti.
`eye(n)`	Matrice identità n×n (default 4).
`pose_2_xyzrpw(pose)`	Da `Mat` a `[x, y, z, r, p, w]` (roll-pitch-yaw, gradi).
`xyzrpw_2_pose([x,y,z,r,p,w])`	Operazione inversa.
`pose_2_KUKA(pose)`	Pose in convenzione KUKA `X Y Z A B C`.
`quaternion_2_pose(q)`	Da quaternione a `Mat`.

Esempio: costruire una pose composta

compose_pose.py

from robodk.robomath import *
from math import pi

# Pose = traslazione (300, 0, 200) poi rotazione 90° attorno a Z
pose = transl(300, 0, 200) * rotz(pi/2)

print(pose_2_xyzrpw(pose))   # [300.0, 0.0, 200.0, 0.0, 0.0, 90.0]
print(pose.inv().Pos())     # traslazione della pose inversa

UNITÀ In RoboDK le distanze sono in millimetri, gli angoli per le funzioni di robomath in radianti, mentre pose_2_xyzrpw e le funzioni dei robot usano i gradi. Non mescolare.

RoboDK Python API Reference

Introduzione e setup

Installazione

Primo script: connessione

Costanti più usate

Classe `Robolink`

Esempio: iterare i robot della stazione

Classe `Item`

Modulo `robomath`

Funzioni di costruzione

Esempio: costruire una pose composta

Esempi pratici

1. Pick & place minimo

2. Traiettoria su griglia

3. Lettura pose corrente e log

Mini quiz

Introduzione e setup

Installazione

Primo script: connessione

Costanti più usate

Classe Robolink

Esempio: iterare i robot della stazione

Classe Item

Modulo robomath

Funzioni di costruzione

Esempio: costruire una pose composta

Esempi pratici

1. Pick & place minimo

2. Traiettoria su griglia

3. Lettura pose corrente e log

Mini quiz

Classe `Robolink`

Classe `Item`

Modulo `robomath`