RobotStudio PT

INSTITUTO POLITÉCNICO DE LEIRIA
ESCOLA SUPERIOR DE TECNOLOGIA E GESTÃO

EEC – 3º ano – Robótica e Visão Computacional
TUTORIAL Nº 1
PROGRAMAÇÃO OFFLINE E SIMULAÇÃO COM O ROBOTSTUDIO 6.04
Índice
1 Objetivos ................ ................. ................. ................ ................. ................ ................. ..............2
2 Introdução ................. ................. ................ ................. ................. ................ ................. ...........

2
3 Elementos Base ................ ................. ................. ................ ................. ................. ................. 2..
3.1 Versão Utilizada .................................................................................................................................3
3.2 Ambiente de Trabalho ........................................................................................................................4
3.3 Abrir e Simular um Ambiente de Trabalho Exemplo ..........................................................................5
3.4 Criar Ambientes de Trabalho .............................................................................................................8
3.5 Sistemas de Coordenadas ................................................................................................................ 9
3.6 Espaço de Trabalho e Alcance do Robô ......................................................................................... 10
3.7 Adicionar Ferramentas Existentes ....................................................................................................11
3.8 Adicionar Objetos Existentes ...........................................................................................................12
3.9 Criar e Importar Novos Objetos .......................................................................................................14
3.10 Modos de Visualização ....................................................................................................................16
3.11 Movimentar o Robô e Criar Caminhos ............................................................................................ 17

4 Criar um Workobject ............................... ................. ................. ................ .................. ...........20
5 Criar um Caminho com Base nos Vértices de um Objeto............... .................. ................ ...... 22
6 Criar Caminhos ao Longo das Arestas de um Objeto................ ................ ................. ............26
7 Alteração da Localização do Espaço de Trabalho Após a Criação das Posturas e/ou do
Caminho ............... ................ ................. ................. ................ ................. ................. ................. ...29
8 Adicionar Sinais ao Robô ................ ................. ................ ................. ................. ................. ...30
9 Programação Gráfica do Robô e Simulação ............... ................ ................. ................. .........32
10 Utilização Direta de Código RAPID ................. ................ ................. ................. .................37
11 Principais Instruções RAPID ................ ................ ................. ................ ................. ............40
11.1 Variáveis e Constantes ....................................................................................................................41
11.2 Controlo de Fluxo ............................................................................................................................42
11.3 Instruções de Movimento .................................................................................................................42
11.4 Entradas/Saídas (sinais) ..................................................................................................................44
11.5 Procedimentos (Funções) com Argumentos ................................................................................... 44
11.6 Algumas Notas Finais ......................................................................................................................45
12 Gravação da Simulação em Vídeo ............... ................ ................. ................. ................. ...45
2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 1/45

1 Objetivos
Pretende-se com este tutorial guiar o estudante na aprendizagem e aplicação de conceitos
fundamentais na utilização de manipuladores industriais, através da utilização dosoftware
RobotStudio da ABB, nomeadamente:
• Princípios básicos (sistemas de coordenadas, espaço de trabalho, alcançabilidade, etc.);
• Carregar e movimentar um manipulador;
• Carregar e movimentar ferramentas;
• Carregar objetos existentes;
• Criar e importar novos objetos;
• Criar e utilizar Workobjects;
• Gerar caminhos com base na geometria de objetos;
• Criar e utilizar sinais para coordenar tarefas robóticas;
• Utilização de código RAPID;
• Gravar um vídeo da simulação.
NOTA: É importante que guarde o seu trabalho no final de cada secção, pois o mesmo poderá ser
necessário na secção seguinte, razão pela qual não deverá fazer nenhuma secção sem ter
concluído todas as anteriores. No final deverá guardar o trabalho desenvolvido, pois este, ou parte
deste, poderá ser utilizado nos tutoriais seguintes.
2 Introdução
Dada a complexidade no desenvolvimento de uma tarefa automatizada com recurso a robôs, é
imprescindível a utilização desoftware de simulação para uma maior produtividade. Além de reduzir
o tempo de desenvolvimento e possíveis erros de conceção, permite ainda reduzir o tempo de
paragem das linhas de produção durante o processo de desenvolvimento.

O RobotStudio é o software de simulação e desenvolvimento produzido e fornecido pela ABB, um
dos principais produtores de manipuladores industriais. Neste software é possível encontrar um
número elevado de robôs desenvolvidos pela ABB, permitindo a sua utilização imediata em
ambiente de simulação. É possível ainda controlar e monitorizar a execução de tarefas por robôs
reais, desde que as versões desoftware e controlador sejam compatíveis.
Neste tutorial encontra uma descrição passo a passo dos principais elementos do RobotStudio, bem
como exemplos e/ou ligações para exemplos fornecidos pelos docentes e/ou juntamente com o
software. Este tutorial foi desenvolvido de modo a que os estudantes adquiram autonomia na
procura de soluções para problemas inesperados que possam surgir. Assim, ao longo deste
documento encontrará vários ponteiros para secções de ajuda do próprio RobotStudio. Todos os
elementos que não façam parte deste tutorial, ou não sejam fornecidos juntamente com o
RobotStudio, são disponibilizados no Moodle ou num sítio Web relacionado com o fabricante com
a respetiva ligação explicitamente indicada na respetiva secção deste tutorial.
3 Elementos Base
Tal como indicado nas aulas teóricas, a cada manipulador robótico está associado um controlador
e uma consola, tal mostra aFigura 1.
No caso da ABB são utilizadas as seguintes terminologias (robôs de outras marcas usam
terminologias semelhantes):
• RAPID – linguagem de programação utilizada para controlar os robôs da ABB;
• Robot manipulator – corresponde ao manipulador robótico em si;
• Control module – corresponde ao módulo responsável pelo controlo dos movimentos do
robô, normalmente constituído por um computador capaz de interpretar linguagem RAPID e
comunicar com os módulos de acionamento;
• Drive module – módulo que contém a eletrónica de potência, capaz de receber as indicações
do módulo de controlo e acionar os motores das juntas do manipulador. Tipicamente um
módulo de acionamento da ABB suporta até 9 juntas, pelo que é necessário um módulo por
robô (o qual tem tipicamente 6 juntas);
• FlexController – Corresponde à unidade denominada como “Controlador” naFigura 1, a qual
contém o módulo de controlo, o módulo de acionamento, e outros módulos necessários ao
•
funcionamento do ABB (por
FlexPendant – Consola exemplo, ligado
de comando de comunicação);
ao controlador. Com um ecrã, que poderá ser
tátil, e teclas, esta permite de uma forma fácil a programação e controlo do manipulador
online;
• Tool – Ferramenta utilizada no elemento terminal do robô. A título de exemplo, e tal como
poderá confirmar na Figura 1, poderá ser utilizada uma garra;
• RobotWare – designação utilizada pela ABB para se referir aosoftware utilizado para
controlar o robô, i.e., corresponde ao sistema instalado no controlador;
• Station – ambiente de trabalho, constituído por um ou mais manipuladores robóticos e
demais objetos e mecanismos.
Consola
Manipulador
Controlador
Figura 1 – Manipulador robótico ABB IRB2400 existente no Laboratório de Robótica.

É ainda importante definir alguns conceitos base relacionados com a programação de robôs, quer
em ambientes reais, quer em ambientes simulados:
• Programação online – consiste em programar um robô através do módulo real do mesmo;
• Programação offline – consiste em programar um robô virtual através de um editor de texto
ou num programa de simulação;
• Controlador virtual –software que simula o controlador real, permitindo interagir e programar
um robô virtual como se fosse um robô real;
•
Sistema de coordenadas (ou frame) – quer no ambiente real, quer no ambiente simulado,
torna-se bastante útil a utilização de diferentes sistemas de coordenadas para diferentes
operações, objetos ou áreas de trabalhos;
3.1 Versão Utilizada

No Laboratório de Simulação de Sistemas (DS0.10) encontra-se instalada a versão6.04.01 do
RobotStudio. Aconselha-se a utilização da versão 64-bit para um melhor desempenho, caso
tenha um PC 64-bit.

A versão do RobotStudio utilizada na UC de Robótica está disponível para descarregar
gratuitamente no sítio Web do fabricante, no entanto essa versão apenas disponibiliza todas as
funcionalidades durante 30 dias. No Moodle, Secção “FAQ – RobotStudio” da página da UC de
Robótica, encontra as instruções necessárias para descarregar e instalar o RobotStudio. A ESTG
possui uma licença de campus que permite a utilização do RobotStudio sem restrições de tempo
para trabalhos académicos, desde que utilizada dentro do campus. Consulte a FAQ no Moodle para
mais informações relativamente à instalação e configuração do RobotStudio no seu PC.
3.2 Ambiente de Trabalho
Abra o RobotStudio, surgindo o ambiente de trabalho inicial ilustrado na Figura 2. De salientar o

ícone no topo, à direita, com o ponto de interrogação (também acessível através do menu
FileHelp), o qual permite aceder ao menu de ajuda do RobotStudio. Esse menu contém vários
itens, sendo os mais relevantes os seguintes:
• RobotStudio Help – acesso a um sistema de ajuda bastante completo sobre a utilização do
RobotStudio;
• RAPID Instructions, Functions and Data Types– acesso à descrição da linguagem de
programação, em particular das várias funções disponíveis.
Figura 2 – Ambiente inicial de trabalho do RobotStudio.

Se após a conclusão do(s) tutorial(ais) tiver dúvidas sobre alguma funcionalidade ou função, este é
um dos repositórios onde encontrará a informação necessária.
Nesta altura deverá abrir a secção RobotStudio Help e, no separador Contents, abrir o item
Introduction to RobotStudio  User Interface  Ribbon, tabs and groups. Neste item verá uma
descrição resumida dos vários blocos disponíveis no ambiente de trabalho do RobotStudio, tal como
mostra a Figura 3.
Figura 3 – Blocos disponíveis no ambiente de trabalho do RobotStudio (retirado de

RobotStudio Help).
Como pode confirmar pela ajuda fornecida pelo programa, tem-se:
File – acesso às funcionalidades de sistema do RobotStudio, como criar um documento
novo, gravar, opções da aplicação, etc.;

Home – acesso as funcionalidades base do RobotStudio, nomeadamente importar sistemas,
robôs, criar caminhos, etc.;
Modeling – acesso à criação de objetos, medidas, operações CAD, etc.;
Simulation – acesso aos comandos e controlo de simulação;
Controller – acesso aos comandos de sincronização e controlo dos controladores, sejam
estes virtuais ou reais;
RAPID – acesso ao editor e depurador de código RAPID;
Add-ins – acesso a opções adicionais instaladas, nomeadamente controlo de soldadura,
etc..
Feche a janela de ajuda do RobotStudio.
3.3 Abrir e Simular um Ambiente de Trabalho Exemplo

Além de incluir inúmeros robôs e um conjunto de ferramentas, o RobotStudio inclui ainda um
conjunto de exemplos completos de ambientes de trabalhos prontos a simular. Estes exemplos
estão armazenados num ficheiro comprimido específico do RobotStudio, o qual permite facilmente
transferir o ambiente de trabalho entre diferentes computadores/utilizadores. O RobotStudio
disponibiliza três funcionalidades para este fim, acessíveis através do menuFile  Share (ver
Figura 4):
• Pack and Go – permite exportar todo um ambiente de trabalho num único ficheiro
comprimido. Esse ficheiro poderá depois ser utilizado noutro computador, ou por outro
utilizador para abrir e/ou editar esse mesmo ambiente de trabalho
1
;
• Unpack and Work – permite abrir e trabalhar num ambiente de trabalho armazenado através
da opção Pack and Go;
• Save Station as Viewer – permite guardar a estação com simulações que tenham sido
efetuadas, permitindo visualizar as mesmas em PCs que não tenham o RobotStudio
instalado. Note que não é possível editar esse ambiente de trabalho.
NOTA: Todos os trabalhos devem ser entregues para avaliação utilizando o ficheiro obtido
através da opção Pack and Go. Aconselha-se ainda que os estudantes façam frequentemente
cópias de segurança do ambiente de trabalho desenvolvido usando essa opção. Sempre que
mudarem de computador devem também usar esta opção para copiar a estação de trabalho
entre PCs.
Figura 4 – Ficheiros Pack & Go.
1 Note-se que um ambiente de trabalho no RobotStudio é composto por múltiplos ficheiros. A opção Pack &
Go permite criar um único ficheiro comprimido que inclui todos esses ficheiros.
O RobotStudio inclui alguns exemplos completos que pode experimentar, dois dos quais se
descrevem de seguida.
3.3.1 Exemplo de soldadura

1. Escolha a opção Unpack and Work clicando no menu File  Share  Unpack and Work e
clique em Next. De seguida navegue até ao ficheiro com o ambiente de trabalho pretendido,
neste caso disponibilizado na pasta C “ :\Program Files (x86)\ABB Industrial IT\Robotics
IT\RobotStudio 6.04\Samples\Stations” com o nome “Demo AW Station.rspag”.
2. Escolha uma pasta para onde descompactar o sistema a trabalhar, por exemplo, uma pasta
em “Os meus documentos” (pode ser a pasta sugerida por omissão). A opçãoUnpack“ to
Solution” serve para indicar ao RobotStudio que deve ser criada uma pasta específica para
o ambiente em questão. Caso não ative esta opção, a pasta será partilhada por outros
ambientes, tipicamente na pasta padrão do RobotStudio. Embora ocupe mais espaço,
aconselha-se a ativar esta opção para manter todos os ficheiros necessários numa mesma
estrutura dentro duma pasta específica do ambiente a trabalhar.
-
Figura 5 – Exemplo de soldadura.
3. Proceda com as opções indicadas por omissão, exceto relativamente à opçãoLibrary
Handling, onde deverá escolher a opção Load files from Pack & Go. Quando clicar em Finish
ambiente de trabalho será carregado (note que o carregamento do ambiente de trabalho
usando a opção Unpack and Work pode demorar algum tempo, podendo surgir alguns
avisos, os quais podem ser ignorados). No final deverá surgir um ambiente semelhante ao
da Figura 5. No canto inferior direito pode visualizar C
“ ontroller status: 1/1”, sendo o dígito
da esquerda o número de controladores utilizados, e o dígito da direita o número de
controladores ativos.
NOTA: Procure utilizar e desenvolver um dado ambiente de trabalho sempre na mesma pasta, no
mesmo PC, para assim evitar gastar tempo com a operação Unpack and Work.
Neste ambiente encontra um manipulador robótico e um posicionador, estando o manipulador
equipado com uma ferramenta de soldadura ABICOR Binzel.
Para iniciar a simulação do sistema, escolha o menuSimulation e pressione a opção Play. Em
qualquer altura poderá utilizar o botão esquerdo do rato para selecionar objetos do ambiente de
trabalho e o botão direito para aceder a opções desses mesmos objetos. A roda do rato permite
aproximar e afastar, Ctrl + botão esquerdo do rato permite arrastar o ambiente e, finalmente, Ctrl +
Shift + botão esquerdo do rato permite rodar o ambiente.
Feche o ambiente clicando no menuFile seguido da opção Close. Note que sempre que executa
uma simulação ocorrem alterações no ambiente, incluindo configuração dos robôs, posição dos

objetos, etc.. Ao selecionar a opção de guardar as alterações efetuadas, está na verdade a alterar
o ambiente face ao seu formato srcinal, mesmo que apenas tenha corrido a simulação.Assim,
deverá sempre gravar o ambiente antes de efetuar uma simulação, ou selecionar a opção
Reset (menu Simulation) após a simulação e antes de gravar o ambiente, repondo este no
estado em que estava antes da simulação.
3.3.2 Exemplo de uma Linha de Produção

Abra e simule um outro exemplo fornecido, nomeadamente o exemplo “Demo Solar
Simulation.rspag”. Neste exemplo, ilustrado na Figura 6, pode ver a simulação de parte de uma
linha de produção de pequenos painéis solares. Este exemplo introduz componentes avançados de
simulação, os quais
células ao colocar as permitem quemesa
mesmas na o primeiro
rotativa.robô
Esteconsiga
exemplocorrigir a posição
inclui ainda de cadadeuma
a simulação das
tapetes
(conveyors em inglês). De salientar que são utilizados dois controladores, um por robô, tal como
poderá confirmar pela informação“Controller Status 2/2” no canto inferior direito.
Figura 6 – Exemplo de uma linha de produção de painéis solares.

Simule este exemplo e veja o mesmo a correr.
3.3.3 Outros exemplos

Na pasta Samples\Stations (onde encontra os exemplos anteriores)encontra ainda os exemplos
“Demo FlexLoader.rspag”(Figura 7) e “Demo Exhaust Pipe.rspag” (Figura 8).
Figura 7 – FlexLoader. Figura 8 – Exhaust Pipe.

No exemplo da Figura 7 encontra uma simulação com múltiplos robôs a trabalhar coordenadamente
em soldadura, utilizando um único controlador, enquanto no exemplo daFigura 8 encontra dois
manipuladores novamente a realizar uma operação de soldadura, mas neste caso coordenada com
um posicionador, também neste caso com um único controlador.

3.4 Criar Ambientes de Trabalho
Na secção anterior teve a oportunidade de simular ambientes complexos com múltiplos robôs, já
fornecidos com o RobotStudio. O primeiro passo para simular um sistema automatizado consiste
na criação do mesmo no ambiente de simulação, neste caso o RobotStudio.
Note que é possível criar todo o ambiente de trabalho, incluindo objetos, no RobotStudio. No entanto
a alteração de objetos criados dentro do RobotStudio é muito limitada, sendo apenas possível
apagando os existentes e criando novos, ou através de funções de corte, união, etc. Não é possível,
por exemplo, modificar as dimensões de um cubo criado previamente, alterando apenas as
propriedades deste. Como tal poderá optar por criar o ambiente e/ou objetos deste num sistema de
modelação 3D (ex. Autocad, Inventor, SolidWorks, Google ShetchUp, etc.) para importar no
RobotStudio2.
NOTA: De modo a acelerar o processo de desenvolvimento deverá sempre projetar
previamente (por exemplo, em papel), o ambiente de trabalho a simular com todas as
dimensões incluídas.
Tal como indicado na ajuda do RobotStudio (verRobotStudio Help  Building stations  Workflow
for building a station ), existem três formas de criar um novo ambiente de trabalho (menuFile 
New):
• Solution with Empty Station – cria um novo ambiente de trabalho completamente vazio numa
pasta isolada;
• Solution with Station and Robot Controller – cria um novo ambiente de trabalho apenas com
um robô e um controlador, de acordo com o modelo escolhido, numa pasta isolada;
• Empty Station – cria um novo ambiente de trabalho completamente vazio.
A forma típica para criar o ambiente é utilizar a opção Solution with Station and Robot Controller,
selecionando o manipulador que se pretende (veremos outras opções posteriormente).
Existe um canal no YouTube criado pela ABB, o qual contém um conjunto de tutoriais e guias para
iniciar a utilização do RobotStudio, os quais complementam a documentação fornecida pelos
docentes e pela ajuda do RobotStudio. Poderá aceder a esse canal em
3
:
http://www.youtube.com/user/RobotStudio
Note no entanto que uma boa parte dos tutoriais disponibilizados naquele canal estão
desatualizados e não são aplicados diretamente na versão utilizadas nas aulas. De salientar ainda
que, para a realização dos trabalhos e conclusão da UC não é necessário consultar esses vídeos,
embora o possa fazer.
3.4.1 Criar um ambiente de trabalho com um robô e um controlador

Esta secção demonstra como criar um novo ambiente de trabalho com um único robô e um
controlador:
1. Clique File  New  Solution with Station and Robot Controller(pode demorar na 1ª vez
2 Para verificar quais os tipos de ficheiros suportados para importar objetos 3D para o RobotStudio, clique em
Home  Import Geometry  Browse for Geometry e confirme na nova janela as extensões suportadas. Note
que algumas geometrias não permitem operações de snap, como é o caso das criadas no Google SketchUp.
3 Poderá visualizar algumas reportagens sobre casos reais na utilização de manipuladores robóticos, em
particular do ambiente de simulação RobotStudio.

que corre);
2. Selecione um robô em Robot model, por exemplo o IRB1600_6kg_1.2m4, o nome a atribuir
ao ambiente de trabalho (Solution Name), o nome a atribuir ao controlador C
( ontroller
Name), a pasta onde quer gravar e clique emCreate;
3. Durante o arranque pode confirmar a inicialização do controlador, através da passagem a
verde do estado do controlador (canto inferior direito da janela principal);
4. Pode fazer zoom, pan e rodar o ambiente seguindo as indicações fornecidas na Secção
3.3.1 ;
5. Para voltar a visualizar toda o ambiente de trabalho, clique na opçãoView All, disponível
clicando com o botão direito do rato no ambiente (verFigura 9);
Figura 9 – Visualizar todo o ambiente de trabalho.

6. Para gravar o ambiente de trabalho criado, clique em File  Save Station ou Save Station
As, caso pretenda alterar o nome e/ou a localização do mesmo e atribua um nome ao
ambiente;
7. Pode confirmar que o ambiente foi gravado com sucesso verificando a mensagem que
aparece no separador Output (na parte inferior da janela do RobotStudio);
Caso queira exportar o ambiente de trabalho desenvolvido, quer para o abrir noutro PC, quer para
ficar com uma cópia de segurança, deverá utilizar a opçãoPack & Go, seguindo os seguintes
passos:
1. File  Share  Pack and Go;
2. Escolha um nome e local para o ficheiro a armazenar e clique emOK. Nesta altura poderá
confirmar através do explorador do Windows que o ficheiro em causa foi criado.
3.5 Sistemas de Coordenadas

Na base de qualquer sistema que implique movimento estão os sistemas de coordenadas, também
denominados de referenciais. Em manipulação robótica é usual utilizar-se múltiplos sistemas de
coordenadas, relacionados entre si de forma hierárquica, tal como abordado na aula teórica.
Como detalha a ajuda do RobotStudio R
( obotStudio Help  Introduction to RobotStudio  Terms
and Concepts  Coordinate Systems), definem-se os seguintes sistemas de coordenadas (ver
exemplo típico na Figura 10):
4O nome do robô indica que este é um modelo com 6 kg de carga máxima suportada e 1.2 m de alcance
máximo.
World Coordinate System – Este é o referencial do mundo, que serve de base a todo o
ambiente de trabalho. Sempre que alguma coordenada é especificada em coordenadas do
mundo, é a este referencial que se refere;
Task Frame Coordinate System – Este referencial, definido relativamente ao referencial
anterior, pode ser usado como referencial base de uma dada tarefa. É sobretudo útil se
houver múltiplas células de trabalho no mesmo ambiente, com múltiplos robôs ou
mecanismos a trabalhar numa mesma célula. Nessa situação poderá haver um mesmo
referencial base para os vários robôs ou mecanismos
5
;
Base Coordinate System – Sistema de coordenadas base associado a cada robô,
localizado por omissão no centro da base do mesmo, junto ao plano de apoio da sua base;
Tool Center Point Coordinate System (TCP) – Referencial associado à ferramenta.
Tipicamente o local onde a ferramenta deverá trabalhar será especificado para que o TCP
fique coincidente com essa postura, sendo essa postura a que é armazenada durante a
opção Teach Target(a descrever posteriormente). Cada robô tem um referencial por omissão
denominado tool0, inicialmente localizado no extremo do punho;
Workobject Coordinate System – O Workobject é um referencial auxiliar que pode servir
de base a uma qualquer zona de trabalho, facilitando a alteração e especificação de pontos
de trabalho com base em objetos existentes. Por omissão todos os robôs possuem
inicialmente um Workobject denominado wobj0, o qual é coincidente com o referencial base
do robô.
A título de exemplo pode observar um conjunto de referenciais na Figura 11 num ambiente
semelhante ao que irá criar ao longo deste tutorial. Neste exemplo os referências do mundo, de
base do robô, da tarefa, bem como o Workobject por omissão (wobj0) estão coincidentes. O
referencial da “ferramenta”
AW_Gun corresponde por omissão,
ao referencial
tool0, encontra-se no extremo do punho. O referencial
associado à ferramenta inserida no robô. Neste exemplo foi
ainda adicionado um novo Workobject (Workobject_1), associado a um hipotético espaço de
trabalho (neste caso a face superior do cubo exibido). Note que as cores dos eixos são sempre as
mesmas, isto é, os eixos X são vermelhos, os Y são verdes e os Z são azuis (XYZ ↔ RGB).
tool0 AW_Gun
World, Base, Task,

WorkObject_1
wobj0
Figura 10 – Relação entre os vários referenciais. Figura 11 – Examplo the referenciais utilizados.
3.6 Espaço de Trabalho e Alcance do Robô

Para a escolha do robô a utilizar no projeto de um sistema robotizado é essencial determinar o
5Note que não é obrigatória esta abordagem quando são utilizados múltiplos robôs. A abordagem típica é que
cada robô utilize o seu referencial base, sendo assim os movimentos independentes.
espaço de trabalho, operações a efetuar e alcance necessário. Assim, a escolha do robô deverá ser
feita apenas depois de responder a estas questões. Em termos de alcançabilidade, isto é,
determinação do espaço de trabalho do robô, o RobotStudio possui uma ferramenta útil (note que
o alcance do robô, bem como a carga máxima e outros dados fazem parte das especificações
tipicamente disponibilizadas pelo fabricante).
Tendo por base a estação criada anteriormente (verFigura 9) clique, no separador Layout, com o
botão direito do rato no robô (IRB1600_6_120__02) e selecione a opçãoShow Work Envelope,
resultando no ambiente de trabalho ilustrado naFigura 12. Desta forma fica bem patente quais os
pontos que o robô consegue alcançar.
Figura 12 – Espaço de trabalho do manipulador Figura 13 – Espaço de trabalho do manipulador

industrial em 2D. industrial em 3D.
Após selecionada a opção Show Work Envelope, pode selecionar, no separadorWork Envelope,
entre mostrar o espaço de trabalho em 2D ou 3D, bem como escolher se quer ver o espaço
alcançável pelo punho (não tem em conta a última ligação do robô) ou pela ferramenta (caso não
tenha nenhuma ferramenta, corresponde ao elemento terminal).
Note que esta informação só por si não é suficiente, pois o facto de o robô atingir um dado ponto
com uma determinada orientação não significa que o consiga com qualquer outra orientação. Assim,
se o robô irá conseguir ou não atingir uma determinada postura (posição mais orientação) irá
depender muito da orientação escolhida.
3.7 Adicionar Ferramentas Existentes

Esta secção detalha a adição de ferramentas ao manipulador. A ferramenta é uma parte crucial de
um manipulador, sendo a sua escolha dependente da tarefa a executar. As ferramentas podem ser
desenvolvidas à parte, no RobotStudio e/ou num programa de CAD (a ver num tutorial futuro), para
posteriormente serem importadas e adicionadas a um robô. Execute os seguintes passos:
1. Abra o ambiente de trabalho criado no ponto anterior, caso o tenha fechado;
 
2. Adicione uma ferramenta através da opção Home Import Library Equipment (a primeira
vez que acede a este menu pode demorar algum tempo) seguida da escolha da ferramenta
MyTool, tal como ilustrado naFigura 14;
3. Por omissão a ferramenta adicionada é colocada na srcem do ambiente de trabalho, i.e.,
na posição (X,Y,Z) = (0,0,0) com orientação (RX,RY,RZ)=(0,0,0), sendo necessário adiciona-
la ao robô. Para tal, no separador Layout selecione a ferramenta adicionada, MyTool, e
arraste-a para o robô (no mesmo separador), tal como ilustrado na Figura 15. À questão “Do
you want to update the position of ‘MyTool’?”responda “Yes”, de forma a garantir que a

ferramenta será colocada no punho do robô na postura certa.
Figura 14 – Escolha de uma ferramenta. Figura 15 – Atribuição de uma ferramenta ao robô.

NOTA: Quando adiciona um manipulador ao ambiente de trabalho, o sistema de coordenadas que
é considerado nos movimentos deste é o do elemento terminal, visível na ponta do manipulador.
Quando se adiciona uma ferramenta, o referencial utilizado passa a ser o da ferramenta. De facto
poderá constatar que o espaço de trabalho do robô Work( Envelop) aumentou com a adição da
ferramenta. Na prática o que acontece é que o referencial base da ferramenta é feito coincidir com
o referencial do elemento terminal do robô, passando o sistema de coordenadas utilizado nos
movimentos do robô a ser o da (ponta da) ferramenta. Assim, quando criar posturas e caminhos, tal
deve ser efetuado considerando sempre a ferramenta, isto é, no desenvolvimento de um
ambiente de trabalho, não deve criar posturas ou caminhos sem ter primeiro adicionado a
ferramenta que pretende ao robô.
3.8 Adicionar Objetos Existentes

Esta secção descreve como adicionar objetos previamente criados ao ambiente de trabalho.
Execute os seguintes passos:
1. Selecione a opção Home  Import Geometry  Browse for Geometry e escolha o objeto
“Table_small.sat” disponível na pasta C
“ :\Program Files (x86)\ABB Industrial IT\Robotics
IT\RobotStudio 6.04\ABB Library\Training Objects ”, resultando no ambiente ilustrado na
Figura 16;
Figura 16 – Adição de um objeto ao Figura 17 – Movimento livre. Figura 18 – Mesa

ambiente. centrada.
2. Selecione o objeto adicionado, i.e., a mesa, e ative a opção de movimento manual clicando
em Home  Move, tal como ilustra a Figura 17. Movimente a mesa para que esta fique em
frente ao robô, sensivelmente ao centro deste e dentro do espaço de trabalho, tal como
ilustra a Figura 18);
NOTA: Preferencialmente deverá utilizar um movimento específico e não um movimento
manual. Para tal, clique na mesa com o botão direito do rato (no ambiente de trabalho ou no
separador Layout), e escolha a opção Position  Set Position. Em coordenadas do mundo
(World) introduza as coordenadas (X,Y,Z) = (700, -375, 0) [mm]. Clique emApply6 e confirme
que a mesa fica dentro do espaço de trabalho do robô Work
( Envelop);
3. Adicione um novo objeto através de Home  Import Geometry  Browse for Geometry e
da escolha do ficheiro “C:\Program Files (x86)\ABB Industrial IT\Robotics IT\RobotStudio
”;
6.04\ABB Library\Training Objects\Curve_thing.sat
4. Altere o aspeto do objeto através dos seguintes passos:

a. Clique no objeto com o botão direito do rato;
b. Escolha a opção Modify  Graphic Appearance…;
Figura 19 – Alteração do aspeto gráfico do Figura 20 – Aspeto gráfico final do objeto.

objeto.
c. Em Selection escolha a opção Body (ver Figura 19) e altera na opção Simple Color
para laranja;
d. Repita a operação para a componente maior do objeto, com a cor castanha,
resultando no aspeto ilustrado naFigura 20.
e. Clique em OK para terminar.
5. Coloque este último objeto em cima da mesa utilizando um
movimento baseado em dois pontos, srcem e destino, como
detalhado nos seguintes passos:
f. Clique no objeto com o botão direito do rato;
g. Escolha a opção Position  Place  One point;
h. Ative a opção Snap End7, selecionando a mesma na Figura 21 – Ativar a opção
barra inferior da janela do RobotStudio (verFigura 21); Snap End.
i. Clique num dos campos das coordenadas do ponto de srcem (Primary Point - From)
e depois clique num canto inferior do objeto. Depois clique num dos campos das
coordenadas do ponto destino P ( rimary Point - To) e clique um canto correspondente
6 Pode ainda aplicar uma operação de rotação seguindo passos similares com a opção de rotação/orientação.
7 Opções semelhantes às que encontra no AutoCAD ou outro qualquer software de desenho geométrico.
do tabuleiro da mesa, à semelhança do ilustrado naFigura 22;
Figura 22 – Movimento de um objeto usando dois pontos.

j. Clique em Apply resultando no ambiente ilustrado naFigura 23.
6. Rode o objeto clicando no mesmo com o botão direito do rato e selecionando a opção
Position  Rotate. Altere o referencial de coordenadas para Local, selecione o eixo dos Zs
e um ângulo de rotação de -90º e aplique a rotação;
NOTA: Na opção Rotate poderá rodar em torno de um eixo definido por si, ou em torno de um
eixo de coordenadas pré-definido, tal como aconteceu neste caso.
Figura 23 – Objeto deslocado. Figura 24 – Postura final do objeto.

7. Altere em Snap Mode para a opção Snap Object e centre o objeto através da opção de
mover baseado em dois pontos (como realizado anteriormente), mas utilizando como
referência pontos intermédios da peça e da mesa. No final a peça deverá estar centrada na
mesa, tal como mostra a Figura 24. Tire proveito do facto de poder apenas aplicar a
translação em eixos selecionados (opçãoTranslate along these axes).
8. Guarde o trabalho.
O RobotStudio inclui não só um conjunto de objetos de interesse, mas também um conjunto de
ferramentas que poderá utilizar, nomeadamente de soldadura, jato de água, etc. Estes itens estão
disponíveis na pasta indicada anteriormente e também através do menuHome  Import Library
(embora aqui possam ter informação extra, não geométrica, adicionada). Poderá ainda clicar em
File  Share  Content Sharing para aceder a um conjunto de modelos (e vídeos) disponibilizados
pela comunidade e/ou para partilhar os conteúdos desenvolvidos por si.
3.9 Criar e Importar Novos Objetos

Os objetos que constituem o ambiente de trabalho podem ser desenvolvidos no próprio RobotStudio
ou numa aplicação externa e posteriormente importados. Estes objetos são denominados de
geometry no RobotStudio, dado que se tratam de figuras geométricas. Quando a essas figuras
geométricas estão associadas outras características e funcionalidades próprias do RobotStudio
(ferramentas, mecanismos, robôs, etc.), passam a denominar-se library (biblioteca). Tipicamente
quando são importadas bibliotecas, estas mantêm a sua ligação ao ficheiro externo, sendo apenas
criado um novo ficheiro se o utilizador pretender efetuar alterações à biblioteca.
Relativamente aos objetos compostos apenas por figuras geométricas, o RobotStudio permite
importar um conjunto de formatos diferentes, nomeadamente sat, igs/iges, stp/step/p21, vda/vdafs,
model/exp, CATPart/CATProduct, prt/asm, ipt, wrl/vrml/vrml1/vrml2, jt, stl, ply, 3ds e dae (aceda à
lista completa fazendo Home  Import Geometry  Browse for Geometry). Note no entanto que
alguns formatos poderão necessitar de uma licença extra. Com a instalação do RobotStudio é ainda
disponibilizada uma ferramenta que permite converter conjuntos de ficheiros do AutoCAD numa
única operação, ferramenta essa denominada deCAD Converter.
Caso o estudante se sinta confortável com um destes formatos pode desenvolver o seu ambiente
de trabalho na aplicação correspondente e importá-la no RobotStudio. Caso contrário pode
desenvolver o ambiente no próprio RobotStudio, embora com bastantes limitações quando
comparado com aplicações específicas de modelação e desenho 3D. Lembre-se que o RobotStudio
é um software de simulação na área da Robótica, não é umsoftware de desenho.
Os passos seguintes descrevem a utilização básica do RobotStudio para criar figuras geométricas:
1. Abra a estação criada anteriormente, caso esteja fechada, e selecione a opção Modeling 
Solid  Box (ver Figura 25);
2. Como pode confirmar na Figura 26, na definição da posição e dimensão do paralelepípedo
tem a opção de escolher qual o referencial utilizado como base (por omissão é no referencial
do mundo). Neste caso pretende-se adicionar um paralelepípedo com 600 mm de lado,
centrado na posição (0, 1100, 0) [mm] e orientado segundo os eixos de coordenadas. Dado
que a especificação da posição do paralelepípedo se baseia num dos vértices deste, tem
que introduzir as coordenadas para o vértice (-300, 800, 0) [mm] e orientação (0,0,0) para
manter o alinhamento com o referencial de base. Relativamente à dimensão, se colocar
apenas o comprimento, o RobotStudio assume a mesma dimensão para todos os lados.
Corner
Point
Figura 25 – Criar um paralelepípedo. Figura 26 – Posições e dimensões na criação de

um paralelepípedo.
Como pode observar pelo resultado, ilustrado naFigura 27 (após alteração da cor do material para
vermelho), foi adicionado um elemento no separadorModeling, denominado Part_1. Este objeto
(part) é constituído neste momento por um elemento apenas, denominado deBody.

3. Adicione agora uma pirâmide retangular com a mesma altura do paralelepípedo e mesmas
dimensões de base, tal como ilustrado na Figura 28 (utilize a opção Snap Object para facilitar
o posicionamento da pirâmide). Fica assim com dois elementos:Part_1 e Part_2.
Figura 27 – Estrutura de informação de objetos. Figura 28 – Conjunção de múltiplos objetos.

4. Caso se pretenda que os dois objetos criados sejam um só, existem várias alternativas. A
mais simples consiste em arrastar um dos elementos Body
( ) para o outro objeto, no
separador Modelling. Neste ficam apenas com um objeto formado por dois elementos
distintos. Cada um dos elementos pode ser selecionado de forma independente.
Experimente esta opção, desfazendo-a de seguida undo
( ) para voltar à situação anterior;
5. Alternativamente pode fazer a união dos dois objetos clicando em Modeling  Union
seguido da seleção dos dois objetos. Esta operação resulta num objeto com um único
elemento. Experimente realizar esta operação. A opçãoKeep Original permite guardar os
objetos srcinais.
Existe um conjunto de formas geométricas que pode criar, bem como um conjunto de operações
que pode efetuar, todas disponibilizadas a partir do menuModeling. Estas figuras geométricas e
operações são em tudo idênticas às existentes em aplicações de modelação 2D e 3D. Encontra
mais informação sobre as mesmas emRobotStudio Help  Modeling Tab.
NOTA: Os nomes atribuídos aos vários elementos constituintes do ambiente de trabalho podem
facilmente ser editados clicando duas vezes com o botão esquerdo do rato nos mesmos, ou clicando
com o botão direito do rato seguido da opçãoRename. Procure atribuir sempre nomes sugestivos
aos vários elementos, permitindo assim uma mais fácil reutilização, depuração e avaliação do
trabalho desenvolvido.
3.10 Modos de Visualização

Por vezes alguns dos pormenores do ambiente de trabalho poderão ser mais percetíveis em
diferentes modos de visualização. Em particular, poderá recorrer ao modowireframe (modelo de
arames), situação em que as superfícies serão transparentes e apenas visualizadas as arestas, tal
como exemplificado na Figura 29. Para aceder a esta visualização, clique emHome  Graphics
Tools  Representation  Wireframe. Caso queira dar um aspeto mais avançado em termos de
gráficos, pode selecionar a opção Advanced Lighting no mesmo menu. No entanto tal não é
aconselhado durante o desenvolvimento, pois implica um consumo mais elevado de recursos
computacionais por parte do RobotStudio.

Figura 29 – Modelo de Arames.
3.11 Movimentar o Robô e Criar Caminhos
Nesta secção irá aprender os modos básicos para:
• Movimentar o robô;
• Criar posturas de trabalho (tipicamente denominados em inglês porTarget Point ou
Geometry Points, GPs);
• Criar um caminho a realizar pelo robô.

A forma mais simples de especificar um movimento/trajetória para um manipulador, é “ensinando-
lhe” posturas de interesse, posturas essas que são depois unidas num movimento pré-configurado.
A estas posturas está associada uma configuração do robô, bem como um tipo de movimento entre
posturas (linear, circular ou de junta). Essas posturas são normalmente denominados em inglês por
targets, sendo o processo de as criar denominadoTeach target. O caminho que une essas posturas
denomina-se em inglês depath.

Os passos que se seguem permitem de uma forma simples compreender a diferença entre um
movimento de junta e um movimento linear, sendo que, para este último, é necessário que o
controlador atue sobre uma ou mais juntas em simultâneo. Poderá ainda observar os valores
mínimos e máximos de cada junta, os quais limitam o movimento do manipulador em si. Realize os
seguintes passos:
1. Abra o ambiente de trabalho criado anteriormente, caso ainda não esteja aberto;
Movimento de Juntas (manual)
2. Selecione movimento manual de juntas, clicando emHome 
Freehand Jog Joint (ver Figura 30);
3. Neste modo, quando seleciona uma junta, esta fica marcada.
Experimente selecionar cada uma das seis juntas do robô e
movimentá-las com o rato. Para testar as juntas mais próximas
do elemento terminal do robô, aconselha-se a que façazoom
a essa zona; Figura 30 – Movimento
manual de juntas.

Movimento Linear (manual)
4. Selecione agora movimento manual linear, clicando emHome
 Freehand Jog Linear (ver Figura 31);
5. Neste modo poderá movimentar o robô sem que ocorram

alterações da orientação do elemento terminal. Para tal
selecione e arraste um dos eixos. Poderá confirmar que o
robô movimenta várias juntas de modo a garantir um
movimento linear segundo o eixo e direção selecionados. Figura 31 – Movimento
Note que, caso tenha selecionado uma das opções deSnap, manual linear.
o robô tentará ir para essas posições;
6. Desabilite a opção Jog Linear;
Controlo manual (numérico) de juntas
7. No separador Layout selecione o robô IRB1600_6_120__02
(ver Figura 32), aparecendo um novo menu de topo,
Mechanism Tools, correspondente à seleção feita;
Figura 32 – Selecionar o
8. Abra o separador de controlo e visualização numérica das robô.
juntas clicando em Mechanism Tools  Modify  Mechanism Joint Jog. Surgirá um novo
separador, ilustrado na Figura 33. Também poderá aceder a esta funcionalidade, clicando
com o botão direito do rato no robô, no separadorLayout, seguido da opção Mechanism
Joint Jog;
9. Neste separador poderá controlar e visualizar o valor de cada
junta do robô. Poder arrastar os valores com o rato, clicar nas
setas ou, após selecionar um dos valores de junta, escrever
um valor específico através do teclado. Nesse separador
poderá ainda monitorizar a configuração utilizada bem como
as coordenadas do Tool Center Point (TCP), i.e., as Figura 33 – Controlo manual
coordenadas da ferramenta; (numérico) de juntas.
Controlo manual (numérico) linear
10. Poderá da mesma forma ativar o controlo numérico linear, clicando em
Mechanism Tools 
Modify  Mechanism Linear Jog;
11. No novo separador poderá visualizar as coordenadas em posição (X, Y, Z) e orientação (RX,
RY e RZ) do elemento terminal de acordo com o referencial escolhido;
Movimento para a postura Home
12. O robô pode possuir um conjunto de posturas armazenadas,
sendo uma destas, incluída por omissão, denominadaHome.
Esta
todas corresponde
as juntas estãotipicamente à postura
na sua posição do robô
zero. Pode em que
em qualquer
altura colocar o robô nesta postura clicando com o botão
direito do rato no robô no separadorLayout, seguido da opção
Jump Home;
Figura 34 – Adicionar uma
postura de trabalho.

Criar posturas de trabalho (targets)
13. Existem várias formas de criar posturas de trabalho. Uma delas consiste em colocar a
ferramenta do robô na postura pretendida, gravando de seguida essa postura. Para tal,
mantenha o robô na postura Home (ponto anterior) e selecione a opçãoHome Teach
Target (se surgir um aviso sobre o uso dos referenciais “tool0”
e “wobj0”, escolha a opção “Yes”), como mostra a Figura 34.
Note que esta postura foi adicionada considerando a tarefa,
Workobject e ferramenta definidos em Settings do separador
Home (ver Figura 35);
Figura 35 – Adicionar uma
14. Mova o robô atuando na junta 1 e guarde a postura alcançada
executando de novo Home Teach Target;
 postura de trabalho.
15. Mova o robô utilizando um movimento linear ao longo do eixo
dos Zs negativo, seguido de um movimento linear horizontal ao
longo de X positivo. Guarde a nova postura alcançada através
da função Teach Targete cancele a opção de mover o robô;
16. Escolha o separadorPaths&Targets e expanda as propriedades
do robô de modo a visualizar as posturas criadas anteriormente,
tal como mostra a Figura 36. Confirme que foram criadas 3
posturas com os nomes por omissão: Target_10, Target_20 e Figura 36 – Posturas de
Target_30. Note que pode selecionar uma ou mais posturas, trabalho criadas.
ficando estas evidenciadas no ambiente;
Criar um caminho
17. Adicione um novo caminho (vazio) ao robô executando Home
 Path  Empty Path (ver Figura 37). Por omissão o novo
caminho denomina-se Path_10;
Figura 37 – Criar um caminho
18. Selecione as 3 posturas criadas anteriormente e arraste-as vazio.
para o caminho criado no ponto anterior, resultando num
conjunto de instruções tal como ilustra a Figura 38. Por
omissão o movimento a realizar entre as várias posturas é do
tipo linear, razão pela qual é utilizada a função MoveL
(futuramente serão dados mais detalhes sobre esta e outras
funções). Confirme que o caminho aparece no ecrã (ver
Figura 40);
NOTA: O caminho que é desenhado no ecrã não corresponde
necessariamente à trajetória que o robô irá descrever, pois tal
depende do tipo de movimentos escolhidos e respetivos parâmetros.
19. Selecione as 3 instruções adicionadas ao caminho, clique Figura 38 – Posturas de
com o botão direito do rato nessa seleção e escolha a opção trabalho criadas.
Edit Instruction. Altere o tipo de movimento deLinear (linear)
para Joint (junta) na opção Motion Type, resultando assim no
conteúdo ilustrado na Figura 39;
20. Clique em Simulation  Monitor, ative a opção Enable TCP
trace, altere a cor Trace color para laranja e clique em OK.
Desta forma ficará marcada a posição por onde o robô passar Figura 39 – Caminho com
movimento de juntas.
sempre que executar uma trajetória programada;
21. No separador Layout, clique com o botão direito do rato na postura Target_10 e escolha a
opção Jump To Target;
Figura 40 – Caminho criado. Figura 41 – Caminho executado.

22. Clique com o botão direito do rato no caminho criado (Path_10) e escolha a opção Move
Along Path. O caminho gerado será carregado para o controlador virtual e executado pelo
robô. Deverá visualizar no ambiente a execução do caminho criado, ficando marcado a
laranja o caminho efetivamente realizado pela ponta de ferramenta. Como pode confirmar,
o caminho não corresponde às linhas retas entre as várias posturas (mais à frente voltará a
abordar esta questão);
NOTA: No final da execução do movimento anterior irá surgir o erroProgram pointer has been reset
na janela de Output do RobotStudio. Esse erro é esperado e resulta do facto de, para testar o
caminho, ter sido criado e carregado um programa temporário para o controlador do robô. Como no
final o programa desaparece, o apontador de programa é perdido. Tal não deverá acontecer quando
tiver a realizar uma simulação completa, como verá nos tutoriais futuros.
23. Para terminar guarde o ambiente desenvolvido, de preferência utilizando a opção
Pack &
Go.
Note-se que as várias posturas criadas podem ser reutilizadas em múltiplos caminhos, pelo que
deve dar-lhes nomes relevantes para facilitar a identificação de cada uma. Para tal basta clicar duas
vezes no nome da postura cujo nome pretende alterar.
É muito importante que tenha percebido a diferença entre um movimento de junta e um movimento
linear. Enquanto num movimento linear a ferramenta realiza uma linha reta entre o ponto anterior e
o ponto objetivo, na realização de um movimento de junta não háqualquer garantia quanto ao trajeto
realizado pelo robô, apenas que irá começar e terminar nas posturas especificadas. Tal significa
que não devem ser utilizados movimentos de junta quando se realizam operações sensíveis, tais
como levantar e colocar objetos, ou em aproximações a objetos, pois poderá haverá o risco de
colisões. Por outro lado, a utilização de movimentos lineares deve ser evitada sempre que possível,
pois além do custo computacional mais elevado para o cálculo do movimento a realizar por parte
do controlador do robô, há tipicamente um custo energético e um tempo de execução superior
quando comparado com o movimento de junta para as mesmas duas posturas de srcem e destino.
Num movimento de junta o robô escolhe o caminho mais rápido entre a postura de partida e postura
de chegada.
4 Criar um Workobject
Tal como detalhado na ajuda do RobotStudio, na secção “How to program robots”, item
“Workobjects”, um Workobject consiste num referencial de coordenadas que é utilizado como
srcem na criação de um conjunto de posturas/caminhos tipicamente associados a um objeto, área
de trabalho e operação específicos. Considere que criou um caminho ao longo das arestas de um
dado objeto e que esse caminho tem por base umWorkobject. Caso pretenda processar a peça
numa postura diferente, tudo o que terá que fazer será reajustar o Workobject. Caso não tivesse
usado um Workobject nessa situação, seria necessário refazer todo o caminho e criar novamente
todas as posturas associadas. É fundamental a utilização de Workobjects para cada operação,
devendo sempre começar qualquer tarefa pela criação destes.
Outro conceito importante reside na escolha da configuração com que cada postura é atingida num
dado caminho. Embora tipicamente um manipulador, em particular um com seis juntas, seja capaz
de atingir a mesma postura com várias configurações distintas (valores diferentes de juntas), a
escolha das configurações é crucial para a execução do caminho com sucesso. Ao longo desta
secção ficará mais familiarizado com este conceito.
Realize os seguintes passos:
1. Abra o ambiente de trabalho gerado no tutorial anterior;
2. Selecione a peça em cima da mesa e centre-a no
separador de visualização, clicando na mesma com o
botão direito do rato e escolhendo a opçãoView Center.
Faça zoom à peça, resultando numa visualização
semelhante à da Figura 42;
3. Ative a opção Snap End ou Snap Object;
Figura 42 – Visualização da peça.
4. Clique em Home  Other  Create Workobject;
5. Modifique o nome do Workobject de Workobject_1 para MyWorkobject (procure sempre que
estes nomes sejam sugestivos);
Figura 43 – Seleção dos pontos para criar um Workobject.

6. Na componente User Frame clique em Frame by points, selecione a opção Three-point e
escolha os três pontos que definem o referencial associado ao plano de trabalho
(Workobject), tal como ilustra a Figura 43. O primeiro ponto corresponde à srcem do
Workobject, o segundo é um ponto ao longo do eixo X (positivo) e o terceiro é um ponto ao
longo do eixo Y (positivo);

7. Clique em Create, terminado assim a criação do Workobject.
No final o referencial associado ao Workobject ficará visível, tal
como ilustrado na Figura 44. Poderá inclusive seleciona-lo no
separador Paths&Targets de modo a ficar mais visível. Note
ainda que na secção Settings do menu Home passou a estar
selecionado o Workobject agora criado; Figura 44 – Workobject.
5 Criar um Caminho com Base nos Vértices de um Objeto

Anteriormente aprendeu a criar posturas e a gerar um caminho com base nestas. Na prática
interessa que as posturas criadas tenham alguma relação com a tarefa a desenvolver, tipicamente
associadas a objetos a trabalhar. Esta secção mostra como pode criar um caminho com base nos
vértices de um dado objeto. De salientar que as posturas geradas estar
ão associadas ao Workobject
criado na secção anterior. Com o ambiente anterior aberto, execute os seguintes passos:
1. Selecione a opção Home  Target  Create Target de modo a poder criar várias posturas;
2. Escolha quatro pontos nos vértices da peça clicando nos mesmos (no sentido dos ponteiros
do relógio e começando pelo vértice na srcem do Workobject), tal como ilustra aFigura 45
(deverá ter a opção Snap Object ativada). Note que as posturas são automaticamente
adicionadas à lista à esquerda. Confirme que oWorkobject selecionado é o MyWorkobject,
que a ferramenta selecionada é a ferramentaMyTool e clique em Create para terminar a
adição das posturas, resultando naFigura 46;
NOTA: Quando as posturas não são adicionadas usando a opçãoTeach target estas não incluem
a configuração do robô, razão pela qual ficam com um ponto de exclamação associado na lista de
posturas. Tal significa que não há ainda confirmação que a postura é de facto alcançável pelo robô,
algo que será determinado nos passos seguintes.
Figura 45 – Criação de posturas num objeto. Figura 46 – Posturas criadas num objeto.
3. De modo a facilitar a perceção das posturas definidas é possível visualizar a ferramenta do
robô nestas. Para tal selecione todas as posturas do Workobject criado e ative a opção
Target Tools Modify  View tool at target  MyTool, resultando na informação disponível
na Figura 47.

Figura 47 – Visualização da ferramenta nas posturas criadas.
Figura 48 – Posturas após primeira rotação. Figura 49 – Posturas após segunda rotação.
4. Tal como aFigura 47 mostra, as posturas escolhidas não são as ideais, pelo que têm de ser
alteradas. Para tal, mantendo todas as posturas selecionadas, clique emTarget Tools 

180º, obtendo o .resultado
Modify Rotate Com o referencial local selecionado, selecione o eixo de rotação X e rode
ilustrado naFigura 48. Selecione agora o eixo de rotação Z e rode
novamente 180º, obtendo o resultado ilustrado naFigura 49;
Figura 50 – Escolha da configuração.

5. Selecione a primeira postura do Workobject e clique em Target Tools Modify  Jump To
Target8. Irá surgir uma janela para escolher a configuração desejada. Experimente as várias
configurações disponíveis, escolha no final a primeira e façaApply (não feche a janela das
configurações). Na Figura 50 encontra o resultado esperado após a escolha da configuração
(0,-1,0,0);
8Poderá também aceder à opção Jump To Target clicando com o botão direito do rato na postura. Um número
razoável das opções disponíveis nos menus está também disponível por esta via.
6. Ative a opção Target Tools  Modify  View Robot at Target de modo a visualizar o robô
na postura selecionada. Selecione uma postura de cada vez das 4 criadas para o Workobject
e escolha a configuração desejada, de preferência a mesma que na postura anterior ou
próxima desta. Após configurar todas as posturas feche a janela das configuraçõe
s e cancele
a opção View Robot at Target. Note que à medida que configura as posturas estas deixam
de ter um ponto de exclamação associado, indicando que a postura foi verificada e é
alcançável pelo robô;
7. Crie um novo caminho vazio e adicione estas 4 posturas a esse caminho, arrastando-as
para lá;
8. Teste a execução do caminho, selecionando o mesmo e clicando emPath Tools  Modify
 Move Along Path, obtendo a trajetória indicada na Figura 51;
9. Como pode verificar pelo resultado obtido, o robô não executa os movimentos sempre em
linha reta entre posturas consecutivas, embora o resultado seja bastante mais próximo do
que o esperado, comparativamente à utilização de movimentos de juntasMoveJ( ). Tal deve-
se aos parâmetros utilizados para o movimento. Como não efetuou qualquer alteração a
estes parâmetros, este terá sido definido com as características indicadas na barra inferior
da janela do RobotStudio, nomeadamente movimentos lineares(MoveL) com velocidade de
1000 mm/s (v1000), aproximação de 100 mm (z100), a ferramenta MyTool e o Workobject
MyWorkobject (pode confirmar estes parâmetros colocando o ponteiro do rato por cima de
cada instrução de movimento). Neste caso em concreto, como definiu uma aproximação de
100 mm, assim que o robô estiver a menos de 100 mm da próxima postura, este avança
para o movimento seguinte;
Figura 51 – Caminho executado com erro. Figura 52 – Caminho executado com precisão.
10. Para a trajetória a realizar, tem duas hipóteses: poderá apagar as instruções, alterar as
opções na barra inferior da janela do RobotStudio e voltar a adiciona-las; alternativamente
pode selecionar todos os movimentos no separadorPaths&Targets e, clicando com o botão
direito do rato, escolher a opção Edit Instruction. Na janela que aparece altere a opçãozone
de z100 para fine, a precisão máxima do robô. Clique emApply e feche a janela;
11. Aceda novamente à opção Simulation  Monitor e clique na opçãoClear Trace para apagar
o traçado anterior e altere a cor para magenta para ser mais visível;
12. Corra novamente o caminho criado e verifique que a trajetória realizada pela ferramenta é a
apresentada na Figura 52. Verifique ainda que agora o robô para nos cantos da peça por
breves instantes, algo que não acontecia no movimento anterior;
13. Grave o ambiente criado.

Mas qual o significado do parâmetro zone?
Como poderá confirmar na ajuda RAPID Instructions, Functions and Data types Data types 
zonedata – Zone data, o parâmetro zone é do tipo zonedata. Quando esse parâmetro éfine, o robô
executa a trajetória com a precisão máxima e tipicamente esse ponto passa a ser um ponto de
paragem. Quando esse parâmetro toma um dos valores indicados naTabela 1, o movimento do
robô passa a ser um movimento aproximado, em função do valor escolhido, à semelhança do
exemplo ilustrado naFigura 53.
Path zone
Name TCP path Orientation Ext. axis
z0 0.3 mm 0.3 mm 0.3 mm
z1 1 mm 1 mm 1 mm
z5
z10 5 mm
10 mm 8 mm
15 mm 8 mm
15 mm
z15 15 mm 23 mm 23 mm
z20 20 mm 30 mm 30 mm
z30 30 mm 45 mm 45 mm
z40 40 mm 60 mm 60 mm
z50 50 mm 75 mm 75 mm
z60 60 mm 90 mm 90 mm
z80 80 mm 120 mm 120 mm
z100 100 mm 150 mm 150 mm
z150 150 mm 225 mm 225 mm
z200 200 mm 300 mm 300 mm
Tabela 1 – Dados de aproximação pré- Figura 53 – Execução de um caminho.

definidos
Mas qual o significado dos valores utilizados para a escolha de uma dada configuração?
Tal como descreve a secção de ajudaRobotStudio Help  Introduction to RobotStudio  Terms
and concepts  Robot axis configurations, uma dada configuração é definida com 4 valores inteiros,
cujos significados dependem do tipo de robô. No caso dos robôs com 6 juntas em série, os três
primeiros número significam: um número maior ou igual a zero corresponde a um movimento no
quadrante positivo correspondente (a começar em 0 para o primeiro quadrante); um número
negativo corresponde a um movimento no quadrante negativo correspondente (a começar em -1).
O quarto elemento indica qual das 8 possíveis posições do punho para três casos particulares do
robô (singularidades). No caso de juntas prismáticas o número inteiro indica o deslocamento em
metros da junta (arredondado para baixo). Apenas se incluem na configuração as juntas que o
fabricante considera relevantes para distinguir entre as várias configurações possíveis para atingir
a postura final do robô, podendo variar entre robôs. A título de exemplo, considere o valor [0 -1 2 1]
para um robô IRB 140:
• O primeiro valor, 0, diz respeito à primeira junta (base), indicando um ângulo entre 0º e 90º
(1º quadrante positivo);
• O segundo valor, -1, corresponde a um ângulo para a quarta junta entre 0º e -90º (1º
quadrante negativo);
• O terceiro valor, 2, corresponde a um ângulo para a sexta
junta entre 180º e 270º (3º quadrante positivo);
• O quarto valor, 1, indica que o punho estaria numa posição
idêntica à da Figura 54;
Aceda ao Mechanism Joint Jog do robô, varie as juntas 1, 4 e 6 e
confirme que a configuração é a esperada. Para mais informações
sobre estes parâmetros, consulte a ajuda emRAPID Instructions,
Functions and Data types  Data types  confdata – Robot Figura 54 – Exemplo de
configuração
configuration data.
Conclui-se que a escolha das configurações a utilizar pode não ser trivial, dado que podem existir
duas posturas consecutivas com configurações diferentes, as quais podem ser incompatíveis, em
particular se o robô estiver a realizar um movimento linear entre ambas. Uma forma de minimizar
estes problemas é utilizar a configuração automática. Essa opção está disponível em Path Tools 
Modify  Auto Configuration e será descrita na secção seguinte. Note, no entanto, que mesmo
utilizando a configuração automática poderá não ser possível gerar um caminho entre todos os
pontos definidos. Note também que o facto de o robô não conseguir realizar a configuração
automática, não significa que não seja possível realizar o caminho escolhendo outras configurações.
Esses casos poderão ser resolvidos alterando as configurações manualmente ou alterando as
posturas, quer individualmente, quer alterando o objeto (e respetivo Workobject)
movendo/orientando este para um local mais acessível por parte do manipulador ou que não
implique alteração de configurações.
6 Criar Caminhos ao Longo das Arestas de um Objeto

Criar caminhos com base nos vértices de um objeto permite realizar tarefas com base na geometria
destes. No entanto, para objetos com geometrias mais complexas, existem alternativas mais
práticas de criar esses caminhos. Os passos seguintes ilustram esse processo:
1. Abra o ambiente final criado na alínea anterior, caso o tenha fechado, e esconda os
caminhos previamente criados, Path_10 e Path_20 (estes não serão utilizados nos passos
que se seguem), bem como o cubo e a pirâmide. Para tal clique nos mesmos com o botão
direito do rato e desative a opçãoView  Visible, resultando no ambiente ilustrado naFigura
55;
2. Modifique a vista de forma ficar idêntica à da Figura 55 e ative a opção Surface Selection,
como mostra a Figura 56;
Figura 55 – Adição de um objeto. Figura 56 – Seleção de superfícies.

3. Selecione a opção Modeling  Border around Surface;
4. Selecione a superfície da peça, tal como ilustra aFigura 57, e clique em Create seguido de
Close, criando assim uma curva ao longo do bordo da superfície selecionada, como ilustra
a Figura 58;
5. Ative a opção Curve Selection (ver a Figura 59) e selecione a curva criada no ponto anterior;

Figura 57 – Modo de seleção de superfície. Figura 58 – Curva criada ao longo da aresta.
Figura 59 – Seleção da fronteira de uma superfície Figura 60 – Geração de um caminho ao longo do

bordo de uma superfície.
6. Com a curva selecionada clique agora em Home  Path  AutoPath, resultando no
separador exibido na Figura 60. Faça as seguintes alterações:

a. Para o campo Reference Surface selecione a superfície superior da peça (a mesma
utilizada no ponto 4);
b. Altere o campo Tolerance (desvio máximo permitido do caminho relativamente à
curva) para 1 mm, verificando que o número de pontos gerados aumenta com a
diminuição deste valor;
c. Altere o campo Approximation Parameters para Circular (para permitir movimentos
circulares no caminho gerado e não apenas movimentos lineares). Verifique que ao
alterar esta opção diminui consideravelmente o número de pontos nas zonas curvas
do caminho;
Figura 61 – Caminho gerado ao longo do bordo da Figura 62 – Visualização da ferramenta numa

superfície. postura.

d. Clique em Create resultando em 10 posturas criadas e um caminho, tal como mostra
a Figura 61;
7. Selecione a primeira postura guardada e ative a opçãoTarget Tools Modify  View Tool
at Target  MyTool, de modo a vizualisar a postura da ferramenta(Figura 62);
8. Selecione todas as posturas guardadas, visualizando assim a ferramenta em todas as
posturas geradas (Figura 63);
9. Para permitir que o robô realize o caminho pretendido de forma suave e minimizando
problemas na realização da trajetória devemos garantir uma maior compatibilidade entre
posturas consecutivas. Um primeiro passo é a reorientação das mesmas. Para tal selecione
a primeira postura e clique emTarget Tools Modify  Rotate, surgindo o separador visível
na Figura 64;
Figura 63 – Visualização da ferramenta em todas Figura 64 – Rotação da postura.

as posturas guardadas.
10. Selecione o eixo dos Zs como eixo de rotação e aplique uma rotação de -90º no referencial
11. local, resultando

Selecione na postura
agora todas indicadaexceto
as posturas naFigura 65;
a primeira e clique emTarget Tools  Modify 
Align Target Orientation surgindo o separador visível na Figura 66;
Figura 65 – Postura após rotação. Figura 66 – Alinhar a orientação de um conjunto de

posturas.
12. Selecione para o campo Reference a primeira postura e escolha alinhar todas as posturas
com a primeira segundo o eixo do X (Align Axis) mantendo o eixo dos Z inalterado L( ock
Axis). Clique em Apply e selecione novamente todas as posturas para confirmar que obteve
o resultado ilustrado naFigura 67;

Figura 67 – Posturas após alinhamento de Figura 68 – Sequência de movimentos para
orientação. executar o caminho.
13. Como pode confirmar observando a lista de posturas, estas apresentam um sinal de aviso.
Se colocar (sem clicar) o rato por cima da postura poderá constatar que o aviso se deve ao
facto de ainda não ter sido escolhida qualquer configuração para as várias posturas. Para
faze-lo rapidamente e de forma automática, selecione o caminho criado e clique emPath
Tools  Modify  Auto Configuration. Ser-lhe-á solicitado para escolher a configuração da
primeira postura, devendo tipicamente escolher aquela que lhe pareça mais próxima de
todas as possíveis configurações ao longo do caminho, neste caso (0,-1,0,0). No final poderá
confirmar na janela de mensagens O ( utput) que a configuração automática do caminho foi
bem-sucedida;
14. No separador Paths&Targets pode visualizar a sequência de instruções de código RAPID
que permite executar o caminho gerado (ver Figura 68), nomeadamente instruções MoveL
para movimentos lineares e MoveC para movimentos circulares, as quais serão estudadas
em mais detalhe posteriormente;
15. Para terminar confirme que o robô consegue executar o caminho com sucesso. Para tal
deverá selecionar o caminho e clicar emPath Tools  Modify  Move Along Path. Deverá
ver o robô a executar o caminho gerado (note que poderá demorar alguns segundos até que
o robô inicie a execução do caminho);
16. Experimente ainda alterar a aproximação para z0 e/ou fine, e repetir a execução do caminho
para observar mais uma vez o impacto dessa opção.
7 Alteração da Localização do Espaço de Trabalho Após a Criação

das Posturas e/ou do Caminho
Pode ocorrer que seja necessário alterar o local onde uma dada peça é operada pelo robô, já depois
de ter gerado todos os caminhos com base na geometria da peça. Um exemplo típico dessa
necessidade, é quando o projeto é feito no ambiente de simulação, mas depois na prática existem
algumas variações face ao projeto. Neste caso a utilização de umWorkobject garante que se pode
proceder a essa alteração com um esforço mínimo. Os passos seguintes ilustram essa situação
para o ambiente de trabalho desenvolvido na secção anterior:
1. Comece por movimentar a peça para o canto da mesa, resultando no ambiente de trabalho
ilustrado na Figura 69. Como pode observar, a movimentação da peça não teve qualquer
impacto no caminho previamente gerado, pelo que é necessário corrigir o caminho;

Figura 69 – Alteração da posição do objeto de Figura 70 – Seleção do Workobject.
trabalho.
2. Dado que o caminho foi gerado tendo por base oWorkobject definido previamente, para que
o caminho fique correto basta atualizar oWorkobject. Para tal selecione o Workobject
utilizado para definir as posturas (verFigura 70) e clique em Workobject Tools  Modify 
Modify Workobject. Na janela de definições que surge, à semelhança do que aconteceu
aquando da criação deste, altere as propriedades doUser Frame procedendo da mesma
forma de quando criou oWorkobject (ver Figura 43). Clique em Apply, sendo todo o caminho
corrigido e de novo coincidente com o bordo utilizado anteriormente, tal como mostra a
Figura 71;
3. Observando a lista de posturas e caminhos criados (verFigura 72) conclui-se que se perdeu
a configuração efetuada anteriormente. Tal é de esperar, dado que as posturas foram todas
alteradas, pelo que é necessário reconfigurar todas as posturas;
4. Para reconfigurar o caminho execute novamente a autoconfiguração. Execute no final a
função Move Along Path para o caminho gerado de modo a confirmar a correta configuração
do mesmo;
5. Guarde o trabalho.
Figura 71 – Alteração do Workobject. Figura 72 – Caminho desconfigurado.
Nesta secção
associados teve
aos oportunidade
objetos de confirmar
ou espaços as Caso
de trabalho. vantagens associadas
não tivesse à utilização
utilizado de
Workobjects
um Workobject nesta
situação, teria que ter criado novamente todos os pontos um a um e gerado o caminho novamente,
o que seria um processo mais moroso face à atualização doWorkobject, mesmo num caso simples
como este.
8 Adicionar Sinais ao Robô

A interação entre robôs e/ou autómatos é normalmente baseada em módulos bastante conhecidos

e utilizados (DeviceNet, EtherCat, Ethernet/IP, etc.). No entanto a interação com os sensores e
atuadores é tipicamente bastante mais simples, funcionando através de sinais analógicos e/ou
digitais (naturalmente que também é possível que a interação com os autómatos seja feita com
recurso a entradas/saídas digitais e/ou analógicas). Qualquer manipulador industrial pode estar
equipado com um conjunto de entradas/saídas digitais e/ou analógicas. Os sinais são tipicamente
utilizados para medir valores de sensores e acionar atuadores (ou pré-acionadores), à semelhança
do que acontece com os autómatos. A leitura dos sensores permite tomar decisões, alterando assim
os atuadores que são acionados. Os sinais podem ainda ser utilizados para coordenação simples
entre múltiplos robôs, embora haja outras formas mais avançadas de o fazer, como é o caso da
opção MultiMove da ABB. No entanto este tipo de abordagem mais avançada não está disponível
para coordenar robôs de diferentes fabricantes.
Esta secção descreve os passos necessários para adicionar sinais a um robô. aTl poderia facilmente
expandir-se para qualquer outro tipo de utilização de sinais digitais. Note, no entanto, que este
exemplo em particular não tem por base nenhum caso específico, mas somente exemplificar a
utilização de sinais.
Considere-se um robô que apenas arranca quando uma determinada entrada ficar com o nível alto,
e que ativa uma saída quando terminar o movimento. Assim, é necessário adicionar esses sinais
ao robô, dado que por omissão este não vem configurado com qualquer saída ou entrada no
ambiente de simulação.
1. Abra o ambiente de trabalho criado anteriormente, caso o tenha fechado, selecione o robô
no separador Layout e clique na opção Controller  Configuration Editor  I/O;
2. É necessário adicionar os sinais a utilizar no robô, neste caso a saída digital
doOperationEnded e a entrada digital diStartOperation. Para adicionar um sinal, com o
painel de configuração do sistema I/O, clique no tipo Signal com o botão direito do rato e
selecione a opção New Signal…. Atribua um nome ao sinal (Name), escolha o tipo de sinal
pretendido (Type of Signal), deixe a opção Assigned to Device livre (dado que é um sinal do
controlador virtual), atribua uma descrição em Signal Identification Label e altere o Access
Level para All. A alteração do tipo de acesso é sobretudo relevante para as saídas, pois caso
contrário não poderíamos forçar o valor das saídas manualmente a partir do simulador. Na
Figura 74 encontra um exemplo para o sinal doOperationEnded (para mais informações
sobre os vários parâmetros consulteRobotStudio Help  Controller Tab  Configuration
Editor);
Figura 73 – Adicionar um sinal. Figura 74 – Configuração de um sinal virtual.

3. Na janela Configuration – I/O System selecione o tipo Signal e confirme que os sinais estão
corretamente adicionados. Caso não estejam, poderá clicar com o botão direito do rato,
selecionar a opçãoEdit Signal(s)… e proceder às alterações pretendidas. Nesta visualização

pode também adicionar novos sinais através do botão direito do rato e da opçãoNew
Signal…;
Figura 75 – Sinais adicionados.

4. Feche o separador de configuração das entradas/saídas, clique com o botão direito do rato
no robô (no separador Controller), escolha a opção Restart  Restart (Warmstart) e clique
em OK para reiniciar o controlador e aplicar as alterações efetuadas;
NOTA: No menu Restart tem várias opções, as quais são detalhadas emRobotStudio Help 
Controller tab  Features for both virtual and controllers. Tipicamente deverá utilizar a opçãoRestart
(Warmstart), apenas disponível para controladores virtuais, pois permite reiniciar o controlador
carregando novas configurações do mesmo. Caso tenha algum problema com o controlador, esta é
a opção a usar.
5. Faça uma cópia de segurança dos parâmetros do robô através da opçãoController  Save
Parameters (opção junto a Configuration Editor). Caso queira usar a configuração criada
num outro robô ou simulação poderá carregar estes parâmetros, cujos ficheiros têm a
extensão *.cfg;
9 Programação Gráfica do Robô e Simulação

Para melhor exemplificar a utilização de sinais, irá
utilizar-se dois robôs coordenados por
entradas/saídas. De modo a acelerar o
desenvolvimento deste tutorial, está disponível no
Moodle uma estação de trabalho do RobotStudio já
preparada. Relativamente ao que se fez acima, foi
adicionado um robô semelhante com as mesmas
entradas e saídas, bem como os movimentos
necessários para cada robô, semelhantes aos
movimentos criados anteriormente.
Colocados todos os elementos no ambiente de Figura 76 – Ambiente fornecido com dois
trabalho, interessa agora programar os robôs para robôs.
executar a tarefa em questão. A programação do
robô
Nestaesecção
a configuração da simulação
descreve-se pode ser puramente
o método puramente gráfica, na
gráfico, enquanto ousecção
pode incluir edição
seguinte de código.
se aborda a
utilização/edição direta de código.
1. Abra o ambiente de trabalho indicado acima;
NOTA: No RobotStudio o separador Paths&Targets do ambiente de trabalho diz respeito à edição
do ambiente mas não necessariamente à informação que está armazenada no controlador do robô.
Assim, para que esta informação esteja disponível no controlador virtual do robô, é necessário
carregar essa informação para o controlador. Caso se utilizasse um robô real teria que se proceder
da mesma forma, mas nesse caso a sincronização seria feita para o controlador real em vez de ser
feita para o controlador virtual.
2. No separador Paths&Targets clique com o botão direito do rato no controlador
IRB1600_6kg_1.2m_1 seguido de Synchronize to RAPID…, surgindo a janela da Figura 77.
Mantenha todos os módulos selecionados para que sejam todos sincronizados e clique em
OK. Repita a mesma operação para o controladorIRB1600_6kg_1.2m;
Figura 77 – Sincronização para o Controlador Figura 78 – Configuração da simulação.

Virtual.
NOTA: A sincronização tanto pode ser feita do ambiente de trabalho para o controlador virtual, como
pode ser feita também no sentido contrário. Em qualquer dos casos pode escolher sincronizar
apenas uma parte da informação. Aliás, é aconselhável que escolha apenas a informação
indispensável a sincronizar (neste caso foi a primeira sincronização, daí terem sido escolhidos todos
os componentes). Deverá ter cuidado com esta operação, em particular quando editar o código
diretamente, pois a mesma substitui os programas no controlador virtual ou no ambiente de trabalho,
dependendo do sentido da sincronização.
3. Concluída a sincronização com o controlador virtual, clique em Simulation  Simulation
Setup, surgindo a janela da Figura 78;
4. Selecione a tarefa T_ROB1 para o controlador IRB1600_6kg_1.2m e, na opção Entry point,
escolha o caminho Path_Part_surf, tal como mostra a Figura 79. Repita o procedimento para
a tarefa T_ROB1 do controlador IRB1600_6kg_1.2m_1. Com estas configurações está a
definir qual a função com que cada controlador deve arrancar, isto é, qual a função de base
que este irá correr;
Figura 79 – Especificação do caminho a executar. Figura 80 – Configuração do modo de simulação.

5. Ainda nesta janela, selecione o controlador IRB1600_6kg_1.2m_1 (nesta altura as opções
Continuous e Single Cycle ficam disponíveis, tal como mostra a Figura 80). Se selecionar
Continuous os caminhos especificados serão realizados de forma cíclica, continuamente.
Se selecionar Single Cycle os caminhos serão executados apenas uma vez. Mantenha
selecionada a opção Single Cycle em cada controlador e clique emClose;

6. Clique em Simulation  Play e confirme que os robôs executam os caminhos especificados;
Neste momento tem uma simulação completa a correr, com ambos os robôs a executar caminhos
semelhantes, sendo que o IRB1600_6kg_1.2m_1 executa os movimentos a metade da velocidade
do robô IRB1600_6kg_1.2m. No entanto, como pode observar, não se verifica qualquer
coordenação entre os robôs, havendo mesmo colisão entre estes. Para tal é necessário incluir na
programação do robô instruções para ler as suas entradas e atuar nas suas saídas. Os passos
seguintes irão garantir que um robô não realiza a aproximação à peça enquanto o outro robô não
terminar a sua operação.
7. Com a opção IRB_1600_6kg_1.2m T_ROB1selecionada em Home  Settings, clique com
o botão direito do rato na primeira instrução do caminho Path_Part_surf do robô
IRB1600_6kg_1.2m e escolha a opção Insert Action Instruction…. No separador Create
Action Instruction utilize as opções indicadas naFigura 81 e clique em Create. Desta forma
adiciona a instrução WaitDI da linguagem RAPID, a qual permite esperar que uma saída
digital atinja um determinado valor. Neste caso especificou-se a entradadiStartOperation
com o valor 1;
Figura 81 – Instrução WaitDI. Figura 82 – Instrução SetDO.

8. Repita o processo para adicionar uma instrução a seguir à última instrução do caminho com
os dados indicados na Figura 82. A instrução SetDO com o parâmetro doOperationEnded e
valor 1 será utilizada para sinalizar que a operação terminou;
9. Repita o processo para adicionar no final do caminho, a instruçãoWaitDI com o valor 0 para
a entrada diStartOperation e, após a instrução WaitDI diStartOperation 1, a instrução SetDO
com a saída doOperationEnded e o valor 0. No final deverá ter um caminho idêntico ao
ilustrado na Figura 83;
10. Repita o processo para o segundo robô, resultando no caminho ilustrado naFigura 84;
11. Dado que foram efetuadas alterações ao caminho é necessário voltar a sincronizar este com
o controlador virtual. Para tal, para o controladorIRB1600_6kg_1.2m, clique com o botão
direito do rato em cima do caminho Path_Part_surf e escolha a opção Synchronize to
RAPID…, surgindo a janela da Figura 85. Clique OK para terminar a sincronização. Note
que ao iniciar a sincronização clicando diretamente num caminho específico,
automaticamente é selecionado apenas esse caminho para sincronização;

Figura 83 – Caminho final do Figura 84 – Caminho final do
IRB1600_6kg_1.2m. IRB1600_6kg_1.2m_1.
Figura 85 – Sincronização do caminhoPath_Part_surf.

12. Repita o procedimento de sincronização para oIRB1600_6kg_1.2m_1;
13. Corra novamente a simulação clicando em Simulation  Play e Confirme que nada
acontece. Nada acontece porque ambos os robôs estão à espera que uma entrada seja
ativada, o que não está a ser feito neste momento. Clique emSimulation  Stop para parar
a simulação;
14. Clique em Simulation  I/O Simulator para aceder ao painel de entradas/saídas do
controlador, tal como mostra aFigura 86;
Figura 86 – Simulador de entradas/saídas. Figura 87 – Listas de sinais do utilizador.

15. Para o sistema IRB1600_6kg_1.2m escolha a opção User List em Filter e clique em Edit
Lists…, surgindo uma janela idêntica à daFigura 87. Clique em New List, atribua um nome
(por exemplo, User) e adicione os sinais diStartOperation e doOperationEnded, tal como
mostra a Figura 88. Clique em OK e repita o procedimento para o sistema
IRB1600_6kg_1.2m_1. No final deverá visualizar à direta os sinais adicionados, tal mostra
a Figura 89;
Figura 88 – Lista final de sinais do utilizador. Figura 89 – Simulador de E/S com lista de utilizador.
16. Inicie novamente a simulação (Simulation  Play) e force a entrada diStartOperation a 1
para o sistema IRB_1600_6kg_1.2m. Verifique que o robô executa a trajetória e ativa a saída
diOperationEnded no final. Repita as operações para o outro robô e verifique o mesmo
comportamento;
17. Embora já seja possível controlar a operação de ambos os robôs, estes não executam ainda
as operações de forma coordenada, pois falta ainda interligar os robôs. Clique em
Simulation
 Station Logic, resultando na janela da Figura 90. Esta janela permite definir a lógica de
funcionamento de alto nível da estação de trabalho, incluindo ligações entre controladores
e outros dispositivos;
18. Neste caso apenas existem dois controladores/robôs em termos de equipamento ativo, o
que pode ser confirmado clicando no separadorDesign, como mostra a Figura 91. Para
interligar os mesmos, aceda ao separadorSignals and Connections e clique em Add I/O
Connections. Na janela que aparece escolha as opções como mostra a Figura 92 e clique
em OK;
Figura 90 – Lógica da estação. Figura 91 – Diagrama de blocos da estação.

19. Repita a operação, mas agora para adicionar a ligação entre a saídadoOperationEnded do
controlador IRB1600_6kg_1.2m_1 à entrada diStartOperation do controlador
IRB1600_6kg_1.2m;
20. Clique no separador Design para verificar as ligações adicionadas (poderá arrastar os blocos
para ter uma melhor visualização das ligações). Tipicamente as ligações também podem ser
adicionadas a partir deste separador, simplesmente arrastando saídas para entradas;

Figura 92 – Adição de uma ligação. Figura 93 – Diagrama de blocos da estação.
21. Se arrancar a simulação após estas ligações feitas, os robôs irão continuar parados, pois
embora as ligações estejam feitas, ambos irão ficar à espera de um sinal positivo na sua
entrada para poder iniciar o movimento. No entanto basta que ative (através do I/O
Simulator) a entrada de um dos robôs para automaticamente o processo se desenrolar
infinitamente;
Mesmo conseguindo ter solucionado o problema, é ainda necessário o utilizador simular uma
entrada, o que não é desejável. Para evitar esse problema poder-
se-ia adicionar no ambiente gráfico
a ativação da saída de um dos robôs no arranque, provocando o início do movimento do outro robô.
No entanto essa não é a abordagem aconselhada, sendo preferível editar diretamente o código
RAPID, como mostra a secção seguinte.
10 Utilização Direta de Código RAPID

Neste momento é já capaz de criar uma simulação completa com vários robôs/controladores, mas
considerando um único fio de execução, pré-programado pelo utilizador graficamente. Como será
de esperar, nem sempre é desejável ou sequer possível que assim seja, sendo útil em determinadas
situações ter sistemas com execução mais complexas. Estas sequências de operação,
implementados diretamente em código, podem ser baseados em variáveis internas ou nos valores
das entradas/saídas do robô. No caso particular dos robôs da ABB, a linguagem utilizada denomina-
se de linguagem RAPID. No menu de ajuda doRobotStudio encontra uma ligação para RAPID 
RAPID Instructions, Functions and Data types, onde encontra uma descrição de todas as funções
que podem ser utilizadas em linguagem RAPID.
Nesta secção terá oportunidade de interagir diretamente com o código RAPID e ficar a conhecer as
principais funções deste. Para informação mais detalhada dessas e outras funções deverá consultar
a ajuda RAPID indicada acima.
Com os próximos passos pretende-se perceber como é feito o acesso ao código RAPID. O código
será ainda alterado para que o robô esteja a operar continuamente, sem que para tal seja necessário
alterar a configuração da simulação ou forçar manualmente uma entrada do robô.
1. Abra o ambiente criado na secção anterior, caso não esteja aberto;
2. Vá a Simulation  Simulation Setup e confirme que a opção Single Cycle está selecionada
para ambos os controladores;
3. No I/O Simulator verifique que todas as entradas e saídas que foram adicionadas a ambos
os controladores estão a 0.
4. Arranque a simulação, situação em que os robôs deverão ficar parados à espera da entrada
digital a 1, como mostra a Figura 94;
5. Clique no menu RAPID, surgindo o ambiente ilustrado na Figura 94;
6. Selecione o menu Controller e faça duplo clique em IRB1600_6kg_1.2m_1  RAPID 
T_ROB1  Module1, surgindo o programa em código RAPID associado ao móduloModule1
do controlador (ver Figura 95);
Figura 94 – Acesso ao menu RAPID. Figura 95 – Código RAPID.

7. Observando o novo separadorT_ROB1/Module1, pode confirmar que já existe um programa
no controlador. Esse código existe no controlador devido à sincronização efetuada
anteriormente. Todos os caminhos que foram selecionados, bem como as posturas utilizadas
por esses caminhos, foram adicionados ao código RAPID. Pode ainda verificar a instrução
de código atualmente a ser executada, marcada por uma seta amarela, e a instrução atual
de movimento (entretanto já concluída), marcada por um pequeno robô. Como se pode
confirmar, o robô está à espera da ativação duma entrada. Verifique que o mesmo se passa
para o outro robô;
Um programa em RAPID pode ser separado em vários módulos, correspondendo cada módulo a
um ficheiro, tal como acontece, por exemplo, em linguagem C. Aqui usar-se-á sempre apenas um
módulo.
O módulo gerado automaticamente pelo RobotStudio com base nas posturas e caminhos criados
tem tipicamente atribuído o nomeModule1. A linha de códigoMODULE Module1 no início do ficheiro
identifica isso mesmo, isto é, o início do módulo denominadoModule1. Pode igualmente verificar
que o módulo é terminado com a instrução ENDMODULE.
Imediatamente após o início do módulo encontra a definição das posturas definidas no ambiente
gráfico do RobotStudio, sendo estas constantes ( CONST) do tipo robtarget. Estes valores não
deverão ser editados diretamente em código.
De seguida encontra procedimentos (funções), cujo início e fim estão identificados pelas instruções
PROC função() e ENDPROC, respetivamente. Estes procedimentos são o equivalente às funções
em linguagem C, podendo também ter argumentos. A funçãomain, tal como em linguagem C,
corresponde à função principal, sendo esta a função chamada quando o código arranca. Quando
esta função
pois não terminar
foi ainda o programa
definida, termina
dado que a sua aexecução.
foi definida Neste momento
função Path_Part_surf esta
como função
sendo não existe,
a função de
arranque (caso nada seja feito, por omissão a funçãomain é a função principal, de arranque).
8. No código gerado pode confirmar que existem uma função,Path_Part_surf(), a qual
corresponde exatamente aos caminhos criados anteriormente no ambiente gráfico;
9. Para resolver o problema de ser necessário ativar uma entrada para o sistema arrancar,
basta agora adicionar essa instrução diretamente no código RAPID. De facto, para ter
maiores garantias no arranque, devem sempre confirmar o estado inicial do sistema e

garantir as condições iniciais, tal como em automação. Assim, adicione a funçãomain() de
modo a que fique como mostra a Figura 96 e a Figura 97, para os robôs IRB1600_6kg_1.2m
e IRB1600_6kg_1.2m_1, respetivamente. Note que ao começar a escrever uma dada
instrução de código, automaticamente lhe é sugerido como terminar a mesma. Este auxílio
à programação é tipo de qualquer editor de código recente, sendo bastante útil para evitar
erros. As instruções iniciadas com “!” são comentários e deverão ser incluídos no código
sempre que necessários. Deverá também utiliza-los na documentação das funções. De
salientar ainda que o ciclo WHILE TRUE DO, que termina na instrução ENDWHILE, serve
para ter um ciclo de funcionamento infinito, e que as várias variáveis utilizadas foram
definidas no início do programa. Pode, no entanto, definir variáveis em cada função, tal como
acontece noutras linguagens de programação. As funções serão explicadas em mais
pormenor mais à frente neste tutorial.
PROC main()
! Ir para a postura base
MoveJ Home,v1000,z50,MyTool\WObj:=wobj0;
! Garantir condições iniciais
SetDO doOperationEnded,0;
WaitDI diStartOperation,0;
! Entrar no ciclo infinito
WHILE TRUE DO
Path_Part_surf;
ENDWHILE
ENDPROC
Figura 96 – Função main() para o robô IRB1600_6kg_1.2m.

PROC main()
! Ir para a postura base
MoveJ Home,v1000,z50,MyTool\WObj:=wobj0;
! Garantir condições iniciais
WaitDI diStartOperation,0;
! Dar ordem de arranque ao outro robô
! Entrar no ciclo infinito
WHILE TRUE DO
Path_Part_surf;
ENDWHILE
ENDPROC
Figura 97 – Função main()para o robô IRB1600_6kg_1.2m_1.

10. Apague a instrução inicial para movimentar para a postura Home da função Path_Part_surf
em ambos os controladores, dado que essa instrução foi incluída na funçãomain;
11. Neste momento efetuou as alterações propostas, mas as mesmas não foram ainda
aplicadas ao controlador. Para tal deverá clicar em RAPID  Apply (All Changes),
atualizando assim o código em ambos os controladores;
12. Aceda a Simulation  Simulation Setup e altere em T_ROB1, para ambos os controladores,
a opção Entry point para main. Desta forma os controladores volta ao funcionamento padrão,
isto é, em que a função main é a função principal, com a qual o controlador inicia. Clique em
Close;
13. Corra novamente a simulação clicando emSimulation Play e verifique que corre como
esperado. Confirme que os robôs executam os caminhos ao longo das arestas, mas um de
cada vez;
As alterações agora efetuadas ocorreram diretamente no código RAPID e foram aplicadas ao
controlador, no entanto não estão disponíveis ainda no ambiente de trabalho gráfico.

14. Aceda ao menu Home e abra o separador Paths&Targets. Verificando os caminhos, pode
confirmar que não contêm as alterações efetuadas diretamente no RAPID. Para sincronizar
a informação no ambiente gráfico com a informação no controlador (virtual), escolha um dos
controladores e aceda a RAPID  Synchronize  Synchronize to Station…. Na janela que
aparece escolha apenas o que foi modificado, isto é, o caminho que alterou e a função main,
tal como mostra a Figura 99, e clique em OK. Repita o processo para o outro controlador;
Figura 99 – Aplicação das alterações introduzidas no código.

15. Aceda novamente ao separador Paths&Targets do
menu Home e confirme que os caminhos estão
coerentes com a informação submetida diretamente
em código RAPID (ver Figura 98);
Como pode constatar pelo exemplo anterior, no caso
particular da função main(), a informação disponibilizada no Figura 98 – Resultado da
sincronização.
ambiente gráfico (ver Figura 98) não corresponde
exatamente à informação introduzida anteriormente no código RAPID (verFigura 96) em termos
visuais. Tal deve-se ao facto de no ambiente gráfico apenas poder incluir instruções de movimento
e ações, não podendo incluir instruções como declaração de variáveis ou lógica de programação
(ciclos, testes de valor, etc.). Por esta razão é importante que apenas use o ambiente gráfico para
criar posturas e caminhos, deixando o resto da programação para o código RAPID, tendo atenção
à informação que sincroniza entre ambos.
A conjugação da criação de caminhos no ambiente gráfico, com a edição direta do código RAPID,
permite criar simulações mais complexas, aliando uma fácil e prática criação de caminhos com a
utilização de um conjunto vasto de instruções disponibilizadas pela linguagem RAPID, à
semelhança de uma outra qualquer linguagem de programação (por exemplo, C). É assim possível
criar execuções alternativas com base em, por exemplo, informação de sensores ou ordens
externas.
11
Principais
Tal como InstruçõesemRAPID
indicado anteriormente, RobotStudio Help  RAPID Instructions, Functions and Data
types encontra a descrição detalhada de todas as funções RAPID existentes. EmRobotStudio Help
 Additional Resources  RAPID Overview encontra uma introdução ao RAPID. Nesta secção
procura-se documentar as principais instruções, devendo consultar os documentos acima para mais
detalhes.

11.1 Variáveis e Constantes
A linguagem RAPID inclui os seguintes quatro tipos de dados fundamentais:
num – tipo de dado numérico, inteiro ou decimal;
dnum – tipo de dado numérico, inteiro ou decimal, com o dobro da precisão de
num;
string – cadeia de carateres (texto);
bool – tipo booleano, podendo ser FALSE ou TRUE
EXEMPLO: Declarar variáveis do tipo num e atribuir valores

VAR num length;
VAR dnum pi;
VAR string name;
VAR bool finished
length := 10;
pi := 3.141592653589793;
name := "John"
finished := TRUE;
11.1.1 Variáveis persistentes

A linguagem RAPID permite criar variáveis persistentes. Estas variáveis mantêm o seu valor mesmo
após terminar e reiniciar o programa. Estas devem ter um valor atribuído inicialmente.
EXEMPLO: Declarar uma variável persistente

PERS num nbr := 1;
11.1.2 Constantes
Constantes são variáveis cujo valor é atribuído na declaração e não pode ser alterado
posteriormente.
EXEMPLO: Declaração de constantes

CONST num gravity := 9.81;
CONST string greating := "Hello"
11.1.3 Operadores
Tal como em C, estão disponíveis operadores numéricos e relacionais. Os operadores numéricos
básicos são os mesmos da linguagem C, isto é:
+: adição;
-: subtração;
*: multiplicação;
/: divisão.
Relativamente aos operadores relacionais, são em tudo semelhantes aos da linguagem C:
=: comparação de igualdade;
<: comparador menor;
>: comparador maior;
<=: comparador menor ou igual;
>=: comparador maior ou igual;
<>: comparador de não igualdade;
É também possível utilizar o operador “+” para concatenação de cadeias de caracteres

EXEMPLO: Concatenação de cadeias de caractéres
VAR string firstname := "John";
VAR string lastname := "Smith";
VAR string fullname;
fullname := firstname + " " + lastname;
A variável fullname contém no final o texto "John Smith".
11.2 Controlo de Fluxo

A linguagem RAPID inclui as principais instruções de controlado de fluxo, como é o caso das
instruções IF/ELSE, TEST e ciclos FOR e WHILE. Encontra abaixo alguns exemplos da aplicação
destas instruções.
EXEMPLO: Utilização da instrução IF/ELSE

VAR num time := 38.7;
IF time < 40 THEN
TPWrite "Part produced at fast rate";
ELSEIF time < 60 THEN
TPWrite "Part produced at average rate";
ELSE
TPWrite "Part produced at slow rate";
ENDIF
NOTA: A função TPWrite é utilizada para escrever texto na consola do robô.
EXEMPLO: Utilização de um ciclo FOR

FOR i FROM 1 TO 5 DO
TPWrite "Hello";
ENDFOR
EXEMPLO: Utilização de um ciclo WHILE

VAR num sum := 0;
VAR num i := 0;
WHILE sum <= 100 DO
i := i + 1;
sum := sum + i;
ENDWHILE
EXEMPLO: Utilização da instrução TEST

TEST reg1
CASE 1,2,3 :
routine1;
CASE 4 :
routine2;
DEFAULT :
TPWrite "Illegal choice";
ENDTEST
A instrução TEST é em tudo semelhante à instrução SWITCH em linguagem C.
11.3 Instruções de Movimento

Existem três principais instruções para movimentar o robô para uma determinada postura
previamente definida: MoveL, MoveJ e MoveC.
As instruções MoveL e MoveJ são utlizadas de forma semelhante mas têm implicações muito
diferentes. Enquanto a instruçãoMoveL implica um movimento ao longo da linha reta que une a

postura inicial e a postura final, a instruçãoMoveJ apenas garante que o robô irá atingir a postura
destino, não dando qualquer garantia do caminho executado para lá chegar.
Nos exemplos seguintes descreve-se a principal funcionalidade destas duas funções. Para uma
descrição completa da utilização destas duas funções, consulte a ajuda do RAPID mencionada
anteriormente.
EXEMPLO: Utilização das instruções MoveL e MoveJ

MoveL Target_10,v1000,z100,MyTool\WObj:=wobj0;
MoveJ Target_10,v1000,z100,MyTool\WObj:=wobj0;
Neste exemplo em concreto temos a movimentação para uma mesma postura utilizando um
movimento linear (MoveL) e um movimento de juntas (MoveJ). O significado destes argumentos é
o que se segue:
Target_10: primeiro argumento, corresponde à postura a atingir;
V1000: segundo argumento, corresponde à velocidade em mm/s, neste caso 1000 mm/s;
Z100: terceiro argumento, corresponde àzonedata, tal como explicado no final na Secção5,
estando relacionado com a aproximação à postura indicada;
MyTool: quarto argumento, indica qual a ferramenta a utilizar, isto é, no fundo indica qual o
referencial a utilizar para chegar à postura objetivo;
WObj:=wobj0: quinto argumento, opcional, corresponde ao Workobject utilizado;
A instrução MoveC é utilizada para realizar um movimento circular, sendo a sua utilização muito
semelhante à das instruções anteriores. A principal diferença é a inclusão de uma segunda postura.
Veja-se o exemplo que se segue.
EXEMPLO: Utilização das instruções MoveC

MoveC Target_90,Target_100,v100,fine,MyTool\WObj:=MyWorkobject;
Neste exemplo o robô parte da postura onde se encontrar e realiza uma trajetória circular que passa
pela postura Target_90 e termina na postura Target_100.
11.3.1 Movimento relativo

Na secção acima descreveram-se movimentos absolutos, mas é possível realizar movimentos
relativos quer à postura atual do robô, quer a posturas predefinidas. Um exemplo de aplicação útil
deste tipo de movimentos, é o caso da paletização. Basta criar a postura associada ao primeiro
ponto da palete, e todos os restantes podem ser descritos de forma automática relativamente a
esse, sem terem de ser criados previamente. As principais instruções na linguagem RAPID para
este tipo de movimentos são as instruções Offs e RelTool.
A instrução Offs permite criar uma postura relativamente a outra.
EXEMPLO: Utilização da instrução Offs

MoveL Offs(p2, 0, 0, 10), v1000, z50, tool1;
p3 := Offs (p1, 5, 10, 15);
Na primeira instrução utiliza-se a instruçãoOffs para movimentar o robô para uma postura 10 mm
acima em z relativamente à postura p2. Na segunda instrução é guardada na variávelp3 uma
postura definida relativamente à postura p1.
A instrução RelTool é semelhante à instruçãoOffs mas permite definir uma orientação além de um
deslocamento. Veja-se um exemplo.
EXEMPLO: Utilização da instrução Offs
MoveL RelTool (p1, 0, 0, 0 \Rx:=25 \Ry:=25 \Rz:=25), v100, fine, tool1;
Neste exemplo é solicitado ao robô para se mover parap1 com um deslocamento de 0 mm em X,

Y e Z, e com uma reorientação de 25º relativamente à orientação em torno de X, Y e Z. Note-se que
os parâmetros de definição da orientação são opcionais, razão pela qual estão escritos na forma
“\Rx:=”.
11.4 Entradas/Saídas (sinais)
As
ser principais
utilizadasinstruções para
diretamente emlerinstruções
e escreverrelacionais.
de sinais são SetDO e WaitDI. As entradas podem ainda
Veja-se os exemplos que se seguem.
EXEMPLO: Utilização da instrução SetDO

SetDO doMechanismControl,0;
Esta instrução atualiza o valor da saídadoMechanismControl para o valor 0. Note-se que é possível
incluir outros argumentos, como por exemplo um atraso. Consulte a documentação do RAPID para
mais informação.
EXEMPLO: Utilização da instrução WaitDI

WaitDI diDoorClosed,1;
Esta instrução bloqueia a execução do programa até que a entradadiDoorClosed tenha o valor 1.
É possível especificar um tempo máximo de espera (consulte a documentação do RAPID para mais
informação).
EXEMPLO: Teste de entradas
IF diDoorClosed = 1 THEN
MoveL p10, v1000, fine, tPen;
ENDIF
Neste caso só se a entrada diDoorClosed tiver o valor 1 é que a instrução de movimentação é

executada.
11.5 Procedimentos (Funções) com Argumentos

Tal como em C, é possível ter funções com argumentos. Veja o seguinte exemplo para perceber
como o fazer.
EXEMPLO: Procedimento com argumentos

PERS tooldata tPen:= ...
CONST robtarget p10:= ...
PROC main()
! Call the procedure draw_square
draw_square 100;
draw_square 200;
draw_square 300;
draw_square 400;
ENDPROC
PROC draw_square(num side_size)

VAR robtarget p20;
VAR robtarget p30;
VAR robtarget p40;
! p20 is set to p10 with an offset on the y value
p20 := Offs(p10, 0, side_size, 0);
p30 := Offs(p10, side_size, side_size, 0);
p40 := Offs(p10, side_size, 0, 0);
ENDPROC
11.6 Algumas Notas Finais
Todas as instruções devem terminar com ponto e vírgula (;). Existem um conjunto enorme de
funções, quer de movimento, quer para outros fins, as quais não foram descritas aqui. Estas
encontram-se descritas em detalhe na documentação do RAPID referida anteriormente. Note no
entanto que as funções definidas aqui deverão ser suficientes para a maioria das aplicações.
12 Gravação da Simulação em Vídeo

A gravação da simulação em formato vídeo é bastante acessível no RobotStudio e muito útil para
mostrar o trabalho desenvolvido. Para tal basta configurar a gravação através da opção Simulation
 Recorder Settings (ver Figura 100). As opções disponíveis para a gravação de vídeo dependem
dos CODECs instalados no sistema operativo. Tenha o cuidado de selecionar uma pasta para a
gravação do vídeo para a qual tenha permissões de escrita e espaço suficiente em disco. Sugere-
se, se possível,
gerando assim um que alterecom
ficheiro a extensão
uma taxaselecionada paraMP4
de compressão mais eelevada,
o CODEClogoutilizado para H.264,
mais pequeno.
Figura 100 – Configuração da gravação de vídeo.

Após configurada a gravação do vídeo, tem três opções para o modo como esta é feita, todas
acessíveis no menu Simulation:
Record Simulation – Quando ativada inicia automaticamente a gravação de vídeo da
próxima simulação (opção pretendida para a entrega do trabalho de avaliação);
Record Application – Inicia imediatamente a gravação de toda a janela do RobotStudio;
Record Graphics – Inicia imediatamente a gravação da célula de trabalho do RobotStudio;
A gravação pode ser terminada a qualquer instante através da opção Stop Recording ou terminando
a simulação, dependendo da opção escolhida anteriormente.
Por último, e independentemente da completa disponibilidade do docente e da documentação
fornecida, salienta-se novamente a importância de recorrer ao manual do RobotStudio e do RAPID
para esclarecimento, nomeadamente relativamente a funções RAPID (argumentos, tipo de dados,
etc.).

RobotStudio PT

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

RobotStudio PT

Enviado por

Direitos autorais:

Formatos disponíveis

INSTITUTO POLITÉCNICO DE LEIRIA

ESCOLA SUPERIOR DE TECNOLOGIA E GESTÃO

2 Introdução ................. ................. ................ ................. ................. ................ ................. ...........

3.11 Movimentar o Robô e Criar Caminhos ............................................................................................ 17

2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 1/45

paragem das linhas de produção durante o processo de desenvolvimento.

Figura 1 – Manipulador robótico ABB IRB2400 existente no Laboratório de Robótica.

3.1 Versão Utilizada

2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 3/45

3.2 Ambiente de Trabalho

Abra o RobotStudio, surgindo o ambiente de trabalho inicial ilustrado na Figura 2. De salientar o

Figura 2 – Ambiente inicial de trabalho do RobotStudio.

Figura 3 – Blocos disponíveis no ambiente de trabalho do RobotStudio (retirado de

2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 4/45

3.3 Abrir e Simular um Ambiente de Trabalho Exemplo

Figura 4 – Ficheiros Pack & Go.

3.3.1 Exemplo de soldadura

2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 6/45

3.3.2 Exemplo de uma Linha de Produção

Figura 6 – Exemplo de uma linha de produção de painéis solares.

3.3.3 Outros exemplos

Figura 7 – FlexLoader. Figura 8 – Exhaust Pipe.

2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 7/45

3.4.1 Criar um ambiente de trabalho com um robô e um controlador

particular do ambiente de simulação RobotStudio.

Figura 9 – Visualizar todo o ambiente de trabalho.

3.5 Sistemas de Coordenadas

World, Base, Task,

3.6 Espaço de Trabalho e Alcance do Robô

Figura 12 – Espaço de trabalho do manipulador Figura 13 – Espaço de trabalho do manipulador

3.7 Adicionar Ferramentas Existentes

2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 11/45

Figura 14 – Escolha de uma ferramenta. Figura 15 – Atribuição de uma ferramenta ao robô.

3.8 Adicionar Objetos Existentes

Figura 16 – Adição de um objeto ao Figura 17 – Movimento livre. Figura 18 – Mesa

4. Altere o aspeto do objeto através dos seguintes passos:

Figura 19 – Alteração do aspeto gráfico do Figura 20 – Aspeto gráfico final do objeto.

Figura 22 – Movimento de um objeto usando dois pontos.

Figura 23 – Objeto deslocado. Figura 24 – Postura final do objeto.

3.9 Criar e Importar Novos Objetos

Figura 25 – Criar um paralelepípedo. Figura 26 – Posições e dimensões na criação de

2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 15/45

Figura 27 – Estrutura de informação de objetos. Figura 28 – Conjunção de múltiplos objetos.

3.10 Modos de Visualização

2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 16/45

• Criar um caminho a realizar pelo robô.

denomina-se em inglês depath.

2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 17/45

5. Neste modo poderá movimentar o robô sem que ocorram

2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 18/45

Figura 40 – Caminho criado. Figura 41 – Caminho executado.

Figura 43 – Seleção dos pontos para criar um Workobject.

2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 21/45

5 Criar um Caminho com Base nos Vértices de um Objeto

2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 22/45

Figura 50 – Escolha da configuração.

2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 24/45

Tabela 1 – Dados de aproximação pré- Figura 53 – Execução de um caminho.

6 Criar Caminhos ao Longo das Arestas de um Objeto

Figura 55 – Adição de um objeto. Figura 56 – Seleção de superfícies.

2016/2017 – 2º Semestre, EEC, RVC Hugo Costelha e Carlos Simplício 26/45

Figura 59 – Seleção da fronteira de uma superfície Figura 60 – Geração de um caminho ao longo do

separador exibido na Figura 60. Faça as seguintes alterações:

Figura 61 – Caminho gerado ao longo do bordo da Figura 62 – Visualização da ferramenta numa