Você está na página 1de 251

Training KUKA Roboter GmbH

Programação do robô 2

KUKA System Software 8


Documento de treinamento

Programação

do robô 2

Data: 24.02.2015

Versão: P2KSS8_robotprogramming_2_(R2)_V4
Programação do robô 2

© Copyright 2015
KUKA Roboter GmbH
Zugspitzstraße 140
D-86165 Augsburg
Alemanha

Este documento ou excertos do mesmo não podem ser reproduzidos ou disponibilizados a terceiros
sem autorização expressa da KUKA Roboter GmbH.
Outras funções de comando não descritas nesta documentação poderão ser postas em prática. No
entanto, não está previsto qualquer tipo de reclamação quanto a estas funções em caso de nova re-
messa ou de serviço.
Verificamos que o conteúdo do prospecto é compatível com o software e com o hardware descrito.
Porém, não são de excluir exceções, de forma que não nos responsabilizamos pela total compatibi-
lidade. Os dados contidos neste prospecto serão verificados regulamente e as correções necessá-
rias serão incluídas na próxima edição.
Sob reserva de alterações técnicas sem influenciar na função.
Tradução da documentação original
KIM-PS5-DOC

Publicação: Pub COLLEGE P2KSS8 Roboterprogrammierung 2 (R2) (PDF-COL) pt


Estrutura do livro: P2KSS8 Roboterprogrammierung 2 (R2) V2.2
Versão: P2KSS8_robotprogramming_2_(R2)_V4

2 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


Índice

Índice
1 Programação com WorkVisual ................................................................... 7
1.1 Visão geral ................................................................................................................. 7
1.2 Gerenciar projeto com o WorkVisual ......................................................................... 7
1.2.1 Vinculação de um PC WorkVisual à unidade de comando .................................. 7
1.2.2 Visão geral da interface de operação WorkVisual ................................................ 8
1.2.3 Carregar projeto existente no WorkVisual ............................................................ 10
1.2.4 Gravar localmente o projeto WorkVisual .............................................................. 12
1.2.5 Modos WorkVisual ................................................................................................ 12
1.2.6 Estrutura de projeto WorkVisual (guia Arquivos) .................................................. 13
1.2.7 Comparar projetos com WorkVisual ..................................................................... 14
1.2.8 Transmitir o projeto à unidade de comando do robô (instalar) ............................. 18
1.2.9 Atribuir o projeto à unidade de comando do robô real .......................................... 28
1.2.10 Ativar o projeto na unidade de comando do robô ................................................. 32
1.3 Processar programas KRL com WorkVisual .............................................................. 35
1.3.1 Importar manuseio de arquivos ............................................................................ 35
1.3.2 Ativar Templates de catálogo ............................................................................... 39
1.3.3 Manuseio com o editor KRL ................................................................................. 41
1.4 Exercício: Editar um projeto ativo no WorkVisual ...................................................... 54

2 Programação estruturada ........................................................................... 57


2.1 Visão geral ................................................................................................................. 57
2.2 Objetivo de um método de programação padronizado .............................................. 57
2.3 Recursos auxiliares para a criação de programas de robô estruturados .................. 57
2.4 Como é elaborado um fluxograma do programa ....................................................... 62

3 Introdução no nível de perito ..................................................................... 65


3.1 Visão geral ................................................................................................................. 65
3.2 Usar nível de perito .................................................................................................... 65
3.3 Exercício: Medição de ferramentas e base ................................................................ 68
3.4 Exercício: Navigator perito loop sem fim ................................................................... 73

4 Variáveis e acordos ..................................................................................... 75


4.1 Visão geral ................................................................................................................. 75
4.2 Manutenção de dados no KRL .................................................................................. 75
4.3 Trabalhar com tipos de dados simples ...................................................................... 78
4.3.1 Declaração de variáveis ....................................................................................... 78
4.3.2 Inicialização de variáveis com simples tipos de dados ......................................... 80
4.3.3 Manipulação de valores de variáveis de tipos de dados simples com KRL ......... 82
4.4 Exibir variáveis ........................................................................................................... 85
4.5 Arrays / Campos com KRL ........................................................................................ 87
4.6 Exercício: Campos com tipos de dados simples e loop de contagem ....................... 91
4.7 Estruturas com KRL ................................................................................................... 93
4.8 Exercício: Criar estruturas com KRL .......................................................................... 96
4.9 O tipo de dados de enumeração ENUM .................................................................... 98
4.10 Exercício: Criar tipo de enumeração com KRL .......................................................... 99

5 Subprogramas e funções ........................................................................... 101


5.1 Visão geral ................................................................................................................. 101

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 3 / 251


Programação do robô 2

5.2 Trabalhar com subprogramas locais ......................................................................... 101


5.3 Trabalhar com subprogramas globais ....................................................................... 103
5.4 Transmitir parâmetros a subprogramas .................................................................... 105
5.5 Exercício: Subprogramas com transferência de parâmetros .................................... 109
5.6 Programação de funções .......................................................................................... 111
5.7 Trabalhar com funções padrão KUKA ....................................................................... 113

6 Programação de mensagens com KRL ..................................................... 115


6.1 Visão geral ................................................................................................................. 115
6.2 Generalidades sobre mensagens definidas pelo usuário .......................................... 115
6.3 Variáveis e estruturas em mensagens definidas pelo usuário .................................. 116
6.4 Funções em mensagens definidas pelo usuário ....................................................... 119
6.5 Trabalhar com uma mensagem de informação ........................................................ 121
6.6 Exercício: Programar mensagem de informação ...................................................... 123
6.7 Trabalhar com uma mensagem de estado ................................................................ 124
6.8 Exercício: Programar mensagem de estado ............................................................. 126
6.9 Trabalhando com uma mensagem de confirmação .................................................. 127
6.10 Exercício: Programar mensagens de confirmação .................................................... 129
6.11 Trabalhar com uma mensagem de espera ................................................................ 130
6.12 Exercício: Programar mensagens de espera ............................................................ 132
6.13 Variáveis e estruturas adicionais em diálogos .......................................................... 133
6.14 Funções em diálogos ................................................................................................ 133
6.15 Trabalhar com diálogos ............................................................................................. 135
6.16 Exercício: Programar diálogo .................................................................................... 139

7 Programação de movimento com KRL ...................................................... 141


7.1 Visão geral ................................................................................................................. 141
7.2 Programar movimentos individuais do SPLINE com KRL ......................................... 141
7.3 Movimento de passo individual com SPTP ............................................................... 141
7.4 Movimento de passo individual com SLIN e SCIRC ................................................. 143
7.5 Parâmetros de movimento ........................................................................................ 145
7.5.1 SCIRC: Comportamento de orientação – Exemplo ponto auxiliar ....................... 149
7.5.2 SCIRC: Comportamento de orientação – Exemplo ponto de destino .................. 151
7.5.3 Restrições em $CIRC_MODE .............................................................................. 152
7.6 Movimentos individuais do SPLINE: Variáveis de sistema para WITH ..................... 153
7.7 Programar movimentos relativos e absolutos com KRL ............................................ 154
7.8 Calcular ou manipular posições de robô ................................................................... 158
7.9 Modificar exatamente bits de Status e Turn .............................................................. 160
7.10 Exercício: Paletizar e despaletizar ............................................................................ 164
7.11 Programação de SPLINE Blocks ............................................................................... 167
7.11.1 Perfil de velocidade em movimentos do SPLINE ................................................. 168
7.11.2 Seleção de passo em movimentos do spline ....................................................... 171
7.11.3 Alterações nos spline blocks ................................................................................ 172
7.11.4 Substituir o movimento CP de aproximação por spline block .............................. 175
7.11.5 Transição SLIN-SPL-SLIN .................................................................................... 177
7.11.6 Programação PROG de SPLINE Blocks com KRL .............................................. 178
7.11.7 SPLINE Block: Variáveis de sistema com WITH .................................................. 181

8 Trabalho com variáveis de sistema ........................................................... 183

4 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


Índice

8.1 Visão geral ................................................................................................................. 183


8.2 Medição do tempo de ciclo com temporizador .......................................................... 183
8.3 Exercício: Medição de ciclo e otimização .................................................................. 185

9 Programação de Interrupt ........................................................................... 187


9.1 Visão geral ................................................................................................................. 187
9.2 Programação de rotinas de Interrupt ......................................................................... 187
9.3 Exercício: Trabalhar com Interrupts ........................................................................... 193
9.4 Frear o robô e cancelar os movimentos de deslocamento ........................................ 195
9.5 Exercício: Cancelar movimentos de deslocamento com Interrupts ........................... 199

10 Funções de comutação KRL ...................................................................... 201


10.1 Visão geral ................................................................................................................. 201
10.2 Programação das funções de comutação simples .................................................... 201
10.3 Programação do trigger em KRL ............................................................................... 205
10.4 Programar stop condicionado com KRL .................................................................... 208
10.5 Programar região de deslocamento constante com KRL .......................................... 211
10.6 Programar bloco de tempo do spline ......................................................................... 213

11 Interpretador Submit ................................................................................... 217


11.1 Visão geral ................................................................................................................. 217
11.2 Status do Interpretador Submit .................................................................................. 217

12 Trabalhar com sinais analógicos ............................................................... 221


12.1 Visão geral ................................................................................................................. 221
12.2 Programar entradas analógicas ................................................................................. 221
12.3 Programar saídas analógicas .................................................................................... 223
12.4 Exercício: Trabalhando com E/Ss analógicas ........................................................... 227

13 Anexo ............................................................................................................ 229


13.1 Programar movimentos com KRL .............................................................................. 229
13.2 Variáveis de sistema .................................................................................................. 237
13.2.1 $ACC .................................................................................................................... 237
13.2.2 $ACC_AXIS .......................................................................................................... 237
13.2.3 $ACC_EXTAX ...................................................................................................... 237
13.2.4 $APO .................................................................................................................... 238
13.2.5 $BASE .................................................................................................................. 239
13.2.6 $CIRC_TYPE ........................................................................................................ 239
13.2.7 Modo de economia de energia ($ECO_LEVEL) ................................................... 239
13.2.8 $GEAR_JERK ...................................................................................................... 240
13.2.9 $IPO_MODE ......................................................................................................... 241
13.2.10 $JERK ................................................................................................................... 241
13.2.11 $LOAD .................................................................................................................. 241
13.2.12 $ORI_TYPE .......................................................................................................... 243
13.2.13 $ROTSYS ............................................................................................................. 243
13.2.14 $SPL_ORI_JOINT_AUTO .................................................................................... 244
13.2.15 $TOOL .................................................................................................................. 244
13.2.16 $VEL ..................................................................................................................... 244
13.2.17 $VEL_AXIS ........................................................................................................... 245
13.2.18 $VEL_EXTAX ....................................................................................................... 245

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 5 / 251


Programação do robô 2

13.2.19 $CIRC_MODE ...................................................................................................... 245

Index ............................................................................................................. 249

6 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

1 Programação com WorkVisual

1.1 Visão geral

Nesta unidade de aprendizagem são repassados os seguintes conteú-


dos:
 Vinculação de um PC WorkVisual à unidade de comando
 Visão geral da interface de operação WorkVisual
 Carregar projetos existentes no WorkVisual
 Modos WorkVisual
 Estrutura de projeto WorkVisual (guia Arquivos)
 Comparar projetos com WorkVisual
 Transmitir o projeto para a unidade de comando do robô (instalar)
 Atribuir o projeto a uma unidade de comando do robô real
 Ativar o projeto na unidade de comando do robô

1.2 Gerenciar projeto com o WorkVisual

Para acrescentar ou alterar programas na unidade de comando em um proje-


to existente, são necessários os seguintes passos de trabalho:
Execução do projeto
1. Vinculação de um PC WorkVisual à unidade de comando através da KSI
- KUKA System Interface.
(>>> 1.2.1 "Vinculação de um PC WorkVisual à unidade de comando"
Página 7)
2. Carregar projetos existentes no WorkVisual
(>>> 1.2.3 "Carregar projeto existente no WorkVisual" Página 10)
3. No WorkVisual, ativar o modo Programação e configuração
(>>> 1.2.5 "Modos WorkVisual" Página 12)
4. Na estrutura de projeto WorkVisual mudar para Visualizar Arquivos.
(>>> 1.2.6 "Estrutura de projeto WorkVisual (guia Arquivos)" Página 13)
5. Modificar projeto, por exemplo, programas KRL
(>>> 1.3 "Processar programas KRL com WorkVisual" Página 35)
6. Comparar eventuais projetos com WorkVisual
(>>> 1.2.7 "Comparar projetos com WorkVisual" Página 14)
7. Transmitir o projeto para a unidade de comando do robô (instalar)
(>>> 1.2.8 "Transmitir o projeto à unidade de comando do robô (instalar)"
Página 18)
8. Atribuir o projeto a uma unidade de comando do robô real
(>>> 1.2.9 "Atribuir o projeto à unidade de comando do robô real" Pági-
na 28)
9. Ativar o projeto na unidade de comando do robô
(>>> 1.2.10 "Ativar o projeto na unidade de comando do robô" Página 32)

1.2.1 Vinculação de um PC WorkVisual à unidade de comando

Descrição  Para trocar projetos de PC via WorkVisual com a unidade de comando, é


necessário estabelecer uma conexão de rede.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 7 / 251


Programação do robô 2

 Até a versão de software KSS 8.2 estava disponível para isso somente a
interface KLI - KUKA Line Interface, que tinha que ser configurada em se-
parado. Essa interface também está à disposição com o KSS 8.3.
 A partir da versão de software KSS 8.3 está disponível a nova interface
KSI - KUKA Service Interface, que oferece um manuseio bem mais simples.
 Após um update do KSS 8.2 para KSS 8.3 também esta interface será li-
berada em unidades de comando mais "antigas".

Conectar o PC
WorkVisual à KSI

Fig. 1-1: Conexão à KSI via CSP

Pos. Descrição
1 Notebook com WorkVisual
2 Cabo de rede
3 Armário de comando KR C4
A Conexão KSI atrás da tampa do CSP

1. O ajuste de rede do PC WorkVisual (1) está configurado em DHCP (ob-


tenção automática de um endereço de rede).
2. Puxar o cabo de rede (2) do PC WorkVisual (1) para a KSI - KUKA Service
Interface (A) do armário de comando (3)
3. A KSI - KUKA Service Interface (A) encontra-se atrás da tampa do CSP -
Controller System Panel.

A KR C4 atribui automaticamente um endereço IP ao PC conectado.

Nunca conectar a KSI - KUKA Service Interface com uma


rede TI existente. Isso causa conflitos de endereço bem
como falhas de funcionamento!

1.2.2 Visão geral da interface de operação WorkVisual

 Na interface de operação não são visíveis como padrão todos os elemen-


tos, porém, eles podem ser exibidos ou ocultados conforme a necessida-
de.
 Além das janelas e editores aqui ilustrados existem outros à disposição.
Entre outros, você pode inserir, através dos itens de menu, janelas e edi-
tores.

8 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Fig. 1-2: Vista geral da interface de operação

Pos. Descrição
1 Barra de menu
2 Barras de botões

3 Área de editores
Quando um editor está aberto, ele é exibido aqui. Podem estar
abertos vários editores simultaneamente, como neste exemplo.
Eles então estão sobrepostos e podem ser selecionados através
de guias.
4 Botão de ajuda
5 Janela Estrutura de projeto

6 Janela Catálogos
Nesta janela são exibidos todos os catálogos adicionados. Os
itens no catálogo podem ser adicionados à janela Estrutura de
projeto da guia Dispositivos ou Geometria.
7 Janela Áreas de trabalho

8 Janela Mensagens

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 9 / 251


Programação do robô 2

Pos. Descrição
9 Janela Propriedades
Quando um objeto é selecionado, as suas propriedades são exibi-
das nesta janela. As propriedades podem ser alteradas. Proprie-
dades individuais em campos cinza não podem ser alteradas.
10 Ícone Análise de projeto WorkVisual

1.2.3 Carregar projeto existente no WorkVisual

Descrição Em cada unidade de comando do robô, para a qual existe uma conexão de
rede, um projeto pode ser selecionado e transmitido ao WorkVisual. Isto tam-
bém é possível, se este projeto ainda não existir neste PC.
O projeto é salvo no diretório …\WorkVisual Projects\Downloaded Projects.

Exibição do No smartPad o projeto ativo é exibido através do pressionamento do botão


projeto ativo na Projeto.
HMI

Fig. 1-3: Projeto ativo antes do Transfer

Explorer de
projeto

Fig. 1-4: Project Explorer

 Últimos arquivos exibe os últimos arquivos utilizados


Caminho de menu: Arquivo > Arquivos abertos por último (acesso rápido
através de janela de seleção separada)
 Criar projeto gera
 um novo projeto vazio
 um novo projeto através de modelo
 um novo projeto com base em um projeto existente
Caminho de menu:Arquivo > Novo
 Abrir projeto é usado para abrir projetos existentes
Caminho de menu:Arquivo > Abrir projeto

10 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

 Localizar é usado para poder carregar um projeto da unidade de coman-


do do robô
Caminho de menu:Arquivo > Localizar projeto

Carregar projeto Procedimento


WorkVisual da 1. Selecionar a sequência de menu Arquivo > Localizar projeto. Abre-se o
unidade de Project Explorer. À esquerda está selecionada a guia Localizar.
comando 2. Na área Células disponíveis (3), abrir o nó da célula desejada. São exi-
bidas todas as unidades de comando do robô desta célula.
3. Abrir o nó da unidade de comando do robô desejada. São exibidos todos
os projetos.
4. Marcar o projeto desejado e clicar em Abrir. O projeto é aberto no WorkVi-
sual.

Fig. 1-5: Find IP Address

Sob determinadas circunstâncias pode acontecer que, apesar da conexão de


rede existente, não apareçam unidades de comando na janela Localizar. O
procedimento a seguir é uma solução:
1. No WorkVisual Explorer clicar no botão Lupa (1).
2. Abre-se a janela Find IP Addess (2).
3. Introduzir o endereço IP desejado do armário de comando.
4. Assumir o endereço IP com OK (2).
5. A unidade de comando agora aparece na janela Células disponíveis (3).

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 11 / 251


Programação do robô 2

1.2.4 Gravar localmente o projeto WorkVisual

Fig. 1-6: Salvar o projeto carregado

1. Salvar o projeto através do caminho de menu: Arquivo > Salvar como.


2. O nome de arquivo introduzido agora é representado na linha de título
pelo WorkVisual com um "*"; isto significa que o arquivo ainda não foi sal-
vo sob WorkVisual.
3. Com o Explorer exibido definir o local de memória do projeto.
4. Definir o nome do arquivo na janela de introdução de mesmo nome.
5. Através do botão Editar propriedades recomenda-se descrever breve-
mente o projeto ou gravar opcionalmente uma figura do projeto.
6. Com o botão Salvar o projeto atual é salvo no caminho de arquivo pre-
definido.

1.2.5 Modos WorkVisual

Descrição  O WorkVisual pode ser usado em dois diferentes modos:


 Programação e configuração
Área para trabalhos específicos de projeto como, p.ex., trabalhos com
o editor KRL, configuração de hardware, de bus de campo e de segu-
rança.
 Administração online
Área para o diagnóstico online como, p.ex., diagnóstico de hardware
e registro de trace.
 Estas podem ser selecionadas através do item de menu Visão geral ou
através da janela Áreas de trabalho:
a. Selecionar a sequência de menu Janela > Áreas de trabalho.
b. Na janela Áreas de trabalho clicar o modo desejado. A seleção ativa
é exibida em laranja.

Fig. 1-7: Janela Áreas de trabalho

12 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Para o treinamento Programação de robô 2 é necessário o modo


Programação e configuração.

1.2.6 Estrutura de projeto WorkVisual (guia Arquivos)

Guia Estrutura de  Guia Estrutura de projeto


projeto

Fig. 1-8: Exemplo: Arquivos gerados automaticamente em cinza

 Equipamentos:
Na guia Equipamentos é esclarecida a interdependência dos equipa-
mentos. Aqui os equipamentos individuais podem ser atribuídos a uma
unidade de comando do robô.
 Geometria:
Na guia Geometria são disponibilizados os dados da máquina para as ci-
nemáticas externas como, p.ex., eixos adicionais.
 Arquivos:
A guia Arquivos contém os arquivos de programa e de configuração per-
tencentes ao projeto.
Representação em cores dos nomes de arquivos:
 Arquivos gerados automaticamente (com função Gerar código): cin-
za
 Arquivos inseridos manualmente no WorkVisual: azul
 Arquivos, que foram transmitidos de uma unidade de comando do
robô ao WorkVisual: preto
Caminho de arquivo para a programação no KRL
 Para a programação no WorkVisual são gerados ou adaptados progra-
mas *.SRC .
 Estes se encontram na unidade de comando real na partição C:\KRC\Ro-
boter\Programme
 No navegador este caminho é representado em separado (semelhante
como os arquivos próprios sob Microsoft Windows).

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 13 / 251


Programação do robô 2

 Na janela Estrutura de projeto sob a guia Arquivos encontra-se a pasta ne-


cessária para a programação:
Caminho de menu: KRC\R1\PROGRAMME

Não excluir ou manipular nenhum arquivo *.XML desconhecido. Em


determinadas circunstâncias o projeto não pode ser ativado ou gera
erros.

1.2.7 Comparar projetos com WorkVisual

Descrição  um projeto no WorkVisual pode ser comparado com um outro projeto


 este pode ser um projeto em uma unidade de comando do robô ou um
projeto armazenado no local
 as diferenças são enumeradas de forma visualizável e podem ser exibi-
das informações detalhadas
 o usuário pode decidir individualmente para cada diferença,
 se ele deseja manter o estado como no projeto atual
 ou se ele deseja assumir o estado de um outro projeto

Princípio da Unir projetos


comparação de  Janela de seleção Comparar projeto
projeto

Fig. 1-9: Selecionar projeto para "comparar"

 Projeto ativo
 Projeto de mesmo nome na unidade de comando (somente possível com
conexão de rede)
 Projeto base
 Projeto inicial
 Projeto local (do Notebook)
Comparação:
As diferenças entre os projetos são exibidas em uma visão geral. Para cada
diferença pode ser selecionado qual estado deve ser assumido.

14 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Fig. 1-10: Exemplo: Visão geral das diferenças

Pos. Descrição
1 O nó para a unidade de comando do robô. As diversas áreas de projeto são represen-
tadas em subnós. Abrir os nós, para exibir as comparações.
Se existirem várias unidades de comando do robô, elas são enumeradas uma sob a
outra.
 Em uma linha, sempre colocar o ticado no valor que deve ser assumido. (Alterna-
tiva: usar as caixas de verificação na linha de rodapé.)
 Um ticado em Não disponível significa, que o elemento não é assumido ou que,
se já existente, será excluído do projeto.
 Quando um nó é ticado, também são ticados automaticamente todos os elementos
subordinados.
Quando um ticado é removido em um nó, também é removido automaticamente o
ticado em todos os elementos subordinados.
Os elementos subordinados, contudo, também podem ser editados individualmen-
te.
 Uma caixa preenchida significa: Dos elementos subordinados, pelo menos um
está selecionado, contudo, não todos.
2 Estado no projeto, que está aberto no WorkVisual.
3 Estado no projeto de comparação.
4 Filtro, para exibir e ocultar diversos tipos de diferenças.
5 TRUE: São inseridas informações detalhadas para a linha marcada na visão geral.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 15 / 251


Programação do robô 2

Pos. Descrição
6 Seta para trás: O foco na exibição salta para a diferença anterior.
Seta para frente: O foco na exibição salta para a diferença seguinte.
Os nós fechados são abertos automaticamente.
7 As caixas de verificação exibem o estado da linha, na qual se encontra o foco no mo-
mento. Em vez de colocar os ticados diretamente na linha, eles também podem ser co-
locados e removidos aqui.
8 Assume as alterações selecionadas no projeto aberto.
9 Fecha a janela Unir projetos.

Descrição das cores:

Coluna Descrição
Estrutura de projeto Cada elemento é exibido na cor, que ele tem na coluna, na qual está
selecionado.
WorkVisual Todos os elementos são exibidos em preto.
Valor selecionado  Verde: Elementos, que não existem no projeto aberto, mas no proje-
to de comparação.
 Azul: Elementos, que existem no projeto aberto, mas não no projeto
de comparação.
 Vermelho: Todos os demais elementos. A estes também pertencem
elementos superiores, que contêm elementos em várias cores.

Procedimento na 1. No WorkVisual, selecionar a sequência de menu Extras > Comparar pro-


comparação de jetos. Abre-se a janela Comparar projetos.
projetos

Fig. 1-11: Comparar projetos

2. Selecionar o projeto, com o qual o projeto WorkVisual atual deve ser com-
parado, p.ex. o projeto de mesmo nome na unidade de comando do robô
real.

Fig. 1-12: Selecionar projeto para "comparar"

3. Clicar em Continuar. É exibida uma barra de progresso. Se o projeto con-


tém várias unidades de comando do robô, é exibida uma barra para cada
uma.

16 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

4. Quando a barra de progresso estiver preenchida e, além disso, for exibido


o estado. Pronto para unir: Clique em Exibir diferenças. As diferenças
entre os projetos são exibidas em uma visão geral.
Se não foram apuradas diferenças, isto é exibido na janela de mensa-
gens. Continuar com o passo 8. Depois disto não são necessários outros
passos.
5. Para cada diferença, selecionar qual estado deve ser assumido. Isto não
é necessário fazer para todas as diferenças em uma operação.
Se for conveniente, pode ser mantida também a seleção padrão.
6. Pressionar Unir, para assumir as alterações no WorkVisual.
7. Repetir os passos 5 e 6 quantas vezes for necessário. Isto possibilita edi-
tar sequencialmente as diversas áreas.
Se não existirem outras diferenças, isto é exibido na mensagem a seguir:
Não há outras diferenças.
8. Fechar a janela Comparar projetos.
9. Caso na unidade de comando do robô tenham sido alterados parâmetros
de eixos adicionais no projeto, eles devem ser atualizados agora no
WorkVisual:
 Para este eixo adicional, abrir a janela Configuração de dados da
máquina.
 Na área Dados de máquina gerais específicos de eixo, pressionar
o botão para a importação de dados da máquina.
Os dados são atualizados.
10. Salvar o projeto.
Exemplo de uma comparação de projetos

Fig. 1-13: Exemplo: Visão geral de comparação de projetos

Decisão de qual estado do(s) arquivo(s) deve ser assumido.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 17 / 251


Programação do robô 2

Fig. 1-14: Exemplo: Unir projetos

Na ativação dos Detalhes podem ser exibidas as diferenças dos arquivos.

Fig. 1-15: Exemplo: Detalhes ativados

1.2.8 Transmitir o projeto à unidade de comando do robô (instalar)

Descrição  Alterações no projeto devem ser enviadas à unidade de comando por


meio do WorkVisual.
 Este procedimento é chamado de "Instalar" na KUKA.
 Na transmissão de um projeto para a unidade de comando de robô sem-
pre é gerado primeiramente o código.
 Uma conexão de rede à unidade de comando do robô real é pré-requisito
para "Instalar".

Se na unidade de comando de robô real existir um projeto, que foi


transmitido anteriormente e nunca foi ativado, ele será sobrescrito
através da transmissão de um outro projeto.
Através da transmissão e ativação de um projeto, um projeto de mesmo no-
me, existente na unidade de comando de robô real, é sobrescrito (após uma
pergunta de segurança).

Funções Gerar código


 Com este procedimento pode-se gerar o código em separado e, com isto,
verificar previamente se a geração ocorre sem erros.
 O acesso ocorre via:
 sequência de menu Extras > Gerar código

 ou o botão
 O código é exibido na janela Estrutura de projeto na guia Arquivos.
Um código gerado automaticamente é exibido em cinza claro.

18 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Fig. 1-16: Exemplo Gerar código: antes - depois

 O código é gerado. Quando o procedimento estiver concluído, são


exibidas na janela de mensagens as seguintes mensagens: O projeto
<"{0}" V{1}> foi compilado. Os resultados você vê na árvore de
arquivos.

Versões
WorkVisual até
3.0

Procedimento
1. Na barra de menu, pressionar o botão Instalar …. . Abre-se a janela
Transmissão de projeto.

Fig. 1-17: Visão geral com observação sobre configuração incompleta

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 19 / 251


Programação do robô 2

2. Em se tratando de um projeto, que nunca foi retransmitido de uma unida-


de de comando do robô ao WorkVisual, ele ainda não contém todos os da-
dos de configuração (dentre os arquivos de configuração estão arquivos
de dados da máquina, arquivos da configuração de segurança e inúmeros
outros). Isso é indicado por uma instrução.
 Se esta instrução não for exibida: Continuar com o passo 13.
 Quando esta instrução é exibida: Continuar com o passo 3.
3. Clicar em Completar. É exibida a seguinte pergunta de segurança: O
projeto deve ser salvo e o comando atual é resetado! Deseja prosse-
guir?
4. Responder a pergunta com Sim. Abre-se a janela Unir projetos.

Fig. 1-18: Selecionar projeto para "comparar"

5. Selecionar um projeto, cujos dados de configuração devem ser assumi-


dos, p.ex., o projeto ativo na unidade de comando do robô real.
6. Clicar em Continuar. É exibida uma barra de progresso. Se o projeto con-
tém várias unidades de comando do robô, é exibida uma barra para cada
uma.

7. Quando a barra de progresso estiver preenchida e, além disso, for exibido


o estado bem como Pronto para unir: Clique em Exibir diferenças.
As diferenças entre os projetos são exibidas em uma visão geral.

8. Para cada diferença, selecionar qual estado deve ser assumido. Isto não
é necessário fazer para todas as diferenças em uma operação.
Se for conveniente, pode ser mantida também a seleção padrão.
9. Pressionar Unir, para assumir as alterações.
10. Repetir os passos 8 e 9 quantas vezes for necessário. Isto possibilita edi-
tar sequencialmente as diversas áreas.
Se não existirem outras diferenças, isto é exibido na mensagem a seguir:
Não há outras diferenças.
11. Fechar a janela Comparar projetos.

12. Na barra de menu, clicar no botão Instalar... . A visão geral sobre a


atribuição de células é exibida novamente. A instrução em relação à con-
figuração incompleta não é mais exibida.

20 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Fig. 1-19: Visão geral

13. Clicar em Continuar. É iniciada a geração de programa. Se a exibição de


progresso atingir 100%, o programa está gerado e o projeto transmitido.
14. Clicar em Ativar.

Nos modos de operação AUT e AUT EXT o projeto é ati-


vado sem consulta de segurança, quando se trata ape-
nas de alterações de programa.

Para a ativação de um projeto, é necessário o perfil de


usuário Peritos. Se no projeto a ser ativado também
existirem alterações na segurança, é necessário o perfil de usuário Coloca-
dor em funcionamento de segurança ou Técnico de manutenção de segu-
rança com código válido de ativação.

15. Somente nos modos de operação T1 e T2: O KUKA smartHMI exibe a per-
gunta de segurança Deseja permitir a ativação do projeto […]?. Além disso, é
indicado se através da ativação um projeto seria sobrescrito e, caso sim,
qual.
Se nenhum projeto relevante for sobrescrito: Confirmar a pergunta com
Sim dentro de 30 minutos.
16. É exibida uma visão geral sobre as alterações, que ainda serão feitas em
comparação com o projeto ainda ativo na unidade de comando do robô.
Através da caixa de verificação Detalhes é possível exibir detalhes sobre
as alterações.
17. A visão geral exibe a pergunta de segurança Deseja prosseguir?. Respon-
der com Sim. O projeto é ativado na unidade de comando do robô. No
WorkVisual é exibida uma confirmação.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 21 / 251


Programação do robô 2

Fig. 1-20: Confirmação no WorkVisual

18. Fechar a janela Transmissão de projeto com Finalizar.


19. Se a consulta à unidade de comando do robô não for respondida dentro
de 30 minutos, o projeto é transmitido mesmo assim. Contudo, não fica
ativo na unidade de comando do robô Nesse caso, o projeto pode ser ati-
vado separadamente.

Após a ativação de um projeto na unidade de comando


do robô é necessário verificar lá a configuração de segu-
rança! Se isso não ocorrer, o robô eventualmente será operado com dados
incorretos. Podem ocorrer morte, ferimentos ou danos materiais.

Se a ativação de um projeto falhar, é exibida uma men-


sagem de erro no WorkVisual. Neste caso é necessário
executar uma das medidas a seguir:
 Ativar novamente um projeto. (O mesmo ou um outro).
 Ou reiniciar a unidade de comando do robô com uma partida a frio.

Versões
WorkVisual a
partir de 3.1

Procedimento

Iniciar trans-
 Na barra de menu, pressionar o botão Instalar …. .
missão de projeto
 Abre-se a janela Transmissão de projeto.
 Alternativamente a transmissão de projeto também pode ser acessada
através do Caminho de menu: Extras (Ferramentas) > Instalar.

Atribuir unidade 1. A unidade de comando do projeto WorkVisual (2) já está atribuída à uni-
de comando dade de comando real (4) através da seta azul (3). (>>> "Procedimento"
Página 31)

22 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Fig. 1-21: Atribuir unidade de comando

Pos. Descrição
1 Decurso da transmissão de projeto
2 Armário de comando do projeto WorkVisual
3 Atribuição do projeto ao armário de comando real
4 Armário de comando real na rede do sistema
5 Abre a janela para a localização de armários de comando na
rede do sistema
6 Abre a janela para a comparação de projeto
7 Confirmação da atribuição de armário de comando

2. Confirmar a atribuição com o botão Continuar (7)

Solucionar  Se existirem conflitos ou irregularidades na transmissão de projeto, é in-


conflitos serida uma janela de eliminação de falhas, que exibe soluções de conflito.
 Selecionar e aplicar a solução adequada das sugestões.

Gerar código  Após a atribuição da unidade de comando o WorkVisual gera, a partir da


configuração gráfica, os arquivos *.xml necessários para a unidade de co-
mando.

Fig. 1-22: Geração de código

 Este passo de trabalho também pode ser executado previamente em se-


parado. Caminho de menu: Extras > Gerar código
 Se forem constatados erros na geração de códigos, a barra de progresso
é exibida em vermelho e a geração é cancelada.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 23 / 251


Programação do robô 2

Transmitir projeto  O projeto gerado pronto é transmitido automaticamente no próximo passo


de trabalho à unidade de comando.

Fig. 1-23: Transmitir projeto

 Os projetos podem ser transmitidos a toda hora na unidade de comando


sem direitos explícitos de usuário.
Eles são copiados na unidade de comando na administração de projeto.
 Se durante a transmissão ocorrer uma interrupção da conexão, este pas-
so de trabalho será cancelado.

Ativar o projeto  Depois que o projeto foi transmitido, o projeto pode ser ativado diretamen-
te através do WorkVisual. Se a ativação falhar, porque, por exemplo, os
direitos de usuário necessários na unidade de comando não estão pre-
sentes, o projeto pode ser ativado novamente através do ícone (1).

Fig. 1-24: Ocorreu um erro na ativação do projeto

 Após uma ativação de projeto bem sucedida é inserida uma barra de pro-
gresso verde. Com o botão Finalizar (1) é finalizado o Wizard.

24 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Fig. 1-25: Transmissão de projeto bem sucedida

 Caso a consulta na unidade de comando do robô não seja respondida


dentro de 30min, o projeto será transmitido mesmo assim, contudo, não
estará ativo na unidade de comando do robô. Agora pode-se ativar o pro-
jeto em separado. (>>> Fig. 1-24 )

Confirmar a 1. De acordo com as alterações no projeto é necessário o perfil de usuário


ativação do perito ou colocador em funcionamento de segurança.
projeto no 2. Da HMI do SmartPads aparece a mensagem "Aguardada introdução de
SmartPad usuário!".

Fig. 1-26: Mensagem de instalação

3. No smartPad abre-se a janela "Administração de projeto" com a pergunta


"Deseja permitir a ativação do projeto "1EG2-R04-8_2_First_Test"?" Confirmar a
ativação com "Sim".

Fig. 1-27: Permitir ativação

4. É inserida outra janela "Administração de projeto". Nela são exibidas as


alterações previstas.
Responder a pergunta "Deseja prosseguir?" com "Sim".

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 25 / 251


Programação do robô 2

Fig. 1-28: Indicação das alterações

5. No smartPad aparece uma mensagem de que é realizada uma reconfigu-


ração.

Fig. 1-29: Reconfiguração em execução

Assumir a soma 1. Se no WorkVisual a segurança tiver sido alterada como, p.ex., a interface
de verificação de segurança ou o parâmetro SafeOperation, é exibida a seguinte men-
alterada sagem de erro na janela de mensagens: "Soma de verificação da configu-
ração de segurança está incorreta".

26 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Fig. 1-30: Erro Soma de verificação

2. E necessário o perfil de usuário Colocador em funcionamento de seguran-


ça.
3. Abrir a configuração de segurança.
Caminho de menu: Tecla KUKA > Configuração > Configuração de segurança
4. Na janela "Assistente de solução de problemas" selecionar o registro "Acabou
de ser ativado um projeto WorkVisual"

Fig. 1-31: Assistente de solução de problemas

5. Aceitar a primeira sugestão, pressionando o botão "Ativar agora".

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 27 / 251


Programação do robô 2

6. Na janela "Ativar" responder a pergunta "Tem certeza que deseja alterar as


seguintes partes da configuração relevante de segurança?" com "Sim". A recon-
figuração é executada.
7. Confirmar a mensagem no smartPad "As modificações foram memorizadas
com sucesso" com o botão "OK".
8. Confirmar a mensagem de confirmação "Quitt: Soma de verificação da
configuração de segurança está incorreta" com "Todos OK"

1.2.9 Atribuir o projeto à unidade de comando do robô real

Descrição Um projeto deve ser atribuído da seguinte forma antes da transmissão:


 Unidade de comando de destino
 A unidade de comando de destino corresponde à unidade de coman-
do real, na qual o projeto deve ser transmitido.
 Se um projeto é carregado de uma unidade de comando, editado no
WorkVisual e se deve ser novamente transmitido de volta, a atribuição
ocorre automaticamente.
 Célula
 Em estruturas de instalações mais complexas pode acontecer que vá-
rios robôs ou várias unidades de comando se encontrem em uma úni-
ca célula grande.
 Antes que um projeto seja transmitido à unidade de comando, a uni-
dade de comando pode ser atribuída a uma célula.
 Essa atribuição não tem nenhum efeito sobre a capacidade funcional
do projeto.
 Ela serve para fins de visualização geral e fica visível na união de ins-
talações através do WorkVisual.

Versões
WorkVisual até
3.0

Procedimento 1. Na barra de menu, clicar no botão Instalar …. Abre-se a janela Trans-


missão de projeto.

Fig. 1-32: Visão geral

2. Através do botão Alterar na linha Célula é aberta a visão geral da célula.

28 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Fig. 1-33: Atribuir a unidade de comando de robô à célula

3. Sob Célula de destino são exibidas as células existentes. (As células po-
dem ser renomeadas através de clique no botão direito.)
Se a célula desejada não estiver disponível, pode ser criada uma célula
nova:
 Clique em Nova célula. Abre-se a janela Propriedades de células.
Introduzir um nome e, se necessário, uma descrição. Salvar com OK.
Agora a célula nova é exibida sob Célula de destino.
4. Sob Célula de destino, marcar a célula desejada. A esta célula agora de-
vem ser atribuídas as unidades de comando do robô reais.
5. Sob Unidades de comando disponíveis, marcar a unidade de comando
do robô real desejada.
Dependendo da topologia de rede é possível, que a unidade de comando
do robô não seja exibida sob Unidades de comando disponíveis. Se o
endereço IP for conhecido, a unidade de comando do robô pode ser exi-
bida como a seguir:

 Clique em . Abre-se uma janela. Introduzir o endereço IP e salvar


com Ok.
A unidade de comando do robô agora é exibida sob Unidades de co-
mando disponíveis.

6. Clique em . A unidade de comando do robô agora é exibida sob Uni-


dades de comando de destino.
7. Se o projeto contiver várias unidades de comando do robô, repetir os pas-
sos 4 e 5 para as demais unidades de comando do robô.
8. A unidade de comando do robô virtual agora deve ser unida à unidade de
comando do robô real: Clicar em Continuar.

Cada unidade de comando do robô virtual deve ser atribuída exata-


mente a uma unidade de comando de robô real.

9. Marcar a unidade de comando virtual sob Unidades de comando no pro-


jeto.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 29 / 251


Programação do robô 2

10. Sob Unidades de comando na célula, marcar a unidade de comando do

robô real e clicar em . A unidade de comando do robô real é atribuída


à unidade de comando do robô virtual.

Fig. 1-34: Atribuir a unidade de comando de robô real à virtual

11. Se o projeto contiver várias unidades de comando do robô, repetir os pas-


sos 8 e 9 para as demais unidades de comando do robô.
12. Clicar em Continuar. É exibida uma visão geral. (Aqui existe a possibili-
dade de alterar mais uma vez a atribuição, caso necessário. Para isto, cli-
car em Alterar ….)

Fig. 1-35: Visão geral

13. Agora o projeto pode ser transmitido à unidade de comando do robô.

Alternativamente o projeto pode ser transmitido posteriormente. Para isto,


clicar em Cancelar: A atribuição é salva e a janela Transmissão de pro-
jeto é fechada.

30 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Versões
WorkVisual a
partir de 3.1

Procedimento 1. Na barra de menu, clicar no botão Instalar …. Abre-se a janela Trans-


missão de projeto WorkVisual. No lado esquerdo é exibida a unidade
de comando do robô virtual do projeto. No lado direito é exibida a unidade
de comando de destino. Ela está em cinza se ainda não foi selecionada
nenhuma unidade de comando.

Fig. 1-36: Atribuir a unidade de comando do robô à célula

2. No lado esquerdo, ativar a célula virtual com a caixa de verificação. A uni-


dade de comando do robô real agora deve ser atribuída a esta célula.
3. Clicar no botão …. Abre-se uma janela. O filtro é ajustado automaticamen-
te de tal forma, que apenas sejam exibidas unidades de comando de mes-
mo tipo e da mesma versão que a unidade de comando virtual. Este ajuste
pode ser alterado.

Fig. 1-37: Atribuir a unidade de comando do robô real à virtual

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 31 / 251


Programação do robô 2

4. Selecionar a unidade de comando do robô real desejada e clicar em Ok.


A unidade de comando do robô real é atribuída à unidade de comando do
robô virtual. Após a atribuição a unidade de comando do robô real é exi-
bida com cor e com nome e endereço IP.

Fig. 1-38: Visão geral

5. Se o projeto contiver várias unidades de comando do robô, repetir os pas-


sos 3 e 4 para as demais unidades de comando do robô.
6. Clicar em Continuar. A atribuição é verificada quanto a conflitos. Em caso
de conflitos, é exibida uma mensagem. Os conflitos devem ser soluciona-
dos, caso contrário não é possível transmitir o projeto. Se não houver con-
flitos, é gerado automaticamente o código.
7. Agora o projeto pode ser transmitido à unidade de comando do robô.
Alternativamente o projeto pode ser transmitido posteriormente. Para isto,
clicar em Cancelar: a atribuição é salva e a janela Transmissão de pro-
jeto WorkVisual fecha.

1.2.10 Ativar o projeto na unidade de comando do robô

Descrição  O projeto pode ser ativado diretamente na unidade de comando do robô


 O projeto pode ser ativado também diretamente a partir do WorkVisual
para na unidade de comando do robô
(não será explicado detalhadamente aqui, usar para isto a documentação
online do WorkVisual)

Função da Generalidades
administração de  A unidade de comando do robô tem a possibilidade de administrar vários
projeto projetos na unidade de comando.
 Todas as funções primeiro estão disponíveis no grupo de usuários Peri-
tos
 Um acesso ocorre via:
 Na interface de operação, com a tecla WorkVisual-Symbol e, em se-
guida, o botão Abrir

32 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Fig. 1-39: Exibição de projeto na interface de operação

Manuseio / Operação

Fig. 1-40: Janela Administração de projeto

Pos. Descrição
1 É exibido o projeto inicial.
2 Restabelece o estado de fornecimento da unidade de comando do
robô.
Está disponível a partir do grupo de usuários Peritos.
3 É exibido o projeto base.
4 Cria uma cópia do projeto base.
Está disponível a partir do grupo de usuários Peritos.
5 O projeto ativo é exibido.
6 Salva o projeto ativo como projeto base. O projeto ativo permane-
ce ativo.
Está disponível a partir do grupo de usuários Peritos.
7 Cria uma cópia pinada do projeto ativo.
Está disponível a partir do grupo de usuários Peritos.
8 Lista dos projetos. O projeto ativo não é exibido aqui.

 Além dos projetos regulares a janela Administração de projeto contém


os seguintes projetos especiais:

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 33 / 251


Programação do robô 2

Projeto Descrição
Projeto inicial O projeto inicial sempre existe. Ele não pode ser alte-
rado pelo usuário. Ele contém o estado da unidade de
comando do robô no fornecimento.
Projeto base O usuário pode salvar o projeto ativo como projeto
base. Esta funcionalidade normalmente é usada para
salvar um estado de projeto aprovado e funcional.
O projeto base não pode ser ativado, mas copiado. O
projeto base não pode mais ser alterado pelo usuário.
Mas ele pode ser sobrescrito através da gravação de
um novo projeto base (após uma pergunta de segu-
rança).
Quando é ativado um projeto, que não contém todos
os arquivos de configuração, as informações faltantes
são assumidas do projeto base. Este pode ser o caso,
p.ex., quando é ativado um projeto de uma versão
anterior do WorkVisual. Aos arquivos de configuração
pertencem arquivos de dados da máquina, arquivos da
configuração de segurança e inúmeros outros.

 Descrição dos botões

Botão Descrição
Ativar Ativa o projeto marcado.
Se o projeto marcado estiver pinado: Cria uma cópia
do projeto marcado. (Um projeto pinado não pode ser
ativado, somente uma cópia dele.) O usuário pode
decidir, se a cópia deve ser ativada imediatamente ou
se o projeto atual deve permanecer ativo.
Está disponível a partir do grupo de usuários Peritos.
Colocar pinos Projetos pinados não podem ser alterados, ativados ou
excluídos. Contudo, eles podem ser copiados ou "des-
pinados". Portanto, pode-se pinar um projeto para,
p.ex., impedir que ele seja excluído acidentalmente.
Somente está disponível, se estiver marcado um pro-
jeto não-pinado. Está disponível a partir do grupo de
usuários Peritos.
Despinar "Despina" o projeto.
Somente está disponível, se estiver marcado um pro-
jeto pinado. Está disponível a partir do grupo de usuá-
rios Peritos.
Copiar Copia o projeto marcado.
Está disponível a partir do grupo de usuários Peritos.
Excluir Exclui o projeto marcado.
Somente está disponível, se estiver marcado um pro-
jeto não-pinado não ativo. Está disponível a partir do
grupo de usuários Peritos.

34 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Botão Descrição
Editar Abre uma janela, na qual podem ser alterados o nome
e/ou a descrição do projeto marcado.
Somente está disponível, se estiver marcado um pro-
jeto não-pinado. Está disponível a partir do grupo de
usuários Peritos.
Atualizar Atualiza a lista de projetos. Desta forma são exibidos,
p.ex., projetos, que foram transmitidos à unidade de
comando do robô desde a abertura da exibição.

Procedimento
Restrição: Se a ativação causar alterações na área de parâmetros
de comunicação da configuração de segurança, deve estar selecio-
nado o grupo de usuários técnico de manutenção de segurança ou
superior.
Se o modo de operação AUT ou AUT EXT estiver selecionado: O projeto so-
mente pode ser ativado, se através disto se alterarem apenas programas
KRL. Se o projeto contiver ajustes, que causariam outras alterações, ele não
pode ser ativado.

1. Selecionar a sequência de menus Arquivo > Administração de projeto.


Abre-se a janela Administração de projeto.

2. Marcar o projeto desejado e ativá-lo com o botão Ativar.


3. O KUKA smartHMI exibe a pergunta de segurança Deseja permitir a ati-
vação do projeto […]?. Além disso, é indicado se através da ativação um
projeto seria sobrescrito e, caso sim, qual.
Se nenhum projeto relevante for sobrescrito: Confirmar a pergunta com
Sim dentro de 30min.
4. É exibida uma visão geral sobre as alterações, que ainda serão feitas em
comparação com o projeto ainda ativo na unidade de comando do robô.
Através da caixa de verificação Detalhes é possível exibir detalhes sobre
as alterações.
5. A visão geral exibe a pergunta de segurança Deseja continuar?. Responder
com Sim. O projeto é ativado na unidade de comando de robô.

Após a ativação de um projeto na unidade de comando


do robô é necessário verificar lá a configuração de segu-
rança! Se isso não ocorrer, o robô eventualmente será operado com dados
incorretos. Podem ocorrer morte, ferimentos ou danos materiais.

1.3 Processar programas KRL com WorkVisual

 Manuseio do arquivo

 Manuseio com o editor KRL

1.3.1 Importar manuseio de arquivos

Descrição  Ativar catálogo Templates


 Abrir arquivo (SRC/DAT/SUB) no editor KRL
 Adicionar o arquivo com templates KRL
 Adicionar arquivo externo

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 35 / 251


Programação do robô 2

Ativar catálogo
Templates

Fig. 1-41: Adicionar catálogo

 Antes do uso dos templates é necessário carregar os respectivos catálo-


gos.
 Caminho de menu: Arquivo > Adicionar catálogo
 Na janela Catálogos disponíveis (1) estão enumerados todos os catálo-
gos instalados no WorkVisual, mas que não estão carregados e ativos.
 Na janela Catálogos de projeto (2) encontram-se todos os catálogos que
estão instalados e carregados no WorkVisual. Com estes catálogos pode
ser trabalhado ativamente.
 Através das teclas de seta (2) os catálogos podem ser setados como ati-
vos e inativos.
 Para a programação no WorkVisual são necessários os seguintes catálo-
gos:
 KRL Templates
KRL Templates.afc
 Modelos VW
VW Templates.afc

Abrir arquivo Procedimento


(SRC/DAT/SUB) 1. Na estrutura de projeto mudar para a guia Arquivos (1)
no editor KRL

Fig. 1-42: WorkVisual Árvore de projeto

2. Abrir diretórios até ao diretório R1

36 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Fig. 1-43: WorkVisual Árvore de projetos Estrutura de dados (R1)

3. Selecionar arquivo e ou
 com duplo-clique

 Botão da lista de símbolos

 Clique à direita e no menu de contexto Editor KRL

Fig. 1-44: Menu mouse de contexto WorkVisual (Editor KRL)

Adicionar o Procedimento
arquivo com 1. Trocar arquivo da árvore de projeto
templates KRL 2. Abrir diretórios até ao diretório R1

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 37 / 251


Programação do robô 2

3. Selecionar a pasta na qual o novo arquivo deverá ser criado

4. Clicar à direita e no menu de contexto Adicionar

Fig. 1-45: Menu de contexto WorkVisual (adicionar)

5. Seleção de template

Fig. 1-46: Catálogos para Templates KRL

a. Na janela Catálogos mudar para a guia Templates KRL (1)


b. Selecionar o template desejado (2), p.ex. Módulo.
c. Na janela Características (3) são inseridas informações detalhadas,
p.ex., quais arquivos são criados (aqui .src e .dat).
6. Atribuir nome de programa

38 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Adicionar arquivo Procedimento


externo 1. Na janela Estrutura de projeto na guia Arquivos abrir a estrutura de ár-
vore da unidade de comando do robô.
2. No nó, no qual deve ser criado o programa, clicar com o botão direito e
selecionar Adicionar arquivo externo no menu de contexto.

Fig. 1-47: Menu de contexto WorkVisual (adicionar arquivo externo)

3. Navegar para o diretório, no qual se encontra o arquivo a ser importado.

Fig. 1-48: Adicionar arquivo externo WorkVisual

4. Marcar o arquivo e confirmar com Abrir. O arquivo é inserido na estrutura


de árvore.
Podem ser importados arquivos com os formatos SRC, DAT, SUB e KRL
Agora o arquivo pode ser editado com o editor KRL.

1.3.2 Ativar Templates de catálogo

Descrição Para poder executar determinadas funções no WorkVisual como, p.ex., con-
figuração ou programação, é necessário ativar os respectivos catálogos.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 39 / 251


Programação do robô 2

Exemplo
 A estrutura de projeto deve ser expandida.
 Clicar com o botão direito no ícone da unidade de comando ativa e clicar
em "Adicionar".

Fig. 1-49: Expandir a estrutura de projeto

 É exibida a mensagem "Não foram encontrados elementos adequados.


Adicione os catálogos correspondentes."

Fig. 1-50: Mensagem de erro

Procedimento

Ativar catálogo
Templates

Fig. 1-51: Adicionar catálogo

 Antes do uso dos templates é necessário carregar os respectivos catálo-


gos.

40 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

 Caminho de menu: Arquivo > Adicionar catálogo


 Na janela Catálogos disponíveis (1) estão enumerados todos os catálo-
gos instalados no WorkVisual, mas que não estão carregados e ativos.
 Na janela Catálogos de projeto (2) encontram-se todos os catálogos que
estão instalados e carregados no WorkVisual. Com estes catálogos pode
ser trabalhado ativamente.
 Através das teclas de seta (2) os catálogos podem ser setados como ati-
vos e inativos.
 Para a programação no WorkVisual são necessários os seguintes catálo-
gos:
 KRL Templates
KRL Templates.afc
 Modelos VW
VW Templates.afc

1.3.3 Manuseio com o editor KRL

Descrição Editor  Conhecer a interface de operação Editor KRL


KRL  Descrição de cores do editor KRL
 Exibir declarações variáveis de um arquivo
 Localizar e substituir em arquivos
 Renomear variáveis
 Autocompletar
 Snippets – Introdução rápida para instruções KRL
 Correção Quickfix
 Corrigir variável não declarada ou declarar automaticamente
 Não excluir variáveis usadas
 Exibir variáveis
 Trabalhar com pastas

Conhecer a Descrição
interface de  O editor KRL permite o processamento confortável de programas KUKA.
operação Editor
 Não é possível testar ou deixar executar programas.
KRL
 Caminho de menu: Editores > Editor KRL

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 41 / 251


Programação do robô 2

Fig. 1-52: Interface de operação - Editor KRL

Pos. Descrição
1 Área do programa
Aqui se insere ou edita o código. O editor KRL oferece inúmeras
funcionalidades que dão suporte ao programador.
2 Lista dos subprogramas neste arquivo
Para se chegar a um subprograma, selecionar isto na lista: O cur-
so salta para a fileira DEF deste subprograma.
Se o arquivo não incluir subprogramas, a lista estará vazia.
3 Lista de declaração de variáveis
Esta lista sempre se refere a um subprograma que foi selecionado
atualmente na lista de subprogramas. Para se chegar a uma de-
claração, selecionar a variável na lista: O cursor salta para a fileira
com a declaração destas variáveis.
Se não houver nenhuma declaração de variável disponível, a lista
estará vazia.
4 Barra de análise
As marcações mostram erros ou discrepâncias no código.
 Um mouseover sobre a marcação mostra uma sugestão de
ferramenta com a descrição do erro.
 Através de um clique na marcação, o cursor salta até a posi-
ção correspondente no programa. Para o caso de alguns er-
ros/discrepâncias é oferecida uma correção automática.

5 O quadrado tem a cor do erro mais grave existente atualmente.


Se não houverem erros/discrepâncias, o quadrado fica verde.

42 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Funções gerais Marcar


de edição  Marcar uma área: Clicar no local onde a marcação deve iniciar e manter
o botão esquerdo do mouse pressionado. Com o mouse, arrastar até que
a área desejada esteja marcada e então soltar o botão.

Ao se pressionar a tecla ALT durante a marcação, pode-se marcar


uma área em formato quadrado.

 Marcar uma fileira: Clicar no número da fileira.


Editar
 As funções de edição atuais podem ser chamadas no menu de contexto.
Dentre elas podemos citar:
 Recortar, Inserir, Copiar, Excluir
 Desfazer, Restaurar
 Localizar ...
 Além do mais, os comandos listados em seguida estão disponíveis no
menu de contexto.

Os comandos não estão disponíveis para qualquer tipo de formato


de arquivo.
Comandos que se referem à área demarcada atuam por todo o ar-
quivo quando nenhuma área estiver marcada.

Item de menu Descrição


Editar > Converter em letras Converte as minúsculas em maiúsculas na área demar-
maiúsculas cada.
Editar > Converter em letras Converte as maiúsculas em minúsculas na área demar-
minúsculas cada.
Editar > Primeira letra em mai- Converte as letras iniciais em maiúsculas na área demar-
úscula cada.
Editar > Converter Tabs em Substitui na área marcada os tabuladores por caracteres
espaços em branco em branco.
Nota: A quantos espaços em branco corresponde um tabu-
lador, pode ser configurado através do parâmetro Tama-
nho de recuo.
Editar > Converter espaços em Substitui na área marcada os caracteres em branco por
branco em Tabs tabuladores.
Editar > Voltar Insere um espaço em branco inicial em cada fileira (adicio-
nal) na área marcada.
Nota: Quantos espaços em branco são inseridos, pode ser
configurado através do parâmetro Tamanho de recuo.
Editar > Remover espaço vazio Remove os espaços em branco iniciais nas fileiras.
inicial
Pastas > Abrir todas Abre todas as pastas do arquivo atualmente exibido.
Pastas > Fechar todas Fecha todas as pastas do arquivo atualmente exibido.
Formatar Parágrafos, quebras de linha etc. são adaptados em todo o
arquivo conforme o padrão. O padrão válido depende do
formato do arquivo.
Descomentar Comentar as linhas.
Comentar Remove o comentário das linhas.
Renomear (>>> "Renomear variáveis" Página 46)

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 43 / 251


Programação do robô 2

Item de menu Descrição


Ir para Declaração (>>> "Exibir variáveis" Página 51)
Inserir Snippet (>>> "Snippets – Introdução rápida para instruções KRL"
Página 48)

Descrição de  Descrição das cores


cores do editor O editor KRL reconhece os componentes do código introduzido e os exibe
KRL automaticamente em diferentes cores.

Componente do código Cor


Palavras-chave KRL azul médio
(exceto ;FOLD e ;ENDFOLD)
;FOLD e ;ENDFOLD cinza
Números azul marinho
Strings (texto entre aspas "…") vermelho
Comentários verde
Caracteres especiais verde azulado
Outro código preto

 Exemplo para o uso das cores

Fig. 1-53: Exemplo de cores no editor KRL

1 Palavras-chave KRL: azul


2 Comentário: verde
3 FOLD: cinza
4 Outro código: preto

Exibir decla- Descrição


rações variáveis  Todas as variáveis KRL, que estão declaradas em um determinado arqui-
de um arquivo vo, podem ser exibidos de forma visualizável em uma lista.
 Em arquivos SRC sempre são exibidas também as variáveis do arquivo
DAT pertinente e vice-versa.
Procedimento
1. Somente se a janela Lista de variáveis ainda não for exibida: Inseri-la
através da sequência de menu Janela > Lista de variáveis.
2. Abrir arquivo no editor KRL ou, se já aberto, clicar a guia do arquivo.
3. A lista de variáveis então mostra todas as variáveis que foram declaradas
neste módulo (arquivo SRC e os respectivos arquivos DAT).

44 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Através de um clique na coluna, a lista pode ser classificada conforme


esta coluna.

Fig. 1-54: Janela Lista de variáveis

Botão Nome/Descrição
Agrupa as variáveis conforme subfunções locais
O botão está pressionado: A exibição é classificada por tipos
de arquivo. (Dentro desta classificação pode ser classificado
adicionalmente por colunas.)
O botão não está pressionado: A exibição não está classifi-
cada por tipos de arquivo.

4. Conforme a necessidade, uma variável pode ser marcada conforme se-


gue no editor KRL:
 Dar um duplo clique na linha no resultado de busca.
 Ou: Clicar com o botão direito na linha, e no menu de contexto sele-
cionar Ir para....
 Ou: Marcar a linha e pressionar a tecla Enter.
5. Na janela Lista de variáveis existe uma função de busca à disposição,
com a qual se pode pesquisar por variáveis locais no arquivo atual:
 Introduzir o nome da variável ou uma parte do nome no campo de bus.
É exibido imediatamente o resultado da busca.

Localizar e Descrição
substituir em  No WorkVisual há uma opção de pesquisa com a qual se pode pesquisar
arquivos o texto de todos os arquivos do projeto todo.
Pode-se selecionar quais áreas podem ser pesquisadas na janela de pes-
quisa.
 Ainda assim, pode-se pesquisar um único arquivo ou uma área marcada
em um arquivo.
Procedimento
1. Abrir esta caso se queira pesquisar um arquivo individual.
2. Marcar estes no caso de uma pesquisa de uma área em um arquivo.
3. Abrir a janela de pesquisa: CTRL+F

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 45 / 251


Programação do robô 2

Fig. 1-55: Busca de WorkVisual

4. Ou: Abrir a janela de pesquisa e substituição: CTRL+H

Fig. 1-56: Localizar e substituir

5. Concluir o ajuste desejado e clicar em Pesquisar, respectivamente em


Substituir ou Substituir todos.

Renomear Descrição
variáveis  Um nome de variável pode ser alterado com uma única ação em todas as
posições onde ela ocorre.
 Isto também é possível quando a variável está declarada em um arquivo
DAT e é usada em vários arquivos SRC.
Pré-requisito
 Os arquivos nos quais os nomes das variáveis aparecem não contêm er-
ros de programação.
 A mudança não acontecerá automaticamente em arquivos com erros de
programação.

46 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Procedimento
1. Em uma posição qualquer, marcar a variável desejada.
2. Clicar com o botão direito e no menu de contexto selecionar Renomear.
3. Abre-se uma janela. Mudar o nome e confirmar com OK.

Fig. 1-57: Renomear variável

Autocompletar Descrição
 Existe uma funcionalidade de autocompletar disponível no editor KRL.
 Ao se incluir o código uma lista é automaticamente exibida, que inclui os
seguintes itens:
 Palavras-chave KRL
 Nomes conhecidos de variáveis
 Nomes conhecidos de funções
 Tipos de dados conhecidos específicos por usuário (STRUC or
ENUM)
 Snippets (>>> "Snippets – Introdução rápida para instruções KRL"
Página 48)
Procedimento
 Introduzir as primeiras letras do comando desejado, variável etc. na linha
de programa correspondente.
 Abre-se a autocompletação:

Fig. 1-58: Autocompletar

 No topo da lista são exibidos itens que correspondem aos símbolos já in-
cluídos.
Estes itens são novamente priorizados de acordo com a sua frequência
de utilização, isto é, a seleção se adapta ao comportamento do utilizador.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 47 / 251


Programação do robô 2

 Se necessário, um item pode ser marcado na lista e aceito no texto do pro-


grama através da tecla Enter.
Isso torna desnecessário, por exemplo, sempre ter de se digitar nomes de
variáveis complexas.

Navegação na lista Completar:


Rolar
Ou: Digitar as letras iniciais do item desejado. A marcação pula para
lá.

Snippets – Intro- Descrição


dução rápida para  Para instruções KRL usuais está disponível uma introdução rápida no edi-
instruções KRL tor KRL.
 Quando, p.ex., se deseja programar um loop FOR, não é necessário inse-
rir a sintaxe completa FOR … = … TO … STEP ….
 Em vez disso, seleciona-se a instrução a partir da lista Completar.
 Agora basta preencher manualmente as posições variáveis da sintaxe.
Procedimento
1. Quando se começa a digitar o código, a lista Completar aparece.
Na lista Completar, aceitar a instrução marcada com a tecla Enter. Ou cli-
car duas vezes em outra instrução.

Fig. 1-59: Aplicar com a tecla Enter ou dar um duplo clique

2. A sintaxe KRL é inserida automaticamente. A primeira posição variável


tem fundo azul Introduzir o valor desejado.

Fig. 1-60: A primeira posição variável tem fundo azul

3. Saltar para a próxima posição variável com a tecla TAB. Introduzir o valor
desejado.
4. Repetir o passo 3 para todas as posições variáveis.
5. Para encerrar a edição, pressionar a tecla Enter.
Aternativas
1. A lista de fragmentos também pode ser acessadas de outra forma: Clicar
o botão direito e no menu de contexto selecionar a entrada Inserir frag-
mento.
2. Além disso, pode-se inserir o fragmento conforme segue: Digitar a abre-
viatura e pressionar a tecla TAB.

48 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

3. (As abreviaturas podem ser determinadas, acessando-se a lista com os


fragmentos. Marcar a instrução. Abre-se uma sugestão de ferramenta. A
2ª linha contém as abreviaturas possíveis.)

Correção Descrição
Quickfix  Ondas sob o código e marcas na barra de análise indicam erros ou incon-
sistências no código.
Procedimento
 Para o caso de alguns erros/discrepâncias é oferecida uma correção au-
tomática, o "Quickfix".
 Uma luzinha Quickfix aparece.

Fig. 1-61: Luzinha Quickfix

 Através do botão de seta ao lado da luzinha, o usuário pode exibir várias


soluções diferentes e selecionar uma.

Corrigir variável Variáveis não declaradas são exibidas conforme segue:


não declarada ou  No código por meio de uma onda vermelha
declarar automa-
 Na barra de análise através de uma linha vermelha
ticamente
 Exceções:
 No entanto, a cor vermelha também pode alertar sobre outros erros.
 Quando se trata de uma variável não declarada, a seguinte sugestão
de ferramenta é exibida com um mouseover sobre a onda/linha:
A declaração das variáveis [nome] não foi encontrada.
Procedimento:
1. Colocar o cursor no nome marcado com a onda ou diretamente antes da
primeira letra ou diretamente após a última.

Fig. 1-62: variável não declarada

Ou: Clicar sobre a linha na barra de análise.


Ao lado dos nomes das variáveis aparecerá uma luzinha Quickfix.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 49 / 251


Programação do robô 2

2. Confirmar se o nome da variável não foi escrito incorretamente por enga-


no (de forma diferente da declaração).
 Caso positivo: Corrigir A onda/linha vermelha desaparece. Nenhuma
outra etapa é necessária!
 Caso negativo: Prossiga com a próxima etapa.
3. Mover o ponteiro do mouse sobre a luzinha Quickfix. Ao lado da luzinha
aparecerá uma seta.
Clicar na seta. As seguintes opções são exibidas:

Fig. 1-63: Declarar a variável

 Declarar a variável no local


 Declarar a variável na lista de dados
4. Clicar sobre a opção desejada.
5. Somente Declarar a variável na lista de dados: Abre-se a página de dados.
A pasta BASISTECH EXT é aberta.
6. Um fragmento para a declaração variável foi inserido automaticamente. O
suposto tipo de dados é realçado em azul. Após a declaração segue-se o
comentário: ; Esta variável é para ....

Fig. 1-64: variável declarada automaticamente na lista .dat

 Manter ou alterar o tipo de dados, conforme necessário.


 Com a tecla TAB, pular para o comentário. Editar o comentário con-
forme necessário.

Este comentário é exibido na sugestão de ferramenta da lista Com-


pletar quando a variável é marcada ali.

50 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Não excluir Descrição


variáveis usadas  Variáveis não utilizadas são exibidas conforme segue:
 No código por meio de uma onda azul
 Na barra de análise através de uma linha azul
 Um mouseover sobre a onda ou sobre a linha exibe uma sugestão de fer-
ramenta com uma descrição.
Procedimento
1. Colocar o cursor no nome marcado com a onda ou diretamente antes da
primeira letra ou diretamente após a última.
Ou: Clicar sobre a linha na barra de análise.
Ao lado dos nomes das variáveis aparecerá uma luzinha Quickfix.
2. Mover o ponteiro do mouse sobre a luzinha Quickfix. Ao lado da luzinha
aparecerá uma seta.

Fig. 1-65: Remover ou descomentar a variável

Clicar na seta. As seguintes opções são exibidas:


 Remover a declaração
 Descomentar a declaração
3. Clicar sobre a opção desejada.

Exibir variáveis Pular para a declaração de uma variável


1. Colocar o cursor no nome da variável, ou diretamente antes da primeira
letra ou diretamente após a última.
2. Clicar com o botão direito e no menu de contexto selecionar Ir para a de-
claração.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 51 / 251


Programação do robô 2

Fig. 1-66: Menu - botão direito do mouse

3. O cursor marca o nome da variável na seção de declaração.


No exemplo:
...
DECL INT counter
...

Exibir todas as utilizações de uma variável


1. Somente quando a janela Localizar utilizações ainda não for exibida:
Selecionar a sequência de menu Janela > Localizar utilizações.
2. Colocar o cursor no nome da variável, ou diretamente antes da primeira
letra ou diretamente após a última.
3. Clicar com o botão direito e selecionar o menu de contexto Localizar uti-
lizações. Ver também: (>>> Fig. 1-66 )
Na janela Localizar utilizações aparece uma guia com o nome Aplica-
ções de [nome da variável]. Todas as aplicações são listadas ali de forma
detalhada (dados com caminho, números de linhas , etc.)

Fig. 1-67: Filtro Utilização

4. Se necessário: Clicar duas vezes sobre uma linha na lista. A posição cor-
respondente será marcada no programa.

52 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

Por exemplo, pode-se Alterar o nome.

Trabalhar com Descrição


pastas  O conteúdo do editor KRL pode ser estruturado com pastas também como
um programa KRL normal.
 Os programas podem ser estruturados de forma mais compreensível com
este método.
Abrir uma pasta
 Dar um duplo clique na caixa da pasta fechada.
 Ou: Clicar no sinal de mais.
 A pasta é aberta.

Fig. 1-68: Pasta aberta

Fechar uma pasta


 Clicar no sinal de menos.
 A pasta é fechada.

Fig. 1-69: Pasta fechada

Abrir ou fechar todas as pastas


 Menu de contexto: Pastas > Abrir todas ou Fechar todas

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 53 / 251


Programação do robô 2

1.4 Exercício: Editar um projeto ativo no WorkVisual

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Conectar um PC com WorkVisual 3.x instalado com a interface KSI da uni-
dade de comando.
 Carregar um projeto ativo no WorkVisual.
 Criar um novo programa KRL no WorkVisual.
 Transmitir e ativar o projeto atualizado na unidade de comando.

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 É necessário um PC com WorkVisual 3.x instalado.
 Conhecimentos teóricos sobre a gestão de projeto com WorkVisual

Definição de  Conecte o PC com o WorkVisual 3.x à KSI - KUKA Service Interface do ar-
funções mário de comando.
 Carregue o projeto ativo da unidade de comando no WorkVisual.
 Crie um novo programa com o nome my1prog.
 Crie um comentário entre os dois conjuntos de movimentos PTP HOME.
 Gere a estrutura de dados específica de projeto com o botão Gerar có-

digo .

 Instale o projeto com o botão Instalar projeto na unidade de coman-


do.
 Ative este projeto.
 Verifique se o seu novo programa criado está disponível na unidade de
comando.
O que você deve saber agora:
1.Quais interfaces podem ser usadas para a vinculação de um PC WorkVisual
à unidade de comando?
.............................................................
.............................................................
2. Quais projetos especiais existem na unidade de comando?
.............................................................
.............................................................
.............................................................
3. Quais modos de WorkVisual estão disponíveis e como eles são utilizados?
.............................................................
.............................................................
4.Quais templates devem ser ativados para a programação KRL?
.............................................................
.............................................................
5. Onde podem ser criados novos programas KRL em programas WorkVisu-
al?
.............................................................
.............................................................

54 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


1 Programação com WorkVisual

6. Para o que são usados Snippets?


............................................................
............................................................

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 55 / 251


Programação do robô 2

56 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


2 Programação estruturada

2 Programação estruturada
2

2.1 Visão geral

Nesta unidade de aprendizagem são repassados os seguintes conteú-


dos:
 Metodologia de programação padronizada
 Recursos auxiliares para a criação de programas de robô estruturados
 Fluxograma do programa

2.2 Objetivo de um método de programação padronizado

Objetivo do Um método de programação padronizado serve para:


método de  dominar mais facilmente os problemas complexos com uma estrutura ri-
programação gorosamente desmembrada
padronizado  representar o procedimento básico de forma compreensível (sem ter co-
nhecimentos mais profundos de programação)
 aumentar a eficiência na manutenção, alteração e ampliação de progra-
mas
O planejamento antecipado do programa leva ao seguinte:
 definições de tarefas complexas podem ser divididas em tarefas simples
 o tempo total aplicado na programação é reduzido
 permite-se a intercambiabilidade dos componentes com o mesmo desem-
penho
 se podem desenvolver componentes separadamente
As 6 exigências para um programa do robô:
1. Eficiência
2. Ausência de erros
3. Compreensão
4. Facilidade de manutenção
5. Visibilidade
6. Economia

2.3 Recursos auxiliares para a criação de programas de robô estruturados

Qual é o sentido Comentários são complementos/notas dentro das linguagens de programa-


de um comen- ção. Todas as linguagens de programação consistem de instruções para o
tário? computador (código) e notas para os processadores de textos (comentários).
Se um texto fonte for processado (compilado, interpretado, etc.), os comentá-
rios são ignorados pelo software de processamento e não têm influência so-
bre o resultado.
Na unidade de comando KUKA são usados comentários de linhas, ou seja, os
comentários terminam automaticamente no final da linha.
Comentários por si só não podem tornar um programa legível, mas podem au-
mentar consideravelmente a legibilidade de programas bem estruturados.
Com os comentários, o programador tem a possibilidade de incluir notas, ex-
plicações no programa, sem que estas sejam registradas pela unidade de co-
mando como sintaxe.
O programador tem a responsabilidade de garantir que o conteúdo dos co-
mentários corresponda ao estado atual das orientações de programação. Em

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 57 / 251


Programação do robô 2

caso de alterações de programa também os comentários deverão ser verifi-


cados e, se necessário, adaptados.
O conteúdo de um comentário e, portanto, também a sua utilidade, pode ser
livremente selecionado pelo processador e não tem sintaxe obrigatória. Ge-
ralmente, comentários são registrados em linguagem "humana", na língua
materna do autor ou em uma língua de conveniência.
 Notas sobre o conteúdo ou a função de um programa
 Conteúdo ou utilidade são livremente selecionáveis
 Melhoram a legibilidade de um programa
 Contribuem para a estruturação de um programa
 A responsabilidade pela atualidade é do programador
 A KUKA usa comentários de linhas
 Os comentários não são registrados pela unidade de comando como sin-
taxe

Onde e quando Informações sobre todo o texto fonte:


são usados No início de um texto fonte o autor pode incluir comentários prévios, sob os
comentários? quais seguem a indicação do autor, da licença, da data de criação, do ende-
reço de contato para perguntas, uma lista de outros arquivos necessários, etc.
DEF PICK_CUBE()
;Este programa busca o cubo do magazine
;Autor: Max Mustermann
;Data de criação: 09.08.2011
INI
...
END

Classificação do texto fonte:


Títulos e parágrafos podem ser identificados como tal. Aqui muitas vezes não
são usados somente recursos linguísticos, mas também recursos gráficos,
que podem ser convertidos através de textos.
DEF PALLETIZE()
;*****************************************************
;*Este programa paletiza 16 cubos sobre a mesa*
;*Autor: Max Mustermann------------------------------*
;*Data de criação: 09.08.2011-----------------------*
;*****************************************************
INI
...
;------------Cálculo das posições----------------
...
;------------Paletização de 16 cubos---------------
...
;----------Despaletização de 16 cubos---------------
...
END

Explicação de uma única linha:


Assim, o modo de trabalho ou o significado de uma parte de texto (por exem-
plo, linha de programa) podem ser explicados, para que outros ou o próprio
autor possam compreender isso mais facilmente mais tarde.
DEF PICK_CUBE()

INI

58 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


2 Programação estruturada

SPTP HOME Vel=100% DEFAULT

SPTP Pre_Pos ; A posição prévia para a coleta é acessada

SLIN Grip_Pos ; Posição de coleta do cubo é acessada


...

END

Nota sobre trabalhos a serem executados:


Comentários podem identificar partes de código insuficientes ou ser variáveis
para partes de código faltantes.
DEF PICK_CUBE()

INI

;Aqui deve ser inserido ainda o cálculo das posições de paletes!

SPTP HOME Vel=100% DEFAULT

SPTP Pre_Pos ; A posição prévia para a coleta é acessada

SLIN Grip_Pos ; Posição de coleta do cubo é acessada

;Aqui falta ainda o fechamento da garra

END

Descomentário:
Se uma parte do código for excluído provisoriamente mas posteriormente
reinserido, ele será descomentado. A parte do código, depois de embalado no
comentário, no ponto de vista não é mais código, ou seja, já não existe mais.
DEF Palletize()

INI

PICK_CUBE()

;CUBE_TO_TABLE()

CUBE_TO_MAGAZINE()

END

Qual é o efeito do  Em PASTAS podem ser ocultadas partes do programa


uso de pastas em  Conteúdos de PASTAS não são visíveis para o usuário
um programa de  Conteúdos de PASTAS são processados normalmente na execução do
robô? programa
 Através do uso de pastas (folds) pode ser melhorada a legibilidade de um
programa

Que exemplos há Na unidade de comando KUKA já são usadas, como padrão, pastas pelo sis-
para o uso de tema, por exemplo, na exibição de formulários Inline. As pastas simplificam a
pastas? visibilidade dos valores introduzidos no formulário Inline, ocultando partes do
programa não relevantes para o operador.
Além disso, o usuário (a partir do grupo de usuários peritos) tem a possibili-
dade de criar pastas próprias. Essas pastas podem ser usadas pelo progra-
mador para, por um lado, comunicar ao operador algo que ocorre em um

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 59 / 251


Programação do robô 2

determinado local do programa, mas mantendo a verdadeira sintaxe KRL em


segundo plano.
Inicialmente as pastas em geral são exibidas fechadas após a sua criação.
DEF Main()
...
INI ; PASTA KUKA fechada

SET_EA ; PASTA criada pelo usuário fechada

SPTP HOME Vel=100% DEFAULT ; PASTA KUKA fechada

SPTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table


...
SPTP HOME Vel=100% Default

END

DEF Main()
...
INI ; PASTA KUKA fechada

SET_EA ; PASTA criada pelo usuário aberta


$OUT[12]=TRUE
$OUT[102]=FALSE
PART=0
Position=0

SPTP HOME Vel=100% DEFAULT ; PASTA KUKA fechada


...
SPTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table

SPTP HOME Vel=100% Default

END

DEF Main()
...
INI ; PASTA KUKA fechada

SET_EA ; PASTA criada pelo usuário fechada

; PASTA KUKA aberta


SPTP XHOME WITH $VEL_AXIS[1]= SVEL_JOINT( 100), $TOOL= STOOL2(
FHOME), $BASE= SBASE( FHOME.BASE_NO),
$IPO_MODE= SIPO_MODE( FHOME.IPO_FRAME), $LOAD= SLOAD( FHOME.TOOL_NO),
$ACC_AXIS[1]= SACC_JOINT( PDEFAULT),
$GEAR_JERK[1]= SGEAR_JERK( PDEFAULT)

...

SPTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table

SPTP HOME Vel=100% Default

END

Por que se Na programação, os subprogramas são utilizados especialmente para permi-


trabalha com a tir um uso múltiplo de partes de tarefas iguais e com isso, conseguir evitar as
técnica de repetições de códigos. Entre outros, isso economiza espaço de memória.
Outro motivo importante para a utilização de subprogramas é também a es-
subprogramas?

60 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


2 Programação estruturada

truturação do programa ocorrente através disso.


Um subprograma deve executar uma tarefa parcial finalizada em si e fácil de
se descrever.
Hoje em dia os subprogramas são preferencialmente curtos e compreensíveis
para favorecer uma melhor manutenção e eliminação de erros de programa-
ção. O dispêndio de tempo e de administração interno do computador para o
acesso de subprogramas praticamente é desprezível em computadores mo-
dernos.
 Uso múltiplo possível
 Evitar repetições de códigos
 Economia de espaço de memória
 Componentes podem ser desenvolvidos separadamente
 A troca de componentes da mesma potência é possível a qualquer mo-
mento
 Estruturação do programa
 Tarefa total dividida em tarefas parciais
 Melhor manutenção e correção dos erros de programação

Aplicação de DEF MAIN()


subprogramas
INI

LOOP

GET_PEN()
PAINT_PATH()
PEN_BACK()
GET_PLATE()
GLUE_PLATE()
PLATE_BACK()

IF $IN[1]== TRUE THEN


EXIT
ENDIF

ENDLOOP

END

O que provoca o Para mostrar a relação de componentes de programa, recomendamos fazer


recuo de linhas um recuo da margem em sequências de comandos encadeadas e escrever
de comando? instruções na mesma profundidade de encadeamento diretamente na se-
quência.
O efeito obtido é meramente visual, ele se refere somente ao valor de um pro-
grama como recurso de comunicação de pessoa para pessoa.
DEF INSERT()
INT PART, COUNTER
INI
SPTP HOME Vel=100% DEFAULT
LOOP
FOR COUNTER = 1 TO 20
PART = PART+1
;não é possível recuar formulários Inline!!!
SPTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table
PTP XP5 ; Movimento com KRL
ENDFOR
...

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 61 / 251


Programação do robô 2

ENDLOOP

O que se obtém Para interpretar corretamente a função de dados e sinais em um programa do


através de uma robô, recomendamos usar termos que fazem sentido na definição de nomes.
identificação A estes pertencem, p.ex.:
adequada de  Nomes de textos descritivos para sinais de entrada e de saída
nomes de dados?  Nomes de ferramentas e base
 Acordos de sinais para sinais de entrada e de saída
 Nomes de pontos

2.4 Como é elaborado um fluxograma do programa

O que é um PAP? Um fluxograma do programa (PAP) é um diagrama de execução para um pro-


grama que também é denominado de fluxograma ou plano de estrutura de
programa. É uma representação gráfica para a realização de um algoritmo em
um programa, descrevendo a consequência de operações para a solução da
tarefa. Os ícones para fluxogramas do programa seguem a norma DIN 66001.
Fluxogramas do programa muitas vezes são usados independente de progra-
mas de computador também para a representação de processos e atividades.
O algoritmo de programa é legível com maior facilidade em comparação com
uma descrição baseada em código, uma vez que a representação gráfica per-
mite um reconhecimento melhor da estrutura.
Erros de estrutura e de programação são facilmente reconhecidos em uma re-
alização posterior em códigos de programa, uma vez que o uso correto do
PAP permite uma realização direta em códigos de programação. Ao mesmo
tempo, com a criação de um PAP, obtém-se uma documentação do programa
a ser criado.
 Ferramenta para a estruturação da execução de um programa
 A execução de um programa é mais facilmente legível
 Erros estruturais podem ser reconhecidos com maior facilidade
 Documentação simultânea do programa

Ícones PAP Início ou fim de um processo ou programa

Fig. 2-1

Integração de instruções e operações

Fig. 2-2

Ramificação

62 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


2 Programação estruturada

Fig. 2-3

Instruções gerais no código de programa

Fig. 2-4

Acesso ao subprograma

Fig. 2-5

Instrução de entrada/saída

Fig. 2-6

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 63 / 251


Programação do robô 2

Exemplo PAP

Fig. 2-7

Como é Partindo da ideia do usuário o problema é detalhado passo a passo, até que
elaborado um os componentes elaborados sejam suficientemente visualizáveis, para poder
PAP realizá-los no KRL.
As minutas geradas nos passos subsequentes de desenvolvimento se destin-
guem pela crescente profundidade de detalhes.
1. Desmembramento grosseiro de todo o processo em aprox. 1 - 2 páginas
2. Divisão da tarefa total em diversas tarefas parciais
3. Classificação geral das tarefas parciais
4. Detalhamento da classificação das tarefas parciais
5. Transposição em código KRL

64 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


3 Introdução no nível de perito

3 Introdução no nível de perito


t

3.1 Visão geral

Nesta unidade de aprendizagem são repassados os seguintes conteú-


dos:
 Usar nível de perito

3.2 Usar nível de perito

Descrição A unidade de comando do robô oferece diferentes Grupos de usuários com


diferentes funções. Podem ser selecionados os seguintes Grupos de usuá-
rios:
 Operador
Grupo de usuários para o operador. Este é o grupo de usuários padrão.
 Usuário
Grupo de usuários para o operador. (Os grupos de usuários Operador e
Usuário são criados como padrão para o mesmo grupo-alvo.)
 Peritos
Grupo de usuários para o programador. O grupo de usuários é protegido
por uma senha.
 Administrador
Funções como no grupo de usuários Peritos. Além disso é possível a in-
tegração de plug-ins na unidade de comando do robô. O grupo de usuá-
rios é protegido por uma senha. A senha de fornecimento kuka deve ser
alterada.
 Técnico de manutenção de segurança
Este usuário pode ativar uma configuração de segurança existente do
robô através de um código de ativação. Se não for usada nenhuma opção
Safe-Option, p.ex. KUKA.SafeOperation ou KUKA.SafeRangeMonitoring,
o técnico de manutenção de segurança dispõe de direitos ampliados. Por
exemplo, ele está autorizado a configurar as funções de segurança pa-
drão. O grupo de usuários é protegido por uma senha. A senha de forne-
cimento kuka deve ser alterada.
 Colocador em funcionamento de segurança
Este grupo de usuários somente é relevante, se for usado KUKA.SafeO-
peration ou KUKA.SafeRangeMonitoring. O grupo de usuários é protegido
por uma senha. A senha de fornecimento kuka deve ser alterada.
Funções ampliadas do grupo de usuários Peritos:
 Protegido por senha (padrão: kuka)
 Programação no Editor é possível com KRL
 O grupo de usuários Peritos é abandonado automaticamente,
 ao mudar para o modo de operação AUT ou AUT EXT
 se durante um determinado período não houver ação na superfície do
usuário (300 s)

Como Perito, estão disponíveis todas as funções no menuEditar.

Funções Criar programas usando templates


 Cell: Programa de célula existente só pode ser substituído ou recriado
com célula excluída.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 65 / 251


Programação do robô 2

 Peritos: módulo existente no arquivo SRC e DAT, no qual só há cabeça-


lho e fim de programa.
 Expert Submit: arquivo Submit (SUB) adicional que consiste de cabeça-
lho e fim de programa.
 Function: elaboração de função SRC, na qual só é criado o cabeçalho da
função com uma variável BOOL O final da função existe, porém, o retorno
ainda deve ser programado.
 Módulo: módulo consiste dos arquivos SRC e DAT, no qual existe o ca-
beçalho do programa, o fim e a estrutura básica (INI e 2x PTP HOME).
 Submit: arquivo Submit (SUB) adicional que consiste de um cabeçalho e
fim de programa e estrutura básica (DECLARATION, INI, LOOP/ENDLO-
OP).

O Filtro determina como os programas são exibidos na lista de arquivos. Es-


tão disponíveis os seguintes Filtros:
 Cancelar programa ou fechar.
 Selecionar o botão Editar > Filtro e depois Detalhe ou Módulo
 Detalhe
Os programas são exibidos como arquivos SRC e DAT. (Ajuste predefini-
do)
 Módulos
Os programas são exibidos como módulos.

Fig. 3-1: Menu Editor

Abrir/Fechar PASTA
 As FOLDs estão sempre fechadas para o usuário e podem ser abertas
como perito.
 O perito também pode programar suas PASTAS próprias.

66 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


3 Introdução no nível de perito

 A sintaxe para uma pasta é:


;FOLD Nome
Instruções
;ENDFOLD <Nome>
As linhas ENDFOLD podem ser atribuídas com mais facilidade, se for in-
serido aqui o nome da pasta. As pastas (Folds) podem ser encadeadas.
Exibir e ocultar Linha DEF
 A Linha DEF é ocultada por defeito. Em um programa só podem ser rea-
lizadas declarações, quando a Linha DEF é exibida.
 A Linha DEF é exibida e ocultada separadamente para programas aber-
tos e selecionados. Se a vista detalhada estiver ativada, a Linha DEF tor-
na-se visível e não precisa ser exibida separadamente.

Ativar procedi- Ativar nível de Peritos


mento para nível 1. Selecionar o menu principal Configuração > Grupo de usuários.
de Perito e
2. Login como Peritos: Clicar em Login. Marcar o grupo de usuários Peritos
corrigir erros e confirmar com Login.
3. Inserir a senha requerida (padrão: kuka) e confirmar com Login.
Eliminar erros no programa.
1. Selecionar módulo com erro no Navegador

Fig. 3-2: Programa com erro

2. Selecionar menu Lista de erros


3. A exibição de erros (nome de programa.ERR) abre
4. Selecionar erros, a descrição ampla é apresentada em baixo na exibição
de erros
5. Na janela exibição de erros pressionar a tecla Exibir e saltar para o pro-
grama com defeitos
6. Corrigir erros
7. Fechar editor e salvar

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 67 / 251


Programação do robô 2

3.3 Exercício: Medição de ferramentas e base

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Medição da ferramenta com o método XYZ 4-Pontos e o método World 5D
 Medição da ferramenta com introdução numérica de valor
 Medição da base conforme o método 3 pontos

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos teóricos sobre a medição de uma ferramenta
 Conhecimentos teóricos sobre a medição de uma base

Função: Intro- Introduza para a sua garra de treinamento com introdução numérica:
dução de dados
de ferramenta de
garra

Fig. 3-3: College garra: Posição do TCP

 Garra de treinamento KR 16

Fig. 3-4: Garra de treinamento KR 16

68 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


3 Introdução no nível de perito

Massa:
M = 4,3 kg
Centro de gravidade da massa:
X = 41 mm Y = 35 mm Z = 62 mm
Orientação:
A = 0° B = 0° C = 0°
Momentos de inércia:
JX = 0,03 kgm2 JY = 0,04 kgm2 JZ = 0,12 kgm2

Canto direito da garra


X Y Z
122,64 mm 177,73 mm 172,49 mm
A B C
45 0 180

 Garra de treinamento Célula modular

Fig. 3-5: Garra de treinamento Célula modular

Massa:
M = 4,4 kg
Centro de gravidade da massa:
X = 7 mm Y = -24 mm Z = 80 mm
Orientação:
A = 0° B = 0° C = 0°
Momentos de inércia:
JX = 0,02 kgm2 JY = 0,05 kgm2 JZ = 0,11 kgm2

Canto direito da garra


X Y Z
175,38 mm -123,97 mm 172,71 mm
A B C
-45 0 -180

 Garra de treinamento Célula móvel

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 69 / 251


Programação do robô 2

Fig. 3-6: Garra de treinamento Célula móvel

Massa:
M = 2 kg
Centro de gravidade da massa:
X = 23 mm Y = 0 mm Z = 61 mm
Orientação:
A = 0° B = 0° C = 0°
Momentos de inércia:
JX = 0,002 kgm2 JY = 0,004 kgm2 JZ = 0,003 kgm2

Canto direito da garra


X Y Z
12 mm 0 mm 77 mm
A B C
0 0 0

Definição de Medição de pino


funções  Use o pino superior do magazine de pinos e fixe-o manualmente na garra.
 Meça o pino com o método XYZ 4-Pontos e o método ABC-World 5D.
 Como número de ferramenta use o 2 e como nome "Pino 1"
 Use para isto os dados de carga da ferramenta do pino apresentados
abaixo.
Medição "base azul"
 A medição da BASE número 2 é realizada com o pino 1 e o método 3 pon-
tos. Como nome é usado "base azul".

Dados de carga  Garra de treinamento KR 16


da ferramenta de
garra com pino

70 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


3 Introdução no nível de perito

Fig. 3-7: Garra de treinamento KR 16

Massa:
M = 4,9 kg
Centro de gravidade da massa:
X = 53 mm Y = 49 mm Z = 65 mm
Orientação:
A = 0° B = 0° C = 0°
Momentos de inércia:
JX = 0,02 kgm2 JY = 0,03 kgm2 JZ = 0,15 kgm2

 Garra de treinamento Célula modular

Fig. 3-8: Garra de treinamento Célula modular

Massa:
M = 5 kg
Centro de gravidade da massa:
X = 23 mm Y = -38 mm Z = 84 mm
Orientação:
A = 0° B = 0° C = 0°
Momentos de inércia:
JX = 0,02 kgm2 JY = 0,07 kgm2 JZ = 0,14 kgm2

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 71 / 251


Programação do robô 2

 Garra de treinamento Célula móvel

Fig. 3-9: Garra de treinamento Célula móvel

Massa:
M = 2,14 kg
Centro de gravidade da massa:
X = 30 mm Y = 0 mm Z = 64 mm
Orientação:
A = 0° B = 0° C = 0°
Momentos de inércia:
JX = 0,002 kgm2 JY = 0,004 kgm2 JZ = 0,003 kgm2

O que você deve saber agora:


1. Quais são as vantagens da medição de uma base sobre a mesa?
.............................................................
.............................................................
2. Onde está o ponto de referência para a medição de uma ferramenta?
.............................................................
.............................................................
3. Quantos sistemas base diferentes o software KUKA comporta?
.............................................................
.............................................................
4. Qual é a diferença entre os métodos ABC-World 5D e 6D?
.............................................................
.............................................................
5. Onde há uma base não medida (estado de fornecimento)?
.............................................................
.............................................................

72 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


3 Introdução no nível de perito

3.4 Exercício: Navigator perito loop sem fim

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Criação de módulos no plano de perícia
 Vínculo de determinados módulos em um programa principal
 Uso de um loop sem fim

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos teóricos sobre o Navigator no plano de peritos
 Conhecimentos teóricos sobre o uso de subprogramas globais
 Conhecimentos teóricos sobre um loop sem-fim

Definição de 1. Antes do início da programação elabore um fluxograma do programa


funções (PAP).
2. Crie dois módulos sensatos (Cubos_dep./Cubos_busc.).
3. O acesso e o loop sem-fim deverão ser realizados no módulo MAGAZINE.
4. Teste o seu programa nos modos de operação T1, T2 e Automático. Aqui
devem ser observadas as prescrições de segurança ensinadas.
O que você deve saber agora:
1. Na criação de um programa, qual é a diferença entre a seleção MODUL e
EXPERT?
............................................................
............................................................
............................................................
............................................................
............................................................
2. O que se entende por tipo de execução do programa Passo individual?
............................................................
............................................................
3. Qual a diferença entre SELECIONAR e ABRIR um programa?
............................................................
............................................................
............................................................
4. Como é a sintaxe para uma "dobra"?
............................................................
............................................................
5. Quais são as consequências de uma alteração posterior da posição HO-
ME?
............................................................
............................................................

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 73 / 251


Programação do robô 2

74 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


4 Variáveis e acordos

4 Variáveis e acordos
4

4.1 Visão geral


v

Nesta unidade de aprendizagem são repassados os seguintes conteú-


dos:
 Manutenção de dados no KRL
 Tipos de dados simples com KRL
 Exibir variáveis
 Arrays/Campos com KRL
 Estruturas com KRL
 Tipo de dados de enumeração ENUM

4.2 Manutenção de dados no KRL

Dados gerais
sobre variáveis

Fig. 4-1: Identificação de variáveis

 Na programação do robô com KRL, uma variável no sentido mais geral é


simplesmente um recipiente para dimensões de cálculo ("valores") que
ocorrem na execução processo do robô.
 Uma variável tem um determinado endereço atribuído na memória do
computador.
 Uma variável é determinada com um nome, que não seja a palavra-chave
da KUKA.
 Cada variável é vinculada a um determinado tipo de dados
 A declaração do tipo de dados é necessária antes do uso.
 Em KRL há diferenciação entre variáveis locais e globais.

Convenções de Na escolha do nome da variável devem ser observadas as seguintes regras:


nomes  Nomes em KRL só podem ter um comprimento máximo de 24 caracteres.
 Nomes em KRL podem conter letras (A-Z), números (09) e os caracteres
especiais '_' e '$',
 Nomes em KRL não podem começar com números.
 Nomes em KRL não podem ser palavras-chave.
 Letras maiúsculas e minúsculas não são relevantes.
Dicas
 Usar nomes de variáveis adequadas, auto-explicativas.
 Não colocar nomes criptografados ou abreviações.
 Usar comprimentos de nome adequados, ou seja, não usar sempre 24 ca-
racteres.

Declarações  Uma declaração dupla ocorre sempre na utilização de nomes de variáveis


duplas de iguais (sequências de caracteres).
variáveis  Não se trata de nenhuma declaração dupla quando em diferentes arqui-
vos *.SCR ou *.DAT for usado o mesmo nome.
 Declarações duplas no mesmo arquivo *.SCR e *.DAT não são permitidas
e geram uma mensagem de erro.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 75 / 251


Programação do robô 2

 Declarações duplas no arquivo *.SCR ou *.DAT e na $CONFIG.DAT são


permitidas:
 No processo da rotina do programa, no qual a variável foi declarada,
é alterado somente o valor local e não o valor no $CONFIG.DAT.
 Na execução de uma rotina de programa "estranha" é acessado e al-
terado somente o valor de $CONFIG.DAT.

Tipos de dados  Tipos de dados pré-definidos


no KRL  BOOL: resultados clássicos "SIM"/"NÃO"
 REAL: número com vírgula flutuante, resultado de operações de cál-
culo, para poder evitar erros de arredondamento
 INT: número inteiro, variável de contagem clássica para loops de con-
tagem ou contadores de unidades
 CHAR: somente um caracter
String ou texto só pode ser realizado como campo CHAR

Número com Determin


Tipos de dados Número Valores
vírgula ado
simples inteiro lógicos
alterável caractere
Palavra chave INT REAL BOOL CHAR
Faixa de valores -231 ... ± 1.1 10-38... ± TRUE / Conjunto
FALSE de carac-
(231-1) 3.4 10+38
teres
ASCII
Exemplos -199 ou -0,0000123 ou TRUE ou "A" ou "q"
56 3,1415 FALSE ou "7"

 Campos /Array
Voltage[10] = 12.75
Voltage[11] = 15.59

 Salvar diversas variáveis do mesmo tipo de dados com índice


 na inicialização ou alteração de valor deve ser indicado o index
 O tamanho máximo do campo depende da necessidade de memória
do tipo de dados
 Tipo de dados de contagem
color = #red

 Todos os valores do tipo de dados de enumeração são definidos com


nomes (texto explícito) na criação
 O sistema define ainda a sequência
 O número máximo de elementos depende da memória
 Tipo de dados composto /estrutura
Date = {day 14, month 12, year 1996}

 Tipo de dados composto de componentes de diversos tipos de dados


 Os componentes podem consistir de tipos de dados simples mas tam-
bém de estruturas
 Um acesso a determinados componentes é possível

Criação de Declaração de variáveis


variáveis  a declaração deve ocorrer sempre antes do uso.
 a cada variável deve ser atribuído um tipo de dados.
 na atribuição do nome devem ser observadas as convenções de nomes.
 a palavra chave para a declaração é DECL.

76 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


4 Variáveis e acordos

 a palavra chave DECL pode ser suprimida nos quatro tipos de dados sim-
ples.
 As atribuições de espera ocorrem no avanço.
 a declaração de variável pode ocorrer em diferentes pontos. Isto se reflete
na vida útil e na validade das respectivas variáveis.

Vida útil e Vida útil de variáveis em KRL


validade de  Por vida útil entende-se um período, no qual está reservado um espaço
variáveis de memória para a variável.
 A variável de vida útil libera a sua memória ao sair do programa ou da fun-
ção.
 Variáveis em uma lista de dados mantêm o seu valor atual (último) de for-
ma permanente em seu espaço de memória.
Validade de variáveis em KRL
 Variáveis declaradas localmente somente estão disponíveis e visíveis no
programa no qual foram declaradas.
 Variáveis globais estão criadas em uma lista de dados central (global).
 Variáveis globais também podem ser criadas em uma lista de dados local
e providas da palavra chave global na declaração.

Declaração de Variável no *.SRC-File


variáveis em  Uma variável que é criada no *.SRC-File chama-se variável de tempo de
dependência do execução.
local de memória  Esta não pode mais ser exibida.
 Ela somente está disponível na rotina de programa, na qual ela foi decla-
rada. Assim a variável está disponível durante a execução do programa.
(Programa principal ou subprograma local).
 Ela libera novamente o seu espaço de memória ao alcançar a última linha
do programa (linha END).
Variável no *.DAT-File local
 pode ser exibida sempre durante a execução do programa do respectivo
*.SRC-File,
 o valor da variável é mantido após a finalização do programa,
 está disponível no *.SRC-File completo, portanto, também no subprograma
local,
 também pode ser criada como variável global,
 contêm o valor atual no *.DAT-File e inicia com o valor salvo em caso de
novo acesso.
 Se a variável é declarada como global, ela também está disponível de for-
ma global. Em todas as rotinas de programa é possível um acesso de lei-
tura e escrita se o DAT-File for usado com a palavra chave PUBLIC e na
declaração, adicionalmente, com a palavra chave GLOBAL.
Variável no arquivo de sistema $CONFIG.DAT
 está disponível em todos os programas (global),
 pode ser exibida sempre, mesmo que não haja nenhum programa ativa-
do,
 está disponível de forma global, ou seja, em todas as rotinas de programa
é possível um acesso de leitura e escrita,
 salva o valor atual no $CONFIG.DAT.

Dados de sistema  Os dados de sistema KUKA ocorrem em todos os tipos de dados, por
KUKA exemplo, como
 tipo de dados de contagem, como p.ex. modo de operação

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 77 / 251


Programação do robô 2

 estrutura como, p.ex., data/hora


 Informações de sistema são obtidas das variáveis de sistema KUKA. Es-
tas
 leem as informações de sistema atuais,
 alteram as configurações de sistema atuais,
 são predefinidas e começam com o caractere "$"
 $DATE (horário e data atual)
 $POS_ACT (posição atual do robô)
 $MODE_OP(modo de operação atual)
 ...

4.3 Trabalhar com tipos de dados simples

A seguir é explicada a elaboração, inicialização e a alteração de variáveis.


Aqui são usados somente tipos de dados simples.
Tipos de dados simples com KRL
 Números inteiros (INT)
 Números de vírgula variável (REAL)
 Valores lógicos (BOOL)
 Caracter individual (CHAR)

4.3.1 Declaração de variáveis

Princípio da Estrutura de programa no exemplo SRC-File


declaração de  Na parte de declaração deverão ser declaradas variáveis
variáveis
 A parte de inicialização inicia com a primeira atribuição de valores, em ge-
ral com a linha "INI"
 Na parte de instruções os valores são atribuídos ou alterados
DEF main( )
; Seção de declaração
...
; Seção de inicialização
INI
...
; Seção de instrução
PTP HOME Vel=100% DEFAULT
...
END

Modificar vista padrão


 Apenas peritos podem exibir a linha DEF.
 O procedimento é necessário para chegar à parte de declaração em mó-
dulos antes da linha "INI"
 Para poder visualizar as linhas DEF e END, importante também para a
transferência de variáveis em subprogramas
Planejar declaração de variáveis
 Definir vida útil
 Definir validade/disponibilidade
 Definir tipo de dados
 Atribuição de nome e declaração

78 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


4 Variáveis e acordos

Procedimento na Criar variável no SRC-File


declaração de 1. Grupo de usuários Peritos
variáveis com
2. Deixar exibir linha DEF
tipos de dados
3. Abrir o SRC-File no Editor
simples
4. Realizar a declaração da variável
DEF MY_PROG ( )
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol
INI
...
END

5. Fechar e salvar programas


Criar variável no DAT-File
1. Grupo de usuários Peritos
2. Abrir DAT-File no Editor
3. Realizar a declaração da variável
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol
...
ENDDAT

4. Fechar e salvar lista de dados


Criar variável na $CONFIG.DAT
1. Grupo de usuários Peritos
2. Na pasta SYSTEM abrir o $CONFIG.DAT no Editor
DEFDAT $CONFIG
BASISTECH GLOBALS
AUTOEXT GLOBALS
USER GLOBALS
ENDDAT

3. Selecionar a pasta "USER GLOBALS" e abri-la com o softkey "Abr/Fech


pasta"
4. Realizar a declaração da variável
DEFDAT $CONFIG
...
;==================================
; Userdefined Types
;==================================
;==================================
; Userdefined Externals
;==================================
;==================================
; Userdefined Variables
;==================================
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 79 / 251


Programação do robô 2

...
ENDDAT

5. Fechar e salvar lista de dados


Criar variável global no DAT-File
1. Grupo de usuários Peritos
2. Abrir DAT-File no Editor
3. Ampliar a lista de dados no cabeçalho do programa com a palavra-chave
PUBLIC
DEFDAT MY_PROG PUBLIC

4. Realizar a declaração da variável


DEFDAT MY_PROG PUBLIC
EXTERNAL DECLARATIONS
DECL GLOBAL INT counter
DECL GLOBAL REAL price
DECL GLOBAL BOOL error
DECL GLOBAL CHAR symbol
...
ENDDAT

5. Fechar e salvar lista de dados

4.3.2 Inicialização de variáveis com simples tipos de dados

Descrição da  Após a declaração uma variável reservou apenas um espaço de memória,


inicialização com o seu valor é sempre um valor inválido.
KRL  No SRC-File é realizada a declaração e a inicialização sempre em duas
linhas separadas.
 No DAT-File é realizada a declaração e a inicialização sempre em uma li-
nha.
Uma constante somente pode ser declarada em uma lista de dados e
deve ser imediatamente instalada lá.
 A seção de inicialização inicia com a primeira atribuição de valor.

Princípio da Inicialização de números inteiros


inicialização  Inicialização de decimais
value = 58

 Inicialização como número binário


value = 'B111010'

Cálculo: 1*32+1*16+1*8+0*4+1*2+0*1 = 58

Binário 25 24 23 22 21 20
Dez 32 16 8 4 2 1

 Inicialização hexadecimal
value = 'H3A'

Cálculo: 3*16 +10 = 58

Hex 0 1 2 3 4 5 6 7 8 9 A B C D E F
Dez 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

80 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


4 Variáveis e acordos

Procedimento na Declaração e inicialização no SRC-File


inicialização com 1. Abrir o SRC-File no Editor
KRL
2. A declaração foi retornada
3. Realizar inicialização
DEF MY_PROG ( )
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol
INI
counter = 10
price = 0.0
error = FALSE
symbol = "X"
...
END

4. Fechar e salvar programas


Declaração e inicialização no DAT-File
1. Abrir DAT-File no Editor
2. A declaração foi retornada
3. Realizar inicialização
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL INT counter = 10
DECL REAL price = 0.0
DECL BOOL error = FALSE
DECL CHAR symbol = "X"
...
ENDDAT

4. Fechar e salvar lista de dados


Declaração no DAT-File e inicialização no SRC-File
1. Abrir DAT-File no Editor
2. Realizar declaração
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol
...
ENDDAT

3. Fechar e salvar lista de dados


4. Abrir o SRC-File no Editor
5. Realizar inicialização
DEF MY_PROG ( )
...
INI
counter = 10
price = 0.0
error = FALSE
symbol = "X"
...
END

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 81 / 251


Programação do robô 2

6. Fechar e salvar programas

Declaração e Descrição
inicialização de  Constantes são criadas com a palavra chave CONST.
uma constante
 Constantes só podem ser criadas em listas de dados.
Criação de constantes
1. Abrir DAT-File no editor.
2. Realizar declaração e inicialização.
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL CONST INT max_size = 99
DECL CONST REAL PI = 3.1415
...
ENDDAT

3. Fechar e salvar lista de dados.

4.3.3 Manipulação de valores de variáveis de tipos de dados simples com KRL

Listagem de Os valores de variáveis são alterados de forma distinta de acordo com a de-
possibilidades finição de funções nas rotinas de programa (SRC-File) conforme a tarefa. A
para a alteração seguir são abordados os métodos mais comuns. A manipulação com opera-
ções bit e funções padrão é possível, mas não será detalhada.
de valores de
variáveis com Manipulação de dados através de
KRL  Tipos de cálculo básico
 (+) Adição
 (-) Subtração
 (*) Multiplicação
 (/) Divisão
 Operações comparativas
 (==) idêntico / igualdade
 (<>) desigual
 (>) maior
 (<) menor
 (>=) maior ou igual
 (<=) menor ou igual
 Operações lógicas
 (NOT) Inversão
 (AND) (E) lógico
 (OR) OU lógico
 (EXOR)OU exclusivo
 Operações Bit
 (B_NOT) Inversão de bit
 (B_AND) vinculação E de bits
 (B_OR) vinculação OU de bits
 (B_EXOR) vinculação OU exclusiva de bits
Funções padrão
 Função absoluta
 Função de raiz
 Função seno e coseno

82 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


4 Variáveis e acordos

 Função tangente
 Função arco seno
 Função arco tangente
 Diversas funções para a manipulação de strings

Contextos na Modificação de valores usando os tipos de dados REAL e INT


manipulação de  Arredondar para cima/ para baixo
dados
; Declaração
DECL INT A,B,C
DECL REAL R,S,T
; Inicialização
A = 3 ; A=3
B = 5.5 ; B=6 (a partir de x.5 é arredondado para cima)
C = 2.25 ; C=2 (arredondar para baixo)
R = 4 ; R=4.0
S = 6.5 ; S=6.5
T = C ; T=2.0 (aplica-se o valor arredondado para baixo)

 Resultados de operações aritméticas (+;-;*)

Operandos INT REAL


INT INT REAL
REAL REAL REAL

; Declaração
DECL INT D,E
DECL REAL U,V
; Inicialização
D = 2
E = 5
U = 0.5
V = 10.6
; Seção de instrução (manipulação de dados)
D = D*E ; D = 2 * 5 = 10
E = E+V ; E= 5 + 10.6 = 15.6 -> arredondar para cima E=16
U = U*V ; U= 0.5 * 10.6 = 5.3
V = E+V ; V= 16 + 10.6 = 26.6

 Resultados de operações aritméticas (/)


Particularidades das operações aritméticas com valores inteiros:
 Nos resultados intermediários de meras operações íntegras, todas as
casas após a vírgula são cortadas.
 Nas atribuições de valores para uma variável íntegra o resultado é ar-
redondado conforme as regras normais de cálculo.
; Declaração
DECL INT F
DECL REAL W
; Inicialização
F = 10
W = 10.0
; Seção de instrução (manipulação de dados)
; INT / INT -> INT
F = F/2 ; F=5
F = 10/4 ; F=2 (10/4 = 2.5 -> Cortar a casa decimal)
; REAL / INT -> REAL

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 83 / 251


Programação do robô 2

F = W/4 ; F=3 (10.0/4=2.5 -> arredondar para cima)


W = W/4 ; W=2.5

Operações comparativas
Com operações comparativas podem ser formadas expressões lógicas O re-
sultado de uma comparação é sempre o tipo de dados BOOL.

Operador/
Descrição Tipos de dados admissíveis
KRL
== idêntico/igual- INT, REAL, CHAR, BOOL
dade
<> desigual INT, REAL, CHAR, BOOL
> maior INT, REAL, CHAR
< menor INT, REAL, CHAR
>= maior igual INT, REAL, CHAR
<= menor igual INT, REAL, CHAR

; Declaração
DECL BOOL G,H
; Inicialização/Seção de instrução
G = 10>10.1 ; G=FALSE
H = 10/3 == 3 ; H=TRUE
G = G<>H ; G=TRUE

Operações lógicas
Com operações lógicas podem ser formadas expressões lógicas. O resultado
dessa operação é sempre o tipo de dados BOOL.

A EXOR
Operações NOT A A AND B A OR B
B
A=FALSE B=FALSE TRUE FALSE FALSE FALSE
A=FALSE B=TRUE TRUE FALSE TRUE TRUE
A=TRUE B=FALSE FALSE FALSE TRUE TRUE
A=TRUE B=TRUE FALSE TRUE TRUE FALSE

; Declaração
DECL BOOL K,L,M
; Inicialização/Seção de instrução
K = TRUE
L = NOT K ; L=FALSE
M = (K AND L) OR (K EXOR L) ; M=TRUE
L = NOT (NOT K) ; L=TRUE

Operadores são executados na sequência de suas prioridades

Prioridade Operador
1 NOT (B_NOT)
2 Multiplicação (*); Divisão (/)
3 Adição (+), Subtração (-)
4 AND (B_AND)
5 EXOR (B_EXOR)

84 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


4 Variáveis e acordos

Prioridade Operador
6 OR (B_OR)
7 qualquer comparação (==; <>; ...)

; Declaração
DECL BOOL X, Y
DECL INT Z
; Inicialização/Seção de instrução
X = TRUE
Z = 4
Y = (4*Z+16 <> 32) AND X ; Y=FALSE

Procedimento na 1. Definir tipo de dados para a(s) variável(eis)


manipulação de 2. Calcular a validade e vida útil das variáveis
dados 3. Realizar a declaração das variáveis
4. Inicializar a variável
5. Nas rotinas de programa, ou seja, sempre no arquivo *.SRC, manipular a
variável
6. Fechar e salvar o arquivo *.SRC

Comando PARAR PARAR é utilizado principalmente durante a fase de programação para fins de
teste. Por exemplo, para levar à exibição o conteúdo de uma variável de tem-
po de execução.
 O comando PARAR para o programa. Contudo, a última instrução de mo-
vimento percorrida ainda é executada por completo.
 O programa somente pode ser continuado com a tecla Iniciar. Depois é
executada a próxima instrução após PARAR.

Em um programa Interrupt o programa somente é parado após a exe-


cução completa do avanço.

Exemplo:
DEF program()
DECL BOOL a,b
INI
...
SPTP XP1
a=$IN[1]
b=$IN[2]
HALT
IF ((a == TRUE) AND (b == FALSE)) THEN
..
ENDIF
...

4.4 Exibir variáveis

Exibir e alterar o 1. No menu principal, selecionar Exibir > Variável > Individual.
valor de uma Abre-se a janela Display de variáveis - individual.
variável 2. No campo Nome introduzir o nome da variável.
3. Quando um programa está selecionado, no campo Módulo está inserido
automaticamente o programa.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 85 / 251


Programação do robô 2

Caso deva ser exibida uma variável de outro programa, introduzir o pro-
grama como a seguir:
/R1/Nome de programa
Não especificar nenhuma pasta entre /R1/ e o nome de programa. Não
especificar nenhuma extensão de arquivo no nome de programa.
4. Pressionar a tecla Enter.
No campo Valor atual é exibido o valor atual das variáveis. Se nada for
exibido, ainda não foi atribuído nenhum valor às variáveis.
5. No campo Novo valor digitar o valor desejado.
6. Pressionar a tecla Enter.
No campo Valor atual é exibido o novo valor.

Fig. 4-2: Janela Exibição de variável - individual

Pos. Descrição
1 Nome das variáveis, que devem ser alteradas
2 Novo valor, que deve ser atribuído às variáveis
3 Programa, no qual são procuradas variáveis
Em variáveis de sistema o campo Módulo é irrelevante.
4 Este campo tem dois estados:

 : o valor exibido não é atualizado automaticamente.

 : o valor exibido é atualizado automaticamente.


Alternar entre os estados:
 Pressionar Atual..
 Alternativamente: Shift + Enter

Exibição de infor- Procedimento para a exibição de flags, contadores e temporizadores:


mações do  No menu principal, selecionar Exibir > Variável.
sistema
Agora podem ser selecionadas as diversas variáveis de sistema:
 Flags cíclicos
 Flags
 Contador
 Temporizador
Procedimento para a exibição de entradas e saídas:
 No menu principal, selecionar Exibir > Entradas/Saídas > Entradas di-
gitais ou Saídas digitais.

86 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


4 Variáveis e acordos

4.5 Arrays / Campos com KRL

Descrição de Campos ou também Arrays oferecem espaço de memória para várias variá-
campos com KRL veis do mesmo tipo de dados, que são diferenciados através de index
 O espaço de memória para campos é finito, ou seja, o tamanho de campo
máximo depende da necessidade de memória do tipo de dados
 na declaração devem ser conhecidos o tamanho de campo e o tipo de da-
dos
 O índice de partida no KRL sempre começa com 1
 Uma inicialização pode ser realizada sempre individualmente
 Uma inicialização no SRC-File também pode ser realizada através de loop
Dimensões de campo
 Campo unidimensional
dimension[4]= TRUE

 Campo bidimensional
dimension[2,1]= 3.25

 Campo tridimensional
dimension[3,4,1]= 21

 Um campo quadridimensional ou superior não é suportado pelo KRL

Contextos no uso A vida útil e a validade de variáveis de campos é igual, como no uso de vari-
de campos áveis de um tipo de dados simples

Declaração de campo
 Criar no SRC_File
DEF MY_PROG ( )
DECL BOOL error[10]
DECL REAL value[50,2]
DECL INT parts[10,10,10]
INI
...
END

 Criação de uma lista de dados (inclusive $CONFIG.DAT)


DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL BOOL error[10]
DECL REAL value[50,2]
DECL INT parts[10,10,10]
...
ENDDAT

Declarar e inicializar campo no SRC-File


 Cada campo individualmente com acesso de índice

DECL BOOL error[10]


INI
error[1]=FALSE
error[2]=FALSE
error[3]=FALSE
error[3]=FALSE
error[4]=FALSE
error[5]=FALSE

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 87 / 251


Programação do robô 2

error[6]=FALSE
error[7]=FALSE
error[8]=FALSE
error[9]=FALSE
error[10]=FALSE

 Com loops adequados


DECL BOOL error[10]
DECL INT x
INI

FOR x = 1 TO 10
error[x]=FALSE
ENDFOR

Após o término do loop x tem o valor 11

Inicializar o campo na lista de dados


 Cada campo individualmente com acesso de índice e posterior exibição
de valor na lista de dados
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL BOOL error[10]
error[1]=FALSE
error[2]=FALSE
error[3]=FALSE
error[4]=FALSE
error[5]=FALSE
error[6]=FALSE
error[7]=FALSE
error[8]=FALSE
error[9]=FALSE
error[10]=FALSE

 Declaração não permitida e inicialização na lista de dados


DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL BOOL error[10]
DECL INT size = 32
error[1]=FALSE
error[2]=FALSE
error[3]=FALSE
error[4]=FALSE
error[5]=FALSE
error[6]=FALSE
error[7]=FALSE
error[8]=FALSE
error[9]=FALSE
error[10]=FALSE

Gera dez mensagens de erro "Passo de valor inicial não está na se-
ção inicial"

O campo completo pode ser exibido quando no menu principal se se-


leciona Display > Variável > Individual e no campo Nome se intro-
duz o nome da variável com colchetes sem Index (p.ex. error[])

88 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


4 Variáveis e acordos

Declarar campos na lista de dados e inicializar no SRC-File


 Se um campo for criado deste modo na lista de dados, os valores atuais
não podem ser lidos na lista de dados; os valores atuais podem ser veri-
ficados somente com a exibição de variáveis.
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL BOOL error[10]

DEF MY_PROG ( )
INI
error[1]=FALSE
error[2]=FALSE
error[3]=FALSE
...
error[10]=FALSE

ou

DEF MY_PROG ( )
INI
FOR x = 1 TO 10
error[x]=FALSE
ENDFOR

Inicialização através de loops


 Campo unidimensional
DECL INT parts[15]
DECL INT x
FOR x = 1 TO 15
parts[x]= 4
ENDFOR

 Campo bidimensional
DECL INT parts_table[10,5]
DECL INT x, y
FOR x = 1 TO 10
FOR y = 1 TO 5
parts_table[x, y]= 6
ENDFOR
ENDFOR

 Campo tridimensional
DECL INT parts_palette[5,4,3]
DECL INT x, y, z
FOR x = 1 TO 5
FOR y = 1 TO 4
FOR z = 1 TO 3
parts_palette[x, y, z]= 12
ENDFOR
ENDFOR
ENDFOR

Procedimento na 1. Definir tipos de dados para o campo


programação de 2. Calcular a validade e vida útil do campo
Arrays 3. Realizar declaração de campo (SRC ou DAT, aqui SRC)
4. Inicializar elementos de campo

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 89 / 251


Programação do robô 2

5. Nas rotinas de programa, isto é, manipular o campo sempre no arquivo


SRC
6. Fechar e salvar SRC-File
DEF MY_PROG ( )
DECL REAL palette_size[10]
DECL INT counter
INI
; Inicialização
FOR counter = 1 TO 10
palette_size[counter] = counter * 1.5
ENDFOR
...
; Alterar o valor individualmente
palette_size[8] = 13
...
; Comparação de valores
IF palette_size[3] > 4.2 THEN
...

90 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


4 Variáveis e acordos

4.6 Exercício: Campos com tipos de dados simples e loop de contagem

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Declarar e inicializar campos com tipos de dados simples
 Editar elementos individuais de campo
 Trabalhar com a exibição de variáveis (configuração/exibição)

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos sobre tipos de dados simples
 Conhecimentos teóricos sobre campos
 Conhecimentos teóricos sobre loop FOR
 Conhecimentos teóricos sobre a exibição da variável

Definição de Amplie os seus programas criados com o seguinte:


funções  Crie um campo unidimensional com o tamanho 12. O conteúdo dos cam-
pos deverá ser a letra "O" ou "X".
 Antes do início da execução todos os campos devem estar pré-preenchi-
dos com "O".
 Após a entrega do 1º módulo, o 1º campo deverá receber a letra "X". Para
as demais entregas deve-se proceder da mesma forma.
 Verifique o index de campo atual e o conteúdo do campo.

Fig. 4-3

 Defina, onde as suas variáveis são declaradas.


 Amplie o seu fluxograma do programa existente, incluindo esse campo.
 Crie um novo grupo para a exibição das variáveis de campo necessárias.
 Teste o seu programa nos modos de operação T1, T2 e Automático. Aqui
devem ser observadas as prescrições de segurança ensinadas.
O que você deve saber agora:
1. Onde o tamanho de um campo é dimensionado?
............................................................

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 91 / 251


Programação do robô 2

.............................................................
2. Qual é a diferença da declaração de um campo no SRC-File e no DAT-File?
.............................................................
.............................................................
3. Qual mensagem de erro é exibida ao ultrapassar o index de campo?
.............................................................
.............................................................
4. Declare um campo tridimensional com o nome preço do armário. O preço
do armário é calculado com os componentes comprimento, largura e profun-
didade. A gama abrange 5 comprimentos diferentes, 3 larguras diferentes e
duas profundidades diferentes?
.............................................................
.............................................................
5. Como o campo Preço do armário (Schrankpreis) acima é exibido de forma
completa?
.............................................................
.............................................................

92 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


4 Variáveis e acordos

4.7 Estruturas com KRL

Variáveis com
diversas infor-
mações indivi-
duais

Fig. 4-4

Tipo de dados composto: estruturas


 Com campos podem ser combinadas variáveis do mesmo tipo de dados.
No mundo real as variáveis geralmente consistem de tipos de dados dife-
rentes.
 Assim um carro tem uma potência de motor ou uma quilometragem do
tipo Integer. Para o preço pode-se oferecer o tipo Real. Em comparação,
a existência de um ar condicionado seria o tipo de dados Bool.
 Tudo junto descreve um carro.
 Uma estrutura pode ser definida com a própria palavra-chave STRUC.
 Uma estrutura é uma união de diferentes tipos de dados.
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition

 Uma estrutura primeiro precisa ser definida, depois pode ser reutilizada.

Uso de uma Disponibilidade/definição de uma estrutura


estrutura  Estruturas locais são inválidas ao alcançar a linha END
 Estruturas usadas em vários programas, deverão ser declaradas na
$CONFIG.DAT
 Tipos de enumeração definidos por conta própria deverão terminar com
TYPE para facilitar o reconhecimento
 Em uma estrutura podem ser usados os tipos de dados simples INT, RE-
AL, BOOL e CHAR.
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition

 Em uma estrutura podem ser inseridos campos CHAR.


STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition, CHAR
car_model[15]

 Em uma estrutura também podem ser usadas estruturas conhecidas,


como uma posição POS.
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition, POS car_pos

 Após a definição da estrutura é necessário declarar uma variável de tra-


balho para isto
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition
DECL CAR_TYPE my_car

Inicialização / Modificação de uma estrutura


 A inicialização pode ser realizada através de parênteses.
 Na inicialização com parênteses só podem ser usadas constantes (valo-
res fixos).
 A sequência da atribuição de valores não deve ser observada.
my_car = {motor 50, price 14999.95, air_condition TRUE}

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 93 / 251


Programação do robô 2

my_car = {price 14999.95, motor 50, air_condition TRUE}

 Em uma estrutura não precisam ser indicados todos os elementos de es-


trutura.
 Uma estrutura é inicializada com um elemento de estrutura.
 Valores não inicializados estão ou serão colocados em desconhecido.
my_car = {motor 75} ; Valor desconhecido para preço e ar
condicionado

 A inicialização também pode ser feita com separador de ponto.


my_car.price = 9999.0

 Um elemento de estrutura pode ser alterado individualmente a qualquer


momento através de separador de ponto. Os demais elementos de estru-
tura não são excluídos ou alterados.
my_car = {price 14999.95, motor 50, air_condition TRUE}
my_car.price = 12000.0 ; Os valores para motor e ar condicionado são
mantidos

Porém:
my_car = {price 14999.95, motor 50, air_condition TRUE}
my_car = {price 12000.0} ; Os valores para motor e ar condicionado
são excluídos

A KUKA trabalha muito com estruturas pré-definidas depositadas no sistema.


É possível encontrar exemplos nas posições e na programação da mensa-
gem.

Estruturas KUKA pré-definidas da área das posições


 AXIS: STRUC AXIS REAL A1, A2, A3, A4, A5, A6
 E6AXIS: STRUC E6AXIS REAL A1, A2, A3, A4, A5, A6, E1, E2, E3, E4,
E5, E6
 FRAME: STRUC FRAME REAL X, Y, Z, A, B, C
 POS: STRUC POS REAL X, Y, Z, A, B, C INT S,T
 E6POS: STRUC E6POS REAL X, Y, Z, A, B, C, E1, E2, E3, E4, E5, E6
INT S,T
Inicialização de uma estrutura com uma posição
 Na inicialização com parênteses só podem ser usadas constantes (valo-
res fixos)
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition, POS car_pos
DECL CAR_TYPE my_car
my_car = {price 14999.95, motor 50, air_condition TRUE, car_pos {X
1000, Y 500, A 0}}

 A inicialização também poderá ser realizada com o separador de ponto


my_car.price = 14999.95
my_car.motor = 50
my_car.air_condition = TRUE
my_car.car_pos = {X 1000, Y 500, A 0}

 Na inicialização com o separador de ponto também podem ser usadas va-


riáveis
my_car.price = my_price*0.85
my_car.car_pos.X = x_value
my_car.car_pos.Y = 750+y_value

94 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


4 Variáveis e acordos

Criação de uma 1. Definição da estrutura


estrutura STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition

2. Declaração das variáveis de trabalho


DECL CAR_TYPE my_car

3. Inicialização das variáveis de trabalho


my_car = {motor 50, price 14999.95, air_condition TRUE}

4. Modificação dos valores e/ou comparação de valores das variáveis de tra-


balho
my_car.price = 5000.0

my_car.price = value_car

IF my_car.price >= 20000.0 THEN


...
ENDIF

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 95 / 251


Programação do robô 2

4.8 Exercício: Criar estruturas com KRL

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Geração de estruturas próprias (declaração, inicialização)
 Trabalhar com o separador de pontos

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos teóricos sobre tipos de dados e estruturas simples

Definição de Crie um programa com o nome Estrutura.


tarefas  Gere uma estrutura com o nome BOX_Typ. Nessa estrutura deverão ser
depositados os seguintes valores característicos:
 Comprimento
 Largura
 Altura
 Estado da esmaltagem (sim/não)
 Número de garrafas
 Atribua à variável KISTE (CAIXA) a estrutura BOX_Typ e inicialize com os
seguintes valores de início:
 Comprimento 25,2
 Largura 18,5
 Altura 5,0
 Conteúdo: 4 garrafas
 Não esmaltado
 No primeiro processo de usinagem ainda serão acrescentadas 8 garrafas.
No 2º passo a KISTE (CAIXA) será ainda pintada. Entre o passo um e dois
programe um período de espera de 3 segundos.
 Solicite a exibição do conteúdo da variável KISTE (CAIXA) durante o pro-
cedimento.
 Defina, onde as suas variáveis são declaradas.
 Amplie o seu fluxograma do programa existente, incluindo essa estrutura.
 Crie um novo grupo para a exibição das variáveis de campo necessárias.
 Teste o seu programa nos modos de operação T1, T2 e Automático. Aqui
devem ser observadas as prescrições de segurança ensinadas.
O que você deve saber agora:
1. O que é uma estrutura?
.............................................................
.............................................................
2. Que estruturas KUKA pré-definidas existem?
.............................................................
.............................................................
3. Qual é a diferença entre uma estrutura POS e uma estrutura E6POS?
.............................................................
.............................................................
4. Nomeie uma estrutura FRAME que você já conhece.
.............................................................

96 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


4 Variáveis e acordos

............................................................
5. Para que precisamos do separador de ponto?
............................................................
............................................................

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 97 / 251


Programação do robô 2

4.9 O tipo de dados de enumeração ENUM

Texto inequívoco
como valor de
variável

Fig. 4-5

 O tipo de dados de enumeração consiste de uma quantidade limitada de


constantes como verde, amarelo ou azul
ENUM COLOR_TYPE green, blue, red, yellow

 As constantes são nomes livremente selecionáveis


 As constantes são definidas pelo programador
 Um tipo de enumeração precisa primeiro ser definido, depois pode ser
reutilizado
 Uma variável de trabalho como a cor da caixa do tipo COLOR_TYPE sem-
pre pode apenas ter o valor de uma constante
 A atribuição de valores de uma constante ocorre sempre com o símbolo #

Uso de um tipo de Disponibilidade / Uso


dados de enume-  Somente constantes conhecidas podem ser usadas
ração
 Um tipo de enumeração finalmente pode ser ampliado (mais de 250 cons-
tantes e mais de 2000 caracteres)
 Um tipo de enumeração pode ser usado sozinho
ENUM COLOR_TYPE green, blue, red, yellow

 Um tipo de enumeração pode ser incluído em uma estrutura


ENUM COLOR_TYPE green, blue, red, yellow
STRUC CAR_TYPE INT motor, REAL price, COLOR_TYPE car_color

 Tipos de dados de enumeração, que são usados em vários programas,


devem ser declarados na $CONFIG.DAT
 Tipos de enumeração auto-definidos devem terminar com TYPE para um
melhor reconhecimento

Criação de um 1. Definição das variáveis de enumeração e das constantes


tipo de dados de ENUM LAND_TYPE de, be, cn, fr, es, br, us, ch
enumeração
2. Declaração das variáveis de trabalho
DECL LAND_TYPE my_land

3. Inicialização das variáveis de trabalho


my_land = #be

4. Comparação de valores das variáveis de trabalho


IF my_land == #es THEN
...
ENDIF

98 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


4 Variáveis e acordos

4.10 Exercício: Criar tipo de enumeração com KRL

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Gerar variáveis ENUM próprias (declaração)
 Trabalhar com variáveis ENUM

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos teóricos sobre tipos de dados e estruturas simples
 Conhecimentos teóricos sobre variáveis ENUM simples

Definição de Amplie a sua estrutura de programa com o seguinte:


funções 1. Gere uma variável ENUM cujo conteúdo inclua as cores vermelho, ama-
relo, verde e azul.
2. Crie uma variável Lâmpada, à qual você atribui a cor azul.
3. No segundo passo, atribua à lâmpada a cor amarela.
4. Amplie a sua estrutura BOX_Typ com o agregado cor e atribua à KISTE
(CAIXA) no início a cor vermelha, depois amarela e no final a cor verde.
5. Exiba o conteúdo da variável KISTE (CAIXA) durante o procedimento.
O que você deve saber agora:
1. Quem define a quantidade e os nomes das constantes no tipo de enume-
ração ENUM?
............................................................
............................................................
2. Quando é usado o símbolo "#"?
............................................................
............................................................
3. O que está errado na seguinte geração?
ENUM Tag_typ mo, di, mi, do, fr, sa, so
............................................................
............................................................

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 99 / 251


Programação do robô 2

100 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


5 Subprogramas e funções

5 Subprogramas e funções

5.1 Visão geral

s
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Subprogramas locais
 Subprogramas globais
 Transferência de parâmetros a subprogramas
 Programação de funções

5.2 Trabalhar com subprogramas locais

Definição de  Subprogramas locais estão após o programa principal e são caracteriza-


subprogramas dos com DEF Nome_Subprograma( ) e END
locais DEF MY_PROG( )
; este é o programa principal
...
END
_______________________________________
DEF LOCAL_PROG1( )
; este é o subprograma local 1
...
END
_______________________________________
DEF LOCAL_PROG2( )
; este é o subprograma local 2
...
END
_______________________________________
DEF LOCAL_PROG3( )
; este é o subprograma local 3
...
END

 Um arquivo SRC pode consistir em até 255 subprogramas locais


 Subprogramas locais podem ser acessados diversas vezes
 Para os nomes de programas locais há necessidade de parênteses

Contextos no  Após o processamento de um subprograma local é realizado o retorno no


trabalho com próximo comando na chamada do subprograma
subprogramas DEF MY_PROG( )
locais ; este é o programa principal
...
LOCAL_PROG1( )
...
END
_______________________________________
DEF LOCAL_PROG1( )
...
LOCAL_PROG2( )
...
END
_______________________________________
DEF LOCAL_PROG2( )
...
END

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 101 / 251


Programação do robô 2

 Podem ser colocados no máx. 20 subprogramas em cascata


 Coordenadas de pontos são salvas na respectiva lista DAT e estão dispo-
níveis para o programa completo (*.src)
DEF MY_PROG( )
; este é o programa principal
...
SPTP P1 Vel=100% PDAT1
...
END
_______________________________________
DEF LOCAL_PROG1( )
...
; esta é a mesma posição que no programa principal
SPTP P1 Vel=100% PDAT1
...
END

DEFDAT MY_PROG
...
DECL E6POS XP1={X 100, Y 200, Z 300 ... E6 0.0}
...
ENDDAT

 Com RETURN pode ser finalizado um subprograma, o que causa um retor-


no ao módulo de programa acessado, no exemplo após LOCAL_PROG1().
DEF MY_PROG( )
; este é o programa principal
...
LOCAL_PROG1( )
...
END
_______________________________________
DEF LOCAL_PROG1( )
...
IF $IN[12]==FALSE THEN
RETURN ; retorno ao programa principal
ENDIF
...
END

Procedimento ao 1. Grupo de usuários Peritos


criar subpro- 2. Abrir o SRC-File no Editor
gramas locais 3. Deixar exibir linha DEF
DEF MY_PROG( )
...
END

4. Saltar com o Cursor sob a linha END


5. Atribuir cabeçalho de programa local com DEF, nomes de programas e pa-
rênteses
DEF MY_PROG( )
...
END
DEF PICK_PART( )

6. Concluir novo subprograma com um comando END

102 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


5 Subprogramas e funções

DEF MY_PROG( )
...
END
DEF PICK_PART( )
END

7. Após acionar retorno, é inserida uma barra transversal entre programa


principal e subprograma
DEF MY_PROG( )
...
END
_______________________________________
DEF PICK_PART( )
END

8. Programa principal e subprograma podem agora ser processados


9. Fechar e salvar programas

5.3 Trabalhar com subprogramas globais

Definição de  Subprogramas globais têm arquivos SRC e DAT próprios


subprogramas DEF GLOBAL1( )
globais ...
END

DEF GLOBAL2( )
...
END

 Subprogramas globais podem ser acessados diversas vezes

Contextos no  Após o processamento de um subprograma local é realizado o retorno no


trabalho com próximo comando na chamada do subprograma
subprogramas DEF GLOBAL1( )
locais ...
GLOBAL2( )
...
END

DEF GLOBAL2( )
...
GLOBAL3( )
...
END

DEF GLOBAL3( )
...
END

 Podem ser colocados no máx. 20 subprogramas em cascata


 As coordenadas dos pontos são salvas na respectiva lista DAT e estão
disponíveis somente para o respectivo programa

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 103 / 251


Programação do robô 2

DEF GLOBAL1( )
...
SPTP P1 Vel=100% PDAT1
END

DEFDAT GLOBAL1( )
DECL E6POS XP1={X 100, Z 200, Z 300 ... E6 0.0}
ENDDAT

Diferentes coordenadas para P1 no Global2 ( )


DEF GLOBAL2( )
...
SPTP P1 Vel=100% PDAT1
END

DEFDAT GLOBAL2( )
DECL E6POS XP1={X 800, Z 775, Z 999 ... E6 0.0}
ENDDAT

 Com RETURN pode ser finalizado um subprograma, o que causa um re-


torno ao componente de programa acessado, no exemplo após
GLOBAL2().
DEF GLOBAL1( )
...
GLOBAL2( )
...
END

DEF GLOBAL2( )
...
IF $IN[12]==FALSE THEN
RETURN ; Retorno ao GLOBAL1( )
ENDIF
...
END

Procedimento na 1. Grupo de usuários Peritos


programação 2. Criar novo programa
com subpro- DEF MY_PROG( )
gramas globais ...
END

3. Recriar o segundo programa


DEF PICK_PART( )
...
END

4. Abrir o arquivo SRC do programa MY_PROG no Editor


5. Programar o acesso do subprograma com nome de programa e colchetes
DEF MY_PROG( )
...
PICK_PART( )

104 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


5 Subprogramas e funções

...
END

6. Fechar e salvar programas

5.4 Transmitir parâmetros a subprogramas

Descrição da  Sintaxe
transferência de DEF MY_PROG( )
parâmetros ...
CALC (K, L)
...
END

DEF CALC(R:IN, S:OUT) ; Possibilidade de transferência como IN/OUT-


Parâmetro
...
END

 A transferência de parâmetros pode ser realizada em subprogramas lo-


cais, mas também globais

Princípio da  Transferência de parâmetros como parâmetro IN (Call by value):


transferência de  o valor da variável permanece inalterado no programa principal, isto
parâmetros é, continua se trabalhando com o valor antigo do programa principal
 o subprograma só pode ler o valor da variável, mas não escrever
 Transferência de parâmetros como parâmetro OUT (Call by reference):
 o valor da variável também é alterado no programa principal, isto é, é
assumido o valor do subprograma
 o subprograma lê o valor, altera-o e escreve o novo valor
 Transferência de parâmetros a subprogramas locais
DEF MY_PROG( )
DECL REAL r,s
...
CALC_1(r)
...
CALC_2(s)
...
END
_______________________________________
DEF CALC_1(num1:IN)
; O valor "r" é transferido somente para leitura para num1
DECL REAL num1
...
END
_______________________________________
DEF CALC_2(num2:OUT)
; O valor "s" é transferido para num2, alterado e retornado
DECL REAL num2
...
END

 Transferência de parâmetros a subprogramas globais


DEF MY_PROG( )
DECL REAL r, s
...
CALC_1(r)
...
CALC_2(s)

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 105 / 251


Programação do robô 2

...
END

DEF CALC_1(num1:IN)
; O valor "r" é transferido somente para leitura para num1
DECL REAL num1
...
END

DEF CALC_2(num2:OUT)
; O valor "s" é transferido para num2, alterado e retornado
DECL REAL num2
...
END

 Transferência de valores ao mesmo tipo de dados é sempre possível


 Transferência de valores a outros tipos de dados:
DEF MY_PROG( )
DECL DATATYPE1 value
CALC(value)
END
_______________________________________
DEF CALC(num:IN)
DECL DATATYPE2 num
...
END

DATATYPE 1 DATATYPE 2 Observação


BOOL INT, REAL, ERRO ( ... Parâmetro incompatível)
CHAR
INT REAL Valor INT é usado como valor REAL
INT CHAR São usados caracteres da tabela ASCII
CHAR INT É usado o valor INT da tabela ASCII
CHAR REAL É usado o valor REAL da tabela ASCII
REAL INT Valores REAIS são arredondados
REAL CHAR Valores REAL são arredondados, são
usados caracteres da tabela ASCII

 Transferência de diversos parâmetros


DEF MY_PROG( )
DECL REAL w
DECL INT a, b
...
CALC(w, b, a)
...
CALC(w, 30, a)
...
END
_______________________________________
DEF CALC(ww:OUT, bb:IN, aa:OUT)
;1.) w <-> ww, b -> bb, a <-> aa
;2.) w <-> ww, 30 -> bb, a <-> aa
DECL REAL ww
DECL INT aa, bb
...
END

106 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


5 Subprogramas e funções

Não é possível transferir valores, se no subprograma também é cal-


culado sem esses valores. Exemplo: RECHNE(w,, a)

 Transferência de parâmetros com campos


 Campos só podem ser transferidos completamente em um novo cam-
po
 Campos só podem ser transferidos com parâmetros OUT (Call by re-
ference)
DEF MY_PROG( )
DECL CHAR name[10]
...
name[]="PETER"
calc(name[])
...
END
_______________________________________
DEF calc(my_name[]:OUT)
; criar campo no subprograma sempre sem tamanho do campo
; o tamanho do campo se adapta ao campo inicial
DECL CHAR my_name[]
...
END

Transferência de campos completos: FELD_1D[] (unidimensional),


FELD_2D[,] (bidimensional), FELD_3D[,,] (tridimensio-
nal)

 Respectivos elementos de campo também podem ser transferidos


DEF MY_PROG( )
DECL CHAR name[10]
...
name[]="PETER"
CALC(name[1])
...
END
_______________________________________
DEF calc(symbol:IN)
; é transferido somente um caractere
DECL CHAR symbol
...
END

Ao transferir elementos de campo individuais, pode haver também


apenas uma única variável como destino e nenhum campo. Aqui so-
mente a letra "P" é transferida para o subprograma.

Procedimento na Considerações
transferência de 1. Definir quais parâmetros são necessários no subprograma
parâmetros 2. Determinar o tipo de transferência de parâmetros (parâmetros IN ou OUT)
3. Definir tipos de dados de saída e de dados de destino (no ideal o mesmo
tipo de dados)
4. Determinar a sequência da transferência de parâmetros

A observar: primeiro parâmetro enviado é escrito no primeiro parâ-


metro no subprograma, o segundo no segundo parâmetro no subpro-
grama etc.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 107 / 251


Programação do robô 2

Procedimento
1. Carregar um programa principal no editor
2. No programa principal, declarar, inicializar e possivelmente manipular va-
riáveis
3. Criar acesso de subprograma com transferência de variável
4. Fechar e salvar o programa principal
5. Carregar um subprograma no editor
6. Complementar linha DEFcom variáveis e IN/OUT
7. No subprograma, declarar, inicializar e possivelmente manipular variáveis
8. Fechar e salvar o subprograma
Exemplo completo:

DEF MY_PROG( )
DECL REAL w
DECL INT a, b
w = 1.5
a = 3
b = 5
CALC(w, b, a)
; valores atuais
; w = 3.8
; a = 13
; b = 5
END
_______________________________________
DEF CALC(ww:OUT, bb:IN, aa:OUT)
; w <-> ww, b -> bb, a <-> aa

DECL REAL ww
DECL INT aa, bb
ww = ww + 2.3 ; ww = 1.5 + 2.3 =3.8 ->w
bb = bb + 5 ; bb = 5 + 5 = 10
aa = bb + aa ; aa = 10 + 3= 13 -> a
END

108 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


5 Subprogramas e funções

5.5 Exercício: Subprogramas com transferência de parâmetros

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Técnica de subprogramas com transferência de parâmetros

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos sobre técnica de subprograma
 Conhecimentos teóricos sobre a transferência de parâmetros
 Conhecimentos teóricos sobre funções

Definição de Definição de tarefas: complete os resultados após o término dos programas.


funções
DEF transmit_var( )
INT A, B, C, D, E, F
A=50
B=48
C=200
D=300
E=8
F=5
Calc (C, D, A, F, B, E)

;A = ....... B = ....... C = .......

;D = ....... E = ....... F = .......


END
---------------------------------------------------------------------
-------------------------------
;Sub program
DEF Calc (X1:OUT, X2:IN, X3:OUT, X4:IN, X6:IN, X5:OUT)
INT X1, X2, X3, X4, X5, X6

; Calculation
X1 = X1 + 211 ; X1 = …………………
X2 = X2 - 312 ; X2 = …………………
X3 = X2 + X3 ; X3 = …………………
X4 = X4 * X5 ; X4 = …………………
X5 = X5 * 8 ; X5 = …………………
X6 = X6 – 40 ; X6 = …………………
END

O que você deve saber agora:


1. Quantos subprogramas podem ser encadeados?
............................................................
............................................................
2. Qual DAT-File é acessado por um subprograma local?
............................................................
............................................................
3. Onde é declarada uma variável que deverá ser conhecida no subprograma
global e no programa principal?
............................................................
............................................................

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 109 / 251


Programação do robô 2

4. Na transmissão de parâmetros, qual é a diferença entre "Parâmetro IN" e


"Parâmetro OUT"?
.............................................................
.............................................................

110 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


5 Subprogramas e funções

5.6 Programação de funções

Definição de  Uma função é um subprograma que retorna um determinado valor ao pro-


funções com KRL grama principal.
 Frequentemente são necessários determinados valores de introdução,
para poder calcular o valor de retorno.
 No cabeçalho da função é definido o tipo de dado, que é retornado no pro-
grama principal.
 O valor a ser entregue é transferido com a instrução RETURN
(return_value).
 Há funções locais e globais.
 Sintaxe de uma função:
DEFFCT DATATYPE NAME_FUNCTION( )
...
RETURN(return_value)
ENDFCT

Princípio de  O nome do programa é ao mesmo tempo o nome da variável de um de-


funções com KRL terminado tipo de dados
 Acesso a uma função global
DEF MY_PROG( )
DECL REAL result, value
INI
...
result = CALC(value)
...
END

DEFFCT REAL CALC(num:IN)


DECL REAL return_value, num
...
RETURN(return_value)
ENDFCT

A instrução RETURN(return_value) deve ocorrer antes da instru-


ção ENDFCT.

 Acesso a uma função local


DEF MY_PROG( )
DECL REAL result, value
INI
...
result = CALC(value)
...
END
_______________________________________
DEFFCT REAL CALC(num:IN)
DECL REAL return_value, num
...
RETURN(return_value)
ENDFCT

 Uso de parâmetros IN/OUT na transferência de valores


 Transferência de valores como parâmetros IN
DEF MY_PROG( )
DECL REAL result, value
INI

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 111 / 251


Programação do robô 2

value = 2.0
result = CALC(value)
; value = 2.0
; result = 1000.0
END

DEFFCT REAL CALC(num:IN)


DECL REAL return_value, num
num = num + 8.0
return_value = num * 100.0
RETURN(return_value)
ENDFCT

O valor de transferência value não é alterado.

 Transferência de valores como parâmetro OUT


DEF MY_PROG( )
DECL REAL result, value
INI
value = 2.0
result = CALC(value)
; value = 10.0
; result = 1000.0
END

DEFFCT REAL CALC(num:OUT)


DECL REAL return_value, num
num = num + 8.0
return_value = num * 100.0
RETURN(return_value)
ENDFCT

O valor de transferência value é retornado alterado.

Procedimento na 1. Definir qual valor a função deve fornecer (tipo de dados de retorno)
programação de 2. Definir quais parâmetros são necessários na função (tipos de dados de
funções transferência)
3. Determinar tipo de transferência de parâmetros (parâmetros IN ou OUT)
4. Determinar se é necessária uma função local ou global
5. Carregar um programa principal no editor
6. No programa principal, declarar, inicializar e possivelmente manipular va-
riáveis
7. Criar acesso de função
8. Fechar e salvar o programa principal
9. Criar função (global ou local)
10. Carregar uma função no editor
11. Complementar linha DEFFCTcom tipo de dados, variáveis e IN/OUT
12. Na função, declarar, inicializar e manipular variáveis
13. Criar linhaRETURN(return_value)

112 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


5 Subprogramas e funções

14. Fechar e salvar a função

5.7 Trabalhar com funções padrão KUKA

Listagem das Funções matemáticas:


funções padrão
Descrição Função KRL
KUKA
Montante ABS(x)
Raiz SQRT(x)
Seno SIN(x)
Coseno COS(x)
Tangente TAN(x)
Arco coseno ACOS(x)
Arco tangente ATAN2(y,x)

Funções para variável string:

Descrição Função KRL


Levantamento do comprimento string na decla- StrDeclLen(x)
ração
Comprimento de uma variável string após a ini- StrLen(x)
cialização
Excluir o conteúdo de uma variável string StrClear(x)
Ampliar variável string StrAdd(x,y)
Comparar o conteúdo de uma variável string StrComp( x,y,z)
Copiar variável string StrCopy(x,y)

Funções para a emissão de mensagens:

Descrição Função KRL


Emitir mensagem Set_KrlMsg(a,b,c,d)
Emitir diálogo Set_KrlDLg(a,b,c,d)
Verificar mensagem Exists_KrlMsg(a)
Verificar diálogo Exists_KrlDlg(a,b)
Excluir mensagem Clear_KrlMsg(a)
Ler memória intermediária de mensagem Get_MsgBuffer(a)

Princípio no uso Cada função é acessada com parâmetros de transferência:


de funções  Com valores fixos
padrão KUKA
result = SQRT(16)

 Variáveis de tipos de dados simples


result = SQRT(x)

 Variáveis consistem dos campos


result = StrClear(Name[])

 Variáveis consistem dos tipos de dados de enumeração


 Variáveis consistem de estruturas
 Com diversas variáveis distintas
result = Set_KrlMsg(#QUIT, message_parameter, parameter[], option)

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 113 / 251


Programação do robô 2

message_parameter, parameter[1...3] e option são estruturas


KUKA predefinidas

Cada função necessita de uma variável adequada, na qual o resultado dessa


função pode ser salvo:
 Funções matemáticas devolvem um valor REAL
 Funções string devolvem valores BOOL ou INT
; Exclusão de um string
result = StrClear(Name[])

 Funções de mensagem devolvem valores BOOL ou INT


; Exclusão de uma mensagem (BOOL: excluído?)
result = Clear_KrlMsg(Valor de retorno)

114 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


6 Programação de mensagens com KRL

6 Programação de mensagens com KRL

6.1 Visão geral

Nesta unidade de aprendizagem são repassados os seguintes conteú-


dos:
 Generalidades sobre mensagens definidas pelo usuário
 Variáveis e estruturas em mensagens definidas pelo usuário
 Funções em mensagens definidas pelo usuário
 Trabalhar com mensagens de informação
 Trabalhar com mensagens de estado
 Trabalhar com mensagens de confirmação
 Trabalhar com mensagens de espera
 Variáveis e estruturas adicionais em diálogos
 Funções em diálogos
 Trabalhar com diálogos

6.2 Generalidades sobre mensagens definidas pelo usuário

Propriedades da programação de mensagens


 Com KRL o programador pode programas mensagens próprias.
 É possível emitir várias mensagens simultaneamente.
 Mensagens emitidas encontram-se em um buffer de mensagens, até que
sejam novamente excluídas.
 As mensagens de informação não são administradas no buffer de mensa-
gens. (Princípio "fire and forget").
 Mensagens podem ser testadas e excluídas de forma simples, já as men-
sagens de informação não.
 Em cada mensagem podem ser integrados até 3 parâmetros.
Na janela de mensagens da KUKA.HMI é exibido um ícone para cada men-
sagem. Os ícones estão atribuídos fixamente aos tipos de mensagem e não
podem ser alterados pelo programador.
Podem ser programados os seguintes tipos de mensagem:

Ícone Tipo
Mensagem de confirmação

Mensagem de estado

Mensagem de informação

Mensagem de espera

Mensagem de diálogo (é exibida em uma janela POP-UP


própria)

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 115 / 251


Programação do robô 2

Nenhuma reação especificada do sistema de robô está ligada com os


diferentes tipos de mensagens (p.ex. o robô freia ou o programa é
parado). As reações desejadas devem ser programadas.

Variáveis complexas para a programação de mensagens


 Estrutura para emissor, número da mensagem, texto de mensagem
 Estrutura como dummy para 3 possíveis parâmetros
 Estrutura para o comportamento geral de mensagens
 Estrutura para a inscrição dos botões em mensagens de diálogo
A emissão, o cancelamento ou o teste de mensagens ocorre através de fun-
ções KUKA pré-realizadas. Para isto são necessárias diversas variáveis.
Funções para a programação de mensagens
 Emitir mensagem
 Verificar mensagem
 Excluir mensagem
 Emitir diálogo
 Verificar diálogo

6.3 Variáveis e estruturas em mensagens definidas pelo usuário

Estrutura para 
emitente, número
da mensagem,
texto de
mensagem

estrutura KUKA predefinida: KrlMsg_T


STRUC KrlMsg_T CHAR Modul[24], INT Nr, CHAR Msg_txt[80]

 do exemplo
DECL KrlMsg_T mymessage
mymessage = {Modul[ ] "College", Nr 1906, Msg_txt[ ] "My first
Message"}

 Emitente: Modul[ ]"College"


 Modul[ ] pode conter, no máximo, 24 caracteres.
 O texto do remetente é colocado pelo sistema na exibição entre "< >".
 Número da mensagem: Nr 1906
 Nr é um número inteiro de livre escolha
 Números utilizados em duplicidade não são detectados.
 Texto de mensagem: Msg_txt[ ] "My first Message"
 Msg_txt[ ] pode conter, no máximo, 80 caracteres.
Se o Msg_txt[ ] deve ser reinstalado para uma mensagem subse-
quente, primeiro deve ser excluído o conteúdo "antigo". (>>> "Prin-
cípio no uso de funções padrão KUKA" Página 113)
...
INT result
INI
...

116 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


6 Programação de mensagens com KRL

result = StrClear(My_Message.Msg_txt[])
...

Alternativa:
...
INT X
INI
FOR x=1 TO 80...
My_Message.Msg_txt[x] = " "
ENDFOR
...

 O texto é exibido na segunda linha da mensagem.

Selecionar o tipo  Tipo de dados de enumeração EKrlMsgType


de mensagem ENUM EKrlMsgType Notify, State, Quit, Waiting

 #Quit: Emite esta mensagem como mensagem de confirmação

 #STATE: Emite esta mensagem como mensagem de estado

 #NOTIFY: Emite esta mensagem como mensagem de informação

 #WAITING: Emite esta mensagem como mensagem de espera

Variáveis no texto Em um texto de mensagem deve ser exibido o valor de uma variável. Por
de mensagem exemplo, deve ser exibida a quantidade atual. Para isto são necessários dum-
mies no texto de mensagem. A quantidade máxima de dummies é 3. A exibi-
ção é %1, %2 e %3.
Por este motivo são necessários 3 conjuntos de parâmetros. Cada conjunto
de parâmetros consiste na estrutura KUKA KrlMsgPar_T:
Enum KrlMsgParType_T Value, Key, Empty
STRUC KrlMsgPar_T KrlMsgParType_T Par_Type, CHAR Par_txt[26], INT
Par_Int, REAL Par_Real, BOOL Par_Bool

Uso dos respectivos agregados


 Par_Type: Tipo do parâmetro/dummy
 #VALUE: O parâmetro é inserido diretamente no texto de mensagem
na forma entregue (portanto, como string, valor INT, REAL ou BOOL)
 #KEY: O parâmetro é uma palavra-chave, pela qual deve ser procura-
do no banco de dados de mensagens, para carregar o texto corres-
pondente
 #EMPTY: O parâmetro está vazio.
 Par_txt[26]: Texto ou palavra-chave para o parâmetro
 Par_Int: Transmissão de um valor inteiro como parâmetro
 Par_Real: Transmissão de um valor real como parâmetro
 Par_Bool: Transmissão de um valor booleano como parâmetro, o texto
de exibição é TRUE ou FALSE
Exemplos de programa para a transmissão direta de parâmetros nos dum-
mies:
O texto de mensagem é Msg_txt[ ] "Falha no %1"
DECL KrlMsgPar_T Parameter[3] ; Criar 3 conjuntos de parâmetros
...
Parameter[1] = {Par_Type #VALUE, Par_txt[ ] "Finisher"}

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 117 / 251


Programação do robô 2

Parameter[2] = {Par_Type #EMPTY}


Parameter[3] = {Par_Type #EMPTY}
...

Emissão de mensagem: Defeito no Finisher

Uma vez que os parâmetros raramente são escritos através de uma


introdução constante, os respectivos agregados são transmitidos
com o separador de ponto.

Exemplos de programa para a transmissão com separador de ponto de parâ-


metros nos dummies:
O texto de mensagem é Msg_txt[ ] "Faltam %1 componentes"
DECL KrlMsgPar_T Parameter[3] ; Criar 3 conjuntos de parâmetros
DECL INT missing_part
...
missing_part = 13
...
Parameter[1] = {Par_Type #VALUE}
Parameter[1].Par_Int = missing_part
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
...

Emissão de mensagem: Faltam 13 componentes

Estrutura para Na emissão de uma mensagem são transmitidas mais 4 opções de mensa-
opções gerais de gens. Com estas opções podem ser influenciados o avanço, a exclusão de
mensagens mensagens e o registro no banco de dados log.
 estrutura KUKA predefinida: KrlMsgOpt_T
STRUC KrlMsgOpt_T BOOL VL_Stop, BOOL Clear_P_Reset, BOOL Clear_SAW,
BOOL Log_To_DB

 VL_Stop: Parada de avanço


 TRUE aciona uma parada de avanço. A mensagem é setada síncrona
ao indicador de avanço principal.
 Padrão: TRUE
 Clear_P_Reset : Excluir no programa reset/desseleção
 TRUE exclui todas as mensagens de estado, de confirmação e de es-
pera, quando o programa é resetado ou desselecionado. Padrão:
TRUE
 Padrão: TRUE

As mensagens de informação podem ser excluídas somente através


das barras de comutação OK ou Todos OK.

 Clear_P_SAW: Excluir na seleção de passo através da barra de comuta-


ção Seleção de passo
 TRUE exclui todas as mensagens de estado, de confirmação e de es-
pera, quando uma seleção de passo for realizada através da barra de
comutação de seleção de passo.
 Padrão: FALSE
 Log_To_DB: Registro no banco de dados log

118 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


6 Programação de mensagens com KRL

 TRUE faz com que esta mensagem seja logada no banco de dados
log.
 Padrão: FALSE

6.4 Funções em mensagens definidas pelo usuário

Setar ou emitir Com esta função é emitida uma mensagem no programa KRL. Isto significa,
uma mensagem que a respectiva mensagem é inserida em um buffer de mensagens interno.
Exceção são mensagens de informação, que não são administradas no bu-
ffer de mensagens.
 Funções build-in para a emissão de uma mensagem
DEFFCT INT Set_KrlMsg(Type:IN, MyMessage:OUT, Parameter[ ]:OUT,
Option:OUT)
DECL EKrlMsgType Type
DECL KrlMsg_T MyMessage
DECL KrlMsgPar_T Parameter[ ]
DECL KrlMsgOpt_T Option

 Tipo: Tipo da mensagem (#Notify, #State, #Quit, #Waiting)


 MyMessage: Estrutura para informações gerais de mensagem (remeten-
te, número da mensagem, texto da mensagem)
 Parâmetro[ ]: Campo dos 3 parâmetros possíveis para os dummies
%1, %2 e %3. Sempre é necessário transmitir todos os 3 parâmetros,
mesmo que os dummies não sejam usados.
 Opção: Estrutura para opções de mensagem gerais (parada de avanço,
logar no banco de dados de mensagens, excluir implicitamente mensa-
gem no reset de programa ou na seleção de passo)
 Valor de retorno da função: é designado como "handle" (número de ti-
cket). Com esse "handle" é possível verificar se a mensagem foi emitida
com êxito. Além disso, o "handle" também é o número de identificação no
buffer de mensagens. Assim é possível verificar ou excluir uma determi-
nada mensagem.
DEF MyProg( )
DECL INT handle
...
handle = Set_KrlMsg(Type, MyMessage, Parameter[ ], Option)

Quando é trabalhado com várias mensagens, é necessário usar para


cada mensagem um handle próprio, ou salvá-lo na memória interme-
diária.

 handle == -1: A mensagem não pôde ser emitida (p. ex. porque o
buffer de mensagens está lotado).
 handle > 0: A mensagem foi emitida com sucesso e é administrada
com o respectivo número de identificação no buffer de mensagens.

As mensagens de informação são processadas segundo o princípio


"fire e forget". Em mensagens de informação sempre é devolvido um
handle = 0, caso a mensagem tenha sido emitida com sucesso.

Verificar uma Com esta função pode ser verificado, se uma determinada mensagem com
mensagem um determinado handle ainda existe. Portanto, é verificado se esta mensa-
gem ainda se encontra no buffer de mensagens interno.
 Funções build-in para a verificação de uma mensagem

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 119 / 251


Programação do robô 2

DEFFCT BOOL Exists_KrlMsg(nHandle:IN)


DECL INT nHandle

 nHandle: O handle disponibilizado pela função "Set_KrlMsg(…)" para


a mensagem
 Valor de retorno da função:
DEF MyProg( )
DECL INT handle
DECL BOOL present
...
handle = Set_KrlMsg(Type, MyMessage, Parameter[ ], Option)
...
present= Exists_KrlMsg(handle)

 present == TRUE: Esta mensagem ainda existe no buffer de men-


sagens
 present == FALSE: Esta mensagem não se encontra mais no buffer
de mensagens (portanto, foi confirmada ou excluída)

Exclusão de uma Com esta função pode ser excluída uma mensagem. Isto significa que a res-
mensagem pectiva mensagem é excluída no buffer de mensagens interno.
 Funções build-in para a verificação de uma mensagem
DEFFCT BOOL Clear_KrlMsg(nHandle:IN)
DECL INT nHandle

 nHandle: O handle disponibilizado pela função "Set_KrlMsg(…)" para


a mensagem
 Valor de retorno da função:
DEF MyProg( )
DECL INT handle
DECL BOOL erase
...
handle = Set_KrlMsg(Type, MyMessage, Parameter[ ], Option)
...
eraser = Clear_KrlMsg(handle)

 eraser == TRUE: Esta mensagem pôde ser excluída


 eraser == FALSE: Esta mensagem não pôde ser excluída

Funções especiais para a exclusão com a função


Clear_KrlMsg(handle):
Clear_KrlMsg(-1): todas as mensagens iniciadas com este pro-
cesso são excluídas.
 Clear_KrlMsg(-99): todas as mensagens de usuário KRL são exclu-
ídas.

120 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


6 Programação de mensagens com KRL

6.5 Trabalhar com uma mensagem de informação

Descrição de uma
mensagem de
informação
definida pelo
usuário

Fig. 6-1: Mensagem de informação

 As mensagens de informação não são administradas no buffer de mensa-


gens.
 As mensagens de informação só podem ser novamente excluídas através
das barras de comutação OK ou Todos OK.

Função de uma  Mensagens de informação são apropriadas, para exibir informações ge-
mensagem de rais.
informação  Uma mensagem de informação somente é criada. Eventualmente verifi-
definida pelo ca-se, se a mensagem chegou com sucesso.
usuário  Uma vez que as mensagens de informação não são administradas, po-
dem ser criadas aprox. 3 milhões de mensagens.

Programação de 1. Carregar um programa principal no editor


mensagens de 2. Declarar variáveis de trabalho para:
informação  remetente, número da mensagem, texto de mensagem (de
definidas pelo KrlMsg_T)
usuário  campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
3. Iniciar variáveis de trabalho com os valores desejados
4. Programar o acesso de função Set_KrlMsg(…)
5. Se necessário, avaliar "handle", para determinar se a emissão teve êxito
6. Fechar e salvar o programa principal

Fig. 6-2: Mensagem de informação

Exemplo de programação para a exibição acima:


DECL KRLMSG_T mymessage
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGOPT_T Option
DECL INT handle
...
mymessage={modul[] "College", Nr 1906, msg_txt[] "My first Message"}
Option={VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE,
Log_to_DB TRUE}
;Dummies[1..3] estão vazios
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 121 / 251


Programação do robô 2

handle = Set_KrlMsg(#NOTIFY, mymessage, Parameter[ ], Option)


...

122 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


6 Programação de mensagens com KRL

6.6 Exercício: Programar mensagem de informação

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Programar mensagens de informação próprias
 Emitir parâmetros quaisquer em mensagens

Pré-requisitos Os seguintes requisitos são necessários para realizar o exercício com êxito.
 Conhecimentos da linguagem de programação KRL
 Conhecimentos teóricos sobre a programação de mensagens

Definição de Tarefa parcial 1: mensagem de informação


funções 1. Crie uma mensagem de informação com o texto "Programa Magazine foi
iniciado".
2. Tão logo o programa tenha sido iniciado, a mensagem de informação
deve ser exibida apenas uma vez.
3. Teste o seu programa conforme a prescrição.
Tarefa parcial 2: Mensagem de informação com parâmetros
1. Crie uma mensagem de informação com o texto "Cubo número xxx trans-
portado".
2. Amplie o programa Magazine com um contador de unidades para os
cubos transportados. Após a devolução ao magazine de cubos, aumente
a quantidade e exiba a mesma.
3. Teste o seu programa conforme a prescrição.
O que você deveria saber agora::
1. Como é excluída novamente uma mensagem de informação?
............................................................
............................................................
2. Qual parte integrante da estrutura de mensagens é responsável pelo "dis-
paro" do texto de mensagem?
............................................................
............................................................

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 123 / 251


Programação do robô 2

6.7 Trabalhar com uma mensagem de estado

Descrição de uma
mensagem de
estado definida
pelo usuário

Fig. 6-3: Mensagem de estado

 As mensagens de estado são administradas no buffer de mensagens.


 As mensagens de estado não podem ser excluídas novamente através da
barra de comutação "Todas OK".

Função de uma  As mensagens de estado são apropriadas para exibir a alteração de um


mensagem de estado (p.ex. a supressão de uma entrada).
estado definida  O programa, por exemplo, é retido até que não exista mais o estado de-
pelo usuário sencadeador.

Nenhuma reação especificada do sistema de robô está ligada com os


diferentes tipos de mensagens (p.ex. o robô freia ou o programa é
parado). As reações desejadas devem ser programadas.

 São administradas, no máximo, 100 mensagens no buffer de mensagens.


(Mensagens de estado, confirmação, espera e diálogos)
 A mensagem de estado é excluída novamente através da função
Clear_KrlMsg( ).
 As mensagens de estado também podem ser excluídas da mesma forma
através dos ajustes nas opções de mensagens no reset do programa ou
ao fechar o programa ou uma seleção de passo

Programação de 1. Carregar um programa principal no editor


mensagens de 2. Declarar variáveis de trabalho para:
estado definidas  remetente, número da mensagem, texto de mensagem (de
pelo usuário KrlMsg_T)
 campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
 variável para o resultado do teste (como BOOL)
 variável para o resultado da exclusão (como BOOL)
3. Iniciar variáveis de trabalho com os valores desejados
4. Programar o acesso de função Set_KrlMsg(…)
5. Parar o programa com um loop, até que o estado desencadeador deixe
de existir
6. Excluir a mensagem de estado com o acesso de função Clear_KrlMsg(
)
7. Fechar e salvar o programa principal

Fig. 6-4: Mensagem de estado

124 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


6 Programação de mensagens com KRL

Exemplo de programação para a exibição/mensagem acima:


A mensagem de estado é gerada através do estado entrada 12 (FALSE). O
programa é parado após a emissão da mensagem. A mensagem é excluída
através do estado entrada 17 (TRUE). Depois disto é dada continuidade no
programa.
Da mesma forma a mensagem é excluída ao dar um reset no programa ou ao
fechar o programa. Isto ocorre através do ajuste nas opções de mensagens
Clear_P_Reset TRUE.
DECL KRLMSG_T mymessage
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGOPT_T Option
DECL INT handle
DECL BOOL present, eraser
...
IF $IN[12]==FALSE THEN
mymessage={modul[] "College", Nr 1909, msg_txt[] "My Messagetext"}
Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE,
Log_to_DB TRUE}
;Dummies[1..3] estão vazios
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
handle = Set_KrlMsg(#STATE, mymessage, Parameter[ ], Option)
ENDIF
eraser=FALSE
;Loop para parar até que esta mensagem tenha sido excluída
REPEAT
IF $IN[12]==TRUE THEN
eraser=Clear_KrlMsg(handle) ;Excluir mensagem
ENDIF
present=Exists_KrlMsg(handle) ;controle adicional
UNTIL NOT(present) or eraser

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 125 / 251


Programação do robô 2

6.8 Exercício: Programar mensagem de estado

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Programar mensagens de estado próprias
 Emitir parâmetros quaisquer em mensagens

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos da linguagem de programação KRL
 Conhecimentos teóricos sobre a programação de mensagens

Definição de Tarefa parcial: Mensagem de estado


funções 1. Crie uma mensagem de estado com o texto "Programa de cubos em exe-
cução".
2. Antes que seja iniciado o loop sem fim, deve ser exibida a mensagem de
estado.
3. Através da entrada 16 no console de operação deve-se sair do loop sem
fim e esta mensagem de estado deve ser então excluída.
4. Teste o seu programa conforme a prescrição.
O que você deve saber agora:
1. O que significa %2 no texto de mensagem?
.............................................................
.............................................................

126 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


6 Programação de mensagens com KRL

6.9 Trabalhando com uma mensagem de confirmação

Descrição de uma
mensagem de
confirmação
definida pelo
usuário

Fig. 6-5: Mensagem de confirmação

 As mensagens de confirmação são administradas no buffer de mensa-


gens.
 As mensagens de confirmação podem ser novamente excluídas através
das barras de comutação OK ou Todos OK.

Função de uma  As mensagens de confirmação são apropriadas para exibir informações,


mensagem de que o usuário precisar tomar conhecimento.
confirmação  O programa será retido, por exemplo, até que a mensagem tenha sido
definida pelo confirmada.
usuário Nenhuma reação especificada do sistema de robô está ligada com os
diferentes tipos de mensagens (p.ex. o robô freia ou o programa é
parado). As reações desejadas devem ser programadas.

 São administradas, no máximo, 100 mensagens no buffer de mensagens.


 Na mensagem de confirmação (ao contrário da mensagem de informa-
ção) pode ser verificado, se o usuário a confirmou ou não.
 As mensagens de confirmação também podem ser excluídas através de
uma função no programa.
 As mensagens de confirmação também podem ser excluídas da mesma
forma através dos ajustes nas opções de mensagens no reset do progra-
ma ou ao fechar o programa ou uma seleção de passo.

Programação de 1. Carregar um programa principal no editor.


mensagens de 2. Declarar variáveis de trabalho para:
confirmação  remetente, número da mensagem, texto de mensagem (de
definidas pelo KrlMsg_T)
usuário  campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
 variável para o resultado do teste (como BOOL)
3. Iniciar variáveis de trabalho com os valores desejados.
4. Programar o acesso de função Set_KrlMsg(…).
5. Verificar as condições de confirmação de um loop.
6. Com o acesso de função Exists_KrlMsg(...), verificar se a mensa-
gem já foi confirmada pelo usuário. Se a mensagem já tiver sido confirma-
da, abandonar o loop acima.
7. Fechar e salvar o programa principal.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 127 / 251


Programação do robô 2

Fig. 6-6: Mensagem de confirmação

Exemplo de programação para a exibição/mensagem acima:


O programa é parado após a emissão da mensagem. A mensagem é excluída
através do pressionamento do botão OK ou Todos OK. Depois disto é dada
continuidade no programa.
Da mesma forma a mensagem é excluída ao dar um reset no programa ou ao
fechar o programa. Isto ocorre através do ajuste nas opções de mensagens
Clear_P_Reset TRUE.
DECL KRLMSG_T mymessage
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGOPT_T Option
DECL INT handle
DECL BOOL present
...
mymessage={modul[] "College", Nr 1909, msg_txt[] "My Messagetext"}
Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE,
Log_to_DB TRUE}
;Dummies[1..3] estão vazios
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
handle = Set_KrlMsg(#QUIT, mymessage, Parameter[ ], Option)

;Loop para parar até que esta mensagem tenha sido excluída
REPEAT
present=Exists_KrlMsg(handle)
UNTIL NOT(present)

128 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


6 Programação de mensagens com KRL

6.10 Exercício: Programar mensagens de confirmação

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Programar mensagens de confirmação próprias
 Emitir parâmetros quaisquer em mensagens

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos da linguagem de programação KRL
 Conhecimentos teóricos sobre a programação de mensagens

Definição de Tarefa parcial 1: Mensagem de confirmação


funções 1. Crie uma mensagem de confirmação com o texto "Foram transportados
xxx cubos".
2. Através do contador de unidades instalado, após cada 10º cubo deve ser
exibida a mensagem de confirmação.
3. O trabalho somente pode continuar após a confirmação.
4. Teste o seu programa conforme a prescrição.
Tarefa parcial 2: Mensagem de estado com mensagem de confirmação
1. Crie uma mensagem de confirmação com o texto "O programa de cubos
é finalizado".
2. Depois que loops sem fim foram abandonados com entrada 16, é excluída
a mensagem de estado "Programa de cubos em execução". Exiba a men-
sagem de confirmação e aguarde até que ela tenha sido confirmada.
3. Teste o seu programa conforme a prescrição.
O que você deve saber agora:
1. Qual é o número máximo de mensagens de confirmação administradas no
buffer de mensagens?
............................................................
............................................................

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 129 / 251


Programação do robô 2

6.11 Trabalhar com uma mensagem de espera

Descrição de uma
mensagem de
espera definida
pelo usuário

Fig. 6-7: Mensagem de espera

 As mensagens de espera são administradas no buffer de mensagens.


 As mensagens de espera podem ser excluídas novamente através da
barra de comutação Simular.
 As mensagens de espera não podem ser excluídas novamente através
da barra de comutação Todas OK.

Função de uma  Mensagens de espera são apropriadas para aguardar um estado e exibir
mensagem de nisto o símbolo de espera.
espera definida  O programa, por exemplo, é retido até que seja obtido o estado pelo qual
pelo usuário está se esperando.
 São administradas, no máximo, 100 mensagens no buffer de mensagens.
 A mensagem de espera é excluída novamente através da função
Clear_KrlMsg( ).
 As mensagens de espera também podem ser excluídas da mesma forma
através dos ajustes nas opções de mensagens no reset do programa ou
ao fechar o programa ou em uma seleção de passo.

Programação de 1. Carregar um programa principal no editor.


mensagens de 2. Declarar variáveis de trabalho para:
espera definidas  remetente, número da mensagem, texto de mensagem (de
pelo usuário KrlMsg_T)
 campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
 variável para o resultado do teste (como BOOL)
 variável para o resultado da exclusão (como BOOL)
3. Iniciar variáveis de trabalho com os valores desejados.
4. Programar o acesso de função Set_KrlMsg(…).
5. Parar o programa com um loop, até que ocorra o estado pelo qual é es-
perado ou até que a mensagem seja excluída através do botão Simular.
6. Excluir a mensagem de espera com o acesso de função Clear_KrlMsg(
).
7. Fechar e salvar o programa principal.

Fig. 6-8: Mensagem de espera

Exemplo de programação para a exibição/mensagem acima:

130 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


6 Programação de mensagens com KRL

O programa é parado após a emissão da mensagem. A mensagem é exclu-


ída através do estado entrada 12 (TRUE). Depois disto é dada continuidade
no programa.
Da mesma forma a mensagem é excluída ao dar um reset no programa ou ao
fechar o programa. Isto ocorre através do ajuste nas opções de mensagens
Clear_P_Reset TRUE.
DECL KRLMSG_T mymessage
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGOPT_T Option
DECL INT handle
DECL BOOL present, eraser
...
IF $IN[12]==FALSE THEN
mymessage={modul[] "College", Nr 1909, msg_txt[] "My Messagetext"}
Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE,
Log_to_DB TRUE}
;Dummies[1..3] estão vazios
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
handle = Set_KrlMsg(#WAITING, mymessage, Parameter[ ], Option)
ENDIF
eraser=FALSE
;Loop para parar até que esta mensagem tenha sido excluída
REPEAT
IF $IN[12]==TRUE THEN
eraser=Clear_KrlMsg(handle) ;Meldung loeschen
ENDIF
present=Exists_KrlMsg(handle) ;kann über simuliere geloescht worden
sein
UNTIL NOT(present) or eraser

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 131 / 251


Programação do robô 2

6.12 Exercício: Programar mensagens de espera

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Programar mensagens de espera próprias
 Emitir parâmetros quaisquer em mensagens

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos da linguagem de programação KRL
 Conhecimentos teóricos sobre a programação de mensagens

Definição de 1. Crie uma mensagem de espera com o texto "Aguardar interruptor 15 ou


funções aguardar 5 segundos".
2. No início do programa Magazine deve ser emitida a mensagem de espe-
ra. Amplie o seu programa Magazine com esta lógica da mensagem de
espera.
3. Teste o seu programa conforme a prescrição.
O que você deve saber agora:
1. Qual é a diferença entre uma mensagem "STATE" e uma mensagem "WAI-
TING"?
.............................................................
.............................................................

132 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


6 Programação de mensagens com KRL

6.13 Variáveis e estruturas adicionais em diálogos

Estrutura para
ocupação de
botões

Fig. 6-9: Diálogo

 estrutura KUKA predefinida: KrlMsgDlgSK_T


Enum KrlMsgParType_T Value, Key, Empty
Struc KrlMsgDlgSK_T KrlMsgParType_T Sk_Type, Char SK_txt[10]

 Sk_Type: Tipo de dados de enumeração para o tipo da inscrição de bo-


tões como ENUM
 #VALUE: O parâmetro é inserido diretamente no texto de mensagem
na forma entregue.
 #KEY: O parâmetro é uma palavra-chave, pela qual deve ser procura-
do no banco de dados de mensagens, para carregar o texto corres-
pondente.
 #EMPTY: O botão não está ocupado
 Sk_txt[ ]: Campo para texto ou palavra-chave para o botão
 Exemplo de programa para a inscrição de 7 botões de um diálogo:
DECL KRLMSGDLGSK_T Softkey[7] ; Preparar 7 possíveis softkeys
...
softkey[1]={sk_type #value, sk_txt[] "key1"}
softkey[2]={sk_type #value, sk_txt[] "key2"}
softkey[3]={sk_type #value, sk_txt[] "key3"}
softkey[4]={sk_type #value, sk_txt[] "key4"}
softkey[5]={sk_type #value, sk_txt[] "key5"}
softkey[6]={sk_type #value, sk_txt[] "key6"}
softkey[7]={sk_type #value, sk_txt[] "key7"}
...

Podem ser atribuídos, no máximo, 10 caracteres por botão. De acor-


do com os caracteres utilizados surgem botões de diferentes largu-
ras.

6.14 Funções em diálogos

Setando um Com a função Set_KrlDlg( ) é emitida uma mensagem de diálogo. Isto


diálogo significa que a mensagem é transmitida ao buffer de mensagens e exibida em
uma janela de mensagens com botões.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 133 / 251


Programação do robô 2

Fig. 6-10: Diálogo

 Funções build-in para a emissão de um diálogo


DEFFCT Extfctp Int Set_KrlDlg (MyQuestion:OUT, Parameter[ ]:OUT,
Touchkey[ ]:OUT, Option:OUT)
DECL KrlMsg_T MyQuestion
DECL KrlMsgPar_T Parameter[ ]
DECL KrlMsgDlgSK_T Touchkey[ ]
DECL KrlMsgOpt_T Option

 MyQuestion: Estrutura para informações gerais de mensagem (reme-


tente, número da mensagem, texto de pergunta)
 Parâmetro[ ]: Campo para os 3 parâmetros possíveis para os dum-
mies %1, %2 e %3. Sempre é necessário transmitir todos os 3 parâme-
tros, mesmo que os dummies não sejam usados.
 Touchkey[ ]: Estrutura para a inscrição dos 7 botões possíveis. Sempre
é necessário transmitir todos os 7 botões, mesmo que os botões não se-
jam usados.
 Opção: Estrutura para opções de mensagem gerais (parada de avanço,
logar no banco de dados de mensagens, excluir implicitamente mensa-
gem no reset de programa ou na seleção de passo)
 Valor de retorno do diálogo: "handle" para o diálogo. Com esse "handle"
é possível controlar, se o diálogo pôde ser emitido com êxito. Além disso,
o "handle" também é o número de identificação no buffer de mensagens.
DEF MyProg( )
DECL INT handle
...
handle = Set_KrlDlg(MyQuestion, Parameter[ ], Touchkey[ ], Option)

 handle == -1: Não foi possível emitir o diálogo (p.ex. porque um


outro diálogo ainda está ativo e não foi respondido ou o buffer de men-
sagens está muito cheio)
 handle > 0: A mensagem foi emitida com sucesso e é administrada
com o respectivo número de identificação no buffer de mensagens.

Um diálogo sempre pode ser emitido somente depois que não houver
mais nenhum outro diálogo.
A função simplesmente emite o diálogo. Ela não aguarda até que ele
tenha sido respondido.

134 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


6 Programação de mensagens com KRL

Controlar e Com a função Exists_KrlDlg( ) pode ser verificado, se um determinado


avaliar um diálogo ainda existe. Portanto, é verificado se este diálogo ainda se encontra
diálogo no buffer de mensagens.
Se o diálogo for respondido, a função fornece a informação de qual botão foi
pressionado.
 Funções build-in para a verificação de uma mensagem
DEFFCT BOOL Exists_KrlDlg(INT nHandle:IN, INT Answer:OUT)
DECL INT nHandle, answer

 nHandle: O handle disponibilizado pela função "Set_KrlDlg(…)" para


o diálogo
 Answer: Feedback de qual botão foi pressionado. O botão 1, que foi de-
finido como "Botão[1]" devolve, portanto, o valor 1

A função não aguarda até que o diálogo esteja respondido, mas sim-
plesmente faz uma busca no buffer pelo diálogo com este handle.
Portanto, a consulta no programa KRL deve ocorrer ciclicamente, até
que o diálogo tenha sido respondido ou excluído de outra forma.

 Valor de retorno da função:


DEF MyProg( )
DECL INT handle, answer
DECL BOOL present
...
handle = Set_KrlDlg(MyQuestion, Parameter[ ], Touchkey[ ], Option)
...
present = Exists_KrlDlg(handle, Answer)

 present == TRUE: Este diálogo ainda existe no buffer de mensa-


gens
 present == FALSE: Este diálogo não se encontra mais no buffer de
mensagens (portanto, foi respondido)

Answer agora é devolvida com o valor do botão pressionado. Valo-


res válidos entre 1 e 7, dependendo dos números de botão progra-
mados.

6.15 Trabalhar com diálogos

Descrição de um
diálogo definido
por usuário

Fig. 6-11: Diálogo

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 135 / 251


Programação do robô 2

 Um diálogo sempre pode ser emitido somente depois que não houver
mais nenhum outro diálogo.
 Podem ser definidas até 7 softkeys.

Função de um  Diálogos são apropriados para exibir perguntas, que o usuário precisar
diálogo definido responder.
pelo usuário  Com a função Set_KrlDlg( ) é emitido um diálogo.
 A função simplesmente emite o diálogo. Ela não aguarda até que ele te-
nha sido respondido.
 Com a função Exists_KrlDlg( ) pode ser verificado, se um determi-
nado diálogo ainda existe.
 Também esta função não aguarda, até que o diálogo esteja respondido,
mas simplesmente faz uma busca no buffer pelo diálogo com este handle.
 Portanto, a consulta no programa KRL deve ocorrer ciclicamente, até que
o diálogo tenha sido respondido ou excluído de outra forma.
 A continuidade da execução do programa pode ser tornada dependente
de qual softkey o usuário seleciona.
Avaliação dos botões

 Declaração e inicialização dos botões


DECL KRLMSGDLGSK_T Softkey[7] ; Preparar 7 possíveis softkeys
softkey[1]={sk_type #value, sk_txt[] "key1"} ; Feedback -> 1
softkey[2]={sk_type #value, sk_txt[] "key2"} ; Feedback -> 2
softkey[3]={sk_type #value, sk_txt[] "key3"} ; Feedback -> 3
softkey[4]={sk_type #value, sk_txt[] "key4"} ; Feedback -> 4
softkey[5]={sk_type #value, sk_txt[] "key5"} ; Feedback -> 5
softkey[6]={sk_type #value, sk_txt[] "key6"} ; Feedback -> 6
softkey[7]={sk_type #value, sk_txt[] "key7"} ; Feedback -> 7

 Avaliação via Exists_KrlDlg(): o botão, que foi criado sob o index 4,


também fornece o 4 como feedback.
; a softkey n° 4 dá como feedback o 4 na variável ANSWER
softkey[4]={sk_type #value, sk_txt[] "key4"}
present = exists_KrlDlg(handle ,ANSWER) ; ANSWER é descrita pelo
sistema

Programação de 1. Carregar um programa principal no editor.


diálogos 2. Declarar variáveis de trabalho para:
definidos pelo  remetente, número da mensagem, texto de mensagem (de
usuário KrlMsg_T)
 campos com 3 elementos para os parâmetros (de KrlMsgPar_T)

136 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


6 Programação de mensagens com KRL

 7 possíveis botões (de KrlMsgDlgSK_T)


 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
 variável para o resultado do teste (como BOOL)
 variável para o resultado da resposta de qual botão foi pressionado
(como INT)
3. Iniciar variáveis de trabalho com os valores desejados.
4. Programar o acesso de função Set_KrlDlg(…).
5. Parar o programa com um loop, até que o diálogo esteja respondido.
6. Avaliar o diálogo com o acesso de função Exists_KrlDlg( ).
7. Planejar e programar outras derivações no programa.
8. Fechar e salvar o programa principal.

Fig. 6-12: Diálogo com 3 botões

Exemplo de programação para a exibição/mensagem acima:


Os botões não devem ser programados de forma completa, mas com lacunas
(n° 1, 4, 6). Para isso, os botões são enfileirados automaticamente pelo siste-
ma. Se forem utilizados apenas os botões 1, 4 e 6, também serão possíveis
apenas os feedbacks 1, 4 e 6.
O programa é parado após a entrega do diálogo e o diálogo é excluído após
a resposta. Depois disto é dada continuidade no programa. Em seguida, é
programado um distribuidor.
Da mesma forma a mensagem é excluída ao dar um reset no programa ou ao
fechar o programa. Isto ocorre através do ajuste nas opções de mensagens
Clear_P_Reset TRUE.
DECL KRLMSG_T myQuestion
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGDLGSK_T Softkey[7] ;Preparar 7 possíveis softkeys
DECL KRLMSGOPT_T Option
DECL INT handle, answer
DECL BOOL present
...

myQuestion={modul[] "College", Nr 1907, msg_txt[] "My Question?"}


Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE,
Log_to_DB TRUE}
;Dummies[1..3] estão vazios
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
softkey[1]={sk_type #value, sk_txt[] "key1"} ; Botão 1
softkey[2]={sk_type #EMPTY, sk_txt[] "key2"} ; Botão 2
softkey[3]={sk_type #EMPTY, sk_txt[] "key3"} ; Botão 3
softkey[4]={sk_type #value, sk_txt[] "key4"} ; Botão 4

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 137 / 251


Programação do robô 2

softkey[5]={sk_type #EMPTY, sk_txt[] "key5"} ; Botão 5


softkey[6]={sk_type #value, sk_txt[] "key6"} ; Botão 6
softkey[7]={sk_type #EMPTY} ; Botão 7: sk_txt[] também pode ser
suprimido
...

...; Emitir diálogo


handle = Set_KrlDlg(myQuestion, Parameter[ ],Softkey[ ], Option)
answer=0
REPEAT ; Loop para parar até que este diálogo seja respondido
present = exists_KrlDlg(handle ,answer) ; A resposta é descrita pelo
sistema
UNTIL NOT(present)
...
SWITCH answer
CASE 1 ; Botão 1
; Ação no botão 1
...
CASE 4 ; Botão 4
; Ação no botão 4
...
CASE 6 ; Botão 6
; Ação no botão 6
...
ENDSWITCH
...

138 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


6 Programação de mensagens com KRL

6.16 Exercício: Programar diálogo

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Programar consultas próprias de diálogo
 Emitir parâmetros quaisquer em mensagens

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos da linguagem de programação KRL
 Conhecimentos teóricos sobre a programação de mensagens

Definição de Tarefa parcial: Mensagem de diálogo


funções 1. Crie uma mensagem de diálogo com o texto "Selecione a quantidade de
cubos a serem transportados".
2. Disponibilize a quantidade 2, 3, 5, 8 e ocupe a 7ª softkey com "FIM".
3. Amplie o seu programa Magazine com o diálogo e saia do loop sem fim
com "FIM".
4. Teste o seu programa conforme a prescrição.
O que você deve saber agora:
1. Como são inscritas as teclas das softkeys no diálogo?
............................................................
............................................................

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 139 / 251


Programação do robô 2

140 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

7 Programação de movimento com KRL

7.1 Visão geral

Nesta unidade de aprendizagem são repassados os seguintes conteú-


dos:
 Programar movimento com KRL
 Programar movimentos relativos através do KRL
 Programação de Spline Blocks com KRL
 Calcular e manipular posições do robô
 Alterar objetivamente o status e turn

7.2 Programar movimentos individuais do SPLINE com KRL

Definição de um
movimento

Fig. 7-1: Formulário Inline Passo individual Movimento SPTP-/SLIN-/


SCIRC

Dados necessários para um movimento


 Tipo de movimento -SPTP, SLIN, SCIRC
 Posição de destino e possivelmente posição auxiliar
 Parada exata ou aproximação
 Velocidade - SPTP (%) e movimento de trajetória (m/s)
 Ferramenta - TCP e carga
 Sistema de coordenadas da base
 Ferramenta conduzida pelo robô ou externa
 Aceleração e solavanco (alteração da aceleração)
 event. parâmetro de aproximação
 Controle de orientação em movimentos de trajetória
 Ângulo circular em um movimento circular CIRC
 Controle de orientação no ponto auxiliar e de destino de um movimento
circular

7.3 Movimento de passo individual com SPTP

Descrição SPTP pode ser programado como segmento em um Spline Block PTP ou
como movimento individual.
É possível copiar um movimento individual SPTP em um Spline Block PTP,
mas somente se ele não contiver nenhuma atribuição às variáveis de sistema
que são proibidas ali.

Sintaxe SPTP Ponto de destino <WITH SysVar1 = Valor1 <, SysVar2 = Valor2 , …>>
<C_SPL>

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 141 / 251


Programação do robô 2

Explicação da Elemento Descrição


sintaxe Ponto de Tipo: AXIS, E6AXIS, POS, E6POS, FRAME
destino
As coordenadas cartesianas referem-se ao sistema de
coordenadas BASE.
Se não forem informados todos os componentes do ponto
de destino, a unidade de comando para os componentes
faltantes assume os valores da posição anterior. Se esta
posição anterior for o ponto de destino de um círculo com
ângulo circular, são assumidos os valores do ponto de
destino realmente atingido, não do ponto de destino pro-
gramado.
Se a unidade de comando do robô não conhecer nenhuma
posição anterior, os componentes que faltam serão assu-
midos da posição atual do robô.
SysVar
Valor Atribuição de valor à variável do sistema
Em segmentos SPTP: A atribuição vale apenas para esse
segmento.
As variáveis do sistema também podem ser ocupadas por
acesso funcional. Para essas funções valem as mesmas
restrições das funções no trigger.

C_SPL  Com C_SPL: O ponto de destino é aproximado. $APO


define o momento mais cedo para a aproximação.
Somente possível para movimentos individuais, não
para segmentos.
 Sem C_SPL: O ponto de destino é alcançado com exa-
tidão.

Até o System Software 8.2, o código para a aproximação no spline


era "C_DIS". Se programas em versões superiores a 8.x forem utili-
zados, os quais se baseiam em 8.2 ou estados mais antigos e con-
têm C_DIS, este não precisa ser alterado em C_SPL e pode ser deixado
como está.

Exemplos  O robô acessa uma posição do arquivo DAT; a posição foi programada
anteriormente com o formulário Inline e aproxima-se desse ponto P3
SPTP XP3 C_SPL

 O robô acessa uma posição introduzida


 Específico do eixo (AXIS ou E6AXIS)
SPTP {A1 0, A2 -80, A3 75, A4 30, A5 30, A6 110}

 Posição espacial (com ferramenta e base atualmente ativas)


SPTP {X 100, Y -50, Z 1500, A 0, B 0, C 90, S 3, T 35}

 O robô só opera com a inserção de um ou mais agregados


SPTP {A1 30} ; só A1 é deslocado para 30°

SPTP {X 200, A 30} ; só em X para 200mm e A para 30°

 O robô se move com valores alterados usando WITH


SPTP XP10 WITH $TOOL=tool_data[2], $LOAD=load_data[2] ; O ponto P10 é
alcançado com TOOL 2

142 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

7.4 Movimento de passo individual com SLIN e SCIRC

Descrição SLIN, SCIRC:


SLIN e SCIRC podem ser programados como segmento em um Spline Block
CP ou como movimento individual.
É possível copiar um movimento individual SLIN ou SCIRC em um Spline Blo-
ck CP, mas somente se ele não contiver nenhuma atribuição às variáveis de
sistema que são proibidas ali.

Sintaxe SLIN:
SLIN Ponto de destino <WITH SysVar1 = Valor1 <, SysVar2 = Valor2, …, >>
<C_SPL>
SCIRC:
SCIRC Ponto auxiliar, Ponto de destino <, CA Ângulo circular> <WITH SysVar1 =
Valor1 <,SysVar2 = Valor2 , … >> <C_SPL>

Explicação da Elemento Descrição


sintaxe Ponto auxi- Tipo: POS, E6POS, FRAME
liar
As coordenadas referem-se ao sistema de coordenadas
Ponto de BASE.
destino
Se não forem informados todos os componentes do ponto
de destino, a unidade de comando para os componentes
faltantes assume os valores da posição anterior. Se esta
posição anterior for o ponto de destino de um círculo com
ângulo circular, existe a seguinte diferenciação:
 Se a posição anterior estiver fora de um Spline Block,
são assumidos os valores do ponto de destino realmen-
te atingido, não do ponto de destino programado.
 Se a posição anterior estiver em um Spline Block, são
assumidos os valores do ponto de destino programado,
não do ponto de destino realmente atingido.
Se a unidade de comando do robô não conhecer nenhuma
posição anterior, os componentes que faltam serão assu-
midos da posição atual do robô.
Ângulo cir- Unidade: grau; sem limitação
cular

SysVar
Valor Atribuição de valor à variável do sistema
Em segmentos: A atribuição vale apenas para esse seg-
mento.
As variáveis do sistema também podem ser ocupadas por
acesso funcional. Para essas funções valem as mesmas
restrições das funções no trigger.

C_SPL  Com C_SPL: O ponto de destino é aproximado. $APO


define o momento mais cedo para a aproximação.
Somente possível para movimentos individuais, não
para segmentos.
 Sem C_SPL: O ponto de destino é alcançado com exa-
tidão.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 143 / 251


Programação do robô 2

Até o System Software 8.2, o código para a aproximação no spline


era "C_DIS". Se programas em versões superiores a 8.x forem utili-
zados, os quais se baseiam em 8.2 ou estados mais antigos e con-
têm C_DIS, este não precisa ser alterado em C_SPL e pode ser deixado
como está.

Exemplos SLIN:
 O robô se movimenta em uma posição calculada aproximando esse ponto
ABLAGE[4]
SLIN ABLAGE[4] C_SPL

 O robô se move para o ponto P4 com estes valores de aceleração


SLIN P4 WITH $ACC={CP 1.8, ORI1 120, ORI2 140}

SCIRC
 O robô acessa as posições previamente programadas do arquivo DAT e
percorre um ângulo inscrito de 190°.
SCIRC XP3, XP4, CA 190

 O robô acessa as posições indicadas e percorre um ângulo inscrito de


180°.
SCIRC {X 100, Y ...}, {X 150, Y ...}, CA 180

 Ângulo circular positivo (CA>0): O círculo é operado no sentido progra-


mado: ponto de partida-ponto auxiliar-ponto de destino

Fig. 7-2: Ângulo do círculo CA = +290°

 Ângulo circular negativo (CA<0): o círculo é operado contra o sentido


programado: ponto de partida-ponto de destino-ponto auxiliar

144 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

Fig. 7-3: Ângulo do círculo CA = -290°

7.5 Parâmetros de movimento

Função dos Configurações prévias para a programação de movimento


parâmetros de  Podem ser assumidas as configurações existentes:
movimento
 a partir da passagem da linha INI
 a partir do último formulário Inline
 a partir das últimas configurações das respectivas variáveis de siste-
ma
 Modificar ou inicializar as respectivas variáveis de sistema
Variáveis de sistema dos parâmetros de movimento
 Ferramenta: $TOOL e $LOAD
 Ativação dos TCPs medidos
$TOOL = tool_data[x] ; x = 1...16

 Ativação dos respectivos dados de carga


$LOAD = load_data[x] ; x = 1...16

 Base de referência / base de trabalho: $BASE


 Ativação da base medida
$BASE = base_data[x] ; x = 1...32

 Ferramenta conduzida pelo robô ou externa: $IPO_MODE


 Ferramenta conduzida por robô
$IPO_MODE = #BASE

 Ferramenta externa
$IPO_MODE = #TCP

 Velocidade:
 Em movimento PTP
$VEL_AXIS[x] ; x=1...8 para cada eixo

 Em movimentos de trajetória LIN ou CIRC

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 145 / 251


Programação do robô 2

$VEL.CP = 2.0 ; [m/s] Velocidade trajetória

$VEL.ORI1 = 150 ; [°/s] Velocidade de oscilação

$VEL.ORI2 = 200 ; [°/s] Velocidade de rotação

A direção de trabalho da ferramenta é geralmente o eixo X. A veloci-


dade de rotação é a rotação em torno desse eixo X com o ângulo C.
Na velocidade de giro, é girado em torno dos outros dois ângulos (A
e B).

 Aceleração
 Em movimento PTP
$ACC_AXIS[x] ; x=1...8 para cada eixo

 Em movimentos de trajetória LIN ou CIRC


$ACC.CP = 2.0 ; [m/s²] Aceleração de trajetória

$ACC.ORI1 = 150 ; [°/s²] Aceleração de oscilação

$ACC.ORI2 = 200 ; [°/s²] Aceleração de rotação

 Solavanco
 Em movimento SPTP
$GEAR_JERK[1...12] = 0 ... 100 Solavanco de redutor dos eixos A1 a E6
em porcentagem (1...100)
SPTP XP10 WITH GEAR_JERK[1]=22, GEAR_JERK[2]=66

 Em movimentos de trajeto SLIN ou SCIRC


$JERK={CP 50.0,ORI 50000.0,AX {A1 1000.0,A2 1000.0,A3 1000.0,A4
1000.0,A5 1000.0,A6 1000.0,E1 1000.0,E2 1000.0,E3 1000.0,E4 1000.0,E5
1000.0,E6 1000.0}}

O agregado consiste nos seguintes componentes:

 CP: Alteração da aceleração de trajeto em [m/s3]


 ORI: Alteração da aceleração de orientação em [°/s3]
 AX: Alteração da aceleração do eixo em [°/s3] em eixos rotatórios
ou em [m/s3] em eixos lineares
SLIN XP13 WITH $JERK = {CP 44} ; [m/s³] Alteração da aceleração de
trajeto

 Distância de aproximação
 Em SPINE passos individuais SLIN, SCIRC e em SPTP: C_SPL
A distância do ponto de destino deverá ser inferior ao valor
$APO.CDIS
$APO.CDIS = 250.0 ; [mm] Distância
SPTP XP3 C_SPL
SLIN XP4 C_SPL

 Somente em movimento PTP: C_PTP


$APO.CPTP = 50 ; Tamanho de aproximação em [%] em C_PTP
PTP XP3 C_PTP

 Em movimentos de trajetória LIN, CIRC: C_ORI


O ângulo de orientação dominante deverá ficar abaixo do valor
$APO.CORI
$APO.CORI = 50.0 ; [°] Ângulo
SLIN XP4 C_ORI

146 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

 Em movimentos de trajetória LIN, CIRC: C_VEL


A velocidade na fase de frenagem para o ponto de destino deverá ser
inferior a $APO.CVEL
$APO.CVEL = 75.0 ; [%] Porcentagem
LIN XP4 C_VEL

 Controle de orientação: Somente para LIN e CIRC


 Para LIN e CIRC: $ORI_TYPE

$ORI_TYPE = #CONSTANT

Durante o movimento de trajetória a orientação permanece cons-


tante. Para o ponto final, a orientação programada é ignorada

Fig. 7-4: Orientação constante

$ORI_TYPE = #VAR

Durante o movimento de trajetória, a orientação é alterada conti-


nuamente até a orientação do ponto de destino.

Fig. 7-5: Padrão ou PTP manual

$ORI_TYPE = #JOINT

Durante o movimento de trajetória, a orientação da ferramenta é


alterada continuamente da posição inicial à posição final. Isso é
realizado através de transferência linear dos ângulos de eixos da
mão. A problemática da singularidade manual pode ser evitada
com esta opção. Ocorre uma rotação em torno da direção de tra-

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 147 / 251


Programação do robô 2

balho da ferramenta. Não é possível um giro em torno da direção


de trabalho da ferramenta.
 Somente em CIRC: $CIRC_TPYE

A variável $CIRC_TYPE não tem importância , quando houver uma


transferência linear dos ângulos de eixos de mão com $ORI_TYPE =
#JOINT.

$CIRC_TYPE = #PATH

Controle de orientação referente à trajetória durante o movimento


circular

Fig. 7-6: Orientação constante, referente ao trajeto

$CIRC_TYPE = #BASE

Controle de orientação referente ao espaço durante o movimento


circular

Fig. 7-7: Orientação constante, referente à base

Configuração de Em movimentos SCIRC, a unidade de comando do robô pode levar em con-


círculo SCIRC sideração a orientação programada do ponto auxiliar. Se e até que ponto ela
é realmente levada em consideração, o usuário pode definir:

148 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

 Na programação com sintaxe KRL: através da variável de sistema


$CIRC_MODE
 Na programação através de formulários inline: na janela de opções Parâ-
metros de movimento, guia Configuração de círculo
Além disso, é possível determinar, da mesma forma, para instruções SCIRC
com ângulo circular, se o ponto de destino deve ter a orientação programada
ou se a orientação deve ser continuada de acordo com o ângulo circular.
$CIRC_MODE é gravável apenas através de uma instrução SCIRC.
$CIRC_MODE não pode ser lido.
Sintaxe KRL
 Para pontos auxiliares:
$CIRC_MODE.AUX_PT.ORI = Comportamento PA
 Para pontos de destino:
$CIRC_MODE.TARGET_PT.ORI = Comportamento PD

Elemento Descrição
Compor- Tipo de dados: ENUM / menu suspenso
tamento PA
 #INTERPOLATE: No ponto auxiliar o TCP assume a
Comporta- orientação programada.
mento de
 #IGNORE: A unidade de comando do robô ignora a
orientação
orientação programada do ponto de ajuda. A orientação
no ponto
de início do TCP é transferida no trajeto mais curto para
auxiliar
a orientação de destino.
 #CONSIDER (padrão):
Basicamente existem 2 caminhos como a orientação
de início com uma rotação pode ser transferida para a
orientação de destino: Um mais curto e um mais longo.
Com #CONSIDER, a unidade de comando do robô se-
leciona o caminho que se aproxima da orientação pro-
gramada do ponto auxiliar. Pode ser que o TCP
assuma a orientação programada do ponto auxiliar em
algum lugar no caminho. Mas este não precisa ser o ca-
so.
Compor- Tipo de dados: ENUM / menu suspenso
tamento PD
 #INTERPOLATE: No ponto de destino real, é assumida
Comporta- a orientação programada do ponto de destino.
mento de (Única possibilidade para SCIRC sem indicação de ân-
orientação
gulo circular. Se #EXTRAPOLATE for ativado, apesar
no ponto de
disso #INTERPOLATE é executado.)
destino
 #EXTRAPOLATE: A orientação é adaptada ao ângulo
circular:
Se o ângulo circular prolongar o movimento, é assumi-
da a orientação programada no ponto de destino pro-
gramado. Até o ponto de destino real, a orientação é
correspondentemente continuada.
Se o ângulo circular encurtar o movimento, a orientação
programada não é atingida.
(Padrão para SCIRC com indicação de ângulo circular)

7.5.1 SCIRC: Comportamento de orientação – Exemplo ponto auxiliar

Descrição Para o TCP foram programadas as seguintes orientações:


 Ponto de partida: 0°

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 149 / 251


Programação do robô 2

 Ponto auxiliar: 98°


 Ponto de destino: 197°
A reorientação, portanto, é 197°. Se o ponto auxiliar for ignorado a orientação
de destino também pode ser atingida através da reorientação menor de 360° -
197° = 163°.
 As setas tracejadas laranja indicam a orientação programada.
 As setas cinza indicam esquematicamente como seria a orientação efeti-
va, desde que ela desvie da orientação programada.

#INTERPOLATE No ponto auxiliar o TCP assume a orientação programada de 98°. A reorien-


tação é 197°.

Fig. 7-8: #INTERPOLATE

SP Ponto de partida
AuxP Ponto auxiliar
TP Ponto de destino

#IGNORE É executada a reorientação curta com 163°. A orientação programada do pon-


to auxiliar é ignorada.

Fig. 7-9: #IGNORE

#CONSIDER
#CONSIDER é apropriado quando o usuário quer determinar em que
sentido o TCP deve reorientar, sem depender de uma determinada
orientação no ponto auxiliar. O usuário pode especificar o sentido
através do ponto auxiliar.

A orientação programada do ponto auxiliar é de 98° e, portanto, está no trajeto


mais longo. Por isso, a unidade de comando do robô toma o trajeto mais longo
na reorientação.

150 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

Fig. 7-10: #CONSIDER

Outro exemplo para #CONSIDER:


Se o ponto auxiliar estivesse programado com 262°, ele estaria no trajeto
mais curto. Por isso, a unidade de comando do robô tomaria o trajeto mais
curto na reorientação. As setas cinza indicam que aqui, de modo algum, ela
necessariamente assume a orientação programada do ponto auxiliar.

Fig. 7-11: #CONSIDER, outro exemplo

7.5.2 SCIRC: Comportamento de orientação – Exemplo ponto de destino

Descrição  As setas tracejadas laranja indicam a orientação programada.


 As setas cinza indicam a orientação efetiva, desde que ela desvie da
orientação programada.

#INTERPOLATE No TP, que se encontra antes do TP_CA, a orientação programada ainda não
foi atingida. No TP_CA é assumida a orientação programada.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 151 / 251


Programação do robô 2

Fig. 7-12: #INTERPOLATE

SP Ponto de partida
AuxP Ponto auxiliar
TP Ponto de destino programado
TP_CA Ponto de destino efetivo. Resulta através do ângulo inscrito.

#EXTRAPOLATE No TP é assumida a orientação programada. Para TP_CA esta orientação é


continuada de acordo com o ângulo inscrito.

Fig. 7-13: #EXTRAPOLATE

7.5.3 Restrições em $CIRC_MODE

Restrições Descrição da descrição das variáveis de sistema


 Se para um segmento SCIRC valer $ORI_TYPE = #IGNORE, então
$CIRC_MODE não é avaliado.
 Se um segmento SCIRC for antecedido por um segmento SCIRC ou
SLIN, para o qual vale o $ORI_TYPE = #IGNORE, então #CONSIDER
não pode ser utilizado neste segmento SCIRC.
Para SCIRC com ângulo inscrito:
 Para o ponto auxiliar não pode ser setado #INTERPOLATE.
 Se valer $ORI_TYPE = #IGNORE, não pode ser setado #EXTRAPOLATE
para o ponto de destino.

152 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

 Se estiver antecedido um segmento Spline, para o qual vale o


$ORI_TYPE = #IGNORE, não pode ser setado #EXTRAPOLATE para o
ponto de destino.

Explicação sobre Algumas mensagens de erro contêm o texto "Erro por causa da regra x"
mensagens de Na programação de $CIRC_MODE deve ser observado, tanto para a orienta-
erro ção como também para os eixos adicionais:
1. Regra 1: #CONSIDER é permitido exatamente quando o ponto de partida
e o ponto de destino não forem ignorados.
2. Regra 2: $CIRC_TYPE=#PATH é permitido exatamente quando o ponto
de partida e o ponto de destino não forem ignorados.
3. Regra 3: se $ORI_TYPE=#IGNORE ou $EX_AX_IGNORE estiverem se-
tados, $CIRC_MODE não é mais avaliado.
4. Regra 4: se estiver programado um ângulo inscrito, é proibida a interpola-
ção no ponto auxiliar.
5. Regra 5: se estiver programado um ângulo inscrito, o ponto de destino
pode ser determinado por extrapolação exatamente quando o ponto de
partida e o ponto inicial não são ignorados.
6. Regra 6: se estiver programado um ângulo inscrito, o ponto de destino
pode ser assumido (interpolado) exatamente quando ele não é ignorado.
7. Regra 7: o trajeto #CONSIDER somente atua em eixos adicionais rotati-
vos sem fim. Em outros tipos de eixo sempre é escolhido o trajeto mais
curto, que corresponde a #IGNORE.
8. Regra 8: o componente TARGET_PT somente é levado em consideração
se estiver programado um ângulo inscrito.
9. Regra 9: a leitura de $CIRC_MODE não é permitida em lugar algum, a
gravação somente no WITH-Token de um SCIRC.

7.6 Movimentos individuais do SPLINE: Variáveis de sistema para WITH

Spline Block, Para Spline Blocks e movimentos individuais do spline, as seguintes variáveis
movimento de sistema são graváveis com a linha WITH:
individual do $ACC
spline
$ACC_AXIS
$ACC_EXTAX
$APO
$BASE
$CIRC_TYPE
$ECO_LEVEL
$GEAR_JERK
$IPO_MODE
$JERK
$LOAD
$ORI_TYPE
$ROTSYS
$SPL_ORI_JOINT_AUTO
$SYNC_ID
$SYNC_LIST
$TOOL

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 153 / 251


Programação do robô 2

$VEL
$VEL_AXIS
$VEL_EXTAX
Adicionalmente para SCIRC e SLIN: $CIRC_MODE

As variáveis de sistema estão descritas no capítulo Variáveis de sis-


tema.

7.7 Programar movimentos relativos e absolutos com KRL

Movimento SPTP {A3 45}


absoluto
Acesso da posição de destino com valores absolutos. Aqui, o eixo A3 é posi-
cionado a 45º.

Fig. 7-14: Movimento absoluto do eixo A3

Movimento SPTP_REL {A3 45}


relativo
Acesso da posição de destino, continuando da posição atual com o valor in-
dicado. Aqui o eixo A3 é posicionado a 45° a partir da posição atual em 135°.

154 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

Fig. 7-15: Movimento relativo do eixo A3

Uma instrução REL sempre se refere à posição atual do robô. Se um


movimento REL foi cancelado, o robô realiza o movimento completo
REL a partir da posição de cancelamento.

SPTP_REL:
SPTP_REL pode ser programado como segmento em um Spline Block PTP
ou como movimento individual.
É possível copiar um movimento individual SPTP_REL em um Spline Block
PTP, mas somente se ele não contiver nenhuma atribuição às variáveis de
sistema que são proibidas ali.
SLIN_REL, SCIRC_REL:
SLIN_REL e SCIRC_REL podem ser programados como segmento em um
Spline Block CP ou como movimento individual.
É possível copiar um movimento individual SLIN_REL ou SCIRC_REL em um
Spline Block CP, mas somente se ele não contiver nenhuma atribuição às va-
riáveis de sistema que são proibidas ali.

Movimentos relativos SPTP_Rel, SLIN_REL e SCIRC_REL estão


disponível somente a partir do software KSS 8.3.6

Sintaxe SPTP_REL:
SPTP_REL Ponto de destino <WITH SysVar1 = Valor1 <, SysVar2 = Valor2 , …>>
<C_SPL><#BASE|#TOOL>

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 155 / 251


Programação do robô 2

Elemento Descrição
Ponto de Tipo: AXIS, E6AXIS, POS, E6POS, FRAME
destino
O ponto de destino pode ser cartesiano ou específico do
eixo. A unidade de comando interpreta as coordenadas
como relativas ao ponto de destino do passo anterior.
Se não forem informados todos os componentes do ponto
de destino, a unidade de comando coloca os componentes
faltantes no valor 0. Isso significa que os valores absolutos
desses componentes permanecerão inalterados.
Os dados relativos a Status e Turn, se existentes, são con-
siderados pela unidade de comando. (Isso contrasta com
SLIN_REL, SCIRC_REL e SPL_REL, onde eles são igno-
rados!)
Valor Atribuição de valor à variável do sistema
Em segmentos SPTP: A atribuição vale apenas para esse
segmento.
As variáveis do sistema também podem ser ocupadas por
acesso funcional. Para essas funções valem as mesmas
restrições das funções no trigger.
C_SPL  Com C_SPL: O ponto de destino é aproximado. $APO
define o momento mais cedo para a aproximação.
Somente possível para movimentos individuais, não
para segmentos.
 Sem C_SPL: O ponto de destino é alcançado com exa-
tidão.
#BASE, Apenas permitido se o ponto de destino cartesiano tiver
#TOOL sido indicado.
 #BASE (padrão): As coordenadas deste ponto de des-
tino se referem ao sistema de coordenadas que perten-
ce à base física.
 #TOOL: As coordenadas deste ponto de destino se re-
ferem ao sistema de coordenadas que pertence à ferra-
menta física.
$IPO_MODE não tem nenhuma influência no significado
de #BASE e #TOOL.

SLIN_REL:
SLIN_REL Ponto de destino <WITH SysVar1 = Valor1 <, SysVar2 = Valor2, …, >>
<C_SPL><#BASE|#TOOL>
SCIRC_REL:
SCIRC_REL Ponto auxiliar, Ponto de destino <, CA Ângulo circular> <WITH
SysVar1 = Valor1 <,SysVar2 = Valor2 , … >> <C_SPL><#BASE|#TOOL>

156 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

Elemento Descrição
Ponto auxiliar Tipo: POS, E6POS, FRAME
Ponto de des- O ponto deve ser indicado em coordenadas cartesianas. A
tino unidade de comando interpreta as coordenadas como rela-
tivas ao ponto de destino do movimento anterior.
Se nem todos os componentes do ponto forem indicados,
a unidade de comando define os componentes que faltam
para o valor 0. Isso significa que os valores absolutos des-
ses componentes permanecerão inalterados.
Os dados relativos a Status e Turn, se existentes, são
ignorados pela unidade de comando. (Isso contrasta com
SPTP_REL, onde eles são considerados!)
Além disso, no ponto auxiliar são ignorados os ângulos de
orientação.
O ponto auxiliar não pode ser aproximado. É sempre acio-
nado exatamente.
Ângulo circu- Unidade: grau; sem limitação
lar
Valor Atribuição de valor à variável do sistema
Em segmentos: A atribuição vale apenas para esse seg-
mento.
As variáveis do sistema também podem ser ocupadas por
acesso funcional. Para essas funções valem as mesmas
restrições das funções no trigger.
C_SPL  Com C_SPL: O ponto de destino é aproximado. $APO
define o momento mais cedo para a aproximação.
Somente possível para movimentos individuais, não
para segmentos.
 Sem C_SPL: O ponto de destino é alcançado com exa-
tidão.
#BASE,  #BASE (padrão): As coordenadas deste ponto de des-
#TOOL tino se referem ao sistema de coordenadas que perten-
ce à base física.
 #TOOL: As coordenadas deste ponto de destino se re-
ferem ao sistema de coordenadas que pertence à ferra-
menta física.
$IPO_MODE não tem nenhuma influência no significado
de #BASE e #TOOL.

Exemplo  O eixo 2 é deslocado em 30° no sentido negativo. Os demais eixos não


se movimentam.
PTP_REL {A2 -30}

 O robô se movimenta a partir da posição atual em 100 mm no sentido X e


em 200 mm no sentido Z negativo. Y, A, B, C, e S permanecem constan-
tes. T é calculado conforme o trajeto mais curto.
PTP_REL {X 100,Z -200}

 O TCP se movimenta a partir da posição atual em 100 mm no sentido X e


em 200 mm no sentido Z negativo no sistema de coordenadas BASE. Y,
A, B, C e S permanecem constantes. T resulta do movimento.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 157 / 251


Programação do robô 2

LIN_REL {X 100,Z -200} ; #BASE é ajuste padrão

A informação #BASE ou #TOOL refere-se somente à orientação


LIN_REL, à qual ela pertence. Não tem efeito sobre as orientações se-
guintes.
 O TCP se movimenta a partir da posição atual em 100 mm no sentido X
negativo no sistema de coordenadas TOOL. Y, Z, A, B, C e S permane-
cem constantes. T resulta do movimento.
Esse exemplo é adequado para movimentar a ferramenta ao longo da di-
reção de trabalho para trás. O pré-requisito é que a direção de trabalho da
ferramenta tenha sido medida no sentido X.
LIN_REL {X -100} #TOOL

 O ponto de destino do movimento circular é definido por um ângulo circu-


lar de 500°. O ponto de destino é aproximado.
CIRC_REL {X 100,Y 30,Z -20},{Y 50},CA 500 C_VEL

 Exemplos de sintaxe

SPTP XHOME
SLIN XP1

SLIN_REL{X 0, Y 500, Z 0, A 0, B 0, C 0} WITH $BASE=$NULLFRAME #BASE


SLIN_REL{X 400} WITH $TOOL=TOOL_DATA[1], $LOAD=LOAD_DATA[1] C_SPL
#TOOL
SLIN_REL{A 20}
SPTP_REL{A3 90} C_SPL
SPTP_REL Z 50, B -30} WITH $VEL.AXIS[4]=90 C_SPL #TOOL
SPTP_REL{A1 100}

PTP_REL {A6 360}


A6 não se move, uma vez que a unidade de comando interpreta po-
sição de destino e posição final como idênticas, e ocorre um cálculo
de resto.
SPTP_REL {A6 360}
A6 se move em 360°, pois não é realizado nenhum cálculo de resto.

7.8 Calcular ou manipular posições de robô

Descrição Posições de destino robô


 são arquivadas em estruturas:
 Existem as seguintes estruturas predefinidas.
 AXIS
Ângulo de eixo A1 ... A6
 E6AXIS
Ângulo de eixo A1 ... A6 e E1 ... E6
 POS
Posição (X, Y, Z), orientação (A, B, C) com Status e Turn (S, T)
 E6POS
Posição (X, Y, Z), orientação (A, B, C) com Status e Turn (S, T) e E1
... E6
 FRAME -
Posição (X, Y, Z), orientação (A, B, C)

158 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

 Podem ser manipuladas posições existentes do arquivo DAT.


 Agregados individuais de posições existentes podem ser alterados direta-
mente com separador de ponto.

Princípio
No cálculo é importante observar os ajustes TOOL e
BASE corretos e ativá-los posteriormente na programa-
ção de movimentos. Se isso não for observado podem ocorrer movimentos
inesperados e colisões.

Variáveis de sistema importantes


 $POS_ACT: posição atual do robô. A variável (E6POS) descreve a posi-
ção planejada do TCP em relação ao sistema de coordenadas BASE.
 $AXIS_ACT: posição atual do robô específica do eixo (valor nominal). A
variável (E6AXIS) contém o ângulo atual do eixo ou posições do eixo
Calcular a posição de destino absoluta
 Alterar uma vez a posição do arquivo DAT
XP1.x = 450 ; novo valor X 450mm
XP1.z = 30.0*distance ; se calcula novo valor Z
SPTP XP1

 Alterar a cada passagem a posição do arquivo DAT


; valor X deslocado cada vez 450mm
XP2.x = XP2.x + 450
SPTP XP2

 A posição é assumida e salva em uma variável


myposition = XP3
myposition.x = myposition.x + 100 ; ao valor x é acrescido 100mm
myposition.z = 10.0*distance ; Calcular novo valor Z
myposition.t = 35 ; Colocar valor Turn
SPTP XP3 ; Posição não foi alterada
SPTP myposition ; Posição calculada

Procedimento 1. Como perito, carregue o programa com a tecla Abrir no editor


2. Calcular/manipular a posição. Salvar os novos valores calculados
em uma nova variável, se for o caso
3. Verificar os ajustes iniciais para a programação de movimentos e assumir
ou reinicializar
 Ferramenta ($TOOL e $LOAD)
 Configuração-base ($BASE)
 Ferramenta conduzida pelo robô ou externa ($IPO_MODE)
 Velocidade
 Aceleração
 Distância de aproximação, caso se aplique
 Possivelmente controle de orientação
4. Criar o comando de movimento completo
 Tipo de movimento (SPTP, SLIN, SCIRC, SPTP_REL, SLIN_REL,
SCIRC_REL)
 Ponto de destino (para SCIRC também ponto auxiliar)
 Para SCIRC possivelmente ângulo circular (CA)
 Ativar aproximação (C_SPL, C_DIS)
5. No caso de novo movimento, retornar ao ponto 3
6. Fechar editor e salvar

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 159 / 251


Programação do robô 2

7.9 Modificar exatamente bits de Status e Turn

Descrição  Os valores da posição (X, Y, Z) e orientação (A, B, C) do TCP não são


suficientes para definir claramente a posição de um robô, uma vez que
com o mesmo TCP são possíveis diversas posições de eixo. Status e
Turn servem para definir uma posição inequívoca a partir de diversas po-
sições de eixos possíveis.

Fig. 7-16: Diferentes posições de eixos condicionadas através de dife-


rentes valores de Status e Turn

 Status (S) e Turn (T) são partes integrantes dos tipos de dados POS e
E6POS:
STRUC POS REAL X, Y, Z, A, B, C, INT S, T

STRUC E6POS REAL X, Y, Z, A, B, C, E1, E2, E3, E4, E5, E6, INT S, T

 A unidade de comando do robô leva em consideração apenas os valores


programados de Status e Turn somente em movimentos SPTP. Em mo-
vimentos CP eles são ignorados.
 A primeira instrução de movimento em um programa KRL deverá ser, por-
tanto, uma das seguintes orientações para que haja uma posição inicial
inequívoca para o robô:
 Instrução SPTP completa do tipo POS ou E6POS
 Ou uma instrução SPTP completa do tipo AXIS ou E6AXIS.
"Completa" significa que todos os componentes do ponto de destino
devem ser indicados. A posição Default-HOME é sempre uma instru-
ção PTP completa.
 Nas demais instruções podem ser omitidas Status e Turn:
 A unidade de comando do robô mantém o valor de status atual.
 O valor Turn é concluído pelos movimentos CP da trajetória.
 No caso de movimentos SPTP, a unidade de comando do robô sele-
ciona um valor Turn, que gera o trajeto mais curto possível (isto é, não

160 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

é violado nenhum interruptor de fim de curso de Software e é ao mes-


mo tempo o mais próximo ao ângulo de partida).

Função STATUS
 A informação de Status evita ambiguidades na posição do eixo.
 Bit 0: informa a posição do ponto de interseção dos eixos da mão (A4, A5,
A6).

Posição Valor
Zona acima da cabeça Bit 0 = 1
O robô encontra-se na zona acima da cabeça, quando
o valor X do ponto de interseção dos eixos da mão, em
relação ao sistema de coordenadas A1, for negativo.
Zona base Bit 0 = 0
O robô encontra-se na zona base, quando o valor X do
ponto de interseção dos eixos da mão, em relação ao
sistema de coordenadas A1, for positivo.

Fig. 7-17: Exemplo: o ponto de interseção dos eixos manuais (ponto ver-
melho) está na área básica.

 Bit 1: informa a posição do eixo 3. O ângulo, no qual o valor de Bit 1 muda,


depende do tipo do robô.
Para robôs, cujos eixos 3 e 4 se cruzam, aplica-se:

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 161 / 251


Programação do robô 2

Posição Valor
A3 ≥ 0° Bit 1 = 1
A3 < 0° Bit 1 = 0

No caso de robôs com um Offset entre o eixo 3 e 4, o ângulo, no qual o


valor de Bit 1 muda, depende do tamanho desse Offset.

Fig. 7-18: Offset entre A3 e A4: Exemplo KR 30

 Bit 2: informa a posição do eixo 5.

Posição Valor
A5 > 0 Bit 2 = 1
A5 ≤ 0 Bit 2 = 0

 Bit 3 não é usado e é sempre 0.


 Bit 4: informa se o ponto em um robô com precisão absoluta foi ensinado
ou não.
O ponto pode ser acionado independente do valor do bit, tanto com robôs
com precisão absoluta como com robôs sem precisão absoluta. O bit 4
serve somente para informação e não tem influência, como a unidade de
comando do robô calcula o ponto. Isso significa também que quando um
robô é programado offline, o bit 4 pode ser desconsiderado.

Descrição Valor
O ponto não foi ensinado com um robô com precisão Bit 4 = 0
absoluta.
O ponto foi ensinado com um robô com precisão abso- Bit 4 = 1
luta.

TURN
 A informação Turn permite se aproximar também de ângulos de eixos
maiores que +180° ou menores que -180° sem uma estratégia específica
de procedimento (por exemplo, pontos intermediários). No caso de eixos
rotatórios, os respectivos bits determinam o sinal do valor axial da forma
seguinte:
Bit = 0: Ângulo ≥ 0 °
Bit = 1: Ângulo < 0 °
 Todos os eixos na visão geral

Valor Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0


0 A6 ≥ 0 ° A5 ≥ 0 ° A4 ≥ 0 ° A3 ≥ 0 ° A2 ≥ 0 ° A1 ≥ 0 °
1 A6 < 0 ° A5 < 0 ° A4 < 0 ° A3 < 0 ° A2 < 0 ° A1 < 0 °

162 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

 Exemplo
DECL POS XP1 = {X 900, Y 0, Z 800, A 0, B 0, C 0, S 6, T 19}

T 19 corresponde T 'B010011'. Isto significa:

Eixo Ângulo Binário


A1 negativo 1
A2 negativo 2
A3 positivo 4
A4 positivo 8
A5 negativo 16
A6 positivo 32

Procedimento 1. Abrir o programa como perito.


2. Manipular Status e Turn. Salvar os novos valores calculados em uma
nova variável, se for o caso
3. Verificar os ajustes prévios para a programação de movimentos e assumir
ou reinicializar
 Ferramenta ($TOOL e $LOAD)
 Configuração-base ($BASE)
 Ferramenta conduzida pelo robô ou externa ($IPO_MODE)
 Velocidade
 Aceleração
 Distância de aproximação, caso se aplique
 Eventualmente controle de orientação
4. Criar o comando de movimento completo como passo individual
 Tipo de movimento (SPTP, SLIN, SCIRC)
 Ponto de destino (para SCIRC também ponto auxiliar)
 Para CIRC, eventualmente ângulo circular (CA)
 Ativar aproximação (C_SPL, C_DIS)
5. No caso de novo movimento, retornar ao ponto 3
6. Fechar editor e salvar

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 163 / 251


Programação do robô 2

7.10 Exercício: Paletizar e despaletizar

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Trabalhar com campos
 Cálculo de coordenadas de posição
 Manuseio com estruturas e o separador de ponto
 Uso de loops FOR em cadeias
 Programação de movimentos sem formulários Inline
 Acesso de coordenadas de destino calculadas

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos sobre campos, estruturas, loop FOR
 Conhecimentos teóricos sobre manipulação de dados
 Conhecimentos teóricos sobre a programação de movimentos sem for-
mulário Inline

Definição de Deverá ser criado um programa com o qual 16 cubos são retirados do maga-
funções zine de cubos e colocados nas posições previstas na mesa. Em seguida, to-
dos os cubos devem ser coletados e retornados ao magazine de cubos.
Todas as posições a serem acessadas devem ser calculadas com base emu-
ma posição ensinada. As posições de entrega deverão ser acionadas com po-
sições prévias, também calculadas. As distâncias entre as respectivas
posições de depósito são de 80 mm para todos os lados. A distância entre a
posição de depósito e a posição prévia deverá ser de 100 mm.
Tarefa parcial 1: Fluxograma do programa
 Crie um PAP para a tarefa descrita.
Tarefa parcial 2: Cálculo das posições de entrega
1. Crie a posição inicial com um formulário Inline.
2. Crie variáveis adequadas para o cálculo das posições de depósito.
3. Inicialize as suas variáveis com valores de início adequados.
4. Calcule as 16 posições de entrega na mesa de trabalho.

164 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

Fig. 7-19

Tarefa parcial 3: Cálculo das posições prévias


1. Essa posição está 100 mm acima da posição de mesa real do cubo.
2. Crie variáveis adequadas para o cálculo das posições prévias.
3. Inicialize as suas variáveis com valores de início adequados.
4. Calcule as 16 posições prévias 100 mm acima da mesa. Como base para
o cálculo valem as posições de entrega já calculadas.

Fig. 7-20

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 165 / 251


Programação do robô 2

Tarefa parcial 4: Paletização e despaletização dos módulos


1. Amplie o seu programa com os comandos de movimento necessários, de
forma que todos os módulos sejam depositados sobre a mesa e depois
coletados.
2. Para buscar e depositar os cubos no magazine devem ser usados os mó-
dulos já existentes.
3. Utilize para isto somente comandos KRL.
4. Se necessário, use os recursos aprendidos para estruturar o seu progra-
ma.
O que você deve saber agora:
1. Calcule os valores para A, B, C, X, Y, Z:
INT X, Y, Z
REAL A, B, C
A = 4.5 ;A= ……………
B = -2 ;B= ……………
C = 4.1 ;C= ……………
X= 2.5 ;X= ……………
Y=4 ;Y= ……………
Z =0.1 ;Z= ……………
A=A*B+Y ;A = ……………
B=B*Z+X ;B = ……………
C = C + 4/3 ;C = ……………
X= X + 2.5 * 4 ;X = ……………
Y = Y – 10.0/4 ;Y = ……………
Z = 14 – Z * C + A ;Z = ……………
2. O que indica a informação CA no movimento circular?
.............................................................
.............................................................
3. Como é o ajuste para TCP externo?
.............................................................
.............................................................
4. Como é ajustada a aproximação em um movimento LIN?
.............................................................
.............................................................

166 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

7.11 Programação de SPLINE Blocks

 Além dos passos individuais com SPTP, SLIN, SCRIC e dos movimentos
relativos, está disponível um "SPLINE Block".
 O SPLINE Block é visto e planejado como movimento individual com um
"trajeto complexo".
 Existem dois tipos de SPLINE Blocks:
 SPLINE Block CP: Spline com movimentos CP (SPL, SLIN, SCIRC)
 SPLINE Block PTP: Spline com movimentos exclusivamente no espa-
ço de eixo (somente SPTP)
 Conceito de Block: Um SPLINE Block é um passo de movimento com uma
TOOL, uma BASE e um IPO_MODE, mas diferentes velocidades e ace-
lerações nos segmentos individuais.
 O trajeto é planejado através de todos os pontos, assim todos os pontos
são percorridos.
 O trajeto é completamente calculado antes. Com isso, tudo é conhecido e
o planejamento pode colocar o trajeto idealmente na zona de trabalho dos
eixos.
 O spline não pode contradizer a física. Trajetos, que têm contornos muito
apertados, implicarão sempre na redução da velocidade, uma vez que os
eixos do robô são sempre os elementos limitantes.
 Dentro de um Spline Block, não é necessária nenhuma aproximação, já
que é definido um trajeto através de todos os pontos. Apesar disso, há ca-
sos em que a velocidade de trajeto cai para 0 m/s.
 Ainda podem ser configuradas funções adicionais como "velocidade
constante" ou "tempo fixo definido".
 Se o robô se afastar dos pontos que estão em uma superfície de trabalho,
pode ocorrer uma colisão no deslocamento do primeiro ponto com a su-
perfície de trabalho.

Fig. 7-21: Colisão com a superfície de trabalho

Para evitar uma colisão, observar as recomendações para a transferência


SLIN-SPL-SLIN.
(>>> 7.10.5 "Transição SLIN-SPL-SLIN" Página 177)

Fig. 7-22: Evitar colisão com a superfície de trabalho

Um spline block que não contém nenhum segmento, não é uma instrução de
movimento. O número de segmentos no bloco é limitado apenas pela capaci-
dade de memória. Além dos segmentos, um spline block pode conter os se-
guintes elementos:

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 167 / 251


Programação do robô 2

 Comandos Inline dos pacotes de tecnologia, que estão disponíveis atra-


vés da funcionalidade Spline
 Comentários e linhas em branco
Um spline block não deve conter nenhuma outra instrução, por exemplo, atri-
buições de variáveis ou instruções de lógica.

O ponto de partida de um spline block é o último ponto antes do spli-


ne block.
O ponto de destino de um spline block é o último ponto no spline blo-
ck.
Um spline block não ativa nenhum stop de avanço.

7.11.1 Perfil de velocidade em movimentos do SPLINE

Velocidade do O trajeto transcorre sempre igual, independente de override, velocidade ou


SPLINE aceleração.
A unidade de comando do robô leva em consideração os limites físicos do
robô já no planejamento. Conforme a velocidade programada, o robô se mo-
vimenta tão rápido quanto possível, ou seja, tão rápido quanto seus limites fí-
sicos permitam. Trata-se de uma vantagem em relação aos movimentos LIN
e CIRC convencionais, nos quais os limites físicos não são levados em con-
sideração no planejamento. Eles atuam nesse ponto apenas durante a exe-
cução do movimento, acionando stops quando necessário.

Redução da Os principais exemplos de casos nos quais a velocidade deve ser inferior à
velocidade programada são:
 Cantos acentuados
 Grandes reorientações
 Grandes movimentos dos eixos adicionais
 Proximidade de singularidades
Selecionando o controle de orientação Sem orientação, é possível evitar
uma redução da velocidade devido a grandes reorientações em segmentos
spline. Para isso, a programação com KRL é como segue:
$ORI_TYPE = #IGNORE

É possível evitar uma redução da velocidade com base em grandes movimen-


tos do eixo adicional em segmentos spline através de $EX_AX_IGNORE.

Redução da Isto acontece com:


velocidade para 0  Pontos sucessivos com as mesmas coordenadas
 Segmentos SLIN e/ou SCIRC sucessivos. Causa: Decurso instável do
sentido da velocidade.
Nas passagens SLIN-SCIRC a velocidade também será 0, quando a reta
passa tangencialmente ao círculo, visto que o círculo é côncavo ao con-
trário das retas.

168 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

Fig. 7-23: Parada exata em P2

Fig. 7-24: Parada exata em P2

Exceções:
 Se seguirem segmentos SLIN, que resultam em uma reta e com os quais
as orientações se alteram de modo uniforme, a velocidade não é reduzi-
da.

Fig. 7-25: P2 é percorrida sem parada exata.

 Com uma passagem SCIRC-SCIRC, a velocidade não é reduzida se am-


bos os círculos tiverem o mesmo ponto central e o mesmo raio, e se as
orientações se alterarem uniformemente. (Difícil de programar, por isso,
calcular e programar os pontos.)

Círculos com o mesmo ponto central e o mesmo raio às vezes são


programados, para se obter círculo ≥ 360°. Uma possibilidade mais
simples é programar um ângulo circular.

Reduções de Em caso de distribuição não uniforme de alterações de orientação / alterações


velocidade dos eixos adicionais relativas ao comprimento do arco, muitas vezes ocorrem
devido à aprendi- quedas indesejadas de velocidade.
zagem incons- Exemplo de uma distribuição não uniforme:
tante
PTP {x 0, y 0, z 0, A 0, B 0, C 0} ; Ponto de partida do spline
SPLINE
SPL {x 0, y 100, z 0, A 10, B 0, C 0} ; 0,1° Reorientação por mm de
trajeto cartesiano
SPL {x 0, y 110, z 0, A 20, B 0, C 0} ; 1° Reorientação por mm de
trajeto cartesiano
SPL {x 0, y 310, z 0, A 31, B 0, C 0} ; 0,055° Reorientação por mm de
trajeto cartesiano
ENDSPLINE

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 169 / 251


Programação do robô 2

Posição cartesiana, orientação e eixos adicionais estão firmemente


acoplados através do planejamento da geometria. Se for "puxado" no
TCP ao longo da tangente cartesiana ao trajeto de um spline, então
a orientação e os eixos adicionais (através do acoplamento) giram pratica-
mente de forma automática e vice-versa (em especial, todos os limites de
segmentos são normalmente interpolados por completo). Muitas quedas in-
desejadas da velocidade cartesiana são necessárias (condicionadas atra-
vés do acoplamento), para cumprir os valores programados
 Solavancos de orientação ($JERK.ORI),
 Acelerações de orientação ($ACC.ORI1) ou
 Velocidades de orientação ($VEL.ORI1).

Em caso de distribuição não uniforme de trajetos de orientação no trajeto car-


tesiano (comprimento do arco), a orientação deve acelerar ou atrasar muito
frequentemente, o que tende a ser acompanhada também por grandes sola-
vancos de orientação. Como resultado, quedas de velocidade ocorrem muito
mais frequentemente em caso de distribuição uniforme de trajetos do que em
distribuição uniforme (proporcional) dos trajetos de orientação. Além disso, o
robô e a mão do robô podem entrar em oscilação em caso de grande solavan-
co.
Solução

Distribuir a orientação e os eixos adicionais mais uniformemente possível


Exemplo de uma distribuição uniforme:
PTP {x 0, y 0, z 0, A 0, B 0, C 0} ; Ponto de partida do spline
SPLINE
SPL {x 0, y 100, z 0, A 10, B 0, C 0} ; 0,1° Reorientação por mm de
trajeto cartesiano
SPL {x 0, y 110, z 0, A 11, B 0, C 0} ; 0,1° Reorientação por mm de
trajeto cartesiano
SPL {x 0, y 310, z 0, A 31, B 0, C 0} ; 0,1° Reorientação por mm de
trajeto cartesiano
ENDSPLINE

Desligar controle de orientação por formulário Inline ou KRL


$ORI_TYPE = #IGNORE

Comparação com e sem controle programado de orientação

Fig. 7-26: Com orientação programada

170 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

Fig. 7-27: Sem orientação programada

Pos. Observação
1 posição programada com orientação correspondente
2 posição interpolada
3 posição programada com orientação correspondente, cuja
orientação não é assumida

Frequentemente: Muitos pontos são programados com


distância relativamente pequena. No entanto, estamos
interessados principalmente no trajeto cartesiano (x, y, z). Porém o spline in-
terpola também a orientação programada, o que pode levar a reduções de
velocidade. Por isso, no formulário Inline "Sem orientação" ou $ORI_TYPE
= #IGNORE.

7.11.2 Seleção de passo em movimentos do spline

Spline block Nos segmentos de um spline block, é possível executar uma seleção de pas-
so.
 Spline block CP:
O percurso SAK é realizado como movimento LIN convencional. Isso é in-
formado através de uma mensagem que deve ser confirmada.
 Spline block PTP:
O percurso SAK é realizado como movimento PTP convencional. Isso não
é avisado por uma mensagem.
Após uma seleção de passo, a trajetória geralmente decorre exatamente
como se o spline fosse percorrido na execução normal do programa.
São possíveis exceções, caso o spline nunca tenha sido percorrido antes da
seleção de passo e se, nesse caso, for realizada uma seleção de passo no
começo do spline block:
O ponto de partida de um movimento spline é o último ponto antes do spline
block, ou seja, o ponto de partida encontra-se fora do bloco. A unidade de co-
mando do robô salva o ponto de partida em caso de percorrimento normal de
um spline. Assim, ele se torna conhecido se em um momento futuro for reali-
zada uma seleção de passo. Contudo, se o spline block nunca tiver sido per-
corrido, o ponto de partida não é conhecido.
Se após o percurso SAK for pressionada a tecla de arranque, a trajetória al-
terada é informada por uma mensagem que deve ser confirmada.
Exemplo: Trajetória alterada em seleção do passo em P1

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 171 / 251


Programação do robô 2

Fig. 7-28: Exemplo: Trajeto alterado em seleção do passo em P1

1 PTP P0
2 SPLINE
3 SPL P1
4 SPL P2
5 SPL P3
6 SPL P4
7 SCIRC P5, P6
8 SPL P7
9 SLIN P8
10 ENDSPLINE

Linha Descrição
2 Cabeçalho/início do spline block CP
3…9 Segmentos spline
10 Fim do spline block CP

SCIRC Na seleção de passo para o segmento SCIRC, para o qual está programado
um ângulo circular, o ponto de destino é acessado tendo em consideração o
ângulo circular, desde que a unidade de comando do robô conheça o ponto
de partida.
Se a unidade de comando do robô não conhecer o ponto de partida, o ponto
de destino programado é acessado. Neste caso, uma mensagem indica que
o ângulo circular não é considerado.
Em uma seleção de passo para um movimento isolado SCIRC, o ângulo cir-
cular nunca é considerado.

7.11.3 Alterações nos spline blocks

Descrição  Alteração da posição do ponto:


Se um ponto é deslocado dentro de um spline block, a trajetória se altera
no máximo nos 2 segmentos antes deste ponto e nos 2 segmentos de-
pois.
Pequenos deslocamentos do ponto resultam geralmente em pequenas al-
terações da trajetória. Se, todavia, houver segmentos muito longos e mui-
to curtos seguidos, pequenas alterações podem ter grandes efeitos.

172 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

 Alteração do tipo de segmento:


Se um segmento SPL é alterado para um segmento SLIN, ou vice-versa,
a trajetória muda no segmento anterior e no seguinte.

Exemplo 1 Trajetória original:


PTP P0
SPLINE
SPL P1
SPL P2
SPL P3
SPL P4
SCIRC P5, P6
SPL P7
SLIN P8
ENDSPLINE

Fig. 7-29: Trajeto original

Um ponto é deslocado em relação à trajetória original:


P3 é deslocado. Com isso, a trajetória muda nos segmentos P1 - P2, P2 - P3
e P3 - P4. Neste caso, o segmento P4 - P5 não se altera, uma vez que ele
pertence a um SCIRC e através do qual é definida uma trajetória circular.

Fig. 7-30: Ponto foi deslocado

O tipo de um segmento é alterado em relação à trajetória original:


Na trajetória original, o tipo do segmento de P2 - P3 é alterado de SPL para
SLIN. A trajetória muda nos segmentos P1 - P2, P2 - P3 e P3 - P4.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 173 / 251


Programação do robô 2

PTP P0
SPLINE
SPL P1
SPL P2
SLIN P3
SPL P4
SCIRC P5, P6
SPL P7
SLIN P8
ENDSPLINE

Fig. 7-31: Tipo de segmento foi alterado

Exemplo 2 Trajetória original:


...
SPLINE
SPL {X 100, Y 0, ...}
SPL {X 102, Y 0}
SPL {X 104, Y 0}
SPL {X 204, Y 0}
ENDSPLINE

Fig. 7-32: Trajetória original

Um ponto é deslocado em relação à trajetória original:


P3 é deslocado. Com isso, a trajetória muda em todos os segmentos repre-
sentados. Uma vez que P2 - P3 e P3 - P4 são segmentos muito curtos, e P1
- P2 e P4 - P5 segmentos longos, um pequeno deslocamento provoca uma
grande mudança na trajetória.
...
SPLINE
SPL {X 100, Y 0, ...}
SPL {X 102, Y 1}
SPL {X 104, Y 0}
SPL {X 204, Y 0}
ENDSPLINE

174 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

Fig. 7-33: Ponto foi deslocado

Solução:
 Distribuir simetricamente as distâncias entre os pontos
 Programar as retas (exceto as retas muito curtas) como segmentos SLIN

7.11.4 Substituir o movimento CP de aproximação por spline block

Descrição Para substituir movimentos CP convencionais de aproximação por spline blo-


cks, o programa deve ser alterado como se segue:
 Substituir LIN - LIN por SLIN - SPL - SLIN.
 Substituir LIN - CIRC por SLIN - SPL - SCIRC.
Recomendação: Deixar o SPL entrar um pedaço no círculo original. Assim
o SCIRC inicia depois do CIRC original.
Em movimentos aproximados é programado o ponto de canto. Em spline blo-
cks, em vez disso, são programados pontos no início da aproximação e no fim
da aproximação.
Deve ser reproduzido o seguinte movimento aproximado:
LIN P1 C_DIS
LIN P2

Movimento spline:
SPLINE
SLIN P1A
SPL P1B
SLIN P2
ENDSPLINE

P1A = Início da aproximação, P1B = Fim da aproximação

Fig. 7-34: Movimento de aproximação - Movimento do spline

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 175 / 251


Programação do robô 2

Possibilidades para apurar P1A e P1B:


 Percorrer a trajetória aproximada e na posição desejada, salvar a posição
via trigger.
 Calcular os pontos no programa com KRL.
 O início da aproximação pode ser apurado a partir do critério de aproxi-
mação. Exemplo: Se como critério de aproximação é indicado C_DIS, a
distância do início da aproximação até o ponto de canto corresponde ao
valor de $APO.CDIS.
O fim da aproximação depende da velocidade programada.
A trajetória SPL não corresponde exatamente ao arco de aproximação, mes-
mo que P1A e P1B estejam exatamente no início da aproximação e no fim da
aproximação. Para obter exatamente o arco de aproximação, é necessário in-
serir pontos adicionais no spline. Normalmente um ponto é suficiente.

Exemplo Deve ser reproduzido o seguinte movimento aproximado:


$APO.CDIS=20
$VEL.CP=0.5
LIN {Z 10} C_DIS
LIN {Y 60}

Movimento spline:
SPLINE WITH $VEL.CP=0.5
SLIN {Z 30}
SPL {Y 30, Z 10}
SLIN {Y 60}
ENDSPLINE

O início do arco de aproximação foi calculado a partir do critério de aproxima-


ção.

Fig. 7-35: Exemplo: Movimento de aproximação - Movimento do spline, 1

A trajetória SPL ainda não corresponde exatamente ao arco de aproximação.


Por isso, é inserido um outro segmento SPL no Spline.
SPLINE WITH $VEL.CP=0.5
SLIN {Z 30}
SPL {Y 15, Z 15}

176 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

SPL {Y 30, Z 10}


SLIN {Y 60}
ENDSPLINE

Fig. 7-36: Exemplo: Movimento de aproximação - Movimento do spline, 2

Através do ponto adicional a trajetória corresponde agora ao arco de aproxi-


mação.

7.11.5 Transição SLIN-SPL-SLIN

Em uma sequência de segmentos SLIN-SPL-SLIN normalmente deseja-se


que o segmento SPL corra dentro do ângulo menor entre as duas retas. De-
pendente do ponto de partida e de destino do segmento SPL, a trajetória tam-
bém pode ser traçada por fora.

Fig. 7-37: SLIN-SPL-SLIN

A trajetória é traçada por dentro, se estiverem atendidos os seguintes pré-re-


quisitos:
 Os dois segmentos SLIN se intersectam em seu prolongamento.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 177 / 251


Programação do robô 2

 2/3 ≤ a/b ≤ 3/2


a = distância do ponto de partida do segmento SPL ao ponto de intersec-
ção dos segmentos SLIN
b = distância do ponto de intersecção dos segmentos SLIN ao ponto de
destino do segmento SPL

7.11.6 Programação PROG de SPLINE Blocks com KRL

SPLINE Block CP SPLINE … ENDSPLINE define um Spline Block CP. Um Spline Block CP
KRL pode conter:
 Segmentos SLIN, SCIRC e SPL (Número limitado apenas pela capacida-
de de memória.)
 Trigger de PATH
 1 bloco de tempo (TIME_BLOCK …)
ou 1 região de deslocamento constante (CONST_VEL …)
 STOP WHEN PATH
 Comentários
 Linhas em branco
O bloco não deve conter nenhuma outra instrução, por exemplo, atribuições
de variáveis ou instruções de lógica.
Sintaxe
SPLINE < WITH SysVar1 = Valor1 <, SysVar2 = Valor2, … > >
Segmento1

<SegmentoN>
ENDSPLINE <C_SPL>

Elemento Descrição
SysVar
Valor Atribuição de valor à variável do sistema. O valor não é
válido para segmentos, aos quais é atribuído um valor pró-
prio. Além disso, exceto se o valor for válido, como de cos-
tume, até um novo valor ser atribuído às variáveis do
sistema.
As variáveis do sistema também podem ser ocupadas por
acesso funcional. Para essas funções valem as mesmas
restrições das funções no trigger.
C_SPL  Com C_SPL: O ponto de destino é aproximado. $APO
define o momento mais cedo para a aproximação.
 Sem C_SPL: O ponto de destino é alcançado com exa-
tidão.

Até o System Software 8.2, o código para a aproximação no spline


era "C_DIS". Se programas em versões superiores a 8.x forem utili-
zados, os quais se baseiam em 8.2 ou estados mais antigos e con-
têm C_DIS, este não precisa ser alterado em C_SPL e pode ser deixado
como está.

SPLINE
SPL P1
TRIGGER WHEN PATH=GET_PATH() ONSTART DELAY=0 DO SUBPROG() PRIO=-1
SPL P2
SLIN P3

178 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

SPL P4
SCIRC P5, P6 WITH $VEL.CP=0.2
SPL P7 WITH $ACC={CP 2.0, ORI1 200, ORI2 200}
SCIRC P8, P9
SPL P10
ENDSPLINE

SPLINE Block PTP_SPLINE … ENDSPLINE define um Spline Block PTP. Um Spline Block
PTP KRL PTP pode conter:
 Segmentos SPTP (Número limitado apenas pela capacidade de memó-
ria.)
 Trigger de PATH
 1 bloco de tempo (TIME_BLOCK …)
 STOP WHEN PATH
 Comentários
 Linhas em branco
O bloco não deve conter nenhuma outra instrução, por exemplo, atribuições
de variáveis ou instruções de lógica.
Sintaxe
PTP_SPLINE < WITH SysVar1 = Valor1 <, SysVar2 = Valor2, … > >
Segmento1

<SegmentoN>
ENDSPLINE <C_SPL>

Elemento Descrição
SysVar
Valor Atribuição de valor à variável do sistema. O valor não é
válido para segmentos, aos quais é atribuído um valor pró-
prio. Além disso, exceto se o valor for válido, como de cos-
tume, até um novo valor ser atribuído às variáveis do
sistema.
As variáveis do sistema também podem ser ocupadas por
acesso funcional. Para essas funções valem as mesmas
restrições das funções no trigger.
C_SPL  Com C_SPL: O ponto de destino é aproximado. $APO
define o momento mais cedo para a aproximação.
 Sem C_SPL: O ponto de destino é alcançado com exa-
tidão.

PTP_SPLINE WITH $ACC_AXIS[1]={CP 20, ORI1 80, ORI2 80}


SPTP P1
TRIGGER WHEN PATH=GET_PATH() ONSTART DELAY=0 DO SUPBROG( ) PRIO=85
SPTP P2
SPTP P3
SPTP P4 WITH $ACC_AXIS[1]={CP 10}
ENDSPLINE C_SPL

Programação  SPL pode ser utilizado somente em SPLINE Blocks CP.


KRL de SPL,  SLIN e SCIRC podem ser utilizados como passo individual ou em um
SLIN, SCRIC e SPLINE Block CP.
SPTP  SPTP pode ser utilizado como passo individual ou em um SPLINE Block
PTP.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 179 / 251


Programação do robô 2

 A programação é quase igual, apenas SCIRC pode ser adicionalmente


provido com um ângulo circular.
 Palavras-chaves são SPL, SLIN, SCIRC e SPTP.
 Também podem ser utilizados os movimentos relativos conhecidos
SLIN_REL, SCIRC_REL e SPTP_REL.

Sintaxe
 SPL:
SPL Ponto de destino < WITH SysVar1 = Valor1 <,SysVar2 = Valor2 , …>>
 SLIN:
SLIN Ponto de destino <WITH SysVar1 = Valor1 <, SysVar2 = Valor2, …, >>
<C_SPL>
 SCIRC:
SCIRC Ponto auxiliar, Ponto de destino <, CA Ângulo circular> <WITH
SysVar1 = Valor1 <,SysVar2 = Valor2 , … >> <C_SPL>
 SPTP:
SPTP Ponto de destino <WITH SysVar1 = Valor1 <, SysVar2 = Valor2 , …>>
<C_SPL>
Elemento Descrição
Ponto auxi- Tipo: POS, E6POS, FRAME
liar
As coordenadas referem-se ao sistema de coordenadas
Ponto de BASE.
destino
Se não forem informados todos os componentes do ponto
de destino, a unidade de comando para os componentes
faltantes assume os valores da posição anterior. Se esta
posição anterior for o ponto de destino de um círculo com
ângulo circular, existe a seguinte diferenciação:
 Se a posição anterior estiver fora de um Spline Block,
são assumidos os valores do ponto de destino realmen-
te atingido, não do ponto de destino programado.
 Se a posição anterior estiver em um Spline Block, são
assumidos os valores do ponto de destino programado,
não do ponto de destino realmente atingido.
Se a unidade de comando do robô não conhecer nenhuma
posição anterior, os componentes que faltam serão assu-
midos da posição atual do robô.
Ângulo cir- Unidade: grau; sem limitação
cular

SysVar

180 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


7 Programação de movimento com KRL

Elemento Descrição
Valor Atribuição de valor à variável do sistema
Em segmentos: A atribuição vale apenas para esse seg-
mento.
As variáveis do sistema também podem ser ocupadas por
acesso funcional. Para essas funções valem as mesmas
restrições das funções no trigger.

C_SPL  Com C_SPL: O ponto de destino é aproximado. $APO


define o momento mais cedo para a aproximação.
Somente possível para movimentos individuais, não
para segmentos.
 Sem C_SPL: O ponto de destino é alcançado com exa-
tidão.

7.11.7 SPLINE Block: Variáveis de sistema com WITH

Segmento spline Para segmentos spline, as seguintes variáveis de sistema são graváveis com
a linha WITH:
$ACC
$ACC_AXIS
$ACC_EXTAX
$CIRC_TYPE
$EX_AX_IGNORE
$GEAR_JERK
$JERK
$ORI_TYPE
$ROTSYS
$SYNC_ID
$VEL
$VEL_AXIS
$VEL_EXTAX
Adicionalmente para SCIRC e SLIN: $CIRC_MODE

As variáveis de sistema estão descritas no capítulo Variáveis de sis-


tema.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 181 / 251


Programação do robô 2

182 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


8 Trabalho com variáveis de sistema

8
T
Trabalho com variáveis de sistema

8.1 Visão geral

Nesta unidade de aprendizagem são repassados os seguintes conteú-


dos:
 Medição de tempo de ciclo com temporizador

8.2 Medição do tempo de ciclo com temporizador

Descrição da
medição de ciclo
com tempori-
zador de sistema
KUKA

Fig. 8-1

 $TIMER[1]
 $TIMER[2]
 ...
 $TIMER[32]
As variáveis de sistema $TIMER[Nr] servem para a medição de processos de
tempo.

A introdução de valores/exibição do temporizador $TIMER[Nr] é rea-


lizada em milissegundos (ms).

Iniciar e parar um temporizador com KRL


 INICIAR: $TIMER_STOP[Nr] = FALSE
 PARAR: $TIMER_STOP[Nr] = TRUE

O temporizador também pode ser atribuido, iniciado e parado manu-


almente com janela de exibição.

Princípio da Atribuição prévia de um temporizador


medição de ciclo  A atribuição prévia de um temporizador no fornecimento é 0 ms
 O temporizador mantém seu valor atual
 Um temporizador pode ser adiantado ou resetado a um valor qualquer
; Temporizador 5 predefinido com 0ms
$TIMER[5] = 0

; Temporizador 12 é ajustado em 1,5 segundos

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 183 / 251


Programação do robô 2

$TIMER[12] = 1500

; Temporizador 4 resetado em -8 segundos


$TIMER[4] = -8000

 Resetar e iniciar um temporizador


; Temporizador 7 Reset a 0ms
$TIMER[7] = 0
; Iniciar Temporizador 7
$TIMER_STOP[7] = FALSE

 Parar um temporizador e subsequente comparação


; Temporizador 7 em operação
...
; Parar o Temporizador 7
$TIMER_STOP[7] = TRUE

; em caso de 10 segundos ou maior há ...


IF $TIMER[7] >= 10000 THEN
...

A partida e parada de um temporizador é sempre realizado com o In-


dicador de avanço. O comando WAIT SEC 0 é apropriado para ge-
rar uma parada de avanço.

Procedimento na 1. Seleção de um temporizador "livre" a partir de 32 elos de tempo possíveis


medição de 2. Atribuição / Reset do temporizador
tempo de ciclo 3. Iniciar o temporizador observando o indicador de avanço
4. Parar o temporizador observando o indicador de avanço
5. Se necessário salvar o tempo de ciclo atual ou atribuir novamente o tem-
porizador
DEF MY_TIME( )
...
INI
$TIMER[1] = 0 ; Reset TIMER 1
PTP HOME Vel=100% DEFAULT

WAIT SEC 0 ; Provocar uma parada de avanço


$TIMER_STOP[1]=FALSE ; Iniciar medição de tempo de ciclo

SPTP XP1
SPTP XP2
SLIN XP3
...
SPTP X50
SPTP XHOME

WAIT SEC 0 ; Provocar uma parada de avanço


$TIMER_STOP[1]=TRUE ; Parar medição de tempo de ciclo

; Tempo de ciclo atual memorizado temporariamente no temporizador 12


$TIMER[12] = $TIMER[1]; O valor agora pode ser lido no display do
temporizador
END

184 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


8 Trabalho com variáveis de sistema

8.3 Exercício: Medição de ciclo e otimização

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Trabalhar com um temporizador (inicializar, iniciar, parar).
 Realizar a otimização do ciclo.

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos sobre as variáveis de sistema $TIMER[x].

Definição de Duplique o seu programa "Palete" e atribua o nome "Medição de tempo". De-
tarefas verão ser registrados três tempos. O temporizador 1 deverá medir o tempo da
paletização, o temporizador 2 o processo de retirada e o temporizador 3 o
tempo geral de ambos processos. Preste atenção para não iniciar ou parar o
temporizador com o avanço.
1. Para medir o tempo de paletização, use $TIMER[1] e salve adicionalmen-
te o valor final em $TIMER[4].
2. Nomeie $TIMER[1] "Paletização atual“ e $TIMER[4] "Paletização ANTI-
GA".
3. Para medir o tempo de despaletização, use $TIMER[2] e salve adicional-
mente o valor final em $TIMER[5].
4. Nomeie $TIMER[2] "Despaletização atual“ e $TIMER[5] "Despaletização
ANTIGA".
5. Para medir o tempo geral é usado $TIMER[3] e salvo em $TIMER[6].
6. Nomeie $TIMER[3] "Total atual“ e $TIMER[6] "Total ANTIGO".
7. Tente otimizar o seu programa de forma adequada.
8. Teste o seu programa nos modos de operação T1, T2 e Automático. Aqui
devem ser observadas as prescrições de segurança ensinadas.
O que você deveria saber agora:
1. Quantos temporizadores há na unidade de comando KUKA e como estes
são iniciados?
............................................................
............................................................
2. Cite um exemplo para uma variável da $CONFIG.DAT?
............................................................
............................................................

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 185 / 251


Programação do robô 2

186 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


9 Programação de Interrupt

9 Programação de Interrupt

9.1 Visão geral

Nesta unidade de aprendizagem são repassados os seguintes conteú-


dos:
 Programação de rotinas Interrupt
 Frear o robô e cancelar os movimentos de deslocamento

9.2 Programação de rotinas de Interrupt

Descrição de
rotinas de cance-
lamento

Fig. 9-1: Trabalhar com rotinas Interrupt

 Em um evento definido, p.ex., uma entrada, a unidade de comando inter-


rompe o programa atual e executa um subprograma definido.
 Um subprograma, que é acessado por um Interrupt, é chamado de pro-
grama Interrupt.
 Podem estar declarados, no máximo, 32 Interrupts ao mesmo tempo.
 Simultaneamente, podem estar ativos, no máximo, 16 Interrupts.
Passos importantes ao usar o Interrupt
 Declaração de Interrupt
 Ativar/desativar ou bloquear/liberar Interrupt
 Se for o caso, parar o robô
 Se for o caso, descartar o planejamento da trajetória atual e percorrer
nova trajetória

Generalidades  Em um evento definido, p.ex., uma entrada, a unidade de comando inter-


sobre a decla- rompe o programa atual e executa um subprograma definido.
ração de Inter-
rupts

Sintaxe <GLOBAL> INTERRUPT DECL Prio WHEN Ereignis DO Interruptprogramm

 Global
 Um Interrupt é reconhecido apenas a partir do nível no qual está de-
clarado.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 187 / 251


Programação do robô 2

Fig. 9-2: Validade de Interrupts

 Um Interrupt, que foi declarado em um subprograma, não é conhecido


no programa principal (aqui Interrupt 23).
 Um Interrupt com a palavra-chave GLOBAL anteposta na declaração,
também é conhecido nos níveis superiores (aqui Interrupt 2).
 Prio: Prioridade
 Estão disponíveis as prioridades 1, 2, 4 - 39 e 81 - 128.
 As prioridades 3 e 40 - 80 estão reservadas para o uso pelo sistema.
 Eventualmente o Interrupt 19 está pré-ocupado para o teste dos
freios.
 Se vários Interrupts ocorrerem simultaneamente, é processado pri-
meiro o Interrupt com a máxima prioridade, depois os Interrupts com
menor prioridade. (1 = máxima prioridade)

Fig. 9-3: Prioridades de Interrupts

188 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


9 Programação de Interrupt

 Evento: Evento, que deve ocorrer no Interrupt.

Este evento é reconhecido em sua ocorrência através de um flanco


(disparado por flanco).

 Programa Interrupt
 Nome do programa Interrupt, que deve ser processado.
 Este subprograma é chamado de programa Interrupt.
 As variáveis de tempo de execução não podem ser entregues como
parâmetro ao programa Interrupt
 São permitidas variáveis, que estão declaradas em uma lista de da-
dos ou através de transferência de variáveis.

Exemplo: Decla- INTERRUPT DECL 23 WHEN $IN[12]==TRUE DO INTERRUPT_PROG(20,VALUE)


ração de um
 Interrupt local
Interrupt
 Prioridade: 23
 Evento: A entrada 12 é reconhecida como flanco positivo (crescente).
 Programa Interrupt: INTERRUPT_PROG(20,VALUE)

Após a declaração um Interrupt primeiramente está desativado. O In-


terrupt deve ser ativado antes que o evento definido possa ser reagi-
do!

Após a declaração um Interrupt primeiramente está desativado. O In-


terrupt deve ser ativado antes que possa ser reagido ao evento defi-
nido.

Descrição Ligar/desligar/bloquear/liberar Interrupt

Possibilidades Após uma declaração de Interrupt, este deve ser ativado em seguida
através do  Ativa um Interrupt.
comando
 Desativa um Interrupt.
INTERRUPT ...
 Bloqueia um Interrupt.
 Libera um Interrupt.

Sintaxe INTERRUPT Ação <Número>


Ação
 ON: Ativa um Interrupt.
 OFF: Desativa um Interrupt.
 DISABLE: Bloqueia um Interrupt ativado.
 ENABLE: Libera um Interrupt bloqueado.
Número
 Número (=prioridade) do Interrupt, ao qual a ação deve se referir.
 O número pode ser suprimido.
Neste caso ON ou OFF referem-se a todos os Interrupts declarados,
DISABLE ou ENABLE a todos os Interrupts ativos.

Interrupt - ativar e Exemplo


desativar Ligar/desligar um Interrupt
INTERRUPT DECL 20 WHEN $IN[22]==TRUE DO SAVE_POS( )
...
INTERRUPT ON 20
;O Interrupt é detectado e executado (flanco positivo)

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 189 / 251


Programação do robô 2

...
INTERRUPT OFF 20 ; Interrupt está desligado

 Neste caso, o Interrupt é ativado por uma mudança do estado, p.ex., em


$IN[22]==TRUE através da troca de FALSE para TRUE. Portanto, o esta-
do não pode já existir no INTERRUPT ON, pois o Interrupt não seria ati-
vado!
 Neste caso deve ser observado adicionalmente o seguinte: A mudança de
estado pode ocorrer somente um ciclo de interpolação depois do INTER-
RUPT ON.
 (Isto pode ser obtido, programando-se um WAIT SEC 0.012 após o
INTERRUPT ON. Se não for desejada uma parada de avanço, pode
ser programado adicionalmente um CONTINUE antes do WAIT SEC.)
 O motivo é que o INTERRUPT ON necessita de um ciclo de interpo-
lação (= 12ms), até que o Interrupt esteja de fato ativado. Se o estado
mudar antes, o Interrupt não consegue identificar a mudança.

Duplo comando de teclas


Quando existe o risco de um Interrupt acionado incorretamente em
duplicidade por causa de sensores hipersensíveis ("duplo comando
de teclas"), você pode impedir isto através da desativação do Interrupt na
primeira linha do programa Interrupt.
No entanto, nesse caso, também não é mais detectado um Interrupt real,
que ocorre durante o processamento do Interrupt. Se desejar que o Interrupt
continue ativo, é necessário reativá-lo antes do retorno.

Bloquear e liberar Exemplo


Interrupt
INTERRUPT DECL 21 WHEN $IN[25]==TRUE DO INTERRUPT_PROG( )
...
INTERRUPT ON 21
;O Interrupt é detectado e executado imediatamente (flanco positivo)
...
INTERRUPT DISABLE 21
;O Interrupt é detectado e salvo, mas não executado (flanco positivo)
...
INTERRUPT ENABLE 21
; Interrupts armazenados são executados somente agora
...
INTERRUPT OFF 21 ; Interrupt está desligado
...

Um Interrupt bloqueado é detectado e gravado. A execução ocorre


diretamente após a liberação do Interrupt. Aqui deve-se observar a
isenção de colisão em movimentos.

Procedimento 1. Declaração de Interrupt


 Definir a prioridade
 Determinar o evento de disparo
 Definir e criar rotina de Interrupt
DEF MY_PROG( )

INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )

END
_________________________________________________
DEF ERROR()

190 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


9 Programação de Interrupt

END

2. Ativar e desativar Interrupt


DEF MY_PROG( )

INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )
INTERRUPT ON 25
...
...
INTERRUPT OFF 25

END
_________________________________________________
DEF ERROR()

END

3. Expandir o programa com movimentos e definir ações na rotina de Inter-


rupt
DEF MY_PROG( )

INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )
INTERRUPT ON 25
SPTP XHOME
SPTP XP1
SPTP XP2
SPTP XHOME
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR()
$OUT[20]=FALSE
$OUT[21]=TRUE
END

Variáveis de
sistema úteis na
parada exata

Fig. 9-4: Variáveis de sistema na parada exata

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 191 / 251


Programação do robô 2

Variáveis de
sistema úteis em
uma aproximação

Fig. 9-5: Variáveis de sistema na aproximação

192 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


9 Programação de Interrupt

9.3 Exercício: Trabalhar com Interrupts

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Declaração de um Interrupt
 Criação de um subprograma Interrupt
 Avaliação e edição de Interrupts na execução do programa

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos da linguagem de programação KRL
 Conhecimentos teóricos sobre a programação de Interrupts

Definição de O objetivo desta tarefa é, através de deslocamento de medição definido, de-


tarefas tectar a posição de 3 cubos e salvar estas posições.
1. Crie um novo programa com o nome "LOCALIZAR".
2. Retire (sem o robô) três cubos do magazine de cubos e coloque-os em
uma linha sobre a mesa.
3. Programe um movimento SLIN como deslocamento de localização pelos
três cubos. A velocidade deve ser definida em 0,2 m/s.
4. É necessário ativar ou desativar o sensor com a saída 27. Como feedback
da determinação de posição você recebe um sinal na entrada 27.
5. Na detecção de um cubo deve ser exibida a posição X, Y e Z do cubo atra-
vés de uma mensagem de informação. Ao mesmo tempo, deve ser salva
a posição na detecção. Para isto, use um campo, que você cria no DAT-
file local ou no $config.dat.
6. Após o término do deslocamento de localização, as três posições salvas
devem ser exibidas através de acesso, isto é, acessar a posição, mensa-
gem de informação "Cubo n° X acessado", e então ir à posição seguinte.
7. Teste o seu programa conforme a prescrição.
O que você deve saber agora:
1. Em qual parte do programa é declarado o Interrupt?
............................................................
............................................................
2. Qual é a diferença entre INTERRUPT OFF 99 e INTERRUPT DISABLE 99?
............................................................
............................................................
............................................................
............................................................
3. Quando é acessado o subprograma Interrupt?
............................................................
............................................................
4. O que faz o comando INTERRUPT OFF no início de um subprograma In-
terrupt?
............................................................
............................................................
5. Qual área de prioridade para o Interrupt não está liberada?
............................................................

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 193 / 251


Programação do robô 2

.............................................................

194 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


9 Programação de Interrupt

9.4 Frear o robô e cancelar os movimentos de deslocamento

Descrição  Frear o robô, depois continuar o movimento "antigo". (>>> "Frear o movi-
mento do robô e continuar o movimento "antigo"" Página 195)
 Frear o robô, cancelar o movimento "antigo" e continuar com movimento
novo. (>>> "Frear o movimento do robô e cancelar o movimento "antigo""
Página 196)

Frear o  O robô é parado com BRAKE e, no final da rotina de Interrupt continua com
movimento do a trajetória planejada do programa principal.
robô e continuar  O robô é parado com BRAKE e deslocado na rotina de Interrupt. Após o
o movimento término da rotina de Interrupt é continuada a trajetória do programa prin-
"antigo" cipal.

Aqui deve ser observada a isenção de colisão!


Se isto não for observado, as consequências podem ser
morte, lesões corporais ou danos materiais.

 Para parar estão disponíveis duas rampas de frenagem (STOP 1 e STOP


2).
 O programa Interrupt somente é continuado depois que o robô parar.
 Tão logo o programa Interrupt esteja concluído, é continuado o movimen-
to do robô iniciado.
 Sintaxe:
 BRAKE: STOP 2
 BRAKE F: STOP 1

BRAKE somente pode ser usado com um programa Interrupt.

Procedimento 1. Declaração de Interrupt


 Definir a prioridade
 Determinar o evento de disparo
 Definir e criar rotina de Interrupt
 Ativar e desativar Interrupt
DEF MY_PROG( )

INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )
INTERRUPT ON 25
...
...
INTERRUPT OFF 25

END
_________________________________________________
DEF ERROR()

END

2. Expandir o programa com movimentos e frear o robô na rotina de Interrupt


e definir a lógica
DEF MY_PROG( )

INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 195 / 251


Programação do robô 2

INTERRUPT ON 25
SPTP XHOME
SPTP XP1
SPTP XP2
SPTP XHOME
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR()
BRAKE
$OUT[20]=FALSE
$OUT[21]=TRUE
END

Frear o  O robô é parado com BRAKE e deve executar uma nova trajetória após o
movimento do término da rotina de Interrupt. Isto pode ser realizado com o comando RE-
robô e cancelar o SUME.
movimento  O robô é parado com BRAKE e deslocado na rotina de Interrupt. Após o
"antigo" término da rotina de Interrupt, a trajetória atual não deve mais ser conti-
nuada e deve ser realizado um novo planejamento de trajetória. Isto tam-
bém pode ser realizado com o comando RESUME.

Depois que não é possível estimar com precisão quando


o Interrupt vai ser ativado, deve ser possível, em todas
as possíveis posições do deslocamento atual do robô, um movimento sem
colisão dentro da rotina de Interrupt e do deslocamento subsequente.
Se isto não for observado, as consequências podem ser morte, lesões cor-
porais ou danos materiais.

Funções de  RESUME cancela todos os programas Interrupt em curso e todos os sub-


RESUME programas até o nível em que o Interrupt atual foi declarado.
 No momento da instrução RESUME, o indicador de avanço não pode estar
no nível em que o Interrupt foi declarado, mas deve se encontrar, no mí-
nimo, em um nível abaixo deste.
 RESUME somente pode ocorrer com programas Interrupt.
 Tão logo um Interrupt tenha sido declarado como GLOBAL, não é permiti-
do usar nenhumRESUME na rotina de Interrupt.
 Alterações da variável $BASE no programa Interrupt atuam somente lá.
 O avanço do computador, isto é, a variável $ADVANCE, não pode ser al-
terado no programa Interrupt.
 Movimentos de deslocamento, que devem ser interrompidos com BRAKE
e RESUME, sempre devem ser programados em um subprograma.
 O comportamento da unidade de comando do robô após RESUME depen-
de da seguinte instrução de movimento:
 Instrução SPTP: É deslocado como movimento SPTP.
 Instrução SLIN: É deslocado como movimento SLIN.
 Instrução SCIRC: Sempre é deslocado como movimento SLIN!
Se a primeira instrução de movimento após RESUME é um movimento
SCIRC, este sempre é executado como SLIN! Com isto o movimento resulta
de forma diferente do que originalmente planejado. Este comportamento deve
ser levado em consideração na programação de instruções RESUME.
O robô deve poder acessar o ponto de destino do movimento SCIRC sem pe-
rigo como SLIN, a partir de qualquer posição na qual ele poderia se encontrar
no RESUME.

Procedimento 1. Declaração de Interrupt

196 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


9 Programação de Interrupt

 Definir a prioridade
 Determinar o evento de disparo
 Definir e criar rotina de Interrupt
DEF MY_PROG( )

INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )
...
END
_________________________________________________
DEF ERROR()
...
END

2. Expandir o programa com movimentos


 Para poder cancelar, o movimento deve ocorrer em um subprograma
 O indicador de avanço deve permanecer no subprograma
 Ativar e desativar Interrupt
DEF MY_PROG( )

INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )
SEARCH()
END
_________________________________________________
DEF SEARCH()
INTERRUPT ON 25
SPTP XHOME
SPTP XP1
SPTP XP2
SPTP XHOME
WAIT SEC 0 ; Parar o ponteiro de avanço
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR()
...
END

3. Processar a rotina de Interrupt


 Parar robô
 Reposicionar o robô para $POS_INT
 Descartar o movimento atual
 Novo movimento no programa principal
DEF MY_PROG( )

INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )
SEARCH()
END
_________________________________________________
DEF SEARCH()
INTERRUPT ON 25
SPTP HOME
SPTP XP1
SPTP XP2

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 197 / 251


Programação do robô 2

SPTP XHOME
WAIT SEC 0 ; Parar o ponteiro de avanço
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR()
BRAKE
SPTP $POS_INT
RESUME
END

198 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


9 Programação de Interrupt

9.5 Exercício: Cancelar movimentos de deslocamento com Interrupts

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Declaração de um Interrupt
 Criação de um subprograma Interrupt
 Avaliação e edição de Interrupts na execução do programa
 Frear o movimento do robô com comando KRL
 Frear e cancelar o movimento do robô com comandos KRL

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos da linguagem de programação KRL
 Conhecimentos teóricos sobre a programação de Interrupts
 Conhecimentos teóricos sobre os comandos KRL para frear e cancelar
movimentos do robô e o seu uso correto

Definição de Através de deslocamento de medição definido você deve poder identificar a


tarefas posição de 3 cubos e salvar estas posições. Além disso, o deslocamento de
medição deve ser cancelado imediatamente após a detecção do 3° cubo.
1. Duplique o seu programa LOCALIZAR e atribua o nome
"SUCHEN_ABBRUCH" (CANCELAR LOCALIZAR).
2. Retire (sem o robô) três cubos do magazine de cubos e coloque-os em
uma linha sobre a mesa.
3. Programe um movimento SLIN como deslocamento de localização pelos
três cubos. A velocidade deve ser definida em 0,2 m/s. É necessário ativar
ou desativar o sensor com a saída 27. Como feedback da determinação
de posição você recebe um sinal na entrada 27.
4. Na detecção de um cubo deve ser exibida a posição X, Y e Z do cubo atra-
vés de uma mensagem de informação. Ao mesmo tempo, deve ser salva
a posição na detecção. Para isto, use um campo, que você cria no DAT-
file local ou no $config.dat.
5. O robô deve ser parado imediatamente após a localização do terceiro
cubo. Após a confirmação da mensagem "Último cubo localizado - o des-
locamento de localização é cancelado" o deslocamento de localização
deve ser finalizado.
6. Após o término do deslocamento de localização, as três posições salvas
devem ser exibidas através de acesso, isto é, acessar a posição, mensa-
gem de informação "Cubo n° X acessado", e então ir à posição seguinte.
7. Teste o seu programa conforme a prescrição
O que você deve saber agora:
1. Qual é a diferença entre BRAKE e BRAKE F?
............................................................
............................................................
2. Por que o comando RESUME não funciona corretamente aqui?
INTERRUPT DECL 21 WHEN $IN[1] DO located( )
INTERRUPT ON 21
Pto_inic SLIN
Pto_final SLIN
$ADVANCE = 0
INTERRUPT OFF 21 ...
END
___________________________________________
DEF located( )

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 199 / 251


Programação do robô 2

INTERRUPT OFF 21
BRAKE
;pick_part
RESUME
END
3. Quando é acionado um Interrupt?
.............................................................
.............................................................

200 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


10 Funções de comutação KRL

10 Funções de comutação KRL

10.1
s
Visão geral

Nesta unidade de aprendizagem são repassados os seguintes conteú-


dos:
 Programação de funções de comutação simples
 Programação de funções de comutação referentes à trajetória com deslo-
camento de tempo

10.2 Programação das funções de comutação simples

Descrição de Generalidades
funções de  A unidade de comando do robô pode administrar no máximo 4096 entradas
comutação digitais e 4096 saídas digitais.
simples Opcionalmente estas podem ser ampliadas via WorkVisual para 8192 en-
tradas digitais e 8192 saídas digitais.
 As entradas/saídas são realizadas através de sistemas de bus de campo
opcionais
 A configuração é específica do cliente
 A projeção é realizada com o WorkVisual

Fig. 10-1

Opções de funções de comutação simples


 Ativação/desligamento simples de uma saída (com avanço/parada de
avanço)
 Pulsos de uma saída
 Comutação de uma saída com o indicador de avanço principal (sem pa-
rada de avanço)
 ver também:

Fig. 10-2: Formulários Inline de funções de comutação simples

Comutação com Sintaxe


parada de avanço  ativação de uma saída com parada de avanço
$OUT[10]=TRUE

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 201 / 251


Programação do robô 2

 desativação de uma saída com parada de avanço


$OUT[10]=FALSE

Descrição
 através da comutação de uma saída é gerada uma parada de avanço, as-
sim o movimento não pode ser aproximado
...
SLIN XP20 C_SPL
SLIN XP21
$OUT[30]=TRUE
SLIN XP22

Fig. 10-3: Comutação com parada de avanço

São geradas duas mensagens de erro:


Aproximação impossível (Módulo nome, Passo número)
Sequência de instrução não passível de aproximação (Módulo nome,
Passo número)

Comutar com o Sintaxe


avanço  ligar uma saída no avanço
CONTINUE
$OUT[10]=TRUE

 desligar uma saída no avanço


CONTINUE
$OUT[10]=FALSE

Descrição
 Através o uso do comando CONTINUE a parada de avanço é cancelada e
assim comutada com o avanço.
 Uma aproximação é possível com CONTINUE.
 CONTINUE refere-se somente à próxima linha (inclusive linha vazia).
...
SLIN XP20
SLIN XP21 C_SPL
CONTINUE
$OUT[30]=TRUE
SLIN XP22

202 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


10 Funções de comutação KRL

Fig. 10-4: Comutação no avanço

Comutação de Sintaxe
uma saída com o  ativação de uma saída com o indicador de avanço principal e sem parada
indicador de de avanço
avanço principal $OUT[10]_C=TRUE

Descrição
 podem ser comutadas até 8 saídas em função do avanço principal e sem
parada de avanço
 se for programada uma parada exata, a comutação é realizada ao alcan-
çar o ponto de destino
 se estiver programada uma aproximação, a comutação é realizada no
meio do movimento de aproximação do ponto de destino
...
SLIN XP20
$OUT_C[30]=TRUE
SLIN XP21 C_SPL
SLIN XP22

Fig. 10-5: Comutar com avanço principal

Pulsos de uma Sintaxe


saída 

PULSE (Signal, Pegel, Impulsdauer)

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 203 / 251


Programação do robô 2

Elemento Descrição
Sinal Tipo: BOOL
Saída na qual o impulso é criado. São admissíveis:
 OUT[Nr]
 Variável de sinal
Nível Tipo: BOOL
Expressão lógica:
 TRUE representa um impulso positivo (high).
 FALSE representa um impulso negativo (low).
Duração de Tipo: REAL
impulso
p.ex. 1.000.000 segundos

Descrição
 PULSE seta um pulso.
 A saída é setada durante um determinado tempo em um nível definido e,
em seguida, resetado automaticamente pelo sistema.
 A instrução PULSE provoca uma parada de avanço inicial.

Em PARADA DE EMERGÊNCIA, parada de operação


ou parada de erro o impulso não é interrompido!

 Exemplo:
PULSE ($OUT[30], TRUE, 20); Impulso positivo

PULSE ($OUT[31], FALSE, 20); Impulso negativo

 se antes da instrução END for programado um pulso, o período de pro-


cessamento de programa aumenta proporcionalmente
...
PULSE($OUT[50],TRUE,2)
END

Fig. 10-6: Exemplo PULSE+END

 se a execução do programa for resetada (RESET) ou cancelada (CAN-


CEL) enquanto há um pulso ativo, esse pulso é resetado imediatamente
...
PULSE($OUT[50],TRUE,2)
; O programa agora é resetado ou desselecionado

Fig. 10-7: Exemplo PULSE+RESET

204 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


10 Funções de comutação KRL

10.3 Programação do trigger em KRL

Descrição O trigger desencadeia uma instrução definida pelo usuário. A unidade de co-
mando do robô executa a instrução paralelamente ao movimento do robô.
Opcionalmente, o trigger pode se referir ao ponto de partida ou ao ponto de
destino do movimento. A instrução pode ser desencadeada diretamente no
ponto de referência ou ela ainda pode ser deslocada no espaço e/ou no tem-
po.

O trigger não pode ser utilizado para movimentos PTP.


Se o trigger for utilizado em um Spline Block, ele não pode estar en-
tre o último segmento e o ENDSPLINE.

Possibilidades da programação
 Formulário Inline Janela de opções Lógica Trigger

Fig. 10-8: Trigger

 Formulário Inline Spline Trigger

Fig. 10-9: Formulário Inline Spline Trigger

 Programação por meio do comando KRL TRIGGER WHEN PATH

Programação do Utilização do comando KRL existente para TRIGGER WHEN PATH:


trigger com KRL TRIGGER WHEN PATH = Percurso <ONSTART> DELAY = Tempo DO
Instrução <PRIO = Prioridade>

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 205 / 251


Programação do robô 2

Elemento Descrição
ONSTART Ponto de referência do trigger
 Com ONSTART: Ponto de partida
 Sem ONSTART: Ponto de destino

Percurso Tipo: REAL; variável, constante ou função; unidade: mm


(Exceção: em splines PTP sem unidade)
Deslocamento espacial em relação ao ponto de referência.
Se não for desejado nenhum deslocamento espacial,
então colocar percurso = 0.
 Valor negativo: Deslocamento no sentido do início do
movimento
 Valor positivo: Deslocamento no sentido do final do mo-
vimento
(>>> "Deslocamento máx." Página 206)
Tempo Tipo: REAL; variável, constante ou função; unidade: ms
Deslocamento temporal em relação ao percurso. Se não for
desejado nenhum deslocamento temporal, então definir
tempo = 0.

 Valor negativo: Deslocamento no sentido do início do


movimento
 Valor positivo: O trigger é comutado decorrido o tempo.
(>>> "Deslocamento máx." Página 206)
Instrução Possível:
 Atribuição de valor para uma variável
Nota: Do lado esquerdo da atribuição não pode haver
nenhuma variável de tempo de execução.
 Instrução OUT; instrução PULSE; instrução CYCFLAG
 Acesso a um subprograma. Nesse caso, deve ser indi-
cada a prioridade.
Prioridade Tipo: INT; variável ou constante
Prioridade do trigger. Apenas relevante se a instrução
acessa um subprograma, porém obrigatoriamente.
Estão disponíveis as prioridades 1, 2, 4 - 39 bem como 81
- 128. As prioridades 40 - 80 estão reservadas para os
casos, nos quais a prioridade é atribuída automaticamente
pelo sistema. Se a prioridade deve ser atribuída automati-
camente pelo sistema, programa-se: PRIO = -1.
Se vários triggers acessam subprogramas simultanea-
mente, edita-se primeiramente o trigger com a prioridade
mais alta, então o trigger com a prioridade mais baixa. 1 =
prioridade mais alta.

Deslocamento O ponto de comutação somente pode ser deslocado até determinados limites.
máx. Se forem programados deslocamentos maiores e, consequentemente, inváli-
dos, a unidade de comando do robô comuta o Trigger o mais tardar no limite
admissível. No T1/T2 ela emite uma mensagem para isso.
Deslocamento máximo para percurso + valor de temponegativo:
Os limites são válidos para o deslocamento geral, que resulta do deslocamen-
to local e temporal negativo.

206 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


10 Funções de comutação KRL

Deslocamento negativo máximo Deslocamento positivo máximo


até … até …
Até o ponto de partida (se este não Até o ponto de destino (se este não
estiver aproximado) estiver aproximado)
Se o ponto de partida estiver apro- Se o ponto de destino estiver apro-
ximado: ximado:
 Se o ponto de partida for um  Na aproximação homogênea:
ponto PTP aproximado: até a próxima parada exata de-
Até o fim do arco de aproxima- pois da instrução TRIGGER
ção  Na aproximação mista (Spline):
 Se o ponto de partida for um ou- até o ponto de comutação, que
tro ponto aproximado: um trigger ONSTART com
PATH = 0 teria, se ele estivesse
Até o início do arco de aproxi-
no movimento para dentro do
mação
qual é aproximado.

 Na aproximação mista (LIN/


CIRC/PTP): Até o início do arco
de aproximação

Deslocamento máximo para valor de tempo positivo:


O deslocamento temporal positivo pode ser de, no máximo, 1.000ms. Cada
deslocamento temporal entre 0 e 1.000ms é comutado, mesmo que o progra-
ma já tenha sido desselecionado neste meio tempo!

Exemplo de 1 SPTP P0
trigger com KRL 2 SPLINE
3 SPL P1
4 SPL P2
5 SPL P3
6 SPL P4
7 TRIGGER WHEN PATH=0 ONSTART DELAY=10 DO $OUT[5]=TRUE
8 SCIRC P5, P6
9 SPL P7
10 TRIGGER WHEN PATH=-20.0 DELAY=0 DO SUBPR_2() PRIO=-1
11 SLIN P8
12 ENDSPLINE

O trigger na linha 10 levaria ao mesmo resultado se ele estivesse diretamente


antes do Spline Block (portanto, entre a linha 1 e linha 2). Em ambos os caso,
ele se refere ao último ponto do movimento do spline, ao P8.
Porém, recomenda-se posicionar o trigger como no exemplo e não diretamen-
te antes do Spline Block.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 207 / 251


Programação do robô 2

Fig. 10-10: Exemplo TRIGGER WHEN PATH (para Spline)

Restrições para Os valores para DELAY e PATH podem ser atribuídos através de funções.
funções no Para estas funções valem as seguintes restrições:
Trigger  O programa KRL, que contém a função, deve ter a propriedade Oculto.
 A função deve ter validade global.
 As funções somente podem conter as seguintes instruções ou elementos:
 Atribuições de valores
 Instruções IF
 Comentários
 Linhas em branco
 RETURN
 Ler a variável de sistema
 Acessar funções KRL predefinidas

10.4 Programar stop condicionado com KRL

Descrição O "stop condicional" permite ao usuário definir um ponto na trajetória na qual


o robô para, caso seja cumprida uma determinada condição. O ponto é cha-
mado de "ponto de stop". Assim que a condição não esteja mais sendo cum-
prida, o robô volta a se deslocar.
A unidade de comando do robô calcula, durante o tempo de execução, o pon-
to máximo no qual ela deve frear, para poder parar no ponto de stop. A partir
desse ponto ("ponto de frenagem") ela avalia se a condição está ou não sen-
do cumprida.
 Se a condição estiver cumprida no ponto de frenagem, o robô freia, para
parar no ponto de stop.
Se, todavia, a condição mudar para "não cumprida" antes de que seja al-
cançado o ponto de stop, o robô acelera novamente e não para.
 Se a condição não for cumprida no ponto de frenagem, o robô continua se
deslocando, sem frear.

208 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


10 Funções de comutação KRL

Fig. 10-11: Spline com parada condicional

Pos. Explicação
1 Ponto de frenagem calculado, dependente de trajeto e
velocidade
2 Ponto de stop predefinido (através de formulário Inline ou
KRL)
3 Possível cancelamento da impressão booleana -> acelera-
ção sobre a velocidade programada

A princípio é possível programar tantos stops condicionais quanto desejado.


Contudo, no máximo 10 trechos "ponto de frenagem → ponto de stop" podem
se sobrepor.
Durante um procedimento de frenagem, a unidade de comando do robô exibe
a seguinte mensagem em T1/T2: Stop condicional ativo (linha {Número de li-
nha}).
Possibilidades da programação
 No spline block (CP e PTP) ou no passo individual spline: Formulário Inli-
ne Janela de opções Lógica Stop condicionado

Fig. 10-12: Stop condicional

 Antes de um spline block (CP e PTP): Formulário Inline Spline Stop con-
dicionado

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 209 / 251


Programação do robô 2

Fig. 10-13: Formulário inline Spline Stop Condition

 Programação por meio do comando KRL STOP WHEN PATH

Stop condi- STOP WHEN PATH = Offset <ONSTART> IFCondição


cionado com KRL
Elemento Descrição
ONSTART Ponto de referência da instrução
 Sem ONSTART: Ponto de destino
 Com ONSTART: Ponto de partida
Se o ponto de referência estiver aproximado, valem as
mesmas regras que no PATH trigger.

Offset Tipo: INT ou REAL; constante, variável ou função; uni-


dade: mm
Através de Offset, o ponto de stop pode ser deslocado no
espaço.
 Valor positivo: Deslocamento no sentido do final do mo-
vimento
 Valor negativo: Deslocamento no sentido do início do
movimento
A qual ponto se refere o deslocamento, depende se ONS-
TART está definido ou não. Se nenhum deslocamento for
desejado, Offset=0 deve ser programado.
O ponto de stop não pode ser deslocado espacialmente de
maneira livre. São válidos os mesmos limites que no PATH
trigger. (>>> "Deslocamento máx." Página 206)
Condição Tipo: BOOL
Condição de stop. São admissíveis:
 uma variável booleana global
 um nome de sinal
 uma comparação
 um vínculo lógico simples: NOT, OR, AND ou EXOR

O stop condicionado pode ser utilizado nas seguintes posições:


 No passo individual spline
 No Spline Block (CP e PTP)
Entre STOP WHEN PATH e ENDSPLINE deve haver pelo menos 1 seg-
mento.
 Antes de um Spline Block (CP e PTP)
STOP WHEN PATH refere-se, neste caso, ao Spline Block. Entre STOP
WHEN PATH e o Spline Block podem existir instruções, mas nenhuma
instrução de movimento.
Exemplo

1 SPTP P1
2 SLIN P2

210 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


10 Funções de comutação KRL

3 STOP WHEN PATH = -30 IF $IN[20]==TRUE ; Para 30 mm antes de P3,


caso a entrada 20 seja TRUE
4 SLIN P3
5 SLIN P4

10.5 Programar região de deslocamento constante com KRL

Descrição Em um CP spline block, é possível definir uma região na qual o robô mantém
constante a velocidade programada sempre que possível. A região é chama-
da de "região de deslocamento constante".
 É possível definir 1 região de deslocamento constante por spline block
CP.
 Uma região de deslocamento constante é definida por uma indicação de
início e uma indicação de final.
 A região pode não pode se estender além do spline block.
 A região pode ser tão pequena quanto desejado.

Fig. 10-14: Área de deslocamento constante Spline

Se não for possível manter constante a velocidade programada, a unidade de


comando do robô indica isso através de uma mensagem durante a execução
do programa.
Região de deslocamento constante ao longo de vários segmentos:
Uma região de deslocamento constante pode se estender ao longo de diver-
sos segmentos, com diferentes velocidades programadas. Nesse caso a mais
baixa velocidade vale para toda a região.
Também nos segmentos com velocidade programada mais elevada, o deslo-
camento nesse caso ocorre com a velocidade mais baixa. Então não é forne-
cida nenhuma mensagem relativa a velocidade abaixo do nível. Isso só ocorre
se não for possível manter a velocidade mais baixa.
Possibilidades da programação
 Formulário Inline Janela de opções Lógica Região de deslocamento cons-
tante: o início/final da região é registrado no respectivo segmento CP

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 211 / 251


Programação do robô 2

Fig. 10-15: Região de deslocamento constante

 Programação por meio do comando KRL CONST_VEL START e


CONST_VEL END

Região de deslo- CONST_VEL START = Offset <ONSTART>


camento <Segmentos spline …>
constante com
...
KRL
CONST_VEL END = Offset <ONSTART>

Elemento Descrição
ONSTART Ponto de referência da instrução
 Com ONSTART: Ponto de partida
 Sem ONSTART: Ponto de destino
Se o ponto de partida ou de destino estiver aproximado, o
ponto de referência resulta da mesma forma que na apro-
ximação homogênea no PATH trigger.

Offset Tipo: INT ou REAL; constante, variável ou função; uni-


dade: mm
Através de CONST_VEL START = Offset, o início da região
pode ser deslocado no espaço.
Através de CONST_VEL END = Offset, o final da região
pode ser deslocado no espaço.
 Valor positivo: Deslocamento no sentido do final do mo-
vimento
 Valor negativo: Deslocamento no sentido do início do
movimento
A qual ponto se refere o deslocamento, depende se ONS-
TART está definido ou não. Se nenhum deslocamento for
desejado, Offset=0 deve ser programado.

Com CONST_VEL são definidas as regiões de deslocamento constante.


CONST_VEL pode ser utilizado somente em Spline Blocks CP.
Entre CONST_VEL END e ENDSPLINE deve haver pelo menos 1 segmento
spline.
Um Spline Block CP pode conter 1 CONST_VEL ou 1 TIME_BLOCK (bloco
de tempo), mas não ambos.

212 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


10 Funções de comutação KRL

Exemplo
Aqui a região de deslocamento constante se estende ao longo de diversos
segmentos com diferentes velocidades programadas. Nesse caso, a mais
baixa velocidade, portanto, 0,2 m/s, vale para toda a região.
1 PTP P0
2 SPLINE WITH $VEL.CP = 2.5
3 SLIN P1
4 CONST_VEL START = +100
5 SPL P2 WITH $VEL.CP = 0.5
6 SLIN P3 WITH $VEL.CP = 0.2
7 SPL P4 WITH $VEL.CP = 0.4
8 CONST_VEL END = -50
9 SCIRC P5, P6
10 SLIN P7
11 ENDSPLINE

10.6 Programar bloco de tempo do spline

Descrição TIME_BLOCK pode ser usado em Spline Blocks CP e PTP.


TIME_BLOCK permite que o Spline Block ou uma parte deste inicie em uma
hora definida. Além disso, é possível atribuir parcelas de tempo a áreas dentro
de TIME_BLOCK.
No Spline Block, pontos podem ser alterados, adicionados ou removidos sem
alterar as especificações de tempo. Isso possibilita ao usuário corrigir a traje-
tória cartesiana e, assim, manter as especificações de tempo existentes.
Um Spline Block pode conter 1 bloco de tempo, ou seja, 1 instrução
TIME_BLOCK START … TIME_BLOCK END. Entre elas podem ser usadas
quantas TIME_BLOCK PART desejar. O bloco de tempo pode ser usado ape-
nas em Spline Blocks.
Um Spline Block CP pode conter 1 bloco de tempo ou 1 região de desloca-
mento constante, mas não ambos.

Bloco de tempo TIME_BLOCK START


com KRL TIME_BLOCK PART = Parcela_N >
TIME_BLOCK END = Tempo total

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 213 / 251


Programação do robô 2

Elemento Descrição
Parcela Tipo: INT ou REAL; constante, variável ou função
Parcela desejada do tempo total para o seguinte percurso:
 Do ponto antes de TIME_BLOCK PART=parcela_anterior
ao ponto antes de TIME_BLOCK PART=parcela
 Se parcela_anterior não existir:
Do ponto antes de TIME_BLOCK START
ao ponto antes de TIME_BLOCK PART=parcela
Com "parcela desejada", quer-se dizer: As parcelas são
mantidas tão precisas quanto possível pela unidade de
comando do robô. Mas geralmente elas não são mantidas
com precisão.
O usuário pode atribuir as parcelas de forma que elas jun-
tas resultem em 100. Então ele pode considerar as parce-
las como percentagem do tempo total.
Porém, as parcelas não podem resultar em 100, mas
podem resultar em qualquer soma! A unidade de comando
do robô define a soma das parcelas sempre igual ao tempo
total. Com isso, as parcelas podem ser utilizadas e também
alteradas de maneira muito flexível.
Quando parcelas são atribuídas, sempre uma
TIME_BLOCK PART deve estar diretamente antes de
TIME_BLOCK END. Entre elas não pode haver nenhum
segmento.
Tempo total Tipo: INT ou REAL; constante, variável ou função; uni-
dade: s
Tempo em que o seguinte percurso é executado:
 Do ponto antes de TIME_BLOCK START
ao ponto antes de TIME_BLOCK END
O valor deve ser maior que 0. O tempo total é mantido com
precisão. Se ele não puder ser mantido, p. ex., porque um
tempo muito curto foi programado, o robô se move o mais
rápido possível. Além disso, em T1 e T2, é exibida uma
mensagem.

Se o valor para parcela ou tempo total for atribuído através de uma fun-
ção, valem as mesmas restrições para as funções no trigger.

Explicação sobre a programação


Antes de TIME_BLOCK START e depois de TIME_BLOCK END, devem ha-
ver segmentos spline não obrigatórios. No entanto, recomenda-se programar
da seguinte maneira:
 Entre SPLINE e TIME_BLOCK START há pelo menos 1 segmento spline.
 Entre TIME_BLOCK END e ENDSPLINE há pelo menos 1 segmento spli-
ne.
Vantagens:
 O tempo total programado é mantido com precisão também na aproxima-
ção.
 Segmentos antes de TIME_BLOCK START possibilitam acelerar para a
velocidade necessária.
Exemplo

214 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


10 Funções de comutação KRL

SPLINE
SLIN P1
SPL P2
TIME_BLOCK START
SLIN P3
TIME_BLOCK PART = 12.7
SPL P4
SPL P5
SPL P6
TIME_BLOCK PART = 56.4
SCIRC P7, P8
SPL P9
TIME_BLOCK PART = 27.8
TIME_BLOCK END = 3.9
SLIN P10
ENDSPLINE

Os pontos P2 a P9 são executados com precisão no tempo programado de


3,9 s. A unidade de comando do robô define o tempo total de 3,9 s igual à
soma de todas as parcelas, portanto, 96,9 parcelas.

Percurso Tempo que a unidade de comando do robô atribui ao per-


curso
P2 … P3 12,7 parcelas de 3,9 s = 0,51 s
P3 … P6 56,4 parcelas de 3,9 s = 2,27 s
P6 … P9 27,8 parcelas de 3,9 s = 1,12 s

Seleção de passo Dependendo em qual linha está sendo executada uma seleção de passo, a
unidade de comando do robô planeja ou não o bloco de tempo.

Seleção de passo na linha … Bloco de tempo é planejado?


No Spline Block, antes de Sim
TIME_BLOCK START
TIME_BLOCK START Não
No bloco de tempo O Spline Block é executado como
TIME_BLOCK END se não houvesse nenhuma instru-
No Spline Block, após ção TIME_BLOCK.
TIME_BLOCK END

Se a unidade de comando do robô não planeja o bloco de tempo, é emitida a


seguinte mensagem: Bloco de tempo ignorado devido ao deslocamento SAK.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 215 / 251


Programação do robô 2

216 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


11 Interpretador Submit

11 Interpretador Submit
t

11.1 Visão geral


t

Nesta unidade de aprendizagem são repassados os seguintes conteú-


dos:
 Utilização do Interpretador Submit

11.2 Status do Interpretador Submit

Descrição do No KSS 8.x rodam duas Tasks


Interpretador  Interpretador de robô (execução dos programas de movimento do robô e
Submit sua lógica)
 Interpretador de comando (execução de um programa de controle parale-
lo)
Estrutura do programa SPS.SUB:
1 DEF SPS ( )
2 DECLARATIONS
3 INI
4
5 LOOP
6 WAIT FOR NOT($POWER_FAIL)
7 TORQUE_MONITORING()
8
9 USER PLC
10 ENDLOOP

O estado do Interpretador Submit

O Interpretador Submit Interpretador Submit Interpretador Submit


está em execução parado desselecionado

O interpretador de comando
 pode ser iniciado automática ou manualmente
 também pode ser parado ou desselecionado manualmente
 pode assumir funções de operação e de comando no ambiente do robô
 como padrão está criado com o nome SPS.sub no diretório R1/SYSTEM
 pode ser programado com o conjunto de comandos KRL
 não pode processar nenhum comando KRL, que esteja relacionado com
movimentos de robô
 permite movimentos assíncronos de eixos adicionais
 pode acessar variáveis de sistema lendo e gravando
 pode acessar entradas/saídas lendo e gravando

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 217 / 251


Programação do robô 2

Correlações na
Atenção!
programação do O Interpretador Submit não pode ser usado para aplica-
Interpretador ções críticas de tempo! Para estes casos é necessário usar um PLC. Moti-
Submit vos:
 O Interpretador Submit divide a capacidade do sistema com o Interpre-
tador de robô e a gestão de IO, que têm prioridades maiores. Por isto, o
Interpretador Submit não operará regularmente no ciclo de interpolação
da unidade de comando do robô de 12ms.
 Além disso, o tempo de execução do Interpretador Submit é inconstante.
O tempo de execução do Interpretador Submit é influenciado pelo núme-
ro das linhas no SUB-programa. Também as linhas de comentário e va-
zias exercem um efeito.

 Início automático do Interpretador Submit


 O interpretador Submit é iniciado automaticamente quando a unidade
de comando do robô é ligada após uma partida a frio.
 É iniciado o programa, que está definido no arquivo KRC/STEU/
MADA/$custom.dat.
$PRO_I_O[]="/R1/SPS()"

 Operação manual do Interpretador Submit


 Selecionar a operação através da sequência de menu Configuração
> Interpretador SUBMIT > Iniciar/Selecionar.
 Operação direta através da barra de status da exibição de status In-
terpretador Submit. Ao ser selecionado, abre-se uma janela com as
opções executáveis.

Quando um arquivo de sistema, p.ex. $config.dat ou $custom.dat, é


modificado, e ocorre um erro através disto, o Interpretador Submit é
desselecionado automaticamente. Se o erro estiver solucionado no
arquivo de sistema, o Interpretador Submit deve ser novamente selecionado
manualmente.

Particularidades na programação do Interpretador Submit


 Não é possível executar nenhuma instrução para movimentos do robô
como
 PTP, LIN, CIRC etc.
 acessos de subprogramas, que contêm movimentos de robô
 Instruções, que se referem a movimentos do robô, TRIGGER ou BRA-
KE.
 Podem ser controlados eixos assíncronos, como E1.
IF (($IN[12] == TRUE) AND ( NOT $IN[13] == TRUE)) THEN
ASYPTP {E1 45}
ENDIF
...
IF ((NOT $IN[12] == TRUE) AND ($IN[13] == TRUE)) THEN
ASYPTP {E1 0}
ENDIF

 Instruções entre a linha LOOP e ENDLOOP são processadas continuamen-


te em "segundo plano".
 Qualquer parada através de comandos de espera ou loops de espera
deve ser impedida, uma vez que isto retarda adicionalmente o processa-
mento do Interpretador Submit.
 É possível uma comutação de saídas.

218 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


11 Interpretador Submit

Aviso!
Não é verificado, se o Interpretador do robô ou o Inter-
pretador Submit acessam simultaneamente a mesma saída, uma vez que
isto pode ser desejado em determinados casos.
Por isso, a atribuição das saídas deve ser cuidadosamente verificada pelo
usuário. Caso contrário, podem ocorrer sinais de saída inesperados, p.ex.,
em dispositivos de segurança. Pode ocorrer morte, lesões corporais graves
ou danos materiais significativos.

Nos modos de teste o $OV_PRO não pode ser escrito a


partir do Interpretador Submit, porque a alteração pode
ser inesperada para usuários que trabalham no robô industrial. Podem ocor-
rer morte, ferimentos ou danos materiais.

Aviso!
Não processar sinais relevantes de segurança, sinais
críticos de tempo e variáveis através do Interpretador Submit.

Procedimento na 1. A programação ocorre no estado parado ou desselecionado.


programação do 2. O programa padrão SPS.sub é carregado no editor.
Interpretador 3. Executar declarações necessárias e a inicialização. Aqui devem ser admi-
Submit nistradas as pastas preparadas.
4. Executar as expansões de programa na pasta USER PLC.
5. Fechar e salvar o Interpretador Submit.
6. Caso o Submit não inicie automaticamente, iniciar manualmente.
Exemplo de programa com base em uma programação de sinalizador inter-
mitente no Interpretador Submit
DEF SPS( )
DECLARATIONS
DECL BOOL flash ;Declaração no $CONFIG.dat
INI
flash = FALSE
$TIMER[32]=0 ; Resetar TIMER[32]
$TIMER_STOP[32]=false ; Iniciar TIMER[32]
...
LOOP
...
USER PLC
IF ($TIMER[32]>500) AND (flash==FALSE) THEN
flash=TRUE
ENDIF
IF $TIMER[32]>1000 THEN
flash=FALSE
$TIMER[32]=0
ENDIF
; Atribuir a uma lâmpada (saída 99)
$OUT[99] = flash
...
ENDLOOP

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 219 / 251


Programação do robô 2

220 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


12 Trabalhar com sinais analógicos

12
2
Trabalhar com sinais analógicos
T

12.1 Visão geral

Nesta unidade de aprendizagem são repassados os seguintes conteú-


dos:
 Programar entradas analógicas
 Programar saídas analógicas

12.2 Programar entradas analógicas

Descrição

Fig. 12-1: Sinais analógicos

 A KR C4 dispõe de mais de 32 entradas analógicas.


 Para os sinais analógicos é necessário um sistema de bus opcional e
deve ser projetado via WorkVisual.
 Entradas analógicas são lidas através das variáveis de sistema
$ANIN[1] ... $ANIN[32].
 Leitura cíclica (a cada 12ms) de uma entrada analógica.
 Os valores $ANIN[nr] movem-se entre 1,0 e -1,0 (100% e -100%) e re-
presentam a tensão de entrada de +10 V a -10 V.

Função Atribuição estática de valores


 atribuição direta de valores
...
REAL value

value = $ANIN[2]
...

 Atribuição de valores de um acordo de sinais


...
SIGNAL sensor $ANIN[6]
REAL value

value = sensor
...

Atribuição dinâmica de valores


 Todas as variáveis utilizadas em uma instrução ANIN devem estar decla-
radas em listas de dados (localmente ou no $CONFIG.DAT).

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 221 / 251


Programação do robô 2

 São permitidas, no máximo, três instruções ANIN ON simultaneamente.


 No máximo duas instruções ANIN ON podem usar a mesma variável Valor
ou acessar a mesma entrada analógica.
 Sintaxe
 Iniciar leitura cíclica:
ANIN ON valor = fator * nome do sinal <±Offset>
Elemento Descrição
Valor Tipo: REAL
Em Valor é gravado o resultado da leitura cíclica. Valor
pode ser uma variável ou um nome do sinal para uma
saída.
Fator Tipo: REAL
Fator qualquer. Pode ser uma constante, uma variável ou
um nome do sinal.
Nome do Tipo: REAL
sinal
Indica a entrada analógica. Nome do sinal deve ter sido
declarado anteriormente com SINAL. Não é possível indi-
car, em vez do nome do sinal, diretamente a entrada ana-
lógica $ANIN[x].
Os valores de uma entrada analógica $ANIN[x] movem-se
entre +1.0 e -1.0 e representam uma tensão de +10 V até
-10 V.
Offset Tipo: REAL
Pode ser uma constante, uma variável ou um nome do
sinal.

 Finalizar a leitura cíclica:


ANIN OFF nome do sinal
 Exemplo 1:
DEFDAT myprog
DECL REAL value = 0
ENDDAT

DEF myprog( )
SIGNAL sensor $ANIN[3]
...
ANIN ON value = 1.99*sensor-0.75
...
ANIN OFF sensor

 Exemplo 2:
DEFDAT myprog
DECL REAL value = 0
DECL REAL corr = 0.25
DECL REAL offset = 0.45
ENDDAT

DEF myprog( )
SIGNAL sensor $ANIN[7]
...
ANIN ON value = corr*sensor-offset
...
ANIN OFF sensor

222 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


12 Trabalhar com sinais analógicos

Procedimento na
O pré-requisito para o uso dos sinais analógicos é uma
programação projeção correta do sistema de bus com os sinais analó-
com entradas gicos conectados.
analógicas
Programação de ANIN ON /OFF
1. Seleção da entrada analógica correta
2. Realização do acordo de sinais
3. Declaração das variáveis necessárias em uma lista de dados
4. Ligar: Programação da instrução ANIN ON
5. Teste para verificar se, no máximo, 3 entradas dinâmicas estão ativas
6. Desligar: Programação da instrução ANIN OFF

12.3 Programar saídas analógicas

Descrição

Fig. 12-2: Sinais analógicos

 A KR C4 dispõe de 32 saídas analógicas.


 Para os sinais analógicos é necessário um sistema de bus opcional e
deve ser projetado via WorkVisual.
 Saídas analógicas são lidas através das variáveis de sistema $ANOUT[1]
... $ANOUT[32].
 Gravação cíclica (a cada 12ms) em uma saída analógica
 Os valores $ANOUT[nr] movem-se entre 1,0 e -1,0 (100% e -100%) e re-
presentam a tensão de saída de +10 V a -10 V.

Função
Podem ser utilizadas no máximo 8 saídas analógicas
(estáticas e dinâmicas) ao mesmo tempo. ANOUT ativa
uma parada de avanço.

Atribuição estática de valores


 atribuição direta de valores
...
ANOUT[2] = 0.7 ; 14 mA (70%) na saída analógica 2 (no módulo 0-20 mA)
...

 atribuição de valores através de variáveis


...
REAL value
value = -0.8

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 223 / 251


Programação do robô 2

ANOUT[4] = value ; -8 V (80%) na saída analógica 4 (no módulo -10 V -


10 V)
...

 Programação através de formulário Inline

Fig. 12-3: Formulário Inline ANOUT estático

Pos. Descrição
1 Número da saída analógica
 CHANNEL_1 … CHANNEL_32
2 Fator para a tensão
 0 … 1 (Escalonamento: 0.01)

Atribuição dinâmica de valores


 Todas as variáveis utilizadas em uma instrução ANOUT devem estar de-
claradas em listas de dados (localmente ou no $CONFIG.DAT).
 São permitidas, no máximo, quatro instruções ANOUT ON simultanea-
mente.
 ANOUT ativa uma parada de avanço.
 Sintaxe
 Iniciar gravação cíclica:
DelayANOUT ON nome do sinal = fator * elemento regulador <±Offset>
<DELAY = ±tempo> <MÍNIMO = valor mínimo> <MÁXIMO = valor
máximo>

Elemento Descrição
Nome do Tipo: REAL
sinal
Indica a saída analógica. Nome do sinal deve ter sido decla-
rado anteriormente com SINAL . Não é possível indicar,
em vez do nome do sinal, diretamente a saída analógica
$ANOUT[x].
Os valores de uma saída analógica $ANOUT[x] movem-se
entre +1.0 e -1.0 e representam uma tensão de +10 V até
-10 V.
Fator Tipo: REAL
Fator qualquer. Pode ser uma constante, uma variável ou
um nome do sinal.
Elemento Tipo: REAL
regulador
Pode ser uma constante, uma variável ou um nome do
sinal.
Offset Tipo: REAL
Pode ser uma constante, uma variável ou um nome do
sinal.

224 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


12 Trabalhar com sinais analógicos

Elemento Descrição
Tempo Tipo: REAL
Unidade: Segundos. Com a palavra-chave DELAY e uma
indicação de tempo positiva ou negativa o sinal de saída
pode ser emitido com retardo (+) ou antecipado (-).
Valor mínimo, Tipo: REAL
Valor máximo
Tensão mínima e/ou máxima, que deve estar aplicada na
saída. Não fica abaixo nem é ultrapassada, mesmo que os
valores calculados estejam abaixo ou acima.
Valores admissíveis: -1.0 até +1.0 (corresponde a -10 V
até +10 V).
Pode ser uma constante, uma variável, um componente
estrutural ou um elemento de campo. Em todo o caso, o
valor mínimo deve ser menor que o valor máximo. A
sequência das palavras-chave MÍNIMO e MÁXIMO deve
ser mantida.

 Finalizar a gravação cíclica:


ANOUT OFF nome do sinal
 Exemplo 1
DEF myprog( )
SIGNAL motor $ANOUT[3]
...
ANOUT ON motor = 3.5*$VEL_ACT-0.75 DELAY=0.5
...
ANOUT OFF motor

 Exemplo 2
DEFDAT myprog
DECL REAL corr = 1.45
DECL REAL offset = 0.25
ENDDAT

DEF myprog( )
SIGNAL motor $ANOUT[7]
...
ANOUT ON motor = corr*$VEL_ACT-offset
...
ANOUT OFF motor

Procedimento na
O pré-requisito para o uso dos sinais analógicos é uma
programação projeção correta do sistema de bus com os sinais analó-
com saídas gicos conectados.
analógicas
Programação de ANOUT ON /OFF
1. Seleção da saída analógica correta
2. Realização do acordo de sinais
3. Declaração das variáveis necessárias em uma lista de dados
4. Ligar: Programação da instrução ANOUT ON
5. Teste para verificar se, no máximo, 4 saídas dinâmicas estão ativas
6. Desligar: Programação da instrução ANOUT OFF
Exemplo:

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 225 / 251


Programação do robô 2

Fig. 12-4: Exemplo de sinal de saída analógico

DEF myprog( )
SIGNAL motor $ANOUT[3]
...
ANOUT ON motor = 3.375*$VEL_ACT MINIMUM=0.30 MAXIMUM=0.97
...
ANOUT OFF motor

226 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


12 Trabalhar com sinais analógicos

12.4 Exercício: Trabalhando com E/Ss analógicas

Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Uso de acordos de sinais em entradas/saídas
 Inclusão estática ou dinâmica de entradas analógicas em processos de
trabalho
 Inclusão estática ou dinâmica de saídas analógicas em processos de tra-
balho

Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos teóricos de acordos de sinais
 Conhecimentos teóricos sobre a inclusão de entradas/saídas analógicas

Definição de Configure o seu sistema de tal forma, que você possa alterar o override de
funções programa através da entrada analógica. Adicionalmente a velocidade de robô
efetivamente percorrida deve controlar uma saída analógica.
Tarefa parcial 1
1. Crie um programa com o nome Velocidade.
2. Use a entrada analógica 1, que é controlada pelo potenciômetro.
3. Adapte o override de programa no Interpretador Submit.
4. Teste o seu programa conforme a prescrição.
Tarefa parcial 2
1. Expanda o seu programa com movimentos de trajetória (velocidade: até
2 m/s), que estão em um loop sem fim.
2. Use a saída analógica 1, da indicação do painel.
3. Use a variável de sistema $VEL_ACT para a velocidade atualmente exe-
cutada.
4. Teste o seu programa conforme a prescrição.
5. Adicionalmente: Se a velocidade for menor que 0,2 m/s a saída deve mes-
mo assim ser sujeitada com 1,0 V e se a velocidade foi maior que 1,8 m/
s a saída não deve emitir mais que 9,0 V.

Tome o cuidado para ativar somente uma vez a E/S analógica.

O que você deve saber agora:


1. Quantas E/S analógicas podem ser usadas na unidade de comando KRC?
............................................................
............................................................
2. Quantas entradas digitais, entradas analógicas e saídas analógicas prede-
finidas a unidade de comando KUKA pode usar simultaneamente?
............................................................
............................................................
3. Como se chamam os comandos KRL para a inicialização e finalização cí-
clica da saída analógica?
............................................................
............................................................
4. Como é consultada estaticamente uma entrada analógica?

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 227 / 251


Programação do robô 2

.............................................................
.............................................................

228 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


13 Anexo

13 Anexo
A

13.1 Programar movimentos com KRL

Definição de um
movimento

Fig. 13-1: Formulários Inline de movimento PTP/LIN/CIRC

Dados necessários para um movimento


 Tipo de movimento - PTP, LIN, CIRC
 Posição de destino e possivelmente posição auxiliar
 Parada exata ou aproximação
 Velocidade - PTP (%) e movimento da trajetória (m/s)
 Ferramenta - TCP e carga
 Sistema de coordenadas da base
 Ferramenta conduzida pelo robô ou externa
 Aceleração
 event. parâmetro de aproximação
 Controle de orientação em movimentos de trajetória
 possível com KRL: Ângulo inscrito em um movimento circular CIRC

Princípio da Tipo de movimento PTP


programação de  PTP Ponto de destino <Aproximação>
movimento
Elemento Descrição
Ponto de des- Tipo: POS, E6POS, AXIS, E6AXIS, FRAME
tino
O ponto de destino pode ser cartesiano ou específico do
eixo. As coordenadas cartesianas referem-se ao sistema
de coordenadas BASE.
Se não forem informados todos os componentes do ponto
de destino, a unidade de comando para os componentes
faltantes assume os valores da posição anterior.
Aproximação C_PTP
 Faz com que o ponto de destino seja aproximado.
 Na aproximação PTP-PTP a informação C_PTP é
suficiente.
C_DIS
 Somente para aproximação PTP-CP. Esse parâ-
metro define o momento mais cedo para a aproxi-
mação. Estas indicações são possíveis:
 Parâmetro de distância: O momento mais cedo
para iniciar a aproximação é quando a distância ao
ponto de destino estiver abaixo de $APO.CDIS.

 O robô acessa uma posição do DAT-File; a posição foi programada ante-


riormente com o formulário Inline, aproximando esse ponto P3
PTP XP3 C_PTP

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 229 / 251


Programação do robô 2

 O robô acessa uma posição inserida


 Específico do eixo (AXIS ou E6AXIS)
PTP {A1 0, A2 -80, A3 75, A4 30, A5 30, A6 110}

 Posição espacial (com ferramenta e base atualmente ativas)


PTP {X 100, Y -50, Z 1500, A 0, B 0, C 90, S 3, T 35}

 O robô só opera com a inserção de um ou mais agregados


PTP {A1 30} ; só A1 é deslocado para 30°

PTP {X 200, A 30} ; só em X para 200mm e A para 30°

Tipo de movimento LIN


 LINPonto de destino <Aproximação da trajetória>
Elemento Descrição
Ponto de des- Tipo: POS, E6POS, FRAME
tino
Se não forem informados todos os componentes do ponto
de destino, a unidade de comando para os componentes
faltantes assume os valores da posição anterior.
Os dados Status e Turn dentro do ponto de destino do tipo
POS ou E6POS são ignorados em movimentos LIN (assim
como em movimentos CIRC).
As coordenadas referem-se ao sistema de coordenadas
BASE.
Aproximação Esse parâmetro faz com que o ponto de destino seja apro-
da trajetória ximado. Ao mesmo tempo define o momento mais cedo
para a aproximação. Os possíveis dados:
 C_DIS
Parâmetro de distância: O momento mais cedo
para iniciar a aproximação é quando a distância ao
ponto de destino estiver abaixo de $APO.CDIS.
 C_ORI
Parâmetros de orientação: O momento mais cedo
para iniciar a aproximação é quando o ângulo de
orientação estiver abaixo de $APO.CORI.
 C_VEL
Parâmetros de velocidade: O momento mais cedo
para iniciar a aproximação é quando a velocidade
na fase de frenagem ao ponto de destino estiver
abaixo de $APO.CVEL.

 O robô se movimenta em uma posição calculada aproximando esse ponto


ABLAGE[4]
LIN ABLAGE[4] C_DIS

Tipo de movimento CIRC


 CIRC Ponto auxiliar, ponto de destino < Ângulo inscrito (CA)> <Aproximação
da trajetória>

230 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


13 Anexo

Elemento Descrição
Ponto auxiliar Tipo: POS, E6POS, FRAME
Se não forem informados todos os componentes do ponto
auxiliar, a unidade de comando assume para os compo-
nentes faltantes os valores da posição anterior.
Os ângulos de orientação, assim como os dados Status e
Turn dentro de um ponto auxiliar normalmente são ignora-
dos.
O ponto auxiliar não pode ser aproximado. Ele é percorrido
no tipo de execução do programa GO. No tipo de execução
do programa Movimento o robô para no ponto auxiliar.
As coordenadas referem-se ao sistema de coordenadas
BASE.
Ponto de des- Tipo: POS, E6POS, FRAME
tino
Se não forem informados todos os componentes do ponto
de destino, a unidade de comando para os componentes
faltantes assume os valores da posição anterior.
Os dados Status e Turn dentro do ponto de destino do tipo
POS ou E6POS são ignorados em movimentos CIRC
(assim como em movimentos LIN).
As coordenadas referem-se ao sistema de coordenadas
BASE.
Ângulo Indica o ângulo total do movimento circular. Isso possibilita
inscrito uma prorrogação do movimento além do ponto de destino
CA programado ou, ainda, uma redução. Deste modo, o ponto
de destino efetivo não corresponde mais ao ponto de des-
tino programado.
Unidade: Graus. Sem limitação; pode-se programar espe-
cialmente um ângulo inscrito maior que 360º.
 Ângulo inscrito positivo: a trajetória circular é inicia-
da no sentido Ponto de partida › Ponto auxiliar ›
Ponto de destino.
 Ângulo inscrito negativo: a trajetória circular é ini-
ciada no sentido Ponto de partida › Ponto de desti-
no › Ponto auxiliar.
Aproximação Esse parâmetro faz com que o ponto de destino seja apro-
da trajetória ximado. Ao mesmo tempo define o momento mais cedo
para a aproximação. Os possíveis dados:
 C_DIS
Parâmetro de distância: O momento mais cedo
para iniciar a aproximação é quando a distância ao
ponto de destino estiver abaixo de $APO.CDIS.
 C_ORI
Parâmetros de orientação: O momento mais cedo
para iniciar a aproximação é quando o ângulo de
orientação estiver abaixo de $APO.CORI.
 C_VEL
Parâmetros de velocidade: O momento mais cedo
para iniciar a aproximação é quando a velocidade
na fase de frenagem ao ponto de destino estiver
abaixo de $APO.CVEL.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 231 / 251


Programação do robô 2

 O robô acessa as posições previamente programadas do arquivo DAT e


percorre um ângulo inscrito de 190°.
CIRC XP3, XP4, CA 190

 O robô acessa as posições indicadas e percorre um ângulo inscrito de


180°.
CIRC {X 100, Y ...}, {X 150, Y ...}, CA 180

 Ângulo inscrito CA

No ponto de destino real é usada a orientação ensinada no ponto de


destino programado.

 Ângulo inscrito positivo (CA>0): O círculo é operado no sentido pro-


gramado: ponto de partida-ponto auxiliar-ponto de destino

Fig. 13-2: Ângulo do círculo CA = +290°

 Ângulo inscrito negativo (CA<0): o círculo é operado contra o sen-


tido programado: ponto de partida-ponto de destino-ponto auxiliar

Fig. 13-3: Ângulo do círculo CA = -290°

232 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


13 Anexo

Função dos Configurações prévias para a programação de movimento


parâmetros de  Podem ser assumidas as configurações existentes:
movimento
 a partir da passagem da linha INI
 a partir do último formulário Inline
 a partir das últimas configurações das respectivas variáveis de siste-
ma
 Modificar ou inicializar as respectivas variáveis de sistema
Variáveis de sistema dos parâmetros de movimento
 Ferramenta: $TOOL e $LOAD
 Ativação dos TCPs medidos
$TOOL = tool_data[x] ; x = 1...16

 Ativação dos respectivos dados de carga


$LOAD = load_data[x] ; x = 1...16

 Base de referência / base de trabalho: $BASE


 Ativação da base medida
$BASE = base_data[x] ; x = 1...32

 Ferramenta conduzida pelo robô ou externa: $IPO_MODE


 Ferramenta conduzida por robô
$IPO_MODE = #BASE

 Ferramenta externa
$IPO_MODE = #TCP

 Velocidade:
 Em movimento PTP
$VEL_AXIS[x] ; x=1...8 para cada eixo

 Em movimentos de trajetória LIN ou CIRC


$VEL.CP = 2.0 ; [m/s] Velocidade trajetória

$VEL.ORI1 = 150 ; [°/s] Velocidade de oscilação

$VEL.ORI2 = 200 ; [°/s] Velocidade de rotação

A direção de trabalho da ferramenta é geralmente o eixo X. A veloci-


dade de rotação é a rotação em torno desse eixo X com o ângulo C.
Na velocidade de giro, é girado em torno dos outros dois ângulos (A
e B).

 Aceleração
 Em movimento PTP
$ACC_AXIS[x] ; x=1...8 para cada eixo

 Em movimentos de trajetória LIN ou CIRC


$ACC.CP = 2.0 ; [m/s²] Aceleração de trajetória

$ACC.ORI1 = 150 ; [°/s²] Aceleração de oscilação

$ACC.ORI2 = 200 ; [°/s²] Aceleração de rotação

 Solavanco
 Em movimento SPTP

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 233 / 251


Programação do robô 2

$GEAR_JERK[1...12] = 0 ... 100 Solavanco de redutor dos eixos A1 a E6


em porcentagem (1...100)
SPTP XP10 WITH GEAR_JERK[1]=22, GEAR_JERK[2]=66

 Em movimentos de trajeto SLIN ou SCIRC


$JERK={CP 50.0,ORI 50000.0,AX {A1 1000.0,A2 1000.0,A3 1000.0,A4
1000.0,A5 1000.0,A6 1000.0,E1 1000.0,E2 1000.0,E3 1000.0,E4 1000.0,E5
1000.0,E6 1000.0}}

O agregado consiste nos seguintes componentes:

 CP: Alteração da aceleração de trajeto em [m/s3]


 ORI: Alteração da aceleração de orientação em [°/s3]
 AX: Alteração da aceleração do eixo em [°/s3] em eixos rotatórios
ou em [m/s3] em eixos lineares
SLIN XP13 WITH $JERK = {CP 44} ; [m/s³] Alteração da aceleração de
trajeto

 Distância de aproximação
 Em SPINE passos individuais SLIN, SCIRC e em SPTP: C_SPL
A distância do ponto de destino deverá ser inferior ao valor
$APO.CDIS
$APO.CDIS = 250.0 ; [mm] Distância
SPTP XP3 C_SPL
SLIN XP4 C_SPL

 Somente em movimento PTP: C_PTP


$APO.CPTP = 50 ; Tamanho de aproximação em [%] em C_PTP
PTP XP3 C_PTP

 Em movimentos de trajetória LIN, CIRC: C_ORI


O ângulo de orientação dominante deverá ficar abaixo do valor
$APO.CORI
$APO.CORI = 50.0 ; [°] Ângulo
SLIN XP4 C_ORI

 Em movimentos de trajetória LIN, CIRC: C_VEL


A velocidade na fase de frenagem para o ponto de destino deverá ser
inferior a $APO.CVEL
$APO.CVEL = 75.0 ; [%] Porcentagem
LIN XP4 C_VEL

 Controle de orientação: Somente para LIN e CIRC


 Para LIN e CIRC: $ORI_TYPE

$ORI_TYPE = #CONSTANT

Durante o movimento de trajetória a orientação permanece cons-


tante. Para o ponto final, a orientação programada é ignorada

234 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


13 Anexo

Fig. 13-4: Orientação constante

$ORI_TYPE = #VAR

Durante o movimento de trajetória, a orientação é alterada conti-


nuamente até a orientação do ponto de destino.

Fig. 13-5: Padrão ou PTP manual

$ORI_TYPE = #JOINT

Durante o movimento de trajetória, a orientação da ferramenta é


alterada continuamente da posição inicial à posição final. Isso é
realizado através de transferência linear dos ângulos de eixos da
mão. A problemática da singularidade manual pode ser evitada
com esta opção. Ocorre uma rotação em torno da direção de tra-
balho da ferramenta. Não é possível um giro em torno da direção
de trabalho da ferramenta.
 Somente em CIRC: $CIRC_TPYE

A variável $CIRC_TYPE não tem importância , quando houver uma


transferência linear dos ângulos de eixos de mão com $ORI_TYPE =
#JOINT.

$CIRC_TYPE = #PATH

Controle de orientação referente à trajetória durante o movimento


circular

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 235 / 251


Programação do robô 2

Fig. 13-6: Orientação constante, referente ao trajeto

$CIRC_TYPE = #BASE

Controle de orientação referente ao espaço durante o movimento


circular

Fig. 13-7: Orientação constante, referente à base

Procedimento na 1. Abrir o programa como perito.


programação de 2. Verificar os ajustes prévios para a programação de movimentos e aplicar
movimentos com ou inicializar novamente:
KRL  Ferramenta ($TOOL e $LOAD)
 Configuração-base ($BASE)
 Ferramenta conduzida pelo robô ou externa ($IPO_MODE)
 Velocidade
 Aceleração
 Distância de aproximação, caso se aplique
 event. controle de orientação
3. Criar comando de movimento que consiste de:
 Tipo de movimento (PTP, LIN, CIRC)
 Ponto de destino (para CIRC também ponto auxiliar)
 em CIRC event. ângulo inscrito (CA)

236 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


13 Anexo

 Ativar aproximação (C_PTP, C_DIS, C_ORI, C_VEL)


4. No caso de novo movimento, retornar ao ponto 3
5. Fechar editor e salvar

13.2 Variáveis de sistema

13.2.1 $ACC

Descrição Aceleração do TCP no avanço


A variável do tipo de estrutura CP contém a aceleração cartesiana programa-
da para os seguintes componentes:

 CP: Aceleração de trajeto em [m/s2]


 ORI1: Aceleração de oscilação em [°/s2]
 ORI2: Aceleração de rotação em [°/s2]
Valores-limite para a aceleração cartesiana:
 0.0 … $ACC_MA
A aceleração cartesiana máxima $ACC_MA está definida nos dados da
máquina.

Outras informações sobre as variáveis $ACC_MA encontram-se na


documentação relativa aos dados de máquina.

Se $ACC violar os valores-limite, será exibida a mensagem Atribuição de va-


lor não permitida. O processamento do programa é parado ou a respectiva
instrução de movimento não é executada em caso de deslocamento manual.

Exemplo $ACC={CP 5.0,ORI1 500.0,ORI2 500.0}

13.2.2 $ACC_AXIS

Descrição Aceleração dos eixos do robô no avanço


A variável contém a aceleração planejada do eixo em porcentagem. Em caso
de movimentos que são planejados com a ajuda do modelo dinâmico, o valor
percentual se refere aos momentos de eixo disponíveis para a aceleração.
Se não existir nenhum modelo dinâmico, o valor percentual se refere às ace-
lerações máximas dos eixos definidas nos dados da máquina através de
$RAISE_TIME (variável no arquivo …R1\Mada\$machine.dat).

Sintaxe $ACC_AXIS[Número de eixo]=Aceleração

Explicação da
Elemento Descrição
sintaxe
Número de Tipo: INT
eixo
 1 … 6: eixo de robô A1 … A6
Aceleração Tipo: INT; unidade: %
 1 … 100

13.2.3 $ACC_EXTAX

Descrição Aceleração dos eixos adicionais no avanço

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 237 / 251


Programação do robô 2

A variável contém a aceleração planejada do eixo em porcentagem. Em caso


de movimentos que são planejados com a ajuda do modelo dinâmico, o valor
percentual se refere aos momentos de eixo disponíveis para a aceleração.
Se não existir nenhum modelo dinâmico, o valor percentual se refere às ace-
lerações máximas dos eixos definidas nos dados da máquina através de
$RAISE_TIME (variável no arquivo …R1\Mada\$machine.dat).

Sintaxe $ACC_EXTAX[Número de eixo]=Aceleração

Explicação da
Elemento Descrição
sintaxe
Número de Tipo: INT
eixo
 1 … 6: eixo adicional E1 … E6
Aceleração Tipo: INT; unidade: %
 1 … 100

13.2.4 $APO

Descrição Parâmetro de aproximação no avanço


Com as variáveis, o trecho de aproximação é definido.

Sintaxe $APO={CVEL Velocidade, CPTP DisPTP, CDIS DisCP, CORI Orientação}

Explicação da
Elemento Descrição
sintaxe
CVEL Tipo: INT; unidade: %
Parâmetros de velocidade
 1 … 100
O parâmetro de aproximação indica a percentagem da
velocidade programada a partir da qual é possível iniciar a
aproximação na fase de frenagem ao ponto de destino.
CPTP Tipo: INT; unidade: %
Distância de aproximação para movimentos PTP e spline
PTP (= Distância antes do ponto de destino, a partir da
qual é possível iniciar a aproximação)
 1 … 100
Explicação do parâmetro de aproximação: (>>> "CPTP"
Página 239)
Nota: Movimentos spline PTP (SPTP) são programáveis a
partir do KUKA System Software 8.3.
CDIS Tipo: REAL; unidade: mm
Parâmetro de distância
O momento mais cedo para iniciar a aproximação é
quando a distância ao ponto de destino está abaixo do
valor especificado aqui.
CORI Tipo: REAL; unidade: °
Parâmetro de orientação
O momento mais cedo para iniciar a aproximação é
quando o ângulo de orientação dominante (rotação ou
oscilação do eixo longitudinal da ferramenta) fica abaixo
da distância angular ao ponto de destino especificada
aqui.

238 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


13 Anexo

CPTP O parâmetro de aproximação CPTP atua de forma diferente, dependendo se


está programado um movimento PTP ou spline PTP (SPTP).
 Em um movimento PTP, o valor percentual indicado com CPTP se refere
a um ângulo de eixo definido com $APO_DIS_PTP nos dados de máqui-
na. Assim que todos os eixos ficarem abaixo de sua distância definida de
aproximação, será aproximado.
Porém, mais cedo começa a aproximação quando 50% do comprimento
de passo tiver sido atingido. Ou seja, mais cedo será aproximado quando
tiver sido realizada a metade do percurso entre o ponto de partida e o pon-
to de destino, relativamente ao contorno do movimento PTP sem aproxi-
mação.
 Esta limitação em 50% vale também em caso de aproximação entre 2 mo-
vimentos individuais SPTP. Na aproximação entre splines PTP, que são
programados como um dos vários segmentos nos Spline Blocks, não está
definido quando é possível começar com a aproximação. Ou seja, é co-
meçada com a aproximação como definido com CPTP.
 Na aproximação entre splines PTP, o valor percentual indicado com
CPTP se refere ao percurso do último segmento do spline no primeiro
Spline Block e ao percurso do primeiro segmento do spline no Spline Blo-
ck subsequente, a colocar de volta no espaço de eixo todos os eixos do
robô e, com isso, eixos adicionais acoplados matematicamente.

13.2.5 $BASE

Descrição Sistema de coordenadas BASE no avanço


A variável do tipo de estrutura FRAME descreve a posição nominal da peça
referente ao sistema de coordenadas WORLD.
 X, Y, Z: Deslocamento da origem ao longo dos eixos em [mm]
 A, B, C: Rotação do ângulo de eixo em [°]

13.2.6 $CIRC_TYPE

Descrição Controle de orientação de CIRC no avanço


A variável contém o controle programado de orientação de um movimento cir-
cular. Esta é referente à base ou referente ao trajeto.

Sintaxe $CIRC_TYPE=Tipo

Explicação da
Elemento Descrição
sintaxe
Tipo Tipo: ENUM
 #BASE: Controle de orientação referente à base
 #PATH: Controle de orientação referente ao trajeto

13.2.7 Modo de economia de energia ($ECO_LEVEL)

Descrição Através da variável de sistema $ECO_LEVEL, o usuário pode deslocar o robô


com economia de energia. O grau da economia pode ser ajustado em "baixo",
"médio" ou "alto". O modo de economia de energia ocasiona deslocamento
mais lento dos eixos do robô e dos eixos adicionais. Quanto maior a econo-
mia, menor é a velocidade. Quanta energia é economizada, em comparação
à potência plena, depende principalmente das posições de eixos e não é pre-
visível.
$ECO_LEVEL não tem efeito sobre todos os movimentos. A tabela a seguir
indica sobre quais movimentos ele tem efeito e sobre quais não:

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 239 / 251


Programação do robô 2

Movimento Efeito?
PTP Sim
LIN Não
CIRC Não
Movimentos Spline CP (Block e passo indivi- Sim
dual)
Com perfil de deslocamento mais elevado
Movimentos Spline CP (Block e passo indivi- Não
dual)
Sem perfil de deslocamento mais elevado
Movimentos Spline PTP (Block e passo indivi- Sim
dual)

Se um programa é redefinido ou cancelado, o modo de economia de energia


é automaticamente desligado.
Nos seguintes casos, o modo de economia de energia está inativo, mesmo se
ele estiver ligado:
 Em caso de um deslocamento SAK
 Em uma região de deslocamento constante no spline
 Em um bloco de tempo no spline
Se para velocidade e aceleração já estiverem programados valores baixos, o
$ECO_LEVEL não tem efeito ou praticamente não tem efeito.
Dependendo do tipo de robô, pode ser que em determinadas combinações a
economia em "média" e "alta seja igual ou praticamente igual. (Por exemplo,
em caso de capacidade de carga abaixo de 30% da capacidade de carga pa-
drão.)

Pré-requisito  $ADAP_ACC <> #NONE


 $OPT_MOVE <> #NONE
Em ambas as variáveis de sistema, <> #NONE já é o ajuste padrão.

Sintaxe $ECO_LEVEL=Nível

Explicação da
Elemento Descrição
sintaxe
Nível Tipo: ENUM
 #OFF: O modo de economia de energia está desligado.
 #LOW: Baixa economia
 #MIDDLE: Economia média
 #HIGH: Alta economia

13.2.8 $GEAR_JERK

Descrição Solavanco de redutor dos eixos no avanço


Com as variáveis, é determinado o solavanco de redutor de um eixo. O sola-
vanco de redutor se refere percentualmente aos respectivos dados da máqui-
na a partir do modelo dinâmico $DYN_DAT[].
Se no início de um movimento do spline $GEAR_JERK não é inicializado, p.
ex., porque a linha INI não foi executada, a mensagem de confirmação Sola-
vanco de redutor não programado {Número de eixo} é exibida e o processa-
mento do programa é parado.

240 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


13 Anexo

Sintaxe $GEAR_JERK[Número do eixo]=Solavanco de redutor

Explicação da
Elemento Descrição
sintaxe
Número de Tipo: INT
eixo
 1 … 6: eixo de robô A1 … A6
 7 … 12: eixo adicional E1 … E6
Solavanco de Tipo: INT; unidade: %
redutor
 1 … 100

13.2.9 $IPO_MODE

Descrição Modo de interpolação programado no avanço

Sintaxe $IPO_MODE=Modo

Explicação da
Elemento Descrição
sintaxe
Modo Tipo: ENUM
 #TCP: a ferramenta é uma ferramenta fixa.
 #BASE: a ferramenta está montada no flange de mon-
tagem.
Padrão: #BASE

13.2.10 $JERK

Descrição Limitação cartesiana de solavancos para SPLINE no avanço


A variável do tipo de estrutura JERK_STRUC limita a alteração temporal da
aceleração em movimentos spline CP (SLIN, SCIRC).

A variável é relevante apenas em movimentos spline CP, que são


planejados sem modelo dinâmico. (Somente KUKA System Software
8.1. A partir de KUKA System Software 8.2, a variável não é mais re-
levante.)

O agregado consiste nos seguintes componentes:

 CP: Alteração da aceleração de trajeto em [m/s3]


 ORI: Alteração da aceleração de orientação em [°/s3]
 AX: Alteração da aceleração do eixo em [°/s3] em eixos rotatórios ou em
[m/s3] em eixos lineares
O solavanco máximo permitido para movimentos SPLINE está definido nos
dados da máquina (variável $JERK_MA no arquivo …R1\Mada\$machi-
ne.dat).

Exemplo $JERK={CP 50.0,ORI 50000.0,AX {A1 1000.0,A2 1000.0,A3 1000.0,A4


1000.0,A5 1000.0,A6 1000.0,E1 1000.0,E2 1000.0,E3 1000.0,E4 1000.0,E5
1000.0,E6 1000.0}}

13.2.11 $LOAD

Descrição Dados de carga atuais válidos no avanço

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 241 / 251


Programação do robô 2

A estrutura contém os dados de capacidade de carga, os quais são introduzi-


dos na unidade de comando do robô e atribuídos à ferramenta atual. O siste-
ma de coordenadas de referência é o sistema de coordenadas FLANGE.
(>>> "Cargas no robô" Página 242)

Sintaxe $LOAD={M Massa, CM Centro de gravidade, J Inércia}

Explicação da
Elemento Descrição
sintaxe
Massa Tipo: REAL; unidade: kg
Centro de Tipo: FRAME
gravidade
 X, Y, Z: Posição do centro de gravidade em relação ao
flange
 A, B, C: Orientação dos eixos principais de inércia em
relação ao flange
Inércia Tipo: INERTIA
 X, Y, Z: Momentos de inércia de massa em torno dos ei-
xos do sistema de coordenadas, que está girado atra-
vés de A, B, C relativamente ao flange

Cargas no robô No robô podem ser montadas diferentes cargas:


 Carga no flange
 Carga adicional no eixo 3
 Carga adicional no eixo 2
 Carga adicional no eixo 1

Fig. 13-8: Cargas no robô

1 Capacidade de carga 3 Carga adicional do eixo 2


2 Carga adicional do eixo 3 4 Carga adicional do eixo 1

Parâmetro Os dados de carga são definidos através dos seguintes parâmetros:

242 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


13 Anexo

Parâmetro Unidade
Massa m kg
Distância até o Lx, Ly, Lz mm
Inércia de massa no Ix, Iy, Iz kg m2
centro de gravidade

Sistemas de referência dos valores X, Y, Z para cada carga:

Carga Sistema de referência


Capacidade de carga Sistema de coordenadas FLANGE
Carga adicional A3 Sistema de coordenadas FLANGE
A4 = 0°, A5 = 0°, A6 = 0°
Carga adicional A2 Sistema de coordenadas ROBROOT
A2 = -90°
Carga adicional A1 Sistema de coordenadas ROBROOT
A1 = 0°

13.2.12 $ORI_TYPE

Descrição Controle de orientação de um movimento CP no avanço

Sintaxe $ORI_TYPE=tipo

Explicação da
Elemento Descrição
sintaxe
Tipo Tipo: ENUM
 #CONSTANT: A orientação do TCP permanece cons-
tante durante o movimento.
 #VAR: A orientação do TCP muda continuamente du-
rante o movimento.
 #JOINT: A orientação do TCP muda continuamente du-
rante o movimento. Isto ocorre através do transporte li-
near (deslocamento específico de eixo) nos ângulos de
eixo de mão.
Nota: Se $ORI_TYPE = #JOINT, a variável $CIRC_TYPE
é ignorada.

13.2.13 $ROTSYS

Descrição Sistema de coordenadas de referência para a rotação no avanço


Com as variáveis, o sistema de coordenadas pode ser definido, em que a ro-
tação (A, B, C) é executada em caso de movimentos relativos e de desloca-
mento manual.

Sintaxe $ROTSYS=Sistema de referência

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 243 / 251


Programação do robô 2

Explicação da
Elemento Descrição
sintaxe
Sistema de Tipo: ENUM
referência
 #AS_TRA: Rotação no sistema de coordenadas
$TRANSSYS
 #BASE: Rotação no sistema de coordenadas BASE
 #TCP: Rotação no sistema de coordenadas TOOL
Padrão: #AS_TRA

13.2.14 $SPL_ORI_JOINT_AUTO

Descrição $SPL_ORI_JOINT_AUTO serve para a otimização do comportamento de


deslocamento nas proximidades de singularidades de eixos de mão.
Modo de atuação de $SPL_ORI_JOINT_AUTO = #ON:
 Para movimentos spline CP, para os quais $ORI_TYPE = #VAR é válido,
a unidade de comando do robô decide automaticamente por movimento
(ou seja, também por segmento), se eles serão realizados como #VAR ou
como #JOINT.

Sintaxe $SPL_ORI_JOINT_AUTO =Tipo

Explicação da
Elemento Descrição
sintaxe
Tipo Tipo: ENUM
 #OFF nenhuma otimização nas proximidades da singu-
laridade de eixos de mão
 #ON é uma alternativa para a utilização de $ORI_TYPE
= #JOINT. Enquanto $ORI_TYPE = #JOINT pode ser
utilizado especificamente para movimentos individuais,
$SPL_ORI_JOINT_AUTO = #ON possibilita uma otimi-
zação automática sobre quaisquer sequências de pro-
gramas grandes com pequeno número de alterações.
 $SPL_ORI_JOINT_AUTO pode ser alterado somente
através de um programa de robô.
$SPL_ORI_JOINT_AUTO não pode ser definido em
segmentos spline.
Padrão: $SPL_ORI_JOINT_AUTO = #OFF

13.2.15 $TOOL

Descrição Sistema de coordenadas TOOL no avanço


A variável do tipo de estrutura FRAME descreve a posição nominal do sistema
de coordenadas TOOL referente ao sistema de coordenadas FLANGE.
 X, Y, Z: Deslocamento da origem ao longo dos eixos em [mm]
 A, B, C: Rotação do ângulo de eixo em [°]

13.2.16 $VEL

Descrição Velocidade do TCP no avanço


A variável do tipo de estrutura CP contém a velocidade cartesiana programa-
da para os seguintes componentes:
 CP: Velocidade de trajeto em [m/s]

244 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


13 Anexo

 ORI1: Velocidade de oscilação em [°/s]


 ORI2: Velocidade de rotação em [°/s]
Valores-limite para a velocidade cartesiana:
 0.0 … $VEL_MA
A velocidade cartesiana máxima $VEL_MA está definida nos dados da
máquina.

Outras informações sobre as variáveis $VEL_MA encontram-se na


documentação relativa aos dados de máquina.

Se $VEL violar os valores-limite, será exibida a mensagem Atribuição de valor


não permitida. O processamento do programa é parado ou a respectiva ins-
trução de movimento não é executada em caso de deslocamento manual.

Exemplo $VEL={CP 2.0,ORI1 300.0,ORI2 300.0}

13.2.17 $VEL_AXIS

Descrição Velocidade dos eixos do robô no avanço


A variável contém a velocidade de eixo programada em porcentagem, refe-
rente à velocidade de eixo máxima definida nos dados de máquina
$VEL_AXIS_MA (variável no arquivo …R1\Mada\$machine.dat).

Sintaxe $VEL_AXIS[Número de eixo]=Velocidade

Explicação da
Elemento Descrição
sintaxe
Número de Tipo: INT
eixo
 1 … 6: eixo de robô A1 … A6
Velocidade Tipo: INT; unidade: %
 1 … 100

13.2.18 $VEL_EXTAX

Descrição Velocidade dos eixos adicionais no avanço


A variável contém a velocidade de eixo programada em porcentagem, refe-
rente à velocidade de eixo máxima definida nos dados de máquina
$VEL_AXIS_MA (variável no arquivo …R1\Mada\$machine.dat).

Sintaxe $VEL_EXTAX[Número do eixo]=Velocidade

Explicação da
Elemento Descrição
sintaxe
Número de Tipo: INT
eixo
 1 … 6: eixo adicional E1 … E6
Velocidade Tipo: INT; unidade: %
 1 … 100

13.2.19 $CIRC_MODE

Descrição Comportamento do controle de orientação e dos eixos adicionais no ponto au-


xiliar e de destino de um circuito SCIRC

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 245 / 251


Programação do robô 2

Em movimentos SCIRC, a unidade de comando do robô pode levar em con-


sideração a orientação programada do ponto auxiliar. Com $CIRC_MODE é
possível determinar se e até que ponto ela é levada em consideração.
Além disso, com $CIRC_MODE é possível determinar se, em caso de instru-
ções SCIRC com ângulo circular, o ponto de destino deve ter a orientação
programada ou se a orientação deve ser correspondentemente escalada ao
ângulo circular.
$CIRC_MODE é gravável apenas através de uma instrução SCIRC.
$CIRC_MODE não pode ser lido.

Sintaxe Para pontos auxiliares:


$CIRC_MODE.AUX_PT.ORI=Comportamento PA
Para pontos de destino:
$CIRC_MODE.TARGET_PT.ORI=Comportamento PD

Explicação da Elemento Descrição


sintaxe
Compor- Tipo: ENUM
tamento PA
 #INTERPOLATE: No ponto auxiliar, a orientação pro-
gramada é assumida.
 #IGNORE: A orientação de início é transferida no traje-
to mais curto para a orientação de destino. A orientação
programada do ponto de ajuda é ignorada.
 #CONSIDER: A orientação de partida é transferida no
trajeto para a orientação de destino, o qual inclui a
orientação programada do ponto auxiliar. Ou seja, a
orientação do ponto auxiliar é assumida durante o tra-
jeto, mas não necessariamente no ponto auxiliar.
Padrão: #CONSIDER
Compor- Tipo: ENUM
tamento PD
 #INTERPOLATE: No ponto de destino real, é assumida
a orientação programada do ponto de destino.
(Única possibilidade para SCIRC sem indicação de ân-
gulo circular. Se #EXTRAPOLATE for ativado, apesar
disso #INTERPOLATE é executado.)
 #EXTRAPOLATE: No ponto de destino programado, é
assumida a orientação programada. No ponto de desti-
no real, a orientação é escalada correspondentemente
ao ângulo circular.
Padrão para SCIRC com indicação de ângulo circular:
#EXTRAPOLATE

Restrições  Se $ORI_TYPE = #IGNORE vale para um segmento SCIRC, então


$CIRC_MODE não é avaliado.
 Se um segmento SCIRC ou SLIN preceder um segmento SCIRC, vale
para o $ORI_TYPE = #IGNORE, então #CONSIDER não pode ser utiliza-
do neste segmento SCIRC.
Para SCIRC com ângulo circular:
 Para o ponto auxiliar, #INTERPOLATE não pode ser definido.
 Se $ORI_TYPE = #IGNORE for válido, então #EXTRAPOLATE não pode
ser definido para o ponto de destino.

246 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


13 Anexo

 Se precedido por um segmento spline, para o qual vale $ORI_TYPE =


#IGNORE, então #EXTRAPOLATE não pode ser definido para o ponto de
destino.

Exemplo: O TCP se move 192° em arco com modo cartesiano.


Ponto auxiliar  A orientação no ponto de partida é 0°.
 A orientação no ponto auxiliar é 98°.
 A orientação no ponto de destino é 197°.
Portanto, a reorientação é de 197°, se o ponto auxiliar for considerado.
Se a orientação no ponto auxiliar for ignorada, a orientação de destino tam-
bém pode ser atingida através de uma reorientação de 360° - 197° = 163°.
 #INTERPOLATE:
No ponto auxiliar, a orientação programada de 98° é assumida. Portanto,
a reorientação é de 197°.
 #IGNORE:
A orientação programada do ponto de ajuda é ignorada. A reorientação
mais curta com 163° é executada.
 #CONSIDER:
O trajeto é realizado, o qual inclui a orientação do ponto auxiliar; neste ca-
so, reorientação com 197°. Ou seja, durante o trajeto são assumidos 98°,
mas não necessariamente no ponto auxiliar.

Exemplo: O exemplo mostra esquematicamente o comportamento de #INTERPOLATE


Ponto de destino e #EXTRAPOLATE.
 As setas claras tracejadas indicam a orientação programada.
 As setas escuras indicam a orientação real se ela for diferente da orienta-
ção programada.
#INTERPOLATE:
Em TP, que se encontra antes de TP_CA, a orientação programada ainda não
está atingida. Em TP_CA a orientação programada é assumida.

Fig. 13-9: #INTERPOLATE

SP Ponto de partida
AuxP Ponto auxiliar
TP Ponto de destino programado
TP_CA Ponto de destino real. Resulta do ângulo circular.

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 247 / 251


Programação do robô 2

#EXTRAPOLATE:
Em TP a orientação programada é assumida. Para TP_CA esta orientação é
escalada de acordo com o ângulo circular.

Fig. 13-10: #EXTRAPOLATE

248 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


Index

Index
Símbolos E
, projeto WorkVisual 35 E/Ss analógicas, exercício 227
$ACC 237 Editor KRL 41
$ACC_AXIS 237 EKrlMsgType 117
$ACC_EXTAX 237 Emitente 116
$ACC_MA 237 Entradas analógicas 221
$APO 238 ENUM 98
$BASE 239 Estrutura 93
$CIRC_MODE 149, 245 Estrutura de projeto (janela) 9
$CIRC_TYPE 239 Estrutura de projeto WorkVisual (guia Arquivos)
$ECO_LEVEL 239 13
$GEAR_JERK 240 Exemplo PAP 64
$IPO_MODE 241
$JERK 241 F
$JERK_MA 241 Fluxograma do programa, PAP 62
$LOAD 241 Funções 101, 111, 113
$ORI_TYPE 243 Funções de comutação 201
$RAISE_TIME 237, 238 Funções padrão 82, 113
$ROTSYS 243 Funções para a emissão de mensagens 113
$SPL_ORI_JOINT_AUTO 244 Funções para variável string 113
$TIMER r 183 Funções, matemáticas 113
$TOOL 244
$VEL 244 G
$VEL_AXIS 245 Global 187
$VEL_AXIS_MA 245 global 77
$VEL_EXTAX 245 Grupo de usuários, padrão 65
$VEL_MA 245
I
A Individual (item de menu) 85
Acordos 75 Inicialização 80
Administrador 65 Interpretador Submit 217
Ajuda 9 Interrupt 187
Anexo 229 Interrupt Cancelar movimentos de deslocamen-
Array 87 to, exercício 199
Ativar o projeto na unidade de comando do robô Inércia de massa 243
32
Avanço 77 K
KrlMsg_T 116
B KrlMsgDlgSK_T 133
Barra de menu 9 KrlMsgOpt_T 118
Barras de botões 9
Bloco de tempo 213 L
local 77
C
Campos 87 M
Cargas 242 Manipulação 82, 83
Cargas no robô 242 Massa 243
Catálogos (janela) 9 Mensagem de confirmação 115, 127
centro de gravidade 243 Mensagem de diálogo 115
Comentário 57 Mensagem de espera 115, 130
Comparar projetos 14 Mensagem de estado 115, 124
Mensagem de informação 115, 121
D Mensagens 115
DECL 76, 78 Mensagens (janela) 9
Declarar Interrupt, exercício 193 Mensagens de usuário 115
Declaração 76, 79 Modo de interpolação 241
DEFFCT 111 Modos WorkVisual 12
Diálogo 135 Método de programação, exemplo PAP 64

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 249 / 251


Programação do robô 2

N Transmitir o projeto à unidade de comando do


Nomes de dados 62 robô (instalar) 18
Nível de perito 65
Número da mensagem 116 V
Variáveis 75, 78
O Variáveis de sistema 183
Operador 65 Variável, alterar 85
Operações Bit 82 Variável, exibir individualmente 85
Operações comparativas 82 Vida útil 77
Operações lógicas 82 Visão geral da interface de operação WorkVisual
8
P
Palavra chave 77 W
PAP 62 WITH (variáveis permitidas de sistema) 153, 181
Pasta 59
Pinar 34 Z
Prioridade 84, 188, 206 Ângulo inscrito 231
Programador 65 Áreas de trabalho (janela) 9
Programar diálogo, exercício 139 Ícones PAP 62
Programar mensagem de estado, exercício 126
Programar mensagem de informação, exercício
123
Programar mensagens de confirmação,
exercício 129
Programar mensagens de espera, exercício 132
Programação de movimento com KRL 141
Programação estruturada 57
Project Explorer 10
Propriedades (janela) 10
Pulso 204

R
Região de deslocamento constante 211, 212
Return 102, 111

S
Saídas analógicas 223
Selecionar o tipo de mensagem 117
Seleção de passo 171
Sinais analógicos 221
Singularidade, spline CP 244
Snippets – Introdução rápida para instruções
KRL 48
Spline Block CP 178
Spline Block PTP 179
Stop condicionado 208
Submit 217
Subprograma 101
Subprograma global 103
Subprograma local 101
Subprogramas 60

T
Template 35
Tempo de ciclo 183
Temporizador 183
Tensão 224
Texto de mensagem 116
tipo de dados de enumeração 98
Tipos de cálculo básico 82
Transmissão de parâmetros 105

250 / 251 Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4


Programação do robô 2

Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 251 / 251