Los Post procesadores son un paso clave en la programación fuera de línea. Los postprocesadores permiten flexibilidad para soportar cualquier controlador de robot. Un postprocesador robot define cómo los programas de robot deben generados para un controlador robot específico.

La conversión desde la simulación RoboDK a un programa robot específico se realizada con un Post procesador. Cada robot tiene un postprocesador asignado por defecto. El postprocesador se usa cuando el programa es generado fuera de línea, como se muestra en la sección Generar Programa(haciendo clic derecho en un programa, luego, seleccionando Generar Programa de Robot).

RoboDK incluye varios postprocesadores que soportan diferentes controladores robot, listados en la sección Post procesadores disponibles. Alternativamente, es posible crear un postprocesador personalizado o modificar un postprocesador existente. Todos los postprocesadores disponibles están en la carpeta:

C:/RoboDK/posts/

Un postprocesador es un archivo PY (cada postprocesador está definido por un script Python). Es posible añadir manualmente, modificar o eliminar los archivos de la carpeta Posts de RoboDK. Si se le ha proporcionado un postprocesador RoboDK (archivo PY) debe ser colocado en la carpeta Posts para que se pueda seleccionar desde RoboDK.

Esta sección muestra cómo seleccionar, editar o crear un postprocesador y usarlo con sus robots en RoboDK. Una introducción rápida está disponible en el siguiente vídeo: https://www.robodk.com/help#PostProcessor

Nota: La mayoría de las marcas de robot tienen diferentes versiones de controlador. Es importante seleccionar el postprocesador para generar programas de robots apropiados compatible con un controlador de robot específico.

Importante: Cada robot tiene un postprocesador específico asignado a él por defecto. La selección por defecto podría no generar programas para un controlador específico del robot. En ese caso, es necesario seleccionar el postprocesador para el controlador correcto del robot.

Seleccionar un Post procesador

Puede seleccionar fácilmente un postprocesador haciendo clic derecho en un robot o un programa. La elección de un postprocesador está asignada a un robot; por lo tanto, cambiar el postprocesador asignado a un programa actualizará el postprocesador usado por todos los programas asignados al mismo robot.

Para seleccionar un postprocesador específico para un robot:

1.Haga clic derecho en un robot o un programa

2.Seleccione Seleccionar Post procesador

3.Elija un postprocesador desde la lista

4.Seleccione OK.

Post Processors - Imagen 1 Post Processors - Imagen 2

El cambio es aplicado ahora y el programa puede ser generado de nuevo para ver el resultado.

Nota: La selección de un Post procesador está vinculada a un robot específico. Al cambiar el postprocesador de un programa se actualizará el postprocesador para todos los programas vinculados al mismo robot.

Como una alternativa, también es posible seleccionar el postprocesador siguiendo estos pasos:

1.Abra el panel del robot (haga doble clic en un robot)

2.Seleccione Parámetros

3.Seleccione su postprocesador en la caja de la marca del robot, como se muestra en la siguiente imagen.

Consejo: Es posible previsualizar rápidamente la salida de cada postprocesador haciendo doble clic en su archivo PY en la carpeta C:/RoboDK/posts/. Más información disponible en la siguiente sección.

Post Processors - Imagen 3

Editor de Postprocesadores

Puede modificar fácilmente los ajustes de un postprocesador usando una interfaz gráfica de usuario. El editor de postprocesadores le permite modificar variables definidas en el postprocesador que son específicas de su controlador de robot.

El editor de postprocesadores es un plugin que ayuda a personalizar sus postprocesadores. Puede descargar e instalar fácilmente el plugin desde la siguiente página: https://robodk.com/addin/com.robodk.plugin.postprocessoreditor.

Siga estos pasos para abrir el editor de postprocesadores:

1.Seleccione ProgramaEditor de Postprocesadores.

2.Seleccione el postprocesador que desea personalizar.

3.Seleccione OK. Se abrirá una nueva ventana donde verá las variables que puede modificar.

4.Seleccione Guardar Postprocesador como…

5.Introduzca el nombre para guardarlo.

Importante: No debe sobrescribir los postprocesadores predeterminados. En su lugar, utilice nombres únicos propios al crear sus postprocesadores. Los postprocesadores predeterminados volverán a su valor original si reinstala RoboDK.

Post Processors - Imagen 4 Post Processors - Imagen 5

Por ejemplo, si selecciona el postprocesador Fanuc R30iA verá la ventana mostrada en la imagen anterior.

Modificar un Post procesador

Es posible modificar postprocesadores existentes o crear nuevos postprocesadores. Los postprocesadores deben ser colocados en la carpeta C:/RoboDK/posts/ para que puedan ser seleccionados en RoboDK. En la sección anterior se describen cómo enlazar un robot específico a un postprocesador.

Cada postprocesador es un archivo PY. Es posible renombrar el archivo o copiar los archivos desde/hacia la carpeta C:/RoboDK/posts/ para compartir diferentes postprocesadores. Para eliminar un script de postprocesador existente, simplemente elimine el archivo PY correspondiente en la carpeta Posts.

Los postprocesadores pueden editarse mediante cualquier editor de texto o un editor de Python (Python IDLE). Usar el editor de Python permite depurar rápidamente y evaluar un programa de muestra al final del archivo.

Vídeo: Descripción general de los postprocesadores: https://www.youtube.com/watch?v=lbycCDjtOnE.

Python puede ser instalado para probar y usar los postprocesadores correctamente (Python está instalado por defecto con RoboDK).

Para modificar un postprocesador existente:

1.Seleccione Programa➔Agregar/Editar Post procesador

2.Seleccione un postprocesador existente

3.Seleccione OK. Un editor de texto se abrirá con el programa.

4.Seleccione Ejecutar➔Ejecutar módulo (F5) para pre visualizar el resultado. Haga cualquier cambio si es necesario.

Post Processors - Imagen 6

Alternativamente, es posible editar manualmente un postprocesador:

1.Vaya a la carpeta de los postprocesadores: C:/RoboDK/posts/

2.Abra un archivo PY con Python IDLE (clic derecho ➔ Editar con IDLE) u otro editor de texto

3.Realice los cambios deseados

4.Ejecute el archivo para probar el resultado: Seleccione Ejecutar➔Ejecutar Módulo (F5 por defecto) desde Python IDLE.

Alternativamente, es posible editar este archivo usando un editor de texto y ejecutarlo con Python haciendo doble clic en él.

Post Processors - Imagen 7

Consejo: Es posible cambiar el editor por defecto para los postprocesadores en RoboDK seleccionando Herramientas➔Opciones➔Otros y proporcionando el camino del editor en el Comando de editor de Python.

Importante: Si se utiliza un editor de texto como Notepad++, es importante reemplazar las tabulaciones por 4 espacios. De lo contrario, se obtendrá un TabError diciendo que hay un uso incoherente de tabuladores y espacios en sangría.

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

Post Processors - Imagen 8

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.

Post Processors - Imagen 9

Nota: La variable MAX_LINES_X_PROG puede ser sobrescrita si el número máximo de líneas por programa se especifica desde el menú Opciones de Programa de RoboDK. También podría modificar la sección __init__ del postprocesador para evitar que esta variable se modifique desde los ajustes de RoboDK.

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)

Post Processors - Imagen 10

Nota: En la variable HEADER, al principio del postprocesador, se define una velocidad predeterminada de 200 mm/s ($VEL.CP=0.2). Esta velocidad predeterminada también se puede cambiar si la velocidad no se modifica desde RoboDK.

Nota: Si no dispone del código fuente del postprocesador, aun así puede añadir su propia función personalizada para sobrescribir el comportamiento predeterminado.

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

Nota: Asegúrese de que el nombre de su postprocesador personalizado sea diferente del nombre del postprocesador de referencia que está usando. Al actualizar RoboDK, el instalador sobrescribirá los postprocesadores predeterminados con la versión original. Sin embargo, el instalador no eliminará ni modificará los postprocesadores personalizados de la carpeta Posts.

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.

Post Processors - Imagen 11

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.

Post Processors - Imagen 12

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.

Post Processors - Imagen 13

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.

Nota: Todos los postprocesadores de RoboDK usan el módulo robodk.py por defecto. Este módulo incluye herramientas útiles para convertir poses a ángulos de Euler para muchos controladores de robot. Use la notación correspondiente a su controlador de robot. Más información disponible en la sección Sistemas de Referencia y el módulo robodk.py.

Nota: Más de un fabricante de robots puede usar la misma notación de ángulos de Euler. Por ejemplo, Fanuc y Motoman usan la misma notación XYZ, Stäubli y Mecademic usan la misma notación XY'Z'', etc.

Importante: Si especifica un movimiento usando una pose (por ejemplo, usando coordenadas cartesianas e información de Euler o Cuaternión), la posición que alcanzará el robot dependerá de la herramienta y el sistema de referencia activos. Las poses de la herramienta y del sistema de referencia deben especificarse correctamente en el programa. Esto se hace mediante las funciones setTool y setFrame, respectivamente.

Post procesadores disponibles

RoboDK proporciona más de 100 postprocesadores de forma predeterminada para generar programas de robot compatibles con más de 50 fabricantes de robots. Algunos postprocesadores se pueden personalizar aún más para generar programas con un formato específico.

Puede encontrar la lista completa de postprocesadores disponibles en la Biblioteca de RoboDK visitando https://robodk.com/posts. También puede seleccionar HerramientasAbrir Biblioteca de Robots en la barra de herramientas principal de RoboDK para encontrar robots, postprocesadores, Add-ins y más.

Al instalar RoboDK encontrará disponibles los siguientes postprocesadores:

1.ABB RAPID IRC5: para controladores de robot ABB IRC5.

2.ABB RAPID IRC5 Robtargets: para controladores de robot ABB IRC5 y genera nombres de robtarget.

3.ABB RAPID S4C: para controladores de robot ABB S4C.

4.Adept Vplus: para el lenguaje de programación Adept V+.

5.Allen Bradley Logix5000: para el PLC Allen Bradley Logix5000.

6.Annin Robotics: para robots AR3 y AR4.

7.Aubo: para controladores de robot AUBO.

8.Aubo ARCS: genera código (.lua y .pro) para controladores robóticos AUBO ARCS.

9.Automata: para robots Automata EVA.

10.Borunte: para brazos robóticos Borunte. Genera un paquete zip con los archivos necesarios para controladores de robot BRTIRUS.

11.Brooks: para robots PreciseFlex.

12.CLOOS: para controladores de robot CLOOS.

13.Comau C5G: para controladores de robot Comau C5G (archivos PDL).

14.Comau Nodal: para controladores de robot Comau C5G que usan programas Comau Nodal modernos (lenguaje PDL2).

15.CPR: genera código en formato XML adecuado para sistemas robóticos CPR.

16.CSV: genera archivos simples en formato CSV para controladores robóticos y de automatización genéricos. Este postprocesador es versátil y se puede usar en aplicaciones que requieren una importación y exportación de datos sencilla.

17.Denso PAC: para controladores de robot Denso RC7 (y anteriores) (lenguaje de programación PAC).

18.Denso RC8: para controladores de robot Denso RC8 (y posteriores) (lenguaje de programación PacScript).

19.Dobot Magician: para robots educativos Dobot.

20.Dobot MG400: para el robot scara Dobot.

21.Dobot: para la línea industrial de robots Dobot.

22.Doosan: para robots colaborativos Doosan.

23.Elite CS: genera código para controladores de robot Elite CS.

24.Elite EC: genera código para controladores de robot Elite EC.

25.Estun RC: para controladores de robot Estun RC.

26.Epson RC: para controladores de robot Epson.

27.Fairino: genera archivos .lua y admite la serie de robots Fairino FR.

28.Fanuc R30iA: para controladores de robot Fanuc R30iA y R30iB.

29.Fanuc R30iA Arc: para soldadura por arco Fanuc.

30.Fanuc RJ3: para controladores de robot Fanuc RJ3.

31.Flexiv: genera archivos de trayectoria (.traj) para controladores Flexiv Hesper.

32.Foxbot: genera archivos .pac para controladores Foxbot.

33.GCode A3200: genera archivos .cnc con el formato específico para controladores A3200 de Aerotech.

34.GCode BnR: para controladores de robot B&R.

35.GCode NCP: genera archivos .cnc compatibles con controladores que admiten el lenguaje NCP.

36.GSK: para robots GSK.

37.Hans: para controladores de robot HAN'S.

38.HCR: para controladores de robot Hanwha.

39.HIWIN HRSS: para robots HIWIN.

40.Huayan: para robots Huayan Robotics (anteriormente conocido como Han's Robot), incluye un script y un archivo json.

41.Hyundai: para controladores de robot Hyundai.

42.IGUS: genera código en formato XML adecuado para sistemas robóticos igus.

43.IIMT: genera archivos .txt que se pueden cargar fácilmente en controladores de robot IIMT CR.

44.Inexbot: genera archivos .JBI diseñados específicamente para controladores Inexbot (Inform III).

45.JAKA: para controladores de robot JAKA.

46.Kassow: genera código para controladores Kassow Robots KR2.

47.Kawasaki: para controladores de robot Kawasaki AS.

48.KEBA KAIRO: para controladores de robot Keba Kairo.

49.Kinova: para robots Kinova.

50.Kinova Link6: genera código JSON (.json), compatible con brazos robóticos Kinova Link 6.

51.KUKA app4PostPro: genera archivos .csv diseñados para controladores KUKA KR C4 con app4PostPro.

52.KUKA CNC: genera archivos .nc diseñados para sistemas KUKA.CNC.

53.KUKA EntertainTech: genera archivos .src y .emily para controladores robóticos KUKA con el paquete Entertain Tech.

54.KUKA IIWA: para programación KUKA IIWA sunrise en Java.

55.KUKA KRC1: para controladores de robot KUKA KRC1.

56.KUKA KRC2: para controladores de robot KUKA KRC2.

57.KUKA KRC2_CamRob: para la opción de fresado KUKA CamRob.

58.KUKA KRC2_DAT: para controladores de robot KUKA KRC2, incluyendo archivos de datos DAT.

59.KUKA KRC4: para controladores de robot KUKA KRC4.

60.KUKA KRC4 Config: para controladores de robot KUKA KRC4 con datos de configuración en cada línea.

61.KUKA KRC4 DAT: para controladores de robot KUKA KRC4, incluyendo archivos de datos DAT.

62.KUKA KRC5: para controladores de robot KUKA KRC5.

63.MARS: genera archivos .gpl para sistemas MARS.

64.MABI: para brazos robóticos MABI que usan controladores de robot Siemens Sinumerik (G-code).

65.Mecademic: para el código de script de Mecademic requerido por el robot Meca500.

66.Mecademic Python: genera un script de Python que puede controlar remotamente el robot Mecademic Meca500.

67.Mitsubishi: para controladores de robot Mitsubishi.

68.Motoman/Yaskawa: para distintos controladores de robot Motoman que usan Inform II e Inform III (JBI). Requiere conocer la relación de pulsos/grado de cada eje. Puede cargar el archivo ALL.PRM en su proyecto para extraer esta información automáticamente.

69.Motoman Cartesian: para controladores de robot Yaskawa/Motoman que usan valores cartesianos. Es posible que necesite la opción Relative Job en el controlador del robot si desea modificar manualmente este programa en el controlador.

70.MyCobot: genera código Python compatible con brazos robóticos MyCobot.

71.Nachi AX FD: para controladores de robot Nachi AX y FD.

72.Neura: genera un script de Python NeuraPy compatible con el controlador Neura Robotics Real-Time NR-Motion Master.

73.NEWKer i6: genera código diseñado para controladores CNC NEWKer i6.

74.Niryo: genera código Python diseñado para robots educativos Niryo.

75.Omron: para controladores de robot Omron-TM.

76.OTC: para controladores de robot Daihen OTC.

77.Panasonic: para programas Panasonic PRG (requiere las herramientas Panasonic G2PC para compilar archivos ASCII en archivos binarios).

78.Precise: para robots Precise Scara.

79.QJAR: genera archivos .rbg para controladores de robot QJAR.

80.Rainbow Robotics: genera archivos .wsl para controladores Rainbow Robotics.

81.Robostar: para controladores de robot Robostar.

82.Rokae: genera archivos .mod para controladores de robot ROKAE.

83.Rozum RC API: genera archivos .py para integrarse con controladores Rozum RC Series.

84.Rozum RC Pulse: genera archivos .rcp diseñados para controladores Rozum RC Series.

85.Schneider: para controladores Schneider Electric Lexium.

86.Siasun: para controladores de robot Siasun.

87.Siemens 840D PKM: para robots PKM que usan el controlador Siemens Sinumerik.

88.Siemens Sinumerik: para el controlador de robot Siemens Sinumerik ROBX.

89.Staubli S6: para controladores de robot Staubli S6.

90.Staubli VAL3: para generar programas de robot Staubli VAL3 (controladores CS8 y posteriores). Incluye los movimientos del robot en línea.

91.Staubli VAL3 Machining: para controladores Staubli VAL3 que tienen la opción Machining HSM.

92.Techman: para controladores de robot Techman.

93.Toshiba: para robots Toshiba.

94.Turin: genera archivos .txt para controladores de robot Turin.

95.uArm: genera código .cnc para sistemas robóticos uFactory uArm.

96.Universal Robots: para robots UR, genera movimientos lineales como objetivos de pose.

97.Universal Robots URP: para robots UR, genera un archivo URP que se puede cargar y modificar en Polyscope (el controlador de robot UR).

98.Universal Robots_RobotiQ: para robots UR, incluye compatibilidad con la pinza RobotiQ.

99.Universal Robots MoveP: para robots UR, genera movimientos lineales como comandos MoveP.

100.Wlkata: para brazos robóticos WLKATA Mirobot.

101.xArm: para sistemas robóticos uFactory xArm.

102.Yamaha: para robots Yamaha.

Nota: Algunos controladores de robot, como los controladores Fanuc y Panasonic, requieren software u opciones de controlador específicas proporcionadas por el fabricante para poder cargar los archivos de programa generados por RoboDK. Por ejemplo, los robots Panasonic requieren las herramientas G2PC para convertir el archivo de programa generado por RoboDK en un archivo binario que el controlador pueda leer. Algunos robots Fanuc admiten archivos ASCII generados por RoboDK; alternativamente, puede compilar los programas usando la utilidad maketp de Roboguide. Más información en la sección de compilación LS a TP de Fanuc.

Nota: La lista y el comportamiento de los postprocesadores predeterminados de RoboDK cambian periódicamente. Esto significa que el código generado usando el mismo postprocesador puede ser diferente entre distintas versiones de RoboDK. Para evitar cambios inesperados en su código generado, asegúrese de crear una copia única o personalizar sus postprocesadores para que el código generado no cambie al actualizar o reinstalar RoboDK.

Referencia

El siguiente vídeo muestra una visión general de los Post procesadores en RoboDK:
https://robodk.com/help#PostProcessor

La documentación de referencia para cada método en el postprocesador está disponible en línea:
http://robodk.com/doc/en/PythonAPI/postprocessor.html

Todos los postprocesadores utilizan el módulo robodk.py:
http://robodk.com/doc/en/PythonAPI/robodk.html#robodk.Mat

El módulo robodk.py proporciona herramientas para operaciones de Pose (multiplicaciones, inversas,...) y conversiones entre poses y ángulos de Euler en diferentes formatos, entre otras cosas.

Nota: De forma predeterminada, Python se instala con RoboDK y el módulo robodk.py se agrega a la ruta de Python.

La documentación está disponible en línea para aprender sobre la programación de Python:
https://docs.Python.org/3/

Cuando un programa es generado, es generado un programa de Python pre-procesado/universal y es guardado en una carpeta temporal local. El programa pre-procesado está vinculado con el postprocesador correcto (seleccionado por el usuario en RoboDK). El postprocesador define un RobotPost Class que genera el código deseado.

Los programas pre compilados son ejecutados con Python.

Consejo: En Windows, los programas pre procesados son guardados en la carpeta C:/Users/username/AppData/Local/Temp (Tipo %TEMP% en el explorador de archivos de Windows). Estos programas también pueden ser usados para depurar nuevos postprocesadores.