Filtragem de programas

Uma vez que o robô tenha sido calibrado, você tem diferentes maneiras de usar a calibração do robô:

●Filtrar programas existentes: todos os pontos do robô dentro de um programa são modificados para melhorar a precisão do robô. Isso pode ser feito manualmente ou usando a API.

●Use o RoboDK para programação off-line para gerar programas precisos (os programas gerados já estão filtrados, incluindo os programas gerados usando a API).

Para filtrar um programa existente manualmente: arraste e solte o arquivo do programa do robô na tela principal do RoboDK (ou selecione Arquivo➔ Abrir) e selecione Filtrar apenas. O programa será filtrado e salvo na mesma pasta. O resumo do filtro mencionará se houve algum problema ao usar o algoritmo de filtragem. Você também tem a opção de importar um programa se quiser simulá-lo dentro do RoboDK. Se o programa tiver alguma dependência (definições de estrutura de ferramentas ou estrutura de base, subprogramas, ...), elas deverão estar localizadas no mesmo diretório em que o primeiro programa for importado.

Depois de importar o programa para o RoboDK, você pode gerá-lo novamente com ou sem precisão absoluta. Nas configurações principais de precisão do RoboDK (Ferramentas ➔ Opções ➔ Precisão), você pode decidir se deseja sempre gerar os programas usando a cinemática precisa, se deseja que o RoboDK pergunte todas as vezes ou se deseja usar a cinemática atual do robô. A cinemática atual do robô pode ser alterada clicando com o botão direito do mouse no robô e ativando/desativando a tag "Usar cinemática precisa". Se ela estiver ativa, você verá um ponto verde; se não estiver ativa, verá um ponto vermelho.

Filtrar programas usando a API

É possível filtrar um programa completo usando o RoboDK com um robô calibrado e o programa do robô usando a chamada FilterProgram:

robot.FilterProgram(Arquivo_program)

Um exemplo de macro chamado FilterProgram está disponível na seção Macros da biblioteca. O código a seguir é um exemplo de script Python que usa a API do RoboDK para filtrar um programa.

from robolink import *     # API para se comunicar com o RoboDK

from robodk import *       # operações básicas de matriz

import os                 # Operações de caminho

# Obter o diretório de trabalho atual

CWD= os.path.dirname(os.path.realpath(__file__))

# Inicie o RoboDK se ele não estiver em execução e vincule-o à API

RDK = Robolink()

# Opcional: forneça os seguintes argumentos para execução nos bastidores

#RDK= Robolink(args='/NOSPLASH /NOEXIBIR /HIDDEN')

# Obtenha a estação calibrada (arquivo .rdk) ou o arquivo do robô (.robot):

# Dica: após a calibração, clique com o botão direito do mouse em um robô e selecione "Save as .robot" (Salvar como .robô)

calibration_Arquivo= CWD+ '/KUKA-KR6.rdk'

# Obter o arquivo do programa:

Arquivo_program= CWD+ '/Prog1.src'

# Carregue o arquivo RDK ou o arquivo do robô:

calib_item= RDK.AddArquivo(calibration_Arquivo)

se não for calib_item.Valid():

    raise Exception("Something went wrong loading "+ calibration_Arquivo)

# Recupere o robô (não haverá pop-up se houver apenas um robô):

robot= RDK.ItemUserPick('Select a robot to filter', ITEM_TYPE_ROBOT)

se não for robot.Valid():

    raise Exception("Robot not selected or not available")

# Ativar a precisão

robot.setAccuracyActive(1)

# Filtrar programa: isso salvará automaticamente uma cópia do programa

# com um arquivo renomeado, dependendo da marca do robô

status, summary= robot.FilterProgram(file_program)

se o status== 0:

    print("Program filtering succeeded")

    print(summary)

    calib_item.Delete()

    RDK.CloseRoboDK()

E mais:

    print("A filtragem do programa falhou! Código de erro: %i" % status)

    print(summary)   

    RDK.ExibirRoboDK()

Filtrar pontos usando a API

O código a seguir é um exemplo de script Python que usa a API do RoboDK para filtrar um ponto (ponto de pose ou ponto joint), usando o comando FilterTarObter:

pose_filt, joints = robot.FilterTarObter(nominal_pose, estimated_joints)

Esse exemplo é útil se um aplicativo de terceiros (que não seja o RoboDK) gerar o programa do robô usando pontos de pose.

from robolink import *     # API para se comunicar com o RoboDK

from robodk import *       # operações básicas de matriz

def XYZWPR_2_Pose(xyzwpr):

    return KUKA_2_Pose(xyzwpr) # Converta X,Y,Z,A,B,C em uma pose

def Pose_2_XYZWPR(pose):

    return Pose_2_KUKA(pose) # Converta uma pose em X,Y,Z,A,B,C

# Inicie a API do RoboDK e recupere o robô:

RDK= Robolink()

robô= RDK.Item('', ITEM_TYPE_ROBOT)

se não for robot.Valid():

    raise Exception("Robot not available")

pose_tcp= XYZWPR_2_Pose([0, 0, 200, 0, 0, 0, 0]) # Define o TCP

pose_ref= XYZWPR_2_Pose([400, 0, 0, 0, 0, 0, 0]) # Define o frame de referência

# Atualizar o TCP do robô e o frame de referência

robot.setTool(pose_tcp)

robot.setFrame(pose_ref)

# Muito importante para SolveFK e SolveIK (cinemática direta/inversa)

robot.setAccuracyActive(False) # A precisão pode ser ativada ou desativada

# Definir um ponto nominal no espaço da articulação:

articulações= [0, 0, 90, 0, 90, 0]

# Calcular a posição nominal do robô para o ponto da articulação:

pose_rob= robot.SolveFK(joints) # flange do robô em relação à base do robô

# Calcular pose_ponto: o TCP em relação ao frame de referência

pose_tarObter= invH(pose_ref)*pose_rob*pose_tcp

print('TarObter not filtered:')

print(Pose_2_XYZWPR(pose_tarObter))

joints_approx= joints # joints_approx deve estar dentro de 20 graus

pose_tarObter_filt, real_joints= robot.FilterTarObter(pose_tarObter, joints)

print('TarObter filtered:')

print(real_joints.tolist())

print(Pose_2_XYZWPR(pose_tarObter_filt))