Pós-processadores
Os pós-processadores são uma etapa fundamental da programação off-line porque podem gerar programas de robô para um controlador de robô específico. A programação do robô deve seguir as regras de programação específicas do fornecedor e essas regras são implementadas no pós-processador. Um pós-processador de robô define como os programas de robô devem ser gerados para um controlador de robô específico.
A conversão da simulação do RoboDK em um programa de robô específico é feita por um pós-processador. Cada robô é vinculado a um pós-processador que definirá um estilo específico de programação do robô. O pós-processador é usado quando o programa é gerado off-line, conforme mostrado na seção Generate Program (clicando com o botão direito do mouse em um programa e selecionando Generate Robot Program).
O RoboDK inclui muitos pós-processadores para suportar mais de 50 fabricantes e controladores de robôs diferentes. Os controladores compatíveis estão listados na seção Pós-processadores disponíveis. Como alternativa, é possível criar um pós-processador personalizado ou modificar um pós-processador existente. Todos os pós-processadores disponíveis estão na pasta: C:/RoboDK/Posts/.
Um pós-processador é um arquivo PY (cada pós-processador é definido por um script Python). É possível adicionar, modificar ou excluir manualmente os arquivos na pasta Posts do RoboDK. Se o senhor tiver recebido um pós-processador do RoboDK (arquivo PY), ele deverá ser colocado na pasta Posts para que possa ser selecionado no RoboDK.
Esta seção mostra como selecionar, editar ou criar um pós-processador e usá-lo com seus robôs no RoboDK. Uma rápida introdução está disponível no seguinte vídeo: https://www.robodk.com/help#PostProcessor
Selecione um pós-processador
O senhor pode selecionar facilmente um pós-processador clicando com o botão direito do mouse em um robô ou programa. A escolha de um pós-processador é atribuída a um robô, portanto, a alteração do pós-processador atribuído a um programa atualizará o pós-processador usado por todos os programas atribuídos ao mesmo robô.
Para selecionar um pós-processador para um robô:
1.Clique com o botão direito do mouse em um robô ou programa
2.Selecione Select Post Processor
3.Escolha um pós-processador na lista
4.Selecione OK.
A alteração foi aplicada e o programa pode ser gerado novamente para ver o resultado.
Como alternativa, também é possível selecionar o pós-processador seguindo estas etapas:
1.Abra o painel do robô (clique duas vezes em um robô)
2.Selecionar parâmetros
3.Selecione seu pós-processador na caixa de marca do robô, conforme mostrado na imagem a seguir.
Post Processor Editor
É possível modificar facilmente as configurações do pós-processador usando uma interface gráfica de usuário. O editor do pós-processador permite que o senhor modifique as variáveis definidas no pós-processador que são específicas do controlador do robô.
O editor de pós-processadores é um plug-in que ajuda a personalizar seus pós-processadores. O senhor pode fazer o download e instalar facilmente o plug-in na seguinte página: https://robodk.com/addin/com.robodk.plugin.postprocessoreditor.
Siga estas etapas para abrir o editor do pós-processador:
1.Selecione Program➔ Post Processor Editor.
2.Selecione o pós-processador que o senhor deseja personalizar.
3.Selecione OK. Uma nova janela será aberta e o senhor verá as variáveis que pode modificar.
4.Selecione Save Post Processor as...
5.Digite o nome para salvá-lo.
Por exemplo, se o senhor selecionar o pós-processador Fanuc R30iA, verá a janela mostrada na imagem anterior.
Modificar um pós-processador
O senhor pode modificar os pós-processadores existentes no RoboDK para personalizar a saída dos programas do seu robô ou criar novos pós-processadores. A maioria dos pós-processadores não precisa ser editada, basta alterar os sinalizadores de configuração para obter o resultado desejado do programa.
Certifique-se de que o senhor tenha o código-fonte do pós-processador para editá-lo. Entre em contato conosco se o pós-processador que está tentando editar não for editável (compilado).
Os pós-processadores devem ser colocados na pasta C:/RoboDK/Posts/ para que possam ser selecionados no RoboDK. A seção anterior descreve como vincular um robô específico a um pós-processador.
Cada pós-processador é um arquivo PY. É possível renomear o arquivo ou copiar arquivos de/para a pasta C:/RoboDK/Posts/ para compartilhar diferentes pós-processadores. Para excluir um script de pós-processador existente, basta excluir o arquivo PY correspondente na pasta Posts.
Os pós-processadores podem ser editados usando qualquer editor de texto ou um editor Python (Python IDLE). O uso do editor Python permite depurar e avaliar rapidamente um programa de amostra no final do arquivo.
O Python deve ser instalado para testar e usar os pós-processadores corretamente (o Python é instalado por padrão com o RoboDK).
Siga estas etapas para modificar um pós-processador existente:
1.Selecione Program➔ Add/Edit Post Processor
2.Selecione um pós-processador existente
3.Selecione OK. Um editor de texto e o programa serão abertos.
4.Selecione Go➔ Debug (F5) para visualizar o resultado. Se necessário, faça alterações. Dependendo do editor de texto que estiver usando, talvez seja necessário selecionar Run➔ Run module (F5).
Como alternativa, é possível editar um pós-processador manualmente:
1.Vá para a pasta de pós-processadores: C:/RoboDK/Posts/
2.Abra um arquivo PY com o Python IDLE (clique com o botão direito do mouse em➔ Edit with IDLE) ou outro editor de texto.
3.Faça as alterações desejadas.
4.Execute o arquivo para testar o resultado: Selecione Run➔ Executar módulo (F5 por padrão) no Python IDLE.
Como alternativa, é possível editar esse arquivo usando um editor de texto e executá-lo com o Python clicando duas vezes nele.
Exemplos de modificação
Esta seção mostrará como o senhor 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 de articulação para gerar o comando de movimento usando informações de ângulos de articulação.
●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 o senhor 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 do editor do pós-processador esteja ativado e siga estas etapas para fazer as modificações no pós-processador:
1.Selecione Program➔ Post Processor Editor.
2.Selecione o pós-processador que o senhor deseja personalizar (KUKA KRC4).
3.Selecione OK. Uma nova janela será aberta e o senhor verá as variáveis que pode modificar, conforme mostrado na imagem a seguir.
4.Defina a variável Include Sub Programs como True em vez de False.
5.Selecione Save Post Processor as...
6.Digite um novo nome para salvá-lo (o nome padrão usa a data de modificação).
Agora o senhor deve ter um novo pós-processador na pasta Posts do RoboDK. Agora, o senhor 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 Select Post Processor.
3.Selecione o novo pós-processador que o senhor criou.
4.Gere seus programas novamente para ver o resultado.
O senhor 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 Program➔ Add/Edit Post Processor
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 o senhor 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 Program➔ Add/Edit Post Processor
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 quadros
Esta seção mostra como o senhor pode personalizar a definição do quadro de referência de um pós-processador existente. Por exemplo, definir um quadro de referência personalizado para um robô KUKA.
O senhor 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 o senhor queira personalizar como a base é definida para um controlador KUKA. Por exemplo, se o senhor quiser emitir a seguinte linha ao definir o quadro de referência:
BASE_DATA[8] = {FRAME: X:2000, Y:0, Z:0, A:0, B:0, C:0}
BAS (#BASE,8)
O senhor 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 quadro 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 o senhor gera programas para os controladores KUKA KRC, há muitas maneiras de definir o sistema de coordenadas ou o quadro 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 usando ângulos de articulação
Esta seção mostrará como senhor pode modificar um pós-processador existente para forçar um movimento axial usando valores de junta 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 da articulação. Nesse caso, o comando de movimento de articulação absoluto da ABB é chamado MoveAbsJ. Esse comando requer uma variável jointtarget que define os eixos da junta.
3.Selecione Program➔ Add/Edit Post Processor e selecione o pós-processador que o senhor está usando no momento para modificá-lo. Se o senhor estiver usando um pós-processador personalizável, ele será selecionado por padrão.
4.O senhor 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 da articulação. 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 o senhor 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 dados de articulação para movimentos de articulação e coordenadas cartesianas para movimentos lineares. Recomenda-se sempre iniciar o primeiro ponto em uma sequência de movimentos lineares como um movimento de articulação, especificando as coordenadas da articulação. Isso evita iniciar um programa com a configuração errada do robô e atingir uma singularidade ou limites de eixo.
Pós-processadores disponíveis
O RoboDK fornece mais de 100 pós-processadores por padrão para dar suporte à geração de programas de robôs para mais de 40 fabricantes de robôs. Alguns pós-processadores podem ser ainda mais personalizados para gerar programas com um formato específico
O senhor pode encontrar a lista completa de pós-processadores disponíveis na Biblioteca do RoboDK navegando até https://robodk.com/posts. O senhor também pode selecionar Tools➔ Open Robot Library na barra de ferramentas principal do RoboDK.
Por padrão, os seguintes pós-processadores estão disponíveis no RoboDK:
●ABB RAPID IRC5: para controladores de robôs ABB IRC5.
●ABB RAPID IRC5 Robtargets: para controladores de robôs ABB IRC5 e gera nomes de robtargets.
●ABB RAPID S4C: para controladores de robôs ABB S4C.
●Adept Vplus: para a linguagem de programação Adept V+.
●Allen Bradley Logix5000: para PLC Allen Bradley Logix5000.
●Annin Robotics: para robôs AR3 e AR4.
●Aubo: para controladores de robôs AUBO.
●Aubo ARCS: gera código (.lua e .pro) para os controladores robóticos AUBO ARCS.
●Automata: para os robôs EVA da Automata.
●Borunte: para braços de robô Borunte. Gera um pacote zip com os arquivos necessários para os controladores de robôs BRTIRUS.
●Brooks: para robôs PreciseFlex.
●CPR: produz código formatado em XML adequado para sistemas robóticos CPR.
●CSV: gera arquivos simples em formato CSV para controladores genéricos de robótica e automação. Esse pós-processador é versátil e pode ser usado em aplicativos que exigem importação e exportação simples de dados.
●CLOOS: para controladores de robôs CLOOS.
●Comau C5G: para controladores de robôs Comau C5G.
●Denso PAC: para controladores de robôs Denso RC7 (e mais antigos) (linguagem de programação PAC).
●Denso RC8: para controladores de robôs Denso RC8 (e mais recentes) (linguagem de programação PacScript).
●Dobot: para robôs educacionais Dobot.
●Doosan: para robôs colaborativos da Doosan.
●Elite: O pós-processador Elite Robots CS Task permite que o senhor gere códigos para controladores CS.
●Epson: para controladores de robôs Epson.
●Fairino: produz arquivos .lua e oferece suporte à série de robôs Fairino FR.
●Fanuc R30iA: para os controladores de robôs Fanuc R30iA e R30iB.
●Fanuc R30iA_Arc: para soldagem a arco Fanuc.
●Fanuc RJ3: para controladores de robôs Fanuc RJ3.
●GCode BnR: para controladores de robôs B&R.
●GSK: para os robôs da GSK.
●HCR: para controladores de robôs Hanwha.
●HIWIN HRSS: para robôs HIWIN.
●Hyundai: para controladores de robôs Hyundai.
●KAIRO: para controladores de robôs Keba Kairo.
●Kinova: para robôs Kinova.
●Kawasaki: para controladores de robôs Kawasaki AS.
●KUKA IIWA: para a programação sunrise do KUKA IIWA em Java.
●KUKA KRC2: para os controladores de robôs KUKA KRC2.
●KUKA KRC2_CamRob: para a opção de fresagem KUKA CamRob.
●KUKA KRC2_DAT: para controladores de robôs KUKA KRC2, incluindo arquivos de dados DAT.
●KUKA KRC4: para os controladores de robôs KUKA KRC4.
●KUKA KRC4_Config: para controladores de robôs KUKA KRC4 com dados de configuração em cada linha.
●KUKA KRC4_DAT: para controladores de robôs KUKA KRC4, incluindo arquivos de dados DAT.
●Mecademic: para o código de script da Mecademic exigido pelo robô Meca500.
●Mecademic Python: gera um script Python que pode controlar remotamente o robô Mecademic Meca500.
●Mitsubishi: para controladores de robôs da Mitsubishi.
●Motoman/Yaskawa: para diferentes controladores de robôs Motoman usando o Inform II e o Inform III (JBI).
●Nachi AX FD: para os controladores de robôs Nachi AX e FD.
●Omron: para controladores de robôs Omron/Techman.
●OTC: para controladores de robôs OTC da Daihen.
●Panasonic: Para programas PRG da Panasonic (requer ferramentas Panasonic G2PC para compilar arquivos ASCII em arquivos binários).
●Robostar: para controladores de robôs Robostar.
●Siasun: para controladores de robôs Siasun.
●Siemens_Sinumerik: para o controlador de robô Siemens Sinumerik ROBX.
●Staubli VAL3: para gerar programas de robô Staubli VAL3 (controladores CS8 e posteriores). Ele faz o inline dos movimentos do robô.
●Staubli VAL3_Machining: para controladores Staubli VAL3 que têm a opção Machining HSM.
●Staubli S6: para controladores de robôs Staubli S6.
●Toshiba: para robôs da Toshiba.
●Techman: para controladores de robôs Omron/Techman.
●Universal Robots: para robôs UR, ele gera movimentos lineares como alvos de pose.
●Universal Robots URP: para robôs UR, gera um URP que pode ser carregado e modificado no Polyscope (o controlador de robôs UR).
●Universal Robots_RobotiQ: para robôs UR, incluindo suporte para a garra RobotiQ.
●Universal Robots_MoveP: para robôs UR, gera movimentos lineares como comandos MoveP.
●Yamaha: para robôs Yamaha.
Referência
Esta seção inclui referências úteis relacionadas a pós-processadores.
O vídeo a seguir mostra uma visão geral dos pós-processadores no RoboDK: https://robodk.com/help#PostProcessor
A documentação de referência para cada método no pós-processador está disponível na seção API do RoboDK da documentação: http://robodk.com/doc/en/PythonAPI/postprocessor.html
A maioria dos pós-processadores usa o módulo robodk.py: http://robodk.com/doc/en/PythonAPI/robodk.html#robodk.Mat. O módulo robodk.py fornece ferramentas para operações de pose (multiplicações, inversas, ...) e conversões entre poses e ângulos de Euler em diferentes formatos, entre outras coisas.
A documentação está disponível on-line para que o senhor aprenda sobre a programação Python:
https://docs.python.org/3/
Quando um programa é gerado, um programa Python pré-processado/universal é gerado e salvo em uma pasta temporária local. O programa pré-processado é vinculado ao pós-processador correto (selecionado pelo usuário no RoboDK). O pós-processador define uma classe RobotPost que gera o código desejado.
Os programas pré-compilados são executados com o Python.
