Post Processori
I Post Processori sono un passaggio chiave nella Programmazione Offline perché permettono flessibilità nel supporto di ogni controllore robot. Un Post Processore robot definisce come i programmi robot sono generati per uno specifico controllore robot.
La conversione dalla simulazione RoboDK in uno specifico programma robot è fatta da un Post Processore, Ogni robot ha un post processore assegnatoli di default. Il post processore è utilizzato quando il programma è generato offline, come mostrato nella sezione Genera Programma (tasto destro sul programma, poi, seleziona Genera Programma Robot)
RoboDK fornisce molti post processori che supportanto più controller robot, elencati nella sezione Post Processori Disponibili. In alternativa, è possibile creare un post processore personalizzato o modificare un post processore esistente. Tutti i post processori sono nella cartella:
C:/RoboDK/Posts/
Un post processore è un file PY (ogni post processore è definito da uno script Python). È possibile aggiungere manualmente, modificare, o cancellare i file nella cartella Posts di RoboDK. Se ti viene fornito un post processore RoboDK (fiel PY) deve essere posizionato nella cartella Post in modo da poter essere selezionato da RoboDK.
Questa sezione mostra come selezionare, modificare o creare un post processore ed utilizzarlo con il tuo robot in RoboDK. Una breve introduzione è disponibile nel seguente video: https://www.robodk.com/help#PostProcessor
Seleziona un Post Processore
Per selezionare uno specifico post processore per un robot:
1.Tasto destro sul robot o programma
2.Seleziona Seleziona Post Processore
3.Scegli il post processore dalla lista
4.Seleziona OK
La modifica è ora applicata e il programma può essere generato nuovamente per vedere il risultato.
In alternativa, è anche possibile selezionare post processori seguendo i passaggi:
1.Apri il pannello robot
2.Seleziona Parametri
3.Seleziona il tuo post processore nella casella produttore Robot, come mostrato nella seguente immagine.
Editor del Post Processore
Puoi modificare facilmente le impostazioni del post processore utilizzando un'interfaccia grafica. L'editor del post processore permette di modificare le variabili definite nel post processore che sono specifiche per il tuo controller robot.
L'editor del post processore è un plugin che aiuta a personalizzare i tuoi post processori. Puoi scaricare e installare facilmente il plugin dalla seguente pagina: https://robodk.com/addin/com.robodk.plugin.postprocessoreditor.
Segui questi passaggi per aprire l'editor del post processore:
4.Seleziona Programma-Editor del Post Processore.
5.Seleziona il post processore che desideri personalizzare.
6.Seleziona OK. Si aprirà una nuova finestra e vedrai le variabili che puoi modificare.
7.Seleziona Salva Post Processore come…
8.Inserisci il nome con cui salvarlo.
Per esempio, se selezioni il post processore Fanuc R30iA vedrai la finestra mostrata nell'immagine precedente.
Modificare un Post Processore
È possibile modificare post processori esistenti o crearne di nuovi. Post processori devono essere posizionati nella cartella C:/RoboDK/Posts/ in modo che possano essere selezionati in RoboDK. La sezione precedente descrive come collegare un robot specifico ad un post processore.
Ogni post processore è un file PY. È possibile rinominare il file o copiare file da/in C:/RoboDK/Posts/ per condividere differenti post processori. Per cancellare un post processore esistente, cancella semplicemente il file PY corrispondente nella cartella Post.
Post processori posson esser modificati utilizzando un editor di testo o un editor Python (Python IDLE). Utilizzando un editor Python è possibile fare il debug velocemente e verificare un programma esempio alla fine del file.
Python deve essere installato per testare ed utilizzare i post processori correttamente (python è installato di default con RoboDK).
Per modificare un post processore esistente:
1.Seleziona Programma➔Aggiungi/Modifica Post Processori
2.Seleziona un post processore esistente
3.Seleziona OK. Un editor di testo aprirà il programma.
4.Seleziona Inizia➔Inizia modulo (F5) per vedere l'anteprima del risultato. Effettuare modifiche se necessario.
In alternativa, è possibile modificare un post processore manualmente:
1.Vai nella cartella del post processore: C:/RoboDK/Posts/
2.Apri un file PY con l'IDLE Python (tasto destro ➔ Modifica con IDLE) o un altro editor di testo
3.Effettuare le modifiche desiderate
4.Aprire il file per testare il risultato: Selezionare Inizia➔Inizia modulo (F5 di default) dal IDLE Python.
In alternativa, è possibile modificare il file utilizzando un editor di testo e aprirlo con Python facendo doppio click.
Esempio Modifiche
Questa sezione mostra come fare piccole modifiche ad un post processore esistente.
Ad esempio, le prossime 3 modifiche saranno fatte ad un post processor esistente KUKA KRC4:
●Sovrascrivere la massima velocità a 500 mm/s. Anche se il robot è programmato per muoversi più velocemente la velocità sarà limitata a 500 mm/s nel post processore.
●Genera ogni programma come un file separato e forzare i programmi ad avere al massimo 3000 linee di codice per programma. Programmi grandi saranno divisi in programmi più piccoli e chiamati in sequenza.
La sezione precedente mostra come aprire post processori esistenti:
1.Seleziona Programma➔Aggiungi/Modifica Post Processore
2.Seleziona KUKA_KRC4
3.Seleziona OK. Il post processore sarà mostrato nell'editor IDLE Python.
Le prossime sezioni mostrano come fare modifiche nell'editor testo.
Generare un programma per file
Fai le seguenti modifiche per evitare di aggiungere più di un programma per file e generare programmi con più di 3000 linee di codice:
1.Imposta la variabile MAX_LINES_X_PROG a 3000
2.Imposta la variabile INCLUDE_SUB_PROGRAMS in False
Forzare limite velocità
Segui questi passaggi per impostare un limite velocità a 500 mm/s ed evitare di impostare velocità maggiori usando RoboDK:
1.Localizzare la funzione setSpeed (def setSpeed)
2.Aggiungi la seguente linea prima di generare l'output $VEL.CP che modifica la velocità in m/s:
speed_mms = min(speed_mms, 500)
Filtro personalizzato per i sistemi di riferimento
Questa sezione mostra come personalizzare l'impostazione del sistema di riferimento di un post processore esistente. Per esempio, impostando un sistema di riferimento personalizzato per un robot KUKA.
Puoi utilizzare post processori compilati e reimplementare facilmente solo le funzioni necessarie (per esempio, setFrame, setTool o setSpeed).
In questo esempio, supponiamo di voler personalizzare come viene definita la base per un controller KUKA. Per esempio, se desideri generare la seguente riga quando imposti il sistema di riferimento:
BASE_DATA[8] = {FRAME: X:2000, Y:0, Z:0, A:0, B:0, C:0}
BAS (#BASE,8)
È sufficiente creare un nuovo file chiamato KUKA_Custom_Post.py nella cartella C:/RoboDK/Posts/ con le seguenti righe, che utilizzano il post processore predefinito KUKA_KRC2 e sovrascrivono l'impostazione del sistema di riferimento (funzione setFrame):
from KUKA_KRC2 import RobotPost as MainPost
class RobotPost(MainPost):
def setFrame(self, pose, frame_id, frame_name):
"""Change the robot reference frame"""
self.addline('; BASE_DATA[8] = {FRAME: %s}' % (self.pose_2_str(pose)))
self.addline('BAS (#BASE,8)')
Tuttavia, potremmo aggiungere filtri personalizzati basati su determinati criteri per scegliere tra il comportamento predefinito e un'implementazione personalizzata. Il file del post processore potrebbe quindi essere modificato come segue:
from KUKA_KRC2 import RobotPost as MainPost
class RobotPost(MainPost):
def setFrame(self, pose, frame_id, frame_name):
"""Change the robot reference frame"""
if frame_name == "Frame 4": # Enter any condition here
# Trigger the call to the default method (same as not overriding the function)
super(MainPost, self).setFrame(pose, frame_id, frame_name)
return
# Implement a custom setFrame
self.addline('; ---- Setting reference: %s ----' % frame_name)
self.addline('; BASE_DATA[8] = {FRAME: %s}' % (self.pose_2_str(pose)))
self.addline('BAS (#BASE,8)')
self.addline('; --------------------------')
Quando generi programmi per controller KUKA KRC, esistono molti modi per impostare il tuo sistema di coordinate o sistema di riferimento. La seguente definizione di setFrame mostra un'implementazione alternativa con diverse opzioni:
def setFrame(self, pose, frame_id, frame_name):
"""Change the robot reference frame"""
self.addline('; ---- Setting reference: %s ----' % frame_name)
# option 1: Build the kinematics based on the MACHINE_DEF array and the provided offset
#self.addline('$BASE = EK (MACHINE_DEF[2].ROOT, MACHINE_DEF[2].MECH_TYPE, { %s })' % self.pose_2_str(pose))
# option 2: Build the kinematics based on the EX_AX_DATA array and the provided offset
#self.addline('$BASE=EK(EX_AX_DATA[1].ROOT,EX_AX_DATA[1].EX_KIN, { %s })' % self.pose_2_str(pose))
# Option 3: Build the kinematics based on the EX_AX_DATA array and the pre-defined offset
#self.addline('; Using external axes')
#self.addline('; $BASE=EK(EX_AX_DATA[1].ROOT,EX_AX_DATA[1].EX_KIN,EX_AX_DATA[1].OFFSET)')
#self.addline('; $ACT_EX_AX= %i' % (self.nAxes - 6))
# Option 4: Use the BAS(#ex_BASE) init function from the BAS.src file
#self.addline('; BASE_DATA[%i] = {FRAME: %s}' % (self.BASE_ID, self.pose_2_str(pose)))
#self.addline('BAS(#ex_BASE,%i)' % self.BASE_ID)
# Option 5: Use the BAS(#BASE) init function from the BAS.src file
self.addline('; BASE_DATA[%i] = {FRAME: %s}' % (self.BASE_ID, self.pose_2_str(pose)))
self.addline('BAS (#BASE,%i)' % self.BASE_ID)
# Option 6: Directly take the base from the BASE_DATA array (usually what the BAS(#BASE) does)
# self.addline('$BASE=BASE_DATA[%i]' % self.BASE_ID)
self.addline('; --------------------------')
Imporre un movimento utilizzando angoli articolari
Questa sezione mostra come modificare un post processore esistente per forzare un movimento assiale utilizzando valori articolari invece di valori cartesiani.
In questo esempio applicheremo questa modifica a un controller robot ABB IRC5.
3.Trova il manuale di programmazione del tuo controller robot. In questo esempio utilizziamo il manuale di programmazione ABB IRC5 RAPID.
4.Cerca le istruzioni di movimento articolare. In questo caso, il comando di movimento articolare assoluto di ABB si chiama MoveAbsJ. Questo comando richiede una variabile jointtarget che definisce gli assi articolari.
5.Seleziona Programma-Aggiungi/Modifica Post Processore e seleziona il post processore che stai attualmente utilizzando per modificarlo. Se stai attualmente utilizzando un post processore personalizzabile, sarà selezionato per default.
6.Dovresti cercare la funzione MoveJ all'interno del post processore. Questa funzione definisce il modo in cui i post processori generano i comandi di movimento articolare. In alternativa, RoboDK utilizza MoveL per i movimenti lineari. Utilizzando il linguaggio di programmazione Python, modifica la riga che viene aggiunta al file del programma per fornire informazioni sugli angoli articolari, come mostrato nell'immagine seguente.
7.Infine, potrebbe essere necessario modificare il modo in cui il post processore converte gli angoli articolari o la posa in una stringa. Le funzioni angles_2_str e pose_2_str definiscono rispettivamente come gli angoli articolari e una posa vengono convertiti in testo.
La maggior parte dei post processori RoboDK utilizza dati articolari per i movimenti articolari e coordinate cartesiane per i movimenti lineari. Si consiglia di iniziare sempre il primo punto in una sequenza di movimenti lineari come movimento articolare, specificando le coordinate articolari. Questo evita di iniziare un programma con la configurazione robot errata e di raggiungere una singolarità o i limiti degli assi.
Post Processori disponibili
Di default, i seguenti post processori sono disponibili in RoboDK:
●ABB_RAPID_IRC5: per controller robot ABB IRC5
●ABB_RAPID_S4C: per controller robot ABB S4C
●Adept_Vplus: per linguaggio di programmazione Adept V+
●Allen_Bradley_Logix5000: per PLC Allen Bradley Logix5000
●Comau_C5G: per controller robot Comau C5G
●Denso_PAC: per controller robot Denso RC7 (e più vecchi) (linguaggio di programmazione PAC)
●Denso_RC8: per controller robot Denso RC8 (e più recenti) (linguaggio di programmazione PacScript)
●Dobot: per robot educational Dobot
●Fanuc_R30iA: per controller robot Fanuc R30iA e R30iB
●Fanuc_R30iA_Arc: per controller robot Fanuc Arc welding
●Fanuc_RJ3: per controller robot Fanuc RJ3
●GCode_BnR: per controller robot B&R
●GSK: per controller robot GSK
●HIWIN_HRSS: per controller robot HIWIN
●KAIRO: per controller robot Keba Kairo
●KUKA_IIWA: per controller robot KUKA IIWA sunrise in Java
●KUKA_KRC2: per controller robot KUKA KRC2
●KUKA_KRC2_CamRob: per controller robot KUKA CamRob
●KUKA_KRC2_DAT: per controller robot KUKA KRC2 inclusi DAT files
●KUKA_KRC4: per controller robot KUKA KRC4
●KUKA_KRC4_Config: per controller robot KUKA KRC4 con configurazioni in ogni linea
●KUKA_KRC4_DAT: per controller robot KUKA KRC4 inclusi DAT files
●Kawasaki: per controller robot Kawasaki AS
●Mecademic: per controller robot Mecademic Meca500
●Mitsubishi: per controller robot Mitsubishi
●Motoman: per controller robot Motoman che utilizzano Inform II e Inform III
●Nachi_AX_FD: per controller robot Nachi AX e FD
●OTC: per controller robot Daihen OTC
●Panasonic: per controller robot Panasonic PRG
●Precise: per controller robot Precise Scara
●Siemens_Sinumerik: per controller robot Siemens Sinumerik ROBX
●Staubli_VAL3: per controller robot Staubli VAL3 (controller CS8 e nuovi)
●Staubli_VAL3_InlineMove: per generare programmi Staubli con movimenti in linea
●Staubli_S6: per controller robot Staubli S6
●Toshiba: per controller robot Toshiba
●Universal_Robots: per controller robot UR, genera movimenti lineari come bersagli pose
●Universal_Robots_RobotiQ: per controller robot UR incluso supporto per gripper RobotiQ
●Universal_Robots_joints: per controller robot UR genera movimenti lineari come bersagli giunti
●Yamaha: per controller robot Yamaha
Riferimento
Il seguente video mostra una panoramica di un Post Processore in RoboDK:
https://robodk.com/help#PostProcessor
La documentazione di riferimento per ogni metodo nel post processore è disponibile online:
http://robodk.com/doc/en/PythonAPI/postprocessor.html
Tutti i post processori utilizzano il modulo robodk.py:
http://robodk.com/doc/en/PythonAPI/robodk.html#robodk.Mat
Il modulo robodk.py fornisce strumenti per operazioni di pose (moltiplicazioni, inverso, ...) e conversioni tra pose ed anglori di eulero in formati diversi.
La documentazione è disponibile online per imparare la programmazione in Python:
Quando un programma è generato, un programma pre-processato/universale in Python viene generato e salvato in una cartella temporanea. Il programma pre-processato è collegato al post processore corretto (selezionato dall'utente in RoboDK). Il post processore definisce una classe RoboPost che genera il codice generato.
I programmi precompilati sono eseguiti con Python.
