Brooks robots
RoboDK es compatible con los robots Brooks PreciseFlex que utilizan el lenguaje de programación GPL (Guidance Programming Language). Los usuarios pueden generar programas avanzados de automatización de laboratorios utilizando una selección de su brazo robótico, pinzas y guías lineales.
Simulación de pinzas
Para controlar las pinzas Brooks PreciseFlex desde una simulación, incluida la pinza doble, siga los pasos descritos en esta sección.
1.Haga clic con el botón derecho del ratón en su programa y añada una instrucción de llamada a programa.
2.Introduzca "Pinza(ID pinza, valor pinza)". Por ejemplo, "Pinza(2, 50)" para mover la pinza nº 2 de una pinza doble a 50 mm.
a.Puede acortar la llamada a "Pinza(valor pinza)" con una sola pinza.
b.Si hay más de un robot, utilice "Pinza(ID pinza, valor pinza, item.ptr)". Por ejemplo, "Pinza(2, 50, item.ptr)" moverá la pinza nº 2 de una pinza doble a 50 mm, asegurándose de que el robot padre está vinculado al programa.
3.Añada la instrucción Gripper() como primera instrucción de todos los subprogramas y después de todas las llamadas a subprogramas. Esto es para asegurar la compatibilidad con el postprocesador. Se esperan instrucciones Gripper() duplicadas.
4.Añada un script Python, cámbiele el nombre a "Gripper".
5.Edite el script Python "Gripper" y pegue lo siguiente:
from robodk import robolink
importar sys
si len(sys.argv) < 2:
abandonar()
def get_item(ptr_item, RDK):
item = robolink.Item(RDK, str(ptr_item), robolink.ITEM_TYPE_PROGRAM)
si no item.Valid(True):
devolver Ninguno
devolver artículo
RDK = robolink.Robolink()
gripper_id = -1
valor_agarre = 0
prog_item = Ninguno
# Obtener el ID de la pinza, el valor y el llamante
si len(sys.argv) == 2:
valor_agarre = float(sys.argv[1])
elif len(sys.argv) >= 4:
gripper_id = int(sys.argv[1])
valor_agarre = 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)
si prog_item:
valor_agarre = float(sys.argv[1])
si no:
gripper_id = int(sys.argv[1])
valor_agarre = float(sys.argv[2])
# Obtener candidatos
pinzas = [x for x in RDK.ItemList(robolink.ITEM_TYPE_ROBOT_AXES) if 'pinza' in x.Name().lower() and len(x.Joints().tolist()) == 1].
si len(pinzas) > 1 y prog_item:
robot_item = prog_item.getLink(robolink.ITEM_TYPE_ROBOT)
if not robot_item.Valid():
robot_item = RDK.ItemUserPick("Seleccione el robot vinculado", robolink.ITEM_TYPE_ROBOT)
prog_item.setRobot(robot_item)
def get_flat_childs(item):
childs = item.Childs()
para child en item.Childs():
childs.extend(get_flat_childs(child))
devolver childs
childs = get_flat_childs(robot_item)
pinzas = [x for x in childs if x.Type() == robolink.ITEM_TYPE_ROBOT and len(x.Joints().tolist()) == 1]
si no son pinzas:
RDK.ShowMessage('¡No se puede encontrar una pinza!', False)
# Intente encontrar el id de pinza correcto (es decir, pinza dual 1)
pinza = pinzas[0]
si gripper_id > 0:
gripper_ids = [g for g in pinzas if g.Nombre().endswith(str(gripper_id))]
si gripper_ids:
pinza = pinza_ids[0]
pinza.MoverJ([valor_pinza])
Tenga en cuenta que este método también es compatible con el postprocesador Brooks.
Raíles lineales
Dado que el bastidor base del robot PreciseFlex no se coloca en la base física del robot, se requieren compensaciones específicas entre los robots PreciseFlex y las guías lineales PreciseFlex.
Configuración del raíl lineal Brooks PreciseFlex:
a.Brooks PreciseFlex 400: [118, 0, 45,6, 0, 0, 0]
b.Brooks PreciseFlex 3400: [118, 0, 62,6, 0, 0, 0]
Carril lineal Brooks PreciseFlex -Configuración de 90 grados:
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 guía lineal debe estar sincronizada para que el postprocesador tenga en cuenta la posición del eje. Consulte la sección https://robodk.com/doc/en/General.html#SyncAxes para obtener más información.
Postprocesador
En esta sección se explican algunos consejos relacionados con la generación de programas para robots Brooks.
Punto central de herramientas (TCP)
El punto central de la herramienta (TCP) en RoboDK y en el controlador deben coincidir. Si utiliza un mecanismo de pinza, es necesario añadir un mediante "Añadir herramienta (TCP)" que se encuentre en la posición esperada. El nuevo TCP de la herramienta debe coincidir con el TCP del mecanismo de agarre. Puede encontrar información relacionada con el punto central de la herramienta (TCP) de los robots Brooks PreciseFlex accediendo a la interfaz web y siguiendo estos pasos:
1.Admin
2.Configuración - Base de datos de parámetros
3.Robot
4.Control conjunto/cartesiano
5.Parámetros dinámicos
6.ID de datos 16051
Gripper
Consulte la sección anterior Simulación de la pinza sobre cómo definir correctamente las instrucciones de la pinza compatibles con el postprocesador. Este enfoque define correctamente las ubicaciones en el proyecto GPL, evitando movimientos inesperados de los ejes de la pinza.
Redondeo
Un valor de entrada de -1 determina que el robot se detendrá al final del movimiento y se aplicará una restricción estricta de error de posición (código GPL: prof1.InRange = 100).
Un valor de entrada de 0 determina que el robot se detendrá al final del movimiento, pero se aplicará una pequeña restricción de error de posición (código GPL: prof1.InRange = 10).
Un valor de entrada superior a 0 determina que el robot no se detendrá al final del movimiento y se ejecutará un movimiento de mezcla (código GPL: prof1.InRange = -1).
Velocidad y aceleración
La información relativa a las velocidades/aceleraciones lineales, angulares y de articulación máximas de los robots Brooks PreciseFlex puede encontrarse accediendo a la interfaz web y siguiendo estos pasos:
1.Admin
2.Configuración - Base de datos de parámetros
3.Robot
4.Control conjunto/cartesiano
5.Parámetros dinámicos
6.DataIDs 2700, 2701, 2702 y 2703
El usuario puede establecer las entradas de las instrucciones de velocidad/aceleración de RoboDK utilizando los valores de los DataID anteriores como referencias. A continuación, el postprocesador de Precise utilizará estos valores para calcular la velocidad/aceleración como porcentajes de la velocidad/aceleración máxima de cada robot, tal y como solicita la clase de perfil GPL.
Para cambiar los límites utilizados por el postprocesador, puede modificarlo según el robot específico que esté utilizando. Por defecto, el postprocesador utiliza los límites de los robots PF400 y PF3400. Consulte la sección https://robodk.com/doc/en/Post-Processors.html#PPEditor de la documentación para modificar el postprocesador.
Si se utilizan valores de entrada inferiores a 1 con las instrucciones de aceleración lineal y angular, estas entradas se utilizarán como la duración en segundos de la rampa hasta el pico de aceleración/desaceleración (código GPL: prof1.AccelRamp/prof1.DecelRamp = inputvalue).
La siguiente imagen ofrece más información relacionada con los conceptos escritos anteriormente y cómo el controlador planifica las trayectorias que debe seguir el robot.
Pausa
Establecer un valor de entrada mayor que 0 generará un comando GPL que pausará el programa durante el tiempo definido por el valor de entrada. Un valor de entrada negativo abrirá un cuadro de diálogo emergente en el Panel de Control del Operador de la Interfaz Web y el programa quedará en pausa hasta que el usuario haga clic en el botón "Continuar" del cuadro de diálogo. Para visualizar el cuadro de diálogo, el usuario debe hacer clic en el botón "Diálogo activo" del Panel de control del operador.
Transferir programas vía FTP
Los programas pueden transferirse fácilmente a través de FTP desde RoboDK para robots Brooks:
1.Haga clic con el botón derecho en el robot en RoboDK
2.Seleccione Conectar al robot...
3.Introduzca la IP y el puerto del robot (el predeterminado es 192.168.0.1 con puerto 21)
4.Introduzca la ruta FTP remota (normalmente /flash/proyectos)
Una vez que un programa de RoboDK está listo para ser enviado al robot:
1.Haga clic con el botón derecho en un programa de RoboDK
2.Seleccione Enviar programa al robot (Ctrl+F6)
Esto generará el programa e intentará transferirlo al controlador del robot. Aparecerá una ventana mostrando si la transferencia FTP ha tenido éxito o no.
Iniciar un programa robot
Debe utilizarse la Interfaz Web del robot para cargar e iniciar el proyecto GPL (es posible acceder a la Interfaz Web del robot utilizando cualquier navegador y buscando la dirección IP del robot). A continuación se muestra una imagen de la página de inicio de la Interfaz Web.
1.Abra un navegador web
2.Introduzca la dirección IP del robot
Para iniciar el programa desde la Interfaz Web
1.Seleccione Admin -> Paneles de control -> Panel de control del operador -> "Cargar".
2.Seleccione el proyecto GPL creado con RoboDK
3.Haga clic en "Seleccionar".
4.Haga clic en "Inicio".
En este punto, el robot ejecutará el programa. A continuación se muestra una imagen que muestra la interfaz del panel de control del operador y la ventana que permite al usuario seleccionar y cargar el proyecto GPL necesario.
