Brooks robot
RoboDK supporta i robot Brooks PreciseFlex utilizzando il GPL (Guidance Programming Language). Gli utenti possono generare programmi avanzati di automazione di laboratorio utilizzando una selezione di bracci robotici, pinze e guide lineari.
Simulazione della pinza
Per controllare le pinze Brooks PreciseFlex da una simulazione, compresa la pinza doppia, segua la procedura descritta in questa sezione.
1.Clicchi con il tasto destro del mouse sul suo programma e aggiunga un'istruzione di chiamata al programma.
2.Inserisca "Pinza(ID pinza, valore pinza)". Ad esempio, "Pinza(2, 50)" per spostare la pinza numero 2 di una pinza doppia a 50 mm.
a.Può abbreviare la chiamata a "Pinza(valore pinza)" con una sola pinza.
b.Se è presente più di un robot, utilizzi "Gripper(ID pinza, valore pinza, item.ptr)". Ad esempio, "Pinza(2, 50, item.ptr)" sposterà la pinza numero 2 di una pinza doppia a 50 mm, assicurandosi che il robot genitore sia collegato al programma.
3.Aggiunga l'istruzione Gripper() come prima istruzione di tutti i sottoprogrammi e dopo tutte le chiamate di sottoprogrammi. Questo per garantire la compatibilità con il post-processore. Sono previste istruzioni Gripper() duplicate.
4.Aggiunga uno script Python, rinominandolo in "Gripper".
5.Modifichi lo script Python "Gripper" e incolli quanto segue:
da robodk importa robolink
Importazione di sys
se len(sys.argv) < 2:
uscire()
def get_item(ptr_item, RDK):
item = robolink.Item(RDK, str(ptr_item), robolink.ITEM_TYPE_PROGRAM)
se non item.Valid(True):
restituire Nessuno
restituire l'articolo
RDK = robolink.Robolink()
gripper_id = -1
valore_presa = 0
prog_item = Nessuno
# Ottenere l'ID pinza, il valore e il chiamante
se len(sys.argv) == 2:
valore_presa = float(sys.argv[1])
elif len(sys.argv) >= 4:
gripper_id = int(sys.argv[1])
valore_presa = float(sys.argv[2])
prog_item = get_item(int(sys.argv[3]), RDK)
elif len(sys.argv) == 3:
prog_item = get_item(int(sys.argv[2]), RDK)
se prog_item:
valore_presa = float(sys.argv[1])
altro:
gripper_id = int(sys.argv[1])
valore_presa = float(sys.argv[2])
# Ottenere i candidati
pinze = [x for x in RDK.ItemList(robolink.ITEM_TYPE_ROBOT_AXES) if 'gripper' in x.Name().lower() and len(x.Joints().tolist()) == 1]
se len(pinze) > 1 e prog_item:
robot_item = prog_item.getLink(robolink.ITEM_TYPE_ROBOT)
se non robot_item.Valid():
robot_item = RDK.ItemUserPick("Seleziona il robot collegato", robolink.ITEM_TYPE_ROBOT)
prog_item.setRobot(robot_item)
def get_flat_childs(elemento):
figli = item.Childs()
per bambino in item.Childs():
childs.extend(get_flat_childs(bambino))
restituire childs
figli = get_flat_childs(robot_item)
pinze = [x per x in childs se x.Type() == robolink.ITEM_TYPE_ROBOT e len(x.Joints().tolist()) == 1]
se non le pinze:
RDK.ShowMessage('Impossibile trovare una pinza!', False)
# Cerca di trovare l'id della pinza giusta (cioè la pinza doppia 1)
pinza = pinze[0]
se gripper_id > 0:
gripper_ids = [g for g in grippers if g.Name().endswith(str(gripper_id))]
se gripper_ids:
pinza = gripper_ids[0]
gripper.MoveJ([gripper_value])
Si noti che questo metodo è compatibile anche con il post processor Brooks.
Binari lineari
Poiché il telaio di base del robot PreciseFlex non è posizionato sulla base fisica del robot, sono necessari degli offset specifici tra i robot PreciseFlex e le guide lineari PreciseFlex.
Configurazione della guida lineare Brooks PreciseFlex:
a.Brooks PreciseFlex 400: [118, 0, 45.6, 0, 0, 0]
b.Brooks PreciseFlex 3400: [118, 0, 62.6, 0, 0, 0]
Guida lineare Brooks PreciseFlex - configurazione a 90 gradi:
a.Brooks PreciseFlex 400: [101,6, 0, 45,6, 0, 0, 0]
b.Brooks PreciseFlex 3400: [101,6, 0, 62,6, 0, 0, 0]
La guida lineare deve essere sincronizzata affinché il post processor tenga conto della posizione dell'asse. Per maggiori informazioni, consulti la sezione https://robodk.com/doc/en/General.html#SyncAxes.
Post Processor
Questa sezione spiega alcuni suggerimenti relativi alla generazione di programmi per i robot Brooks.
Punto centrale dello strumento (TCP)
Il punto centrale dell'utensile (TCP) in RoboDK e nel controllore deve corrispondere. Se si utilizza un meccanismo di presa, è necessario aggiungere un TCP utilizzando "Aggiungi utensile (TCP)" che si trovi nella posizione prevista. Il nuovo TCP dell'utensile deve corrispondere al TCP del meccanismo di presa. Le informazioni relative al Punto Centrale Utensile (TCP) dei robot Brooks PreciseFlex possono essere trovate accedendo all'Interfaccia Web e seguendo questi passaggi:
1.Admin
2.Impostazione - Database dei parametri
3.Robot
4.Controllo congiunto/cartesiano
5.Parametri dinamici
6.DataID 16051
Pinza
Vedere la sezione precedente Simulazione della pinza su come definire correttamente le istruzioni della pinza compatibili con il post processor. Questo approccio definisce correttamente le posizioni nel progetto GPL, evitando movimenti imprevisti degli assi della pinza.
Rounding
Un valore di ingresso di -1 determina che il robot si fermerà alla fine del movimento e verrà applicato un vincolo di errore di posizione severo (codice GPL: prof1.InRange = 100).
Un valore di ingresso pari a 0 determina che il robot si fermerà alla fine del movimento, ma verrà applicato un piccolo vincolo di errore di posizione (codice GPL: prof1.InRange = 10).
Un valore di ingresso superiore a 0 determina che il robot non si fermerà alla fine del movimento e verrà eseguito un movimento misto (codice GPL: prof1.InRange = -1).
Velocità e accelerazione
Le informazioni relative alle velocità/accelerazioni massime lineari, angolari e dei giunti dei robot Brooks PreciseFlex possono essere trovate accedendo all'Interfaccia Web e seguendo questi passaggi:
1.Admin
2.Impostazione - Database dei parametri
3.Robot
4.Controllo congiunto/cartesiano
5.Parametri dinamici
6.ID dati 2700, 2701, 2702 e 2703
L'utente può impostare gli ingressi delle istruzioni di velocità/accelerazioni di RoboDK utilizzando i valori dei DataID di cui sopra come riferimenti. Il post-processore Precise utilizzerà poi questi valori per calcolare la velocità/accelerazione come percentuali della velocità/accelerazione massima per ogni robot, come richiesto dalla classe Profilo GPL.
Per cambiare i limiti utilizzati dal post processor, può modificare il post processor in base al robot specifico che sta utilizzando. Per impostazione predefinita, il post processor utilizza i limiti dei robot PF400 e PF3400. Per modificare il post processor, faccia riferimento alla sezione https://robodk.com/doc/en/Post-Processors.html#PPEditor della documentazione.
Se si utilizzano valori di ingresso inferiori a 1 con le istruzioni di accelerazione lineare e angolare, questi ingressi saranno utilizzati come durata in secondi per la rampa di accelerazione/decelerazione di picco (codice GPL: prof1.AccelRamp/prof1.DecelRamp = valore di ingresso).
L'immagine sottostante fornisce ulteriori informazioni relative ai concetti scritti sopra e al modo in cui il controllore pianifica le traiettorie che il robot deve seguire.
Pausa
L'impostazione di un valore di ingresso maggiore di 0 genererà un comando GPL che metterà in pausa il programma per il tempo definito dal valore di ingresso. Un valore di ingresso negativo aprirà una finestra di dialogo pop-up sul Pannello di controllo dell'operatore dell'interfaccia web e il programma verrà messo in pausa finché l'utente non farà clic sul pulsante "Continua" della finestra di dialogo. Per visualizzare la finestra di dialogo, l'utente deve cliccare sul pulsante "Dialogo attivo" sul Pannello di controllo dell'operatore.
Trasferimento di programmi via FTP
I programmi possono essere facilmente trasferiti via FTP da RoboDK per i robot Brooks:
1.Clicchi con il tasto destro del mouse sul robot in RoboDK.
2.Selezionare Collega al robot...
3.Inserisca l'IP e la porta del robot (quella predefinita è 192.168.0.1 con porta 21).
4.Inserisca il percorso FTP remoto (tipicamente /flash/progetti)
Una volta che un programma RoboDK è pronto per essere inviato al robot:
1.Clicchi con il tasto destro del mouse su un programma in RoboDK.
2.Selezionare Invia programma al robot (Ctrl+F6)
Questo genererà il programma e tenterà di trasferirlo al controller del robot. Verrà visualizzata una finestra che mostra se il trasferimento FTP è riuscito o meno.
Avviare un programma robotico
L'interfaccia web del robot deve essere utilizzata per caricare e avviare il progetto GPL (è possibile accedere all'interfaccia web del robot utilizzando qualsiasi browser e cercando l'indirizzo IP del robot). Di seguito è riportata un'immagine della pagina iniziale dell'Interfaccia Web.
1.Apra un browser web
2.Inserire l'indirizzo IP del robot
Per avviare il programma dall'interfaccia web
1.Selezioni Amministrazione -> Pannelli di controllo -> Pannello di controllo dell'operatore -> "Carica".
2.Selezioni il progetto GPL creato con RoboDK.
3.Clicchi su "Seleziona".
4.Clicchi su "Avvio".
A questo punto, il robot eseguirà il programma. Di seguito è riportata un'immagine che mostra l'interfaccia del Pannello di Controllo dell'Operatore e la finestra che consente all'utente di selezionare e caricare il progetto GPL necessario.
