Apostila Treinamento Robo Kuka 2 de 3

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
© 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

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

Í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

13.2.19 $CIRC_MODE ...................................................................................................... 245
Index ............................................................................................................. 249

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.

 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.

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

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

 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).

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

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).

 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.

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.

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.
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.

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.

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.

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

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.
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.

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.

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)

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.

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.

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".

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".

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".

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.
2. Através do botão Alterar na linha Célula é aberta a visão geral da célula.

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.

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

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 ….)
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.

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

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.

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

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.
5 O projeto ativo é exibido.
6 Salva o projeto ativo como projeto base. O projeto ativo permane-
ce ativo.
7 Cria uma cópia pinada do projeto ativo.
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:

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.
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.
jeto pinado. Está disponível a partir do grupo de usuá-
rios Peritos.
Copiar Copia o projeto marcado.
Excluir Exclui o projeto marcado.
jeto não-pinado não ativo. Está disponível a partir do
grupo de usuários Peritos.

Botão Descrição
Editar Abre uma janela, na qual podem ser alterados o nome
e/ou a descrição do projeto marcado.
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

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

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

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

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.

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.

 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

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.

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)

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).

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

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.

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.

 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.

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.

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.

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.

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.

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

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?
.............................................................
.............................................................

6. Para o que são usados Snippets?

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


2 Programação estruturada
2
2.1 Visão geral

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

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

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 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

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()
...
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

...
END
DEF Main()
...
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)
...
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?

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
LOOP
FOR COUNTER = 1 TO 20
PART = PART+1
;não é possível recuar formulários Inline!!!
PTP XP5 ; Movimento com KRL
ENDFOR
...

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

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

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

3 Introdução no nível de perito

t
3.1 Visão geral

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.

 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.

 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

3.3 Exercício: Medição de ferramentas e base
 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
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

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
X = 7 mm Y = -24 mm Z = 80 mm
Orientação:
A = 0° B = 0° C = 0°

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

Fig. 3-6: Garra de treinamento Célula móvel
Massa:
M = 2 kg
X = 23 mm Y = 0 mm Z = 61 mm
Orientação:
A = 0° B = 0° C = 0°

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

Fig. 3-7: Garra de treinamento KR 16
Massa:
M = 4,9 kg
X = 53 mm Y = 49 mm Z = 65 mm
Orientação:
A = 0° B = 0° C = 0°
 Garra de treinamento Célula modular
Fig. 3-8: Garra de treinamento Célula modular
Massa:
M = 5 kg
X = 23 mm Y = -38 mm Z = 84 mm
Orientação:
A = 0° B = 0° C = 0°

 Garra de treinamento Célula móvel
Fig. 3-9: Garra de treinamento Célula móvel
Massa:
M = 2,14 kg
X = 30 mm Y = 0 mm Z = 64 mm
Orientação:
A = 0° B = 0° C = 0°

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)?
.............................................................
.............................................................

3.4 Exercício: Navigator perito loop sem fim
 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
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.
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?
............................................................
............................................................


4 Variáveis e acordos
4
4.1 Visão geral

v

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.

 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.

 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

 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

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
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
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"
DEFDAT $CONFIG
...
;==================================
; Userdefined Types
;==================================
;==================================
; Userdefined Externals
;==================================
;==================================
; Userdefined Variables
;==================================
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol

...
ENDDAT

Criar variável global no DAT-File
3. Ampliar a lista de dados no cabeçalho do programa com a palavra-chave
PUBLIC
DEFDAT MY_PROG PUBLIC

DEFDAT MY_PROG PUBLIC
DECL GLOBAL INT counter
DECL GLOBAL REAL price
DECL GLOBAL BOOL error
DECL GLOBAL CHAR symbol
...
ENDDAT
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

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

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

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

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

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
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

 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

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
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)

Prioridade Operador
6 OR (B_OR)
7 qualquer comparação (==; <>; ...)
; Declaração
DECL BOOL X, Y
DECL INT Z
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.

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.

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
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

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
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
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[])

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
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

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
...

4.6 Exercício: Campos com tipos de dados simples e loop de contagem
 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)
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
1. Onde o tamanho de um campo é dimensionado?
............................................................

.............................................................
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?
.............................................................
.............................................................

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.
 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
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}

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 = 12000.0 ; Os valores para motor e ar condicionado são
mantidos
Porém:
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
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.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

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

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 = value_car
IF my_car.price >= 20000.0 THEN

...
ENDIF

4.8 Exercício: Criar estruturas com KRL
 Geração de estruturas próprias (declaração, inicialização)
 Trabalhar com o separador de pontos
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
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.
.............................................................

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

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
 Um tipo de enumeração pode ser incluído em uma estrutura

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

4.10 Exercício: Criar tipo de enumeração com KRL
 Gerar variáveis ENUM próprias (declaração)
 Trabalhar com variáveis ENUM
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.
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
............................................................
............................................................


5 Subprogramas e funções
5.1 Visão geral
s
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( )
...
END
_______________________________________
DEF LOCAL_PROG3( )
...
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

 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( )
...
SPTP P1 Vel=100% PDAT1
...
END
_______________________________________
DEF LOCAL_PROG1( )
...
; esta é a mesma posição que no programa principal
...
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( )
...
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

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

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

DEF GLOBAL1( )
...
END
DEFDAT GLOBAL1( )
DECL E6POS XP1={X 100, Z 200, Z 300 ... E6 0.0}
ENDDAT
Diferentes coordenadas para P1 no Global2 ( )

DEF GLOBAL2( )
...
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( )
...
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( )

...
END
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)

...
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

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.

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

5.5 Exercício: Subprogramas com transferência de parâmetros
 Técnica de subprogramas com transferência de parâmetros
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

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?
............................................................
............................................................

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

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

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
...
ENDFCT
A instrução RETURN(return_value) deve ocorrer antes da instru-

ção ENDFCT.
 Acesso a uma função local

DEF MY_PROG( )
INI
...
...
END
_______________________________________
...
ENDFCT
 Uso de parâmetros IN/OUT na transferência de valores

 Transferência de valores como parâmetros IN
DEF MY_PROG( )
INI

value = 2.0
; value = 2.0
; result = 1000.0
END

num = num + 8.0
return_value = num * 100.0
ENDFCT
O valor de transferência value não é alterado.
 Transferência de valores como parâmetro OUT

DEF MY_PROG( )
INI
value = 2.0
; value = 10.0
; result = 1000.0
END
DEFFCT REAL CALC(num:OUT)

num = num + 8.0
return_value = num * 100.0
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
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)

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:

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:

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)

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)

6 Programação de mensagens com KRL
6.1 Visão geral

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)

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
...

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"}

Parameter[2] = {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
...
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

 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

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
...
...
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.
DEFFCT BOOL Clear_KrlMsg(nHandle:IN)
DECL INT nHandle
 nHandle: O handle disponibilizado pela função "Set_KrlMsg(…)" para

a mensagem
DEF MyProg( )
DECL INT handle
DECL BOOL erase
...
...
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.

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
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
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

handle = Set_KrlMsg(#NOTIFY, mymessage, Parameter[ ], Option)

...

6.6 Exercício: Programar mensagem de informação
 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.
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?
............................................................
............................................................

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

 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

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)
 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(
)
Fig. 6-4: Mensagem de estado

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 INT handle
DECL BOOL present, eraser
...
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}
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

6.8 Exercício: Programar mensagem de estado
 Programar mensagens de estado próprias
te exercício:
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.
1. O que significa %2 no texto de mensagem?
.............................................................
.............................................................

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
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

 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.

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)
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.

Fig. 6-6: Mensagem de confirmação

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.
Clear_P_Reset TRUE.
DECL INT handle
DECL BOOL present
...
Log_to_DB TRUE}
handle = Set_KrlMsg(#QUIT, mymessage, Parameter[ ], Option)
REPEAT
present=Exists_KrlMsg(handle)
UNTIL NOT(present)

6.10 Exercício: Programar mensagens de confirmação
 Programar mensagens de confirmação próprias
te exercício:
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.
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.
1. Qual é o número máximo de mensagens de confirmação administradas no
buffer de mensagens?
............................................................
............................................................

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.
 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.

espera definidas  remetente, número da mensagem, texto de mensagem (de
pelo usuário KrlMsg_T)
 variável para o resultado da exclusão (como BOOL)
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(
).
Fig. 6-8: Mensagem de espera

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.
Clear_P_Reset TRUE.
DECL INT handle
DECL BOOL present, eraser
...
Log_to_DB TRUE}
handle = Set_KrlMsg(#WAITING, mymessage, Parameter[ ], Option)
ENDIF
eraser=FALSE
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

6.12 Exercício: Programar mensagens de espera
 Programar mensagens de espera próprias
te exercício:
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.
1. Qual é a diferença entre uma mensagem "STATE" e uma mensagem "WAI-
TING"?
.............................................................
.............................................................

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"}
...
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.

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.

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.
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.

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

 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
 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
present = exists_KrlDlg(handle ,ANSWER) ; ANSWER é descrita pelo
sistema

diálogos 2. Declarar variáveis de trabalho para:
definidos pelo  remetente, número da mensagem, texto de mensagem (de
usuário KrlMsg_T)

 7 possíveis botões (de KrlMsgDlgSK_T)

 variável para o resultado da resposta de qual botão foi pressionado
(como INT)
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.
Fig. 6-12: Diálogo com 3 botões

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.
Clear_P_Reset TRUE.
DECL KRLMSG_T myQuestion
DECL KRLMSGDLGSK_T Softkey[7] ;Preparar 7 possíveis softkeys
DECL INT handle, answer
DECL BOOL present
...
myQuestion={modul[] "College", Nr 1907, msg_txt[] "My Question?"}

Log_to_DB TRUE}
softkey[1]={sk_type #value, sk_txt[] "key1"} ; Botão 1
softkey[2]={sk_type #EMPTY, sk_txt[] "key2"} ; Botão 2


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
...
CASE 6 ; Botão 6
...
ENDSWITCH
...

6.16 Exercício: Programar diálogo
 Programar consultas próprias de diálogo
te exercício:
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".
1. Como são inscritas as teclas das softkeys no diálogo?
............................................................
............................................................


7 Programação de movimento com KRL
7.1 Visão geral

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>

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

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>

sintaxe Ponto auxi- Tipo: POS, E6POS, FRAME
liar
As coordenadas referem-se ao sistema de coordenadas
Ponto de BASE.
destino
â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.
Ângulo cir- Unidade: grau; sem limitação
cular
SysVar
Em segmentos: A atribuição vale apenas para esse seg-
mento.

para segmentos.
tidão.


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

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

$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
$ACC_AXIS[x] ; x=1...8 para cada eixo

$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

 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-

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:

 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°

 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.

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.

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.

 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

$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°.

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>

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.
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!)
Em segmentos SPTP: A atribuição vale apenas para esse
segmento.
para segmentos.
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>

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
mento.
para segmentos.
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.

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)

 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

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

é 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:

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 °

 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)
 Velocidade
 Aceleração
 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)

7.10 Exercício: Paletizar e despaletizar
 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
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.

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

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.
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?
.............................................................
.............................................................

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:

 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.

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
trajeto cartesiano
ENDSPLINE

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
trajeto cartesiano
trajeto cartesiano
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

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

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.

 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.

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

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

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}

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.

 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>
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.
tidão.

como está.
SPLINE
SPL P1
TRIGGER WHEN PATH=GET_PATH() ONSTART DELAY=0 DO SUBPROG() PRIO=-1
SPL P2
SLIN P3

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
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>
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.
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.

 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>
Ponto auxi- Tipo: POS, E6POS, FRAME
liar
Ponto de BASE.
destino
â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.
Ângulo cir- Unidade: grau; sem limitação
cular
SysVar

mento.

para segmentos.
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.


8 Trabalho com variáveis de sistema
8
T
Trabalho com variáveis de sistema
8.1 Visão geral

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

$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

8 Trabalho com variáveis de sistema
8.3 Exercício: Medição de ciclo e otimização
 Trabalhar com um temporizador (inicializar, iniciar, parar).
 Realizar a otimização do ciclo.
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
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?
............................................................
............................................................


9 Programação de Interrupt
9.1 Visão geral

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.

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

 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)

...
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()

END
2. Ativar e desativar Interrupt

DEF MY_PROG( )
INI
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 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

Variáveis de
sistema úteis em
uma aproximação
Fig. 9-5: Variáveis de sistema na aproximação

9.3 Exercício: Trabalhar com Interrupts
 Declaração de um Interrupt
 Criação de um subprograma Interrupt
 Avaliação e edição de Interrupts na execução do programa
te exercício:
 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.
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?
............................................................

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

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.

 Ativar e desativar Interrupt
DEF MY_PROG( )
INI
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 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.

DEF MY_PROG( )
INI
...
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
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
SEARCH()
END
_________________________________________________
DEF SEARCH()
INTERRUPT ON 25
SPTP HOME
SPTP XP1
SPTP XP2

SPTP XHOME
WAIT SEC 0 ; Parar o ponteiro de avanço
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR()
BRAKE
SPTP $POS_INT
RESUME
END

9.5 Exercício: Cancelar movimentos de deslocamento com Interrupts
 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
te exercício:
 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
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( )

INTERRUPT OFF 21
BRAKE
;pick_part
RESUME
END
3. Quando é acionado um Interrupt?
.............................................................
.............................................................

10 Funções de comutação KRL
10.1
s
Visão geral

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

 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

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)

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

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>

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.

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.

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.

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
 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.

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}).
 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

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
ONSTART Ponto de referência da instrução
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.
vimento
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

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.
 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

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>
ONSTART Ponto de referência da instrução
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.
vimento
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.

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

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

SPLINE
SLIN P1
SPL P2
TIME_BLOCK START
SLIN P3
TIME_BLOCK PART = 12.7
SPL P4
SPL P5
SPL P6
SCIRC P7, P8
SPL P9
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.


11 Interpretador Submit
t
11.1 Visão geral

t

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

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.

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


12 Trabalhar com sinais analógicos
12
2
Trabalhar com sinais analógicos
T
12.1 Visão geral

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).

 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>
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( )
...
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( )
...
ANIN ON value = corr*sensor-offset
...
ANIN OFF sensor

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

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>
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
sinal.
Offset Tipo: REAL
sinal.

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( )
...
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:

Fig. 12-4: Exemplo de sinal de saída analógico
DEF myprog( )
...
ANOUT ON motor = 3.375*$VEL_ACT MINIMUM=0.30 MAXIMUM=0.97
...
ANOUT OFF motor

12.4 Exercício: Trabalhando com E/Ss analógicas
 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
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.
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.
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.

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?

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

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
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.
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

 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>
Ponto de des- Tipo: POS, E6POS, FRAME
tino
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).
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
 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>

13 Anexo
Ponto auxiliar Tipo: POS, E6POS, FRAME
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.
BASE.
Ponto de des- Tipo: POS, E6POS, FRAME
tino
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).
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
 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ô 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°

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:
$VEL_AXIS[x] ; x=1...8 para cada eixo

$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
$ACC_AXIS[x] ; x=1...8 para cada eixo

$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}}

 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

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

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)
 Velocidade
 Aceleração
 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)

13 Anexo
 Ativar aproximação (C_PTP, C_DIS, C_ORI, C_VEL)

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
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

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
sintaxe
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
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.

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
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:

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
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.

13 Anexo
Sintaxe $GEAR_JERK[Número do eixo]=Solavanco de redutor
Explicação da
sintaxe
eixo
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
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.)

 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

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
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
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:

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
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

Explicação da
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
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]

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
sintaxe
eixo
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
sintaxe
eixo
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

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

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.

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.
SP Ponto de partida
AuxP Ponto auxiliar
TP Ponto de destino programado
TP_CA Ponto de destino real. Resulta do ângulo circular.

#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

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

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


Apostila Treinamento Robo Kuka 2 de 3

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Apostila Treinamento Robo Kuka 2 de 3

Hochgeladen von

Copyright:

Verfügbare Formate

Training KUKA Roboter GmbH

KUKA System Software 8

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.1 Visão geral

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

1.2 Gerenciar projeto com o WorkVisual

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

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, é

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

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

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

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

Nunca conectar a KSI - KUKA Service Interface com uma

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-

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

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

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

1.2.3 Carregar projeto existente no WorkVisual

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

Fig. 1-3: Projeto ativo antes do Transfer

Fig. 1-4: Project Explorer

 Últimos arquivos exibe os últimos arquivos utilizados

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

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

Carregar projeto Procedimento

Fig. 1-5: Find IP Address

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

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

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.

1.2.5 Modos WorkVisual

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

Fig. 1-7: Janela Áreas de trabalho

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

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

1.2.6 Estrutura de projeto WorkVisual (guia Arquivos)

Guia Estrutura de  Guia Estrutura de projeto

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