Universal Robots

Os Universal Robots (UR) podem ser programados com o RoboDK usando dois métodos diferentes: Arquivos URP e arquivos de script.

1.A interface gráfica do usuário (arquivos URP): Os programas URP são criados usando a tela sensível ao toque do terminal de programação do robô. Um programa URP pode ter um ou mais arquivos SCRIPT como subprogramas. Os programas URP são transformados em programas SCRIPT nos bastidores do controlador do robô antes da execução.

2.Arquivos de script: Os programas de script usam a linguagem de programação UR Script. Como qualquer outra linguagem de programação, o UR Script tem variáveis, tipos, fluxo de instruções de controle, função etc. Além disso, o UR Script tem várias variáveis e funções integradas que controlam a E/S e os movimentos do robô.

Com o RoboDK, Você pode gerar arquivos SCRIPT e URP que podem ser executados por um robô UR. Além disso, é possível executar programas no robô a partir do RoboDK se o robô estiver conectado ao computador.

O RoboDK também pode importar arquivos SCRIPT para o simulador. Isso permite que Você simule programas SCRIPT, modifique-os e reexporte-os.

A interface gráfica do usuário de um robô UR é chamada de PolyScope (como mostrado na imagem a seguir).

Recuperar o IP do robô UR

O IP do robô é necessário para executar programas diretamente do simulador RoboDK. Também é possível transferir arquivos de programa por FTP.

O IP do robô pode ser recuperado no menu About (Sobre) na tela principal do terminal de programação do UR.

O robô deve estar conectado ao computador por meio de uma conexão Ethernet (conexão direta ou por meio de uma rede). Um teste de ping permite testar se o link de rede foi estabelecido corretamente.

Executar o programa a partir do RoboDK

Os drivers do robô oferecem uma alternativa à programação off-line (em que um programa é gerado e, em seguida, transferido para o robô e executado). Você pode executar uma simulação do RoboDK diretamente no robô (Programação Online). Mais informações estão disponíveis na seção Robot Drivers.

Siga estas etapas para se conectar ao robô a partir do RoboDK:

1.Clique com o botão direito do mouse no robô no RoboDK

2.Selecione:  Conectar ao robô...

3.Digite o IP do robô

4.Selecione Conectar.

Deve haver uma mensagem verde exibindo Pronto se a conexão for bem-sucedida.

O robô pode ser movido selecionando Obter posições de eixo do robô, Mover eixos e Mover linear no menu de conexão.

Há dois métodos diferentes para executar o programa do PC para o robô:

1.Executar no robô, passo a passo, com feedback no RoboDK (Programação on-line):          
Esse método usa o robô como um servidor e cada instrução é enviada ao robô passo a passo à medida que é executada no simulador. Esse método é útil para fins de depuração.

a.Clique com o botão direito do mouse no programa (Print3D, neste exemplo)

b.Selecione Executar no robô

c.Clique duas vezes no programa para iniciá-lo (ou clique com o botão direito do mouse e selecione Executar)

Quando essa opção estiver marcada, ela se conectará ao robô real sempre que clicarmos duas vezes em um programa (ou clicarmos com o botão direito do mouse e selecionarmos Executar)

Essas operações também estão disponíveis na API do RoboDK e permitem a integração da programação do robô com outros aplicativos. A API está disponível em Python, C# e outras linguagens de programação.

2.Enviar programa para o robô gera o programa completo, transfere-o para o robô e inicia o programa no robô real (Programação Offline):

a.Clique com o botão direito do mouse no programa (Print3D, neste exemplo)

b.Selecione Enviar programa para o robô (Ctrl+F6).

Como ativar o controle remoto no URe

Você deve ativar a opção Remote Control no controlador do robô UR se tiver um robô URe (UR3e, UR5e ou UR10e).

Siga estas etapas para ativar o controle remoto da URe:

1.Selecione o menu Settings (Configurações) no botão superior direito

2.Selecione System-Remote Control (Controle remoto do sistema)

3.Selecione Enable (Ativar)

4.Altere o modo de operação para Remote Control (Controle remoto)

Executar um programa no controlador UR

Quando a simulação do RoboDK estiver pronta, você poderá gerar um SCRIPT e/ou um programa URP. Esses dois arquivos podem ser executados pelo controlador do robô. Siga estas etapas para gerar um SCRIPT e um programa URP a partir da simulação do robô:

1.Clique com o botão direito do mouse em um programa (Print3D, neste exemplo)

2.Selecione Gerar programa do robô F6

O programa será exibido em um editor de texto (esse comportamento pode ser alterado no menu: Ferramentas➔ Opções➔ Programa).

A transferência dos arquivos SCRIPT e URP pode ser feita por meio de transferência SFTP ou de uma unidade USB.

Como carregar um programa URP

As etapas a seguir resumem o procedimento para carregar um arquivo URP no robô da Universal Robots.

1.Clique com o botão direito do mouse no programa e selecione Selecionar Pós-processador

2.Selecione Universal Robots URP   
Essas duas primeiras etapas são opcionais, pois o pós-processador padrão também gera um arquivo URP; no entanto, isso permitirá que você gere um programa URP legível pelo usuário em vez de um programa URP que executa um arquivo de script.

3.Clique com o botão direito do mouse no programa e selecione Gerar programa do robô (F6)

4.Salve o(s) arquivo(s) URP gerado(s) em um disco de memória USB.

5.Conecte o disco de memória USB ao terminal de programação do robô (Polyscope da UR)

6.No terminal de programação do robô: Selecione a guia Run (Executar)

7.Selecione Load Program e carregue o programa gerado pelo RoboDK

8.Selecione a guia Program e selecione o botão Play para iniciá-lo

9.Selecione o botão Play para iniciar o programa.

Como carregar um arquivo de script

As etapas e imagens a seguir resumem o procedimento para executar um programa SCRIPT no robô. Essas etapas não são necessárias para executar um arquivo de programa URP:

1.Selecione Program Robot na tela principal da botoeira de aprendizagem

2.Selecione Empty Program

3.Selecione a guia Structure (Estrutura)

4.Selecione a guia Advanced (Avançado)

5.Selecione o código do script

6.Selecione File (como mostrado na imagem)

7.Selecione o arquivo de script gerado pelo RoboDK

8.Selecione o ícone de reprodução para executar o programa

9.Selecione File➔ Save para salvar as alterações.

10.Por fim, o programa pode ser executado

Transferir um programa (FTP)

Um programa SCRIPT gerado a partir do RoboDK (por exemplo, pressionando F6) pode ser transferido para o robô usando um disco USB ou por transferência FTP se o robô e o computador estiverem conectados.

Recomenda-se instalar o FileZilla Client no caminho padrão ou diretamente dentro da pasta de instalação do RoboDK para que ele seja detectado automaticamente pelo RoboDK:

C:\RoboDK\FileZilla FTP Client\

Para transferir um arquivo por FTP:

1.Clique com o botão direito do mouse em um robô

2.Selecione Conectar ao robô...

3.Selecione Explore. O FileZilla Client será aberto (software para transferência FTP).

4.Selecione File➔ Site Manager...

5.Selecione Universal Robots sample, em Predefined Sites.

6.Selecione Duplicate (Duplicar). Será criada uma cópia da configuração do Universal Robots.

7.Digite o IP do robô (192.168.1.66 neste exemplo).

8.Selecione Connect (Conectar).

9.Transfira o arquivo SCRIPT gerado anteriormente para o robô.

Os programas SCRIPT geralmente são armazenados na pasta /Programs/ no controlador do robô.

Monitoramento da UR

Há uma macro disponível na biblioteca que permite você monitorar o estado de um robô UR e atualizar a posição do robô real no RoboDK.

1.Selecione Arquivo ➔ Abrir

2.Carregue a macro UR_ActivateMonitoring.py em: C:/RoboDK/Library/Macros/. Um novo objeto Python será adicionado à estação.

3.Certifique-se de que o IP do robô seja fornecido corretamente nos parâmetros de conexão do robô.

4.Clique duas vezes na macro para iniciar o monitoramento.

O simulador atualizará a posição do robô e criará alvos à medida que o robô real for movido. Entre outras coisas, é possível monitorar a velocidade, a aceleração e as correntes do motor do robô.

Usando a garra RobotiQ

O RoboDK suporta a geração de programas para Universal Robots que podem operar as garras do RobotiQ. Você pode operar a garra RobotiQ gerando um programa off-line e usando o driver do RoboDK para robôs UR.

Usando a garra RobotiQ do RoboDK

Você pode operar a garra RobotiQ diretamente do controlador UR, gerando programas off-line usando o RoboDK.

Para adicionar suporte às garras RobotiQ, você deve selecionar o pós-processador Universal_Robots_RobotiQ:

1.Clique com o botão direito do mouse em um programa ou em seu robô

2.Clique em Selecionar Pós-processador

3.Selecione Universal Robots RobotiQ

Você pode então gerar chamadas de programa que podem operar a garra do RobotiQ. Por exemplo: rq_move_and_wait( 255 ) para abrir a garra ou rq_move_and_wait( 0 ) para fechar a garra.

Depois de ter o programa pronto no RoboDK, você pode executá-lo no robô usando um destes dois métodos:

• Clique com o botão direito do mouse em um programa (como o GripperOpenClose) e selecione Enviar programa para o robô)
• Clique com o botão direito do mouse em um programa (como o GripperOpenClose) e selecione Gerar Programa (essa segunda opção requer que você carregue manualmente o programa no robô).

Esse método de operação não requer o uso do driver.

Usando a garra RobotiQ com o driver

Você pode operar a garra RobotiQ diretamente do RoboDK usando o driver (opção Executar no Robô). O driver do RoboDK para UR e RobotiQ permite que você execute programas passo a passo a partir do RoboDK e veja o ponteiro sendo executado a qualquer momento a partir do RoboDK.

É importante garantir que você possa se conectar ao robô para usar esse recurso. Talvez seja necessário ter privilégios de administrador no Windows e/ou adicionar uma regra do Firewall do Windows para permitir essa comunicação (se você desativar o Firewall do Windows, isso poderá ajudar a solucionar o problema se ele estiver relacionado ao Firewall).

Você deve seguir estas etapas para adicionar suporte à movimentação da garra RobotiQ diretamente do RoboDK:

1.Faça o download do arquivo de script a seguir:       
https://robodk.com/files/upload/progrobodk-rq.zip

2.Descompacte o arquivo progrobodk.script aqui:      
C:/RoboDK/bin/progrobodk.script

3.Certifique-se de reiniciar o driver se ele estiver em execução (clique duas vezes em Desconectar e, em seguida, em Conectar).

4.Selecione Ferramentas-Opções-Drivers

5.Desmarque a opção: Gerenciar chamadas de programa com o RoboDK quando conectado a um robô.

Para operar corretamente a garra usando o driver (por exemplo, abrir/fechar a garra), você deve usar a chamada de programa para rq_move_and_wait passando um parâmetro no intervalo de 0 a 255.

Exemplo:

rq_move_and_wait( 0 ) # Fecha totalmente a garra

rq_move_and_wait( 255 ) # Abrir totalmente a garra

O número passado como argumento é exigido pelo driver.

Movimentos circulares versus movimentos lineares

Os robôs UR são compatíveis com movimentos circulares e lineares; no entanto, você poderá ver erros no terminal de programação se usar o driver para robôs UR.

Você pode ver os seguintes erros ao usar o driver do robô UR (opção "Executar no robô") porque o driver não aplica todos os filtros padrão que você tem no pós-processador UR por padrão. Esses filtros ajudam a limpar o código para que o controlador UR possa executar o programa sem problemas.

Esses erros incluem:

1.Circular arc with infinite radius (CIRCULAR_ARC_WITH_INFINITE_RADIUS): Você poderá ver esse erro quando tentar fazer um movimento circular com um raio grande. O pós-processador converte automaticamente esses movimentos em movimentos lineares.

2.Arco circular com raio zero (CIRCULAR_ARC_WITH_ZERO_RADIUS): Você pode ver esse erro com pequenos movimentos circulares. O pós-processador pode remover esses movimentos ou convertê-los em movimentos lineares.

Você não deverá ver esses erros quando gerar o programa off-line (clique com o botão direito do mouse em um programa e selecione Gerar programa ou F6) ou enviá-lo automaticamente para o robô (clique com o botão direito do mouse em um programa e selecione Enviar programa para o robô ou Ctrl+F6). Esses dois métodos de geração do programa usam o pós-processador em vez do driver.

Se ainda ocorrerem erros ao gerar o programa off-line (sem usar o driver), você poderá converter automaticamente os movimentos de arco em movimentos lineares seguindo estas etapas:

1. Selecione Ferramentas-Opções-Programa.
2. Defina o tamanho mínimo do arco como 1 mm.
3. Defina o tamanho máximo do arco como 0,5 mm.
4. Defina o tamanho mínimo do passo como 0,5 mm: isso garantirá que os pontos não sejam exportados com menos de 0,5 mm de distância, de modo que o raio de mistura tenha algum efeito; você pode aumentá-lo mais para ter menos movimentos bruscos.

Guia de instalação do URSim

O URSim permite que você emule o comportamento do controlador real do robô Universal Robots no seu computador. Isso permite que você se familiarize com o controlador e teste os programas que gera usando o RoboDK. Esta seção o guiará na instalação do URSim.

Faça o download dos requisitos do URSim

Você deve fazer o download da imagem oficial do URSim no site da Universal Robots e do Oracle VM VirtualBox nos sites oficiais.

1.Faça o download do Offline Simulator mais atualizado para não Linux a partir deste link: https://www.universal-robots.com/download/?query=.

3.Instale o software Oracle VM VirtualBox a partir do seguinte link: https://www.virtualbox.org/wiki/Downloads.

4.Crie uma pasta em seu disco rígido e dê a ela o nome de URSim.

5.Extraia o conteúdo do arquivo zip do URSim baixado para a pasta URSim.

6.Inicie o Oracle VM VirtualBox.

VirtualBox

Esta seção mostra como Você pode criar uma nova máquina virtual usando o Oracle VM VirtualBox para simular o controlador Universal Robots.

Siga estas etapas para criar uma nova máquina Linux e carregar a imagem do controlador baixada:

1.Inicie o VirtualBox e pressione "New" (Novo).

2.Defina o nome como UR_Sim_Eseries e defina a pasta Machine como a pasta que você criou.
Defina o tipo como Linux e a versão como Ubuntu (64 bits).

3.Defina o tamanho da memória como 768 MB e pressione "Next".

4.Selecione Usar um arquivo de disco rígido virtual existente e defina o caminho para a pasta em que o arquivo compactado foi descompactado. Pressione Criar.

5.Pressione "Start" para iniciar a máquina virtual.

6.Se for exibido um erro dizendo “A aceleração de hardware não está disponível”, talvez seja necessário reiniciar o computador e alterar uma configuração do BIOS para ativar a virtualização. Com a virtualização ativada, você poderá reiniciar o Windows, o VirtualBox e a máquina virtual.

7.A máquina virtual deve começar a funcionar.

Pasta compartilhada entre o Windows e o URSim

Opcionalmente, você pode configurar uma pasta compartilhada entre o computador Windows e o controlador emulado para transferir facilmente os arquivos de programa.

Siga estas etapas para mapear a pasta de programas do RoboDK com uma nova pasta no controlador do robô UR emulado:

1.Esta seção explica como ter uma pasta compartilhada entre o Windows e o URSim para transferir programas.

2.Abra a VM do URSim.

3.Crie uma pasta no Linux Ubuntu e nomeie-a "RoboDK_Shared" em "/home/ur/".

4.Crie um atalho na área de trabalho arrastando e soltando a pasta "RoboDK_Shared" na área de trabalho.

5.Abra o RoboDK_Shared.

6.Selecione View (Exibir)➔ Folder View Mode (Modo de exibição de pasta)➔ Compact View (Exibição compacta).

7.No menu superior da janela do VirtualBox, selecione Devices (Dispositivos)➔ Shared Folders (Pastas compartilhadas)➔ Shared Folders Settings (Configurações de pastas compartilhadas).

8.Add-in uma nova pasta compartilhada usando o botão mostrado na imagem a seguir.

9.Selecione o caminho para a pasta compartilhada no Windows (Você pode usar qualquer pasta do seu computador).

10.Marque " Montagem automática " e "Tornar permanente".

11.Ponto de montagem: /home/ur/RoboDK_Shared

12.No menu superior do VirtualBox, selecione Dispositivos ➔ Inserir imagem de CD de Adicional para convidados.

13.Selecione "Abrir no gerenciador de arquivos" e pressione "OK".

14.Abra a pasta para: /media/ur/VBox_Gas_6.1.38 (a versão do VBox pode variar).

15.Clique duas vezes no arquivo "autorun.sh" e selecione "Execute" (a senha é "easybot"). O script pode demorar um pouco para ser executado.

16.Reinicialize a máquina virtual.

17.Abra o terminal: Selecione o botão Iniciar➔ System Ferramentas➔ UXTerm.

18.Digite no terminal: sudo adduser $USER vboxsf e pressione "Enter".

19.Reiniciar a VM.

20.Se Você gerar novos arquivos com o RoboDK na pasta compartilhada do Windows, poderá pressionar "Exibir" → "Atualizar Pasta" ou pressionar "F5" na pasta compartilhada da VM "RoboDK_Shared".

Use o driver RoboDK com o UR Sim

Você pode testar a conexão entre o RoboDK e o controlador da Universal Robots usando o URSim.

1.No Oracle VM VirtualBox Manager.

2.Selecione a VM UR_Sim_Eseries e pressione Settings.

3.Selecione Rede➔ Conectado a: e selecione Placa em Modo Bridge e pressione OK.

4.Inicie a máquina virtual URSim.

5.Inicie o Polyscope com seu modelo de UR preferido.

8.Recuperar o endereço IP do simulador.

9.Vá para a janela "Move" (Mover) do URSim.

10.Abra a estação RoboDK com o mesmo modelo UR.

11.Selecione Conectar ➔ Conectar ao Robô.

12.Digite o endereço IP do UR Sim e pressione Conectar.

13.Use o Obter Posição para recuperar a posição do robô URSim e aplicá-la ao RoboDK.

14.Use o Mover Eixos para mover o robô do URSim para a posição do robô do RoboDK.

15.Clique com o botão direito do mouse em um programa do RoboDK, selecione "Executar no robô" e "Executar" para executar o programa simultaneamente no RoboDK e no URSim.

Atualizar a cinemática do robô

Seguir as etapas desta seção é opcional e necessário apenas em determinadas circunstâncias, quando a precisão é necessária na programação off-line. Esta seção explica como inserir os valores cinemáticos exclusivos do seu robô UR no RoboDK para simular o robô com precisão.

A cinemática do controlador UR é exclusiva para cada robô. As cinemáticas são as dimensões que definem o robô na forma da tabela DH (Denavit Hartenberg). O simulador RoboDK usa a cinemática UR nominal por padrão, portanto, você pode ver uma discrepância de 2 mm a 10 mm entre a cinemática do simulador e a cinemática do controlador.

Para que a simulação corresponda exatamente ao robô real, você pode importar a cinemática específica do seu robô UR simplesmente abrindo um arquivo URP criado com o terminal de programação.

Você também pode carregar o arquivo URP manualmente seguindo este procedimento:

1.Recupere um arquivo URP gerado usando o robô real (não usando o RoboDK ou o simulador UR)

2.Abra seu robô no RoboDK. Você encontrará seu robô UR na biblioteca do RoboDK. Você também pode usar um robô UR disponível em uma de suas estações RoboDK existentes.

3.Selecione Ferramentas-Executar Script

4.Selecione UR_LoadControllerKinematics

5.Selecione o arquivo URP extraído do controlador do robô.

Você deverá ver uma mensagem como a mostrada na imagem a seguir. Você poderá ver uma mensagem de aviso se não tiver carregado um arquivo URP válido ou se não tiver selecionado o robô UR correto.

Quando esse procedimento for concluído, você pode clicar com o botão direito do mouse em um robô e selecionar Salvar como .robot. Esses parâmetros são salvos com o arquivo do robô e você pode usar o arquivo do robô em vez de repetir esse procedimento para cada novo projeto.

O RoboDK extrai as informações específicas do seu robô a partir do arquivo URP e as leva em consideração para a simulação e a programação off-line no arquivo do robô. Você pode alterar essa configuração e reverter para a cinemática padrão no menu de parâmetros do robô, conforme mostrado na imagem a seguir.

Você perceberá que as informações de pose exibidas no terminal de programação correspondem à cinemática exibida no RoboDK (certifique-se de remover o quadro da ferramenta e o quadro de referência no RoboDK e no robô UR para fazer a comparação).

A cinemática UR muda de um robô para outro porque cada robô é calibrado na fábrica pela UR. Outros fornecedores de robôs, como KUKA, ABB, Motoman ou Fanuc, não calibram seus robôs, a menos que você adquira a opção chamada Absolute Accuracy (Precisão absoluta). As opções de Precisão Absoluta podem levar em conta até 40 parâmetros de calibração ou mais.

Esse procedimento não é o mesmo que a calibração do robô do RoboDK. A calibração do robô ajuda a melhorar a precisão do robô real.