MONOGRAFIA EstratégiasIntegraçãoBraço

Universidade Federal de Ouro Preto - UFOP
Escola de Minas
Colegiado do curso de Engenharia de Controle e
Automação - CECAU
Marcos Paulo Torre
Estratégias de integração entre braço manipulador ABB IRB 120 e

mão robótica Barrett BH8-282 utilizando o ROS
Monografia de Graduação em Engenharia de Controle e Automação
Ouro Preto, 2017

Marcos Paulo Torre
Estratégias de integração entre braço manipulador ABB IRB 120 e

mão robótica Barrett BH8-282 utilizando o ROS
Monografia apresentada ao Curso de Enge-

nharia de Controle e Automação da Universi-
dade Federal de Ouro Preto como parte dos
requisitos para a obtenção do Grau de Enge-
nheiro de Controle e Automação.
Orientador: Prof. Gustavo Medeiros Freitas, Dr.

Coorientador: Prof. José Alberto Naves Cocota Júnior, Msc.
Ouro Preto, 2017

T689e Torre, Marcos Paulo.
Estratégias de integração entre braço manipulador ABB IRB 120 e mão
robótica Barrett BH8-282 utilizando o ROS [manuscrito] / Marcos Paulo Torre.
- 2017.
98f.: il.: color; tabs.
Orientador: Prof. Dr. Gustavo M. Freitas.

Coorientador: Prof. Dr. José Alberto N. Cocota Júnior.
Monografia (Graduação). Universidade Federal de Ouro Preto. Escola de

Minas. Departamento de Engenharia de Controle e Automação e Técnicas
Fundamentais.
1. Robôs - ROS (sistema operacional de robôs). 2. Peças de maquinas -

BarrettHand BH8-282. 3. Robôs - Braço mecânico. I. Freitas, Gustavo M.. II.
Júnior, José Alberto N. Cocota. III. Universidade Federal de Ouro Preto. IV.
Titulo.
Catalogação: ficha@sisbin.ufop.br
CDU: 681.5
Resumo
O desenvolvimento deste trabalho tem por objetivo realizar a integração entre um
braço robótico industrial e uma mão robótica multi-dedos utilizando o framework
ROS (Robot Operating System). O braço robótico industrial, modelo IRB 120, é o
menor da categoria desenvolvido pela ABB Corporation. A mão robótica, modelo
BarrettHand BH8-282, é fabricada pela empresa Barrett e possui matrizes de toque
nas pontas dos dedos e na palma da mão, além de um sensor de força e torque
no punho. Devido a ambos os equipamentos possuírem controladores nativos e
independentes, se faz necessária a utilização de mais uma camada para permitir
a integração entre os mesmos. Dessa maneira, o framework ROS será utilizado
tanto como sistema auxiliar, quanto como sistema central para efetuar o controle
e permitir a comunicação entre os equipamentos. Serão abordadas duas soluções
distintas. A primeira utiliza o software proprietário da ABB, o RobotStudio, para
efetuar a programação do robô. O interfaceamento entre o braço e a mão se dá
através de uma placa microcontrolada Arduino Uno, imersa no ambiente do ROS
através de um pacote de comunicação denominado rosserial. A segunda maneira
permite uma integração mais direta, eliminando a necessidade de utilização da placa
microcontrolada. O braço robótico terá sua trajetória planejada por um ambiente
de controle de movimento denominado MoveIt!. A comunicação entre o robô físico
e o ROS é feita através de um socket, responsável por enviar o vetor de pontos
gerador da trajetória e receber o estado real das juntas. A comunicação entre a mão
robótica e o ROS, em ambos os casos, é realizada por um barramento CAN, através
do protocolo CANopen®, e implementada através de um pacote de controle mantido
pela empresa Robotnik, denominado bhand_controller. No final, são discutidos os
resultados apontando as vantagens e desvantagens das duas abordagens levadas em
consideração no presente trabalho.
Palavras-chaves: Robot Operating System (ROS), MoveIt!, rosserial, ABB

IRB 120, BarrettHand BH8-282.
Abstract
This work aims the integration between an industrial robotic arm and a
multi-fingered robotic hand using the ROS framework. The IRB 120 industrial
robotic arm is the smallest of the category ever produced by ABB Corporation.
The BarrettHand BH8-282 robotic hand is manufactured by Barrett company and
features tactile sensors at the fingertips and palm of the hand, plus a force and torque
sensor at the wrist. Because both devices have native and independent controllers,
it is necessary to use one more layer to allow the integration between them. Thus,
the ROS framework will be used both as auxiliary and central systems to control
and allow communication between the equipment. Two different solutions will be
developed. The first uses ABB’s proprietary software, RobotStudio, to perform the
robot programming. The interface between the arm and the hand occurs through
an Arduino Uno microcontroled board, immersed in the ROS environment through
a communication packet called rosserial. The second way allows a more direct
integration, eliminating the requirement of the extra microcontrolled board. The
robotic arm will have its trajectory planned by a movement control environment
called MoveIt!. The communication between the physical robot and the ROS is made
through a socket, responsible for sending the vector of points that generates the
trajectory and receive the real state of the joints. The communication between the
robotic hand and the ROS in both cases is performed by a CAN bus, through the
CANopen protocol, and implemented through a control package maintained by the
Robotnik company, called bhand_controller. At the end of this work, the results
are discussed, pointing out the advantages and disadvantages of the two approaches
taken into account in the present work.
Keywords: Robot Operating System (ROS), MoveIt!, rosserial, ABB IRB 120,
BarrettHand BH8-282.
Lista de ilustrações
Figura 1 Manipulador IRB 120 . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

Figura 2 Controlador IRC5 Compact . . . . . . . . . . . . . . . . . . . . . . . . 13
Figura 3 Vista traseira do IRC5 compact . . . . . . . . . . . . . . . . . . . . . . 14
Figura 4 Módulo de I/O DSQC 652 . . . . . . . . . . . . . . . . . . . . . . . . . 14
Figura 5 FlexPendant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Figura 6 Software RobotStudio . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Figura 7 BarrettHand BH8-282 . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Figura 8 Placa Arduino UNO . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Figura 9 Arduino IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Figura 10 Diagrama de blocos do ROS-Industrial . . . . . . . . . . . . . . . . . . 21
Figura 11 Interface gráfica do MoveIt! . . . . . . . . . . . . . . . . . . . . . . . . 22
Figura 12 Arquitetura do sistema utilizando o IRC5 Compact como controlador

central . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Figura 13 Arquitetura do sistema utilizando o ROS como sistema central . . . . . 25
Figura 14 Movimento com zona definida . . . . . . . . . . . . . . . . . . . . . . . 27
Figura 15 Seleção do modo de movimento pelo FlexPendant . . . . . . . . . . . 28
Figura 16 Adicionar instrução pelo FlexPendant . . . . . . . . . . . . . . . . . . 29
Figura 17 Adicionar controlador pela rede . . . . . . . . . . . . . . . . . . . . . . 30
Figura 18 Configuração de I/O pelo RobotStudio . . . . . . . . . . . . . . . . . 30
Figura 19 Exemplo de código no editor do RobotStudio . . . . . . . . . . . . . . 31
Figura 20 Interligação do conector XS10 . . . . . . . . . . . . . . . . . . . . . . 32
Figura 21 Divisor de tensão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Figura 22 Executando o programa pelo FlexPendant . . . . . . . . . . . . . . . . 36
Figura 23 Configuração dos parâmetros para o link 2 . . . . . . . . . . . . . . . . 37
Figura 24 Configuração final da montagem . . . . . . . . . . . . . . . . . . . . . . 38
Figura 25 Movimento das juntas da BarrettHand BH8-282 . . . . . . . . . . . . . 40
Figura 26 Modelo final IRB 120 e BarrettHand BH8-282 . . . . . . . . . . . . . . 41
Figura 27 MoveIt! Setup Assistant . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Figura 28 MoveIt! Planning Group . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Figura 29 Interfaces do MoveIt! e Joint State Publisher . . . . . . . . . . . . . . . 51
Figura 30 Conjunto do braço e mão robótica no World Mining Congress . . . . . 52

Figura 31 Sistema em execução durante o World Mining Congress . . . . . . . . . 53
Figura 32 Exemplo de posição simulada pelo robô virtual e executada pelo robô real 54
Figura 33 Exemplo de trajetória planejada com desvio de obstáculo e pose final
executada pelo robô real . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Lista de tabelas
Tabela 1 Estrutura da mensagem tipo sensor_msgs/JointState . . . . . . . . . . 20
Tabela 2 Pinos do conector XS10 . . . . . . . . . . . . . . . . . . . . . . . . . . 32

Tabela 3 Limites de junta do braço ABB IRB 120 . . . . . . . . . . . . . . . . . 39
Tabela 4 Limites de junta da mão BarrettHand BH8-282 . . . . . . . . . . . . . 39
Tabela 5 Tarefas a serem criadas no controlador . . . . . . . . . . . . . . . . . . 45
Tabela 6 Módulos a serem carregados no controlador . . . . . . . . . . . . . . . 45
Sumário
1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.1 Descrição do problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3 Organização do trabalho . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2 Arquitetura do sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1 Braço Robótico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1.1 ABB IRB 120 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1.2 Controlador IRC5 Compact . . . . . . . . . . . . . . . . . . . . . . 13
2.1.2.1 Módulo de I/O DSQC 652 . . . . . . . . . . . . . . . . . . 14
2.1.2.2 FlexPendant . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.1.3 ABB RobotStudio . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2 Barrett Hand BH8-282 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3 Arduino Uno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3.1 Arduino IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.4 Robot Operating System (ROS) . . . . . . . . . . . . . . . . . . . . . . . . 18
2.4.1 Rosserial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.4.2 Bhand controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.4.3 ROS Industrial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.4.4 MoveIt! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.4.5 OMPL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3 Metodologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.1 Visão geral dos sistemas propostos . . . . . . . . . . . . . . . . . . . . . . 23
3.2 Preparação do ambiente . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.3 Estratégia de integração utilizando o IRC5 Compact como controlador central 26
3.3.1 Utilização do FlexPendant e do RobotStudio para a programação
do robô . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.3.2 Alimentação do módulo DSQC 652 . . . . . . . . . . . . . . . . . . 31
3.3.3 Interfaceamento entre o módulo DSQC 652 e o Arduino . . . . . . . 32
3.3.4 Programação do Arduino Uno . . . . . . . . . . . . . . . . . . . . . 33
3.3.5 Colocando a primeira estratégia de integração em operação . . . . . 35
3.4 Estratégia de integração utilizando o ROS como sistema central . . . . . . 36
3.4.1 Criação do arquivo URDF . . . . . . . . . . . . . . . . . . . . . . . 37
3.4.2 Preparando o pacote do MoveIt! . . . . . . . . . . . . . . . . . . . . 41
3.4.3 Configuração do socket de comunicação . . . . . . . . . . . . . . . . 43
3.4.3.1 Configuração do socket servidor . . . . . . . . . . . . . . . 43
3.4.3.2 Configuração do socket cliente . . . . . . . . . . . . . . . . 45
3.4.4 Desenvolvimento do nó de controle da mão robótica . . . . . . . . . 47
3.4.5 Alteração no controlador Bhand Controller . . . . . . . . . . . . . . 49
3.4.6 Colocando a segunda estratégia de integração em operação . . . . . 50
4 Experimentos e discussão dos resultados . . . . . . . . . . . . . . . . . . . . 52

4.1 Comparação entre as estratégias propostas . . . . . . . . . . . . . . . . . . 55
5 Considerações finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Referências . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Apêndices 61
APÊNDICE A Código do Arduino Uno . . . . . . . . . . . . . . . . . . . . . . 62
APÊNDICE B Código do controlador IRC5 Compact . . . . . . . . . . . . . 64
APÊNDICE C Código do nó de controle da mão robótica . . . . . . . . . . . 95

1 Introdução
1.1 Descrição do problema

Com a intensa busca pela alta produtividade, em paralelo aos requisitos de saúde e
segurança necessários para a execução de tarefas inerentes aos diversos ramos de atividade
existentes na indústria, as empresas começam a perceber a necessidade de manter seus
processos com o maior grau de automação possível e garantir que a mão de obra esteja
capacitada para acompanhar tal evolução.
Devido a capacidade de efetuar tarefas complexas e repetitivas, com alto grau
de precisão, velocidade e repetibilidade, os braços robóticos se tornaram um importante
aliado no caminho para a competitividade que todos os setores industriais visam atingir.
As paradas de processo se tornam cada vez menores, sendo a maioria delas já planejadas
para manutenções preditivas ou preventivas. Além do mais, estes podem ser aplicados
em ambientes insalubres e em cenários de risco sem perda de desempenho, sendo uma
importante ferramenta para evitar riscos à vida dos colaboradores.
Mesmo com as inúmeras vantagens de sua utilização, os braços robóticos industriais
são geralmente programados para efetuar tarefas repetitivas, sem interação com o ambiente
(MARTíN, 2013).
A maioria dos robôs industriais utilizam softwares proprietários e controladores na-
tivos, de arquitetura fechada, fazendo com que a integração com dispositivos de fabricantes
diferentes se torne uma tarefa difícil para ser feita de maneira direta.
Segundo Bartolomeu et al. (2005), um dos grandes desafios da robótica é justamente
como integrar as informações vindas de todos estes algoritmos e sensores, de modo a gerar
comandos e controlar os diferentes dispositivos de atuação do robô, garantindo que a tarefa
seja executada de modo correto e sem colocar em risco tanto o robô quanto aqueles que o
cercam.
Uma possível maneira de se contornar o problema é implementar o controle dos
equipamentos à partir de um sistema unificado, executado em um ou mais computadores,
fazendo que todos os comandos enviados partam de um ambiente comum, possibilitando
tomada de decisões mais adequadas e cruzamento de informações. Além disso, um sistema
unificado permite dar mais flexibilidade à aplicação, pois diversos tipos diferentes de
algoritmos para interagir com o sistema podem ser aplicados de maneira mais simples,
como de otimização, tratamento de imagens, visão computacional, entre outros.
Capítulo 1. Introdução 11
1.2 Objetivos
O objetivo deste trabalho é avaliar diferentes formas de se integrar o braço robótico
industrial ABB IRB 120 e a mão robótica BarrettHand BH8-282, a fim de se obter sincronia
de movimentos que permitam utilizá-los em conjunto, em diversos tipos de trabalhos que
exijam manipulação de objetos. As técnicas serão estudadas com o intuito de identificar o
melhor método para aplicação em sistemas já implantados e projetos futuros, levando em
consideração a complexidade das trajetórias, dos movimentos de manipulação, capacidade
de expansão de funcionalidades, entre outros.
1.3 Organização do trabalho

O presente trabalho está organizado em 5 capítulos. Este capítulo traz algumas
vantagens da utilização de células robóticas para o auxílio dos processos produtivos das
empresas, destacando também a necessidade de flexibilização destas células aplicadas na
indústria. O capítulo também descreve o objetivo do trabalho, que é propor duas maneiras
distintas de realizar a integração entre o braço manipulador ABB IRB 120 e a mão robótica
BarrettHand BH8-282.
O Capítulo 2 apresenta uma revisão sobre os hardwares e softwares utilizados
nas etapas de desenvolvimento do trabalho, como o braço robótico ABB IRB 120 e o
controlador IRC5 Compact, além da mão robótica BarrettHand BH8-282, que foram os
equipamentos motivadores da realização deste projeto. Dentre outros softwares revisados,
destacam-se o RobotStudio, utilizado para programação do controlador IRC5 Compact; o
ROS e suas ferramentas, como o MoveIt! e o ROS Industrial.
Os testes realizados e comparações feitas entre as estratégias de integração estão
no Capítulo 4. O Capítulo 5 apresenta as considerações finais do projeto, analisando onde
cada estratégia proposta se encaixaria melhor, nas células robóticas em operação ou nas
que ainda estejam em fase de projeto.
12
2 Arquitetura do sistema
Neste capítulo será apresentada a estrutura geral do sistema, bem como a revisão
dos equipamentos e softwares envolvidos no mesmo. Os hardwares revisados serão o sistema
robótico da ABB Corporation utilizado neste projeto, a mão robótica BarrettHand BH8-
282 e o Arduino Uno. Os softwares utilizados incluem o RobotStudio, o ROS e suas
ferramentas, além da interface de desenvolvimento Arduino IDE.
2.1 Braço Robótico

Nesta seção será feita a revisão do sistema robótico utilizado neste trabalho,
fornecido pela ABB Corporation. O sistema conta com um braço manipulador IRB 120,
um controlador IRC5 Compact, um módulo I/O DSQC 652 e o software de programação
RobotStudio.
2.1.1 ABB IRB 120

O IRB 120, mostrado na Figura 1, é o menor braço robótico universal já desenvolvido
pela ABB corporation. Ele possui alcance horizontal de 580mm, 25kg de massa e capacidade
de carga de 3kg, podendo chegar a até 4kg em manipulações com o pulso voltado para
baixo. Este manipulador robótico conta com seis juntas de revolução, caracterizando seis
graus de liberdade (DOF).
Figura 1: Manipulador IRB 120
Fonte: Site oficial da ABB
O robô é feito em estrutura leve de alumínio, com motores compactos e de alta

Capítulo 2. Arquitetura do sistema 13
velocidade/torque, que garantem ao mesmo uma rápida aceleração, agilidade e precisão

durante suas atividades (ABB, 2013).
Segundo a ABB (2013), as características construtivas do robô, que conta com
dimensões e peso reduzidos, facilita a integração do mesmo em diversos tipos de células,
fazendo com que o mesmo seja indicado para aplicações de manipulação de objetos e
atividades de montagem.
2.1.2 Controlador IRC5 Compact

O IRC5 Compact, mostrado na Figura 2, é um controlador otimizado para pequenos
robôs. Em uma versão compacta, ele apresenta todas as características do completo
controlador IRC5, fornecendo controle de movimento e precisão para as aplicações (ABB,
2013).
Figura 2: Controlador IRC5 Compact
Entre as funcionalidades do controlador IRC5 Compact, o sistema conta com a

possibilidade de ser integrado em redes de campo largamente utilizadas na industria, como
Profibus® DP e DeviceNetTM . Além disso, com a capacidade de se comunicar no padrão
ethernet, é possivel que o mesmo seja inserido em redes locais, domínios, entre outros,
podendo ser controlado e monitorado remotamente. Este também possui a vantagem de
ser alimentado em 220Vac , eliminando a necessidade de instalações elétricas trifásicas. A
Figura 3 mostra os conectores, chaves e botões do painel traseiro do controlador.
Todos os sistemas robóticos da ABB são programados através de RAPIDTM , que
é uma linguagem de programação flexível e de alto nível. Apesar de possuir comandos
simples e de fácil entendimento, a linguagem permite a criação de aplicações altamente
sofisticadas (ABB, 2013).
Figura 3: Vista traseira do IRC5 compact
2.1.2.1 Módulo de I/O DSQC 652
O controlador IRC5 compact conta com uma unidade DSQC 652, como mostrado
na Figura 4, de 16 entradas e 16 saídas digitais. Os pontos de I/O podem ser utilizados
através de conectores externos, geralmente acessíveis por uma régua de bornes.
Figura 4: Módulo de I/O DSQC 652
O interfaceamento entre o módulo e o controlador é realizado através da rede

DeviceNetTM . Mas não basta que o módulo esteja corretamente conectado à rede para sua
utilização; também é necessário que os pontos de I/O estejam devidamente energizados.

A energização é feita no painel traseiro do controlador, e será explicada no decorrer do
trabalho.
2.1.2.2 FlexPendant
O FlexPendant (Figura 5) é uma Interface Homem Máquina portátil utilizada para

operação e supervisão do robô. Através dele, é possivel ter acesso a todas as funcionalidades
do controlador IRC5 compact, incluindo realizar sua programação e operar o manipulador.
Seu hardware conta uma tela para navegação, teclas de atalho programáveis e de execução
de programa, chave de emergência, entrada USB, um joystick de três eixos para operação
manual do robô e um botão chamado de "homem morto", que deve estar pressionado de
uma maneira específica durante todo o tempo para que os motores permaneçam habilitados.
Figura 5: FlexPendant
Fonte: PCRobotics
2.1.3 ABB RobotStudio

O RobotStudio é um software proprietário de programação e simulação de sistemas
robóticos desenvolvido pela ABB. O programa é uma ferramenta completa e extremamente
útil para projetistas, pois permite que a programação seja feita offline e posteriormente
simulada em um Windows PC, além de edições "a quente", sem necessidade de parada de
produção. O software permite a completa utilização de suas ferramentas por 30 dias, sendo
que após este período, é necessária a aquisição de uma licença para usufruir de todas as
suas funcionalidades.
O RobotStudio possui um controlador virtual que apresenta uma cópia exata do
software presente no controlador real, fazendo com que as simulações sejam extremamente
realistas através de seu sistema de visualização dos robôs, conforme mostrado na Figura 6.
Estas características são fundamentais para redução de riscos, rápidos start-ups e mudanças
mais curtas, que convergem para o aumento de produtividade.
Figura 6: Software RobotStudio
2.2 Barrett Hand BH8-282

O efetuador BarrettHand BH8-282 (Figura 7) é uma mão robótica programável
que possui três dedos, com a destreza de segurar objetos de diferentes tamanhos, formas e
orientações, pesando 980g e com uma capacidade de carga de até 6kg. Mesmo apresen-
tando baixo peso e uma base ultra-compacta, é totalmente auto-controlada (BARRETT
TECHNOLOGY INC., 2013).
Figura 7: BarrettHand BH8-282
Fonte: Site oficial Barrett Technology

Seu hardware é composto por uma unidade de comunicação, quatro motores

brushless e encoders de alta precisão. Além disso, conta com sensores tácteis na palma
da mão e na ponta dos dedos, podendo também ser adquirida com um sensor de força
e torque extra de seis graus de liberdade no punho . Dos seus três dedos multi-juntas,
dois deles possuem um grau de liberdade adicional, garantindo a mobilidade lateral para
melhor se adaptar aos variados tipos de objetos.
A possibilidade de comunicação em padrão serial e também via barramento CAN
de alta velocidade, torna o equipamento flexível para integração com diversos tipos de
braços robóticos.
2.3 Arduino Uno

O Arduino UNO (Figura 8) é uma placa microcontrolada baseada no chip AT-
mega328P. É uma plataforma compacta que possui quatorze pinos de entrada e saída
configuráveis, no qual seis deles podem ser utilizados como saída PWM, além de seis
entradas analógicas. Seu hardware também conta com um clock de 16MHz, conexão USB,
entrada para alimentação externa e um botão de reset (ARDUINO, 2017).
Figura 8: Placa Arduino UNO
Fonte: Site oficial Arduino
O Arduino é uma plataforma conhecida por sua flexibilidade e baixo custo, podendo
se comunicar facilmente com um computador através de sua porta USB, que além de criar
uma porta serial virtual, pode ser usada para alimentação do dispositivo. O fabricante
disponibiliza uma série de bibliotecas capazes de fornecer informações a nível de hardware
sem a necessidade de manipulação direta de registradores, tornando seu uso extremamente
simples. Com uma comunidade de utilizadores bastante difundida pelo mundo, bibliotecas
adicionais são facilmente encontradas, bem como o apoio técnico para a resolução de
problemas.
2.3.1 Arduino IDE

O software Arduino IDE, mostrado na Figura 9, é um ambiente de desenvolvimento
open source utilizado para implementar a programação de qualquer placa Arduino. Esta
utiliza uma linguagem de programação de alto nível, baseada em C/C++. O uso da
interface é extremamente simples, onde é necessário apenas configurar o modelo da placa
utilizada e selecionar a porta serial virtual criada pelo dispositivo após sua conexão com
o computador. Após as configurações básicas, o ambiente já está pronto para receber a
programação, realizar a compilação dos códigos e transferir o programa para a placa com
apenas um clique (ARDUINO, 2017).
As bibliotecas do ROS também podem ser utilizadas no Arduino IDE, conforme
será abordado no decorrer do trabalho.
Figura 9: Arduino IDE
Fonte: Wikipedia
2.4 Robot Operating System (ROS)

O ROS é uma ferramenta flexível para implementação de softwares para robôs,
apresentando uma coleção de ferramentas, bibliotecas e convenções com o objetivo de
simplificar a tarefa da criação de robôs complexos e robustos (ROS, 2013). O ROS é também
uma ferramenta de código aberto criada para incentivar a implementação colaborativa

de softwares para sistemas robóticos, geralmente escritos nas linguagens de programação
C++ ou Python. Um de seus objetivos é unir diferentes grupos ao redor do mundo,
aproveitando os pontos fortes individuais, convergindo para criação de uma ferramenta
robusta e multidisciplinar através do trabalho em equipe.
O desenvolvimento do software para um robô verdadeiramente robusto e generalista
é uma tarefa difícil. Na perspectiva da robótica, tarefas que aparentam ser triviais para
humanos geralmente variam muito entre instâncias de tarefas e ambientes, exigindo um
processamento computacional considerável (ROS, 2013).
Uma característica importante do ROS é a maneira com que os programas se
comunicam entre si. Cada programa é chamado de nó, e a troca de informações entre eles
é feita através dos tópicos e serviços, que transmitem um determinado tipo de mensagem.
Os nós são processos que são executados em paralelo, sem a necessidade de programação
de threads. As mensagens que transitam através dos tópicos apresentam uma estrutura
própria, e podem ser personalizadas de acordo com as necessidades do projeto.
Para que uma mensagem seja enviada, é necessário que os nós publiquem esta
mensagem a um determinado tópico. Para que outro nó seja capaz de receber esta
mensagem, é necessário que o mesmo subscreva a este tópico, caracterizando um sistema
de broadcast. Diferentes nós podem subscrever e publicar em um único tópico, mas a
troca de grandes quantidades de mensagens deve ser feito com cautela, devido a possível
saturação do canal de transporte.
Outra característica relevante no ROS é a sua universalidade. É possível controlar,
através dos vários drivers disponíveis, robôs de diferentes fabricantes, desde que os mesmos
estejam definidos em um formato comum, como por exemplo, o URDF (Unified Robot
Description Format). Como o próprio nome sugere, o URDF é um modelo único no qual
podemos incluir todas as informações sobre as juntas e links de um determinado robô. É
possível obter a visualização tridimensional fiel de sua estrutura, a partir de um modelo
CAD representando os links com seus graus de liberdade bem definidos.
2.4.1 Rosserial
Rosserial é um protocolo utilizado para comunicação ponto a ponto entre dispositi-
vos através de uma porta serial ou via rede. Apesar de existirem várias bibliotecas clientes,
inclusive para aplicações em plataforma Windows, apenas a biblioteca para Arduino será
utilizada neste trabalho.
Seu uso permite a comunicação direta entre o Arduino e o sistema base. O de-
senvolvimento do programa deve ser feito levando em consideração a estrutura do ROS,
incluindo suas bibliotecas no sketch de programação. Após estabelecer a sincronia entre o
dispositivo e o computador onde o sistema base está rodando, o Arduino é visto como um
nó, sendo capaz de publicar e subscrever tópicos de maneira direta.
2.4.2 Bhand controller

Bhand controller é um nó do ROS, baseado na linguagem de programação Python,
utilizado para controlar qualquer mão robótica da série BH8 fabricada pela Barrett.
Este pacote é mantido pela empresa Robotnik e fornece todos os dados telemétricos do
equipamento, como posição e temperatura dos motores, além dos valores de leitura dos
sensores tácteis e de força e torque. O pacote apresenta grande número de funcionalidades,
incluindo uma interface gráfica para comando da mão robótica por completo em diferentes
modos, além da apresentação animada dos valores dos sensores tácteis.
Todos os valores de telemetria são publicados através de tópicos. A posição e
velocidade das juntas da mão robótica também podem ser setadas através de um tópico
específico para comandos. Por este motivo, para este trabalho, apesar do grande número
de funcionalidades do pacote, somente o tópico /bhand_node/command será utilizado.
Para publicar no tópico /bhand_node/command, mensagens do tipo
sensor_msgs/JointState devem ser utilizadas. A estrutura da mensagem é mostrada na
Tabela 1.
Nome Tipo
header std_msgs/Header
name string[]
position float64[]
velocity float64[]
effort float64[]
Tabela 1: Estrutura da mensagem tipo sensor_msgs/JointState
Fonte: ROS (2013)
Este tipo de mensagem apresenta múltiplos arrays para representação dos dados,
carregando informações como nome, velocidade, posição e esforço. Todas estas informações
individuais das juntas são obtidas pelo mesmo índice nos arrays que os representam.
2.4.3 ROS Industrial

ROS Industrial é um projeto open-source que estende as avançadas capacidades do
ROS para aplicações industriais. É usado em projetos industriais avançados de manufatura
(MARTíN, 2013). Sua estrutura pode ser observada na Figura 10.
Com novas funcionalidades, o ROS Industrial torna possível a comunicação entre

o ROS e alguns braços robóticos industriais fabricados pela ABB, Motoman, Fanuc e
Universal. Alguns pacotes vêm sendo desenvolvidos para se comunicar com diferentes
marcas. Neste projeto, foi usado o pacote desenvolvido para efetuar comunicação com
robôs da ABB (MARTíN, 2013).
Figura 10: Diagrama de blocos do ROS-Industrial
Fonte: Joseph (2015, p. 379)
2.4.4 MoveIt!
MoveIt! é considerado um algoritmo estado da arte para manipulação móvel,
incorporando os últimos avanços em planejamento de trajetórias, manipulação, percepção
3D, cinemática, controle e navegação. A ferramenta fornece uma plataforma de fácil
utilização para desenvolvimento de aplicações robóticas avançadas, avaliação de projetos
de novos robôs e construção de sistemas robóticos integrados para as áreas industriais,
comerciais, pesquisa e desenvolvimento, entre outros (MOVEIT!, 2015).
Após a criação do modelo unificado do robô (URDF), o MoveIt! oferece um
assistente de configuração amigável que permite gerar matrizes de colisão do robô, criar
grupos de planejamento, selecionar diferentes tipos de solucionadores cinemáticos, entre
outros.
A aplicação final, conforme mostrado na Figura 11, oferece interação direta do

usuário com o robô, através de uma interface gráfica, tornando-o capaz de definir posições
pré-programadas ou planejar novas trajetórias.
Figura 11: Interface gráfica do MoveIt!
2.4.5 OMPL
Open Motion Planning Library (OMPL) consiste nos mais avançados algoritmos
de planejamento de trajetória baseados em amostragem. A biblioteca foi projetada para
ser facilmente integrada a outros sistemas (OMPL, 2015).
O pacote do MoveIt! utiliza os planejadores da biblioteca OMPL, que podem ser
utilizados para vários tipos de robôs, a fim de calcular trajetórias válidas para o braço
robótico.
23
3 Metodologia
Este trabalho propõe duas abordagens distintas para a integração entre o braço
robótico ABB IRB 120 e a mão robótica BarrettHand BH8-282. A preparação inicial do
ambiente, bem como as demais instruções para o desenvolvimento completo do projeto
serão explicadas nas próximas seções.
3.1 Visão geral dos sistemas propostos

No primeiro método, a integração se dará de uma forma mais simples, utilizando
o controlador IRC5 Compact como elemento central, a placa Arduino como interface e
o ROS como sistema auxiliar para comunicação com a mão robótica, conforme pode ser
visualizado através da Figura 12. O sistema será composto pela seguinte arquitetura:
• Hardware: Arduino Uno, Braço Robótico IRB 120, Controlador IRC5 Compact, Mão
Robótica Barret BH8-282.
• Software: Robot Operating System (ROS), rosserial, Robot Studio, Arduino IDE.
Todos os movimentos do robô são programados através do software de programação

RobotStudio, não ficando a cargo do computador nenhum tipo de planejamento e controle
de trajetória.
A placa microcontrolada Arduino Uno é a responsável por receber o conjunto de
sinais proveniente do módulo de saída digital do controlador IRC5 Compact e enviar
as informações ao computador. As informações recebidas são tratadas, identificando os
comandos e enviando as posições pré-programada das juntas para a mão robótica.
Neste primeiro método, são necessárias as instalações do framework ROS na
distribuição Indigo, da biblioteca de comunicação rosserial e do pacote de interfaceamento
da mão robótica, o bhand_controller.
O segundo método apresenta uma filosofia diferente do primeiro, onde o computador
passa a ser o elemento central, tornando o ROS o sistema principal, conforme mostrado
na Figura 13. Esta estratégia possui a seguinte estrutura:
• Hardware: Braço Robótico IRB 120, Controlador IRC5 Compact, Mão Robótica
Barret BH8-282.
Capítulo 3. Metodologia 24
Figura 12: Arquitetura do sistema utilizando o IRC5 Compact como controlador central
• Software: Robot Operating System (ROS), MoveIt!, ROS-Industrial, Robot Studio.
O computador é o responsável por processar todas as informações. Diferentes

trajetórias podem ser calculadas e executadas através da ferramenta MoveIt!. O vetor de
pontos que representa a trajetória é enviado através de um socket ao controlador IRC5
Compact, que colocará o robô em movimento seguindo a trajetória calculada.
No mesmo ambiente, as juntas da mão robótica podem ser controladas diretamente,
sem a limitação do modelo da primeira abordagem, no qual os movimentos são pré-
programados e executados conforme a combinação de saídas digitais. É possível, ainda,
receber e tratar os valores dos sensores tácteis e de força-torque existentes no hardware da
mão robótica.
Para esta estratégia, além dos softwares necessários para o primeiro método, também
é necessária a instalação do ROS Industrial com o pacote de comunicação para robôs ABB.
3.2 Preparação do ambiente

Para que o ambiente esteja apto a ser configurado, contemplando a instalação e
correta utilização de todas as ferramentas necessárias, é exigido um microcomputador ou
Figura 13: Arquitetura do sistema utilizando o ROS como sistema central
laptop com sistema operacional Ubuntu 14.04 LTS Trusty e, no mínimo, uma porta USB e
uma placa de rede disponíveis.
A instalação dos softwares descritos abaixo é necessária para o desenvolvimento do
projeto:
• ROS Indigo: A instalação do ROS Indigo para a plataforma Ubuntu deve ser feita
seguindo as orientações do site oficial do ROS (ROS. . . , 2017b).
• ROS Industrial: A instalação do ROS Industrial deve ser feita no terminal do

linux, digitando o seguinte comando (SITE. . . , 2015) :
$ sudo apt-get install ros-indigo-industrial-core
• MoveIt!: A instalação do MoveIt! deve ser feita no terminal do linux, digitando o

seguinte comando (MOVEIT!, 2015):
$ sudo apt-get install ros-indigo-moveit-full
• rosserial: A instalação do rosserial para a plataforma Arduino deve ser feita seguindo
as orientaçoes do site oficial do ROS (ARDUINO. . . , 2015).
• bhand_controller: Os passos para instalação do bhand_controller estão disponíveis

no site oficial do ROS (ROS. . . , 2017a).
3.3 Estratégia de integração utilizando o IRC5 Compact como con-

trolador central
O primeiro método proposto visa realizar uma integração que exige modificações
menos invasivas no sistema, utilizando o IRC5 Compact como controlador central. O braço
manipulador é programado através das ferramentas nativas do sistema robótico, como o
FlexPendant e o RobotStudio, utilizando a linguagem RAPID. As trajetórias programadas
englobam os acionamentos estratégicos das saídas digitais, nos pontos em que a mão
robótica deve efetuar algum tipo de trabalho.
O interfaceamento entre o controlador IRC5 Compact e a mão robótica BH8-282
se dá através do módulo de saídas digitais DSQC 652. O Arduino Uno é utilizado para
receber estes comandos digitais e publicar as posições pré-programadas no ROS, onde o
controlador da mão robótica bhand_controller está em execução.
3.3.1 Utilização do FlexPendant e do RobotStudio para a programação do

robô
O RobotStudio é o software utilizado para desenvolver a programação do controlador
IRC5 Compact. Entretanto, para a marcação dos pontos que servirão como base para
a geração de trajetórias, é feito o uso do FlexPendant, devido a sua praticidade. O
FlexPendant também pode ser utilizado para programação do robô, mas à medida que
funções de programação mais específicas são necessárias, o uso do RobotStudio se torna
mais indicado por ser um ambiente de desenvolvimento.
Neste projeto são utilizados comandos com movimento no espaço de trabalho das
juntas, trajetórias lineares e circulares no espaço de trabalho do efetuador, bem como a
manipulação de saídas digitais para o comando da mão robótica.
O comando de movimento por juntas é utilizado quando não há necessidade de
criar uma trajetória linear entre dois pontos no espaço de trabalho do robô, sendo este o
comando mais simples para mover o efetuador de um ponto para o outro. Desta maneira,
não haverá previsibilidade no movimento do braço e os pontos serão alcançados com
trajetórias não lineares. A estrutura de um comando por juntas segue o seguinte padrão:
MoveJ ponto, velocidade, zona , ferramenta;
Onde:
• Ponto: Posição que deve ser alcançada, dentro do espaço de trabalho do robô ;
• Velocidade: Velocidade das juntas em °/s, ou mm/s em movimentos lineares;

• Zona: Parâmetro que cria uma zona circular ao redor do ponto desejado. O próximo
comando começa a ser executado quando o efetuador entra nesta área, realizando
um movimento suave e ininterrupto, como mostrado na Figura 14. O desvio deixa de
existir caso o valor fine seja adotado, garantindo que o efetuador passará exatamente
pelo ponto definido.
• Ferramenta: Variável relativa ao Tool Center Point (TCP), ponto em relação ao

qual será definido todo o posicionamento do robô. Caso nenhuma ferramente seja
definida, o TCP adotado é o centro da flange do manipulador.
Figura 14: Movimento com zona definida
Fonte: Adaptado de ABB Corporation (2010)
O comando de movimento linear é utilizado para mover o efetuador por uma

trajetória em linha reta entre dois pontos. Este apresenta estrutura similar ao comando de
movimento por juntas:
MoveL ponto, velocidade, zona, ferramenta;
O comando de movimento circular é utilizado para mover o efetuador descrevendo

uma trajetória semicircular, que passa por dois pontos, saindo de um ponto inicial. Sua
estrutura segue o seguinte padrão:
MoveC ponto1, ponto2, velocidade, zona , ferramenta;
O acionamento de uma saída digital é realizado através da função "SetDO", onde o

nome da saída digital deve ser indicado, bem como o estado desejado:
SetDo doNome , estado;
Onde:
• doNome: Nome da saída digital.
• estado: Valor booleano desejado na saída (0 ou 1).
A maneira mais simples de marcar os pontos é movendo o robô para a posição

desejada e incluir uma instrução de movimento, que automaticamente cria os pontos
necessários para sua execução. O nome e a posição destes pontos podem ser modificados
manualmente. Há diferentes maneiras de mover o robô em modo manual, podendo ser
através de cada junta, movimento linear e por reorientação do efetuador. A seleção é feita no
FlexPendant, conforme mostrado na Figura 15. Após selecionar o modo de movimentação,
o braço pode ser movido através do joystick.
Figura 15: Seleção do modo de movimento pelo FlexPendant
Com o robô posicionado no ponto desejado, o editor de programa deve ser acessado
através do "Menu ABB", e as instruções de movimento adicionadas através da opção
"Adicionar Instrução". Para modificar a posição do ponto, basta selecioná-lo e clicar
na opção "Modificar Posição", localizada na parte inferior da interface do FlexPendant,
conforme mostrado na Figura 16.
À partir do FlexPendant é possível desenvolver a estrutura base do programa,
salvando pontos e programando instruções movimento. É recomendável prosseguir com o
desenvolvimento do código pelo software RobotStudio, que apresenta funcionalidades que
auxiliam durante a programação, como sugestões de preenchimento de comandos, entre
outros. Para isto, é necessário a conexão entre um computador com o software instalado e
o controlador IRC5 Compact.
Figura 16: Adicionar instrução pelo FlexPendant
Para que a comunicação entre o controlador e o computador com o software

RobotStudio seja estabelecida, é necessário que as placas de rede de ambos os equipamentos
estejam com endereços de IP configurados na mesma faixa.
O computador pode estar conectado ao robô pela porta ethernet ou pela service port,
situadas no painel traseiro do controlador, conforme indicado na Figura 3. O procedimento
para estabelecer a comunicação é realizado através da opção Add Controller, localizada na
aba Controller do software RobotStudio (Figura 17). Com o computador conectado pela
service port, a opção One Click Connect pode ser utilizada. Caso esteja conectado pela
porta ethernet, o software irá realizar a busca do controlador na rede através da opção
Add Controller.
Para prosseguir com a programação pelo RobotStudio, é necessário solicitar o
acesso para o controlador IRC5 Compact. O acesso é requerido na aba Controller, pela
opção Request Write Acces. A liberação deve ser concedida pelo FlexPendant, após o
surgimento de uma caixa de diálogo com as opções de permitir ou negar o pedido.
O primeiro passo é configurar as saídas digitais do controlador que serão usadas
no interfaceamento com o Arduino Uno. A lista de I/O do sistema pode ser encontrada
através da aba Controller, no ícone Configuration Editor. Na opção Signals, todos os
pontos de I/O do sistema podem ser visualizados. A Figura 18 mostra a configuração da
saída de abertura da mão robótica, que está mapeada como o bit 0 de saída do módulo
DSQC 652, assinado como BOARD10.
Figura 17: Adicionar controlador pela rede
Figura 18: Configuração de I/O pelo RobotStudio
O programa pode ser aberto através aba RAPID, localizada estrutura de arquivos
do RobotStudio. A tarefa principal, T_ROB1, possui uma rotina main. Ao clicar nesta
rotina, o editor de programa será aberto. O mesmo código, feito até então pelo Joystick,
aparecerá no editor de programa do software RobotStudio. O trecho de código a seguir foi
adaptado do programa original, onde são mostrados os exemplos de comando por juntas,
lineares e circulares, além do acionamento da saída de abertura da mão robótica:
1 MoveJ p10, v300, fine, tool0;

2 MoveL p20, v300, z10, tool0;
3 MoveC p30, v300, z20, tool0;
4 SetDO doAbreGarra, 1;
A Figura 19 mostra um exemplo de código no editor de texto do software RobotS-

tudio.
Figura 19: Exemplo de código no editor do RobotStudio
3.3.2 Alimentação do módulo DSQC 652

Um dos componentes que podem gerar dúvidas em relação ao controlador IRC5
Compact é o módulo de I/O DSQC 652. Geralmente, todos os pontos de entrada e saída
do mesmo já são mapeados para utilização no programa, porém, nada ocorre durante a
injeção de sinal em alguma entrada ou quando uma saída é acionada no programa.
Isto se deve ao fato de que o módulo não vem com seu circuito de alimentação
completo da fábrica. Além do mais, os diagramas de interligação existentes para auxiliar
na energização do componente não são claros.
A alimentação do módulo é realizado no conector XS10 localizado no painel traseiro
do controlador IRC5 Compact. As funções dos pinos do conector XS10 estão indicadas na
Tabela 2.
A interligação dos pinos deve ser feita como indicado na Figura 20.
Pino Descrição
1 24V
2 0V
3 0V Output
4 24V Output
5 0V Input
6 -
Tabela 2: Pinos do conector XS10
Fonte: ABB (2013)
Figura 20: Interligação do conector XS10
3.3.3 Interfaceamento entre o módulo DSQC 652 e o Arduino

Devido a incompatibilidade dos níveis de sinais utilizados pelo módulo DSQC 652
e o Arduino Uno, um circuito auxiliar deve ser desenvolvido para adequar os valores de
tensão dentro da faixa utilizada por cada equipamento.
As saídas digitais do módulo DSQC 652 apresentam um valor de tensão de 24V
para nível lógico alto e 0V para nível lógico baixo, enquanto as entradas digitais do Arduino
Uno trabalham com 0V e 5V nas mesmas condições.
Como estão sendo utilizadas apenas duas saídas do módulo DSQC 652, que são
interligadas em duas entradas digitais do Arduino Uno, um simples divisor de tensão
basta, desde que corretamente calculado, para que ocorra uma queda de tensão de 5V no
segundo resistor do circuito.
Os cálculos dos valores de resistência foram realizados fixando um dos resistores
com o valor comercial de 1kΩ. Como é sabido que a queda de tensão nesse resistor deve
ser de 5V, pela Lei de Ohm, pode ser calculada a corrente que passa pelo mesmo:
V = R2 × i ∴ 5 = 1k × i ∴ i = 5mA
Desconsiderando a carga, o divisor de tensão é um circuito série. Por isso, a corrente

que passa através de ambos os resistores é a mesma. Sabendo que a saída do módulo é de
24V, o valor do segundo resistor pode ser calculado:
V = (R1 + R2 ) × i ∴ 24 = (R1 + 1k) × 5m ∴ R1 = 3.8kΩ
O resistor comercial com valor mais próximo de 3.8kΩ, é de 3.9kΩ. O Arduino

considera, em média, tensões acima de 2.5V como nível alto. Portanto, adotando o valor
de 3.9kΩ, há uma queda de tensão no resistor R2 levemente abaixo dos 5V, mas que não
compromete o funcionamento do circuito. O esquema eletrônico é mostrado na Figura 21.
Figura 21: Divisor de tensão
3.3.4 Programação do Arduino Uno

Utilizando as bibliotecas do rosserial, é possível usar as classes do ROS na pro-
gramação do Arduino Uno para publicação em tópicos de maneira direta, através da
comunicação serial entre a placa e o computador.
Como a função do Arduino neste projeto é enviar os comandos de abre e fecha
para a mão robótica BH8-282, este está programado para publicar no tópico de comandos
do controlador bhand_controller.
O tópico /bhand_node/command recebe mensagens do tipo sensor_msgs/JointState
para controlar as juntas da mão robótica. O Arduino está programado para enviar
mensagens deste tipo.
As partes mais importantes do código serão explicadas, entretanto, a versão com-

pleta do mesmo se encontra no apêndice A deste trabalho.
A classe sensor_msgs/JointState.h deve ser incluída no código para que um objeto
deste tipo seja instanciado. A declaração pode ser feita da seguinte maneira:
sensor_msgs::JointState BarrettCommands;
Esta variável carregará os dados que serão publicados no tópico de destino. Para
declarar o publisher, é necessário definir o tópico que receberá a mensagem e indicar a
variável como um ponteiro:
ros::Publisher Bhand_Publisher("/bhand_node/command", &BarrettCommands);
O controlador bhand_controller define, por padrão, nomes e sequencias fixas das

juntas da mão robótica nos arrays da mensagem. Valores constantes de velocidade e esforço
também foram adotados. Como estes dados não mudam, os mesmos podem ser carregados
em variáveis constantes para facilitar o entendimento do código:
1 char *names[] = {"bh_j11_joint", "bh_j32_joint", "bh_j12_joint",

2 "bh_j22_joint"};
3 float vel[] = {0.1, 0.1 , 0.1, 0.1};
4 float effort[] = {0.0, 0.0 , 0.0, 0.0};
Quando uma variável que utiliza múltiplos arrays é declarada, o tamanho de cada
um destes arrays deve ser atribuído. Isto pode ser feito uma única vez na função setup(),
que é executada apenas no momento em que o Arduino é ligado:
1 void setup() {
2 BarrettCommands.name_length = 4;
3 BarrettCommands.velocity_length = 4;
4 BarrettCommands.position_length = 4;
5 BarrettCommands.effort_length = 4;
6 }
As posições aberta e fechada da mão robótica foram identificadas, e seus valores

nestas situações foram armazenados em dois vetores distintos:
1 float open_Position[] = {3.14, 0 , 0, 0};

2 float close_Position[] = {3.14, 2.44 , 2.44, 2.44};
O envio dos comandos será associado ao estado das entradas digitais da placa
microcontrolada. Cada posição será publicada de acordo com a combinação de sinais lidas
pelo Arduino. O trecho de código a seguir foi adaptado do código original para exemplificar
a publicação da posição aberta:
1 void loop() {
2 if (digitalRead(AbreFechaMao_In) {
3 BarrettCommands.position = open_Position;
4 delay(1500); }
5 Bhand_Publisher.publish( &BarrettCommands );
6 nh.spinOnce(); }
3.3.5 Colocando a primeira estratégia de integração em operação

O completo funcionamento do sistema exige a inicialização do controlador
bhand_controller para gerenciamento da mão robótica BarrettHand BH8-282, a sincroni-
zação entre o Arduino Uno e o ROS para que os comandos de posição da mão robótica
sejam publicados, além da execução do programa do controlador IRC5 Compact para a
movimentação do braço robótico.
O controlador da mão robótica deve ser iniciado digitando o seguinte comando em
um terminal do Linux:
$ roslaunch bhand_controller bhand_controller.launch
Para colocar a mão robótica em estado operacional, outro comando deve ser digitado
em um novo terminal. Este exige um pouco de atenção, já que a mão será movimentada
para o seu estado inicial:
$ rosservice call /bhand_node/actions "action: 1"
Com o Arduino Uno conectado ao computador através de uma porta USB, é

necessário identificar qual o número da porta serial emulada pelo mesmo. Supondo que a
porta serial seja a ACM0, o seguinte comando deve ser digitado no terminal do Linux:
$ rosrun rosserial_python serial_node.py /dev/ttyACM0
Quando a sincronia entre o ROS e o Arduino Uno estiver concluída, uma mensagem
de confirmação é exibida no terminal.
Finalmente, a programação do robô deve ser executada. Isto pode ser feito através
do FlexPendant. Primeiramente, a opção "Depurar" deve ser selecionada, seguida da opção
"PP para principal". Esta ação coloca o ponteiro do programa na primeira linha da função
main(). O botão Play, localizado na parte frontal do FlexPendant, deve ser pressionado
para a execução do programa.
Figura 22: Executando o programa pelo FlexPendant
3.4 Estratégia de integração utilizando o ROS como sistema cen-

tral
No segundo método proposto, o objetivo é que o controle do braço manipulador e
da mão robótica seja feito através de um único ambiente, no caso, o ROS. As trajetórias
do braço são planejadas através do computador, pelo software MoveIt!. É necessário criar
diferentes tipos de arquivos para que seja gerado um pacote do MoveIt!, que nos fornece
uma interface amigável para interação com o robô. As trajetórias são transferidas para o
controlador do braço robótico, o IRC5 Compact, através de um socket do ROS Industrial.
Como explicado na seção 3.1, a mão robótica é gerenciada pelo controlador
bhand_controller. A mão robótica não está sendo controlada pelo MoveIt!, mas sim
por um nó independente, onde a posição de suas juntas podem ser modificadas livremente.
Apesar disso, este efetuador também é representado graficamente no MoveIt!, mostrando
a posição real de seus elos e juntas.
3.4.1 Criação do arquivo URDF

O primeiro pré-requisito para criar um pacote do MoveIt! é gerar um modelo
unificado, que dá todas as informações sobre os elementos de um robô, chamado de URDF.
O URDF é um arquivo no formato XML, e nele estão contidas informações sobre
dimensões dos elos, tipos de juntas, limites de posições, entre outros. Para a criação do
arquivo URDF, é necessário retirar algumas informações do datasheet do robô, como o
tipo, limite e velocidade de cada junta, além das dimensões dos links.
No site oficial da ABB é disponibilizado o modelo CAD do robô IRB 120. Também
é possível obter o modelo CAD da mão robótica BarrettHand BH8-282 no site oficial da
Barrett Technology.
Com o modelo CAD dos dois equipamentos, é possível realizar uma montagem
no software SolidWorks. Com a montagem feita, é necessário realizar o download e fazer
a instalação de um add-in para o SolidWorks, chamado SolidWorks to URDF Exporter.
Este add-in permite a exportação dos elos e montagens do SolidWorks para o formato
URDF de uma maneira muito simples e rápida. (SOLIDWORKS. . . , 2015)
A Figura 23 mostra um exemplo de configuração para um elo específico da cadeia
cinemática, no caso, o elo 2. Com excessão da base, todo elo possui um parent link, onde o
mesmo está acoplado, e um child link, que estará acoplado a ele. Todas as configurações
deverão ser feitas individualmente, elo a elo.
Figura 23: Configuração dos parâmetros para o link 2
No caso da mão robótica, a base terá três child links, que são os dedos. Apesar da
maioria das juntas da montagem serem de rotação, o SolidWorks tem dificuldades para
detectar os eixos das juntas rotacionais automaticamente e, provavelmente, o programa
travaria no momento da exportação. Para evitar isso, as juntas devem ser configuradas
inicialmente como Fixed e, posteriormente, o arquivo gerado deve ser alterado manualmente.
A estrutura final pode ser vista na Figura 24. Basta clicar no botão Preview and
Export, prosseguir pelas janelas e finalizar. Todas as configurações que poderiam ser feitas
nestas janelas serão feitas manualmente, editando o arquivo URDF.
Figura 24: Configuração final da montagem
O resultado da exportação é uma pasta com duas subpastas. Em uma delas há

os meshes do modelo, e na outra, está contido o arquivo de extensão .urdf. Esta pasta
deve ser transferida para o computador com Ubuntu, para que seja possível realizar as
alterações no arquivo e testá-la no visualizador de URDF do ROS.
Os dados de limites das juntas, velocidade máxima e tamanho dos elos são encon-
trados no datasheet dos equipamentos. Os dados para o braço ABB IRB 120 estão sendo
mostrados na Tabela 3.
Os dados para a mão robótica Barrett Hand BH8-282 também podem ser encon-
trados em seu datasheet, conforme mostrado na Tabela 4.
Com os dados das Tabelas 3 e 4, os valores no arquivo URDF devem ser modificados.
Como exemplo, pode ser visto no trecho de código a seguir, o arquivo modificado para a
junta 2.
1 <joint name="joint_2" type="revolute">

2 <origin rpy="0 0 0" xyz="0 0 0.29"/>
3 <parent link="link_1"/>
4 <child link="link_2"/>
5 <limit effort="0" lower="-1.91986" upper="1.91986" velocity="4.36332"/>
6 <axis xyz="0 1 0"/>
7 <dynamics damping="0.0" friction="0.0"/>
8 </joint>
Eixos Limites (°) Limites (rad) Vel. máx. (º/s) Vel. máx. (rad/s)
Junta 1 +165 a -165 +2.88 a -2.88 250 4.36
Junta 2 +110 a -110 +1.92 a -1.92 250 4.36
Junta 3 +70 a -110 +1.22 a -1.92 250 4.36
Junta 4 +160 a -160 +2.79 a -2.79 320 5.58
Junta 5 +120 a -120 +2.09 a -2.09 320 5.58
Junta 6 +400 a -400 +6.98 a -6.98 420 7.33
Tabela 3: Limites de junta do braço ABB IRB 120
Fonte: ABB (2013)
Eixos Limites (°) Limites (rad) Vel. máx. (º/s) Vel. máx. (rad/s)
J11 - Spread dedo 1 0 a -180 0 a -3.14 360 6.28
J21 - Spread dedo 2 0 a -180 0 a -3.14 360 6.28
J12 - Base dedo 1 0 a -140 0 a -2.44 140 2.44
J13 - Médio dedo 1 0 a -45 0 a -0.78 45 0.78
J22 - Base dedo 2 0 a -140 0 a -2.44 140 2.44
J23 - Médio dedo 2 0 a -45 0 a -0.78 45 0.78
J32 - Base dedo 3 0 a -140 0 a -2.44 140 2.44
J33 - Médio dedo 3 0 a -45 0 a -0.78 45 0.78
Tabela 4: Limites de junta da mão BarrettHand BH8-282
Fonte: Barrett Technology Inc. (2013)
A mão robótica possui quatro motores para movimentar suas juntas, sendo três
deles responsáveis por abrir e fechar os dedos e o último para efetuar o espalhamento dos
dedos laterais, conforme mostrado na Figura 25.
Neste caso específico, existem juntas diferentes que são movimentadas pelo mesmo
motor. Isso tem que ser levado em consideração no arquivo URDF, visto que quando
enviarmos um comando de spread para os dedos laterais, ambos terão que se movimentar.
No caso de fechamento e abertura dos dedos, as juntas base e média de cada conjunto se
movimentarão proporcionalmente ao comando enviado.
Figura 25: Movimento das juntas da BarrettHand BH8-282
Fonte: Ben-Tzvi e Moubarak (2011)
A relação entre juntas movimentadas por um mesmo elemento pode ser facilmente
configurada no arquivo URDF através da adição da TAG <mimic>. Para utilizá-la, basta
que a TAG seja inserida nas configurações da junta escolhida para receber o comando. O
valor recebido pela junta principal será transferido para a junta secundária, multiplicado
por um fator de correção.
Um exemplo da utilização da TAG pode ser observado na configuração da junta
base do dedo número 1, onde a junta média receberá o valor da junta base multiplicado
pelo fator 0.31. Este valor não foi encontrado empiricamente, basta que façamos uma
relação entre o range da junta base, que é 180° e o range da junta média, que é 45°.
1 <joint name="finger_1_dist_joint" type="revolute">

2 <origin xyz="-0.069936 0.003 0"
3 rpy="1.6787E-18 -3.6382E-15 -6.1073E-33" />
4 <parent link="finger_1_med_liink" />
5 <child link="finger_1_dist_link" />
6 <axis xyz="0 0 1" />
7 <limit lower="-0.785" upper="0" effort="0" velocity="0" />
8 <mimic joint="bh_j12_joint" multiplier="0.31" offset="0.0"/>
9 </joint>
A TAG <mimic> deve ser adicionada para os três dedos, tanto na abertura e
fechamento, quando para o espalhamento. O arquivo URDF completo está nos anexos do
trabalho.
Após todas as modificações, o arquivo URDF já pode ser visualizado através de
uma ferramenta para compilação e visualização disponível no ROS. Para utilizá-la, basta
abrir o terminal do linux, acessar o diretório onde está o arquivo URDF e digitar o comando
mostrado.
$ roslaunch urdf_tutorial display.launch model:=irb120_Bhand.urdf gui:=True
O parâmetro model deve receber o nome do arquivo URDF, enquanto o parâmetro

gui deve receber true para que o comando seja executado com interface gráfica. Se o
arquivo for compilado normalmente, o resultado será parecido com a Figura 26.
Figura 26: Modelo final IRB 120 e BarrettHand BH8-282
3.4.2 Preparando o pacote do MoveIt!

O MoveIt! será o software utilizado para o planejamento das trajetórias do manipula-
dor robótico IRB 120. Esta ferramenta fornece um assistente de configuração extremamente
intuitivo para a criação dos arquivos de configuração. Para executar o assistente, basta
digitar no terminal do Ubuntu:
$ roslaunch moveit_setup_assistant setup_assistant.launch

Uma interface parecida com a figura 27 será aberta. O arquivo URDF criado na
seção anterior será utilizado. Como será criado um novo pacote, basta clicar no botão
Create new MoveIt Confguration Package e, posteriormente, procurar e carregar o arquivo
URDF clicando no botão Browse. Com o arquivo URDF carregado, podemos iniciar o
processo de configuração do pacote.
Figura 27: MoveIt! Setup Assistant
O primeiro passo é gerar a matriz de autocolisão do robô, que pode ser calculada na
aba Self-Collisions. A matriz é calculada automaticamente, bastando definir a quantidade
de posições randômicas que o algoritmo irá submeter ao robô para checar as autocolisões.
O valor padrão é de 10000 posições. Para gerar a matriz, basta clicar no botão Regenerate
Default Matrix Collision.
É necessário definir uma junta virtual para "conectar"o robô com o quadro de
referência externa do MoveIt!. Isto pode ser feito na aba Virtual Joints. No caso do braço
IRB 120, esta conexão é feita através do elo da base. Portanto, um nome deve ser dado para
esta junta virtual, sendo que seu child link será a própria base do manipulador robótico.
A etapa mais importante da configuração é a criação dos grupos de planejamento.
Neste caso, apenas um grupo será criado, que é o do braço manipulador, pois a mão
robótica será tratada apenas como um efetuador e não fará parte dos cálculos cinemáticos.
Na aba Planning Groups, um grupo pode ser criado clicando no botão Add Group. Deve
ser dado um nome para este grupo. O plugin responsável pelos cálculos cinemáticos será o
KDL, que deve ser selecionado na segunda aba. É recomendável manter os valores padrão
de resolução, tempo de estouro e tentativas de cálculo. Para finalizar, basta clicar no botão
Add Joints e selecionar as juntas do braço robótico. Um exemplo de configuração pode ser
visto na Figura 28.
Figura 28: MoveIt! Planning Group
Para finalizar a configuração, os arquivos podem ser gerados na aba Configuration

Files. Um caminho deve ser especificado para que os arquivos sejam salvos. Para que seja
criada uma boa estrutura de arquivos, é ideal que exista uma pasta geral dentro da pasta
src do ROS, e que todos os pacotes do projeto sejam suas subpastas.
3.4.3 Configuração do socket de comunicação

Com o pacote do MoveIt! criado, os pontos gerados para a execução da trajetória
calculada devem ser transferidos para o braço robótico real. É possível encontrar, nas
bibliotecas do ROS Industrial, um socket de comunicação para robôs ABB.
O socket é composto por uma arquitetura cliente-servidor, e deve ser configurado
tanto no computador, que será o cliente, quanto no controlador IRC5 Compact, que será o
servidor.
3.4.3.1 Configuração do socket servidor
O socket servidor é um conjunto de seis módulos desenvolvidos para a interação

com os braços robóticos. Eles são programados utilizando a linguagem RAPID e este
socket pode ser usado apenas em robôs da ABB (MARTíN, 2013).
Cada módulo é responsável por uma determinada tarefa:
• ROS_stateServer.mod: Módulo responsável por enviar as posições atuais das

juntas para o socket cliente.
• ROS_motionServer.mod: Módulo responsável por receber as posições das juntas

do socket cliente.
• ROS_motion.mod: Módulo responsável receber as trajetórias do módulo

ROS_motion_server.mod e colocar o robô em movimento.
• ROS_messages.sys: Módulo responsável pelas conversões dos tipos de mensagens

utilizados pelo socket e pela linguagem RAPID.
• ROS_socket.sys: Módulo responsável pela criação e gerenciamento do socket. Este

estabelece comunicação com o cliente e efetua a troca de mensagens.
• ROS_common.sys: Módulo responsável pela interação entre as tarefas, que lida

com parâmetros utilizados por tarefas diferentes.
Todos estes módulos são encontrados no wiki do ROS Installing. . . (2015) e devem
ser incluídos no controlador IRC5 Compact.
Antes que a transferência de arquivos seja iniciada, uma modificação no arquivo
ROS_motion.mod deve ser feita. Como a tarefa main provavelmente já existe no controla-
dor, seu nome deve ser mudado. Uma sugestão seria alterar seu nome para ROS_main,
como mostrado no seguinte trecho de código:
1 PROC ROS_main()
2 VAR num current_index;
3 VAR jointtarget target;
4 VAR speeddata move_speed := v10; ! default speed
5 VAR zonedata stop_mode;
6 VAR bool skip_move;
Feita a modificação, os seis arquivos devem ser copiados para um pen drive. No
flex pendant existe uma entrada USB que pode ser utilizada. Estes arquivos devem ser
copiados para uma pasta dentro do diretório HOME do controlador. Todo o procedimento
será realizado assumindo que a pasta criada no diretório tenha o nome ROS.
Após a cópia dos arquivos, as tarefas devem ser criadas seguindo o caminho:
Menu ABB -> Painel de Controle -> Configurações -> Tópicos ->
Controlador -> Tarefas
Name Type Trust Level Entry Motion Task

ROS_stateServer SEMISTATIC NoSafety main NO
ROS_motionServer SEMISTATIC SysStop main NO
T_ROB1 NORMAL main YES
Tabela 5: Tarefas a serem criadas no controlador
Fonte: (INSTALLING. . . , 2015)
As tarefas devem ser criadas exatamente como na Tabela 5.

Após a criação das tarefas, os módulos devem ser carregados, seguindo o seguinte
caminho:
Menu ABB -> Painel de Controle -> Configurações -> Tópicos ->
Controlador -> Carregamento automático de módulos
As entradas devem ser adicionadas exatamente como na Tabela 6.

File Task Installed All Tasks Hidden
HOME:/ROS/ROS_common.sys NO YES NO
HOME:/ROS/ROS_socket.sys NO YES NO
HOME:/ROS/ROS_messages.sys NO YES NO
HOME:/ROS/ROS_stateServer.mod ROS_stateServer NO NO NO
HOME:/ROS/ROS_motionServer.mod ROS_motionServer NO NO NO
HOME:/ROS/ROS_motion.mod T_ROB1 NO NO NO
Tabela 6: Módulos a serem carregados no controlador
Fonte: (INSTALLING. . . , 2015)
Após as configurações, o controlador deve ser reiniciado para que os módulos sejam
carregados.
3.4.3.2 Configuração do socket cliente
A camada cliente é a responsável por enviar e receber as posições das juntas do

controlador. É composta basicamente por dois tópicos importantes:
• /joint_states: tópico que recebe a posição atual do robô.
• /joint_path_command: Tópico que envia as posições das juntas para o contro-

lador, após a geração de uma nova trajetória.
Todos os pacotes da camada cliente são obtidos através do repositório Levi. . .

(2015), disponível no GitHub, que contém os drivers para comunicação com robôs ABB e
também um pacote experimental que possui o socket de comunicação com o robô IRB 120.
O download dos arquivos pode ser feito diretamente da página ou clonado para a pasta de
preferência, dentro do ambiente do ROS.
O próximo passo é realizar as modificações nos arquivos baixados para que o socket
envie as trajetórias geradas pelo pacote do MoveIt! criado na subseção 3.4.1.
A primeira modificação deve ser feita na pasta de configurações do pacote
abb_irb120_support. O arquivo joint_names_irb120.yaml deve conter o nome exato
das seis juntas relativas ao robô IRB 120, criadas no arquivo URDF:
1 controller_joint_names: ['joint_1', 'joint_2', 'joint_3', 'joint_4',

2 'joint_5', 'joint_6']
As pastas meshes e urdf presentes neste pacote devem ser substituídas pelas
pastas de mesmo nome, criadas na subseção 3.4.1.
No diretório launch do pacote abb_irb120_moveit_config existe o arquivo
moveit_planning_execution.launch, que não é gerado pelo assistente de configuração
do MoveIt!. Uma cópia deste arquivo deve ser feita para dentro da pasta launch do pacote
criado na subseção 3.4.1.
Após a cópia do arquivo, algumas modificações devem ser realizadas. Primeiramente,
todas as referências para o pacote abb_irb120_moveit_config devem ser substituídas
pelo nome do pacote criado na subseção. 3.4.1, que foi nomeado de irb120_bhand_moveit.
Isto pode ser feito utilizando o software gedit, através da ferramenta replace.
No ROS, o pacote joint_state_publisher pode ser utilizado para ler a descrição
das juntas de um robô e publicar mensagens do tipo sensor_msgs/JointState através
de uma interface gráfica interativa, em que os valores das juntas são modificados atra-
vés de barras de rolagem. Por este motivo, devemos incluir um trecho de código neste
arquivo para realizar a chamada da interface gráfica. Por padrão, este pacote publica
diretamente no tópico /joint_states. Como o MoveIt! utiliza este tópico para atualizar
a posição real do robô, as publicações serão remapeadas para outro tópico, chamado de
/joint_states_barrett. Isto pode ser feito adicionando o o seguinte trecho de código ao
arquivo moveit_planning_execution.launch:
1 <node name="joint_state_publisher" pkg="joint_state_publisher"

2 type="joint_state_publisher">
3 <param name="/use_gui" value="true"/>
4 <rosparam param="/source_list">
5 [/move_group/fake_controller_joint_states]</rosparam>
6 <remap from="joint_states"
7 to="joint_states_barrett" />
8 </node>
Desta maneira, sempre que o valor de alguma junta for alterado através da interface
joint_state_publisher, uma mensagem será enviada através do tópico /joint_states_barrett.
Um nó pode ser criado para subescrever esta mensagem e publicar a posição desejada para
o controlador da mão robótica, o bhand_controller, e também a posição real da mesma
para visualização no MoveIt!, como será explicado na subseção 3.4.4.
3.4.4 Desenvolvimento do nó de controle da mão robótica

As mensagens geradas pela alteração dos valores das juntas através da interface
gráfica joint_state_publisher são utilizadas para enviar os comandos ao controlador da
mão robótica BH8-282 e atualizar sua posição real na interface gráfica do MoveIt!.
Um nó do ROS foi criado para receber as mensagens que trafegam pelo tópico
/joint_states_barrett, enviá-las para o controlador bhand_controller através do tópico
/bhand_node/commands e atualizar a posição de suas juntas na interface gráfica do
MoveIt!, através do tópico /joint_states. Desta forma, este nó tem a função de publisher e
subscriber simultaneamente.
Para iniciar o desenvolvimento do nó, que foi programado em C++, deve-se escolher
o pacote em que são apontadas as dependências necessárias para a compilação do programa
e geração de seu arquivo executável. O pacote pode ser o mesmo gerado pelo setup assistant
do MoveIt!. Para isso, é necessário criar uma pasta src e o arquivo CMakeLists.txt do
pacote deve sofrer algumas alterações.
Iniciando o desenvolvimento do programa, um arquivo com o nome JointStatesBar-
rett.cpp deve ser criado dentro da pasta src. Os trechos mais relevantes do código serão
explicados, entretanto sua versão completa se encontra no apêndice C deste trabalho.
Sempre que for enviado uma mensagem através do tópico /joint_states_barret, a
parte do programa responsável por subescrever este tópico executará uma função, chamada
de callback, que carregará os dados desta mensagem, permitindo a manipulação dos mesmos
e tomada de ações. Dentro da função de callback, os dados desta mensagem podem ser
recebidos e publicados nos tópicos responsáveis por controlar a mão robótica e atualizar o
estado da mesma na interface do MoveIt!
A declaração dos publishers e subscribers são feitas na função main(). Para o
subscriber, deve ser indicado qual tópico será subescrito, o tamanho do buffer e o nome da
função de callback que será gerada quando algum evento ocorrer. No caso dos publishers,
devem ser indicados qual o tipo da mensagem e em qual tópico será publicado, além do
tamanho do buffer, conforme o seguinte trecho de código:
1 ros::Subscriber sub = n.subscribe("joint_states_barrett", 1000,

2 JointStatesCallback);
3 BarrettHandPub_Control =
4 n.advertise<sensor_msgs::JointState>("/bhand_node/command", 1000);
5 BarrettHandPub_Moveit =
6 n.advertise<sensor_msgs::JointState>("/joint_states", 1000);
A declaração da função de callback deve conter o tipo da mensagem e a variável

que irá receber os dados da mesma. No arquivo URDF, o range de valores dos ângulos
das juntas da mão robótica estão com valores negativos, conforme consta na Tabela 4.
Portanto, os valores recebidos na função de callback serão valores negativos de posição.
Para que o controlador bhand_controller posicione corretamente a mão robótica BH8-282,
os valores enviados precisam ser positivos. Os dados da mensagem deverão ser tratados,
enviando os valores negativos para a representação no MoveIt! e os valores positivos
para o bhand_controller. A declaração da função de callback e a atribuição de valores da
mensagem a um vetor auxilicar pode ser observada no seguinte trecho de código:
1 void JointStatesCallback(const sensor_msgs::JointState & msg)

2 {
3 float BarrettPosition[4];
4 sensor_msgs::JointState BarrettCommandsControl,
5 BarrettCommandsMoveIt;
6 ros::Rate loop_rate(10);
7
8 BarrettPosition[0] = msg.position[9];
Estes valores podem ser recebidos e publicados dentro da função de callback. Como
exemplo, o seguinte trecho de código traz uma adaptação do código final, que publica a
posição, velocidade e esforço de uma determinada junta:
1 BarrettCommandsControl.name.push_back("bh_j11_joint");
2 BarrettCommandsControl.position.push_back(BarrettPosition[0]);
3 BarrettCommandsControl.velocity.push_back(0.1);
4 BarrettCommandsControl.effort.push_back(0.0);
5
6 BarrettHandPub_Control.publish(BarrettCommandsControl);
Outro fator que pode ser melhorado é o tratamento de mensagens recebidas da

interface /joint_state_publisher. Mesmo que as juntas não sofram alteração de posição,
as mensagens são geradas da mesma maneira e em uma frequência muito alta. Não há
necessidade de transferir as publicações de mesmo valor para os tópicos de controle da
mão e visualização do MoveIt!. Por este motivo, o código foi programado para apenas
publicar posições recebidas que forem diferentes das últimas publicadas.
Iniciando as modificações no arquivo CMakeLists.txt, é necessário encontrar pacotes
externos para a compilação do programa. Alguns componentes devem ser incluídos na
função find_package(), conforme o trecho de código a seguir:
1 find_package(catkin REQUIRED COMPONENTS roscpp rospy std_msgs

2 message_generation)
Para a completa compilação, referenciando as bibliotecas externas necessárias e

criação do arquivo executável, o seguinte trecho de código também deve ser adicionado:
1 add_executable(JointStatesBarrett src/JointStatesBarrett.cpp)
2 target_link_libraries(JointStatesBarrett ${catkin_LIBRARIES})
3 add_dependencies(JointStatesBarrett
4 irb120_bhand_moveit_generate_messages_cpp)
O código está pronto para ser compilado. Isto pode ser feito através do terminal do
linux. Supondo que o ambiente do ROS foi instalado na pasta home, os seguintes comandos
devem ser digitados em sequencia:
$ cd catkin_ws/src
$ catkin_make
3.4.5 Alteração no controlador Bhand Controller

Por padrão, o controlador bhand_controller também utiliza o tópico /joint_states
para publicar a posição das juntas. Para evitar interferências com a interface gráfica do
MoveIt!, o nome do tópico utilizado pelo nó do controlador precisa ser alterado.
Esta alteração deve ser feita no arquivo bhand_node.py, que se encontra na pasta src
do pacote do controlador. Existe uma parte do código em que os publishers são declarados,
local em que deve ser feita a alteração. O novo nome escolhido foi /joint_states_bhand, e
foi adotado conforme o trecho de código:
1 self._joints_publisher = rospy.Publisher('/joint_states_bhand', JointState,

2 queue_size=5)
3.4.6 Colocando a segunda estratégia de integração em operação

Primeiramente, o controlador IRC5 Compact deve estar preparado para colocar
o robô em movimento no momento em que receber as mensagens do computador. As
tarefas do socket servidor sempre estarão em execução, pois foram configuradas como
semi-estáticas no momento de sua criação. Portanto, o controlador está apto a se conectar
com o socket cliente e estabelecer a comunicação, sem necessidade de interferência do
usuário.
Entretanto, mesmo que receba as mensagens do socket cliente, o robô não realiza
qualquer ação até que o usuário execute a função de movimento programada na tarefa
T_ROB1. A tarefa pode ser executada tanto em modo manual quanto em modo automático.
Tarefas executadas em modo manual exigem que o usuário esteja com o FlexPendant
em mãos, acionando a chave deadman durante toda a operação. Por este motivo, por uma
questão de flexibilidade, o robô deve ser utilizado em modo automático.
A chave do modo de operação, localizada no painel traseiro do controlador IRC5
Compact (Figura 3), deve ser virada para o modo automático. Uma mensagem de confir-
mação de mudança de modo aparecerá no FlexPendant, devendo ser confirmada. Logo
em seguida, o botão Motors On, também localizado no painel traseiro do controlador,
deve ser pressionado. A patir deste momento, os motores já se encontram habilitados.
Para executar a tarefa de movimento, o botão play, localizado no FlexPendant, deve ser
pressionado em seguida.
Com o socket servidor em execução, os serviços do socket cliente devem entrar em
operação para que a conexão seja estabelecida. Primeiramente, criaremos uma conexão
com o robô digitando o seguinte comando no terminal do linux:
$ roslaunch abb_irb120_support robot_interface_download_irb120.launch

robot_ip:=192.168.125.1
O parâmetro robot_ip deve ser igual ao endereço de IP configurado na porta LAN do

controlador IRC5 Compact. Caso a conexão não seja estabelecida, pode ser devido à algum
erro na definição dos endereços de IP dos equipamentos, que devem estar obrigatoriamente
na mesma faixa. Para certificar que estes estão configurados corretamente, um simples
teste de ping pode ser feito do computador. Se os endereços de IP estiverem na mesma
faixa e não houver resposta no teste de ping, o cabo de rede ou qualquer outro meio físico
de comunicação utilizado deve ser verificado.
Com a conexão estabelecida, a interface do MoveIt! pode ser executada e, em
paralelo com a mesma, a interface gráfica /joint_state_publisher também será chamada,
com a execução do arquivo launch modificado na sub-subseção 3.4.3.2. Em outro terminal,
o seguinte código deverá ser digitado:
$ roslaunch irb120_bhand_moveit moveit_planning_execution.launch
Para iniciar o controlador da mão robótica Barrett Hand BH8-282, o comando a

seguir deve ser digitado em outro terminal:
$ roslaunch bhand_controller bhand_controller.launch
Para colocar a mão robótica em estado operacional, outro comando deverá ser
digitado em um novo terminal. Este exige um pouco de atenção, já que a mão será
movimentada para o seu estado inicial:
$ rosservice call /bhand_node/actions "action: 1"
Por fim, o nó criado na subseção 3.4.4 deve ser executado:
$ rosrun irb120_bhand_moveit JointStatesBarrett
Com a execução de todos os processos, a interação com o robô manipulador e a

mão robótica pode ser feita através de suas interfaces, conforme mostrado na Figura 29. O
planejamento de trajetórias pode ser realizado posicionando manualmente o robô no ponto
desejado. O movimento será executado clicando no botão Plan and Execute. A interação
com a mão robótica é feita através da interface Joint States Publisher, alterando a posição
de suas juntas através das barras de rolagem.
Figura 29: Interfaces do MoveIt! e Joint State Publisher

52
4 Experimentos e discussão dos resultados
Os experimentos descritos nesta seção visam aplicar as formas distintas de integração

entre o braço robótico ABB IRB 120 e a mão robótica BarrettHand BH8-282 propostas
neste trabalho.
A primeira estratégia, que mantém o controlador IRC5 Compact como elemento
principal e utiliza a placa Arduino Uno para o interfaceamento com a mão robótica, foi
aplicado em uma demonstração durante o 24th World Mining Congress, um congresso
mundial de mineração que, no ano de 2016, foi sediado na cidade do Rio de Janeiro. Na
ocasião, a companhia Vale S/A era uma das patrocinadoras do evento e possuía um estande
no local, onde destacava seus maiores projetos e investimentos em tecnologia e inovação.
O objetivo da demonstração era que o braço, com a mão robótica acoplada em
seu punho, desenhasse a logomarca da Vale S/A em sua versão monocromática, além de
escrever a frase: "Vale invests in technology"; que afirma o investimento em tecnologia
por parte da empresa. Como ferramenta de desenho, foi adaptada uma caneta do tipo
pincel em um tubo com molas, a fim de oferecer complacência ao toque da caneta junto
à superfície de desenho. Um suporte foi construído para armazenamento da ferramenta,
que teria que ser segurada pela mão robótica e, ao final do desenho, colocada de volta no
suporte. A trajetória final do braço era um movimento de aceno para o público, conforme
mostrado na Figura 30.
Figura 30: Conjunto do braço e mão robótica no World Mining Congress
Fonte: Vale S/A

Capítulo 4. Experimentos e discussão dos resultados 53
A logomarca da empresa teria que ser desenhada com grande precisão nos detalhes,
respeitando a proporção e o espaço entre seus elementos constituintes. O desenho só poderia
ser apresentado ao público após passar por uma avaliação da equipe de comunicação da
Vale S/A, onde seria constatada a fidelidade entre o modelo base da logomarca e o que
foi efetivamente desenhado. Isto exige a marcação precisa dos pontos que servem como
base para a geração das trajetórias, além de uma estrutura mecânica firme que reduza as
vibrações inerentes ao movimento do robô. Devido a vibração causada pela execução do
sistema, foi necessário reduzir a velocidade de movimento do braço para eliminar pequenas
imperfeições geradas em decorrência deste fato.
A demonstração foi presenciada pelos milhares de participantes do evento e ganhou
destaque nos meios de comunicação. A Figura 31 registra o momento em que Murilo
Ferreira, Diretor Presidente da Vale S/A, presencia a performance do sistema.
Figura 31: Sistema em execução durante o World Mining Congress
Fonte: Vale S/A
A programação do braço foi realizada com comandos de movimento por juntas,

lineares e circulares, além do acionamento de saídas digitais e utilização de loops de controle.
O código do sketch do arduino e o código em linguagem RAPID para programação do
controlador IRC5 Compact estão, respectivamente, nos apêndices A e B deste trabalho.

Um ponto de destaque é em relação a robustez do sistema. A demonstração foi
realizada inúmeras vezes, por quatro dias seguidos. Devido às restrições de espaço, o
controlador IRC5 Compact foi armazenado, junto com o controlador da mão robótica e o
Arduino Uno, em local fechado e com pouca ventilação. Devido a dissipação de calor do
mesmo, que é um equipamento industrial, o ambiente estava com a temperatura interna
elevada. Mesmo nestas condições, não ocorreu nenhuma falha durante a execução das
demonstrações.
A segunda abordagem proposta, que utiliza o ROS como sistema central para
comando da mão robótica e geração de trajetórias do robô, foi testado em laboratório
quanto à fidelidade de execução, pelo sistema, da trajetória gerada pelo software MoveIt!,
bem como sua ferramenta de desvio de obstáculos.
Durante o primeiro teste, o braço robótico foi posicionado interativamente, através
da interface gráfica do MoveIt!, em algum ponto de seu espaço de trabalho e foi dado o
comando para planejamento da trajetória da posição corrente até a posição objetivo. Como
resultado, o manipulador segue fielmente a trajetória gerada. Um exemplo de posição final
solicitada através do software e executada pelo hardware pode ser observada na Figura 32.
Figura 32: Exemplo de posição simulada pelo robô virtual e executada pelo robô real
Outra funcionalidade interessante que a ferramenta MoveIt! oferece é o desvio de

obstáculos. Diferentes tipos de objetos podem ser incorporados na cena, com opções de
ajuste de posição e orientação. A Figura 33 mostra um objeto incorporado à cena. A
mesma figura mostra o caminho feito pelo manipulador para evitar a colisão com o objeto.
Claramente, a maneira mais simples de atingir o ponto final seria através de uma trajetória
linear, onde fatalmente ocorreria a colisão entre o efetuador e o objeto. O próprio software
identifica a colisão com o obstáculo e calcula a melhor trajetória para que o desvio ocorra.
Figura 33: Exemplo de trajetória planejada com desvio de obstáculo e pose final executada pelo robô real
4.1 Comparação entre as estratégias propostas

Uma comparação entre os dois sistemas propostos pode ser feita. O primeiro
método estudado é mais simples no ponto de vista de implementação, visto que não exige
grandes modificações na estrutura do sistema, pois a interface é feita por saídas digitais
que podem ser facilmente manipuladas através da linguagem RAPID. Entretanto, há
uma limitação muito grande nos movimentos da mão robótica, pois todos as posições
devem ser pré-configuradas, e cada uma delas terá de ser associada a uma saída digital,
ou uma combinação delas. Além do mais, a flexibilidade do sistema continua baixa, pois
ainda existirá dificuldade na integração entre diferentes algoritmos, como de otimização,
tratamento de imagens, etc. Este método pode ser aplicado em plantas que já estejam em
operação, que exijam mudanças rápidas e menos profundas.
O segundo método abordado apresenta grande flexibilidade, devido ao sistema
ser centralizado no framework ROS, que tem por característica ser um ambiente que
oferece facilidade de integração entre diferentes algoritmos. Além disso, todas as juntas
da mão robótica podem ser posicionadas de qualquer forma respeitando seu espaço de
trabalho, visto que o comando de posição, no valor desejado, é enviado diretamente para
o seu controlador. Da mesma forma em que a funcionalidade de desvio de obstáculos foi

atribuída ao sistema, outros algoritmos também poderiam ser facilmente incorporados,
tornando a aplicação ainda mais completa. Apesar da flexibilidade, para ser implantado,
este método exige uma grande reformulação no sistema da célula robótica. Para plantas
novas, seu uso deve ser levado em consideração pois facilitará, no futuro, a integração com
novos dispositivos. Entretanto, em células que já estão em operação, sua implantação pode
ser demorada e exigir grandes alterações.
57
5 Considerações finais
Este trabalho apresentou duas técnicas de integração distintas entre o braço

manipulador ABB IRB 120 e a mão robótica Barrett Hand BH8-282.
Inicialmente, foi feita uma introdução, onde foi explicado as vantagens da existência
de células robóticas que auxiliam no processo produtivo das empresas. Também foi
comentado que os robôs industriais geralmente apresentam arquitetura fechada e utilizam
softwares proprietários, destacando então, a necessidade de flexibilização dos sistemas
robóticos aplicados na industria.
Uma revisão sobre os hardwares e softwares utilizados nas etapas de desenvolvimento
do trabalho foi realizada, abordando o braço robótico ABB IRB 120 e o controlador
IRC5 Compact, bem como a mão robótica Barrett BH8-282, que foram os equipamentos
motivadores da realização do presente trabalho. Também foi comentado sobre o Arduino
Uno, sendo este um elemento auxiliar de integração em um dos métodos propostos. Os
principais softwares envolvidos no sistema foram abordados, como o Robotstudio, utilizado
para a programação do controlador IRC5; o ROS, que foi o sistema principal na segunda
estratégia adotada, além de suas ferramentas como o MoveIt! e ROS Industrial.
As arquiteturas propostas foram apresentadas em cada estratégia de integração,
bem como as técnicas utilizadas para o desenvolvimento de cada uma delas. Para a
implementação da primeira abordagem, utilizou-se o controlador IRC5 Compact como
controlador principal e o ROS como sistema auxiliar para comando da mão robótica, além
do Arduino Uno como o elemento de interfaceamento entre estes equipamentos. A segunda
estratégia apresenta todo o controle centralizado no framework ROS, onde foi utilizado o
software MoveIt! para planejamento de trajetórias e um socket do ROS Industrial para
comunicação com o robô real. A integração com a mão robótica se dá de forma mais direta,
visto que os softwares de controle dos equipamentos se encontram no mesmo ambiente.
Por fim, os experimentos e discussão dos resultados foram apresentados. As técnicas
abordadas foram aplicadas em situações diferentes; a primeira delas exigia precisão nos
movimentos da ferramenta, pois a logomarca da empresa Vale S/A, em versão monocro-
mática, teria que ser desenhada dentro dos requisitos de semelhança com o modelo de
referência cedido pelo departamento de comunicação da empresa. A segunda abordagem foi
testada em escala de laboratório, onde a trajetória simulada pela interface do MoveIt! teria
que ser repetida pelo robô. Além disso, a funcionalidade de desvio de obstáculos oferecida
por este software foi observada, onde uma caixa foi incorporada à cena de planejamento,
Capítulo 5. Considerações finais 58
na mesma posição e orientação que uma caixa real. A trajetória gerada pelo software para
contornar o obstáculo foi planejada e repetida pelo robô.
A primeira estratégia apresenta a vantagem de ser de fácil implementação, pois não
exige grandes modificações na estrutura do sistema. Apresenta também a desvantagem de
ser menos flexível, pois os movimentos da mão serão limitados à combinações de saídas
digitais. Esta pode ser uma alternativa viável para implantação em células robóticas que já
estejam em operação. A segunda abordagem apresenta uma flexibilidade maior, devido o
sistema estar implantado no ambiente do ROS, o que facilita a integração entre algoritmos
distintos que poderiam auxiliar na otimização de processos, a medida que suas restrições
aumentem. Além disso, há um controle maior sobre os equipamentos, devido a comunicação
com os mesmos se dar de maneira direta. Esta técnica também pode ser aplicada em
células que já estejam em operação, porém, demandará um tempo maior de implantação.
Entretanto, devido as vantagens apresentadas, seu uso deve ser levado em consideração
em projetos de novas plantas robóticas.
59
Referências
ABB. 2013. http://new.abb.com/products/robotics/industrial-robots/irb-120.

Acessado em 15/01/2017. Citado 3 vezes nas páginas 13, 32 e 39.
ABB CORPORATION. RAPID Instructions, Functions and Data types. [S.l.],
2010. Citado na página 27.
ARDUINO. 2017. http://arduino.cc. Acessado em 18/01/2017. Citado 2 vezes nas
páginas 17 e 18.
ARDUINO IDE Setup. 2015. http://wiki.ros.org/rosserial_arduino/Tutorials/
ArduinoIDESetup. Acessado em 11/02/2017. Citado na página 25.
BARRETT TECHNOLOGY INC. BH8-282. [S.l.], 2013. Citado 2 vezes nas páginas 16
e 39.
BARTOLOMEU, P.; LOPES, L. S.; LAU, N.; PINHO, A.; ALMEIDA, L. Integração de
informação na equipa de futebol robótico cambada. Electrónica e Telecomunicações,
2005. v. 4, n. 4, p. 467–477, 2005. Citado na página 10.
BEN-TZVI, P.; MOUBARAK, P. A mechatronic perspective on robotic arms and
end-effectors. Edited by Ganesh R. Naik, 2011. p. 1, 2011. Citado na página 40.
INSTALLING the ABB ROS Server. 2015. http://wiki.ros.org/abb/Tutorials/
InstallServer. Acessado em 11/02/2017. Citado 2 vezes nas páginas 44 e 45.
JOSEPH, L. Mastering ROS for robotics programming. [S.l.]: Packt Publishing
Ltd, 2015. Citado na página 21.
LEVI Armstrong - ROS-Industrial abb meta package. 2015. https://github.com/
ros-industrial/abb. Acessado em 11/02/2017. Citado na página 45.
MARTíN, J. M. Trajectory planning for the IRB120 robotic arm using ROS.
2013. Citado 4 vezes nas páginas 10, 20, 21 e 43.
MOVEIT! 2015. http://moveit.ros.org. Acessado em 29/01/2017. Citado 2 vezes nas
páginas 21 e 25.
OMPL. 2015. http://ompl.kavrakilab.org/. Acessado em 29/01/2017. Citado na
página 22.
ROS. 2013. http://www.ros.org/about-ros/. Acessado em 22/01/2017. Citado 3
vezes nas páginas 18, 19 e 20.
ROS - bhand_controller. 2017. http://wiki.ros.org/bhand_controller. Acessado em
11/02/2017. Citado na página 25.
ROS Indigo Installation. 2017. http://wiki.ros.org/indigo/Installation/Ubuntu.
Acessado em 15/01/2017. Citado na página 25.
Referências 60
SITE oficial do ROS-Industrial. 2015. http://wiki.ros.org/Industrial. Acessado em

28/01/2017. Citado na página 25.
SOLIDWORKS to URDF Exporter. 2015. http://wiki.ros.org/sw_urdf_exporter.

Acessado em 05/02/2017. Citado na página 37.
Apêndices
62
APÊNDICE A – Código do Arduino Uno
1 #include <ros.h>
2 #include <std_msgs/String.h>
3 #include <sensor_msgs/JointState.h>
4 #include <stdlib.h>
5 #include <stdint.h>
6 ros::NodeHandle nh;
7 sensor_msgs::JointState BarrettCommands;
8 char *names[] = {"bh_j11_joint", "bh_j32_joint", "bh_j12_joint",
,→ "bh_j22_joint"};
9 float open_Position[] = {3.14, 0 , 0, 0};

10 float close_Position[] = {3.14, 2.44 , 2.44, 2.44};
11 float v_Position[] = {2.00, 0 , 2.44, 2.44};
12 float vel[] = {0.1, 0.1 , 0.1, 0.1};
13 float effort[] = {0.0, 0.0 , 0.0, 0.0};
14 const int AbreFechaMao_In = 12;
15 const int V_In = 13;
16 ros::Publisher Bhand_Publisher("/bhand_node/command", &BarrettCommands);
17
18 void setup()
19 {
20 nh.initNode();
21 nh.advertise(Bhand_Publisher);
22 BarrettCommands.name_length = 4;
23 BarrettCommands.velocity_length = 4;
24 BarrettCommands.position_length = 4;
25 BarrettCommands.effort_length = 4;
26 BarrettCommands.header.seq = 0;
27 BarrettCommands.header.frame_id = "bh";
28 BarrettCommands.name = names;
29 BarrettCommands.velocity = vel;
30 BarrettCommands.effort = effort;
31 pinMode(AbreFechaMao_In, INPUT);
APÊNDICE A. Código do Arduino Uno 63
32 pinMode(V_In, INPUT);
33 }
34
35 void loop()
36 {
37 if (digitalRead(AbreFechaMao_In) & !digitalRead(V_In)) {
38 BarrettCommands.position = open_Position;
39 delay(1500);
40 }
41 else { if (!digitalRead(AbreFechaMao_In) & !digitalRead(V_In)) {
42 BarrettCommands.position = close_Position;
43 delay(1500);
44 }
45 else {
46 BarrettCommands.position = v_Position;
47 delay(1500);
48 }
49 }
50
51 Bhand_Publisher.publish( &BarrettCommands );
52 nh.spinOnce();
53 }
64
APÊNDICE B – Código do controlador IRC5

Compact
1 MODULE MainModule
2 PERS wobjdata FolhaA3:=[FALSE,TRUE,"",[[69.9989,185.834,392.877],
3 [0.706688,0.707522,0.00147294,0.00145613]],[[0,0,0],[1,0,0,0]]];
4 CONST robtarget
,→ p10:=[[202.64,121.88,182.06],[0.26647,0.655838,0.270296,0.652542],
5 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
6 CONST robtarget
,→ p20:=[[383.36,85.00,219.07],[0.648419,0.276258,0.65333,0.276394],
7 [-1,-1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
8 CONST robtarget
,→ p30:=[[383.36,102.93,219.05],[0.64844,0.276284,0.653313,0.276358],
9 [-1,-1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
10 CONST robtarget
,→ p40:=[[378.99,105.67,276.82],[0.644975,0.284241,0.649901,0.284328],
11 [-1,-1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
12 CONST robtarget
,→ p50:=[[91.43,120.84,184.14],[0.267097,0.655687,0.270628,0.652299],
13 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
14 CONST robtarget
,→ p60:=[[95.62,100.38,15.67],[0.267096,0.655744,0.270619,0.652246],
15 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
16 CONST robtarget
,→ p70:=[[95.68,102.57,2.77],[0.267104,0.655762,0.270583,0.652239],
17 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
18 CONST robtarget
,→ p80:=[[107.76,107.79,2.81],[0.267111,0.65577,0.270564,0.652236],
19 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
20 CONST robtarget
,→ p90:=[[126.60,119.30,2.88],[0.267123,0.655775,0.270547,0.652233],
21 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
APÊNDICE B. Código do controlador IRC5 Compact 65
22 CONST robtarget
,→ p110:=[[152.60,118.29,2.98],[0.267131,0.65581,0.270526,0.652203],
23 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
24 CONST robtarget
,→ p100:=[[141.40,121.29,2.93],[0.267125,0.655791,0.270539,0.65222],
25 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
26 CONST robtarget
,→ p120:=[[137.81,98.68,2.94],[0.267136,0.655834,0.270517,0.652181],
27 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
28 CONST robtarget
,→ p140:=[[121.16,122.39,-0.20],[0.650801,-0.274798,0.654014,-0.270574],
29 [0,0,-1,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
30 CONST robtarget
,→ p130:=[[116.81,92.87,2.86],[0.267149,0.655833,0.270513,0.652179],
31 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
32 CONST robtarget
,→ p160:=[[105.74,128.82,-0.20],[0.650785,-0.274876,0.654011,-0.270538],
33 [0,0,-1,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
34 CONST robtarget
,→ p150:=[[113.75,132.54,-0.20],[0.65076,-0.274877,0.654029,-0.270554],
35 [0,0,-1,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
36 CONST robtarget
,→ p170:=[[131.83,89.54,12.23],[0.267142,0.655796,0.27062,0.652173],
37 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
38 CONST robtarget
,→ p180:=[[131.87,89.52,2.03],[0.267152,0.6558,0.270617,0.652167],
39 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
40 CONST robtarget
,→ p190:=[[83.28,26.71,1.91],[0.267176,0.65578,0.270624,0.652175],
41 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
42 CONST robtarget
,→ p200:=[[14.53,116.25,3.45],[0.267181,0.655811,0.270621,0.652142],
43 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
44 CONST robtarget
,→ p220:=[[68.51,116.67,3.89],[0.267211,0.655799,0.270616,0.652145],
45 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
46 CONST robtarget
,→ p210:=[[42.11,125.88,3.77],[0.267207,0.65579,0.270615,0.652156],
47 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
48 CONST robtarget
,→ p230:=[[90.72,96.07,2.80],[0.267223,0.655813,0.270601,0.652131],
49 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
50 CONST robtarget
,→ p250:=[[106.32,87.06,2.28],[0.267225,0.655817,0.270594,0.65213],
51 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
52 CONST robtarget
,→ p240:=[[106.32,87.06,2.28],[0.267226,0.655817,0.270592,0.652131],
53 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
54 CONST robtarget
,→ p260:=[[156.81,73.32,14.94],[0.267141,0.655854,0.270606,0.652122],
55 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
56 CONST robtarget
,→ p270:=[[157.20,73.27,1.76],[0.267199,0.655866,0.270552,0.652109],
57 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
58 CONST robtarget
,→ p280:=[[159.85,73.27,1.76],[0.267178,0.655883,0.270564,0.652095],
59 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
60 CONST robtarget
,→ p290:=[[171.66,46.88,1.64],[0.267176,0.655883,0.270571,0.652093],
61 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
62 CONST robtarget
,→ p300:=[[183.25,73.27,1.65],[0.267182,0.655906,0.270554,0.652074],
63 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
64 CONST robtarget
,→ p310:=[[186.85,73.27,1.66],[0.267182,0.65594,0.270539,0.652047],
65 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
66 CONST robtarget
,→ p320:=[[174.04,41.65,1.65],[0.26718,0.655941,0.270529,0.652051],
67 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
68 CONST robtarget
,→ p340:=[[168.44,45.44,2.43],[0.267215,0.655959,0.270489,0.652035],
69 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
70 CONST robtarget
,→ p330:=[[171.45,41.65,1.64],[0.267197,0.655944,0.270511,0.652048],
71 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
72 CONST robtarget
,→ p350:=[[168.44,45.44,2.43],[0.267216,0.655959,0.270489,0.652034],
73 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
74 CONST robtarget
,→ p360:=[[41.49,275.88,16.12],[0.267171,0.655756,0.270541,0.652235],
75 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
76 CONST robtarget
,→ p370:=[[46.66,264.65,2.82],[0.267181,0.655727,0.270467,0.652291],
77 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
78 CONST robtarget
,→ p380:=[[51.07,275.84,0.24],[0.26718,0.655709,0.270411,0.652333],
79 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
80 CONST robtarget
,→ p390:=[[51.02,275.83,13.43],[0.267246,0.655724,0.270402,0.652294],
81 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
82 CONST robtarget
,→ p400:=[[57.03,264.41,13.27],[0.267305,0.655715,0.270371,0.652292],
83 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
84 CONST robtarget
,→ p410:=[[57.07,264.40,1.88],[0.267305,0.655701,0.270321,0.652327],
85 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
86 CONST robtarget
,→ p420:=[[61.76,275.39,2.49],[0.267317,0.655663,0.270297,0.65237],
87 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
88 CONST robtarget
,→ p430:=[[66.76,264.78,1.33],[0.267342,0.655632,0.270275,0.6524],
89 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
90 CONST robtarget
,→ p440:=[[64.96,268.37,2.44],[0.267348,0.655609,0.270255,0.652429],
91 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
92 CONST robtarget
,→ p450:=[[58.56,268.37,2.42],[0.267376,0.655585,0.27023,0.652452],
93 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
94 CONST robtarget
,→ p460:=[[58.52,268.36,11.81],[0.267414,0.655589,0.27023,0.652432],
95 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
96 CONST robtarget
,→ p470:=[[73.68,275.14,12.88],[0.267463,0.655601,0.270249,0.652393],
97 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
98 CONST robtarget
,→ p480:=[[73.73,275.12,2.68],[0.267471,0.655573,0.270216,0.652431],
99 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
100 CONST robtarget

,→ p490:=[[73.73,264.72,2.69],[0.267489,0.655575,0.270199,0.652428],
101 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
102 CONST robtarget
,→ p500:=[[80.13,264.71,2.72],[0.26749,0.655589,0.270184,0.65242],
103 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
104 CONST robtarget
,→ p510:=[[80.08,264.71,13.71],[0.267531,0.655611,0.270192,0.652378],
105 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
106 CONST robtarget
,→ p520:=[[95.14,275.68,13.15],[0.267563,0.655633,0.270186,0.652345],
107 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
108 CONST robtarget
,→ p530:=[[112.33,275.74,13.56],[0.267394,0.655591,0.270292,0.652413],
109 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
110 CONST robtarget
,→ p540:=[[95.19,275.67,1.96],[0.267572,0.6556,0.270164,0.652385],
111 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
112 CONST robtarget
,→ p550:=[[87.39,275.66,1.93],[0.267595,0.655572,0.270155,0.652406],
113 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
114 CONST robtarget
,→ p560:=[[87.40,264.45,1.95],[0.267612,0.655549,0.270146,0.652427],
115 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
116 CONST robtarget
,→ p570:=[[95.60,264.44,1.98],[0.26761,0.65557,0.270127,0.652413],
117 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
118 CONST robtarget
,→ p580:=[[95.55,264.44,12.37],[0.26765,0.655584,0.270132,0.652381],
119 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
120 CONST robtarget
,→ p590:=[[95.55,270.02,12.36],[0.267666,0.655602,0.270134,0.652356],
121 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
122 CONST robtarget
,→ p600:=[[95.60,270.00,1.77],[0.267676,0.655561,0.270101,0.652407],
123 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
124 CONST robtarget
,→ p610:=[[88.40,269.99,1.74],[0.267724,0.655504,0.270087,0.65245],
125 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
126 CONST robtarget

,→ p620:=[[88.34,269.98,16.74],[0.26778,0.65553,0.270091,0.652399],
127 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
128 CONST robtarget
,→ p630:=[[104.47,270.05,15.14],[0.267556,0.655558,0.270195,0.65242],
129 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
130 CONST robtarget
,→ p640:=[[156.79,73.28,18.13],[0.267186,0.655898,0.270609,0.652058],
131 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
132 CONST robtarget
,→ p650:=[[41.55,275.84,2.53],[0.267238,0.65571,0.27048,0.65228],
133 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
134 VAR num offX;
135 VAR num offY;
136 VAR num offZ;
137 CONST robtarget
,→ p670:=[[138.47,109.72,0.93],[0.267115,0.655838,0.270536,0.652178],
138 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
139 CONST robtarget
,→ p660:=[[121.48,101.13,1.34],[0.267121,0.655792,0.270517,0.652229],
140 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
141 CONST robtarget
,→ p690:=[[109.24,100.33,-1.19],[0.267522,0.65548,0.270571,0.652356],
142 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
143 CONST robtarget
,→ p680:=[[121.24,102.35,-1.34],[0.267498,0.655446,0.270561,0.652405],
144 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
145 CONST robtarget
,→ p700:=[[89.06,78.56,2.44],[0.267312,0.655938,0.270733,0.651914],
146 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
147 CONST robtarget
,→ p710:=[[41.22,107.73,1.63],[0.267372,0.656012,0.270744,0.651811],
148 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
149 CONST robtarget
,→ p720:=[[66.63,109.08,2.53],[0.267309,0.655958,0.270714,0.651904],
150 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
151 CONST robtarget
,→ p730:=[[194.27,43.30,2.90],[0.267221,0.655931,0.270576,0.652024],
152 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
153 CONST robtarget

,→ p740:=[[194.20,43.30,18.30],[0.267233,0.655949,0.270565,0.652006],
154 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
155 CONST robtarget
,→ p750:=[[206.42,73.52,2.50],[0.267239,0.655953,0.270551,0.652005],
156 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
157 CONST robtarget
,→ p760:=[[210.62,73.52,2.50],[0.267243,0.655991,0.270542,0.651969],
158 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
159 CONST robtarget
,→ p770:=[[223.41,43.30,2.54],[0.267248,0.656008,0.270519,0.651959],
160 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
161 CONST robtarget
,→ p780:=[[219.81,43.30,2.53],[0.267274,0.655997,0.270515,0.651962],
162 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
163 CONST robtarget
,→ p790:=[[216.22,50.89,2.68],[0.267283,0.655993,0.270506,0.651966],
164 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
165 CONST robtarget
,→ p800:=[[200.03,50.87,2.62],[0.267297,0.655987,0.27049,0.651973],
166 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
167 CONST robtarget
,→ p810:=[[198.02,43.30,2.61],[0.267313,0.65602,0.270455,0.651947],
168 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
169 CONST robtarget
,→ p820:=[[213.64,53.44,14.05],[0.267348,0.656116,0.270403,0.651858],
170 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
171 CONST robtarget
,→ p830:=[[215.97,53.41,2.86],[0.267385,0.656132,0.270382,0.651836],
172 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
173 CONST robtarget
,→ p840:=[[199.88,53.42,3.81],[0.267368,0.656097,0.270385,0.651877],
174 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
175 CONST robtarget
,→ p850:=[[205.48,68.21,3.82],[0.267374,0.656097,0.270367,0.651881],
176 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
177 CONST robtarget
,→ p860:=[[210.89,68.20,4.01],[0.267393,0.656087,0.270354,0.651888],
178 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
179 CONST robtarget

,→ p870:=[[210.89,68.20,4.01],[0.267393,0.656087,0.270354,0.651888],
180 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
181 CONST robtarget
,→ p880:=[[214.42,53.39,17.25],[0.267432,0.656222,0.270348,0.65174],
182 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
183 CONST robtarget
,→ p890:=[[235.60,74.17,18.90],[0.267439,0.656282,0.270317,0.651689],
184 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
185 CONST robtarget
,→ p900:=[[235.67,74.15,2.51],[0.267457,0.656251,0.270316,0.651713],
186 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
187 CONST robtarget
,→ p910:=[[235.67,43.30,2.55],[0.267464,0.656248,0.270305,0.651717],
188 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
189 CONST robtarget
,→ p920:=[[254.67,43.30,2.63],[0.267474,0.656266,0.270296,0.6517],
190 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
191 CONST robtarget
,→ p930:=[[254.67,44.72,2.62],[0.267486,0.656276,0.270285,0.651689],
192 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
193 CONST robtarget
,→ p940:=[[238.07,44.72,2.55],[0.267496,0.656283,0.270276,0.651681],
194 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
195 CONST robtarget
,→ p950:=[[238.07,74.70,2.52],[0.26752,0.656309,0.270251,0.651656],
196 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
197 CONST robtarget
,→ p960:=[[235.26,74.70,2.51],[0.267543,0.656296,0.270237,0.651665],
198 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
199 CONST robtarget
,→ p970:=[[235.19,74.70,20.50],[0.267569,0.656322,0.270178,0.651653],
200 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
201 CONST robtarget
,→ p980:=[[284.89,75.45,18.49],[0.267574,0.656428,0.27009,0.651581],
202 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
203 CONST robtarget
,→ p990:=[[284.87,75.43,1.89],[0.267579,0.656423,0.270076,0.65159],
204 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
205 CONST robtarget

,→ p1000:=[[267.87,75.42,1.83],[0.267587,0.656428,0.270057,0.651589],
206 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
207 CONST robtarget
,→ p1010:=[[267.87,43.60,1.87],[0.26761,0.656438,0.27005,0.651573],
208 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
209 CONST robtarget
,→ p1020:=[[285.27,43.59,1.94],[0.267628,0.656451,0.270038,0.651557],
210 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
211 CONST robtarget
,→ p1030:=[[285.27,44.78,1.93],[0.267645,0.656466,0.270019,0.651543],
212 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
213 CONST robtarget
,→ p1040:=[[269.27,44.77,1.87],[0.267666,0.656474,0.269988,0.651539],
214 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
215 CONST robtarget
,→ p1050:=[[269.27,59.56,1.86],[0.26769,0.656492,0.26997,0.651519],
216 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
217 CONST robtarget
,→ p1060:=[[282.67,59.55,1.90],[0.267693,0.656526,0.269959,0.651488],
218 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
219 CONST robtarget
,→ p1070:=[[282.67,61.15,1.90],[0.267722,0.656553,0.269937,0.651457],
220 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
221 CONST robtarget
,→ p1080:=[[269.08,60.73,1.86],[0.267749,0.656549,0.269909,0.651461],
222 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
223 CONST robtarget
,→ p1090:=[[269.07,73.31,1.84],[0.267759,0.656554,0.269911,0.651452],
224 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
225 CONST robtarget
,→ p1100:=[[281.47,73.30,1.89],[0.26777,0.656563,0.269901,0.651443],
226 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
227 CONST robtarget
,→ p1110:=[[281.47,73.30,1.89],[0.26777,0.656563,0.269901,0.651443],
228 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
229 CONST robtarget
,→ p1130:=[[283.67,74.09,1.89],[0.267777,0.656597,0.269893,0.651409],
230 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
231 CONST robtarget

,→ p1120:=[[283.67,74.09,1.89],[0.267777,0.656597,0.269893,0.651409],
232 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
233 CONST robtarget
,→ p1140:=[[285.44,75.45,22.49],[0.267588,0.656415,0.270071,0.651596],
234 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
235 CONST robtarget
,→ p1150:=[[194.19,44.12,18.58],[0.267268,0.655997,0.27054,0.651953],
236 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
237 CONST robtarget
,→ p1160:=[[66.55,109.11,21.23],[0.267269,0.655977,0.270697,0.651908],
238 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
239 CONST robtarget
,→ p1170:=[[28.49,241.62,21.39],[0.267664,0.656452,0.270076,0.651525],
240 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]]; !Inicio da

,→ frase
241 CONST robtarget

,→ p1180:=[[28.55,241.62,6.19],[0.267695,0.656441,0.270079,0.651522],
242 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
243 CONST robtarget
,→ p1190:=[[34.95,225.81,7.04],[0.267687,0.656429,0.27005,0.65155],
244 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
245 CONST robtarget
,→ p1200:=[[41.96,241.62,5.26],[0.267673,0.656398,0.270009,0.651604],
246 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
247 CONST robtarget
,→ p1210:=[[41.90,241.62,19.46],[0.267706,0.656382,0.269996,0.651612],
248 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
249 CONST robtarget
,→ p1220:=[[49.68,225.81,17.03],[0.267763,0.656397,0.270006,0.651569],
250 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
251 CONST robtarget
,→ p1230:=[[49.73,225.81,6.04],[0.267751,0.656364,0.269993,0.651613],
252 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
253 CONST robtarget
,→ p1240:=[[56.53,241.62,6.85],[0.267791,0.656338,0.269974,0.65163],
254 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
255 CONST robtarget
,→ p1250:=[[63.74,225.81,5.70],[0.267816,0.656329,0.269947,0.65164],
256 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
257 CONST robtarget
,→ p1260:=[[60.95,231.77,6.85],[0.267855,0.656325,0.269949,0.651628],
258 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
259 CONST robtarget
,→ p1270:=[[52.75,231.76,6.22],[0.267886,0.656302,0.269917,0.651651],
260 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
261 CONST robtarget
,→ p1280:=[[52.71,231.75,17.22],[0.267929,0.65631,0.269933,0.651618],
262 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
263 CONST robtarget
,→ p1290:=[[71.75,241.62,16.07],[0.267967,0.656331,0.269911,0.651592],
264 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
265 CONST robtarget
,→ p1300:=[[71.79,241.62,6.28],[0.267986,0.656306,0.269902,0.651612],
266 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
267 CONST robtarget
,→ p1310:=[[71.79,225.81,6.30],[0.268016,0.656273,0.269885,0.65164],
268 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
269 CONST robtarget
,→ p1320:=[[81.39,225.81,6.34],[0.268029,0.656269,0.269877,0.651642],
270 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
271 CONST robtarget
,→ p1330:=[[81.34,225.81,19.13],[0.268039,0.656283,0.26988,0.651623],
272 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
273 CONST robtarget
,→ p1340:=[[101.14,241.62,17.79],[0.268041,0.656297,0.269862,0.651616],
274 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
275 CONST robtarget
,→ p1350:=[[101.19,241.62,7.00],[0.26804,0.656279,0.269825,0.651649],
276 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
277 CONST robtarget
,→ p1360:=[[89.99,241.62,6.95],[0.268065,0.656266,0.269791,0.651666],
278 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
279 CONST robtarget
,→ p1370:=[[89.99,233.97,6.96],[0.268103,0.656222,0.269769,0.651704],
280 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
281 CONST robtarget
,→ p1380:=[[99.97,233.96,7.01],[0.268113,0.656212,0.269753,0.651717],
282 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
283 CONST robtarget
,→ p1390:=[[89.99,225.81,6.97],[0.268128,0.656204,0.269761,0.651715],
284 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
285 CONST robtarget
,→ p1400:=[[101.79,225.81,7.02],[0.268109,0.65622,0.269763,0.651706],
286 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
287 CONST robtarget
,→ p1410:=[[101.74,225.81,19.02],[0.268163,0.656223,0.269759,0.651683],
288 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
289 CONST robtarget
,→ p1420:=[[122.32,241.62,16.68],[0.268192,0.656228,0.269754,0.651667],
290 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
291 CONST robtarget
,→ p1430:=[[122.36,241.62,6.08],[0.268197,0.656215,0.269721,0.651692],
292 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
293 CONST robtarget
,→ p1440:=[[122.36,225.81,6.10],[0.268225,0.656194,0.269714,0.651705],
294 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
295 CONST robtarget
,→ p1450:=[[122.31,225.81,19.70],[0.268275,0.656211,0.269713,0.651667],
296 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
297 CONST robtarget
,→ p1460:=[[132.48,225.81,16.35],[0.268301,0.656224,0.269703,0.651648],
298 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
299 CONST robtarget
,→ p1470:=[[132.52,225.81,6.35],[0.268305,0.656203,0.269699,0.651669],
300 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
301 CONST robtarget
,→ p1480:=[[132.53,241.62,6.33],[0.26832,0.656218,0.269673,0.651658],
302 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
303 CONST robtarget
,→ p1490:=[[145.13,225.81,6.41],[0.268302,0.656195,0.269663,0.651693],
304 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
305 CONST robtarget
,→ p1500:=[[145.13,225.81,6.41],[0.268327,0.656184,0.269626,0.651709],
306 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
307 CONST robtarget
,→ p1510:=[[145.14,241.62,6.39],[0.26835,0.656202,0.269607,0.651689],
308 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
309 CONST robtarget
,→ p1520:=[[145.10,241.62,15.78],[0.268358,0.656211,0.26959,0.651683],
310 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
311 CONST robtarget
,→ p1530:=[[153.88,241.62,15.81],[0.268368,0.656258,0.269546,0.651651],
312 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
313 CONST robtarget
,→ p1540:=[[153.93,241.62,4.81],[0.268366,0.65625,0.269524,0.651669],
314 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
315 CONST robtarget
,→ p1550:=[[161.13,225.81,5.86],[0.268365,0.65624,0.269508,0.651686],
316 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
317 CONST robtarget
,→ p1560:=[[167.53,241.62,5.68],[0.268386,0.656207,0.269471,0.651726],
318 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
319 CONST robtarget
,→ p1570:=[[167.49,241.62,16.47],[0.268422,0.656225,0.26947,0.651693],
320 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
321 CONST robtarget
,→ p1580:=[[187.49,241.62,15.35],[0.268427,0.656228,0.269439,0.651701],
322 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
323 CONST robtarget
,→ p1590:=[[187.53,241.62,7.16],[0.26843,0.656208,0.269411,0.651731],
324 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
325 CONST robtarget
,→ p1600:=[[177.13,241.62,7.12],[0.268459,0.656201,0.269375,0.651741],
326 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
327 CONST robtarget
,→ p1610:=[[177.13,233.56,7.15],[0.268498,0.656148,0.269352,0.651788],
328 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
329 CONST robtarget
,→ p1620:=[[186.70,233.55,7.18],[0.268505,0.656151,0.269342,0.651786],
330 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
331 CONST robtarget
,→ p1630:=[[177.13,225.81,7.15],[0.268496,0.656156,0.269325,0.651792],
332 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
333 CONST robtarget
,→ p1640:=[[188.33,225.81,7.20],[0.26849,0.656151,0.269324,0.651799],
334 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
335 CONST robtarget
,→ p1650:=[[188.29,225.81,17.39],[0.268525,0.65619,0.269331,0.651744],
336 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
337 CONST robtarget
,→ p1660:=[[206.94,240.04,15.83],[0.268555,0.656269,0.269283,0.651671],
338 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]]; !Comeca S

339 CONST robtarget
,→ p1670:=[[206.97,240.05,6.84],[0.268532,0.65623,0.269287,0.651719],
340 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
341 CONST robtarget
,→ p1690:=[[197.67,242.00,6.58],[0.268572,0.656253,0.269248,0.651694],
342 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
343 CONST robtarget
,→ p1680:=[[201.98,242.61,6.81],[0.268567,0.656267,0.269258,0.651679],
344 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
345 CONST robtarget
,→ p1710:=[[197.67,235.99,6.39],[0.268577,0.656259,0.269236,0.651692],
346 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
347 CONST robtarget
,→ p1700:=[[195.68,239.58,5.79],[0.268576,0.656227,0.269208,0.651736],
348 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
349 CONST robtarget
,→ p1720:=[[205.08,233.77,5.83],[0.268569,0.656213,0.269183,0.651763],
350 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
351 CONST robtarget
,→ p1740:=[[205.28,227.56,6.05],[0.268561,0.65618,0.269158,0.65181],
352 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
353 CONST robtarget
,→ p1730:=[[207.87,230.77,6.25],[0.268564,0.656187,0.269174,0.651795],
354 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
355 CONST robtarget
,→ p1760:=[[195.12,229.95,5.74],[0.268562,0.656155,0.26912,0.651851],
356 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
357 CONST robtarget
,→ p1750:=[[198.81,227.35,6.06],[0.268566,0.656171,0.269146,0.651822],
358 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
359 CONST robtarget
,→ p1770:=[[195.07,229.95,16.73],[0.268557,0.656182,0.26912,0.651826],
360 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
361 CONST robtarget
,→ p1780:=[[221.80,225.81,21.46],[0.268656,0.656161,0.269229,0.651761],
362 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
363 CONST robtarget
,→ p1790:=[[221.86,225.81,6.48],[0.268626,0.656121,0.269184,0.651832],
364 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
365 CONST robtarget
,→ p1800:=[[221.86,242.80,6.45],[0.268632,0.656125,0.269184,0.651825],
366 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
367 CONST robtarget
,→ p1810:=[[216.09,242.79,6.71],[0.268639,0.65612,0.269176,0.651831],
368 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
369 CONST robtarget
,→ p1820:=[[227.89,242.78,6.75],[0.268647,0.656124,0.269184,0.65182],
370 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
371 CONST robtarget
,→ p1830:=[[227.84,242.78,18.75],[0.268677,0.656149,0.269176,0.651786],
372 [0,1,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
373 CONST robtarget
,→ p1840:=[[108.96,206.48,18.53],[0.268043,0.656368,0.26988,0.651535],
374 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
375 CONST robtarget
,→ p1850:=[[109.13,206.46,5.34],[0.268055,0.656362,0.269862,0.651544],
376 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
377 CONST robtarget
,→ p1870:=[[96.85,206.85,6.17],[0.268032,0.656355,0.269833,0.651573],
378 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
379 CONST robtarget
,→ p1860:=[[103.33,210.05,5.91],[0.268051,0.656363,0.269851,0.651549],
380 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
381 CONST robtarget
,→ p1890:=[[96.85,196.03,5.79],[0.26805,0.656322,0.269786,0.651618],
382 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
383 CONST robtarget
,→ p1880:=[[95.25,201.44,5.57],[0.268043,0.656344,0.269818,0.651585],
384 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
385 CONST robtarget
,→ p1910:=[[109.26,196.82,6.05],[0.268051,0.656306,0.269762,0.651644],
386 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
387 CONST robtarget
,→ p1900:=[[102.26,193.42,5.62],[0.268056,0.656319,0.269776,0.651623],
388 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
389 CONST robtarget
,→ p1920:=[[109.22,196.82,16.04],[0.268074,0.656339,0.269769,0.651598],
390 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
391 CONST robtarget
,→ p1930:=[[118.41,193.39,18.88],[0.268118,0.656386,0.269743,0.651543],
392 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
393 CONST robtarget
,→ p1940:=[[119.26,193.36,6.08],[0.26811,0.656387,0.269727,0.651552],
394 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
395 CONST robtarget
,→ p1950:=[[119.26,209.15,6.07],[0.268129,0.656368,0.269696,0.651575],
396 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
397 CONST robtarget
,→ p1960:=[[119.27,202.15,6.07],[0.268135,0.656382,0.269699,0.651558],
398 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
399 CONST robtarget
,→ p1970:=[[130.86,202.14,6.12],[0.268143,0.656377,0.269689,0.651564],
400 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
401 CONST robtarget
,→ p1980:=[[130.86,209.73,6.12],[0.268157,0.656361,0.269659,0.651587],
402 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
403 CONST robtarget
,→ p1990:=[[130.86,193.72,6.13],[0.268157,0.656377,0.269653,0.651573],
404 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
405 CONST robtarget
,→ p2000:=[[130.82,193.72,17.33],[0.268169,0.656396,0.26965,0.651551],
406 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
407 CONST robtarget
,→ p2010:=[[170.75,210.05,18.27],[0.268193,0.656414,0.269631,0.651531],
408 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
409 CONST robtarget
,→ p2030:=[[178.81,202.81,5.32],[0.268196,0.65641,0.269551,0.651566],
410 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
411 CONST robtarget
,→ p2020:=[[176.61,207.81,5.50],[0.268196,0.65641,0.269567,0.651559],
412 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
413 CONST robtarget
,→ p2040:=[[170.81,210.02,5.87],[0.268206,0.6564,0.269603,0.651551],
414 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
415 CONST robtarget
,→ p2060:=[[170.87,193.59,4.19],[0.268199,0.656435,0.269531,0.651549],
416 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
417 CONST robtarget
,→ p2050:=[[176.80,196.40,6.91],[0.268199,0.656429,0.269539,0.651551],
418 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
419 CONST robtarget
,→ p2080:=[[163.67,201.57,6.14],[0.268191,0.656479,0.269492,0.651524],
420 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
421 CONST robtarget
,→ p2070:=[[165.27,195.97,6.16],[0.26819,0.656473,0.269474,0.651537],
422 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
423 CONST robtarget
,→ p2100:=[[165.27,195.97,6.16],[0.26819,0.656473,0.269474,0.651537],
424 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
425 CONST robtarget
,→ p2090:=[[165.29,206.96,3.96],[0.268186,0.656435,0.26945,0.651587],
426 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
427 CONST robtarget
,→ p2110:=[[243.96,195.20,5.42],[0.268059,0.65635,0.269746,0.651602],
428 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
429 CONST robtarget
,→ p2120:=[[243.96,200.18,5.40],[0.268064,0.656383,0.269732,0.651573],
430 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
431 CONST robtarget
,→ p2130:=[[239.16,200.17,5.38],[0.26806,0.656392,0.269731,0.651566],
432 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
433 CONST robtarget
,→ p2140:=[[239.11,200.17,16.37],[0.268064,0.656414,0.269757,0.651532],
434 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
435 CONST robtarget
,→ p2150:=[[253.34,209.46,18.43],[0.268068,0.656472,0.269725,0.651484],
436 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
437 CONST robtarget
,→ p2160:=[[253.40,209.44,5.44],[0.268083,0.656454,0.269716,0.651501],
438 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
439 CONST robtarget
,→ p2170:=[[259.80,201.23,4.88],[0.268092,0.656445,0.269706,0.65151],
440 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
441 CONST robtarget
,→ p2180:=[[259.80,193.02,4.89],[0.268095,0.656464,0.269695,0.651494],
442 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
443 CONST robtarget
,→ p2190:=[[266.40,209.42,5.90],[0.26811,0.656458,0.269687,0.651498],
444 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
445 CONST robtarget
,→ p2200:=[[266.34,209.42,18.88],[0.26811,0.656491,0.269694,0.651461],
446 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
447 CONST robtarget
,→ p2210:=[[116.57,113.93,2.26],[0.267147,0.655822,0.270531,0.652183],
448 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
449 CONST robtarget
,→ p2220:=[[116.57,113.93,2.26],[0.267147,0.655822,0.270531,0.652183],
450 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
451 CONST robtarget
,→ p2230:=[[121.73,116.99,2.85],[0.267132,0.655825,0.270532,0.652185],
452 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
453 CONST robtarget
,→ p2240:=[[166.22,54.94,16.18],[0.267197,0.655969,0.270589,0.651991],
454 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
455 CONST robtarget
,→ p2250:=[[166.28,54.93,4.19],[0.267209,0.655933,0.270591,0.652021],
456 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
457 CONST robtarget
,→ p2260:=[[171.87,44.12,4.22],[0.267212,0.655973,0.27057,0.651988],
458 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
459 CONST robtarget
,→ p2270:=[[181.86,67.71,4.29],[0.267216,0.655992,0.270549,0.651976],
460 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
461 CONST robtarget
,→ p2290:=[[181.79,67.70,21.28],[0.267227,0.656082,0.27053,0.651889],
462 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
463 CONST robtarget
,→ p2280:=[[181.79,67.70,21.28],[0.267227,0.656082,0.27053,0.651889],
464 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
465 CONST robtarget
,→ p2300:=[[181.79,67.71,19.28],[0.267225,0.656044,0.270528,0.651929],
466 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
467 CONST robtarget
,→ p2310:=[[217.37,51.80,2.87],[0.267391,0.656131,0.270378,0.651835],
468 [0,0,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
469 CONST robtarget
,→ p2320:=[[205.81,69.77,16.19],[0.267438,0.656282,0.270328,0.651685],
470 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
471 CONST robtarget
,→ p2330:=[[205.87,69.75,4.19],[0.267445,0.656258,0.270322,0.651708],
472 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
473 CONST robtarget
,→ p2340:=[[211.07,69.75,4.20],[0.267442,0.656299,0.270303,0.651677],
474 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
475 CONST robtarget
,→ p2350:=[[211.01,69.74,17.20],[0.267461,0.656369,0.270261,0.651616],
476 [0,0,-3,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
477 CONST robtarget
,→ p2360:=[[266.34,209.40,18.87],[0.649053,0.276327,0.65376,0.273806],
478 [0,0,-4,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
479 CONST robtarget
,→ p2370:=[[265.79,209.54,148.88],[0.649057,0.276373,0.653749,0.273777],
480 [0,0,-4,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
481 CONST robtarget
,→ p2380:=[[265.42,209.64,240.01],[0.649063,0.276373,0.653748,0.273768],
482 [-1,-1,-2,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
483 CONST robtarget
,→ p2390:=[[202.64,121.86,182.06],[0.280452,-0.651663,0.280207,-0.646658],
484 [0,0,-1,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
485 CONST robtarget
,→ p2400:=[[202.64,121.85,182.06],[0.652815,-0.269526,0.656152,-0.265804],
486 [0,0,0,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
487 CONST robtarget
,→ p2410:=[[172.30,122.00,310.62],[0.792046,-0.197514,0.478974,-0.322854],
488 [-1,0,0,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
489 CONST robtarget
,→ p2420:=[[172.30,121.99,310.62],[0.737998,-0.263688,0.445978,-0.432355],
490 [-1,0,0,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
491 CONST robtarget
,→ p2430:=[[172.30,121.98,310.62],[0.82337,-0.142258,0.498188,-0.231588],
492 [-1,0,0,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
493 CONST robtarget
,→ p2440:=[[172.31,121.97,310.62],[0.791694,-0.197963,0.478789,-0.323715],
494 [-1,0,0,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
495 CONST robtarget
,→ p2450:=[[172.31,121.95,310.62],[0.277588,-0.490694,0.166277,-0.809022],
496 [-1,0,-1,1],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]];
497 PROC main()
498 MoveL p2450, v300, z50, tool0\WObj:=FolhaA3;
499 SetDO doFechaGarra, 0;
501 MoveL p10, v300, fine, tool0\WObj:=FolhaA3;
504 WaitTime 2;
509 offX := 0;
510
511
512 !Inicia desenho da parte superior do logo

513 !Contorno
514 MoveL Offs(p70, 0, 0 ,0 ),v30, fine, tool0\WObj:=FolhaA3;
515 MoveC Offs(p80, 0, 0, 0), Offs(p2220,0,0,0), v30, z1,
,→ tool0\WObj:=FolhaA3;
516 MoveC p2230, p90, v30, z1, tool0\WObj:=FolhaA3;

517 MoveC Offs(p100, 0, 0, 0), Offs(p110, 0, 0, 0), v30, z0,
518 MoveL Offs(p120, 0, 0,0), v30, z1, tool0\WObj:=FolhaA3;

519 MoveC Offs(p130, 0, 0, 0), Offs(p70, -1.3, 0,0), v30,
,→ fine, tool0\WObj:=FolhaA3;
520
521 !MoveL Offs(p70, 0, 0 ,0 ),v30, fine, tool0\WObj:=FolhaA3;

522 !MoveC Offs(p80, 0, 0, 0), Offs(p90,0,0,0), v30, z1,

523 !MoveC Offs(p100, 0, 0, 0), Offs(p110, 0, 0, 0), v30, z0,

524 !MoveL Offs(p120, 0, 0,0), v30, z1, tool0\WObj:=FolhaA3;

525 !MoveC Offs(p130, 0, 0, 0), Offs(p70, -1.3, 0,0), v30,
526
527
528 !Preenchimento
529 FOR offX FROM 1 TO 5 DO
530 MoveL Offs(p70, offX, 0 ,0 ),v300, fine, tool0\WObj:=FolhaA3;
531 MoveC Offs(p80, offX, -offX, 0), Offs(p90, offX , -2*offX, 0),
,→ v300, z1, tool0\WObj:=FolhaA3;
532 MoveC Offs(p100, -offX, -2*offX, 0), Offs(p110, -offX,

,→ -offX, 0), v300, fine, tool0\WObj:=FolhaA3;
533 MoveL Offs(p120, -offX, offX,0), v300, z1,

534 MoveC Offs(p130, -offX, offX, 0), Offs(p70, offX, 0,0),

,→ v300, fine, tool0\WObj:=FolhaA3;
535 ENDFOR
536 MoveC p660, p670, v30, fine, tool0\WObj:=FolhaA3;
538 !Finaliza desenho da parte superior do logo
539

542 !Inicia desenho da parte inferior do logo
543 !Contorno
544 MoveL Offs(p180, -2*offX,-offX,0 ), v30, fine,
545 MoveL Offs(p190, 0, offX, 0), v30, fine,

546 MoveL Offs(p200, 2*offX, -offX,0), v30, fine,

547 MoveC Offs(p210, offX, -offX, 0), Offs(p220, 0, -offX,

,→ 0), v30, z0, tool0\WObj:=FolhaA3;
548 MoveL Offs(p230, 0, -offX, 0), v30, z0,

549 MoveC Offs(p240, -offX, -offX, 0), Offs(p180, -2*offX,

,→ -offX,0), v30, z0, tool0\WObj:=FolhaA3;
550 !Cobertura Inicial



555 MoveC Offs(p210, offX, -offX, 0), Offs(p220, 0, -offX,

,→ 0), v300, z0, tool0\WObj:=FolhaA3;
556 MoveL Offs(p230, 0, -offX, 0), v300, z0,

557 MoveC Offs(p240, -offX, -offX, 0), Offs(p180, -2*offX,

,→ -offX,0), v300, z0, tool0\WObj:=FolhaA3;
558 ENDFOR
559 !Cobertura do vazio inferior
561 MoveL Offs(p180, -2*offX, -offX, 0 ), v300, fine,


564 ENDFOR
565 !Cobertura do vazio Superior
568 MoveL Offs(p710, offX,0, 0), v300, fine,

569 MoveL Offs(p720,0,-2*offX,0), v300, fine,

570 ENDFOR
572 !Finaliza desenho da parte inferior do logo
573
574 !Inicia V do logo


590 !Finaliza V do logo
591

593
594 !Inicia A do logo


617
618 !Finaliza A do logo

619

621
622 !Inicia L do logo

631
632 !Finaliza L do logo

633

635
636 !Inicia E do logo

652
653 !Finaliza E do logo

654 !Escrita da frase
655 !Vale
656 !V
662 !A
670 !L
676 !E
686
687 !Invests
688 !I

693 !N
700 !V
706 !E
716 !S
725 !T

732 !S
733 MoveL Offs(p1660, 40.5, 0, 0), v20, fine, tool0\WObj:=FolhaA3;
735 MoveC Offs(p1680, 40.5, 0, 0), Offs(p1690, 40.5, 0, 0), v20, fine,


741
742 !IN
743 !I
744 MoveL Offs(p1420, -109.56, -32.74, 0), v20, fine,



748 !N





755
756 !TECHNOLOGY
757 !T





764 !E







773 !C
780
781 !H
790
791 !N
792 MoveL Offs(p1460, 9.30, -32.74, 0), v20, fine,





798 !O
806
807
808 !L




814 !O

822 !G
825 MoveC Offs(p1860, 135.00, 0, 0), Offs(p1870, 135.00, 0, 0), v20,
826 MoveC Offs(p1880, 135.00, 0, 0), Offs(p1890, 135.00, 0, 0), v20,

827 MoveC Offs(p1900, 135.00, 0, 0), p2110, v20, fine,


831
832 !Y

842
843
844 !Coloca a caneta no garfo

850 WaitTime 2;
855 SetDO doFechaGarra, 1;
856 WaitTime 1;
862
863 ENDPROC
864 ENDMODULE
95
APÊNDICE C – Código do nó de controle da

mão robótica
1 #include "ros/ros.h"
2 #include "std_msgs/String.h"
3 #include <sensor_msgs/JointState.h>
4 #include <stdlib.h>
5 #include <stdint.h>
6
7 ros::Publisher BarrettHandPub_Control;
8 ros::Publisher BarrettHandPub_Moveit;
9 float OldBarrettPosition[4];
10
11 void JointStatesCallback(const sensor_msgs::JointState & msg)

12 {
13 float BarrettPosition[4];
14 sensor_msgs::JointState BarrettCommandsControl,
,→ BarrettCommandsMoveIt;
15 ros::Rate loop_rate(10);
16
21
22 for (int i = 0; i < 4 ; i ++) {

23 if (BarrettPosition[i] < 0) {
24 BarrettPosition[i] = -BarrettPosition[i];
25 }
26
27 }
28 BarrettCommandsControl.header.seq = 0;
29 BarrettCommandsControl.header.frame_id = "";
APÊNDICE C. Código do nó de controle da mão robótica 96
46
47 BarrettCommandsMoveIt.header.seq = 0;
48 BarrettCommandsMoveIt.header.frame_id = "";
49 BarrettCommandsMoveIt.name.push_back("bh_j11_joint");
53 BarrettCommandsMoveIt.position.push_back(-BarrettPosition[0]);
57 BarrettCommandsMoveIt.velocity.push_back(0.1);
61 BarrettCommandsMoveIt.effort.push_back(0.0);
65
66 if ((OldBarrettPosition[0] != BarrettPosition[0]) |
67 (OldBarrettPosition[1] != BarrettPosition[1]) |
68 (OldBarrettPosition[2] != BarrettPosition[2]) |
69 (OldBarrettPosition[3] != BarrettPosition[3]) ) {
70
APÊNDICE C. Código do nó de controle da mão robótica 97
71 BarrettHandPub_Control.publish(BarrettCommandsControl);
72 BarrettHandPub_Moveit.publish(BarrettCommandsMoveIt);}
73
74 for (int i = 0; i < 4 ; i ++) {

75 OldBarrettPosition[i] = BarrettPosition[i]; }
76
77 ros::spin();
78 }
79 int main(int argc, char **argv) {
80 ros::init(argc, argv, "JointStatestoBarrett");
81 ros::NodeHandle n;
82 ros::Subscriber sub =
83 n.subscribe("joint_states_barrett", 1000,
84 JointStatesCallback);
85 BarrettHandPub_Control =
86 n.advertise<sensor_msgs::JointState>("/bhand_node/command",
,→ 1000);
87 BarrettHandPub_Moveit =
88 n.advertise<sensor_msgs::JointState>("/joint_states", 1000);
89 ros::spin();
90 return 0;
91 }

MONOGRAFIA EstratégiasIntegraçãoBraço

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

MONOGRAFIA EstratégiasIntegraçãoBraço

Caricato da

Copyright:

Formati disponibili

Universidade Federal de Ouro Preto - UFOP

Marcos Paulo Torre

Estratégias de integração entre braço manipulador ABB IRB 120 e

Monografia de Graduação em Engenharia de Controle e Automação

Ouro Preto, 2017

Estratégias de integração entre braço manipulador ABB IRB 120 e

Monografia apresentada ao Curso de Enge-

Orientador: Prof. Gustavo Medeiros Freitas, Dr.

Ouro Preto, 2017

98f.: il.: color; tabs.

Orientador: Prof. Dr. Gustavo M. Freitas.

Monografia (Graduação). Universidade Federal de Ouro Preto. Escola de

1. Robôs - ROS (sistema operacional de robôs). 2. Peças de maquinas -

Palavras-chaves: Robot Operating System (ROS), MoveIt!, rosserial, ABB

Figura 1 Manipulador IRB 120 . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

Figura 12 Arquitetura do sistema utilizando o IRC5 Compact como controlador

Figura 30 Conjunto do braço e mão robótica no World Mining Congress . . . . . 52

Tabela 1 Estrutura da mensagem tipo sensor_msgs/JointState . . . . . . . . . . 20

Tabela 2 Pinos do conector XS10 . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4 Experimentos e discussão dos resultados . . . . . . . . . . . . . . . . . . . . 52

APÊNDICE A Código do Arduino Uno . . . . . . . . . . . . . . . . . . . . . . 62

APÊNDICE B Código do controlador IRC5 Compact . . . . . . . . . . . . . 64

APÊNDICE C Código do nó de controle da mão robótica . . . . . . . . . . . 95

1.1 Descrição do problema

1.3 Organização do trabalho

2.1 Braço Robótico

2.1.1 ABB IRB 120

Figura 1: Manipulador IRB 120

Fonte: Site oficial da ABB

O robô é feito em estrutura leve de alumínio, com motores compactos e de alta

velocidade/torque, que garantem ao mesmo uma rápida aceleração, agilidade e precisão

2.1.2 Controlador IRC5 Compact

Figura 2: Controlador IRC5 Compact

Fonte: Site oficial da ABB

Entre as funcionalidades do controlador IRC5 Compact, o sistema conta com a

Figura 3: Vista traseira do IRC5 compact

Fonte: Site oficial da ABB

2.1.2.1 Módulo de I/O DSQC 652

Figura 4: Módulo de I/O DSQC 652

Fonte: Site oficial da ABB

O interfaceamento entre o módulo e o controlador é realizado através da rede

utilização; também é necessário que os pontos de I/O estejam devidamente energizados.

O FlexPendant (Figura 5) é uma Interface Homem Máquina portátil utilizada para

2.1.3 ABB RobotStudio

Figura 6: Software RobotStudio

Fonte: Site oficial da ABB

2.2 Barrett Hand BH8-282

Figura 7: BarrettHand BH8-282

Fonte: Site oficial Barrett Technology

Seu hardware é composto por uma unidade de comunicação, quatro motores

2.3 Arduino Uno

Figura 8: Placa Arduino UNO

Fonte: Site oficial Arduino

2.3.1 Arduino IDE

Figura 9: Arduino IDE

2.4 Robot Operating System (ROS)

uma ferramenta de código aberto criada para incentivar a implementação colaborativa

2.4.2 Bhand controller

Fonte: ROS (2013)

2.4.3 ROS Industrial

Com novas funcionalidades, o ROS Industrial torna possível a comunicação entre

Figura 10: Diagrama de blocos do ROS-Industrial

Fonte: Joseph (2015, p. 379)