Exemplos de modificação
Esta seção mostrará como você pode fazer pequenas alterações em um pós-processador existente. A maioria dos pós-processadores tem algumas variáveis que podem ser facilmente modificadas para alterar ou ativar recursos de programação de robôs específicos do fornecedor.
Como exemplo, as seguintes alterações serão feitas nos pós-processadores existentes da KUKA e da ABB:
●Gerar um programa com seus subprogramas como um arquivo e forçar os programas a terem, no máximo, 3.000 linhas de código por programa. Programas grandes serão divididos em programas menores e chamados sequencialmente.
●Defina um movimento joint para gerar o comando de movimento usando informações de ângulos de eixo.
●Substitua a velocidade máxima para 500 mm/s. Mesmo que o robô seja programado para se mover mais rápido, a velocidade será limitada a 500 mm/s no pós-processador.
As seções a seguir mostram como fazer as alterações sugeridas em um editor de texto.
Gerar todos os programas em um único arquivo
Este exemplo mostrará como você pode alterar o comportamento padrão do pós-processador KUKA KRC4 para gerar um programa principal com seus subprogramas no mesmo arquivo.
Certifique-se de que o plug-in Editor de pós-processadores esteja ativado e siga estas etapas para fazer as modificações no pós-processador:
1.Selecione Programa ➔ Editor de Pós-processadores.
2.Selecione o pós-processador que você deseja personalizar (KUKA KRC4).
3.Selecione OK. Uma nova janela será aberta e você verá as variáveis que pode modificar, conforme mostrado na imagem a seguir.
4.Defina a variável Incluir Sub-programas como Verdadeira em vez de Falsa.
5.Selecione Sallvar Pós-processador como...
6.Digite um novo nome para salvá-lo (o nome padrão usa a data de modificação).
Agora você deve ter um novo pós-processador na pasta Posts do RoboDK. Você pode atualizar seu projeto para usar esse novo pós-processador seguindo estas etapas:
1.Clique com o botão direito do mouse em seu robô.
2.Selecione Selecionar Pós-processador.
3.Selecione o novo pós-processador que você criou.
4.Gere seus programas novamente para ver o resultado.
Você também pode fazer essas alterações usando um editor de texto. Siga estas etapas para alterar o código Python padrão do pós-processador:
1.Selecione Programa ➔ Adicionar/Editar Pós-processador
2.Selecione seu pós-processador. Por exemplo, para o KUKA KRC4, selecione KUKA_KRC4.
3.Selecione OK. O pós-processador será mostrado em um editor de texto.
4.Defina a variável MAX_LINES_X_PROG como 3000.
5.Defina a variável INCLUDE_SUB_PROGRAMS como True.
Forçar um limite de velocidade
Este exemplo mostrará como você pode impor um limite de velocidade de 500 mm/s e evitar o uso de velocidades mais altas ao gerar um programa com o RoboDK.
Neste exemplo, presumimos que estamos usando um controlador KUKA KRC2 ou KRC4:
1.Selecione Programa ➔ Adicionar/Editar Pós-processador
2.Selecione seu pós-processador. Por exemplo, para o KUKA KRC4, selecione KUKA_KRC4.
3.Selecione OK. O pós-processador será mostrado em um editor de texto.
4.Localize a definição da função setSpeed (def setSpeed)
5.Add-in a seguinte linha para que a velocidade máxima seja de 500 mm/s. A linha precisa ser adicionada antes de gerar a saída $VEL.CP, que alterará a velocidade em m/s:
speed_mms = min(speed_mms, 500)
Filtro personalizado para frames
Esta seção mostra como você pode personalizar a definição do frame de referência de um pós-processador existente. Por exemplo, definir um frame de referência personalizado para um robô KUKA.
Você pode usar pós-processadores compilados e reimplementar facilmente apenas as funções necessárias (por exemplo, setFrame, setTool ou setSpeed).
Neste exemplo, supomos que você queira personalizar como a base é definida para um controlador KUKA. Por exemplo, se você quiser emitir a seguinte linha ao definir o frame de referência:
BASE_DATA[8] = {FRAME: X:2000, Y:0, Z:0, A:0, B:0, C:0}
BAS (#BASE,8)
Você só precisa criar um novo arquivo chamado KUKA_Custom_Post.py na pasta C:/RoboDK/Posts/ com as seguintes linhas, que usam o pós-processador padrão KUKA_KRC2 e substituem a configuração do frame de referência (função setFrame):
from KUKA_KRC2 import RobotPost as MainPost
classe 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)')
No entanto, poderíamos adicionar filtros personalizados com base em determinados critérios para filtrar entre o uso do comportamento padrão e o uso de uma implementação personalizada. O arquivo do pós-processador poderia então ser modificado da seguinte forma:
from KUKA_KRC2 import RobotPost as MainPost
classe RobotPost(MainPost):
def setFrame(self, pose, frame_id, frame_name):
"""Change the robot reference frame"""
if frame_name == "Frame 4": # Insira qualquer condição aqui
# Acionar a chamada para o método padrão (o mesmo que não substituir a função)
super(MainPost, self).setFrame(pose, frame_id, frame_name)
retorno
# Implementar um setFrame personalizado
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('; --------------------------')
Quando você gera programas para os controladores KUKA KRC, há muitas maneiras de definir o sistema de coordenadas ou o frame de referência. A seguinte definição de setFrame mostra uma implementação alternativa com diferentes opções:
def setFrame(self, pose, frame_id, frame_name):
"""Change the robot reference frame"""
self.addline('; ---- Referência de configuração: %s ----' % frame_name)
# Opção 1: Construir a cinemática com base na matriz MACHINE_DEF e no deslocamento fornecido
#self.addline('$BASE = EK (MACHINE_DEF[2].ROOT, MACHINE_DEF[2].MECH_TYPE, { %s })' % self.pose_2_str(pose))
# Opção 2: construir a cinemática com base na matriz EX_AX_DATA e no deslocamento fornecido
#self.addline('$BASE=EK(EX_AX_DATA[1].ROOT,EX_AX_DATA[1].EX_KIN, { %s })' % self.pose_2_str(pose))
# Opção 3: construir a cinemática com base na matriz EX_AX_DATA e no deslocamento predefinido
#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))
# Opção 4: usar a função de inicialização BAS(#ex_BASE) do arquivo BAS.src
#self.addline('; BASE_DATA[%i] = {FRAME: %s}' % (self.BASE_ID, self.pose_2_str(pose)))
#self.addline('BAS(#ex_BASE,%i)' % self.BASE_ID)
# Opção 5: Use a função de inicialização BAS(#BASE) do arquivo BAS.src
self.addline('; BASE_DATA[%i] = {FRAME: %s}' % (self.BASE_ID, self.pose_2_str(pose)))
self.addline('BAS (#BASE,%i)' % self.BASE_ID)
# Opção 6: Obter diretamente a base da matriz BASE_DATA (geralmente o que o BAS(#BASE) faz)
# self.addline('$BASE=BASE_DATA[%i]' % self.BASE_ID)
self.addline('; --------------------------')
Impor um movimento joint
Esta seção mostrará como você pode modificar um pós-processador existente para forçar um movimento joint usando valores de eixos em vez de valores cartesianos.
Neste exemplo, aplicaremos essa alteração a um controlador de robô ABB IRC5.
1.Encontre o manual de programação do controlador de seu robô. Neste exemplo, usamos o manual de programação do ABB IRC5 RAPID.
2.Procure as instruções de movimento joint. Nesse caso, o comando de movimento joint absoluto da ABB é chamado MoveAbsJ. Esse comando requer uma variável jointtarget que define os eixos da junta.
3.Selecione Programa ➔ Adicionar/Editar Pós-processador e selecione o pós-processador que você está usando no momento para modificá-lo. Se você estiver usando um pós-processador personalizável, ele será selecionado por padrão.
4.Você deve procurar a função MoveJ dentro do pós-processador. Essa função define a maneira como os pós-processadores geram os comandos de movimento joint. Como alternativa, o RoboDK usa o MoveL para movimentos lineares. Usando a linguagem de programação Python, modifique a linha que é adicionada ao arquivo de programa para fornecer informações sobre o ângulo da articulação, conforme mostrado na imagem a seguir.
5.Por fim, talvez você precise modificar a forma como o pós-processador converte os ângulos das articulações ou a pose em uma string. As funções angles_2_str e pose_2_str definem como os ângulos das articulações e uma pose, respectivamente, são convertidos em texto
A maioria dos pós-processadores do RoboDK usa ângulos de eixo para movimentos joint e coordenadas cartesianas para movimentos lineares. Recomenda-se sempre iniciar o primeiro ponto em uma sequência de movimentos lineares como um movimento joint, especificando os ângulos dos eixos. Isso evita iniciar um programa com a configuração errada do robô e atingir uma singularidade ou limites de eixo.
