Ejemplo de Modificación
Esta sección muestra cómo hacer un pequeño cambio para un postprocesador existente.
Como ejemplo, se realizarán los siguientes cambios en el postprocesador KUKA KRC4 existente:
●Ajustar la velocidad máxima a 500 mm/s. incluso si el robot está programado para moverse más rápido, la velocidad se limitará a 500 mm/s en el postprocesador.
●Generar cada programa como un archivo separado y forzar programas para tener 3000 líneas de código por programa como máximo. Los programas grandes serán divididos en programas más pequeños y llamados secuencialmente.
La sección anterior muestra cómo abrir un postprocesador existente para su edición:
1.Seleccione Programa➔Añadir/Editar Post procesador
2.Seleccione KUKA_KRC4
3.Seleccione OK. El postprocesador será mostrado en el editor de Python IDLE.
En las siguientes secciones se muestra cómo realizar en el editor de texto los cambios sugeridos.
Generar todos los programas en un solo archivo
Este ejemplo le mostrará cómo cambiar el comportamiento predeterminado del postprocesador KUKA KRC4 para generar un programa principal junto con sus subprogramas en el mismo archivo.
Asegúrese de que el plugin del editor de postprocesadores está habilitado y siga estos pasos para realizar las modificaciones del postprocesador:
1.Seleccione ProgramaEditor de Postprocesadores.
2.Seleccione el postprocesador que desea personalizar (KUKA KRC4).
3.Seleccione OK. Se abrirá una nueva ventana donde verá las variables que puede modificar, como se muestra en la siguiente imagen.
4.Establezca la variable Include Sub Programs en True en lugar de False.
5.Seleccione Guardar Postprocesador como…
6.Introduzca un nuevo nombre para guardarlo (el nombre predeterminado usa la fecha de modificación).
Ahora debería tener un nuevo postprocesador en la carpeta Posts de RoboDK. Puede actualizar su proyecto para usar este nuevo postprocesador siguiendo estos pasos:
1.Haga clic derecho en su robot.
2.Seleccione Seleccionar Postprocesador.
3.Seleccione el nuevo postprocesador que creó.
4.Genere sus programas de nuevo para ver el resultado.
También podría realizar estos cambios usando un editor de texto. Siga estos pasos para cambiar el código Python predeterminado del postprocesador:
1.Seleccione ProgramaAñadir/Modificar Postprocesador
2.Seleccione su postprocesador. Por ejemplo, para KUKA KRC4 seleccione KUKA_KRC4.
3.Seleccione OK. El postprocesador se mostrará en un editor de texto.
4.Establezca la variable MAX_LINES_X_PROG en 3000.
5.Establezca la variable INCLUDE_SUB_PROGRAMS en True.
Forzar un límite de velocidad
Este ejemplo le mostrará cómo imponer un límite de velocidad de 500 mm/s y evitar el uso de velocidades mayores al generar un programa con RoboDK.
En este ejemplo asumimos que estamos usando un controlador KUKA KRC2 o KRC4:
1.Seleccione ProgramaAñadir/Modificar Postprocesador
2.Seleccione su postprocesador. Por ejemplo, para KUKA KRC4 seleccione KUKA_KRC4.
3.Seleccione OK. El postprocesador se mostrará en un editor de texto.
4.Localice la definición de la función setSpeed (def setSpeed)
5.Añada la siguiente línea para limitar la velocidad máxima a 500 mm/s. La línea debe añadirse antes de generar la salida $VEL.CP, que cambia la velocidad en m/s:
speed_mms = min(speed_mms, 500)
Filtro personalizado para sistemas de referencia
Esta sección muestra cómo personalizar la forma en que se establece el sistema de referencia de un postprocesador existente. Por ejemplo, estableciendo un sistema de referencia personalizado para un robot KUKA.
Puede usar postprocesadores compilados y reimplementar fácilmente solo las funciones necesarias (por ejemplo, setFrame, setTool o setSpeed).
En este ejemplo, asumimos que queremos personalizar cómo se define la base para un controlador KUKA. Por ejemplo, si desea generar la siguiente línea al establecer el sistema de referencia:
BASE_DATA[8] = {FRAME: X:2000, Y:0, Z:0, A:0, B:0, C:0}
BAS (#BASE,8)
Simplemente necesita crear un nuevo archivo llamado KUKA_Custom_Post.py en la carpeta C:/RoboDK/Posts/ con las siguientes líneas, que usan el postprocesador KUKA_KRC2 predeterminado y sobrescriben el establecimiento del sistema de referencia (función 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)')
Sin embargo, podríamos añadir filtros personalizados basados en ciertos criterios para elegir entre usar el comportamiento predeterminado o una implementación personalizada. El archivo del postprocesador podría modificarse entonces de la siguiente manera:
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('; --------------------------')
Al generar programas para controladores KUKA KRC, hay muchas formas de establecer su sistema de coordenadas o sistema de referencia. La siguiente definición de setFrame muestra una implementación alternativa con diferentes opciones:
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('; --------------------------')
Imponer un movimiento usando ángulos de articulación
Esta sección le mostrará cómo modificar un postprocesador existente para forzar un movimiento axial usando valores de articulación en lugar de valores cartesianos.
En este ejemplo aplicaremos este cambio a un controlador de robot ABB IRC5.
1.Busque el manual de programación de su controlador de robot. En este ejemplo usamos el manual de programación RAPID de ABB IRC5.
2.Busque las instrucciones de movimiento articular. En este caso, el comando de movimiento articular absoluto de ABB se llama MoveAbsJ. Este comando requiere una variable jointtarget que define los ejes de articulación.
3.Seleccione ProgramaAñadir/Modificar Postprocesador y seleccione el postprocesador que está usando actualmente para modificarlo. Si actualmente usa un postprocesador personalizable, este se seleccionará por defecto.
4.Debe buscar la función MoveJ dentro del postprocesador. Esta función define la forma en que los postprocesadores generan los comandos de movimiento articular. Alternativamente, RoboDK usa MoveL para los movimientos lineales. Usando el lenguaje de programación Python, modifique la línea que se añade al archivo del programa para proporcionar información de ángulos de articulación, como se muestra en la siguiente imagen.
5.Finalmente, es posible que deba modificar la forma en que el postprocesador convierte los ángulos de articulación o la pose a texto. Las funciones angles_2_str y pose_2_str definen cómo se convierten a texto los ángulos de articulación y una pose, respectivamente.
La mayoría de los postprocesadores de RoboDK usan datos de articulación para los movimientos articulares y coordenadas cartesianas para los movimientos lineales. Se recomienda iniciar siempre el primer punto de una secuencia de movimientos lineales como un movimiento articular, especificando las coordenadas de articulación. Esto evita iniciar un programa con la configuración de robot incorrecta y alcanzar una singularidad o los límites de los ejes.
