Robôs Brooks
O RoboDK é compatível com os robôs PreciseFlex da Brooks usando a GPL (Linguagem de Programação de Orientação). Os usuários podem gerar programas avançados de automação de laboratório usando uma seleção de seus braços de robô, garras e trilhos lineares.
Simulação de garras
Para controlar as garras Brooks PreciseFlex IntelliGuide a partir de uma simulação, incluindo a garra IntelliGuide s23D (dupla), siga as etapas descritas nesta seção.
1.Clique com o botão direito do mouse em seu programa e adicione uma instrução de chamada de programa.
2.Digite "Gripper(gripper ID, gripper value)". Por exemplo, "Gripper(2, 50)" para mover a garra nº 2 de uma garra dupla para 50 mm.
a.O senhor pode encurtar a chamada para "Gripper(gripper value)" com um único gripper.
b.Se houver mais de um robô presente, use "Gripper(gripper ID, gripper value, item.ptr)". Por exemplo, "Gripper(2, 50, item.ptr)" moverá a garra nº 2 de uma garra dupla para 50 mm, garantindo que o robô pai esteja vinculado ao programa.
3.Add-in a instrução Gripper() como a primeira instrução de todos os subprogramas e após todas as chamadas de subprogramas. Isso é para garantir a compatibilidade com o pós-processador. São esperadas instruções Gripper() duplicadas.
4.Add-in um script Python, renomeie-o para "Gripper".
5.Edite o script Python "Gripper" e cole o seguinte:
from robodk import robolink
importar sys
Se len(sys.argv) < 2:
quit()
def get_item(ptr_item, RDK):
item = robolink.Item(RDK, str(ptr_item), robolink.ITEM_TYPE_PROGRAM)
if not item.Valid(True):
retornar Nenhum
item de devolução
RDK = robolink.Robolink()
gripper_id = -1
gripper_value = 0
prog_item = None
# Obter o ID da garra, o valor e, possivelmente, o chamador
Se len(sys.argv) == 2:
gripper_value = float(sys.argv[1])
elif len(sys.argv) >= 4:
gripper_id = int(sys.argv[1])
gripper_value = 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:
gripper_value = float(sys.argv[1])
E mais:
gripper_id = int(sys.argv[1])
gripper_value = float(sys.argv[2])
# Obter candidatos
garras = [x for x in RDK.ItemList(robolink.ITEM_TYPE_ROBOT_AXES) if 'intelliguide' in x.Name().lower() and len(x.Joints().tolist()) == 1]
se len(grippers) > 1 e prog_item:
robot_item = prog_item.getLink(robolink.ITEM_TYPE_ROBOT)
se não for robot_item.Valid():
robot_item = RDK.ItemUserPick("Select the linked robot", robolink.ITEM_TYPE_ROBOT)
prog_item.setRobot(robot_item)
def get_flat_childs(item):
childs = item.Childs()
for child in item.Childs():
childs.extend(get_flat_childs(child))
return childs
crianças = get_flat_childs(robot_item)
garras = [x for x in childs if x.Type() == robolink.ITEM_TYPE_ROBOT and len(x.Joints().tolist()) == 1]
se não forem garras:
RDK.ShowMessage('Não foi possível encontrar uma garra!', False)
# Tente encontrar a identificação correta da garra (ou seja, Dual Gripper 1)
garra = garras[0]
se gripper_id > 0:
gripper_ids = [g for g in grippers if g.Name().endswith(str(gripper_id))]
se gripper_ids:
garra = gripper_ids[0]
gripper.MoveJ([gripper_value])
Observe que esse método também é compatível com o pós-processador Brooks.
Trilhos lineares
Como a estrutura de base do robô PreciseFlex não é colocada na base física do robô, são necessários deslocamentos específicos entre os robôs PreciseFlex e os trilhos lineares PreciseFlex.
Trilho Linear Brooks PreciseFlex Configuração de 0 grau:
a.Brooks PreciseFlex 400: [118, 0, 45.6, 0, 0, 0, 0].
b.Brooks PreciseFlex 3400: [118, 0, 62,6, 0, 0, 0, 0].
Trilho Linear Brooks PreciseFlex - Configuração de 90 graus:
a.Brooks PreciseFlex 400: [101,6, 0, 45,6, 0, 0, 0, 0].
b.Brooks PreciseFlex 3400: [101,6, 0, 62,6, 0, 0, 0, 0].
O trilho linear deve ser sincronizado para que o pós-processador leve em conta a posição do eixo. Consulte a seção https://robodk.com/doc/en/General.html#SyncAxes para obter mais informações.
Para salvar corretamente os alvos no quadro de referência mundial do robô e usá-los posteriormente em um projeto GPL criado usando o pós-processador, o usuário deve definir um novo quadro de referência. Ele deve ser definido com relação ao quadro de referência da estação, com os mesmos deslocamentos usados anteriormente entre a base do robô e o trilho linear (conforme relatado acima). Os alvos devem ser definidos com relação a esse quadro de referência.
Abaixo está uma imagem que mostra um robô PreciseFlex 400 montado em um trilho linear de 1 m (na configuração de 0 grau) e o quadro de referência definido como o Quadro de Referência Mundial do robô.
Depois de gerar o projeto GPL, abra o arquivo Main.gpl usando qualquer editor de texto e comente a linha em que a estrutura de referência básica do robô é definida:
Brooks PreciseFlex c8A
Dada a cinemática exclusiva do robô PreciseFlex c8A da Brooks, seu modelo foi desenvolvido no RoboDK combinando dois modelos de robôs para lidar com os 3+3 graus de liberdade do braço robótico.
Esse desenvolvimento faz com que não seja possível usar os modelos dos robôs PreciseFlex c8A da Brooks em combinação com o pós-processador da Brooks.
Os robôs Brooks PreciseFlex c8A não são compatíveis com nenhuma das garras Brooks PreciseFlex IntelliGuide.
Se for necessário adicionar um ponto central da ferramenta (TCP), ele deverá ser definido com relação ao flange do mecanismo de pulso do robô. Observe as informações relatadas no parágrafo "Tool Center Point (TCP)" para definir a pose do TCP conforme configurado no controlador do robô.
Brooks PreciseFlex 100 XZTS
Da mesma forma que o robô Brooks PreciseFlex c8A, os robôs Brooks PreciseFlex 100 XZTS foram desenvolvidos pela combinação de dois modelos de robôs, aos quais foi adicionada a garra. Isso permite lidar com os três graus de liberdade do braço (movimentos lineares ao longo dos eixos X e Z e rotação Theta em torno do eixo Z) e com o grau de liberdade da garra.
O Brooks PreciseFlex 100 XZTS com 685 mm de amplitude de movimento no eixo X é mostrado abaixo.
Assim como o robô Brooks PreciseFlex c8A, os robôs Brooks PreciseFlex 100 XZTS não são compatíveis com o pós-processador.
Se for necessário adicionar um ponto central da ferramenta (TCP), ele deverá ser definido com relação ao flange do mecanismo Theta (rotação em torno do eixo Z) do robô.
Observe as informações relatadas no parágrafo "Tool Center Point (TCP)" para definir a pose do TCP conforme configurado no controlador do robô.
Pós-processador
Esta seção explica algumas dicas relacionadas à geração de programas para robôs Brooks.
Ponto central da ferramenta (TCP)
O ponto central da ferramenta (TCP) no RoboDK e o definido no controlador do robô devem corresponder. Se o senhor estiver usando um mecanismo de pinça, é necessário adicionar um TCP usando "Add Tool (TCP)" que esteja na posição esperada. O novo TCP da ferramenta deve corresponder ao TCP do mecanismo da garra. Para obter informações relacionadas ao ponto central da ferramenta (TCP) dos robôs Brooks PreciseFlex, acesse a interface da Web e siga estas etapas:
1.Administrador
2.Setup - Parameter Database (Configuração - Banco de dados de parâmetros)
3.Robô
4.Controle conjunto/cartesiano
5.Parâmetros dinâmicos
6.DataID 16051
Gripper
Consulte a seção anterior Simulação do gripper para saber como definir corretamente as instruções do gripper compatíveis com o pós-processador. Essa abordagem define corretamente os locais no projeto GPL, evitando movimentos inesperados do eixo ou eixos da garra.
As garras Brooks PreciseFlex IntelliGuide disponíveis são:
1.Brooks PreciseFlex IntelliGuide s23
2.Brooks PreciseFlex IntelliGuide s60
3.Brooks PreciseFlex IntelliGuide s23D
4.Brooks PreciseFlex IntelliGuide v23
5.Brooks PreciseFlex IntelliGuide v60
A estrutura de referência de base de cada uma das garras acima é definida de forma exclusiva. Para posicionar corretamente as garras em relação à estrutura de referência do flange dos robôs, as seguintes informações de posição de referência devem ser usadas:
IntelliGuide s23 | IntelliGuide s60 | IntelliGuide s23D | IntelliGuide v23 | IntelliGuide v60 | |
PreciseFlex 400 | [0.603,0,0,0,0,0] | N/A | N/A | [0,0,0,0,0,0] | N/A |
PreciseFlex 3400 | [0.033,0,0,0,0,0] | [0.033,0,0,0,0,0] | [0.033,0,0,0,0,0] | [-0.57,0,0,0,0,0] | [0,0,0,0,0,0] |
PreciseFlex DD 4 eixos | [-70.5,0,0,0,180,180] | [-70.5,0,0,0,180,180] | [-70.5,0,0,0,180,180] | [-71.1,0,0,0,180,180] | [-71.5,0,0,0,180,180] |
PreciseFlex c10 | [-82.5,0,0,0,180,180] | [-82.5,0,0,0,180,180] | [-82.5,0,0,0,180,180] | [-82.5,0,0,0,180,180] | [-82.5,0,0,0,180,180] |
PreciseFlex c3 | [0.313,0,0,0,0,0] | [0.313,0,0,0,0,0] | [0.313,0,0,0,0,0] | [-0.291,0,0,0,0,0] | [0.279,0,0,0,0,0] |
PreciseFlex c3x | [-14.655,0,0,0,0,0] | [-14.655,0,0,0,0,0] | [-14.655,0,0,0,0,0] | [-15.258,0,0,0,0,0] | [-14.688,0,0,0,0,0] |
PreciseFlex c5 | [113,0,0,0,0,0] | [113,0,0,0,0,0] | [113,0,0,0,0,0] | [112.4,0,0,0,0,0] | [113,0,0,0,0,0] |
No que se refere aos robôs Brooks PreciseFlex DD de 4 eixos e c10, o flange IntelliGuide ISO disponível na Biblioteca de robôs deve ser adicionado ao robô para fins de visualização (no caso do robô DD de 4 eixos, a geometria do flange IntelliGuide ISO deve ser movida 9 mm para cima).
Arredondando
Um valor de entrada de -1 determina que o robô parará no final do movimento e uma restrição de erro de posição rigorosa será aplicada (código GPL: prof1.InRange = 100).
Um valor de entrada de 0 determina que o robô parará no final do movimento, mas uma pequena restrição de erro de posição será aplicada (código GPL: prof1.InRange = 10).
Um valor de entrada maior que 0 determina que o robô não parará no final do movimento e um movimento combinado será executado (código GPL: prof1.InRange = -1).
Velocidade e aceleração
Para obter informações relacionadas às velocidades/acelerações máximas lineares, angulares e das articulações dos robôs Brooks PreciseFlex, acesse a interface da Web e siga estas etapas:
1.Administrador
2.Setup - Parameter Database (Configuração - Banco de dados de parâmetros)
3.Robô
4.Controle conjunto/cartesiano
5.Parâmetros dinâmicos
6.DataIDs 2700, 2701, 2702 e 2703
O usuário pode definir as entradas das instruções de velocidade/aceleração do RoboDK usando os valores dos DataIDs acima como referências. O pós-processador do Precise usará esses valores para calcular a velocidade/aceleração como porcentagens da velocidade/aceleração máxima de cada robô, conforme solicitado pela classe GPL Profile.
Para alterar os limites usados pelo pós-processador, o senhor pode modificar o pós-processador de acordo com o robô específico que estiver usando. Por padrão, o pós-processador utiliza os limites dos robôs PreciseFlex 400 e PreciseFlex 3400. Consulte a seção https://robodk.com/doc/en/Post-Processors.html#PPEditor da documentação para modificar o pós-processador.
Se os valores de entrada menores que 1 forem usados com instruções de aceleração linear e angular, essas entradas serão usadas como a duração em segundos para a rampa até o pico de aceleração/desaceleração (código GPL: prof1.AccelRamp/prof1.DecelRamp = valor de entrada).
A imagem abaixo fornece mais informações relacionadas aos conceitos descritos acima e como o controlador planeja as trajetórias que o robô deve seguir.
Pausa
A definição de um valor de entrada maior que 0 gerará um comando GPL que pausará o programa durante o tempo definido pelo valor de entrada. Um valor de entrada negativo abrirá uma caixa de diálogo pop-up no painel de controle do operador da interface da Web e o programa será pausado até que o usuário clique no botão "Continue" (Continuar) na caixa de diálogo. Para visualizar a caixa de diálogo, o usuário precisa clicar no botão "Dialog Active" (Diálogo ativo) no Painel de controle do operador.
Transferência de programas via FTP
Os programas podem ser facilmente transferidos via FTP do RoboDK para os robôs Brooks:
1.Clique com o botão direito do mouse no robô no RoboDK
2.Selecione Conectar ao robô...
3.Digite o IP e a porta do robô (o padrão é 192.168.0.1, com a porta 21)
4.Digite o caminho do FTP remoto (normalmente /flash/projects)
Quando o programa do RoboDK estiver pronto para ser enviado ao robô, o senhor poderá enviar o programa ao robô:
1.Clique com o botão direito do mouse em um programa no RoboDK
2.Selecione Enviar programa para o robô (Ctrl+F6)
Isso gerará o programa e tentará transferi-lo para o controlador do robô. Aparecerá uma janela mostrando se a transferência FTP foi bem-sucedida ou não.
Iniciar um programa de robô
A interface da Web do robô deve ser usada para carregar e iniciar o projeto GPL (é possível acessar a interface da Web do robô usando qualquer navegador e pesquisando o endereço IP do robô). Abaixo está uma imagem da página inicial da interface da Web.
1.Abrir um navegador da Web
2.Digite o endereço IP do robô
Para iniciar o programa a partir da interface da Web
1.Selecione Admin -> Control Panels -> Operator Control Panel -> "Load".
2.Selecione o projeto GPL criado com o RoboDK
3.Clique em "Select" (Selecionar)
4.Clique em "Start" (Iniciar)
Nesse momento, o robô executará o programa. Abaixo está uma imagem que mostra a interface do Painel de Controle do Operador e a janela que permite ao usuário selecionar e carregar o projeto GPL necessário.
