apostila-treinamento-robo-kuka-2-de-3 pdf

Prévia do material em texto

Training
Programação do robô 2
KUKA System Software 8
Documento de treinamento
KUKA Roboter GmbH
Data: 24.02.2015
Versão: P2KSS8_robotprogramming_2_(R2)_V4
 
Programação 
do robô 2
Programação do robô 2
2 / 251 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
Í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
3 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
4 / 251
Programação do robô 2
5.2 Trabalhar com subprogramas locais ......................................................................... 101
5.3 Trabalhar com subprogramas globais ....................................................................... 103
5.4 Transmitir parâmetros a subprogramas .................................................................... 105
5.5 Exercício: Subprogramas com transferência de parâmetros .................................... 109
5.6 Programação de funções .......................................................................................... 111
5.7 Trabalhar com funções padrão KUKA ....................................................................... 113
6 Programação de mensagens com KRL ..................................................... 115
6.1 Visão geral ................................................................................................................. 115
6.2 Generalidades sobre mensagens definidas pelo usuário .......................................... 115
6.3 Variáveis e estruturas em mensagens definidas pelo usuário .................................. 116
6.4 Funções em mensagens definidas pelo usuário ....................................................... 119
6.5 Trabalhar com uma mensagem de informação ........................................................ 121
6.6 Exercício: Programar mensagem de informação ...................................................... 123
6.7 Trabalhar com uma mensagem de estado ................................................................ 124
6.8Exercí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
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
Índice
8.1 Visão geral ................................................................................................................. 183
8.2 Medição do tempo de ciclo com temporizador .......................................................... 183
8.3 Exercício: Medição de ciclo e otimização .................................................................. 185
9 Programação de Interrupt ........................................................................... 187
9.1 Visão geral ................................................................................................................. 187
9.2 Programação de rotinas de Interrupt ......................................................................... 187
9.3 Exercício: Trabalhar com Interrupts ........................................................................... 193
9.4 Frear o robô e cancelar os movimentos de deslocamento ........................................ 195
9.5 Exercício: Cancelar movimentos de deslocamento com Interrupts ........................... 199
10 Funções de comutação KRL ...................................................................... 201
10.1 Visão geral ................................................................................................................. 201
10.2 Programação das funções de comutação simples .................................................... 201
10.3 Programação do trigger em KRL ............................................................................... 205
10.4 Programar stop condicionado com KRL .................................................................... 208
10.5 Programar região de deslocamento constante com KRL .......................................... 211
10.6 Programar bloco de tempo do spline ......................................................................... 213
11 Interpretador Submit ................................................................................... 217
11.1 Visão geral ................................................................................................................. 217
11.2 Status do Interpretador Submit .................................................................................. 217
12 Trabalhar com sinais analógicos ............................................................... 221
12.1 Visão geral ................................................................................................................. 221
12.2 Programar entradas analógicas ................................................................................. 221
12.3 Programar saídas analógicas .................................................................................... 223
12.4 Exercício: Trabalhando com E/Ss analógicas ........................................................... 227
13 Anexo ............................................................................................................ 229
13.1 Programar movimentos com KRL .............................................................................. 229
13.2 Variáveis de sistema .................................................................................................. 237
13.2.1 $ACC .................................................................................................................... 237
13.2.2 $ACC_AXIS .......................................................................................................... 237
13.2.3 $ACC_EXTAX ...................................................................................................... 237
13.2.4 $APO .................................................................................................................... 238
13.2.5 $BASE .................................................................................................................. 239
13.2.6 $CIRC_TYPE ........................................................................................................ 239
13.2.7 Modo de economia de energia ($ECO_LEVEL) ................................................... 239
13.2.8 $GEAR_JERK ...................................................................................................... 240
13.2.9 $IPO_MODE ......................................................................................................... 241
13.2.10 $JERK ...................................................................................................................241
13.2.11 $LOAD .................................................................................................................. 241
13.2.12 $ORI_TYPE .......................................................................................................... 243
13.2.13 $ROTSYS ............................................................................................................. 243
13.2.14 $SPL_ORI_JOINT_AUTO .................................................................................... 244
13.2.15 $TOOL .................................................................................................................. 244
13.2.16 $VEL ..................................................................................................................... 244
13.2.17 $VEL_AXIS ........................................................................................................... 245
13.2.18 $VEL_EXTAX ....................................................................................................... 245
5 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
6 / 251
Programação do robô 2
13.2.19 $CIRC_MODE ...................................................................................................... 245
Index ............................................................................................................. 249
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
1 Programação com WorkVisual
1.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Vinculação de um PC WorkVisual à unidade de comando
 Visão geral da interface de operação WorkVisual
 Carregar projetos existentes no WorkVisual
 Modos WorkVisual
 Estrutura de projeto WorkVisual (guia Arquivos)
 Comparar projetos com WorkVisual
 Transmitir o projeto para a unidade de comando do robô (instalar)
 Atribuir o projeto a uma unidade de comando do robô real
 Ativar o projeto na unidade de comando do robô
1.2 Gerenciar projeto com o WorkVisual
Para acrescentar ou alterar programas na unidade de comando em um proje-
to existente, são necessários os seguintes passos de trabalho:
Execução do projeto
1. Vinculação de um PC WorkVisual à unidade de comando através da KSI 
- KUKA System Interface.
 (>>> 1.2.1 "Vinculação de um PC WorkVisual à unidade de comando" 
Página 7)
2. Carregar projetos existentes no WorkVisual
 (>>> 1.2.3 "Carregar projeto existente no WorkVisual" Página 10)
3. No WorkVisual, ativar o modo Programação e configuração
 (>>> 1.2.5 "Modos WorkVisual" Página 12)
4. Na estrutura de projeto WorkVisual mudar para Visualizar Arquivos.
 (>>> 1.2.6 "Estrutura de projeto WorkVisual (guia Arquivos)" Página 13)
5. Modificar projeto, por exemplo, programas KRL
 (>>> 1.3 "Processar programas KRL com WorkVisual" Página 35)
6. Comparar eventuais projetos com WorkVisual
 (>>> 1.2.7 "Comparar projetos com WorkVisual" Página 14)
7. Transmitir o projeto para a unidade de comando do robô (instalar)
 (>>> 1.2.8 "Transmitir o projeto à unidade de comando do robô (instalar)" 
Página 18)
8. Atribuir o projeto a uma unidade de comando do robô real
 (>>> 1.2.9 "Atribuir o projeto à unidade de comando do robô real" Pági-
na 28)
9. Ativar o projeto na unidade de comando do robô
 (>>> 1.2.10 "Ativar o projeto na unidade de comando do robô" Página 32)
1.2.1 Vinculação de um PC WorkVisual à unidade de comando
Descrição  Para trocar projetos de PC via WorkVisual com a unidade de comando, é 
necessário estabelecer uma conexão de rede.
 
 
7 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
8 / 251
Programação do robô 2
 Até a versão de software KSS 8.2 estava disponível para isso somente a 
interface KLI - KUKA Line Interface, que tinha que ser configurada em se-
parado. Essa interface também está à disposição com o KSS 8.3. 
 A partir da versão de software KSS 8.3 está disponível a nova interface 
KSI - KUKA Service Interface, que oferece um manuseio bem mais simples.
 Após um update do KSS 8.2 para KSS 8.3 também esta interface será li-
berada em unidades de comando mais "antigas".
Conectar o PC 
WorkVisual à KSI
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.
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-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
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!
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
Fig. 1-2: Vista geral da interface de operação
Pos. Descrição
1 Barra de menu
2 Barras de botões
3 Área de editores
Quando um editor está aberto, ele é exibido aqui. Podem estar 
abertos vários editores simultaneamente, como neste exemplo. 
Eles então estão sobrepostos e podem ser selecionados através 
de guias.
4 Botão de ajuda
5 Janela Estrutura de projeto
6 Janela Catálogos
Nesta janela são exibidos todos os catálogos adicionados. Os 
itens no catálogo podem ser adicionados à janela Estrutura de 
projeto da guia Dispositivos ou Geometria.
7 Janela Áreas de trabalho
8 Janela Mensagens
9 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
10 / 251
Programação do robô 2
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 
projeto ativo na 
HMI
No smartPad o projeto ativo é exibido através do pressionamento do botão 
Projeto.
Explorer de 
projeto
 Ú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
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
Pos. Descrição
Fig. 1-3: Projeto ativo antes do Transfer
Fig. 1-4: Project Explorer
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
 Localizar é usado para poder carregar um projeto da unidade de coman-
do do robô
Caminho de menu:Arquivo > Localizar projeto
Carregar projeto 
WorkVisual da 
unidade de 
comando
Procedimento
1. Selecionar a sequência de menu Arquivo > Localizar projeto. Abre-se o 
Project Explorer. À esquerda está selecionada a guia Localizar.
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.
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).
Fig. 1-5: Find IP Address
11 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
12 / 251
Programação do robô 2
1.2.4 Gravar localmente o projeto WorkVisual
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-6: Salvar o projeto carregado
Fig. 1-7: Janela Áreas de trabalho
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
1.2.6 Estrutura de projeto WorkVisual (guia Arquivos)
Guia Estrutura de 
projeto
 Guia Estrutura de projeto
 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).
Para o treinamento Programação de robô 2 é necessário o modo 
Programação e configuração.
Fig. 1-8: Exemplo: Arquivos gerados automaticamente em cinza
13 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
14 / 251
Programação do robô 2
 Na janela Estrutura de projeto sob a guia Arquivos encontra-se a pasta ne-
cessária para a programação:
Caminho de menu: KRC\R1\PROGRAMME
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 
comparação de 
projeto
Unir projetos
 Janela de seleção Comparar projeto
 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.
Não excluir ou manipular nenhum arquivo *.XML desconhecido. Em 
determinadas circunstâncias o projeto não pode ser ativado ou gera 
erros.
Fig. 1-9: Selecionar projeto para "comparar"
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
Fig. 1-10: Exemplo: Visão geral das diferenças
Pos. Descrição
1 O nó para a unidade de comando do robô. As diversas áreas de projeto são represen-
tadas em subnós. Abrir os nós, para exibir as comparações.
Se existirem várias unidades de comando do robô, elas são enumeradas uma sob a 
outra.
 Em uma linha, sempre colocar o ticado no valor que deve ser assumido. (Alterna-
tiva: usar as caixas de verificação na linha de rodapé.)
 Um ticado em Não disponível significa, que o elemento não é assumido ou que, 
se já existente, será excluído do projeto.
 Quando um nó é ticado, também são ticados automaticamente todos os elementos 
subordinados.
Quando um ticado é removido em um nó, também é removido automaticamente o 
ticado em todos os elementos subordinados.
Os elementos subordinados, contudo, também podem ser editados individualmen-
te.
 Uma caixa preenchida significa: Dos elementos subordinados, pelo menos um 
está selecionado, contudo, não todos.
2 Estado no projeto, que está aberto no WorkVisual.
3 Estado no projeto de comparação.
4 Filtro, para exibir e ocultar diversos tipos de diferenças.
5 TRUE: São inseridas informações detalhadas para a linha marcada na visão geral.
15 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
16 / 251
Programação do robô 2
Descrição das cores:
Procedimento na 
comparação de 
projetos
1. No WorkVisual, selecionar a sequência de menu Extras > Comparar pro-
jetos. Abre-se a janela 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.
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.
Pos. Descrição
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.
Fig. 1-11: Comparar projetos
Fig. 1-12: Selecionar projeto para "comparar"
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
4. Quando a barra de progresso estiver preenchida e, além disso, for exibido 
o estado. Pronto para unir: Clique em Exibir diferenças. As diferenças 
entre os projetos são exibidas em uma visão geral.
Se não foram apuradas diferenças, isto é exibido na janela de mensa-
gens. Continuar com o passo 8. Depois disto não sãonecessá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
Decisão de qual estado do(s) arquivo(s) deve ser assumido.
Fig. 1-13: Exemplo: Visão geral de comparação de projetos
17 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
18 / 251
Programação do robô 2
Na ativação dos Detalhes podem ser exibidas as diferenças dos arquivos.
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".
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-14: Exemplo: Unir projetos
Fig. 1-15: Exemplo: Detalhes ativados
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).
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
 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-16: Exemplo Gerar código: antes - depois
Fig. 1-17: Visão geral com observação sobre configuração incompleta 
19 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
20 / 251
Programação do robô 2
2. Em se tratando de um projeto, que nunca foi retransmitido de uma unida-
de de comando do robô ao WorkVisual, ele ainda não contém todos os da-
dos de configuração (dentre os arquivos de configuração estão arquivos 
de dados da máquina, arquivos da configuração de segurança e inúmeros 
outros). Isso é indicado por uma instrução.
 Se esta instrução não for exibida: Continuar com o passo 13.
 Quando esta instrução é exibida: Continuar com o passo 3.
3. Clicar em Completar. É exibida a seguinte pergunta de segurança: O 
projeto deve ser salvo e o comando atual é resetado! Deseja prosse-
guir?
4. Responder a pergunta com Sim. Abre-se a janela Unir projetos.
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-18: Selecionar projeto para "comparar"
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
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.
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-19: Visão geral
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. 
21 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
22 / 251
Programação do robô 2
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.
Versões 
WorkVisual a 
partir de 3.1
Procedimento
Iniciar trans-
missão de projeto
 Na barra de menu, pressionar o botão Instalar …. . 
 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 
de comando
1. A unidade de comando do projeto WorkVisual (2) já está atribuída à uni-
dade de comando real (4) através da seta azul (3). (>>> "Procedimento" 
Página 31)
Fig. 1-20: Confirmação no WorkVisual
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.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V41 Programação com WorkVisual
2. Confirmar a atribuição com o botão Continuar (7)
Solucionar 
conflitos
 Se existirem conflitos ou irregularidades na transmissão de projeto, é in-
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.
 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.
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
Fig. 1-22: Geração de código
23 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
24 / 251
Programação do robô 2
Transmitir projeto  O projeto gerado pronto é transmitido automaticamente no próximo passo 
de trabalho à unidade de comando.
 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).
 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-23: Transmitir projeto
Fig. 1-24: Ocorreu um erro na ativação do projeto
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
 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 
ativação do 
projeto no 
SmartPad
1. De acordo com as alterações no projeto é necessário o perfil de usuário 
perito ou colocador em funcionamento de segurança.
2. Da HMI do SmartPads aparece a mensagem "Aguardada introdução de 
usuário!".
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".
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-25: Transmissão de projeto bem sucedida
Fig. 1-26: Mensagem de instalação
Fig. 1-27: Permitir ativação
25 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
26 / 251
Programação do robô 2
5. No smartPad aparece uma mensagem de que é realizada uma reconfigu-
ração.
Assumir a soma 
de verificação 
alterada
1. Se no WorkVisual a segurança tiver sido alterada como, p.ex., a interface 
de segurança ou o parâmetro SafeOperation, é exibida a seguinte men-
sagem de erro na janela de mensagens: "Soma de verificação da configu-
ração de segurança está incorreta".
Fig. 1-28: Indicação das alterações
Fig. 1-29: Reconfiguração em execução
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
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"
5. Aceitar a primeira sugestão, pressionando o botão "Ativar agora".
Fig. 1-30: Erro Soma de verificação
Fig. 1-31: Assistente de solução de problemas
27 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
28 / 251
Programação do robô 2
6. Na janela "Ativar" responder a pergunta "Tem certeza que deseja alterar as 
seguintes partes da configuração relevante de segurança?" com "Sim". A recon-
figuração é executada.
7. Confirmar a mensagem no smartPad "As modificações foram memorizadas 
com sucesso" com o botão "OK".
8. Confirmar a mensagem de confirmação "Quitt: Soma de verificação da 
configuração de segurança está incorreta" com "Todos OK"
1.2.9 Atribuir o projeto à unidade de comando do robô real
Descrição Um projeto deve ser atribuído da seguinte forma antes da transmissão:
 Unidade de comando de destino
 A unidade de comando de destino corresponde à unidade de coman-
do real, na qual o projeto deve ser transmitido.
 Se um projeto é carregado de uma unidade de comando, editado no 
WorkVisual e se deve ser novamente transmitido de volta, a atribuição 
ocorre automaticamente. 
 Célula
 Em estruturas de instalações mais complexas pode acontecer que vá-
rios robôs ou várias unidades de comando se encontrem em uma úni-
ca célula grande.
 Antes que um projeto seja transmitido à unidade de comando, a uni-
dade de comando pode ser atribuída a uma célula.
 Essa atribuição não tem nenhum efeito sobre a capacidade funcional 
do projeto.
 Ela serve para fins de visualização geral e fica visível na união de ins-
talações através do WorkVisual. 
Versões 
WorkVisual até 
3.0
Procedimento 1. Na barra de menu, clicar no botão Instalar …. Abre-se a janela Trans-
missão de projeto. 
2. Através do botão Alterar na linha Célula é aberta a visão geral da célula.
Fig. 1-32: Visão geral
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
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.
9. Marcar a unidade de comando virtual sob Unidades de comando no pro-
jeto.
Fig. 1-33: Atribuir a unidade de comando de robô à célula
Cada unidade de comando do robô virtual deve ser atribuída exata-
mente a uma unidade de comando de robô real.
29 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
30 / 251
Programação do robô 2
10. Sob Unidades de comando na célula, marcar a unidade de comando do 
robô real e clicar em . A unidade de comando do robô real é atribuída 
à unidade de comando do robô virtual.
11. Se o projetocontiver várias unidades de comando do robô, repetir os pas-
sos 8 e 9 para as demais unidades de comando do robô.
12. Clicar em Continuar. É exibida uma visão geral. (Aqui existe a possibili-
dade de alterar mais uma vez a atribuição, caso necessário. Para isto, cli-
car em Alterar ….)
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.
Fig. 1-34: Atribuir a unidade de comando de robô real à virtual
Fig. 1-35: Visão geral
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
Versões 
WorkVisual a 
partir de 3.1
Procedimento 1. Na barra de menu, clicar no botão Instalar …. Abre-se a janela Trans-
missão de projeto WorkVisual. No lado esquerdo é exibida a unidade 
de comando do robô virtual do projeto. No lado direito é exibida a unidade 
de comando de destino. Ela está em cinza se ainda não foi selecionada 
nenhuma unidade de comando.
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-36: Atribuir a unidade de comando do robô à célula
Fig. 1-37: Atribuir a unidade de comando do robô real à virtual
31 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
32 / 251
Programação do robô 2
4. Selecionar a unidade de comando do robô real desejada e clicar em Ok. 
A unidade de comando do robô real é atribuída à unidade de comando do 
robô virtual. Após a atribuição a unidade de comando do robô real é exi-
bida com cor e com nome e endereço IP.
5. Se o projeto contiver várias unidades de comando do robô, repetir os pas-
sos 3 e 4 para as demais unidades de comando do robô.
6. Clicar em Continuar. A atribuição é verificada quanto a conflitos. Em caso 
de conflitos, é exibida uma mensagem. Os conflitos devem ser soluciona-
dos, caso contrário não é possível transmitir o projeto. Se não houver con-
flitos, é gerado automaticamente o código.
7. Agora o projeto pode ser transmitido à unidade de comando do robô.
Alternativamente o projeto pode ser transmitido posteriormente. Para isto, 
clicar em Cancelar: a atribuição é salva e a janela Transmissão de pro-
jeto WorkVisual fecha.
1.2.10 Ativar o projeto na unidade de comando do robô
Descrição  O projeto pode ser ativado diretamente na unidade de comando do robô
 O projeto pode ser ativado também diretamente a partir do WorkVisual 
para na unidade de comando do robô
(não será explicado detalhadamente aqui, usar para isto a documentação 
online do WorkVisual)
Função da 
administração de 
projeto
Generalidades
 A unidade de comando do robô tem a possibilidade de administrar vários 
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-38: Visão geral
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
Manuseio / Operação

 Além dos projetos regulares a janela Administração de projeto contém 
os seguintes projetos especiais:
Fig. 1-39: Exibição de projeto na interface de operação
Fig. 1-40: Janela Administração de projeto
Pos. Descrição
1 É exibido o projeto inicial.
2 Restabelece o estado de fornecimento da unidade de comando do 
robô.
Está disponível a partir do grupo de usuários Peritos.
3 É exibido o projeto base.
4 Cria uma cópia do projeto base.
Está disponível a partir do grupo de usuários Peritos.
5 O projeto ativo é exibido.
6 Salva o projeto ativo como projeto base. O projeto ativo permane-
ce ativo.
Está disponível a partir do grupo de usuários Peritos.
7 Cria uma cópia pinada do projeto ativo.
Está disponível a partir do grupo de usuários Peritos.
8 Lista dos projetos. O projeto ativo não é exibido aqui.
33 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
34 / 251
Programação do robô 2
 Descrição dos botões
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.
Botão Descrição
Ativar Ativa o projeto marcado.
Se o projeto marcado estiver pinado: Cria uma cópia 
do projeto marcado. (Um projeto pinado não pode ser 
ativado, somente uma cópia dele.) O usuário pode 
decidir, se a cópia deve ser ativada imediatamente ou 
se o projeto atual deve permanecer ativo.
Está disponível a partir do grupo de usuários Peritos.
Colocar pinos Projetos pinados não podem ser alterados, ativados ou 
excluídos. Contudo, eles podem ser copiados ou "des-
pinados". Portanto, pode-se pinar um projeto para, 
p.ex., impedir que ele seja excluído acidentalmente.
Somente está disponível, se estiver marcado um pro-
jeto não-pinado. Está disponível a partir do grupo de 
usuários Peritos.
Despinar "Despina" o projeto.
Somente está disponível, se estiver marcado um pro-
jeto pinado. Está disponível a partir do grupo de usuá-
rios Peritos.
Copiar Copia o projeto marcado.
Está disponível a partir do grupo de usuários Peritos.
Excluir Exclui o projeto marcado.
Somente está disponível, se estiver marcado um pro-
jeto não-pinado não ativo. Está disponível a partir do 
grupo de usuários Peritos.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
Procedimento
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ô.
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
Editar Abre uma janela, na qual podem ser alterados o nome 
e/ou a descrição do projeto marcado.
Somente está disponível, se estiver marcado um pro-
jeto não-pinado. Está disponível a partir do grupo de 
usuários Peritos.
Atualizar Atualiza a lista de projetos. Desta forma são exibidos, 
p.ex., projetos, que foram transmitidos à unidade de 
comando do robô desde a abertura da exibição.Botão Descrição
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. 
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.
35 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
36 / 251
Programação do robô 2
Ativar catálogo 
Templates
 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 
(SRC/DAT/SUB) 
no editor KRL
Procedimento
1. Na estrutura de projeto mudar para a guia Arquivos (1)
2. Abrir diretórios até ao diretório R1
Fig. 1-41: Adicionar catálogo
Fig. 1-42: WorkVisual Árvore de projeto
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
3. Selecionar arquivo e ou 
 com duplo-clique
 Botão da lista de símbolos 
 Clique à direita e no menu de contexto Editor KRL
Adicionar o 
arquivo com 
templates KRL
Procedimento 
1. Trocar arquivo da árvore de projeto
2. Abrir diretórios até ao diretório R1
Fig. 1-43: WorkVisual Árvore de projetos Estrutura de dados (R1)
Fig. 1-44: Menu mouse de contexto WorkVisual (Editor KRL)
37 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
38 / 251
Programação do robô 2
3. Selecionar a pasta na qual o novo arquivo deverá ser criado
4. Clicar à direita e no menu de contexto Adicionar
5. Seleção de template
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
Fig. 1-45: Menu de contexto WorkVisual (adicionar)
Fig. 1-46: Catálogos para Templates KRL
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
Adicionar arquivo 
externo
Procedimento
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. 
3. Navegar para o diretório, no qual se encontra o arquivo a ser importado.
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.
Fig. 1-47: Menu de contexto WorkVisual (adicionar arquivo externo)
Fig. 1-48: Adicionar arquivo externo WorkVisual
39 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
40 / 251
Programação do robô 2
Exemplo
 A estrutura de projeto deve ser expandida.
 Clicar com o botão direito no ícone da unidade de comando ativa e clicar 
em "Adicionar".
 É exibida a mensagem "Não foram encontrados elementos adequados. 
Adicione os catálogos correspondentes."
Procedimento
Ativar catálogo 
Templates
 Antes do uso dos templates é necessário carregar os respectivos catálo-
gos.
Fig. 1-49: Expandir a estrutura de projeto
Fig. 1-50: Mensagem de erro
Fig. 1-51: Adicionar catálogo
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
 Caminho de menu: Arquivo > Adicionar catálogo
 Na janela Catálogos disponíveis (1) estão enumerados todos os catálo-
gos instalados no WorkVisual, mas que não estão carregados e ativos.
 Na janela Catálogos de projeto (2) encontram-se todos os catálogos que 
estão instalados e carregados no WorkVisual. Com estes catálogos pode 
ser trabalhado ativamente. 
 Através das teclas de seta (2) os catálogos podem ser setados como ati-
vos e inativos.
 Para a programação no WorkVisual são necessários os seguintes catálo-
gos:
 KRL Templates 
KRL Templates.afc
 Modelos VW
VW Templates.afc
1.3.3 Manuseio com o editor KRL
Descrição Editor 
KRL
 Conhecer a interface de operação Editor 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 
interface de 
operação Editor 
KRL
Descrição
 O editor KRL permite o processamento confortável de programas KUKA.
 Não é possível testar ou deixar executar programas. 
 Caminho de menu: Editores > Editor KRL
41 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
42 / 251
Programação do robô 2
Fig. 1-52: Interface de operação - Editor KRL
Pos. Descrição
1 Área do programa
Aqui se insere ou edita o código. O editor KRL oferece inúmeras 
funcionalidades que dão suporte ao programador.
2 Lista dos subprogramas neste arquivo
Para se chegar a um subprograma, selecionar isto na lista: O cur-
so salta para a fileira DEF deste subprograma.
Se o arquivo não incluir subprogramas, a lista estará vazia.
3 Lista de declaração de variáveis
Esta lista sempre se refere a um subprograma que foi selecionado 
atualmente na lista de subprogramas. Para se chegar a uma de-
claração, selecionar a variável na lista: O cursor salta para a fileira 
com a declaração destas variáveis.
Se não houver nenhuma declaração de variável disponível, a lista 
estará vazia.
4 Barra de análise
As marcações mostram erros ou discrepâncias no código. 
 Um mouseover sobre a marcação mostra uma sugestão de 
ferramenta com a descrição do erro.
 Através de um clique na marcação, o cursor salta até a posi-
ção correspondente no programa. Para o caso de alguns er-
ros/discrepâncias é oferecida uma correção automática.
5 O quadrado tem a cor do erro mais grave existente atualmente.
Se não houverem erros/discrepâncias, o quadrado fica verde.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
Funções gerais 
de edição
Marcar
 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.
 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.
Ao se pressionar a tecla ALT durante a marcação, pode-se marcar 
uma área em formato quadrado. 
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 
maiúsculas
Converte as minúsculas em maiúsculas na área demar-
cada.
Editar > Converter em letras 
minúsculas
Converte as maiúsculas em minúsculas na área demar-
cada.
Editar > Primeira letra em mai-
úscula
Converte as letras iniciais em maiúsculas na área demar-
cada.
Editar > Converter Tabs em 
espaços em branco
Substitui na área marcada os tabuladores por caracteres 
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 
branco em Tabs
Substitui na área marcada os caracteres em branco por 
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 
inicial
Remove os espaços em branco iniciais nas fileiras.
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)
43 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
44 / 251
Programação do robô 2
Descrição de 
cores do editor 
KRL
 Descrição das cores
O editor KRL reconhece os componentes do código introduzido e os exibe 
automaticamente em diferentes cores.
 Exemplo para o uso das cores
Exibir decla-
rações variáveis 
de um arquivo
Descrição
 Todas as variáveis KRL, que estão declaradas em um determinado arqui-
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).
Ir para Declaração (>>> "Exibir variáveis" Página 51)
Inserir Snippet (>>> "Snippets – Introdução rápida para instruções KRL" 
Página 48)
Item de menu Descrição
Componente do código Cor
Palavras-chave KRL
(exceto ;FOLD e ;ENDFOLD)
azul médio
;FOLD e ;ENDFOLD cinza
Números azul marinho
Strings (texto entre aspas "…") vermelho
Comentários verde
Caracteres especiais verde azulado
Outro código preto
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
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
Através de um clique na coluna, a lista pode ser classificada conforme 
esta coluna.
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 
substituir em 
arquivos
Descrição
 No WorkVisual há uma opção de pesquisa com a qual se pode pesquisar 
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-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.
45 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
46 / 251
Programação do robô 2
4. Ou: Abrir a janela de pesquisa e substituição: CTRL+H
5. Concluir o ajuste desejado e clicar em Pesquisar, respectivamente em 
Substituir ou Substituir todos.
Renomear 
variáveis
Descrição
 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.
Fig. 1-55: Busca de WorkVisual
Fig. 1-56: Localizar e substituir
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
Procedimento
1. Em uma posição qualquer, marcar a variável desejada.
2. Clicar com o botão direito e no menu de contexto selecionar Renomear.
3. Abre-se uma janela. Mudar o nome e confirmar com OK.
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:
 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.
Fig. 1-57: Renomear variável
Fig. 1-58: Autocompletar
47 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
48 / 251
Programação do robô 2
 Se necessário, um item pode ser marcado na lista e aceito no texto do pro-
grama através da tecla Enter. 
Isso torna desnecessário, por exemplo, sempre ter de se digitar nomes de 
variáveis complexas.
Snippets – Intro-
dução rápida para 
instruções KRL
Descrição
 Para instruções KRL usuais está disponível uma introdução rápida no edi-
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.
2. A sintaxe KRL é inserida automaticamente. A primeira posição variável 
tem fundo azul Introduzir o valor desejado.
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.
Navegação na lista Completar:
Rolar
Ou: Digitaras letras iniciais do item desejado. A marcação pula para 
lá.
Fig. 1-59: Aplicar com a tecla Enter ou dar um duplo clique
Fig. 1-60: A primeira posição variável tem fundo azul
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
3. (As abreviaturas podem ser determinadas, acessando-se a lista com os 
fragmentos. Marcar a instrução. Abre-se uma sugestão de ferramenta. A 
2ª linha contém as abreviaturas possíveis.)
Correção 
Quickfix
Descrição
 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.
 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 
não declarada ou 
declarar automa-
ticamente
Variáveis não declaradas são exibidas conforme segue:
 No código por meio de uma onda vermelha
 Na barra de análise através de uma linha vermelha
 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.
Ou: Clicar sobre a linha na barra de análise.
Ao lado dos nomes das variáveis aparecerá uma luzinha Quickfix. 
Fig. 1-61: Luzinha Quickfix
Fig. 1-62: variável não declarada
49 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
50 / 251
Programação do robô 2
2. Confirmar se o nome da variável não foi escrito incorretamente por enga-
no (de forma diferente da declaração).
 Caso positivo: Corrigir A onda/linha vermelha desaparece. Nenhuma 
outra etapa é necessária!
 Caso negativo: Prossiga com a próxima etapa.
3. Mover o ponteiro do mouse sobre a luzinha Quickfix. Ao lado da luzinha 
aparecerá uma seta.
Clicar na seta. As seguintes opções são exibidas:
 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 ....
 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.
Fig. 1-63: Declarar a variável
Fig. 1-64: variável declarada automaticamente na lista .dat
Este comentário é exibido na sugestão de ferramenta da lista Com-
pletar quando a variável é marcada ali.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
Não excluir 
variáveis usadas
Descrição
 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.
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-65: Remover ou descomentar a variável
51 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
52 / 251
Programação do robô 2
3. O cursor marca o nome da variável na seção de declaração. 
No exemplo:
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.)
4. Se necessário: Clicar duas vezes sobre uma linha na lista. A posição cor-
respondente será marcada no programa. 
Fig. 1-66: Menu - botão direito do mouse 
...
DECL INT counter
...
Fig. 1-67: Filtro Utilização
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
Por exemplo, pode-se Alterar o nome.
Trabalhar com 
pastas
Descrição
 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.
Fechar uma pasta
 Clicar no sinal de menos.
 A pasta é fechada.
Abrir ou fechar todas as pastas
 Menu de contexto: Pastas > Abrir todas ou Fechar todas
Fig. 1-68: Pasta aberta
Fig. 1-69: Pasta fechada
53 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
54 / 251
Programação do robô 2
1.4 Exercício: Editar um projeto ativo no WorkVisual
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
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 
funções
 Conecte o PC com o WorkVisual 3.x à KSI - KUKA Service Interface do ar-
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?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
1 Programação com WorkVisual
6. Para o que são usados Snippets?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
55 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
56 / 251
Programação do robô 2
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
2 Programação estruturada
2 Programação estruturada
2.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Metodologia de programação padronizada
 Recursos auxiliares para a criação de programas de robô estruturados
 Fluxograma do programa
2.2 Objetivo de um método de programação padronizado
Objetivo do 
método de 
programação 
padronizado
Um método de programação padronizado serve para:
 dominar mais facilmente os problemas complexos com uma estrutura ri-
gorosamente desmembrada
 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 
de um comen-
tário?
Comentários são complementos/notas dentro das linguagens de programa-
ção. Todas as linguagens de programação consistem de instruções para o 
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 
2
 
 
57 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
58 / 251
Programação do robô 2
caso de alterações de programa também os comentários deverão ser verifi-
cados e, se necessário, adaptados.
O conteúdo de um comentário e, portanto, também a sua utilidade, pode ser 
livremente selecionado pelo processador e não tem sintaxe obrigatória. Ge-
ralmente, comentários são registrados em linguagem "humana", na língua 
materna do autor ou em uma língua de conveniência. 
 Notas sobre o conteúdo ou a função de um programa
 Conteúdo ou utilidade são livremente selecionáveis
 Melhoram a legibilidade de um programa
 Contribuem para a estruturação de um programa
 A responsabilidade pela atualidade é do programador
 A KUKA usa comentários de linhas
 Os comentários não são registrados pela unidade de comando como sin-
taxe
Onde e quando 
são usados 
comentários?
Informações sobre todo o texto fonte: 
No início de um texto fonte o autor pode incluir comentários prévios, sob os 
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. 
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. 
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()
;Este programa busca o cubo do magazine
;Autor: Max Mustermann
;Data de criação: 09.08.2011
INI
...
END
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
DEF PICK_CUBE()
INI
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
2 Programação estruturada
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.
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.
Qual é o efeito do 
uso de pastas em 
um programa de 
robô?
 Em PASTAS podem ser ocultadas partes do programa
 Conteúdos de PASTAS não são visíveis para o usuário
 Conteúdos de PASTAS são processados normalmente na execução do 
programa
 Através do uso de pastas (folds) pode ser melhorada a legibilidade de um 
programa 
Que exemplos há 
para o uso de 
pastas?
Na unidade de comando KUKA já são usadas, como padrão, pastas pelo sis-
tema, por exemplo, na exibição de formulários Inline. As pastas simplificam a 
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 
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
DEF PICK_CUBE()
INI
;Aqui deve ser inserido ainda o cálculo das posições de paletes!
SPTP HOME Vel=100% DEFAULT
SPTP Pre_Pos ; A posição prévia para a coleta é acessada
SLIN Grip_Pos ; Posição de coleta do cubo é acessada
;Aqui falta ainda o fechamento da garra
END
DEF Palletize()
INI
PICK_CUBE()
;CUBE_TO_TABLE()
CUBE_TO_MAGAZINE()
END
59 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
60 / 251
Programação do robô 2
determinado local do programa, mas mantendo a verdadeira sintaxe KRL em 
segundo plano. 
Inicialmente as pastas em geral são exibidas fechadas após a sua criação.
Por que se 
trabalhacom a 
técnica de 
subprogramas?
Na programação, os subprogramas são utilizados especialmente para permi-
tir um uso múltiplo de partes de tarefas iguais e com isso, conseguir evitar as 
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-
DEF Main()
...
INI ; PASTA KUKA fechada
SET_EA ; PASTA criada pelo usuário fechada
SPTP HOME Vel=100% DEFAULT ; PASTA KUKA fechada
SPTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table
...
SPTP HOME Vel=100% Default
END
DEF Main()
...
INI ; PASTA KUKA fechada
SET_EA ; PASTA criada pelo usuário aberta
$OUT[12]=TRUE
$OUT[102]=FALSE
PART=0
Position=0
SPTP HOME Vel=100% DEFAULT ; PASTA KUKA fechada
...
SPTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table
SPTP HOME Vel=100% Default
END
DEF Main()
...
INI ; PASTA KUKA fechada
SET_EA ; PASTA criada pelo usuário fechada
; PASTA KUKA aberta
SPTP XHOME WITH $VEL_AXIS[1]= SVEL_JOINT( 100), $TOOL= STOOL2( 
FHOME), $BASE= SBASE( FHOME.BASE_NO),
$IPO_MODE= SIPO_MODE( FHOME.IPO_FRAME), $LOAD= SLOAD( FHOME.TOOL_NO), 
$ACC_AXIS[1]= SACC_JOINT( PDEFAULT), 
$GEAR_JERK[1]= SGEAR_JERK( PDEFAULT)
...
SPTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table
SPTP HOME Vel=100% Default
END
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
2 Programação estruturada
truturação do programa ocorrente através disso.
Um subprograma deve executar uma tarefa parcial finalizada em si e fácil de 
se descrever.
Hoje em dia os subprogramas são preferencialmente curtos e compreensíveis 
para favorecer uma melhor manutenção e eliminação de erros de programa-
ção. O dispêndio de tempo e de administração interno do computador para o 
acesso de subprogramas praticamente é desprezível em computadores mo-
dernos.
 Uso múltiplo possível
 Evitar repetições de códigos 
 Economia de espaço de memória
 Componentes podem ser desenvolvidos separadamente
 A troca de componentes da mesma potência é possível a qualquer mo-
mento
 Estruturação do programa
 Tarefa total dividida em tarefas parciais
 Melhor manutenção e correção dos erros de programação 
Aplicação de 
subprogramas
O que provoca o 
recuo de linhas 
de comando?
Para mostrar a relação de componentes de programa, recomendamos fazer 
um recuo da margem em sequências de comandos encadeadas e escrever 
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 MAIN()
INI
LOOP
 GET_PEN()
 PAINT_PATH()
 PEN_BACK()
 GET_PLATE()
 GLUE_PLATE()
 PLATE_BACK()
 IF $IN[1]== TRUE THEN
 EXIT
 ENDIF
ENDLOOP
END
DEF INSERT()
INT PART, COUNTER
INI
SPTP HOME Vel=100% DEFAULT
LOOP
 FOR COUNTER = 1 TO 20
 PART = PART+1
 ;não é possível recuar formulários Inline!!!
SPTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table
 PTP XP5 ; Movimento com KRL
 ENDFOR
...
61 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
62 / 251
Programação do robô 2
O que se obtém 
através de uma 
identificação 
adequada de 
nomes de dados?
Para interpretar corretamente a função de dados e sinais em um programa do 
robô, recomendamos usar termos que fazem sentido na definição de nomes. 
A estes pertencem, p.ex.: 
 Nomes de textos descritivos para sinais de entrada e de saída
 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
Integração de instruções e operações
Ramificação
ENDLOOP
Fig. 2-1
Fig. 2-2
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
2 Programação estruturada
Instruções gerais no código de programa
Acesso ao subprograma
Instrução de entrada/saída
Fig. 2-3
Fig. 2-4
Fig. 2-5
Fig. 2-6
63 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
64 / 251
Programação do robô 2
Exemplo PAP
Como é 
elaborado um 
PAP
Partindo da ideia do usuário o problema é detalhado passo a passo, até que 
os componentes elaborados sejam suficientemente visualizáveis, para poder 
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
Fig. 2-7
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
3 Introdução no nível de perito
3 Introdução no nível de perito
3.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Usar nível de perito
3.2 Usar nível de perito
Descrição A unidade de comando do robô oferece diferentes Grupos de usuários com 
diferentes funções. Podem ser selecionados os seguintes Grupos de usuá-
rios:
 Operador
Grupo de usuários para o operador. Este é o grupo de usuários padrão.
 Usuário
Grupo de usuários para o operador. (Os grupos de usuários Operador e 
Usuário são criados como padrão para o mesmo grupo-alvo.)
 Peritos
Grupo de usuários para o programador. O grupo de usuários é protegido 
por uma senha.
 Administrador
Funções como no grupo de usuários Peritos. Além disso é possível a in-
tegração de plug-ins na unidade de comando do robô. O grupo de usuá-
rios é protegido por uma senha. A senha de fornecimento kuka deve ser 
alterada.
 Técnico de manutenção de segurança
Este usuário pode ativar uma configuração de segurança existente do 
robô através de um código de ativação. Se não for usada nenhuma opção 
Safe-Option, p.ex. KUKA.SafeOperation ou KUKA.SafeRangeMonitoring, 
o técnico de manutenção de segurança dispõe de direitos ampliados. Por 
exemplo, ele está autorizado a configurar as funções de segurança pa-
drão. O grupo de usuários é protegido por uma senha. A senha de forne-
cimento kuka deve ser alterada.
 Colocador em funcionamento de segurança
Este grupo de usuários somente é relevante, se for usado KUKA.SafeO-
peration ou KUKA.SafeRangeMonitoring. O grupo de usuários é protegido 
por uma senha. A senha de fornecimento kuka deve ser alterada.
Funções ampliadas do grupo de usuários Peritos:
 Protegido por senha (padrão: kuka)
 Programação no Editor é possível com KRL
 O grupo de usuários Peritos é abandonado automaticamente,
 ao mudar para o modo de operação AUT ouAUT EXT
 se durante um determinado período não houver ação na superfície do 
usuário (300 s)
Funções Criar programas usando templates
 Cell: Programa de célula existente só pode ser substituído ou recriado 
com célula excluída.
 
t
 
Como Perito, estão disponíveis todas as funções no menuEditar.
65 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
66 / 251
Programação do robô 2
 Peritos: módulo existente no arquivo SRC e DAT, no qual só há cabeça-
lho e fim de programa.
 Expert Submit: arquivo Submit (SUB) adicional que consiste de cabeça-
lho e fim de programa.
 Function: elaboração de função SRC, na qual só é criado o cabeçalho da 
função com uma variável BOOL O final da função existe, porém, o retorno 
ainda deve ser programado.
 Módulo: módulo consiste dos arquivos SRC e DAT, no qual existe o ca-
beçalho do programa, o fim e a estrutura básica (INI e 2x PTP HOME). 
 Submit: arquivo Submit (SUB) adicional que consiste de um cabeçalho e 
fim de programa e estrutura básica (DECLARATION, INI, LOOP/ENDLO-
OP).
O Filtro determina como os programas são exibidos na lista de arquivos. Es-
tão disponíveis os seguintes Filtros:
 Cancelar programa ou fechar.
 Selecionar o botão Editar > Filtro e depois Detalhe ou Módulo
 Detalhe
Os programas são exibidos como arquivos SRC e DAT. (Ajuste predefini-
do)
 Módulos
Os programas são exibidos como módulos.
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.
Fig. 3-1: Menu Editor
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
3 Introdução no nível de perito
 A sintaxe para uma pasta é:
;FOLD Nome
Instruções
;ENDFOLD <Nome>
As linhas ENDFOLD podem ser atribuídas com mais facilidade, se for in-
serido aqui o nome da pasta. As pastas (Folds) podem ser encadeadas.
Exibir e ocultar Linha DEF
 A Linha DEF é ocultada por defeito. Em um programa só podem ser rea-
lizadas declarações, quando a Linha DEF é exibida.
 A Linha DEF é exibida e ocultada separadamente para programas aber-
tos e selecionados. Se a vista detalhada estiver ativada, a Linha DEF tor-
na-se visível e não precisa ser exibida separadamente.
Ativar procedi-
mento para nível 
de Perito e 
corrigir erros
Ativar nível de Peritos
1. Selecionar o menu principal Configuração > Grupo de usuários.
2. Login como Peritos: Clicar em Login. Marcar o grupo de usuários Peritos 
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
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
Fig. 3-2: Programa com erro
67 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
68 / 251
Programação do robô 2
3.3 Exercício: Medição de ferramentas e base
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Medição da ferramenta com o método XYZ 4-Pontos e o método World 5D
 Medição da ferramenta com introdução numérica de valor
 Medição da base conforme o método 3 pontos
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos teóricos sobre a medição de uma ferramenta
 Conhecimentos teóricos sobre a medição de uma base
Função: Intro-
dução de dados 
de ferramenta de 
garra
Introduza para a sua garra de treinamento com introdução numérica:
 Garra de treinamento KR 16
Fig. 3-3: College garra: Posição do TCP
Fig. 3-4: Garra de treinamento KR 16
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
3 Introdução no nível de perito
 Garra de treinamento Célula modular
 Garra de treinamento Célula móvel
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 kgm
2 JY = 0,04 kgm
2 JZ = 0,12 kgm
2
Canto direito da garra
X Y Z
122,64 mm 177,73 mm 172,49 mm
A B C
45 0 180
Fig. 3-5: Garra de treinamento Célula modular
Massa:
M = 4,4 kg
Centro de gravidade da massa:
X = 7 mm Y = -24 mm Z = 80 mm
Orientação:
A = 0° B = 0° C = 0°
Momentos de inércia:
JX = 0,02 kgm
2 JY = 0,05 kgm
2 JZ = 0,11 kgm
2
Canto direito da garra
X Y Z
175,38 mm -123,97 mm 172,71 mm
A B C
-45 0 -180
69 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
70 / 251
Programação do robô 2
Definição de 
funções
Medição de pino
 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 
da ferramenta de 
garra com pino
 Garra de treinamento KR 16
Fig. 3-6: Garra de treinamento Célula móvel
Massa:
M = 2 kg
Centro de gravidade da massa:
X = 23 mm Y = 0 mm Z = 61 mm
Orientação:
A = 0° B = 0° C = 0°
Momentos de inércia:
JX = 0,002 kgm
2 JY = 0,004 kgm
2 JZ = 0,003 kgm
2
Canto direito da garra
X Y Z
12 mm 0 mm 77 mm
A B C
0 0 0
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
3 Introdução no nível de perito
 Garra de treinamento Célula modular
Fig. 3-7: Garra de treinamento KR 16
Massa:
M = 4,9 kg
Centro de gravidade da massa:
X = 53 mm Y = 49 mm Z = 65 mm
Orientação:
A = 0° B = 0° C = 0°
Momentos de inércia:
JX = 0,02 kgm
2 JY = 0,03 kgm
2 JZ = 0,15 kgm
2
Fig. 3-8: Garra de treinamento Célula modular
Massa:
M = 5 kg
Centro de gravidade da massa:
X = 23 mm Y = -38 mm Z = 84 mm
Orientação:
A = 0° B = 0° C = 0°
Momentos de inércia:
JX = 0,02 kgm
2 JY = 0,07 kgm
2 JZ = 0,14 kgm
2
71 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
72 / 251
Programação do robô 2
 Garra de treinamento Célula móvel
O que você deve saber agora:
1. Quais são as vantagens da medição de uma base sobre a mesa?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2. Onde está o ponto de referência para a medição de uma ferramenta?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3. Quantos sistemas base diferentes o software KUKA comporta?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4. Qual é a diferença entre os métodos ABC-World 5D e 6D?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5. Onde há uma base não medida (estado de fornecimento)?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fig. 3-9: Garra de treinamento Célula móvel
Massa:
M = 2,14 kg
Centro de gravidade da massa:
X = 30 mm Y = 0 mm Z = 64 mm
Orientação:
A = 0°B = 0° C = 0°
Momentos de inércia:
JX = 0,002 kgm
2 JY = 0,004 kgm
2 JZ = 0,003 kgm
2
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
3 Introdução no nível de perito
3.4 Exercício: Navigator perito loop sem fim
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Criação de módulos no plano de perícia
 Vínculo de determinados módulos em um programa principal
 Uso de um loop sem fim
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos teóricos sobre o Navigator no plano de peritos
 Conhecimentos teóricos sobre o uso de subprogramas globais
 Conhecimentos teóricos sobre um loop sem-fim 
Definição de 
funções
1. Antes do início da programação elabore um fluxograma do programa 
(PAP).
2. Crie dois módulos sensatos (Cubos_dep./Cubos_busc.).
3. O acesso e o loop sem-fim deverão ser realizados no módulo MAGAZINE.
4. Teste o seu programa nos modos de operação T1, T2 e Automático. Aqui 
devem ser observadas as prescrições de segurança ensinadas.
O que você deve saber agora:
1. Na criação de um programa, qual é a diferença entre a seleção MODUL e 
EXPERT?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
2. O que se entende por tipo de execução do programa Passo individual?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
3. Qual a diferença entre SELECIONAR e ABRIR um programa?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
4. Como é a sintaxe para uma "dobra"?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
5. Quais são as consequências de uma alteração posterior da posição HO-
ME?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
73 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
74 / 251
Programação do robô 2
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
4 Variáveis e acordos
4 Variáveis e acordos
4.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Manutenção de dados no KRL
 Tipos de dados simples com KRL
 Exibir variáveis
 Arrays/Campos com KRL
 Estruturas com KRL
 Tipo de dados de enumeração ENUM
4.2 Manutenção de dados no KRL
Dados gerais 
sobre variáveis
 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 
nomes
Na escolha do nome da variável devem ser observadas as seguintes regras:
 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 
duplas de 
variáveis
 Uma declaração dupla ocorre sempre na utilização de nomes de variáveis 
iguais (sequências de caracteres).
 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.
4
 
V
v
s
 
 
Fig. 4-1: Identificação de variáveis
75 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
76 / 251
Programação do robô 2
 Declarações duplas no arquivo *.SCR ou *.DAT e na $CONFIG.DAT são 
permitidas:
 No processo da rotina do programa, no qual a variável foi declarada, 
é alterado somente o valor local e não o valor no $CONFIG.DAT.
 Na execução de uma rotina de programa "estranha" é acessado e al-
terado somente o valor de $CONFIG.DAT.
Tipos de dados 
no KRL
 Tipos de dados pré-definidos
 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
 Campos /Array
 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
 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
 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 
variáveis
Declaração de 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.
Tipos de dados 
simples
Número 
inteiro
Número com 
vírgula 
alterável
Valores 
lógicos
Determin
ado 
caractere
Palavra chave INT REAL BOOL CHAR
Faixa de valores -231 ... 
(231-1)
± 1.1 10-38... ± 
3.4 10+38
TRUE / 
FALSE
Conjunto 
de carac-
teres 
ASCII
Exemplos -199 ou 
56
-0,0000123 ou 
3,1415
TRUE ou 
FALSE
"A" ou "q" 
ou "7"
Voltage[10] = 12.75
Voltage[11] = 15.59
color = #red
Date = {day 14, month 12, year 1996}
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
4 Variáveis e acordos
 a palavra chave DECL pode ser suprimida nos quatro tipos de dados sim-
ples.
 As atribuições de espera ocorrem no avanço.
 a declaração de variável pode ocorrer em diferentes pontos. Isto se reflete 
na vida útil e na validade das respectivas variáveis.
Vida útil e 
validade de 
variáveis
Vida útil de variáveis em KRL
 Por vida útil entende-se um período, no qual está reservado um espaço 
de memóriapara 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áveis em 
dependência do 
local de memória
Variável no *.SRC-File 
 Uma variável que é criada no *.SRC-File chama-se variável de tempo de 
execução.
 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 
KUKA
 Os dados de sistema KUKA ocorrem em todos os tipos de dados, por 
exemplo, como
 tipo de dados de contagem, como p.ex. modo de operação
77 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
78 / 251
Programação do robô 2
 estrutura como, p.ex., data/hora
 Informações de sistema são obtidas das variáveis de sistema KUKA. Es-
tas
 leem as informações de sistema atuais,
 alteram as configurações de sistema atuais,
 são predefinidas e começam com o caractere "$"
 $DATE (horário e data atual)
 $POS_ACT (posição atual do robô)
 $MODE_OP(modo de operação atual)
 ...
4.3 Trabalhar com tipos de dados simples
A seguir é explicada a elaboração, inicialização e a alteração de variáveis. 
Aqui são usados somente tipos de dados simples.
Tipos de dados simples com KRL
 Números inteiros (INT)
 Números de vírgula variável (REAL)
 Valores lógicos (BOOL)
 Caracter individual (CHAR)
4.3.1 Declaração de variáveis
Princípio da 
declaração de 
variáveis
Estrutura de programa no exemplo SRC-File
 Na parte de declaração deverão ser declaradas 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 
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
DEF main( )
; Seção de declaração
...
; Seção de inicialização
INI
...
; Seção de instrução
PTP HOME Vel=100% DEFAULT
...
END
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
4 Variáveis e acordos
Procedimento na 
declaração de 
variáveis com 
tipos de dados 
simples
Criar variável no SRC-File
1. Grupo de usuários Peritos
2. Deixar exibir linha DEF
3. Abrir o SRC-File no Editor
4. Realizar a declaração da variável
5. Fechar e salvar programas
Criar variável no DAT-File
1. Grupo de usuários Peritos
2. Abrir DAT-File no Editor
3. Realizar a declaração da variável
4. Fechar e salvar lista de dados
Criar variável na $CONFIG.DAT
1. Grupo de usuários Peritos
2. Na pasta SYSTEM abrir o $CONFIG.DAT no Editor
3. Selecionar a pasta "USER GLOBALS" e abri-la com o softkey "Abr/Fech 
pasta"
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
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol
...
ENDDAT
DEFDAT $CONFIG
BASISTECH GLOBALS
AUTOEXT GLOBALS
USER GLOBALS
ENDDAT
DEFDAT $CONFIG
...
;==================================
; Userdefined Types 
;==================================
;==================================
; Userdefined Externals 
;==================================
;==================================
; Userdefined Variables 
;==================================
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol
79 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
80 / 251
Programação do robô 2
5. Fechar e salvar lista de dados
Criar variável global no DAT-File
1. Grupo de usuários Peritos
2. Abrir DAT-File no Editor
3. Ampliar a lista de dados no cabeçalho do programa com a palavra-chave 
PUBLIC
4. Realizar a declaração da variável
5. Fechar e salvar lista de dados
4.3.2 Inicialização de variáveis com simples tipos de dados
Descrição da 
inicialização com 
KRL
 Após a declaração uma variável reservou apenas um espaço de memória, 
o seu valor é sempre um valor inválido.
 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
Inicialização de números inteiros
 Inicialização de decimais
 Inicialização como número binário
Cálculo: 1*32+1*16+1*8+0*4+1*2+0*1 = 58
 Inicialização hexadecimal
Cálculo: 3*16 +10 = 58
...
ENDDAT
DEFDAT MY_PROG PUBLIC
DEFDAT MY_PROG PUBLIC
EXTERNAL DECLARATIONS
DECL GLOBAL INT counter
DECL GLOBAL REAL price
DECL GLOBAL BOOL error
DECL GLOBAL CHAR symbol
...
ENDDAT
value = 58
value = 'B111010'
Binário 25 24 23 22 21 20
Dez 32 16 8 4 2 1
value = 'H3A'
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
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
4 Variáveis e acordos
Procedimento na 
inicialização com 
KRL
Declaração e inicialização no SRC-File
1. Abrir o SRC-File no Editor
2. A declaração foi retornada
3. Realizar inicialização
4. Fechar e salvar programas
Declaração e inicialização no DAT-File
1. Abrir DAT-File no Editor
2. A declaração foi retornada
3. Realizar inicialização
4. Fechar e salvar lista de dados
Declaração no DAT-File e inicialização no SRC-File
1. Abrir DAT-File no Editor
2. Realizar declaração
3. Fechar e salvar lista de dados
4. Abrir o SRC-File no Editor
5. 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
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL INT counter = 10
DECL REAL price = 0.0
DECL BOOL error = FALSE
DECL CHAR symbol = "X"
...
ENDDAT
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol
...
ENDDAT
DEF MY_PROG ( )
...
INI
counter = 10
price = 0.0
error = FALSE
symbol = "X"
...END
81 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
82 / 251
Programação do robô 2
6. Fechar e salvar programas
Declaração e 
inicialização de 
uma constante
Descrição
 Constantes são criadas com a palavra chave CONST.
 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.
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 
possibilidades 
para a alteração 
de valores de 
variáveis com 
KRL
Os valores de variáveis são alterados de forma distinta de acordo com a de-
finição de funções nas rotinas de programa (SRC-File) conforme a tarefa. A 
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.
Manipulação de dados através de
 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
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL CONST INT max_size = 99
DECL CONST REAL PI = 3.1415
...
ENDDAT
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
4 Variáveis e acordos
 Função tangente
 Função arco seno
 Função arco tangente
 Diversas funções para a manipulação de strings
Contextos na 
manipulação de 
dados
Modificação de valores usando os tipos de dados REAL e INT
 Arredondar para cima/ para baixo
 Resultados de operações aritméticas (+;-;*)
 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 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)
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
; 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
83 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
84 / 251
Programação do robô 2
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.
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.
Operadores são executados na sequência de suas prioridades
F = W/4 ; F=3 (10.0/4=2.5 -> arredondar para cima)
W = W/4 ; W=2.5
Operador/
KRL
Descrição Tipos de dados admissíveis
== idêntico/igual-
dade
INT, REAL, CHAR, BOOL
<> 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 NOT A A AND B A OR B
A EXOR 
B
A=FALSE B=FALSE TRUE FALSE FALSE FALSE
A=FALSE B=TRUE TRUE FALSE TRUE TRUE
A=TRUE B=FALSE FALSE FALSE TRUE TRUE
A=TRUE B=TRUE FALSE TRUE TRUE FALSE
; Declaração
DECL BOOL K,L,M
; Inicialização/Seção de instrução
K = TRUE
L = NOT K ; L=FALSE
M = (K AND L) OR (K EXOR L) ; M=TRUE
L = NOT (NOT K) ; L=TRUE
Prioridade Operador
1 NOT (B_NOT)
2 Multiplicação (*); Divisão (/)
3 Adição (+), Subtração (-)
4 AND (B_AND)
5 EXOR (B_EXOR)
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
4 Variáveis e acordos
Procedimento na 
manipulação de 
dados
1. Definir tipo de dados para a(s) variável(eis)
2. Calcular a validade e vida útil das variáveis
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.
Exemplo:
4.4 Exibir variáveis
Exibir e alterar o 
valor de uma 
variável
1. No menu principal, selecionar Exibir > Variável > Individual.
Abre-se a janela Display de variáveis - individual.
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.
6 OR (B_OR)
7 qualquer comparação (==; <>; ...)
; Declaração
DECL BOOL X, Y
DECL INT Z
; Inicialização/Seção de instrução
X = TRUE
Z = 4
Y = (4*Z+16 <> 32) AND X ; Y=FALSE
Prioridade Operador
Em um programa Interrupt o programa somente é parado após a exe-
cução completa do avanço.
DEF program()
DECL BOOL a,b
INI
...
SPTP XP1
a=$IN[1]
b=$IN[2]
HALT
IF ((a == TRUE) AND (b == FALSE)) THEN
..
ENDIF
...
85 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
86 / 251
Programação do robô 2
Caso deva ser exibida uma variável de outro programa, introduzir o pro-
grama como a seguir:
/R1/Nome de programa
Não especificar nenhuma pasta entre /R1/ e o nome de programa. Não 
especificar nenhuma extensão de arquivo no nome de programa.
4. Pressionar a tecla Enter.
No campo Valor atual é exibido o valor atual das variáveis. Se nada for 
exibido, ainda não foi atribuído nenhum valor às variáveis.
5. No campo Novo valor digitar o valor desejado.
6. Pressionar a tecla Enter.
No campo Valor atual é exibido o novo valor.
Exibição de infor-
mações do 
sistema
Procedimento para a exibição de flags, contadores e temporizadores:
 No menu principal, selecionar Exibir > Variável.
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.
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
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
4 Variáveis e acordos
4.5 Arrays / Campos com KRL
Descrição de 
campos com KRL
Campos ou também Arrays oferecem espaço de memória para várias variá-
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
 Campo bidimensional
 Campo tridimensional
 Um campo quadridimensional ou superior não é suportado pelo KRL
Contextos no uso 
de campos
A vida útil e a validade de variáveis de campos é igual, como no uso de vari-
áveis de um tipo de dados simples
Declaração de campo
 Criar no SRC_File
 Criação de uma lista de dados (inclusive $CONFIG.DAT)
Declarar e inicializar campo no SRC-File
 Cada campo individualmente com acesso de índice
dimension[4]= TRUE
dimension[2,1]= 3.25
dimension[3,4,1]= 21
DEF MY_PROG ( )
DECL BOOL error[10]
DECL REAL value[50,2]
DECL INT parts[10,10,10]
INI
...
END
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL BOOL error[10]
DECL REAL value[50,2]
DECL INT parts[10,10,10]
...
ENDDAT
DECL BOOL error[10]
INI
error[1]=FALSE
error[2]=FALSE
error[3]=FALSE
error[3]=FALSE
error[4]=FALSE
error[5]=FALSE
87 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
88 / 251
Programação do robô 2
 Com loops adequados
Inicializar o campo na lista de dados
 Cada campo individualmente com acesso de índice e posterior exibição 
de valor na lista de dados
 Declaração não permitida e inicialização na lista de dados 
error[6]=FALSE
error[7]=FALSE
error[8]=FALSE
error[9]=FALSE
error[10]=FALSE
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
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL BOOL error[10]
error[1]=FALSE
error[2]=FALSE
error[3]=FALSE
error[4]=FALSE
error[5]=FALSE
error[6]=FALSE
error[7]=FALSE
error[8]=FALSE
error[9]=FALSE
error[10]=FALSE
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL BOOL error[10]
DECL INT size = 32
error[1]=FALSE
error[2]=FALSE
error[3]=FALSE
error[4]=FALSE
error[5]=FALSE
error[6]=FALSE
error[7]=FALSE
error[8]=FALSE
error[9]=FALSE
error[10]=FALSE
Gera dez mensagens de erro "Passo de valor inicial não está na se-
ção inicial"
O campo completo pode ser exibido quando no menu principal se se-
leciona Display > Variável > Individual e no campo Nome se intro-
duz o nome da variável com colchetes sem Index (p.ex. error[]) 
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
4 Variáveis e acordos
Declarar campos na lista de dados e inicializar no SRC-File
 Se um campo for criado deste modo na lista de dados, os valores atuais 
não podem ser lidos na lista de dados; os valores atuais podem ser veri-
ficados somente com a exibição de variáveis.
ou 
Inicialização através de loops 
 Campo unidimensional
 Campo bidimensional
 Campo tridimensional
Procedimento na 
programação de 
Arrays
1. Definir tipos de dados para o campo
2. Calcular a validade e vida útil do campo
3. Realizar declaração de campo (SRC ou DAT, aqui SRC)
4. Inicializar elementos de campo
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL BOOL error[10]
DEF MY_PROG ( )
INI
 error[1]=FALSE
 error[2]=FALSE
 error[3]=FALSE
...
error[10]=FALSE
DEF MY_PROG ( )
INI
FOR x = 1 TO 10
 error[x]=FALSE
ENDFOR
DECL INT parts[15]
DECL INT x
FOR x = 1 TO 15
 parts[x]= 4
ENDFOR
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
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
89 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
90 / 251
Programação do robô 2
5. Nas rotinas de programa, isto é, manipular o campo sempre no arquivo 
SRC
6. Fechar e salvar SRC-File
DEF MY_PROG ( )
DECL REAL palette_size[10]
DECL INT counter
INI
; Inicialização
FOR counter = 1 TO 10
 palette_size[counter] = counter * 1.5
ENDFOR
...
; Alterar o valor individualmente
palette_size[8] = 13
...
; Comparação de valores
IF palette_size[3] > 4.2 THEN
...
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
4 Variáveis e acordos
4.6 Exercício: Campos com tipos de dados simples e loop de contagem
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Declarar e inicializar campos com tipos de dados simples
 Editar elementos individuais de campo
 Trabalhar com a exibição de variáveis (configuração/exibição) 
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos sobre tipos de dados simples 
 Conhecimentos teóricos sobre campos 
 Conhecimentos teóricos sobre loop FOR 
 Conhecimentos teóricos sobre a exibição da variável
Definição de 
funções
Amplie os seus programas criados com o seguinte:
 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. 
 Defina, onde as suas variáveis são declaradas. 
 Amplie o seu fluxograma do programa existente, incluindo esse campo. 
 Crie um novo grupo para a exibição das variáveis de campo necessárias. 
 Teste o seu programa nos modos de operação T1, T2 e Automático. Aqui 
devem ser observadas as prescrições de segurança ensinadas. 
O que você deve saber agora:
1. Onde o tamanho de um campo é dimensionado? 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
Fig. 4-3
91 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
92 / 251
Programação do robô 2
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2. Qual é a diferença da declaração de um campo no SRC-File e no DAT-File?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3. Qual mensagem de erro é exibida ao ultrapassar o index de campo?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4. Declare um campo tridimensional com o nome preço do armário. O preço 
do armário é calculado com os componentes comprimento, largura e profun-
didade. A gama abrange 5 comprimentos diferentes, 3 larguras diferentes e 
duas profundidades diferentes? 
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5. Como o campo Preço do armário (Schrankpreis) acima é exibido de forma 
completa?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
4 Variáveis e acordos
4.7 Estruturas com KRL
Variáveis com 
diversas infor-
mações indivi-
duais
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 tiposde 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.
 Uma estrutura primeiro precisa ser definida, depois pode ser reutilizada.
Uso de uma 
estrutura
Disponibilidade/definição de uma 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.
 Em uma estrutura também podem ser usadas estruturas conhecidas, 
como uma posição POS.
 Após a definição da estrutura é necessário declarar uma variável de tra-
balho para isto
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.
Fig. 4-4
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition, CHAR 
car_model[15]
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition, POS car_pos
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition
DECL CAR_TYPE my_car
my_car = {motor 50, price 14999.95, air_condition TRUE}
93 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
94 / 251
Programação do robô 2
 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.
 A inicialização também pode ser feita com separador de ponto.
 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.
Porém:
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)
 A inicialização também poderá ser realizada com o separador de ponto
 Na inicialização com o separador de ponto também podem ser usadas va-
riáveis
my_car = {price 14999.95, motor 50, air_condition TRUE}
my_car = {motor 75} ; Valor desconhecido para preço e ar 
condicionado
my_car.price = 9999.0
my_car = {price 14999.95, motor 50, air_condition TRUE}
my_car.price = 12000.0 ; Os valores para motor e ar condicionado são 
mantidos
my_car = {price 14999.95, motor 50, air_condition TRUE}
my_car = {price 12000.0} ; Os valores para motor e ar condicionado 
são excluídos
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition, POS car_pos
DECL CAR_TYPE my_car
my_car = {price 14999.95, motor 50, air_condition TRUE, car_pos {X 
1000, Y 500, A 0}}
my_car.price = 14999.95
my_car.motor = 50
my_car.air_condition = TRUE
my_car.car_pos = {X 1000, Y 500, A 0}
my_car.price = my_price*0.85
my_car.car_pos.X = x_value
my_car.car_pos.Y = 750+y_value
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
4 Variáveis e acordos
Criação de uma 
estrutura
1. Definição da estrutura
2. Declaração das variáveis de trabalho
3. Inicialização das variáveis de trabalho
4. Modificação dos valores e/ou comparação de valores das variáveis de tra-
balho
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition
DECL CAR_TYPE my_car
my_car = {motor 50, price 14999.95, air_condition TRUE}
my_car.price = 5000.0
my_car.price = value_car
IF my_car.price >= 20000.0 THEN
...
ENDIF
95 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
96 / 251
Programação do robô 2
4.8 Exercício: Criar estruturas com KRL
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Geração de estruturas próprias (declaração, inicialização) 
 Trabalhar com o separador de pontos
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos teóricos sobre tipos de dados e estruturas simples 
Definição de 
tarefas
Crie um programa com o nome Estrutura.
 Gere uma estrutura com o nome BOX_Typ. Nessa estrutura deverão ser 
depositados os seguintes valores característicos:
 Comprimento
 Largura
 Altura
 Estado da esmaltagem (sim/não)
 Número de garrafas 
 Atribua à variável KISTE (CAIXA) a estrutura BOX_Typ e inicialize com os 
seguintes valores de início:
 Comprimento 25,2
 Largura 18,5
 Altura 5,0 
 Conteúdo: 4 garrafas 
 Não esmaltado
 No primeiro processo de usinagem ainda serão acrescentadas 8 garrafas. 
No 2º passo a KISTE (CAIXA) será ainda pintada. Entre o passo um e dois 
programe um período de espera de 3 segundos.
 Solicite a exibição do conteúdo da variável KISTE (CAIXA) durante o pro-
cedimento. 
 Defina, onde as suas variáveis são declaradas. 
 Amplie o seu fluxograma do programa existente, incluindo essa estrutura. 
 Crie um novo grupo para a exibição das variáveis de campo necessárias. 
 Teste o seu programa nos modos de operação T1, T2 e Automático. Aqui 
devem ser observadas as prescrições de segurança ensinadas. 
O que você deve saber agora:
1. O que é uma estrutura?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2. Que estruturas KUKA pré-definidas existem?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3. Qual é a diferença entre uma estrutura POS e uma estrutura E6POS?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4. Nomeie uma estrutura FRAME que você já conhece. 
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
4 Variáveis e acordos
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
5. Para que precisamos do separador de ponto?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
97 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
98 / 251
Programação do robô 2
4.9 O tipo de dados de enumeração ENUM
Texto inequívoco 
como valor de 
variável
 O tipo de dados de enumeração consiste de uma quantidade limitada de 
constantes como verde, amarelo ou azul
 As constantes são nomes livrementeselecioná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 
dados de enume-
ração
Disponibilidade / Uso
 Somente constantes conhecidas podem ser usadas
 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 
 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 
tipo de dados de 
enumeração
1. Definição das variáveis de enumeração e das constantes
2. Declaração das variáveis de trabalho
3. Inicialização das variáveis de trabalho
4. Comparação de valores das variáveis de trabalho
Fig. 4-5
ENUM COLOR_TYPE green, blue, red, yellow
ENUM COLOR_TYPE green, blue, red, yellow
ENUM COLOR_TYPE green, blue, red, yellow
STRUC CAR_TYPE INT motor, REAL price, COLOR_TYPE car_color
ENUM LAND_TYPE de, be, cn, fr, es, br, us, ch
DECL LAND_TYPE my_land
my_land = #be
IF my_land == #es THEN
...
ENDIF
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
4 Variáveis e acordos
4.10 Exercício: Criar tipo de enumeração com KRL
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Gerar variáveis ENUM próprias (declaração) 
 Trabalhar com variáveis ENUM
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos teóricos sobre tipos de dados e estruturas simples 
 Conhecimentos teóricos sobre variáveis ENUM simples 
Definição de 
funções
Amplie a sua estrutura de programa com o seguinte:
1. Gere uma variável ENUM cujo conteúdo inclua as cores vermelho, ama-
relo, verde e azul. 
2. Crie uma variável Lâmpada, à qual você atribui a cor azul.
3. No segundo passo, atribua à lâmpada a cor amarela. 
4. Amplie a sua estrutura BOX_Typ com o agregado cor e atribua à KISTE 
(CAIXA) no início a cor vermelha, depois amarela e no final a cor verde.
5. Exiba o conteúdo da variável KISTE (CAIXA) durante o procedimento. 
O que você deve saber agora:
1. Quem define a quantidade e os nomes das constantes no tipo de enume-
ração ENUM? 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
2. Quando é usado o símbolo "#"?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
3. O que está errado na seguinte geração? 
ENUM Tag_typ mo, di, mi, do, fr, sa, so
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
99 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
100 / 251
Programação do robô 2
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
5 Subprogramas e funções
5 Subprogramas e funções
5.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Subprogramas locais
 Subprogramas globais
 Transferência de parâmetros a subprogramas
 Programação de funções
5.2 Trabalhar com subprogramas locais
Definição de 
subprogramas 
locais
 Subprogramas locais estão após o programa principal e são caracteriza-
dos com DEF Nome_Subprograma( ) e 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 
trabalho com 
subprogramas 
locais
 Após o processamento de um subprograma local é realizado o retorno no 
próximo comando na chamada do subprograma
 
s
 
DEF MY_PROG( )
; este é o programa principal
...
END
_______________________________________
DEF LOCAL_PROG1( )
; este é o subprograma local 1
...
END
_______________________________________
DEF LOCAL_PROG2( )
; este é o subprograma local 2
...
END
_______________________________________
DEF LOCAL_PROG3( )
; este é o subprograma local 3
...
END
DEF MY_PROG( )
; este é o programa principal
...
LOCAL_PROG1( )
...
END
_______________________________________
DEF LOCAL_PROG1( )
...
LOCAL_PROG2( )
...
END
_______________________________________
DEF LOCAL_PROG2( )
...
END
101 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
102 / 251
Programação do robô 2
 Podem ser colocados no máx. 20 subprogramas em cascata
 Coordenadas de pontos são salvas na respectiva lista DAT e estão dispo-
níveis para o programa completo (*.src)
 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().
Procedimento ao 
criar subpro-
gramas locais
1. Grupo de usuários Peritos
2. Abrir o SRC-File no Editor
3. Deixar exibir linha DEF
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
6. Concluir novo subprograma com um comando END
DEF MY_PROG( )
; este é o programa principal
...
SPTP P1 Vel=100% PDAT1
...
END
_______________________________________
DEF LOCAL_PROG1( )
...
; esta é a mesma posição que no programa principal
SPTP P1 Vel=100% PDAT1
...
END
DEFDAT MY_PROG
...
DECL E6POS XP1={X 100, Y 200, Z 300 ... E6 0.0}
...
ENDDAT
DEF MY_PROG( )
; este é o programa principal
...
LOCAL_PROG1( )
...
END
_______________________________________
DEF LOCAL_PROG1( )
...
IF $IN[12]==FALSE THEN
RETURN ; retorno ao programa principal
ENDIF
...
END
DEF MY_PROG( )
...
END
DEF MY_PROG( )
...
END
DEF PICK_PART( )
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
5 Subprogramas e funções
7. Após acionar retorno, é inserida uma barra transversal entre programa 
principal e subprograma
8. Programa principal e subprograma podem agora ser processados
9. Fechar e salvar programas
5.3 Trabalhar com subprogramas globais
Definição de 
subprogramas 
globais
 Subprogramas globais têm arquivos SRC e DAT próprios
 Subprogramas globais podem ser acessados diversas vezes
Contextos no 
trabalho com 
subprogramas 
locais
 Após o processamento de um subprograma local é realizado o retorno no 
próximo comando na chamada do subprograma
 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 MY_PROG( )
...
END
DEF PICK_PART( )
END
DEF MY_PROG( )
...
END
_______________________________________
DEF PICK_PART( )
END
DEF GLOBAL1( )
...
END
DEF GLOBAL2( )
...
END
DEF GLOBAL1( )
...
GLOBAL2( )
...
END
DEF GLOBAL2( )
...
GLOBAL3( )
...
END
DEF GLOBAL3( )
...
END
103 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
104 / 251
Programação do robô 2
Diferentes coordenadas para P1 no Global2 ( )
 Com RETURN pode ser finalizado um subprograma, o que causa um re-
torno ao componente de programa acessado, no exemplo após 
GLOBAL2().
Procedimento na 
programação 
com subpro-
gramas globais
1. Grupo de usuários Peritos
2. Criar novo programa
3. Recriar o segundo programa
4. Abrir o arquivo SRC do programa MY_PROG no Editor
5. Programar o acessodo subprograma com nome de programa e colchetes
DEF GLOBAL1( )
...
SPTP P1 Vel=100% PDAT1
END
DEFDAT GLOBAL1( )
DECL E6POS XP1={X 100, Z 200, Z 300 ... E6 0.0}
ENDDAT
DEF GLOBAL2( )
...
SPTP P1 Vel=100% PDAT1
END
DEFDAT GLOBAL2( )
DECL E6POS XP1={X 800, Z 775, Z 999 ... E6 0.0}
ENDDAT
DEF GLOBAL1( )
...
GLOBAL2( )
...
END
DEF GLOBAL2( )
...
IF $IN[12]==FALSE THEN
RETURN ; Retorno ao GLOBAL1( )
ENDIF
...
END
DEF MY_PROG( )
...
END
DEF PICK_PART( )
...
END
DEF MY_PROG( )
...
PICK_PART( )
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
5 Subprogramas e funções
6. Fechar e salvar programas
5.4 Transmitir parâmetros a subprogramas
Descrição da 
transferência de 
parâmetros
 Sintaxe
 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
 Transferência de parâmetros como parâmetro IN (Call by value):
 o valor da variável permanece inalterado no programa principal, isto 
é, 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
 Transferência de parâmetros a subprogramas globais
...
END
DEF MY_PROG( ) 
...
CALC (K, L)
...
END
DEF CALC(R:IN, S:OUT) ; Possibilidade de transferência como IN/OUT-
Parâmetro
...
END
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
DEF MY_PROG( )
DECL REAL r, s
...
CALC_1(r)
...
CALC_2(s)
105 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
106 / 251
Programação do robô 2
 Transferência de valores ao mesmo tipo de dados é sempre possível
 Transferência de valores a outros tipos de dados:
 Transferência de diversos parâmetros
...
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
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, 
CHAR
ERRO ( ... Parâmetro incompatível)
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
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
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
5 Subprogramas e funções
 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)
 Respectivos elementos de campo também podem ser transferidos
Procedimento na 
transferência de 
parâmetros
Considerações
1. Definir quais parâmetros são necessários no subprograma
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
Não é possível transferir valores, se no subprograma também é cal-
culado sem esses valores. Exemplo: RECHNE(w,, a)
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)
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.
A observar: primeiro parâmetro enviado é escrito no primeiro parâ-
metro no subprograma, o segundo no segundo parâmetro no subpro-
grama etc.
107 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
108 / 251
Programação do robô 2
Procedimento
1. Carregar um programa principal no editor
2. No programa principal, declarar, inicializar e possivelmente manipular va-
riáveis
3. Criar acesso de subprograma com transferência de variável
4. Fechar e salvar o programa principal
5. Carregar um subprograma no editor
6. Complementar linha DEFcom variáveis e IN/OUT
7. No subprograma, declarar, inicializar e possivelmente manipular variáveis
8. Fechar e salvar o subprograma
Exemplo completo:
DEF MY_PROG( )
DECL REAL w
DECL INT a, b
w = 1.5
a = 3
b = 5
CALC(w, b, a)
; valores atuais
; w = 3.8
; a = 13
; b = 5
END
_______________________________________
DEF CALC(ww:OUT, bb:IN, aa:OUT)
; w <-> ww, b -> bb, a <-> aa
DECL REAL ww
DECL INT aa, bb
ww = ww + 2.3 ; ww = 1.5 + 2.3 =3.8 ->w 
bb = bb + 5 ; bb = 5 + 5 = 10 
aa = bb + aa ; aa = 10 + 3= 13 -> a
END
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
5 Subprogramas e funções
5.5 Exercício: Subprogramas com transferência de parâmetros
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Técnica de subprogramas com transferência de parâmetros 
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos sobre técnica de subprograma 
 Conhecimentos teóricos sobre a transferência de parâmetros
 Conhecimentos teóricos sobre funções 
Definição de 
funções
Definição de tarefas: complete os resultados após o término dos programas.
O que você deve saber agora:
1. Quantos subprogramas podem ser encadeados? 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
2. Qual DAT-File é acessado por um subprograma local?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
3. Onde é declarada uma variável que deverá ser conhecida no subprograma 
global e no programa principal?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
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
109 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
110 / 251
Programação do robô 2
4. Na transmissão de parâmetros, qual é a diferença entre "Parâmetro IN" e 
"Parâmetro OUT"? 
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
5 Subprogramas e funções
5.6 Programação de funções
Definição de 
funções com KRL
 Uma função é um subprograma que retorna um determinado valor ao pro-
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:
Princípio de 
funções com KRL
 O nome do programa é ao mesmo tempo o nome da variável de um de-
terminado tipo de dados
 Acesso a uma função global
 Acesso a uma função local
 Uso de parâmetros IN/OUT na transferência de valores
 Transferência de valores como parâmetros IN
DEFFCT DATATYPE NAME_FUNCTION( )
...
RETURN(return_value)
ENDFCT
DEF MY_PROG( )
DECL REAL result, value
INI
...
result = CALC(value)
...
END
DEFFCT REAL CALC(num:IN)
DECL REAL return_value, num
...
RETURN(return_value)
ENDFCT
A instrução RETURN(return_value) deve ocorrer antes da instru-
ção ENDFCT.
DEF MY_PROG( )
DECL REAL result, value
INI
...
result = CALC(value)
...
END
_______________________________________
DEFFCT REAL CALC(num:IN)
DECL REAL return_value, num
...
RETURN(return_value)
ENDFCT
DEF MY_PROG( )
DECL REAL result, value
INI
111 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
112 / 251
Programação do robô 2
 Transferência de valores como parâmetro OUT
Procedimento na 
programação de 
funções
1. Definir qual valor a função deve fornecer (tipo de dados de retorno)
2. Definir quais parâmetros são necessários na função (tipos de dados de 
transferência)
3. Determinar tipo de transferência de parâmetros (parâmetros IN ou OUT)
4. Determinar se é necessária uma função local ou global
5. Carregar um programa principal no editor
6. No programa principal, declarar, inicializar e possivelmente manipular va-
riáveis
7. Criar acesso de função
8. Fechar e salvar o programa principal
9. Criar função (global ou local)
10. Carregar uma função no editor
11. Complementar linha DEFFCTcom tipo de dados, variáveis e IN/OUT
12. Na função, declarar, inicializar e manipular variáveis
13. Criar linhaRETURN(return_value)
value = 2.0
result = CALC(value)
; value = 2.0
; result = 1000.0
END
DEFFCT REAL CALC(num:IN)
DECL REAL return_value, num
num = num + 8.0
return_value = num * 100.0
RETURN(return_value)
ENDFCT
O valor de transferência value não é alterado.
DEF MY_PROG( )
DECL REAL result, value
INI
value = 2.0
result = CALC(value)
; value = 10.0
; result = 1000.0
END
DEFFCT REAL CALC(num:OUT)
DECL REAL return_value, num
num = num + 8.0
return_value = num * 100.0
RETURN(return_value)
ENDFCT
O valor de transferência value é retornado alterado.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
5 Subprogramas e funções
14. Fechar e salvar a função
5.7 Trabalhar com funções padrão KUKA
Listagem das 
funções padrão 
KUKA
Funções matemáticas:
Funções para variável string:
Funções para a emissão de mensagens:
Princípio no uso 
de funções 
padrão KUKA
Cada função é acessada com parâmetros de transferência:
 Com valores fixos
 Variáveis de tipos de dados simples
 Variáveis consistem dos campos
 Variáveis consistem dos tipos de dados de enumeração
 Variáveis consistem de estruturas
 Com diversas variáveis distintas
Descrição Função KRL
Montante ABS(x)
Raiz SQRT(x)
Seno SIN(x)
Coseno COS(x)
Tangente TAN(x)
Arco coseno ACOS(x)
Arco tangente ATAN2(y,x)
Descrição Função KRL
Levantamento do comprimento string na decla-
ração
StrDeclLen(x)
Comprimento de uma variável string após a ini-
cialização
StrLen(x)
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)
Descrição Função KRL
Emitir mensagem Set_KrlMsg(a,b,c,d)
Emitir diálogo Set_KrlDLg(a,b,c,d)
Verificar mensagem Exists_KrlMsg(a)
Verificar diálogo Exists_KrlDlg(a,b)
Excluir mensagem Clear_KrlMsg(a)
Ler memória intermediária de mensagem Get_MsgBuffer(a)
result = SQRT(16)
result = SQRT(x)
result = StrClear(Name[])
result = Set_KrlMsg(#QUIT, message_parameter, parameter[], option)
113 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
114 / 251
Programação do robô 2
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 
 Funções de mensagem devolvem valores BOOL ou INT
message_parameter, parameter[1...3] e option são estruturas 
KUKA predefinidas
; Exclusão de um string
result = StrClear(Name[])
; Exclusão de uma mensagem (BOOL: excluído?)
result = Clear_KrlMsg(Valor de retorno)
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
6 Programação de mensagens com KRL
6 Programação de mensagens com KRL
6.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Generalidades sobre mensagens definidas pelo usuário
 Variáveis e estruturas em mensagens definidas pelo usuário
 Funções em mensagens definidas pelo usuário
 Trabalhar com mensagens de informação
 Trabalhar com mensagens de estado
 Trabalhar com mensagens de confirmação
 Trabalhar com mensagens de espera
 Variáveis e estruturas adicionais em diálogos
 Funções em diálogos
 Trabalhar com diálogos
6.2 Generalidades sobre mensagens definidas pelo usuário
Propriedades da programação de mensagens
 Com KRL o programador pode programas mensagens próprias.
 É possível emitir várias mensagens simultaneamente.
 Mensagens emitidas encontram-se em um buffer de mensagens, até que 
sejam novamente excluídas.
 As mensagens de informação não são administradas no buffer de mensa-
gens. (Princípio "fire and forget").
 Mensagens podem ser testadas e excluídas de forma simples, já as men-
sagens de informação não. 
 Em cada mensagem podem ser integrados até 3 parâmetros.
Na janela de mensagens da KUKA.HMI é exibido um ícone para cada men-
sagem. Os ícones estão atribuídos fixamente aos tipos de mensagem e não 
podem ser alterados pelo programador.
Podem ser programados os seguintes tipos de mensagem:
 
 
Ícone Tipo
Mensagem de confirmação
Mensagem de estado
Mensagem de informação
Mensagem de espera
Mensagem de diálogo (é exibida em uma janela POP-UP 
própria)
115 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
116 / 251
Programação do robô 2
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
 do exemplo
 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) 
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.
STRUC KrlMsg_T CHAR Modul[24], INT Nr, CHAR Msg_txt[80]
DECL KrlMsg_T mymessage
mymessage = {Modul[ ] "College", Nr 1906, Msg_txt[ ] "My first 
Message"}
...
INT result
INI
...
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
6 Programação de mensagens com KRL
Alternativa:
 O texto é exibido na segunda linha da mensagem.
Selecionar o tipo 
de mensagem 
 Tipo de dados de enumeração EKrlMsgType
 #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 
de mensagem
Em um texto de mensagem deve ser exibido o valor de uma variável. Por 
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:
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"
result = StrClear(My_Message.Msg_txt[])
...
...
INT X
INI
FOR x=1 TO 80...
 My_Message.Msg_txt[x] = " "
ENDFOR
...
ENUM EKrlMsgType Notify, State, Quit, Waiting
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
DECL KrlMsgPar_T Parameter[3] ; Criar 3 conjuntos de parâmetros
...
Parameter[1] = {Par_Type #VALUE, Par_txt[ ] "Finisher"}
117 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
118 / 251
Programação do robô 2
Emissão de mensagem: Defeito no Finisher
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"
Emissão de mensagem: Faltam 13 componentes
Estrutura para 
opções gerais de 
mensagens
Na emissão de uma mensagem são transmitidas mais 4 opções de mensa-
gens. Com estas opções podem ser influenciados o avanço, a exclusão de 
mensagens e o registro no banco de dados log.
 estrutura KUKA predefinida: KrlMsgOpt_T
 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
 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
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
...
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.
DECL KrlMsgPar_T Parameter[3] ; Criar 3 conjuntos de parâmetros
DECL INT missing_part
...
missing_part = 13
...
Parameter[1] = {Par_Type #VALUE}
Parameter[1].Par_Int = missing_part
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
...
STRUC KrlMsgOpt_T BOOL VL_Stop, BOOL Clear_P_Reset, BOOL Clear_SAW, 
BOOL Log_To_DB
As mensagens de informação podem ser excluídas somente através 
das barras de comutação OK ou Todos OK.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
6 Programação de mensagens com KRL
 TRUE faz com que esta mensagem seja logada no banco de dados 
log. 
 Padrão: FALSE
6.4 Funções em mensagens definidas pelo usuário
Setar ou emitir 
uma mensagem
Com esta função é emitida uma mensagem no programa KRL. Isto significa, 
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
 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.
 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.
Verificar uma 
mensagem
Com esta função pode ser verificado, se uma determinada mensagem com 
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 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
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.
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. 
119 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
120 / 251
Programação do robô 2
 nHandle: O handle disponibilizado pela função "Set_KrlMsg(…)" para 
a mensagem
 Valor de retorno da função:
 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 
mensagem
Com esta função pode ser excluída uma mensagem. Isto significa que a res-
pectiva mensagem é excluída no buffer de mensagens interno.
 Funções build-in para a verificação de uma mensagem
 nHandle: O handle disponibilizado pela função "Set_KrlMsg(…)" para 
a mensagem
 Valor de retorno da função:
 eraser == TRUE: Esta mensagem pôde ser excluída
 eraser == FALSE: Esta mensagem não pôde ser excluída
DEFFCT BOOL Exists_KrlMsg(nHandle:IN)
DECL INT nHandle
DEF MyProg( )
DECL INT handle
DECL BOOL present
...
handle = Set_KrlMsg(Type, MyMessage, Parameter[ ], Option)
...
present= Exists_KrlMsg(handle)
DEFFCT BOOL Clear_KrlMsg(nHandle:IN)
DECL INT nHandle
DEF MyProg( )
DECL INT handle
DECL BOOL erase
...
handle = Set_KrlMsg(Type, MyMessage, Parameter[ ], Option)
...
eraser = Clear_KrlMsg(handle)
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.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
6 Programação de mensagens com KRL
6.5 Trabalhar com uma mensagem de informação
Descrição de uma 
mensagem de 
informação 
definida pelo 
usuário
 As mensagens de informação não são administradas no buffer de mensa-
gens.
 As mensagens de informação só podem ser novamente excluídas através 
das barras de comutação OK ou Todos OK.
Função de uma 
mensagem de 
informação 
definida pelo 
usuário
 Mensagens de informação são apropriadas, para exibir informações ge-
rais. 
 Uma mensagem de informação somente é criada. Eventualmente verifi-
ca-se, se a mensagem chegou com sucesso.
 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 
mensagens de 
informação 
definidas pelo 
usuário
1. Carregar um programa principal no editor
2. Declarar variáveis de trabalho para:
 remetente, número da mensagem, texto de mensagem (de 
KrlMsg_T)
 campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
3. Iniciar variáveis de trabalho com os valores desejados
4. Programar o acesso de função Set_KrlMsg(…)
5. Se necessário, avaliar "handle", para determinar se a emissão teve êxito
6. Fechar e salvar o programa principal
Exemplo de programação para a exibição acima:
Fig. 6-1: Mensagem de informação
Fig. 6-2: Mensagem de informação
DECL KRLMSG_T mymessage
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGOPT_T Option
DECL INT handle
...
mymessage={modul[] "College", Nr 1906, msg_txt[] "My first Message"}
Option={VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, 
Log_to_DB TRUE} 
;Dummies[1..3] estão vazios
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
121 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
122 / 251
Programação do robô 2
handle = Set_KrlMsg(#NOTIFY, mymessage, Parameter[ ], Option)
...
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
6 Programação de mensagens com KRL
6.6 Exercício: Programar mensagem de informação
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Programar mensagens de informação próprias
 Emitir parâmetros quaisquer em mensagens
Pré-requisitos Os seguintes requisitos são necessários para realizar o exercício com êxito.
 Conhecimentos da linguagem de programação KRL 
 Conhecimentos teóricos sobre a programação de mensagens 
Definição de 
funções
Tarefa parcial 1: mensagem de informação
1. Crie uma mensagem de informação com o texto "Programa Magazine foi 
iniciado". 
2. Tão logo o programa tenha sido iniciado, a mensagem de informação 
deve ser exibida apenas uma vez. 
3. Teste o seu programa conforme a prescrição.
Tarefa parcial 2: Mensagem de informação com parâmetros
1. Crie uma mensagem de informação com o texto "Cubo número xxx trans-
portado". 
2. Amplie o programa Magazine com um contador de unidades para os 
cubos transportados. Após a devolução ao magazine de cubos, aumente 
a quantidade e exiba a mesma. 
3. Teste o seu programa conforme a prescrição.
O que você deveria saber agora::
1. Como é excluída novamente uma mensagem de informação? 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
2. Qual parte integrante da estrutura de mensagens é responsável pelo "dis-
paro" do texto de mensagem?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
123 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
124 / 251
Programação do robô 2
6.7 Trabalhar com uma mensagem de estado
Descrição de uma 
mensagem de 
estado definida 
pelo usuário
 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 
mensagem de 
estado definida 
pelo usuário
 As mensagens de estado são apropriadas para exibir a alteração de um 
estado (p.ex. a supressão de uma entrada).
 O programa, por exemplo, é retido até que não exista mais o estado de-
sencadeador.
 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 
mensagens de 
estado definidas 
pelo usuário
1. Carregar um programa principal no editor
2. Declarar variáveis de trabalho para:
 remetente, número da mensagem, texto de mensagem (de 
KrlMsg_T)
 campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
 variável para o resultado do teste (como BOOL)
 variável para o resultado da exclusão (como BOOL)
3. Iniciar variáveis de trabalho com os valores desejados
4. Programar o acesso de função Set_KrlMsg(…)
5. Parar o programa com um loop, até que o estado desencadeador deixe 
de existir
6. Excluir a mensagem de estado com o acesso de função Clear_KrlMsg( 
)
7. Fechar e salvar o programa principal
Fig. 6-3: Mensagem de estado
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.
Fig. 6-4: Mensagem de estado
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
6 Programação de mensagens com KRL
Exemplo de programação para a exibição/mensagem acima:
A mensagem de estado é gerada através do estado entrada 12 (FALSE). O 
programa é parado após a emissão da mensagem. A mensagem é excluída 
através do estado entrada 17 (TRUE). Depois disto é dada continuidade no 
programa. 
Da mesma forma a mensagem é excluída ao dar um reset no programa ou ao 
fechar o programa. Isto ocorre através do ajuste nas opções de mensagens 
Clear_P_Reset TRUE.
DECL KRLMSG_T mymessage
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGOPT_T Option
DECL INT handle
DECL BOOL present, eraser
...
IF $IN[12]==FALSE THEN
mymessage={modul[] "College", Nr 1909, msg_txt[] "My Messagetext"}
Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, 
Log_to_DB TRUE} 
;Dummies[1..3]estão vazios
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
handle = Set_KrlMsg(#STATE, mymessage, Parameter[ ], Option)
ENDIF
eraser=FALSE
;Loop para parar até que esta mensagem tenha sido excluída
REPEAT
IF $IN[12]==TRUE THEN
eraser=Clear_KrlMsg(handle) ;Excluir mensagem
ENDIF
present=Exists_KrlMsg(handle) ;controle adicional
UNTIL NOT(present) or eraser
125 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
126 / 251
Programação do robô 2
6.8 Exercício: Programar mensagem de estado
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Programar mensagens de estado próprias 
 Emitir parâmetros quaisquer em mensagens 
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos da linguagem de programação KRL 
 Conhecimentos teóricos sobre a programação de mensagens 
Definição de 
funções
Tarefa parcial: Mensagem de estado
1. Crie uma mensagem de estado com o texto "Programa de cubos em exe-
cução". 
2. Antes que seja iniciado o loop sem fim, deve ser exibida a mensagem de 
estado.
3. Através da entrada 16 no console de operação deve-se sair do loop sem 
fim e esta mensagem de estado deve ser então excluída. 
4. Teste o seu programa conforme a prescrição. 
O que você deve saber agora:
1. O que significa %2 no texto de mensagem? 
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
6 Programação de mensagens com KRL
6.9 Trabalhando com uma mensagem de confirmação
Descrição de uma 
mensagem de 
confirmação 
definida pelo 
usuário
 As mensagens de confirmação são administradas no buffer de mensa-
gens.
 As mensagens de confirmação podem ser novamente excluídas através 
das barras de comutação OK ou Todos OK.
Função de uma 
mensagem de 
confirmação 
definida pelo 
usuário
 As mensagens de confirmação são apropriadas para exibir informações, 
que o usuário precisar tomar conhecimento.
 O programa será retido, por exemplo, até que a mensagem tenha sido 
confirmada.
 São administradas, no máximo, 100 mensagens no buffer de mensagens.
 Na mensagem de confirmação (ao contrário da mensagem de informa-
ção) pode ser verificado, se o usuário a confirmou ou não.
 As mensagens de confirmação também podem ser excluídas através de 
uma função no programa.
 As mensagens de confirmação também podem ser excluídas da mesma 
forma através dos ajustes nas opções de mensagens no reset do progra-
ma ou ao fechar o programa ou uma seleção de passo.
Programação de 
mensagens de 
confirmação 
definidas pelo 
usuário
1. Carregar um programa principal no editor.
2. Declarar variáveis de trabalho para:
 remetente, número da mensagem, texto de mensagem (de 
KrlMsg_T)
 campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
 variável para o resultado do teste (como BOOL)
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-5: Mensagem de confirmação
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.
127 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
128 / 251
Programação do robô 2
Exemplo de programação para a exibição/mensagem acima:
O programa é parado após a emissão da mensagem. A mensagem é excluída 
através do pressionamento do botão OK ou Todos OK. Depois disto é dada 
continuidade no programa. 
Da mesma forma a mensagem é excluída ao dar um reset no programa ou ao 
fechar o programa. Isto ocorre através do ajuste nas opções de mensagens 
Clear_P_Reset TRUE.
Fig. 6-6: Mensagem de confirmação
DECL KRLMSG_T mymessage
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGOPT_T Option
DECL INT handle
DECL BOOL present
...
mymessage={modul[] "College", Nr 1909, msg_txt[] "My Messagetext"}
Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, 
Log_to_DB TRUE} 
;Dummies[1..3] estão vazios
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
handle = Set_KrlMsg(#QUIT, mymessage, Parameter[ ], Option)
;Loop para parar até que esta mensagem tenha sido excluída
REPEAT
present=Exists_KrlMsg(handle)
UNTIL NOT(present)
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
6 Programação de mensagens com KRL
6.10 Exercício: Programar mensagens de confirmação
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Programar mensagens de confirmação próprias
 Emitir parâmetros quaisquer em mensagens
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos da linguagem de programação KRL 
 Conhecimentos teóricos sobre a programação de mensagens 
Definição de 
funções
Tarefa parcial 1: Mensagem de confirmação
1. Crie uma mensagem de confirmação com o texto "Foram transportados 
xxx cubos". 
2. Através do contador de unidades instalado, após cada 10º cubo deve ser 
exibida a mensagem de confirmação.
3. O trabalho somente pode continuar após a confirmação.
4. Teste o seu programa conforme a prescrição. 
Tarefa parcial 2: Mensagem de estado com mensagem de confirmação
1. Crie uma mensagem de confirmação com o texto "O programa de cubos 
é finalizado". 
2. Depois que loops sem fim foram abandonados com entrada 16, é excluída 
a mensagem de estado "Programa de cubos em execução". Exiba a men-
sagem de confirmação e aguarde até que ela tenha sido confirmada.
3. Teste o seu programa conforme a prescrição. 
O que você deve saber agora:
1. Qual é o número máximo de mensagens de confirmação administradas no 
buffer de mensagens? 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
129 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
130 / 251
Programação do robô 2
6.11 Trabalhar com uma mensagem de espera
Descrição de uma 
mensagem de 
espera definida 
pelo usuário
 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 
mensagem de 
espera definida 
pelo usuário
 Mensagens de espera são apropriadas para aguardar um estado e exibir 
nisto o símbolo de espera.
 O programa, por exemplo, é retido até que seja obtido o estado pelo qual 
está se esperando.
 São administradas, no máximo, 100 mensagens no buffer de mensagens. 
 A mensagem de espera é excluída novamente através da função 
Clear_KrlMsg( ).
 As mensagens de espera também podem ser excluídas da mesma forma 
através dos ajustes nas opções de mensagens no reset do programa ou 
ao fechar o programa ou em uma seleção de passo.
Programação de 
mensagens de 
espera definidas 
pelo usuário
1. Carregar um programa principal no editor.
2. Declarar variáveis de trabalho para:
 remetente, número da mensagem, texto de mensagem (de 
KrlMsg_T)
 camposcom 3 elementos para os parâmetros (de KrlMsgPar_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
 variável para o resultado do teste (como BOOL)
 variável para o resultado da exclusão (como BOOL)
3. Iniciar variáveis de trabalho com os valores desejados.
4. Programar o acesso de função Set_KrlMsg(…).
5. Parar o programa com um loop, até que ocorra o estado pelo qual é es-
perado ou até que a mensagem seja excluída através do botão Simular.
6. Excluir a mensagem de espera com o acesso de função Clear_KrlMsg( 
).
7. Fechar e salvar o programa principal.
Exemplo de programação para a exibição/mensagem acima:
Fig. 6-7: Mensagem de espera
Fig. 6-8: Mensagem de espera
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
6 Programação de mensagens com KRL
 O programa é parado após a emissão da mensagem. A mensagem é exclu-
ída através do estado entrada 12 (TRUE). Depois disto é dada continuidade 
no programa. 
Da mesma forma a mensagem é excluída ao dar um reset no programa ou ao 
fechar o programa. Isto ocorre através do ajuste nas opções de mensagens 
Clear_P_Reset TRUE.
DECL KRLMSG_T mymessage
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGOPT_T Option
DECL INT handle
DECL BOOL present, eraser
...
IF $IN[12]==FALSE THEN
mymessage={modul[] "College", Nr 1909, msg_txt[] "My Messagetext"}
Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, 
Log_to_DB TRUE} 
;Dummies[1..3] estão vazios
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
handle = Set_KrlMsg(#WAITING, mymessage, Parameter[ ], Option)
ENDIF
eraser=FALSE
;Loop para parar até que esta mensagem tenha sido excluída
REPEAT
IF $IN[12]==TRUE THEN
eraser=Clear_KrlMsg(handle) ;Meldung loeschen
ENDIF
present=Exists_KrlMsg(handle) ;kann über simuliere geloescht worden 
sein
UNTIL NOT(present) or eraser
131 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
132 / 251
Programação do robô 2
6.12 Exercício: Programar mensagens de espera
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Programar mensagens de espera próprias
 Emitir parâmetros quaisquer em mensagens
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos da linguagem de programação KRL 
 Conhecimentos teóricos sobre a programação de mensagens 
Definição de 
funções
1. Crie uma mensagem de espera com o texto "Aguardar interruptor 15 ou 
aguardar 5 segundos". 
2. No início do programa Magazine deve ser emitida a mensagem de espe-
ra. Amplie o seu programa Magazine com esta lógica da mensagem de 
espera.
3. Teste o seu programa conforme a prescrição.
O que você deve saber agora:
1. Qual é a diferença entre uma mensagem "STATE" e uma mensagem "WAI-
TING"? 
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
6 Programação de mensagens com KRL
6.13 Variáveis e estruturas adicionais em diálogos
Estrutura para 
ocupação de 
botões
 estrutura KUKA predefinida: KrlMsgDlgSK_T
 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:
6.14 Funções em diálogos
Setando um 
diálogo
Com a função Set_KrlDlg( ) é emitida uma mensagem de diálogo. Isto 
significa que a mensagem é transmitida ao buffer de mensagens e exibida em 
uma janela de mensagens com botões.
Fig. 6-9: Diálogo
Enum KrlMsgParType_T Value, Key, Empty
Struc KrlMsgDlgSK_T KrlMsgParType_T Sk_Type, Char SK_txt[10]
DECL KRLMSGDLGSK_T Softkey[7] ; Preparar 7 possíveis softkeys
...
softkey[1]={sk_type #value, sk_txt[] "key1"}
softkey[2]={sk_type #value, sk_txt[] "key2"}
softkey[3]={sk_type #value, sk_txt[] "key3"}
softkey[4]={sk_type #value, sk_txt[] "key4"}
softkey[5]={sk_type #value, sk_txt[] "key5"}
softkey[6]={sk_type #value, sk_txt[] "key6"}
softkey[7]={sk_type #value, sk_txt[] "key7"}
...
Podem ser atribuídos, no máximo, 10 caracteres por botão. De acor-
do com os caracteres utilizados surgem botões de diferentes largu-
ras.
133 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
134 / 251
Programação do robô 2
 Funções build-in para a emissão de um diálogo
 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.
 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.
Fig. 6-10: 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
DEF MyProg( )
DECL INT handle
...
handle = Set_KrlDlg(MyQuestion, Parameter[ ], Touchkey[ ], Option)
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.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
6 Programação de mensagens com KRL
Controlar e 
avaliar um 
diálogo
Com a função Exists_KrlDlg( ) pode ser verificado, se um determinado 
diálogo ainda existe. Portanto, é verificado se este diálogo ainda se encontra 
no buffer de mensagens.
Se o diálogo for respondido, a função fornece a informação de qual botão foi 
pressionado.
 Funções build-in para a verificação de uma mensagem
 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
 Valor de retorno da função:
 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)
6.15 Trabalhar com diálogos
Descrição de um 
diálogo definido 
por usuário
DEFFCT BOOL Exists_KrlDlg(INT nHandle:IN, INT Answer:OUT)
DECL INT nHandle, answer
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)
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.
Fig. 6-11: Diálogo
135 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
136 / 251
Programação do robô 2
 Um diálogo sempre pode ser emitido somente depois que não houver 
mais nenhum outro diálogo.
 Podem ser definidas até 7 softkeys.
Função de um 
diálogo definido 
pelo usuário
 Diálogos são apropriados para exibir perguntas, que o usuário precisar 
responder.
 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
 Avaliação via Exists_KrlDlg(): o botão, que foi criado sob o index 4, 
também fornece o 4 como feedback.
Programação de 
diálogos 
definidos pelo 
usuário
1. Carregar um programa principal no editor.
2. Declarar variáveis de trabalho para:
 remetente, número da mensagem, texto de mensagem (de 
KrlMsg_T)
 campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
DECL KRLMSGDLGSK_T Softkey[7] ; Preparar 7 possíveis softkeys
softkey[1]={sk_type #value, sk_txt[] "key1"} ; Feedback -> 1
softkey[2]={sk_type #value, sk_txt[] "key2"} ; Feedback -> 2
softkey[3]={sk_type #value, sk_txt[] "key3"} ; Feedback -> 3
softkey[4]={sk_type #value, sk_txt[] "key4"} ; Feedback -> 4
softkey[5]={sk_type #value, sk_txt[] "key5"} ; Feedback -> 5
softkey[6]={sk_type #value, sk_txt[] "key6"} ; Feedback -> 6
softkey[7]={sk_type #value, sk_txt[] "key7"} ; Feedback -> 7
; a softkey n° 4 dá como feedback o 4 na variável ANSWER
softkey[4]={sk_type #value, sk_txt[] "key4"}
present = exists_KrlDlg(handle ,ANSWER) ; ANSWER é descrita pelo 
sistema
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
6 Programação de mensagens com KRL
 7 possíveis botões (de KrlMsgDlgSK_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
 variável para o resultado do teste (como BOOL)
 variável para o resultado da resposta de qual botão foi pressionado 
(como INT)
3. Iniciar variáveis de trabalho com os valores desejados.
4. Programar o acesso de função Set_KrlDlg(…).
5. Parar o programa com um loop, até que o diálogo esteja respondido.
6. Avaliar o diálogo com o acesso de função Exists_KrlDlg( ).
7. Planejar e programar outras derivações no programa.
8. Fechar e salvar o programa principal.
Exemplo de programação para a exibição/mensagem acima:
Os botões não devem ser programados de forma completa, mas com lacunas 
(n° 1, 4, 6). Para isso, os botões são enfileirados automaticamente pelo siste-
ma. Se forem utilizados apenas os botões 1, 4 e 6, também serão possíveis 
apenas os feedbacks 1, 4 e 6.
O programa é parado após a entrega do diálogo e o diálogo é excluído após 
a resposta. Depois disto é dada continuidade no programa. Em seguida, é 
programado um distribuidor. 
Da mesma forma a mensagem é excluída ao dar um reset no programa ou ao 
fechar o programa. Isto ocorre através do ajuste nas opções de mensagens 
Clear_P_Reset TRUE.
Fig. 6-12: Diálogo com 3 botões
DECL KRLMSG_T myQuestion
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGDLGSK_T Softkey[7] ;Preparar 7 possíveis softkeys
DECL KRLMSGOPT_T Option
DECL INT handle, answer
DECL BOOL present
...
myQuestion={modul[] "College", Nr 1907, msg_txt[] "My Question?"}
Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, 
Log_to_DB TRUE} 
;Dummies[1..3] estão vazios
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
softkey[1]={sk_type #value, sk_txt[] "key1"} ; Botão 1
softkey[2]={sk_type #EMPTY, sk_txt[] "key2"} ; Botão 2
softkey[3]={sk_type #EMPTY, sk_txt[] "key3"} ; Botão 3
softkey[4]={sk_type #value, sk_txt[] "key4"} ; Botão 4
137 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
138 / 251
Programação do robô 2
softkey[5]={sk_type #EMPTY, sk_txt[] "key5"} ; Botão 5
softkey[6]={sk_type #value, sk_txt[] "key6"} ; Botão 6
softkey[7]={sk_type #EMPTY} ; Botão 7: sk_txt[] também pode ser 
suprimido
...
...; Emitir diálogo
handle = Set_KrlDlg(myQuestion, Parameter[ ],Softkey[ ], Option)
answer=0
REPEAT ; Loop para parar até que este diálogo seja respondido
present = exists_KrlDlg(handle ,answer) ; A resposta é descrita pelo 
sistema
UNTIL NOT(present)
...
SWITCH answer
CASE 1 ; Botão 1
; Ação no botão 1
...
CASE 4 ; Botão 4
; Ação no botão 4
...
CASE 6 ; Botão 6
; Ação no botão 6
...
ENDSWITCH
...
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
6 Programação de mensagens com KRL
6.16 Exercício: Programar diálogo
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Programar consultas próprias de diálogo 
 Emitir parâmetros quaisquer em mensagens 
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos da linguagem de programação KRL 
 Conhecimentos teóricos sobre a programação de mensagens 
Definição de 
funções
Tarefa parcial: Mensagem de diálogo
1. Crie uma mensagem de diálogo com o texto "Selecione a quantidade de 
cubos a serem transportados". 
2. Disponibilize a quantidade 2, 3, 5, 8 e ocupe a 7ª softkey com "FIM".
3. Amplie o seu programa Magazine com o diálogo e saia do loop sem fim 
com "FIM".
4. Teste o seu programa conforme a prescrição.
O que você deve saber agora:
1. Como são inscritas as teclas das softkeys no diálogo? 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
139 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
140 / 251
Programação do robô 2
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
7 Programação de movimento com KRL
7.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Programar movimento com KRL
 Programar movimentos relativos através do KRL
 Programação de Spline Blocks com KRL
 Calcular e manipular posições do robô
 Alterar objetivamente o status e turn
7.2 Programar movimentos individuais do SPLINE com KRL
Definição de um 
movimento
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>
 
 
Fig. 7-1: Formulário Inline Passo individual Movimento SPTP-/SLIN-/SCIRC
141 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
142 / 251
Programação do robô 2
Explicação da 
sintaxe
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
 O robô acessa uma posição introduzida
 Específico do eixo (AXIS ou E6AXIS)
 Posição espacial (com ferramenta e base atualmente ativas)
 O robô só opera com a inserção de um ou mais agregados
 O robô se move com valores alterados usando WITH
Elemento Descrição
Ponto de 
destino
Tipo: AXIS, E6AXIS, POS, E6POS, FRAME
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á.
SPTP XP3 C_SPL
SPTP {A1 0, A2 -80, A3 75, A4 30, A5 30, A6 110}
SPTP {X 100, Y -50, Z 1500, A 0, B 0, C 90, S 3, T 35}
SPTP {A1 30} ; só A1 é deslocado para 30°
SPTP {X 200, A 30} ; só em X para 200mm e A para 30°
SPTP XP10 WITH $TOOL=tool_data[2], $LOAD=load_data[2] ; O ponto P10 é 
alcançado com TOOL 2
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
7.4 Movimento de passo individual com SLIN e SCIRC
Descrição SLIN, SCIRC: 
SLIN e SCIRC podem ser programados como segmento em um Spline Block 
CP ou como movimento individual. 
É possível copiar um movimento individual SLIN ou SCIRC em um Spline Blo-
ck CP, mas somente se ele não contiver nenhuma atribuição às variáveis de 
sistema que são proibidas ali.
Sintaxe SLIN:
SLIN Ponto de destino <WITH SysVar1 = Valor1 <, SysVar2 = Valor2, …, >> 
<C_SPL>
SCIRC:
SCIRC Ponto auxiliar, Ponto de destino <, CA Ângulo circular> <WITH SysVar1 = 
Valor1 <,SysVar2 = Valor2 , … >> <C_SPL>
Explicação da 
sintaxe
Elemento Descrição
Ponto auxi-
liar
Ponto de 
destino
Tipo: POS, E6POS, FRAME
As coordenadas 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, existe a seguinte diferenciação:
 Se a posição anterior estiver fora de um Spline Block, 
são assumidos os valores do ponto de destino realmen-
te atingido, não do ponto de destino programado.
 Se a posição anterior estiver em um Spline Block, são 
assumidos os valores do ponto de destino programado, 
não do ponto de destino realmente atingido.
Se a unidade de comando do robô não conhecer nenhuma 
posição anterior, os componentes que faltam serão assu-
midos da posição atual do robô.
Ângulo cir-
cular
Unidade: grau; sem limitação
SysVar
Valor Atribuição de valor à variável do sistema
Em segmentos: A atribuição vale apenas para esse seg-
mento.
As variáveis do sistema também podem ser ocupadas por 
acesso funcional. Para essas funções valem as mesmas 
restrições das funções no trigger.
C_SPL  Com C_SPL: O ponto de destino é aproximado. $APO 
define o momento mais cedo para a aproximação.
Somente possível para movimentos individuais, não 
para segmentos.
 Sem C_SPL: O ponto de destino é alcançado com exa-
tidão.
143 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
144 / 251
Programação do robô 2
Exemplos SLIN:
 O robô se movimenta em uma posição calculada aproximando esse ponto 
ABLAGE[4]
 O robô se move para o ponto P4 com estes valores de aceleração 
SCIRC
 O robô acessa as posições previamente programadas do arquivo DAT e 
percorre um ângulo inscrito de 190°.
 O robô acessa as posições indicadas e percorre um ângulo inscrito de 
180°.
 Ângulo circular positivo (CA>0): O círculo é operado no sentido progra-
mado: ponto de partida-ponto auxiliar-ponto de destino
 Ângulo circular negativo (CA<0): o círculo é operado contra o sentido 
programado: ponto de partida-ponto de destino-ponto auxiliar
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á.
SLIN ABLAGE[4] C_SPL
SLIN P4 WITH $ACC={CP 1.8, ORI1 120, ORI2 140}
SCIRC XP3, XP4, CA 190
SCIRC {X 100, Y ...}, {X 150, Y ...}, CA 180
Fig. 7-2: Ângulo do círculo CA = +290°
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
7.5 Parâmetros de movimento
Função dos 
parâmetros de 
movimento
Configurações prévias para a programação de movimento
 Podem ser assumidas as configurações existentes:
 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
 Ativação dos respectivos dados de carga
 Base de referência / base de trabalho: $BASE
 Ativação da base medida
 Ferramenta conduzida pelo robô ou externa: $IPO_MODE
 Ferramenta conduzida por robô
 Ferramenta externa
 Velocidade:
 Em movimento PTP
 Em movimentos de trajetória LIN ou CIRC
Fig. 7-3: Ângulo do círculo CA = -290°
$TOOL = tool_data[x] ; x = 1...16
$LOAD = load_data[x] ; x = 1...16
$BASE = base_data[x] ; x = 1...32
$IPO_MODE = #BASE
$IPO_MODE = #TCP
$VEL_AXIS[x] ; x=1...8 para cada eixo
145 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
146 / 251
Programação do robô 2
 Aceleração
 Em movimento PTP
 Em movimentos de trajetória LIN ou CIRC
 Solavanco
 Em movimento SPTP
 Em movimentos de trajeto SLIN ou SCIRC
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
 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 
 Somente em movimento PTP: C_PTP
 Em movimentos de trajetória LIN, CIRC: C_ORI
O ângulo de orientação dominante deverá ficar abaixo do valor 
$APO.CORI 
$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).
$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
$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
$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}}
SLIN XP13 WITH $JERK = {CP 44} ; [m/s³] Alteração da aceleração de 
trajeto
$APO.CDIS = 250.0 ; [mm] Distância
SPTP XP3 C_SPL
SLIN XP4 C_SPL
$APO.CPTP = 50 ; Tamanho de aproximação em [%] em C_PTP
PTP XP3 C_PTP
$APO.CORI = 50.0 ; [°] Ângulo
SLIN XP4 C_ORI
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
 Em movimentos de trajetória LIN, CIRC: C_VEL
A velocidade na fase de frenagem para o ponto de destino deverá ser 
inferior a $APO.CVEL 
 Controle de orientação: Somente para LIN e CIRC
 Para LIN e CIRC: $ORI_TYPE

Durante o movimento de trajetória a orientação permanece cons-
tante. Para o ponto final, a orientação programada é ignorada 

Durante o movimento de trajetória, a orientação é alterada conti-
nuamente até a orientação do ponto de destino.

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-
$APO.CVEL = 75.0 ; [%] Porcentagem
LIN XP4 C_VEL
$ORI_TYPE = #CONSTANT
Fig. 7-4: Orientação constante
$ORI_TYPE = #VAR
Fig. 7-5: Padrão ou PTP manual
$ORI_TYPE = #JOINT
147 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
148 / 251
Programação do robô 2
balho da ferramenta. Não é possível um giro em torno da direção 
de trabalho da ferramenta.
 Somente em CIRC: $CIRC_TPYE

Controle de orientação referente à trajetória durante o movimento 
circular

Controle de orientação referente ao espaço durante o movimento 
circular 
Configuração de 
círculo SCIRC
Em movimentos SCIRC, a unidade de comando do robô pode levar em con-
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: 
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
Fig. 7-6: Orientação constante, referente ao trajeto
$CIRC_TYPE = #BASE
Fig. 7-7: Orientação constante, referente à base
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
 Na programação com sintaxe KRL: através da variável de sistema 
$CIRC_MODE
 Na programação através de formulários inline: na janela de opções Parâ-
metros de movimento, guia Configuração de círculo
Além disso, é possível determinar, da mesma forma, para instruções SCIRC 
com ângulo circular, se o ponto de destino deve ter a orientação programada 
ou se a orientação deve ser continuada de acordo com o ângulo circular.
$CIRC_MODE é gravável apenas através de uma instrução SCIRC. 
$CIRC_MODE não pode ser lido.
Sintaxe KRL
 Para pontos auxiliares:
$CIRC_MODE.AUX_PT.ORI = Comportamento PA
 Para pontos de destino:
$CIRC_MODE.TARGET_PT.ORI = Comportamento PD
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°
Elemento Descrição
Compor-
tamento PA
Comporta-
mento de 
orientação 
no ponto 
auxiliar
Tipo de dados: ENUM / menu suspenso
 #INTERPOLATE: No ponto auxiliar o TCP assume a 
orientação programada.
 #IGNORE: A unidade de comando do robô ignora a 
orientação programada do ponto de ajuda. A orientação 
de início do TCP é transferida no trajeto mais curto para 
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-
tamento PD
Comporta-
mento de 
orientação 
no ponto de 
destino
Tipo de dados: ENUM / menu suspenso
 #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: 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)
149 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
150 / 251
Programação do robô 2
 Ponto auxiliar: 98°
 Ponto de destino: 197°
A reorientação, portanto, é 197°. Se o ponto auxiliar for ignorado a orientação 
de destino também pode ser atingida através da reorientação menor de 360° -
 197° = 163°.
 As setas tracejadas laranja indicam a orientação programada.
 As setas cinza indicam esquematicamente como seria a orientação efeti-
va, desde que ela desvie da orientação programada.
#INTERPOLATE No ponto auxiliar o TCP assume a orientação programada de 98°. A reorien-
tação é 197°.
#IGNORE É executada a reorientação curta com 163°. A orientação programada do pon-
to auxiliar é ignorada.
#CONSIDER
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-8: #INTERPOLATE
SP Ponto de partida
AuxP Ponto auxiliar
TP Ponto de destino
Fig. 7-9: #IGNORE
#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.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
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. 
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.
Fig. 7-10: #CONSIDER
Fig. 7-11: #CONSIDER, outro exemplo
151 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
152 / 251
Programação do robô 2
#EXTRAPOLATE No TP é assumida a orientação programada. Para TP_CA esta orientação é 
continuada de acordo com o ângulo inscrito.
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.
Fig. 7-12: #INTERPOLATE
SP Ponto de partida
AuxP Ponto auxiliarTP Ponto de destino programado
TP_CA Ponto de destino efetivo. Resulta através do ângulo inscrito.
Fig. 7-13: #EXTRAPOLATE
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
 Se estiver antecedido um segmento Spline, para o qual vale o 
$ORI_TYPE = #IGNORE, não pode ser setado #EXTRAPOLATE para o 
ponto de destino.
Explicação sobre 
mensagens de 
erro
Algumas mensagens de erro contêm o texto "Erro por causa da regra x"
Na programação de $CIRC_MODE deve ser observado, tanto para a orienta-
çã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, 
movimento 
individual do 
spline
Para Spline Blocks e movimentos individuais do spline, as seguintes variáveis 
de sistema são graváveis com a linha WITH:
$ACC
$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
153 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
154 / 251
Programação do robô 2
$VEL
$VEL_AXIS
$VEL_EXTAX
Adicionalmente para SCIRC e SLIN: $CIRC_MODE
7.7 Programar movimentos relativos e absolutos com KRL
Movimento 
absoluto
Acesso da posição de destino com valores absolutos. Aqui, o eixo A3 é posi-
cionado a 45º.
Movimento 
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°.
As variáveis de sistema estão descritas no capítulo Variáveis de sis-
tema.
SPTP {A3 45}
Fig. 7-14: Movimento absoluto do eixo A3
SPTP_REL {A3 45}
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
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.
Sintaxe SPTP_REL:
SPTP_REL Ponto de destino <WITH SysVar1 = Valor1 <, SysVar2 = Valor2 , …>> 
<C_SPL><#BASE|#TOOL>
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.
Movimentos relativos SPTP_Rel, SLIN_REL e SCIRC_REL estão 
disponível somente a partir do software KSS 8.3.6
155 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
156 / 251
Programação do robô 2
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>
Elemento Descrição
Ponto de 
destino
Tipo: AXIS, E6AXIS, POS, E6POS, FRAME
O ponto de destino pode ser cartesiano ou específico do 
eixo. A unidade de comando interpreta as coordenadas 
como relativas ao ponto de destino do passo anterior.
Se não forem informados todos os componentes do ponto 
de destino, a unidade de comando coloca os componentes 
faltantes no valor 0. Isso significa que os valores absolutos 
desses componentes permanecerão inalterados.
Os dados relativos a Status e Turn, se existentes, são con-
siderados pela unidade de comando. (Isso contrasta com 
SLIN_REL, SCIRC_REL e SPL_REL, onde eles são igno-
rados!)
Valor Atribuição de valor à variável do sistema
Em segmentos SPTP: A atribuição vale apenas para esse 
segmento. 
As variáveis do sistema também podem ser ocupadas por 
acesso funcional. Para essas funções valem as mesmas 
restrições das funções no trigger.
C_SPL  Com C_SPL: O ponto de destino é aproximado. $APO 
define o momento mais cedo para a aproximação.
Somente possível para movimentos individuais, não 
para segmentos.
 Sem C_SPL: O ponto de destino é alcançado com exa-
tidão.
#BASE, 
#TOOL
Apenas permitido se o ponto de destino cartesiano tiver 
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.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
Exemplo  O eixo 2 é deslocado em 30° no sentido negativo. Os demais eixos não 
se movimentam.
 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.
 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. 
Elemento Descrição
Ponto auxiliar
Ponto de des-
tino
Tipo: POS, E6POS, FRAME
O ponto deve ser indicado em coordenadas cartesianas. A 
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-
lar
Unidade: grau; sem limitação
Valor Atribuição de valor à variável do sistema
Em segmentos: A atribuição vale apenas para esse seg-
mento.
As variáveis do sistema também podem ser ocupadas por 
acesso funcional. Para essas funções valem as mesmas 
restrições das funções no trigger.
C_SPL  Com C_SPL: O ponto de destino é aproximado. $APO 
define o momento mais cedo para a aproximação.
Somente possível para movimentos individuais, não 
para segmentos.
 Sem C_SPL: O ponto de destino é alcançado com exa-
tidão.
#BASE, 
#TOOL
 #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.
PTP_REL {A2 -30}
PTP_REL {X 100,Z -200}
157 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
158 / 251
Programação do robô 2
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.
 O ponto de destino do movimento circular é definido por um ângulo circu-
lar de 500°. O ponto de destino é aproximado.
 Exemplos de sintaxe
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)
LIN_REL {X 100,Z -200} ; #BASE é ajuste padrão
LIN_REL {X -100} #TOOL
CIRC_REL {X 100,Y 30,Z -20},{Y 50},CA 500 C_VEL
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.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
 Podem ser manipuladas posições existentes do arquivo DAT.
 Agregados individuais de posições existentes podem ser alterados direta-
mente com separador de ponto.
Princípio
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
 Alterar a cada passagem a posição do arquivo DAT
 A posição é assumida e salva em uma variável
Procedimento 1. Como perito, carregue o programa com a tecla Abrir no editor
2. Calcular/manipular a posição. Salvar os novos valores calculados 
em uma nova variável, se for o caso
3. Verificar os ajustes iniciais para a programação de movimentos e assumir 
ou reinicializar
 Ferramenta ($TOOL e $LOAD)
 Configuração-base ($BASE)
 Ferramenta conduzida pelo robô ou externa ($IPO_MODE)
 Velocidade
 Aceleração
 Distância de aproximação, caso se aplique
 Possivelmente controle de orientação
4. Criar o comando de movimento completo
 Tipo de movimento (SPTP, SLIN, SCIRC, SPTP_REL, SLIN_REL, 
SCIRC_REL)
 Ponto de destino (para SCIRC também ponto auxiliar)
 Para SCIRC possivelmente ângulo circular (CA)
 Ativar aproximação (C_SPL, C_DIS)
5. No caso de novo movimento, retornar ao ponto 3
6. Fechar editor e salvar
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.
XP1.x = 450 ; novo valor X 450mm
XP1.z = 30.0*distance ; se calcula novo valor Z
SPTP XP1
; valor X deslocado cada vez 450mm
XP2.x = XP2.x + 450
SPTP XP2
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 
159 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
160 / 251
Programação do robô 2
7.9 Modificar exatamente bits de Status e Turn
Descrição  Os valores da posição (X, Y, Z) e orientação (A, B, C) do TCP não são 
suficientes para definir claramente a posição de um robô, uma vez que 
com o mesmo TCP são possíveis diversas posições de eixo. Status e 
Turn servem para definir uma posição inequívoca a partir de diversas po-
sições de eixos possíveis.
 Status (S) e Turn (T) são partes integrantes dos tipos de dados POS e 
E6POS:
 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 
Fig. 7-16: Diferentes posições de eixos condicionadas através de dife-
rentes valores de Status e Turn
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
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
é violado nenhum interruptor de fim de curso de Software e é ao mes-
mo tempo o mais próximo ao ângulo de partida).
Função STATUS
 A informação de Status evita ambiguidades na posição do eixo.
 Bit 0: informa a posição do ponto de interseção dos eixos da mão (A4, A5, 
A6).
 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
Zona acima da cabeça
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.
Bit 0 = 1
Zona base
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.
Bit 0 = 0
Fig. 7-17: Exemplo: o ponto de interseção dos eixos manuais (ponto ver-
melho) está na área básica.
161 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
162 / 251
Programação do robô 2
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.
 Bit 2: informa a posição do eixo 5.
 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.
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ãogeral
Posição Valor
A3 ≥ 0° Bit 1 = 1
A3 < 0° Bit 1 = 0
Fig. 7-18: Offset entre A3 e A4: Exemplo KR 30
Posição Valor
A5 > 0 Bit 2 = 1
A5 ≤ 0 Bit 2 = 0
Descrição Valor
O ponto não foi ensinado com um robô com precisão 
absoluta.
Bit 4 = 0
O ponto foi ensinado com um robô com precisão abso-
luta.
Bit 4 = 1
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 °
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
 Exemplo
T 19 corresponde T 'B010011'. Isto significa:
Procedimento 1. Abrir o programa como perito.
2. Manipular Status e Turn. Salvar os novos valores calculados em uma 
nova variável, se for o caso
3. Verificar os ajustes prévios para a programação de movimentos e assumir 
ou reinicializar
 Ferramenta ($TOOL e $LOAD)
 Configuração-base ($BASE)
 Ferramenta conduzida pelo robô ou externa ($IPO_MODE)
 Velocidade
 Aceleração
 Distância de aproximação, caso se aplique
 Eventualmente controle de orientação
4. Criar o comando de movimento completo como passo individual
 Tipo de movimento (SPTP, SLIN, SCIRC)
 Ponto de destino (para SCIRC também ponto auxiliar)
 Para CIRC, eventualmente ângulo circular (CA)
 Ativar aproximação (C_SPL, C_DIS)
5. No caso de novo movimento, retornar ao ponto 3
6. Fechar editor e salvar
DECL POS XP1 = {X 900, Y 0, Z 800, A 0, B 0, C 0, S 6, T 19}
Eixo Ângulo Binário
A 1 negativo 1
A 2 negativo 2
A 3 positivo 4
A 4 positivo 8
A 5 negativo 16
A 6 positivo 32
163 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
164 / 251
Programação do robô 2
7.10 Exercício: Paletizar e despaletizar
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Trabalhar com campos 
 Cálculo de coordenadas de posição 
 Manuseio com estruturas e o separador de ponto 
 Uso de loops FOR em cadeias
 Programação de movimentos sem formulários Inline
 Acesso de coordenadas de destino calculadas
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos sobre campos, estruturas, loop FOR 
 Conhecimentos teóricos sobre manipulação de dados 
 Conhecimentos teóricos sobre a programação de movimentos sem for-
mulário Inline
Definição de 
funções
Deverá ser criado um programa com o qual 16 cubos são retirados do maga-
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.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
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-19
Fig. 7-20
165 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
166 / 251
Programação do robô 2
Tarefa parcial 4: Paletização e despaletização dos módulos
1. Amplie o seu programa com os comandos de movimento necessários, de 
forma que todos os módulos sejam depositados sobre a mesa e depois 
coletados.
2. Para buscar e depositar os cubos no magazine devem ser usados os mó-
dulos já existentes.
3. Utilize para isto somente comandos KRL.
4. Se necessário, use os recursos aprendidos para estruturar o seu progra-
ma.
O que você deve saber agora:
1. Calcule os valores para A, B, C, X, Y, Z: 
INT X, Y, Z 
REAL A, B, C 
A = 4.5 ;A= ……………
B = -2 ;B= ……………
C = 4.1 ;C= ……………
X= 2.5 ;X= ……………
Y = 4 ;Y= ……………
Z =0.1 ;Z= ……………
A = A * B + Y ;A = …………… 
B = B * Z + X ;B = …………… 
C = C + 4/3 ;C = …………… 
X= X + 2.5 * 4 ;X = …………… 
Y = Y – 10.0/4 ;Y = …………… 
Z = 14 – Z * C + A ;Z = …………… 
2. O que indica a informação CA no movimento circular?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3. Como é o ajuste para TCP externo? 
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4. Como é ajustada a aproximação em um movimento LIN? 
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
7.11 Programação de SPLINE Blocks
 Além dos passos individuais com SPTP, SLIN, SCRIC e dos movimentos 
relativos, está disponível um "SPLINE Block".
 O SPLINE Block é visto e planejado como movimento individual com um 
"trajeto complexo".
 Existem dois tipos de SPLINE Blocks:
 SPLINE Block CP: Spline com movimentos CP (SPL, SLIN, SCIRC)
 SPLINE Block PTP: Spline com movimentos exclusivamente no espa-
ço de eixo (somente SPTP)
 Conceito de Block: Um SPLINE Block é um passo de movimento com uma 
TOOL, uma BASE e um IPO_MODE, mas diferentes velocidades e ace-
lerações nos segmentos individuais.
 O trajeto é planejado através de todos os pontos, assim todos os pontos 
são percorridos.
 O trajeto é completamente calculado antes. Com isso, tudo é conhecido e 
o planejamento pode colocar o trajeto idealmente na zona de trabalho dos 
eixos.
 O spline não pode contradizer a física. Trajetos, que têm contornos muito 
apertados, implicarão sempre na redução da velocidade, uma vez que os 
eixos do robô são sempre os elementos limitantes.
 Dentro de um Spline Block, não é necessária nenhuma aproximação, já 
que é definido um trajeto através de todos os pontos. Apesar disso, há ca-
sos em que a velocidade de trajeto cai para 0 m/s.
 Ainda podem ser configuradas funções adicionais como "velocidade 
constante" ou "tempo fixo definido".
 Se o robô se afastar dos pontos que estão em uma superfície de trabalho, 
pode ocorrer uma colisão no deslocamento do primeiro ponto com a su-
perfície de trabalho.
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)
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:
Fig. 7-21:Colisão com a superfície de trabalho
Fig. 7-22: Evitar colisão com a superfície de trabalho
167 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
168 / 251
Programação do robô 2
 Comandos Inline dos pacotes de tecnologia, que estão disponíveis atra-
vés da funcionalidade Spline
 Comentários e linhas em branco
Um spline block não deve conter nenhuma outra instrução, por exemplo, atri-
buições de variáveis ou instruções de lógica. 
7.11.1 Perfil de velocidade em movimentos do SPLINE
Velocidade do 
SPLINE
O trajeto transcorre sempre igual, independente de override, velocidade ou 
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 
velocidade
Os principais exemplos de casos nos quais a velocidade deve ser inferior à 
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:
É 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 
velocidade para 0
Isto acontece com:
 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.
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.
$ORI_TYPE = #IGNORE
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
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.
 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.)
Reduções de 
velocidade 
devido à aprendi-
zagem incons-
tante
Em caso de distribuição não uniforme de alterações de orientação / alterações 
dos eixos adicionais relativas ao comprimento do arco, muitas vezes ocorrem 
quedas indesejadas de velocidade.
Exemplo de uma distribuição não uniforme:
Fig. 7-23: Parada exata em P2
Fig. 7-24: Parada exata em P2
Fig. 7-25: P2 é percorrida sem parada exata.
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.
PTP {x 0, y 0, z 0, A 0, B 0, C 0} ; Ponto de partida do spline 
SPLINE
SPL {x 0, y 100, z 0, A 10, B 0, C 0} ; 0,1° Reorientação por mm de 
trajeto cartesiano
SPL {x 0, y 110, z 0, A 20, B 0, C 0} ; 1° Reorientação por mm de 
trajeto cartesiano
SPL {x 0, y 310, z 0, A 31, B 0, C 0} ; 0,055° Reorientação por mm de 
trajeto cartesiano 
 ENDSPLINE
169 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
170 / 251
Programação do robô 2
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:
Desligar controle de orientação por formulário Inline ou KRL 
Comparação com e sem controle programado de orientação
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). 
 
PTP {x 0, y 0, z 0, A 0, B 0, C 0} ; Ponto de partida do spline 
SPLINE
SPL {x 0, y 100, z 0, A 10, B 0, C 0} ; 0,1° Reorientação por mm de 
trajeto cartesiano
SPL {x 0, y 110, z 0, A 11, B 0, C 0} ; 0,1° Reorientação por mm de 
trajeto cartesiano
SPL {x 0, y 310, z 0, A 31, B 0, C 0} ; 0,1° Reorientação por mm de 
trajeto cartesiano 
 ENDSPLINE
$ORI_TYPE = #IGNORE
Fig. 7-26: Com orientação programada
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
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-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.
171 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
172 / 251
Programação do robô 2
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.
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
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
 Alteração do tipo de segmento:
Se um segmento SPL é alterado para um segmento SLIN, ou vice-versa, 
a trajetória muda no segmento anterior e no seguinte.
Exemplo 1 Trajetória original:
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.
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
 SPL P3
 SPL P4
 SCIRC P5, P6
 SPL P7
 SLIN P8
ENDSPLINE
Fig. 7-29: Trajeto original
Fig. 7-30: Ponto foi deslocado
173 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
174 / 251
Programação do robô 2
Exemplo 2 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.
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
...
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
...
SPLINE
 SPL {X 100, Y 0, ...}
 SPL {X 102, Y 1}
 SPL {X 104, Y 0}
 SPL {X 204, Y 0}
ENDSPLINE
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
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:
Movimento spline:
P1A = Início da aproximação, P1B = Fim da aproximação
Fig. 7-33: Ponto foi deslocado
LIN P1 C_DIS
LIN P2
SPLINE
 SLIN P1A
 SPL P1B
 SLIN P2
ENDSPLINE
Fig. 7-34: Movimento de aproximação - Movimento do spline
175 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
176 / 251
Programação do robô 2
Possibilidades para apurar P1A e P1B:
 Percorrer a trajetória aproximada e na posição desejada, salvar a posição 
via trigger.
 Calcular os pontos no programa com KRL.
 O início da aproximação pode ser apurado a partir do critério de aproxi-
mação. Exemplo: Se como critério de aproximação é indicado C_DIS, a 
distância do início da aproximação até o ponto de canto corresponde ao 
valor de $APO.CDIS.
O fim da aproximação depende da velocidade programada.
A trajetória SPL não corresponde exatamente ao arco de aproximação, mes-
mo que P1A e P1B estejam exatamente no início da aproximação e no fim da 
aproximação. Para obter exatamente o arco de aproximação, é necessário in-
serir pontos adicionais no spline. Normalmente um ponto é suficiente.
Exemplo Deve ser reproduzido o seguinte movimento aproximado:
Movimento spline:
O início do arco de aproximação foi calculado a partir do critério de aproxima-
ção.
A trajetória SPL ainda não corresponde exatamente ao arco de aproximação. 
Por isso, é inserido um outro segmento SPL no Spline.
$APO.CDIS=20
$VEL.CP=0.5
LIN {Z 10} C_DIS
LIN {Y 60}
SPLINE WITH $VEL.CP=0.5
 SLIN {Z 30}
 SPL {Y 30, Z 10}
 SLIN {Y 60}
ENDSPLINE
Fig. 7-35: Exemplo: Movimento de aproximação - Movimento do spline, 1
SPLINE WITH $VEL.CP=0.5
 SLIN {Z 30}
 SPL {Y 15, Z 15}
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
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.
A trajetória é traçada por dentro, se estiverem atendidos os seguintes pré-re-
quisitos:
 Os dois segmentos SLIN se intersectam em seu prolongamento.
 SPL {Y 30, Z 10}
 SLIN {Y 60}
ENDSPLINE
Fig. 7-36: Exemplo: Movimento de aproximação - Movimento do spline, 2
Fig. 7-37: SLIN-SPL-SLIN
177 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
178 / 251
Programação do robô 2
 2/3 ≤ a/b ≤ 3/2
a = distância do ponto de partida do segmento SPL ao ponto de intersec-
ção dos segmentos SLIN
b = distância do ponto de intersecção dos segmentos SLIN ao ponto de 
destino do segmento SPL
7.11.6 Programação PROG de SPLINE Blocks com KRL
SPLINE Block CP 
KRL
SPLINE … ENDSPLINE define um Spline Block CP. Um Spline Block CP 
pode conter:
 Segmentos SLIN, SCIRC e SPL (Número limitado apenas pela capacida-
de de memória.)
 Trigger de PATH
 1 bloco de tempo (TIME_BLOCK …)
ou 1 região de deslocamento constante (CONST_VEL …)
 STOP WHEN PATH
 Comentários
 Linhas em branco
O bloco não deve conter nenhuma outra instrução, por exemplo, atribuições 
de variáveis ou instruções de lógica. 
Sintaxe
SPLINE < WITH SysVar1 = Valor1 <, SysVar2 = Valor2, … > >
Segmento1
 …
 <SegmentoN>
ENDSPLINE <C_SPL>
Elemento Descrição
SysVar
Valor Atribuição de valor à variável do sistema. O valor não é 
válido para segmentos, aos quais é atribuído um valor pró-
prio. Além disso, exceto se o valor for válido, como de cos-
tume, até um novo valor ser atribuído às variáveis do 
sistema.
As variáveis do sistema também podem ser ocupadas por 
acesso funcional. Para essas funções valem as mesmas 
restrições das funções no trigger.
C_SPL  Com C_SPL: O ponto de destino é aproximado. $APO 
define o momento mais cedo para a aproximação.
 Sem C_SPL: O ponto de destino é alcançado com exa-
tidão.
Até o System Software 8.2, o código para a aproximação no spline 
era "C_DIS". Se programas em versões superiores a 8.x forem utili-
zados, os quais se baseiam em 8.2 ou estados mais antigos e con-
têm C_DIS, este não precisa ser alterado em C_SPL e pode ser deixado 
como está.
SPLINE
 SPL P1
 TRIGGER WHEN PATH=GET_PATH() ONSTART DELAY=0 DO SUBPROG() PRIO=-1
 SPL P2
 SLIN P3
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V47 Programação de movimento com KRL
SPLINE Block 
PTP KRL
PTP_SPLINE … ENDSPLINE define um Spline Block PTP. Um Spline Block 
PTP pode conter:
 Segmentos SPTP (Número limitado apenas pela capacidade de memó-
ria.)
 Trigger de PATH
 1 bloco de tempo (TIME_BLOCK …)
 STOP WHEN PATH
 Comentários
 Linhas em branco
O bloco não deve conter nenhuma outra instrução, por exemplo, atribuições 
de variáveis ou instruções de lógica.
Sintaxe
PTP_SPLINE < WITH SysVar1 = Valor1 <, SysVar2 = Valor2, … > >
Segmento1
 …
 <SegmentoN>
ENDSPLINE <C_SPL>
Programação 
KRL de SPL, 
SLIN, SCRIC e 
SPTP
 SPL pode ser utilizado somente em SPLINE Blocks CP.
 SLIN e SCIRC podem ser utilizados como passo individual ou em um 
SPLINE Block CP.
 SPTP pode ser utilizado como passo individual ou em um SPLINE Block 
PTP.
 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
Elemento Descrição
SysVar
Valor Atribuição de valor à variável do sistema. O valor não é 
válido para segmentos, aos quais é atribuído um valor pró-
prio. Além disso, exceto se o valor for válido, como de cos-
tume, até um novo valor ser atribuído às variáveis do 
sistema.
As variáveis do sistema também podem ser ocupadas por 
acesso funcional. Para essas funções valem as mesmas 
restrições das funções no trigger.
C_SPL  Com C_SPL: O ponto de destino é aproximado. $APO 
define o momento mais cedo para a aproximação.
 Sem C_SPL: O ponto de destino é alcançado com exa-
tidão.
PTP_SPLINE WITH $ACC_AXIS[1]={CP 20, ORI1 80, ORI2 80}
 SPTP P1
 TRIGGER WHEN PATH=GET_PATH() ONSTART DELAY=0 DO SUPBROG( ) PRIO=85
 SPTP P2
 SPTP P3
 SPTP P4 WITH $ACC_AXIS[1]={CP 10}
ENDSPLINE C_SPL
179 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
180 / 251
Programação do robô 2
 A programação é quase igual, apenas SCIRC pode ser adicionalmente 
provido com um ângulo circular.
 Palavras-chaves são SPL, SLIN, SCIRC e SPTP.
 Também podem ser utilizados os movimentos relativos conhecidos 
SLIN_REL, SCIRC_REL e SPTP_REL.

Sintaxe
 SPL:
SPL Ponto de destino < WITH SysVar1 = Valor1 <,SysVar2 = Valor2 , …>>
 SLIN:
SLIN Ponto de destino <WITH SysVar1 = Valor1 <, SysVar2 = Valor2, …, >> 
<C_SPL>
 SCIRC:
SCIRC Ponto auxiliar, Ponto de destino <, CA Ângulo circular> <WITH 
SysVar1 = Valor1 <,SysVar2 = Valor2 , … >> <C_SPL>
 SPTP:
SPTP Ponto de destino <WITH SysVar1 = Valor1 <, SysVar2 = Valor2 , …>> 
<C_SPL>
Elemento Descrição
Ponto auxi-
liar
Ponto de 
destino
Tipo: POS, E6POS, FRAME
As coordenadas 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, existe a seguinte diferenciação:
 Se a posição anterior estiver fora de um Spline Block, 
são assumidos os valores do ponto de destino realmen-
te atingido, não do ponto de destino programado.
 Se a posição anterior estiver em um Spline Block, são 
assumidos os valores do ponto de destino programado, 
não do ponto de destino realmente atingido.
Se a unidade de comando do robô não conhecer nenhuma 
posição anterior, os componentes que faltam serão assu-
midos da posição atual do robô.
Ângulo cir-
cular
Unidade: grau; sem limitação
SysVar
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
7 Programação de movimento com KRL
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
Valor Atribuição de valor à variável do sistema
Em segmentos: A atribuição vale apenas para esse seg-
mento.
As variáveis do sistema também podem ser ocupadas por 
acesso funcional. Para essas funções valem as mesmas 
restrições das funções no trigger.
C_SPL  Com C_SPL: O ponto de destino é aproximado. $APO 
define o momento mais cedo para a aproximação.
Somente possível para movimentos individuais, não 
para segmentos.
 Sem C_SPL: O ponto de destino é alcançado com exa-
tidão.
Elemento Descrição
As variáveis de sistema estão descritas no capítulo Variáveis de sis-
tema.
181 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
182 / 251
Programação do robô 2
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
8 Trabalho com variáveis de sistema
8 Trabalho com variáveis de sistema
8.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Medição de tempo de ciclo com temporizador
8.2 Medição do tempo de ciclo com temporizador
Descrição da 
medição de ciclo 
com tempori-
zador de sistema 
KUKA
 $TIMER[1]
 $TIMER[2]
 ...
 $TIMER[32]
As variáveis de sistema $TIMER[Nr] servem para a medição de processos de 
tempo.
Iniciar e parar um temporizador com KRL
 INICIAR: $TIMER_STOP[Nr] = FALSE
 PARAR: $TIMER_STOP[Nr] = TRUE
Princípio da 
medição de ciclo
Atribuição prévia de um temporizador
 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
 
T
 
 
Fig. 8-1
A introdução de valores/exibição do temporizador $TIMER[Nr] é rea-
lizada em milissegundos (ms). 
O temporizador também pode ser atribuido, iniciado e parado manu-
almente com janela de exibição.
; Temporizador 5 predefinido com 0ms 
$TIMER[5] = 0
; Temporizador 12 é ajustado em 1,5 segundos
183 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
184 / 251
Programação do robô 2
 Resetar e iniciar um temporizador
 Parar um temporizador e subsequente comparação
Procedimento na 
medição de 
tempo de ciclo
1. Seleção de um temporizador "livre" a partir de 32 elos de tempo possíveis
2. Atribuição / Reset do temporizador
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
$TIMER[12] = 1500
; Temporizador 4 resetado em -8 segundos
$TIMER[4] = -8000
; Temporizador 7 Reset a 0ms
$TIMER[7] = 0
; Iniciar Temporizador 7
$TIMER_STOP[7] = FALSE
; 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.
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
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
8 Trabalho com variáveis de sistema
8.3 Exercício: Medição de ciclo e otimização
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Trabalhar com um temporizador (inicializar, iniciar, parar). 
 Realizar a otimização do ciclo.
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos sobre as variáveis de sistema $TIMER[x]. 
Definição de 
tarefas
Duplique o seu programa "Palete" e atribua o nome "Medição de tempo". De-
verão ser registrados três tempos. O temporizador 1 deverá medir o tempo da 
paletização,o temporizador 2 o processo de retirada e o temporizador 3 o 
tempo geral de ambos processos. Preste atenção para não iniciar ou parar o 
temporizador com o avanço. 
1. Para medir o tempo de paletização, use $TIMER[1] e salve adicionalmen-
te o valor final em $TIMER[4]. 
2. Nomeie $TIMER[1] "Paletização atual“ e $TIMER[4] "Paletização ANTI-
GA". 
3. Para medir o tempo de despaletização, use $TIMER[2] e salve adicional-
mente o valor final em $TIMER[5]. 
4. Nomeie $TIMER[2] "Despaletização atual“ e $TIMER[5] "Despaletização 
ANTIGA". 
5. Para medir o tempo geral é usado $TIMER[3] e salvo em $TIMER[6]. 
6. Nomeie $TIMER[3] "Total atual“ e $TIMER[6] "Total ANTIGO". 
7. Tente otimizar o seu programa de forma adequada.
8. Teste o seu programa nos modos de operação T1, T2 e Automático. Aqui 
devem ser observadas as prescrições de segurança ensinadas. 
O que você deveria saber agora:
1. Quantos temporizadores há na unidade de comando KUKA e como estes 
são iniciados? 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
2. Cite um exemplo para uma variável da $CONFIG.DAT?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
185 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
186 / 251
Programação do robô 2
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
9 Programação de Interrupt
9 Programação de Interrupt
9.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Programação de rotinas Interrupt
 Frear o robô e cancelar os movimentos de deslocamento
9.2 Programação de rotinas de Interrupt
Descrição de 
rotinas de cance-
lamento
 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 
sobre a decla-
ração de Inter-
rupts
 Em um evento definido, p.ex., uma entrada, a unidade de comando inter-
rompe o programa atual e executa um subprograma definido. 
Sintaxe
 Global
 Um Interrupt é reconhecido apenas a partir do nível no qual está de-
clarado.
 
 
Fig. 9-1: Trabalhar com rotinas Interrupt
<GLOBAL> INTERRUPT DECL Prio WHEN Ereignis DO Interruptprogramm
187 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
188 / 251
Programação do robô 2
 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-2: Validade de Interrupts
Fig. 9-3: Prioridades de Interrupts
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
9 Programação de Interrupt
 Evento: Evento, que deve ocorrer no Interrupt.
 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-
ração de um 
Interrupt
 Interrupt local
 Prioridade: 23
 Evento: A entrada 12 é reconhecida como flanco positivo (crescente).
 Programa Interrupt: INTERRUPT_PROG(20,VALUE)
Descrição Ligar/desligar/bloquear/liberar Interrupt
Possibilidades 
através do 
comando 
INTERRUPT ...
Após uma declaração de Interrupt, este deve ser ativado em seguida
 Ativa um Interrupt.
 Desativa um 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 
desativar
Exemplo
Ligar/desligar um Interrupt
Este evento é reconhecido em sua ocorrência através de um flanco 
(disparado por flanco).
INTERRUPT DECL 23 WHEN $IN[12]==TRUE DO 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.
INTERRUPT DECL 20 WHEN $IN[22]==TRUE DO SAVE_POS( )
...
INTERRUPT ON 20
;O Interrupt é detectado e executado (flanco positivo)
189 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
190 / 251
Programação do robô 2
 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.
Bloquear e liberar 
Interrupt
Exemplo
Procedimento 1. Declaração de Interrupt
 Definir a prioridade
 Determinar o evento de disparo
 Definir e criar rotina de Interrupt
...
INTERRUPT OFF 20 ; Interrupt está desligado
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.
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.
DEF MY_PROG( )
INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DOERROR( )
END
_________________________________________________
DEF ERROR() 
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
9 Programação de Interrupt
2. Ativar e desativar Interrupt
3. Expandir o programa com movimentos e definir ações na rotina de Inter-
rupt
Variáveis de 
sistema úteis na 
parada exata
END
DEF MY_PROG( )
INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )
INTERRUPT ON 25
...
...
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR() 
END
DEF MY_PROG( )
INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )
INTERRUPT ON 25
SPTP XHOME
SPTP XP1
SPTP XP2
SPTP XHOME
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR() 
$OUT[20]=FALSE
$OUT[21]=TRUE
END
Fig. 9-4: Variáveis de sistema na parada exata
191 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
192 / 251
Programação do robô 2
Variáveis de 
sistema úteis em 
uma aproximação
Fig. 9-5: Variáveis de sistema na aproximação
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
9 Programação de Interrupt
9.3 Exercício: Trabalhar com Interrupts
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Declaração de um Interrupt 
 Criação de um subprograma Interrupt 
 Avaliação e edição de Interrupts na execução do programa
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos da linguagem de programação KRL
 Conhecimentos teóricos sobre a programação de Interrupts 
Definição de 
tarefas
O objetivo desta tarefa é, através de deslocamento de medição definido, de-
tectar a posição de 3 cubos e salvar estas posições. 
1. Crie um novo programa com o nome "LOCALIZAR".
2. Retire (sem o robô) três cubos do magazine de cubos e coloque-os em 
uma linha sobre a mesa. 
3. Programe um movimento SLIN como deslocamento de localização pelos 
três cubos. A velocidade deve ser definida em 0,2 m/s. 
4. É necessário ativar ou desativar o sensor com a saída 27. Como feedback 
da determinação de posição você recebe um sinal na entrada 27. 
5. Na detecção de um cubo deve ser exibida a posição X, Y e Z do cubo atra-
vés de uma mensagem de informação. Ao mesmo tempo, deve ser salva 
a posição na detecção. Para isto, use um campo, que você cria no DAT-
file local ou no $config.dat.
6. Após o término do deslocamento de localização, as três posições salvas 
devem ser exibidas através de acesso, isto é, acessar a posição, mensa-
gem de informação "Cubo n° X acessado", e então ir à posição seguinte.
7. Teste o seu programa conforme a prescrição. 
O que você deve saber agora:
1. Em qual parte do programa é declarado o Interrupt? 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
2. Qual é a diferença entre INTERRUPT OFF 99 e INTERRUPT DISABLE 99?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
3. Quando é acessado o subprograma Interrupt?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
4. O que faz o comando INTERRUPT OFF no início de um subprograma In-
terrupt?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
5. Qual área de prioridade para o Interrupt não está liberada?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
193 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
194 / 251
Programação do robô 2
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
9 Programação de Interrupt
9.4 Frear o robô e cancelar os movimentos de deslocamento
Descrição  Frear o robô, depois continuar o movimento "antigo". (>>> "Frear o movi-
mento do robô e continuar o movimento "antigo"" Página 195)
 Frear o robô, cancelar o movimento "antigo" e continuar com movimento 
novo. (>>> "Frear o movimento do robô e cancelar o movimento "antigo"" 
Página 196)
Frear o 
movimento do 
robô e continuar 
o movimento 
"antigo"
 O robô é parado com BRAKE e, no final da rotina de Interrupt continua com 
a trajetória planejada do programa principal.
 O robô é parado com BRAKE e deslocado na rotina de Interrupt. Após o 
término da rotina de Interrupt é continuada a trajetória do programa prin-
cipal.
 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
Procedimento 1. Declaração de Interrupt
 Definir a prioridade
 Determinar o evento de disparo
 Definir e criar rotina de Interrupt
 Ativar e desativar Interrupt
2. Expandir o programa com movimentos e frear o robô na rotina de Interrupt 
e definir a lógica
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.
BRAKE somente pode ser usado com um programa Interrupt.
DEF MY_PROG( )
INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )
INTERRUPT ON 25
...
...
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR() 
END
DEF MY_PROG( )
INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )
195 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
196 / 251
Programação do robô 2
Frear o 
movimento do 
robô e cancelar o 
movimento 
"antigo"
 O robô é parado com BRAKE e deve executar uma nova trajetória após o 
término da rotina de Interrupt. Isto pode ser realizado com o comando RE-
SUME.
 O robô é parado com BRAKE e deslocado na rotina de Interrupt. Após o 
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.
Funções de 
RESUME 
 RESUME cancela todos os programas Interrupt em curso e todos os sub-
programas até o nível em que o Interrupt atual foi declarado.
 No momento da instrução RESUME, o indicador de avanço não pode estar 
no nível em que o Interrupt foi declarado, mas deve se encontrar, no mí-
nimo, em um nível abaixo deste.
 RESUME somente pode ocorrer com programas Interrupt.
 Tão logo um Interrupt tenha sido declarado como GLOBAL, não é permiti-
do usar nenhumRESUME na rotina de Interrupt.
 Alterações da variável $BASE no programa Interrupt atuam somente lá.
 O avanço do computador, isto é, a variável $ADVANCE, não pode ser al-
terado no programa Interrupt.
 Movimentos de deslocamento, que devem ser interrompidos com BRAKE 
e RESUME, sempre devem ser programados em um subprograma.
 O comportamento da unidade de comando do robô após RESUME depen-
de da seguinte instrução de movimento:
 Instrução SPTP: É deslocado como movimento SPTP.
 Instrução SLIN:É deslocado como movimento SLIN.
 Instrução SCIRC: Sempre é deslocado como movimento SLIN!
Se a primeira instrução de movimento após RESUME é um movimento 
SCIRC, este sempre é executado como SLIN! Com isto o movimento resulta 
de forma diferente do que originalmente planejado. Este comportamento deve 
ser levado em consideração na programação de instruções RESUME. 
O robô deve poder acessar o ponto de destino do movimento SCIRC sem pe-
rigo como SLIN, a partir de qualquer posição na qual ele poderia se encontrar 
no RESUME.
Procedimento 1. Declaração de Interrupt
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
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.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
9 Programação de Interrupt
 Definir a prioridade
 Determinar o evento de disparo
 Definir e criar rotina de Interrupt
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
3. Processar a rotina de Interrupt
 Parar robô
 Reposicionar o robô para $POS_INT
 Descartar o movimento atual
 Novo movimento no programa principal
DEF MY_PROG( )
INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )
...
END
_________________________________________________
DEF ERROR() 
...
END
DEF MY_PROG( )
INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )
SEARCH()
END
_________________________________________________
DEF SEARCH()
INTERRUPT ON 25
SPTP XHOME
SPTP XP1
SPTP XP2
SPTP XHOME
WAIT SEC 0 ; Parar o ponteiro de avanço
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR() 
...
END
DEF MY_PROG( )
INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )
SEARCH()
END
_________________________________________________
DEF SEARCH()
INTERRUPT ON 25
SPTP HOME
SPTP XP1
SPTP XP2
197 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
198 / 251
Programação do robô 2
SPTP XHOME
WAIT SEC 0 ; Parar o ponteiro de avanço
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR() 
BRAKE
SPTP $POS_INT
RESUME
END
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
9 Programação de Interrupt
9.5 Exercício: Cancelar movimentos de deslocamento com Interrupts
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Declaração de um Interrupt
 Criação de um subprograma Interrupt
 Avaliação e edição de Interrupts na execução do programa
 Frear o movimento do robô com comando KRL
 Frear e cancelar o movimento do robô com comandos KRL
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos da linguagem de programação KRL
 Conhecimentos teóricos sobre a programação de Interrupts
 Conhecimentos teóricos sobre os comandos KRL para frear e cancelar 
movimentos do robô e o seu uso correto
Definição de 
tarefas
Através de deslocamento de medição definido você deve poder identificar a 
posição de 3 cubos e salvar estas posições. Além disso, o deslocamento de 
medição deve ser cancelado imediatamente após a detecção do 3° cubo. 
1. Duplique o seu programa LOCALIZAR e atribua o nome 
"SUCHEN_ABBRUCH" (CANCELAR LOCALIZAR).
2. Retire (sem o robô) três cubos do magazine de cubos e coloque-os em 
uma linha sobre a mesa. 
3. Programe um movimento SLIN como deslocamento de localização pelos 
três cubos. A velocidade deve ser definida em 0,2 m/s. É necessário ativar 
ou desativar o sensor com a saída 27. Como feedback da determinação 
de posição você recebe um sinal na entrada 27. 
4. Na detecção de um cubo deve ser exibida a posição X, Y e Z do cubo atra-
vés de uma mensagem de informação. Ao mesmo tempo, deve ser salva 
a posição na detecção. Para isto, use um campo, que você cria no DAT-
file local ou no $config.dat.
5. O robô deve ser parado imediatamente após a localização do terceiro 
cubo. Após a confirmação da mensagem "Último cubo localizado - o des-
locamento de localização é cancelado" o deslocamento de localização 
deve ser finalizado. 
6. Após o término do deslocamento de localização, as três posições salvas 
devem ser exibidas através de acesso, isto é, acessar a posição, mensa-
gem de informação "Cubo n° X acessado", e então ir à posição seguinte.
7. Teste o seu programa conforme a prescrição
O que você deve saber agora:
1. Qual é a diferença entre BRAKE e BRAKE F? 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
2. Por que o comando RESUME não funciona corretamente aqui? 
INTERRUPT DECL 21 WHEN $IN[1] DO located( ) 
INTERRUPT ON 21 
Pto_inic SLIN 
Pto_final SLIN 
$ADVANCE = 0 
INTERRUPT OFF 21 ... 
END
 ___________________________________________ 
DEF located( ) 
199 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
200 / 251
Programação do robô 2
INTERRUPT OFF 21 
BRAKE 
;pick_part 
RESUME
END 
3. Quando é acionado um Interrupt?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
10 Funções de comutação KRL
10 Funções de comutação KRL
10.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Programação de funções de comutação simples
 Programação de funções de comutação referentes à trajetória com deslo-
camento de tempo
10.2 Programação das funções de comutação simples
Descrição de 
funções de 
comutação 
simples
Generalidades
 A unidade de comando do robô pode administrar no máximo 4096 entradas 
digitais e 4096 saídas digitais.
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
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:
Comutação com 
parada de avanço
Sintaxe
 ativação de uma saída com parada de avanço
 
s
 
 
Fig. 10-1
Fig. 10-2: Formulários Inline de funções de comutação simples
$OUT[10]=TRUE
201 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
202 / 251
Programação do robô 2
 desativação de uma saída com parada de avanço
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
Comutar com o 
avanço
Sintaxe
 ligar uma saída no avanço
 desligar uma saída no avanço
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).
$OUT[10]=FALSE
...
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çãonão passível de aproximação (Módulo nome, 
Passo número)
CONTINUE
$OUT[10]=TRUE
CONTINUE
$OUT[10]=FALSE
...
SLIN XP20
SLIN XP21 C_SPL
CONTINUE
$OUT[30]=TRUE
SLIN XP22 
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
10 Funções de comutação KRL
Comutação de 
uma saída com o 
indicador de 
avanço principal
Sintaxe
 ativação de uma saída com o indicador de avanço principal e sem parada 
de avanço
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
Pulsos de uma 
saída
Sintaxe

Fig. 10-4: Comutação no avanço
$OUT[10]_C=TRUE
...
SLIN XP20
$OUT_C[30]=TRUE
SLIN XP21 C_SPL
SLIN XP22
Fig. 10-5: Comutar com avanço principal
PULSE (Signal, Pegel, Impulsdauer)
203 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
204 / 251
Programação do robô 2
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.
 Exemplo:
 se antes da instrução END for programado um pulso, o período de pro-
cessamento de programa aumenta proporcionalmente
 se a execução do programa for resetada (RESET) ou cancelada (CAN-
CEL) enquanto há um pulso ativo, esse pulso é resetado imediatamente
Elemento Descrição
Sinal Tipo: BOOL
Saída na qual o impulso é criado. São admissíveis:
 OUT[Nr]
 Variável de sinal 
Nível Tipo: BOOL
Expressão lógica:
 TRUE representa um impulso positivo (high).
 FALSE representa um impulso negativo (low).
Duração de 
impulso
Tipo: REAL
p.ex. 1.000.000 segundos
Em PARADA DE EMERGÊNCIA, parada de operação 
ou parada de erro o impulso não é interrompido!
PULSE ($OUT[30], TRUE, 20); Impulso positivo
PULSE ($OUT[31], FALSE, 20); Impulso negativo
...
PULSE($OUT[50],TRUE,2)
END
Fig. 10-6: Exemplo PULSE+END
...
PULSE($OUT[50],TRUE,2)
; O programa agora é resetado ou desselecionado
Fig. 10-7: Exemplo PULSE+RESET
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
10 Funções de comutação KRL
10.3 Programação do trigger em KRL
Descrição O trigger desencadeia uma instrução definida pelo usuário. A unidade de co-
mando do robô executa a instrução paralelamente ao movimento do robô.
Opcionalmente, o trigger pode se referir ao ponto de partida ou ao ponto de 
destino do movimento. A instrução pode ser desencadeada diretamente no 
ponto de referência ou ela ainda pode ser deslocada no espaço e/ou no tem-
po.
Possibilidades da programação
 Formulário Inline Janela de opções Lógica Trigger
 Formulário Inline Spline Trigger
 Programação por meio do comando KRL TRIGGER WHEN PATH
Programação do 
trigger com KRL
Utilização do comando KRL existente para TRIGGER WHEN PATH:
TRIGGER WHEN PATH = Percurso <ONSTART> DELAY = Tempo DO 
Instrução <PRIO = Prioridade>
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.
Fig. 10-8: Trigger
Fig. 10-9: Formulário Inline Spline Trigger
205 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
206 / 251
Programação do robô 2
Deslocamento 
máx.
O ponto de comutação somente pode ser deslocado até determinados limites. 
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.
Elemento Descrição
ONSTART Ponto de referência do trigger
 Com ONSTART: Ponto de partida
 Sem ONSTART: Ponto de destino
Percurso Tipo: REAL; variável, constante ou função; unidade: mm 
(Exceção: em splines PTP sem unidade)
Deslocamento espacial em relação ao ponto de referência. 
Se não for desejado nenhum deslocamento espacial, 
então colocar percurso = 0.
 Valor negativo: Deslocamento no sentido do início do 
movimento
 Valor positivo: Deslocamento no sentido do final do mo-
vimento
 (>>> "Deslocamento máx." Página 206)
Tempo Tipo: REAL; variável, constante ou função; unidade: ms
Deslocamento temporal em relação ao percurso. Se não for 
desejado nenhum deslocamento temporal, então definir 
tempo = 0.
 Valor negativo: Deslocamento no sentido do início do 
movimento
 Valor positivo: O trigger é comutado decorrido o tempo.
 (>>> "Deslocamento máx." Página 206)
Instrução Possível:
 Atribuição de valor para uma variável
Nota: Do lado esquerdo da atribuição não pode haver 
nenhuma variável de tempo de execução.
 Instrução OUT; instrução PULSE; instrução CYCFLAG
 Acesso a um subprograma. Nesse caso, deve ser indi-
cada a prioridade.
Prioridade Tipo: INT; variável ou constante
Prioridade do trigger. Apenas relevante se a instrução 
acessa um subprograma, porém obrigatoriamente.
Estão disponíveis as prioridades 1, 2, 4 - 39 bem como 81 
- 128. As prioridades 40 - 80 estão reservadas para os 
casos, nos quais a prioridade é atribuída automaticamente 
pelo sistema. Se a prioridade deve ser atribuída automati-
camente pelo sistema, programa-se: PRIO = -1.
Se vários triggers acessam subprogramas simultanea-
mente, edita-se primeiramente o trigger com a prioridade 
mais alta, então o trigger com a prioridade mais baixa. 1 = 
prioridade mais alta. 
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
10 Funções de comutação KRL
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 
trigger com KRL
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.
Deslocamento negativo máximo 
até …
Deslocamento positivo máximo 
até …
Até o ponto de partida (se este não 
estiver aproximado)
Até o ponto de destino (se este não 
estiver aproximado)
Se o ponto de partida estiver apro-
ximado: 
 Se o ponto de partida for um 
ponto PTP aproximado: 
Até o fim do arco de aproxima-
ção
 Se o ponto de partida for um ou-
tro ponto aproximado: 
Até o início do arco de aproxi-
mação
Se o ponto de destino estiver apro-
ximado: 
 Na aproximação homogênea: 
até a próxima parada exata de-
pois da instrução TRIGGER
 Na aproximação mista (Spline): 
até o ponto de comutação, que 
um trigger ONSTART com 
PATH = 0 teria, se ele estivesse 
no movimento para dentro do 
qual é aproximado.
 Na aproximação mista (LIN/
CIRC/PTP): Até o início do arco 
de aproximação
1 SPTP P0
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
207 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
208 / 251
Programação do robô 2
Restrições para 
funções no 
Trigger
Os valores para DELAY e PATH podem ser atribuídos através de funções. 
Para estas funções valem as seguintes restrições:
 O programa KRL, que contém a função, deve ter a propriedade Oculto. 
 A função deve ter validade global. 
 As funções somente podem conter as seguintes instruções ou elementos:
 Atribuições de valores
 Instruções IF
 Comentários
 Linhas em branco
 RETURN
 Ler a variável de sistema
 Acessar funções KRL predefinidas10.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-10: Exemplo TRIGGER WHEN PATH (para Spline)
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
10 Funções de comutação KRL
A princípio é possível programar tantos stops condicionais quanto desejado. 
Contudo, no máximo 10 trechos "ponto de frenagem → ponto de stop" podem 
se sobrepor.
Durante um procedimento de frenagem, a unidade de comando do robô exibe 
a seguinte mensagem em T1/T2: Stop condicional ativo (linha {Número de li-
nha}).
Possibilidades da programação
 No spline block (CP e PTP) ou no passo individual spline: Formulário Inli-
ne Janela de opções Lógica Stop condicionado
 Antes de um spline block (CP e PTP): Formulário Inline Spline Stop con-
dicionado
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
Fig. 10-12: Stop condicional
209 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
210 / 251
Programação do robô 2
 Programação por meio do comando KRL STOP WHEN PATH
Stop condi-
cionado com KRL
STOP WHEN PATH = Offset <ONSTART> IFCondição
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
Fig. 10-13: Formulário inline Spline Stop Condition
Elemento Descrição
ONSTART Ponto de referência da instrução
 Sem ONSTART: Ponto de destino
 Com ONSTART: Ponto de partida
Se o ponto de referência estiver aproximado, valem as 
mesmas regras que no PATH trigger. 
Offset Tipo: INT ou REAL; constante, variável ou função; uni-
dade: mm
Através de Offset, o ponto de stop pode ser deslocado no 
espaço.
 Valor positivo: Deslocamento no sentido do final do mo-
vimento
 Valor negativo: Deslocamento no sentido do início do 
movimento
A qual ponto se refere o deslocamento, depende se ONS-
TART está definido ou não. Se nenhum deslocamento for 
desejado, Offset=0 deve ser programado.
O ponto de stop não pode ser deslocado espacialmente de 
maneira livre. São válidos os mesmos limites que no PATH 
trigger. (>>> "Deslocamento máx." Página 206)
Condição Tipo: BOOL
Condição de stop. São admissíveis:
 uma variável booleana global
 um nome de sinal
 uma comparação
 um vínculo lógico simples: NOT, OR, AND ou EXOR
1 SPTP P1
2 SLIN P2
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
10 Funções de comutação KRL
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. 
Se não for possível manter constante a velocidade programada, a unidade de 
comando do robô indica isso através de uma mensagem durante a execução 
do programa. 
Região de deslocamento constante ao longo de vários segmentos:
Uma região de deslocamento constante pode se estender ao longo de diver-
sos segmentos, com diferentes velocidades programadas. Nesse caso a mais 
baixa velocidade vale para toda a região. 
Também nos segmentos com velocidade programada mais elevada, o deslo-
camento nesse caso ocorre com a velocidade mais baixa. Então não é forne-
cida nenhuma mensagem relativa a velocidade abaixo do nível. Isso só ocorre 
se não for possível manter a velocidade mais baixa. 
Possibilidades da programação
 Formulário Inline Janela de opções Lógica Região de deslocamento cons-
tante: o início/final da região é registrado no respectivo segmento CP
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
Fig. 10-14: Área de deslocamento constante Spline
211 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
212 / 251
Programação do robô 2
 Programação por meio do comando KRL CONST_VEL START e 
CONST_VEL END
Região de deslo-
camento 
constante com 
KRL
CONST_VEL START = Offset <ONSTART>
<Segmentos spline …>
...
CONST_VEL END = Offset <ONSTART>
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.
Fig. 10-15: Região de deslocamento constante
Elemento Descrição
ONSTART Ponto de referência da instrução
 Com ONSTART: Ponto de partida
 Sem ONSTART: Ponto de destino
Se o ponto de partida ou de destino estiver aproximado, o 
ponto de referência resulta da mesma forma que na apro-
ximação homogênea no PATH trigger. 
Offset Tipo: INT ou REAL; constante, variável ou função; uni-
dade: mm
Através de CONST_VEL START = Offset, o início da região 
pode ser deslocado no espaço.
Através de CONST_VEL END = Offset, o final da região 
pode ser deslocado no espaço.
 Valor positivo: Deslocamento no sentido do final do mo-
vimento
 Valor negativo: Deslocamento no sentido do início do 
movimento
A qual ponto se refere o deslocamento, depende se ONS-
TART está definido ou não. Se nenhum deslocamento for 
desejado, Offset=0 deve ser programado.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
10 Funções de comutação KRL
Exemplo
Aqui a região de deslocamento constante se estende ao longo de diversos 
segmentos com diferentes velocidades programadas. Nesse caso, a mais 
baixa velocidade, portanto, 0,2 m/s, vale para toda a região. 
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 
com KRL
TIME_BLOCK START
TIME_BLOCK PART = Parcela_N >
TIME_BLOCK END = Tempo total
1 PTP P0
2 SPLINE WITH $VEL.CP = 2.53 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
213 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
214 / 251
Programação do robô 2
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
Elemento Descrição
Parcela Tipo: INT ou REAL; constante, variável ou função
Parcela desejada do tempo total para o seguinte percurso:
 Do ponto antes de TIME_BLOCK PART=parcela_anterior
ao ponto antes de TIME_BLOCK PART=parcela
 Se parcela_anterior não existir:
Do ponto antes de TIME_BLOCK START
ao ponto antes de TIME_BLOCK PART=parcela
Com "parcela desejada", quer-se dizer: As parcelas são 
mantidas tão precisas quanto possível pela unidade de 
comando do robô. Mas geralmente elas não são mantidas 
com precisão. 
O usuário pode atribuir as parcelas de forma que elas jun-
tas resultem em 100. Então ele pode considerar as parce-
las como percentagem do tempo total.
Porém, as parcelas não podem resultar em 100, mas 
podem resultar em qualquer soma! A unidade de comando 
do robô define a soma das parcelas sempre igual ao tempo 
total. Com isso, as parcelas podem ser utilizadas e também 
alteradas de maneira muito flexível.
Quando parcelas são atribuídas, sempre uma 
TIME_BLOCK PART deve estar diretamente antes de 
TIME_BLOCK END. Entre elas não pode haver nenhum 
segmento.
Tempo total Tipo: INT ou REAL; constante, variável ou função; uni-
dade: s
Tempo em que o seguinte percurso é executado:
 Do ponto antes de TIME_BLOCK START
ao ponto antes de TIME_BLOCK END
O valor deve ser maior que 0. O tempo total é mantido com 
precisão. Se ele não puder ser mantido, p. ex., porque um 
tempo muito curto foi programado, o robô se move o mais 
rápido possível. Além disso, em T1 e T2, é exibida uma 
mensagem.
Se o valor para parcela ou tempo total for atribuído através de uma fun-
ção, valem as mesmas restrições para as funções no trigger.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
10 Funções de comutação KRL
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.
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.
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.
SPLINE
 SLIN P1 
 SPL P2
 TIME_BLOCK START
 SLIN P3
 TIME_BLOCK PART = 12.7
 SPL P4
 SPL P5
 SPL P6
 TIME_BLOCK PART = 56.4
 SCIRC P7, P8
 SPL P9
 TIME_BLOCK PART = 27.8
 TIME_BLOCK END = 3.9
 SLIN P10
ENDSPLINE
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 na linha … Bloco de tempo é planejado?
No Spline Block, antes de 
TIME_BLOCK START
Sim
TIME_BLOCK START Não
O Spline Block é executado como 
se não houvesse nenhuma instru-
ção TIME_BLOCK.
No bloco de tempo
TIME_BLOCK END
No Spline Block, após 
TIME_BLOCK END
215 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
216 / 251
Programação do robô 2
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
11 Interpretador Submit
11 Interpretador Submit
11.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Utilização do Interpretador Submit
11.2 Status do Interpretador Submit
Descrição do 
Interpretador 
Submit
No KSS 8.x rodam duas Tasks
 Interpretador de robô (execução dos programas de movimento do robô e 
sua lógica)
 Interpretador de comando (execução de um programa de controle parale-
lo)
Estrutura do programa SPS.SUB:
O estado do Interpretador Submit
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 
 
t
t
 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 Interpretador Submit 
está em execução
Interpretador Submit 
parado
Interpretador Submit 
desselecionado
217 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
218 / 251
Programação do robô 2
Correlações na 
programação do 
Interpretador 
Submit
 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.
 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.
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.
 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.
Atenção!
O Interpretador Submit não pode ser usado para aplica-
ções críticas de tempo! Para estes casos é necessário usar um PLC. Moti-
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.
$PRO_I_O[]="/R1/SPS()"
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.
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
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
11 Interpretador Submit
Procedimento na 
programação do 
Interpretador 
Submit
1. A programação ocorre no estado paradoou desselecionado.
2. O programa padrão SPS.sub é carregado no editor.
3. Executar declarações necessárias e a inicialização. Aqui devem ser admi-
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
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.
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
219 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
220 / 251
Programação do robô 2
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
12 Trabalhar com sinais analógicos
12 Trabalhar com sinais analógicos
12.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Programar entradas analógicas
 Programar saídas analógicas
12.2 Programar entradas analógicas
Descrição
 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
 Atribuição de valores de um acordo de sinais
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).
2
 
T
 
Fig. 12-1: Sinais analógicos
...
REAL value
value = $ANIN[2]
...
...
SIGNAL sensor $ANIN[6]
REAL value
value = sensor
...
221 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
222 / 251
Programação do robô 2
 São permitidas, no máximo, três instruções ANIN ON simultaneamente.
 No máximo duas instruções ANIN ON podem usar a mesma variável Valor 
ou acessar a mesma entrada analógica.
 Sintaxe
 Iniciar leitura cíclica:
ANIN ON valor = fator * nome do sinal <±Offset>
 Finalizar a leitura cíclica:
ANIN OFF nome do sinal
 Exemplo 1:
 Exemplo 2:
Elemento Descrição
Valor Tipo: REAL
Em Valor é gravado o resultado da leitura cíclica. Valor 
pode ser uma variável ou um nome do sinal para uma 
saída.
Fator Tipo: REAL
Fator qualquer. Pode ser uma constante, uma variável ou 
um nome do sinal.
Nome do 
sinal
Tipo: REAL
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.
DEFDAT myprog
DECL REAL value = 0
ENDDAT
DEF myprog( )
SIGNAL sensor $ANIN[3]
...
ANIN ON value = 1.99*sensor-0.75
...
ANIN OFF sensor
DEFDAT myprog
DECL REAL value = 0
DECL REAL corr = 0.25
DECL REAL offset = 0.45
ENDDAT
DEF myprog( )
SIGNAL sensor $ANIN[7]
...
ANIN ON value = corr*sensor-offset
...
ANIN OFF sensor
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
12 Trabalhar com sinais analógicos
Procedimento na 
programação 
com entradas 
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
 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
Atribuição estática de valores
 atribuição direta de valores
 atribuição de valores através de variáveis
O pré-requisito para o uso dos sinais analógicos é uma 
projeção correta do sistema de bus com os sinais analó-
gicos conectados.
Fig. 12-2: Sinais analógicos
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.
...
ANOUT[2] = 0.7 ; 14 mA (70%) na saída analógica 2 (no módulo 0-20 mA)
...
...
REAL value
value = -0.8
223 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
224 / 251
Programação do robô 2
 Programação através de formulário Inline
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>
ANOUT[4] = value ; -8 V (80%) na saída analógica 4 (no módulo -10 V - 
10 V)
...
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)
Elemento Descrição
Nome do 
sinal
Tipo: REAL
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 
regulador
Tipo: REAL
Pode ser uma constante, uma variável ou um nome do 
sinal.
Offset Tipo: REAL
Pode ser uma constante, uma variável ou um nome do 
sinal.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
12 Trabalhar com sinais analógicos
 Finalizar a gravação cíclica:
ANOUT OFF nome do sinal
 Exemplo 1
 Exemplo 2
Procedimento na 
programação 
com saídas 
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:
Tempo Tipo: REAL
Unidade: Segundos. Com a palavra-chave DELAY e uma 
indicação de tempo positiva ou negativa o sinal de saída 
podeser emitido com retardo (+) ou antecipado (-).
Valor mínimo, 
Valor máximo
Tipo: REAL
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.
DEF myprog( )
SIGNAL motor $ANOUT[3]
...
ANOUT ON motor = 3.5*$VEL_ACT-0.75 DELAY=0.5
...
ANOUT OFF motor
DEFDAT myprog
DECL REAL corr = 1.45
DECL REAL offset = 0.25
ENDDAT
DEF myprog( )
SIGNAL motor $ANOUT[7]
...
ANOUT ON motor = corr*$VEL_ACT-offset
...
ANOUT OFF motor
Elemento Descrição
O pré-requisito para o uso dos sinais analógicos é uma 
projeção correta do sistema de bus com os sinais analó-
gicos conectados.
225 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
226 / 251
Programação do robô 2
Fig. 12-4: Exemplo de sinal de saída analógico
DEF myprog( )
SIGNAL motor $ANOUT[3]
...
ANOUT ON motor = 3.375*$VEL_ACT MINIMUM=0.30 MAXIMUM=0.97
...
ANOUT OFF motor
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
12 Trabalhar com sinais analógicos
12.4 Exercício: Trabalhando com E/Ss analógicas
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Uso de acordos de sinais em entradas/saídas
 Inclusão estática ou dinâmica de entradas analógicas em processos de 
trabalho
 Inclusão estática ou dinâmica de saídas analógicas em processos de tra-
balho
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos teóricos de acordos de sinais 
 Conhecimentos teóricos sobre a inclusão de entradas/saídas analógicas
Definição de 
funções
Configure o seu sistema de tal forma, que você possa alterar o override de 
programa através da entrada analógica. Adicionalmente a velocidade de robô 
efetivamente percorrida deve controlar uma saída analógica.
Tarefa parcial 1
1. Crie um programa com o nome Velocidade. 
2. Use a entrada analógica 1, que é controlada pelo potenciômetro. 
3. Adapte o override de programa no Interpretador Submit. 
4. Teste o seu programa conforme a prescrição. 
Tarefa parcial 2
1. Expanda o seu programa com movimentos de trajetória (velocidade: até 
2 m/s), que estão em um loop sem fim. 
2. Use a saída analógica 1, da indicação do painel. 
3. Use a variável de sistema $VEL_ACT para a velocidade atualmente exe-
cutada.
4. Teste o seu programa conforme a prescrição. 
5. Adicionalmente: Se a velocidade for menor que 0,2 m/s a saída deve mes-
mo assim ser sujeitada com 1,0 V e se a velocidade foi maior que 1,8 m/
s a saída não deve emitir mais que 9,0 V. 
O que você deve saber agora:
 1. Quantas E/S analógicas podem ser usadas na unidade de comando KRC? 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
2. Quantas entradas digitais, entradas analógicas e saídas analógicas prede-
finidas a unidade de comando KUKA pode usar simultaneamente?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
3. Como se chamam os comandos KRL para a inicialização e finalização cí-
clica da saída analógica?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
4. Como é consultada estaticamente uma entrada analógica?
Tome o cuidado para ativar somente uma vez a E/S analógica.
227 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
228 / 251
Programação do robô 2
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
13 Anexo
13 Anexo
13.1 Programar movimentos com KRL
Definição de um 
movimento
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 
programação de 
movimento
Tipo de movimento PTP
 PTP Ponto de destino <Aproximação>
 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
 
A
x
Fig. 13-1: Formulários Inline de movimento PTP/LIN/CIRC
Elemento Descrição
Ponto de des-
tino
Tipo: POS, E6POS, AXIS, E6AXIS, FRAME
O ponto de destino pode ser cartesiano ou específico do 
eixo. As coordenadas cartesianas referem-se ao sistema 
de coordenadas BASE.
Se não forem informados todos os componentes do ponto 
de destino, a unidade de comando para os componentes 
faltantes assume os valores da posição anterior.
Aproximação C_PTP
 Faz com que o ponto de destino seja aproximado.
 Na aproximação PTP-PTP a informação C_PTP é 
suficiente.
C_DIS
 Somente para aproximação PTP-CP. Esse parâ-
metro define o momento mais cedo para a aproxi-
mação. Estas indicações são possíveis:
 Parâmetro de distância: O momento mais cedo 
para iniciar a aproximação é quando a distância ao 
ponto de destino estiver abaixo de $APO.CDIS.
PTP XP3 C_PTP
229 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
230 / 251
Programação do robô 2
 O robô acessa uma posição inserida
 Específico do eixo (AXIS ou E6AXIS)
 Posição espacial (com ferramenta e base atualmente ativas)
 O robô só opera com a inserção de um ou mais agregados
Tipo de movimento LIN
 LINPonto de destino <Aproximação da trajetória>
 O robô se movimenta em uma posição calculada aproximando esse ponto 
ABLAGE[4]
Tipo de movimento CIRC
 CIRC Ponto auxiliar, ponto de destino < Ângulo inscrito (CA)> <Aproximação 
da trajetória>
PTP {A1 0, A2 -80, A3 75, A4 30, A5 30, A6 110}
PTP {X 100, Y -50, Z 1500, A 0, B 0, C 90, S 3, T 35}
PTP {A1 30} ; só A1 é deslocado para 30°
PTP {X 200, A 30} ; só em X para 200mm e A para 30°
Elemento Descrição
Ponto de des-
tino
Tipo: POS, E6POS, FRAME
Se não forem informados todos os componentes do ponto 
de destino, a unidade de comando para os componentes 
faltantes assume os valores da posição anterior.
Os dados Status e Turn dentro do ponto de destino do tipo 
POS ou E6POS são ignorados em movimentos LIN (assim 
como em movimentos CIRC).
As coordenadas referem-se ao sistema de coordenadas 
BASE.
Aproximação 
da trajetória
Esse parâmetro faz com que o ponto de destino seja apro-
ximado. Ao mesmo tempo define o momento mais cedo 
para a aproximação. Os possíveis dados:
 C_DIS
Parâmetro de distância: O momento mais cedo 
para iniciar a aproximação é quando a distância ao 
ponto de destino estiver abaixo de $APO.CDIS.
 C_ORI
Parâmetros de orientação: O momento mais cedo 
para iniciar a aproximação é quando o ângulo de 
orientação estiver abaixo de $APO.CORI.
 C_VEL
Parâmetros de velocidade: O momento mais cedo 
para iniciar a aproximação é quando a velocidade 
na fase de frenagemao ponto de destino estiver 
abaixo de $APO.CVEL.
LIN ABLAGE[4] C_DIS
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
13 Anexo
Elemento Descrição
Ponto auxiliar Tipo: POS, E6POS, FRAME
Se não forem informados todos os componentes do ponto 
auxiliar, a unidade de comando assume para os compo-
nentes faltantes os valores da posição anterior.
Os ângulos de orientação, assim como os dados Status e 
Turn dentro de um ponto auxiliar normalmente são ignora-
dos.
O ponto auxiliar não pode ser aproximado. Ele é percorrido 
no tipo de execução do programa GO. No tipo de execução 
do programa Movimento o robô para no ponto auxiliar.
As coordenadas referem-se ao sistema de coordenadas 
BASE.
Ponto de des-
tino
Tipo: POS, E6POS, FRAME
Se não forem informados todos os componentes do ponto 
de destino, a unidade de comando para os componentes 
faltantes assume os valores da posição anterior.
Os dados Status e Turn dentro do ponto de destino do tipo 
POS ou E6POS são ignorados em movimentos CIRC 
(assim como em movimentos LIN).
As coordenadas referem-se ao sistema de coordenadas 
BASE.
Ângulo 
inscrito
CA
Indica o ângulo total do movimento circular. Isso possibilita 
uma prorrogação do movimento além do ponto de destino 
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 
da trajetória
Esse parâmetro faz com que o ponto de destino seja apro-
ximado. Ao mesmo tempo define o momento mais cedo 
para a aproximação. Os possíveis dados:
 C_DIS
Parâmetro de distância: O momento mais cedo 
para iniciar a aproximação é quando a distância ao 
ponto de destino estiver abaixo de $APO.CDIS.
 C_ORI
Parâmetros de orientação: O momento mais cedo 
para iniciar a aproximação é quando o ângulo de 
orientação estiver abaixo de $APO.CORI.
 C_VEL
Parâmetros de velocidade: O momento mais cedo 
para iniciar a aproximação é quando a velocidade 
na fase de frenagem ao ponto de destino estiver 
abaixo de $APO.CVEL.
231 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
232 / 251
Programação do robô 2
 O robô acessa as posições previamente programadas do arquivo DAT e 
percorre um ângulo inscrito de 190°.
 O robô acessa as posições indicadas e percorre um ângulo inscrito de 
180°.
 Ângulo inscrito CA
 Ângulo inscrito positivo (CA>0): O círculo é operado no sentido pro-
gramado: ponto de partida-ponto auxiliar-ponto de destino
 Ângulo inscrito negativo (CA<0): o círculo é operado contra o sen-
tido programado: ponto de partida-ponto de destino-ponto auxiliar
CIRC XP3, XP4, CA 190
CIRC {X 100, Y ...}, {X 150, Y ...}, CA 180
No ponto de destino real é usada a orientação ensinada no ponto de 
destino programado.
Fig. 13-2: Ângulo do círculo CA = +290°
Fig. 13-3: Ângulo do círculo CA = -290°
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
13 Anexo
Função dos 
parâmetros de 
movimento
Configurações prévias para a programação de movimento
 Podem ser assumidas as configurações existentes:
 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
 Ativação dos respectivos dados de carga
 Base de referência / base de trabalho: $BASE
 Ativação da base medida
 Ferramenta conduzida pelo robô ou externa: $IPO_MODE
 Ferramenta conduzida por robô
 Ferramenta externa
 Velocidade:
 Em movimento PTP
 Em movimentos de trajetória LIN ou CIRC
 Aceleração
 Em movimento PTP
 Em movimentos de trajetória LIN ou CIRC
 Solavanco
 Em movimento SPTP
$TOOL = tool_data[x] ; x = 1...16
$LOAD = load_data[x] ; x = 1...16
$BASE = base_data[x] ; x = 1...32
$IPO_MODE = #BASE
$IPO_MODE = #TCP
$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).
$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
233 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
234 / 251
Programação do robô 2
 Em movimentos de trajeto SLIN ou SCIRC
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
 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 
 Somente em movimento PTP: C_PTP
 Em movimentos de trajetória LIN, CIRC: C_ORI
O ângulo de orientação dominante deverá ficar abaixo do valor 
$APO.CORI 
 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 
 Controle de orientação: Somente para LIN e CIRC
 Para LIN e CIRC: $ORI_TYPE

Durante o movimento de trajetória a orientação permanece cons-
tante. Para o ponto final, a orientação programada é ignorada 
$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
$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}}
SLIN XP13 WITH $JERK = {CP 44} ; [m/s³] Alteração da aceleração de 
trajeto
$APO.CDIS = 250.0 ; [mm] Distância
SPTP XP3 C_SPL
SLIN XP4 C_SPL
$APO.CPTP = 50 ; Tamanho de aproximação em [%] em C_PTP
PTP XP3 C_PTP
$APO.CORI = 50.0 ; [°] Ângulo
SLIN XP4 C_ORI
$APO.CVEL = 75.0 ; [%] Porcentagem
LIN XP4 C_VEL
$ORI_TYPE = #CONSTANT
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
13 Anexo

Durante o movimento de trajetória, a orientação é alterada conti-
nuamente até a orientação do ponto de destino.

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

Controle de orientação referente à trajetória durante o movimento 
circular
Fig. 13-4: Orientação constante
$ORI_TYPE = #VAR
Fig. 13-5: Padrão ou PTP manual
$ORI_TYPE = #JOINT
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
235 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
236 / 251
Programação do robô 2

Controle de orientação referente ao espaço durante o movimento 
circular 
Procedimento na 
programação de 
movimentos com 
KRL
1. Abrir o programa como perito. 
2. Verificar os ajustes prévios para a programação de movimentos e aplicar 
ou inicializar novamente:
 Ferramenta ($TOOL e $LOAD)
 Configuração-base ($BASE)
 Ferramenta conduzidapelo robô ou externa ($IPO_MODE)
 Velocidade
 Aceleração
 Distância de aproximação, caso se aplique
 event. controle de orientação
3. Criar comando de movimento que consiste de:
 Tipo de movimento (PTP, LIN, CIRC)
 Ponto de destino (para CIRC também ponto auxiliar)
 em CIRC event. ângulo inscrito (CA)
Fig. 13-6: Orientação constante, referente ao trajeto
$CIRC_TYPE = #BASE
Fig. 13-7: Orientação constante, referente à base
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
13 Anexo
 Ativar aproximação (C_PTP, C_DIS, C_ORI, C_VEL)
4. No caso de novo movimento, retornar ao ponto 3
5. Fechar editor e salvar
13.2 Variáveis de sistema
13.2.1 $ACC
Descrição Aceleração do TCP no avanço
A variável do tipo de estrutura CP contém a aceleração cartesiana programa-
da para os seguintes componentes:
 CP: Aceleração de trajeto em [m/s2]
 ORI1: Aceleração de oscilação em [°/s2]
 ORI2: Aceleração de rotação em [°/s2]
Valores-limite para a aceleração cartesiana:
 0.0 … $ACC_MA
A aceleração cartesiana máxima $ACC_MA está definida nos dados da 
máquina.
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
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
13.2.3 $ACC_EXTAX
Descrição Aceleração dos eixos adicionais no avanço
Outras informações sobre as variáveis $ACC_MA encontram-se na 
documentação relativa aos dados de máquina.
$ACC={CP 5.0,ORI1 500.0,ORI2 500.0}
Elemento Descrição
Número de 
eixo
Tipo: INT
 1 … 6: eixo de robô A1 … A6
Aceleração Tipo: INT; unidade: %
 1 … 100
237 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
238 / 251
Programação do robô 2
A variável contém a aceleração planejada do eixo em porcentagem. Em caso 
de movimentos que são planejados com a ajuda do modelo dinâmico, o valor 
percentual se refere aos momentos de eixo disponíveis para a aceleração.
Se não existir nenhum modelo dinâmico, o valor percentual se refere às ace-
lerações máximas dos eixos definidas nos dados da máquina através de 
$RAISE_TIME (variável no arquivo …R1\Mada\$machine.dat).
Sintaxe $ACC_EXTAX[Número de eixo]=Aceleração
Explicação da 
sintaxe
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
Elemento Descrição
Número de 
eixo
Tipo: INT
 1 … 6: eixo adicional E1 … E6
Aceleração Tipo: INT; unidade: %
 1 … 100
Elemento Descrição
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.
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
13 Anexo
CPTP O parâmetro de aproximação CPTP atua de forma diferente, dependendo se 
está programado um movimento PTP ou spline PTP (SPTP).
 Em um movimento PTP, o valor percentual indicado com CPTP se refere 
a um ângulo de eixo definido com $APO_DIS_PTP nos dados de máqui-
na. Assim que todos os eixos ficarem abaixo de sua distância definida de 
aproximação, será aproximado.
Porém, mais cedo começa a aproximação quando 50% do comprimento 
de passo tiver sido atingido. Ou seja, mais cedo será aproximado quando 
tiver sido realizada a metade do percurso entre o ponto de partida e o pon-
to de destino, relativamente ao contorno do movimento PTP sem aproxi-
mação.
 Esta limitação em 50% vale também em caso de aproximação entre 2 mo-
vimentos individuais SPTP. Na aproximação entre splines PTP, que são 
programados como um dos vários segmentos nos Spline Blocks, não está 
definido quando é possível começar com a aproximação. Ou seja, é co-
meçada com a aproximação como definido com CPTP.
 Na aproximação entre splines PTP, o valor percentual indicado com 
CPTP se refere ao percurso do último segmento do spline no primeiro 
Spline Block e ao percurso do primeiro segmento do spline no Spline Blo-
ck subsequente, a colocar de volta no espaço de eixo todos os eixos do 
robô e, com isso, eixos adicionais acoplados matematicamente.
13.2.5 $BASE
Descrição Sistema de coordenadas BASE no avanço
A variável do tipo de estrutura FRAME descreve a posição nominal da peça 
referente ao sistema de coordenadas WORLD.
 X, Y, Z: Deslocamento da origem ao longo dos eixos em [mm]
 A, B, C: Rotação do ângulo de eixo em [°]
13.2.6 $CIRC_TYPE
Descrição Controle de orientação de CIRC no avanço
A variável contém o controle programado de orientação de um movimento cir-
cular. Esta é referente à base ou referente ao trajeto.
Sintaxe $CIRC_TYPE=Tipo
Explicação da 
sintaxe
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:
Elemento Descrição
Tipo Tipo: ENUM
 #BASE: Controle de orientação referente à base
 #PATH: Controle de orientação referente ao trajeto
239 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
240 / 251
Programação do robô 2
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
13.2.8 $GEAR_JERK
Descrição Solavanco de redutor dos eixos no avanço
Com as variáveis, é determinadoo 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.
Movimento Efeito?
PTP Sim
LIN Não
CIRC Não
Movimentos Spline CP (Block e passo indivi-
dual)
Com perfil de deslocamento mais elevado
Sim
Movimentos Spline CP (Block e passo indivi-
dual)
Sem perfil de deslocamento mais elevado
Não
Movimentos Spline PTP (Block e passo indivi-
dual)
Sim
Elemento Descrição
Nível Tipo: ENUM
 #OFF: O modo de economia de energia está desligado.
 #LOW: Baixa economia
 #MIDDLE: Economia média
 #HIGH: Alta economia
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
13 Anexo
Sintaxe $GEAR_JERK[Número do eixo]=Solavanco de redutor
Explicação da 
sintaxe
13.2.9 $IPO_MODE
Descrição Modo de interpolação programado no avanço
Sintaxe $IPO_MODE=Modo
Explicação da 
sintaxe
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).
O agregado consiste nos seguintes componentes:
 CP: Alteração da aceleração de trajeto em [m/s3] 
 ORI: Alteração da aceleração de orientação em [°/s3] 
 AX: Alteração da aceleração do eixo em [°/s3] em eixos rotatórios ou em 
[m/s3] em eixos lineares
O solavanco máximo permitido para movimentos SPLINE está definido nos 
dados da máquina (variável $JERK_MA no arquivo …R1\Mada\$machi-
ne.dat).
Exemplo
13.2.11 $LOAD
Descrição Dados de carga atuais válidos no avanço
Elemento Descrição
Número de 
eixo
Tipo: INT
 1 … 6: eixo de robô A1 … A6
 7 … 12: eixo adicional E1 … E6
Solavanco de 
redutor
Tipo: INT; unidade: %
 1 … 100
Elemento Descrição
Modo Tipo: ENUM
 #TCP: a ferramenta é uma ferramenta fixa.
 #BASE: a ferramenta está montada no flange de mon-
tagem.
Padrão: #BASE
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.)
$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}}
241 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
242 / 251
Programação do robô 2
A estrutura contém os dados de capacidade de carga, os quais são introduzi-
dos na unidade de comando do robô e atribuídos à ferramenta atual. O siste-
ma de coordenadas de referência é o sistema de coordenadas FLANGE.
 (>>> "Cargas no robô" Página 242)
Sintaxe $LOAD={M Massa, CM Centro de gravidade, J Inércia}
Explicação da 
sintaxe
Cargas no robô No robô podem ser montadas diferentes cargas:
 Carga no flange
 Carga adicional no eixo 3
 Carga adicional no eixo 2
 Carga adicional no eixo 1
Parâmetro Os dados de carga são definidos através dos seguintes parâmetros:
Elemento Descrição
Massa Tipo: REAL; unidade: kg
Centro de 
gravidade
Tipo: FRAME
 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
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
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
13 Anexo
Sistemas de referência dos valores X, Y, Z para cada carga:
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
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
Parâmetro Unidade
Massa m kg
Distância até o Lx, Ly, Lz mm
Inércia de massa no 
centro de gravidade
Ix, Iy, Iz kg m2
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°
Elemento Descrição
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.
243 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
244 / 251
Programação do robô 2
Explicação da 
sintaxe
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
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]
Elemento Descrição
Sistema de 
referência
Tipo: ENUM
 #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
Elemento Descrição
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
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
13 Anexo
 ORI1: Velocidade de oscilação em [°/s]
 ORI2: Velocidade de rotação em [°/s]
Valores-limite para a velocidade cartesiana:
 0.0 … $VEL_MA
A velocidade cartesiana máxima $VEL_MA está definida nos dados da 
máquina.
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
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
13.2.18 $VEL_EXTAX
Descrição Velocidade dos eixos adicionais noavanç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
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
Outras informações sobre as variáveis $VEL_MA encontram-se na 
documentação relativa aos dados de máquina.
$VEL={CP 2.0,ORI1 300.0,ORI2 300.0}
Elemento Descrição
Número de 
eixo
Tipo: INT
 1 … 6: eixo de robô A1 … A6
Velocidade Tipo: INT; unidade: %
 1 … 100
Elemento Descrição
Número de 
eixo
Tipo: INT
 1 … 6: eixo adicional E1 … E6
Velocidade Tipo: INT; unidade: %
 1 … 100
245 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
246 / 251
Programação do robô 2
Em movimentos SCIRC, a unidade de comando do robô pode levar em con-
sideração a orientação programada do ponto auxiliar. Com $CIRC_MODE é 
possível determinar se e até que ponto ela é levada em consideração.
Além disso, com $CIRC_MODE é possível determinar se, em caso de instru-
ções SCIRC com ângulo circular, o ponto de destino deve ter a orientação 
programada ou se a orientação deve ser correspondentemente escalada ao 
ângulo circular.
$CIRC_MODE é gravável apenas através de uma instrução SCIRC. 
$CIRC_MODE não pode ser lido.
Sintaxe Para pontos auxiliares:
$CIRC_MODE.AUX_PT.ORI=Comportamento PA
Para pontos de destino:
$CIRC_MODE.TARGET_PT.ORI=Comportamento PD
Explicação da 
sintaxe
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.
Elemento Descrição
Compor-
tamento PA
Tipo: ENUM
 #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-
tamento PD
Tipo: ENUM
 #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
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
13 Anexo
 Se precedido por um segmento spline, para o qual vale $ORI_TYPE = 
#IGNORE, então #EXTRAPOLATE não pode ser definido para o ponto de 
destino.
Exemplo:
Ponto auxiliar
O TCP se move 192° em arco com modo cartesiano. 
 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:
Ponto de destino
O exemplo mostra esquematicamente o comportamento de #INTERPOLATE 
e #EXTRAPOLATE.
 As setas claras tracejadas indicam a orientação programada.
 As setas escuras indicam a orientação real se ela for diferente da orienta-
ção programada.
#INTERPOLATE: 
Em TP, que se encontra antes de TP_CA, a orientação programada ainda não 
está atingida. Em TP_CA a orientação programada é assumida.
Fig. 13-9: #INTERPOLATE
SP Ponto de partida
AuxP Ponto auxiliar
TP Ponto de destino programado
TP_CA Ponto de destino real. Resulta do ângulo circular.
247 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
248 / 251
Programação do robô 2
#EXTRAPOLATE: 
Em TP a orientação programada é assumida. Para TP_CA esta orientação é 
escalada de acordo com o ângulo circular.
Fig. 13-10: #EXTRAPOLATE
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
Index
Index
Símbolos
, projeto WorkVisual 35
$ACC 237
$ACC_AXIS 237
$ACC_EXTAX 237
$ACC_MA 237
$APO 238
$BASE 239
$CIRC_MODE 149, 245
$CIRC_TYPE 239
$ECO_LEVEL 239
$GEAR_JERK 240
$IPO_MODE 241
$JERK 241
$JERK_MA 241
$LOAD 241
$ORI_TYPE 243
$RAISE_TIME 237, 238
$ROTSYS 243
$SPL_ORI_JOINT_AUTO 244
$TIMER r 183
$TOOL 244
$VEL 244
$VEL_AXIS 245
$VEL_AXIS_MA 245
$VEL_EXTAX 245
$VEL_MA 245
A
Acordos 75
Administrador 65
Ajuda 9
Anexo 229
Array 87
Ativar o projeto na unidade de comando do robô 
32
Avanço 77
B
Barra de menu 9
Barras de botões 9
Bloco de tempo 213
C
Campos 87
Cargas 242
Cargas no robô 242
Catálogos (janela) 9
centro de gravidade 243
Comentário 57
Comparar projetos 14
D
DECL 76, 78
Declarar Interrupt, exercício 193
Declaração 76, 79
DEFFCT 111
Diálogo 135
E
E/Ss analógicas, exercício 227
Editor KRL 41
EKrlMsgType 117
Emitente 116
Entradas analógicas 221
ENUM 98
Estrutura 93
Estrutura de projeto (janela) 9
Estrutura de projeto WorkVisual (guia Arquivos) 
13
Exemplo PAP 64
F
Fluxograma do programa, PAP 62
Funções 101, 111, 113
Funções de comutação 201
Funções padrão 82, 113
Funções para a emissão de mensagens 113
Funções para variável string 113
Funções, matemáticas 113
G
Global 187
global 77
Grupo de usuários, padrão 65
I
Individual (item de menu) 85
Inicialização 80
Interpretador Submit 217
Interrupt 187
Interrupt Cancelar movimentos de deslocamen-
to, exercício 199
Inércia de massa 243
K
KrlMsg_T 116
KrlMsgDlgSK_T 133
KrlMsgOpt_T 118
L
local 77
M
Manipulação 82, 83
Massa 243
Mensagem de confirmação 115, 127
Mensagem de diálogo 115
Mensagem de espera 115, 130
Mensagem de estado 115, 124
Mensagem de informação 115, 121
Mensagens 115
Mensagens (janela) 9
Mensagens de usuário 115
Modo de interpolação 241
Modos WorkVisual 12
Método de programação, exemplo PAP 64
249 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
250 / 251
Programação do robô 2
N
Nomes de dados 62
Nível de perito 65
Número da mensagem 116
O
Operador 65
Operações Bit 82
Operações comparativas 82
Operações lógicas 82
P
Palavra chave 77
PAP 62
Pasta 59
Pinar 34
Prioridade 84, 188, 206
Programador 65
Programar diálogo, exercício 139
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
Template35
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
Transmitir o projeto à unidade de comando do 
robô (instalar) 18
V
Variáveis 75, 78
Variáveis de sistema 183
Variável, alterar 85
Variável, exibir individualmente 85
Vida útil 77
Visão geral da interface de operação WorkVisual 
8
W
WITH (variáveis permitidas de sistema) 153, 181
Z
Ângulo inscrito 231
Áreas de trabalho (janela) 9
Ícones PAP 62
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
251 / 251Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4
Programação do robô 2
	Programação do robô 2
	1 Programação com WorkVisual
	1.1 Visão geral
	1.2 Gerenciar projeto com o WorkVisual
	1.2.1 Vinculação de um PC WorkVisual à unidade de comando
	1.2.2 Visão geral da interface de operação WorkVisual
	1.2.3 Carregar projeto existente no WorkVisual
	1.2.4 Gravar localmente o projeto WorkVisual
	1.2.5 Modos WorkVisual
	1.2.6 Estrutura de projeto WorkVisual (guia Arquivos)
	1.2.7 Comparar projetos com WorkVisual
	1.2.8 Transmitir o projeto à unidade de comando do robô (instalar)
	1.2.9 Atribuir o projeto à unidade de comando do robô real
	1.2.10 Ativar o projeto na unidade de comando do robô
	1.3 Processar programas KRL com WorkVisual
	1.3.1 Importar manuseio de arquivos
	1.3.2 Ativar Templates de catálogo
	1.3.3 Manuseio com o editor KRL
	1.4 Exercício: Editar um projeto ativo no WorkVisual
	2 Programação estruturada
	2.1 Visão geral
	2.2 Objetivo de um método de programação padronizado
	2.3 Recursos auxiliares para a criação de programas de robô estruturados
	2.4 Como é elaborado um fluxograma do programa
	3 Introdução no nível de perito
	3.1 Visão geral
	3.2 Usar nível de perito
	3.3 Exercício: Medição de ferramentas e base
	3.4 Exercício: Navigator perito loop sem fim
	4 Variáveis e acordos
	4.1 Visão geral
	4.2 Manutenção de dados no KRL
	4.3 Trabalhar com tipos de dados simples
	4.3.1 Declaração de variáveis
	4.3.2 Inicialização de variáveis com simples tipos de dados
	4.3.3 Manipulação de valores de variáveis de tipos de dados simples com KRL
	4.4 Exibir variáveis
	4.5 Arrays / Campos com KRL
	4.6 Exercício: Campos com tipos de dados simples e loop de contagem
	4.7 Estruturas com KRL
	4.8 Exercício: Criar estruturas com KRL
	4.9 O tipo de dados de enumeração ENUM
	4.10 Exercício: Criar tipo de enumeração com KRL
	5 Subprogramas e funções
	5.1 Visão geral
	5.2 Trabalhar com subprogramas locais
	5.3 Trabalhar com subprogramas globais
	5.4 Transmitir parâmetros a subprogramas
	5.5 Exercício: Subprogramas com transferência de parâmetros
	5.6 Programação de funções
	5.7 Trabalhar com funções padrão KUKA
	6 Programação de mensagens com KRL
	6.1 Visão geral
	6.2 Generalidades sobre mensagens definidas pelo usuário
	6.3 Variáveis e estruturas em mensagens definidas pelo usuário
	6.4 Funções em mensagens definidas pelo usuário
	6.5 Trabalhar com uma mensagem de informação
	6.6 Exercício: Programar mensagem de informação
	6.7 Trabalhar com uma mensagem de estado
	6.8 Exercício: Programar mensagem de estado
	6.9 Trabalhando com uma mensagem de confirmação
	6.10 Exercício: Programar mensagens de confirmação
	6.11 Trabalhar com uma mensagem de espera
	6.12 Exercício: Programar mensagens de espera
	6.13 Variáveis e estruturas adicionais em diálogos
	6.14 Funções em diálogos
	6.15 Trabalhar com diálogos
	6.16 Exercício: Programar diálogo
	7 Programação de movimento com KRL
	7.1 Visão geral
	7.2 Programar movimentos individuais do SPLINE com KRL
	7.3 Movimento de passo individual com SPTP
	7.4 Movimento de passo individual com SLIN e SCIRC
	7.5 Parâmetros de movimento
	7.5.1 SCIRC: Comportamento de orientação – Exemplo ponto auxiliar
	7.5.2 SCIRC: Comportamento de orientação – Exemplo ponto de destino
	7.5.3 Restrições em $CIRC_MODE
	7.6 Movimentos individuais do SPLINE: Variáveis de sistema para WITH
	7.7 Programar movimentos relativos e absolutos com KRL
	7.8 Calcular ou manipular posições de robô
	7.9 Modificar exatamente bits de Status e Turn
	7.10 Exercício: Paletizar e despaletizar
	7.11 Programação de SPLINE Blocks
	7.11.1 Perfil de velocidade em movimentos do SPLINE
	7.11.2 Seleção de passo em movimentos do spline
	7.11.3 Alterações nos spline blocks
	7.11.4 Substituir o movimento CP de aproximação por spline block
	7.11.5 Transição SLIN-SPL-SLIN
	7.11.6 Programação PROG de SPLINE Blocks com KRL
	7.11.7 SPLINE Block: Variáveis de sistema com WITH
	8 Trabalho com variáveis de sistema
	8.1 Visão geral
	8.2 Medição do tempo de ciclo com temporizador
	8.3 Exercício: Medição de ciclo e otimização
	9 Programação de Interrupt
	9.1 Visão geral
	9.2 Programação de rotinas de Interrupt
	9.3 Exercício: Trabalhar com Interrupts
	9.4 Frear o robô e cancelar os movimentos de deslocamento
	9.5 Exercício: Cancelar movimentos de deslocamento com Interrupts
	10 Funções de comutação KRL
	10.1 Visão geral
	10.2 Programação das funções de comutação simples
	10.3 Programação do trigger em KRL
	10.4 Programar stop condicionado com KRL
	10.5 Programar região de deslocamento constante com KRL
	10.6 Programar bloco de tempo do spline
	11 Interpretador Submit
	11.1 Visão geral
	11.2 Status do Interpretador Submit
	12 Trabalhar com sinais analógicos
	12.1 Visão geral
	12.2 Programar entradas analógicas
	12.3 Programar saídas analógicas
	12.4 Exercício: Trabalhando com E/Ss analógicas
	13 Anexo
	13.1 Programar movimentos com KRL
	13.2 Variáveis de sistema
	13.2.1 $ACC
	13.2.2 $ACC_AXIS
	13.2.3 $ACC_EXTAX
	13.2.4 $APO
	13.2.5 $BASE
	13.2.6 $CIRC_TYPE
	13.2.7 Modo de economia de energia ($ECO_LEVEL)
	13.2.8 $GEAR_JERK
	13.2.9 $IPO_MODE
	13.2.10 $JERK
	13.2.11 $LOAD
	13.2.12 $ORI_TYPE
	13.2.13 $ROTSYS
	13.2.14 $SPL_ORI_JOINT_AUTO
	13.2.15 $TOOL
	13.2.16 $VEL
	13.2.17 $VEL_AXIS
	13.2.18 $VEL_EXTAX
	13.2.19 $CIRC_MODE
	Index