Apostila Treinamento Robo Kuka 2 de 3

Training KUKA Roboter GmbH
Programação do robô 2
KUKA System Software 8

Documento de treinamento
Programação
do robô 2
Data: 24.02.2015
Versão: P2KSS8_robotprogramming_2_(R2)_V4
© Copyright 2015
KUKA Roboter GmbH
Zugspitzstraße 140
D-86165 Augsburg
Alemanha
Este documento ou excertos do mesmo não podem ser reproduzidos ou disponibilizados a terceiros
sem autorização expressa da KUKA Roboter GmbH.
Outras funções de comando não descritas nesta documentação poderão ser postas em prática. No
entanto, não está previsto qualquer tipo de reclamação quanto a estas funções em caso de nova re-
messa ou de serviço.
Verificamos que o conteúdo do prospecto é compatível com o software e com o hardware descrito.
Porém, não são de excluir exceções, de forma que não nos responsabilizamos pela total compatibi-
lidade. Os dados contidos neste prospecto serão verificados regulamente e as correções necessá-
rias serão incluídas na próxima edição.
Sob reserva de alterações técnicas sem influenciar na função.
Tradução da documentação original
KIM-PS5-DOC
Publicação: Pub COLLEGE P2KSS8 Roboterprogrammierung 2 (R2) (PDF-COL) pt

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

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

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

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

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

5.1 Visão geral ................................................................................................................. 101
Data: 24.02.2015 Versão: P2KSS8_robotprogramming_2_(R2)_V4 3 / 251

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

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

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

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

Índice
8.1 Visão geral ................................................................................................................. 183

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

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

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

11.1 Visão geral ................................................................................................................. 217
11.2 Status do Interpretador Submit .................................................................................. 217
12 Trabalhar com sinais analógicos ............................................................... 221

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

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

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

1 Programação com WorkVisual
1.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-

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

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

necessário estabelecer uma conexão de rede.

 Até a versão de software KSS 8.2 estava disponível para isso somente a
interface KLI - KUKA Line Interface, que tinha que ser configurada em se-
parado. Essa interface também está à disposição com o KSS 8.3.
 A partir da versão de software KSS 8.3 está disponível a nova interface
KSI - KUKA Service Interface, que oferece um manuseio bem mais simples.
 Após um update do KSS 8.2 para KSS 8.3 também esta interface será li-
berada em unidades de comando mais "antigas".
Conectar o PC
WorkVisual à KSI
Fig. 1-1: Conexão à KSI via CSP
Pos. Descrição
1 Notebook com WorkVisual
2 Cabo de rede
3 Armário de comando KR C4
A Conexão KSI atrás da tampa do CSP
1. O ajuste de rede do PC WorkVisual (1) está configurado em DHCP (ob-

tenção automática de um endereço de rede).
2. Puxar o cabo de rede (2) do PC WorkVisual (1) para a KSI - KUKA Service
Interface (A) do armário de comando (3)
3. A KSI - KUKA Service Interface (A) encontra-se atrás da tampa do CSP -
Controller System Panel.
A KR C4 atribui automaticamente um endereço IP ao PC conectado.
Nunca conectar a KSI - KUKA Service Interface com uma

rede TI existente. Isso causa conflitos de endereço bem
como falhas de funcionamento!
1.2.2 Visão geral da interface de operação WorkVisual
 Na interface de operação não são visíveis como padrão todos os elemen-

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

Fig. 1-2: Vista geral da interface de operação
Pos. Descrição
1 Barra de menu
2 Barras de botões
3 Área de editores
Quando um editor está aberto, ele é exibido aqui. Podem estar
abertos vários editores simultaneamente, como neste exemplo.
Eles então estão sobrepostos e podem ser selecionados através
de guias.
4 Botão de ajuda
5 Janela Estrutura de projeto
6 Janela Catálogos
Nesta janela são exibidos todos os catálogos adicionados. Os
itens no catálogo podem ser adicionados à janela Estrutura de
projeto da guia Dispositivos ou Geometria.
7 Janela Áreas de trabalho
8 Janela Mensagens

Pos. Descrição
9 Janela Propriedades
Quando um objeto é selecionado, as suas propriedades são exibi-
das nesta janela. As propriedades podem ser alteradas. Proprie-
dades individuais em campos cinza não podem ser alteradas.
10 Ícone Análise de projeto WorkVisual
1.2.3 Carregar projeto existente no WorkVisual
Descrição Em cada unidade de comando do robô, para a qual existe uma conexão de
rede, um projeto pode ser selecionado e transmitido ao WorkVisual. Isto tam-
bém é possível, se este projeto ainda não existir neste PC.
O projeto é salvo no diretório …\WorkVisual Projects\Downloaded Projects.
Exibição do No smartPad o projeto ativo é exibido através do pressionamento do botão

projeto ativo na Projeto.
HMI
Fig. 1-3: Projeto ativo antes do Transfer
Explorer de
projeto
Fig. 1-4: Project Explorer
 Últimos arquivos exibe os últimos arquivos utilizados

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

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

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

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

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

1.2.4 Gravar localmente o projeto WorkVisual
Fig. 1-6: Salvar o projeto carregado
1. Salvar o projeto através do caminho de menu: Arquivo > Salvar como.

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

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

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

Programação e configuração.
1.2.6 Estrutura de projeto WorkVisual (guia Arquivos)
Guia Estrutura de  Guia Estrutura de projeto

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

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

cessária para a programação:
Caminho de menu: KRC\R1\PROGRAMME
Não excluir ou manipular nenhum arquivo *.XML desconhecido. Em

determinadas circunstâncias o projeto não pode ser ativado ou gera
erros.
1.2.7 Comparar projetos com WorkVisual
Descrição  um projeto no WorkVisual pode ser comparado com um outro projeto

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

comparação de  Janela de seleção Comparar projeto
projeto
Fig. 1-9: Selecionar projeto para "comparar"
 Projeto ativo
 Projeto de mesmo nome na unidade de comando (somente possível com
conexão de rede)
 Projeto base
 Projeto inicial
 Projeto local (do Notebook)
Comparação:
As diferenças entre os projetos são exibidas em uma visão geral. Para cada
diferença pode ser selecionado qual estado deve ser assumido.

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

Pos. Descrição
6 Seta para trás: O foco na exibição salta para a diferença anterior.
Seta para frente: O foco na exibição salta para a diferença seguinte.
Os nós fechados são abertos automaticamente.
7 As caixas de verificação exibem o estado da linha, na qual se encontra o foco no mo-
mento. Em vez de colocar os ticados diretamente na linha, eles também podem ser co-
locados e removidos aqui.
8 Assume as alterações selecionadas no projeto aberto.
9 Fecha a janela Unir projetos.
Descrição das cores:
Coluna Descrição
Estrutura de projeto Cada elemento é exibido na cor, que ele tem na coluna, na qual está
selecionado.
WorkVisual Todos os elementos são exibidos em preto.
Valor selecionado  Verde: Elementos, que não existem no projeto aberto, mas no proje-
to de comparação.
 Azul: Elementos, que existem no projeto aberto, mas não no projeto
de comparação.
 Vermelho: Todos os demais elementos. A estes também pertencem
elementos superiores, que contêm elementos em várias cores.
Procedimento na 1. No WorkVisual, selecionar a sequência de menu Extras > Comparar pro-

comparação de jetos. Abre-se a janela Comparar projetos.
projetos
Fig. 1-11: Comparar projetos
2. Selecionar o projeto, com o qual o projeto WorkVisual atual deve ser com-
parado, p.ex. o projeto de mesmo nome na unidade de comando do robô
real.
3. Clicar em Continuar. É exibida uma barra de progresso. Se o projeto con-

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

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

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

Fig. 1-14: Exemplo: Unir projetos
Na ativação dos Detalhes podem ser exibidas as diferenças dos arquivos.
Fig. 1-15: Exemplo: Detalhes ativados
1.2.8 Transmitir o projeto à unidade de comando do robô (instalar)
Descrição  Alterações no projeto devem ser enviadas à unidade de comando por

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

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

 Com este procedimento pode-se gerar o código em separado e, com isto,
verificar previamente se a geração ocorre sem erros.
 O acesso ocorre via:
 sequência de menu Extras > Gerar código
 ou o botão
 O código é exibido na janela Estrutura de projeto na guia Arquivos.
Um código gerado automaticamente é exibido em cinza claro.

Fig. 1-16: Exemplo Gerar código: antes - depois
 O código é gerado. Quando o procedimento estiver concluído, são

exibidas na janela de mensagens as seguintes mensagens: O projeto
<"{0}" V{1}> foi compilado. Os resultados você vê na árvore de
arquivos.
Versões
WorkVisual até
3.0
Procedimento
1. Na barra de menu, pressionar o botão Instalar …. . Abre-se a janela
Transmissão de projeto.
Fig. 1-17: Visão geral com observação sobre configuração incompleta

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

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

dos, p.ex., o projeto ativo na unidade de comando do robô real.
6. Clicar em Continuar. É exibida uma barra de progresso. Se o projeto con-
tém várias unidades de comando do robô, é exibida uma barra para cada
uma.
7. Quando a barra de progresso estiver preenchida e, além disso, for exibido

o estado bem como Pronto para unir: Clique em Exibir diferenças.
As diferenças entre os projetos são exibidas em uma visão geral.
8. Para cada diferença, selecionar qual estado deve ser assumido. Isto não
é necessário fazer para todas as diferenças em uma operação.
Se for conveniente, pode ser mantida também a seleção padrão.
9. Pressionar Unir, para assumir as alterações.
10. Repetir os passos 8 e 9 quantas vezes for necessário. Isto possibilita edi-
tar sequencialmente as diversas áreas.
Se não existirem outras diferenças, isto é exibido na mensagem a seguir:
Não há outras diferenças.
11. Fechar a janela Comparar projetos.
12. Na barra de menu, clicar no botão Instalar... . A visão geral sobre a

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

Fig. 1-19: Visão geral
13. Clicar em Continuar. É iniciada a geração de programa. Se a exibição de

progresso atingir 100%, o programa está gerado e o projeto transmitido.
14. Clicar em Ativar.
Nos modos de operação AUT e AUT EXT o projeto é ati-

vado sem consulta de segurança, quando se trata ape-
nas de alterações de programa.
Para a ativação de um projeto, é necessário o perfil de

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

Fig. 1-20: Confirmação no WorkVisual
18. Fechar a janela Transmissão de projeto com Finalizar.

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

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

sagem de erro no WorkVisual. Neste caso é necessário
executar uma das medidas a seguir:
 Ativar novamente um projeto. (O mesmo ou um outro).
 Ou reiniciar a unidade de comando do robô com uma partida a frio.
Versões
WorkVisual a
partir de 3.1
Procedimento
Iniciar trans-
 Na barra de menu, pressionar o botão Instalar …. .
missão de projeto
 Abre-se a janela Transmissão de projeto.
 Alternativamente a transmissão de projeto também pode ser acessada
através do Caminho de menu: Extras (Ferramentas) > Instalar.
Atribuir unidade 1. A unidade de comando do projeto WorkVisual (2) já está atribuída à uni-
de comando dade de comando real (4) através da seta azul (3). (>>> "Procedimento"
Página 31)

Fig. 1-21: Atribuir unidade de comando
Pos. Descrição
1 Decurso da transmissão de projeto
2 Armário de comando do projeto WorkVisual
3 Atribuição do projeto ao armário de comando real
4 Armário de comando real na rede do sistema
5 Abre a janela para a localização de armários de comando na
rede do sistema
6 Abre a janela para a comparação de projeto
7 Confirmação da atribuição de armário de comando
2. Confirmar a atribuição com o botão Continuar (7)
Solucionar  Se existirem conflitos ou irregularidades na transmissão de projeto, é in-

conflitos serida uma janela de eliminação de falhas, que exibe soluções de conflito.
 Selecionar e aplicar a solução adequada das sugestões.
Gerar código  Após a atribuição da unidade de comando o WorkVisual gera, a partir da

configuração gráfica, os arquivos *.xml necessários para a unidade de co-
mando.
Fig. 1-22: Geração de código
 Este passo de trabalho também pode ser executado previamente em se-

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

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

de trabalho à unidade de comando.
Fig. 1-23: Transmitir projeto
 Os projetos podem ser transmitidos a toda hora na unidade de comando

sem direitos explícitos de usuário.
Eles são copiados na unidade de comando na administração de projeto.
 Se durante a transmissão ocorrer uma interrupção da conexão, este pas-
so de trabalho será cancelado.
Ativar o projeto  Depois que o projeto foi transmitido, o projeto pode ser ativado diretamen-
te através do WorkVisual. Se a ativação falhar, porque, por exemplo, os
direitos de usuário necessários na unidade de comando não estão pre-
sentes, o projeto pode ser ativado novamente através do ícone (1).
Fig. 1-24: Ocorreu um erro na ativação do projeto
 Após uma ativação de projeto bem sucedida é inserida uma barra de pro-
gresso verde. Com o botão Finalizar (1) é finalizado o Wizard.

Fig. 1-25: Transmissão de projeto bem sucedida
 Caso a consulta na unidade de comando do robô não seja respondida

dentro de 30min, o projeto será transmitido mesmo assim, contudo, não
estará ativo na unidade de comando do robô. Agora pode-se ativar o pro-
jeto em separado. (>>> Fig. 1-24 )
Confirmar a 1. De acordo com as alterações no projeto é necessário o perfil de usuário

ativação do perito ou colocador em funcionamento de segurança.
projeto no 2. Da HMI do SmartPads aparece a mensagem "Aguardada introdução de
SmartPad usuário!".
Fig. 1-26: Mensagem de instalação
3. No smartPad abre-se a janela "Administração de projeto" com a pergunta

"Deseja permitir a ativação do projeto "1EG2-R04-8_2_First_Test"?" Confirmar a
ativação com "Sim".
Fig. 1-27: Permitir ativação
4. É inserida outra janela "Administração de projeto". Nela são exibidas as

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

Fig. 1-28: Indicação das alterações
5. No smartPad aparece uma mensagem de que é realizada uma reconfigu-

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

Fig. 1-30: Erro Soma de verificação
2. E necessário o perfil de usuário Colocador em funcionamento de seguran-

ça.
3. Abrir a configuração de segurança.
Caminho de menu: Tecla KUKA > Configuração > Configuração de segurança
4. Na janela "Assistente de solução de problemas" selecionar o registro "Acabou
de ser ativado um projeto WorkVisual"
Fig. 1-31: Assistente de solução de problemas
5. Aceitar a primeira sugestão, pressionando o botão "Ativar agora".

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

seguintes partes da configuração relevante de segurança?" com "Sim". A recon-
figuração é executada.
7. Confirmar a mensagem no smartPad "As modificações foram memorizadas
com sucesso" com o botão "OK".
8. Confirmar a mensagem de confirmação "Quitt: Soma de verificação da
configuração de segurança está incorreta" com "Todos OK"
1.2.9 Atribuir o projeto à unidade de comando do robô real
Descrição Um projeto deve ser atribuído da seguinte forma antes da transmissão:

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

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

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

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

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

mente a uma unidade de comando de robô real.
9. Marcar a unidade de comando virtual sob Unidades de comando no pro-

jeto.

10. Sob Unidades de comando na célula, marcar a unidade de comando do
robô real e clicar em . A unidade de comando do robô real é atribuída

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

12. Clicar em Continuar. É exibida uma visão geral. (Aqui existe a possibili-
dade de alterar mais uma vez a atribuição, caso necessário. Para isto, cli-
car em Alterar ….)
13. Agora o projeto pode ser transmitido à unidade de comando do robô.
Alternativamente o projeto pode ser transmitido posteriormente. Para isto,

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

Versões
WorkVisual a
partir de 3.1
Procedimento 1. Na barra de menu, clicar no botão Instalar …. Abre-se a janela Trans-

missão de projeto WorkVisual. No lado esquerdo é exibida a unidade
de comando do robô virtual do projeto. No lado direito é exibida a unidade
de comando de destino. Ela está em cinza se ainda não foi selecionada
nenhuma unidade de comando.
Fig. 1-36: Atribuir a unidade de comando do robô à célula
2. No lado esquerdo, ativar a célula virtual com a caixa de verificação. A uni-

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

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

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

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

 O projeto pode ser ativado também diretamente a partir do WorkVisual
para na unidade de comando do robô
(não será explicado detalhadamente aqui, usar para isto a documentação
online do WorkVisual)
Função da Generalidades
administração de  A unidade de comando do robô tem a possibilidade de administrar vários
projeto projetos na unidade de comando.
 Todas as funções primeiro estão disponíveis no grupo de usuários Peri-
tos
 Um acesso ocorre via:
 Na interface de operação, com a tecla WorkVisual-Symbol e, em se-
guida, o botão Abrir

Fig. 1-39: Exibição de projeto na interface de operação
Manuseio / Operação

Fig. 1-40: Janela Administração de projeto
Pos. Descrição
1 É exibido o projeto inicial.
2 Restabelece o estado de fornecimento da unidade de comando do
robô.
Está disponível a partir do grupo de usuários Peritos.
3 É exibido o projeto base.
4 Cria uma cópia do projeto base.
5 O projeto ativo é exibido.
6 Salva o projeto ativo como projeto base. O projeto ativo permane-
ce ativo.
7 Cria uma cópia pinada do projeto ativo.
8 Lista dos projetos. O projeto ativo não é exibido aqui.
 Além dos projetos regulares a janela Administração de projeto contém

os seguintes projetos especiais:

Projeto Descrição
Projeto inicial O projeto inicial sempre existe. Ele não pode ser alte-
rado pelo usuário. Ele contém o estado da unidade de
comando do robô no fornecimento.
Projeto base O usuário pode salvar o projeto ativo como projeto
base. Esta funcionalidade normalmente é usada para
salvar um estado de projeto aprovado e funcional.
O projeto base não pode ser ativado, mas copiado. O
projeto base não pode mais ser alterado pelo usuário.
Mas ele pode ser sobrescrito através da gravação de
um novo projeto base (após uma pergunta de segu-
rança).
Quando é ativado um projeto, que não contém todos
os arquivos de configuração, as informações faltantes
são assumidas do projeto base. Este pode ser o caso,
p.ex., quando é ativado um projeto de uma versão
anterior do WorkVisual. Aos arquivos de configuração
pertencem arquivos de dados da máquina, arquivos da
configuração de segurança e inúmeros outros.
 Descrição dos botões
Botão Descrição
Ativar Ativa o projeto marcado.
Se o projeto marcado estiver pinado: Cria uma cópia
do projeto marcado. (Um projeto pinado não pode ser
ativado, somente uma cópia dele.) O usuário pode
decidir, se a cópia deve ser ativada imediatamente ou
se o projeto atual deve permanecer ativo.
Colocar pinos Projetos pinados não podem ser alterados, ativados ou
excluídos. Contudo, eles podem ser copiados ou "des-
pinados". Portanto, pode-se pinar um projeto para,
p.ex., impedir que ele seja excluído acidentalmente.
Somente está disponível, se estiver marcado um pro-
jeto não-pinado. Está disponível a partir do grupo de
usuários Peritos.
Despinar "Despina" o projeto.
jeto pinado. Está disponível a partir do grupo de usuá-
rios Peritos.
Copiar Copia o projeto marcado.
Excluir Exclui o projeto marcado.
jeto não-pinado não ativo. Está disponível a partir do
grupo de usuários Peritos.

Botão Descrição
Editar Abre uma janela, na qual podem ser alterados o nome
e/ou a descrição do projeto marcado.
jeto não-pinado. Está disponível a partir do grupo de
usuários Peritos.
Atualizar Atualiza a lista de projetos. Desta forma são exibidos,
p.ex., projetos, que foram transmitidos à unidade de
comando do robô desde a abertura da exibição.
Procedimento
Restrição: Se a ativação causar alterações na área de parâmetros
de comunicação da configuração de segurança, deve estar selecio-
nado o grupo de usuários técnico de manutenção de segurança ou
superior.
Se o modo de operação AUT ou AUT EXT estiver selecionado: O projeto so-
mente pode ser ativado, se através disto se alterarem apenas programas
KRL. Se o projeto contiver ajustes, que causariam outras alterações, ele não
pode ser ativado.
1. Selecionar a sequência de menus Arquivo > Administração de projeto.

Abre-se a janela Administração de projeto.
2. Marcar o projeto desejado e ativá-lo com o botão Ativar.

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

do robô é necessário verificar lá a configuração de segu-
rança! Se isso não ocorrer, o robô eventualmente será operado com dados
incorretos. Podem ocorrer morte, ferimentos ou danos materiais.
1.3 Processar programas KRL com WorkVisual
 Manuseio do arquivo
 Manuseio com o editor KRL
1.3.1 Importar manuseio de arquivos
Descrição  Ativar catálogo Templates

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

Ativar catálogo
Templates
Fig. 1-41: Adicionar catálogo
 Antes do uso dos templates é necessário carregar os respectivos catálo-

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

(SRC/DAT/SUB) 1. Na estrutura de projeto mudar para a guia Arquivos (1)
no editor KRL
Fig. 1-42: WorkVisual Árvore de projeto
2. Abrir diretórios até ao diretório R1

Fig. 1-43: WorkVisual Árvore de projetos Estrutura de dados (R1)
3. Selecionar arquivo e ou
 com duplo-clique
 Botão da lista de símbolos
 Clique à direita e no menu de contexto Editor KRL
Fig. 1-44: Menu mouse de contexto WorkVisual (Editor KRL)
Adicionar o Procedimento
arquivo com 1. Trocar arquivo da árvore de projeto
templates KRL 2. Abrir diretórios até ao diretório R1

3. Selecionar a pasta na qual o novo arquivo deverá ser criado
4. Clicar à direita e no menu de contexto Adicionar
Fig. 1-45: Menu de contexto WorkVisual (adicionar)
5. Seleção de template
Fig. 1-46: Catálogos para Templates KRL
a. Na janela Catálogos mudar para a guia Templates KRL (1)

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

Adicionar arquivo Procedimento

externo 1. Na janela Estrutura de projeto na guia Arquivos abrir a estrutura de ár-
vore da unidade de comando do robô.
2. No nó, no qual deve ser criado o programa, clicar com o botão direito e
selecionar Adicionar arquivo externo no menu de contexto.
Fig. 1-47: Menu de contexto WorkVisual (adicionar arquivo externo)
3. Navegar para o diretório, no qual se encontra o arquivo a ser importado.
Fig. 1-48: Adicionar arquivo externo WorkVisual
4. Marcar o arquivo e confirmar com Abrir. O arquivo é inserido na estrutura

de árvore.
Podem ser importados arquivos com os formatos SRC, DAT, SUB e KRL
Agora o arquivo pode ser editado com o editor KRL.
1.3.2 Ativar Templates de catálogo
Descrição Para poder executar determinadas funções no WorkVisual como, p.ex., con-
figuração ou programação, é necessário ativar os respectivos catálogos.

Exemplo
 A estrutura de projeto deve ser expandida.
 Clicar com o botão direito no ícone da unidade de comando ativa e clicar
em "Adicionar".
Fig. 1-49: Expandir a estrutura de projeto
 É exibida a mensagem "Não foram encontrados elementos adequados.

Adicione os catálogos correspondentes."
Fig. 1-50: Mensagem de erro
Procedimento
Ativar catálogo
Templates
Fig. 1-51: Adicionar catálogo
 Antes do uso dos templates é necessário carregar os respectivos catálo-

gos.

 Caminho de menu: Arquivo > Adicionar catálogo

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

KRL  Descrição de cores do editor KRL
 Exibir declarações variáveis de um arquivo
 Localizar e substituir em arquivos
 Renomear variáveis
 Autocompletar
 Snippets – Introdução rápida para instruções KRL
 Correção Quickfix
 Corrigir variável não declarada ou declarar automaticamente
 Não excluir variáveis usadas
 Exibir variáveis
 Trabalhar com pastas
Conhecer a Descrição
interface de  O editor KRL permite o processamento confortável de programas KUKA.
operação Editor
 Não é possível testar ou deixar executar programas.
KRL
 Caminho de menu: Editores > Editor KRL

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

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

Funções gerais Marcar

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

uma área em formato quadrado.
 Marcar uma fileira: Clicar no número da fileira.

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

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

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

Item de menu Descrição

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

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

Palavras-chave KRL azul médio
(exceto ;FOLD e ;ENDFOLD)
;FOLD e ;ENDFOLD cinza
Números azul marinho
Strings (texto entre aspas "…") vermelho
Comentários verde
Caracteres especiais verde azulado
Outro código preto
 Exemplo para o uso das cores
Fig. 1-53: Exemplo de cores no editor KRL
1 Palavras-chave KRL: azul

2 Comentário: verde
3 FOLD: cinza
4 Outro código: preto
Exibir decla- Descrição

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

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

esta coluna.
Fig. 1-54: Janela Lista de variáveis
Botão Nome/Descrição
Agrupa as variáveis conforme subfunções locais
O botão está pressionado: A exibição é classificada por tipos
de arquivo. (Dentro desta classificação pode ser classificado
adicionalmente por colunas.)
O botão não está pressionado: A exibição não está classifi-
cada por tipos de arquivo.
4. Conforme a necessidade, uma variável pode ser marcada conforme se-

gue no editor KRL:
 Dar um duplo clique na linha no resultado de busca.
 Ou: Clicar com o botão direito na linha, e no menu de contexto sele-
cionar Ir para....
 Ou: Marcar a linha e pressionar a tecla Enter.
5. Na janela Lista de variáveis existe uma função de busca à disposição,
com a qual se pode pesquisar por variáveis locais no arquivo atual:
 Introduzir o nome da variável ou uma parte do nome no campo de bus.
É exibido imediatamente o resultado da busca.
Localizar e Descrição
substituir em  No WorkVisual há uma opção de pesquisa com a qual se pode pesquisar
arquivos o texto de todos os arquivos do projeto todo.
Pode-se selecionar quais áreas podem ser pesquisadas na janela de pes-
quisa.
 Ainda assim, pode-se pesquisar um único arquivo ou uma área marcada
em um arquivo.
Procedimento
1. Abrir esta caso se queira pesquisar um arquivo individual.
2. Marcar estes no caso de uma pesquisa de uma área em um arquivo.
3. Abrir a janela de pesquisa: CTRL+F

Fig. 1-55: Busca de WorkVisual
4. Ou: Abrir a janela de pesquisa e substituição: CTRL+H
Fig. 1-56: Localizar e substituir
5. Concluir o ajuste desejado e clicar em Pesquisar, respectivamente em

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

Procedimento
1. Em uma posição qualquer, marcar a variável desejada.
2. Clicar com o botão direito e no menu de contexto selecionar Renomear.
3. Abre-se uma janela. Mudar o nome e confirmar com OK.
Fig. 1-57: Renomear variável
Autocompletar Descrição
 Existe uma funcionalidade de autocompletar disponível no editor KRL.
 Ao se incluir o código uma lista é automaticamente exibida, que inclui os
seguintes itens:
 Palavras-chave KRL
 Nomes conhecidos de variáveis
 Nomes conhecidos de funções
 Tipos de dados conhecidos específicos por usuário (STRUC or
ENUM)
 Snippets (>>> "Snippets – Introdução rápida para instruções KRL"
Página 48)
Procedimento
 Introduzir as primeiras letras do comando desejado, variável etc. na linha
de programa correspondente.
 Abre-se a autocompletação:
Fig. 1-58: Autocompletar
 No topo da lista são exibidos itens que correspondem aos símbolos já in-
cluídos.
Estes itens são novamente priorizados de acordo com a sua frequência
de utilização, isto é, a seleção se adapta ao comportamento do utilizador.

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

grama através da tecla Enter.
Isso torna desnecessário, por exemplo, sempre ter de se digitar nomes de
variáveis complexas.
Navegação na lista Completar:

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

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

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

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

fragmentos. Marcar a instrução. Abre-se uma sugestão de ferramenta. A
2ª linha contém as abreviaturas possíveis.)
Correção Descrição
Quickfix  Ondas sob o código e marcas na barra de análise indicam erros ou incon-
sistências no código.
Procedimento
 Para o caso de alguns erros/discrepâncias é oferecida uma correção au-
tomática, o "Quickfix".
 Uma luzinha Quickfix aparece.
Fig. 1-61: Luzinha Quickfix
 Através do botão de seta ao lado da luzinha, o usuário pode exibir várias

soluções diferentes e selecionar uma.
Corrigir variável Variáveis não declaradas são exibidas conforme segue:

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

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

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

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

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

 Com a tecla TAB, pular para o comentário. Editar o comentário con-
forme necessário.
Este comentário é exibido na sugestão de ferramenta da lista Com-

pletar quando a variável é marcada ali.

Não excluir Descrição

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

 Remover a declaração
 Descomentar a declaração
3. Clicar sobre a opção desejada.
Exibir variáveis Pular para a declaração de uma variável

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

Fig. 1-66: Menu - botão direito do mouse
3. O cursor marca o nome da variável na seção de declaração.

No exemplo:
...
DECL INT counter
...
Exibir todas as utilizações de uma variável

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

Por exemplo, pode-se Alterar o nome.
Trabalhar com Descrição

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

 Clicar no sinal de menos.
 A pasta é fechada.
Fig. 1-69: Pasta fechada
Abrir ou fechar todas as pastas

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

1.4 Exercício: Editar um projeto ativo no WorkVisual
Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício executar as seguintes atividades:
 Conectar um PC com WorkVisual 3.x instalado com a interface KSI da uni-
dade de comando.
 Carregar um projeto ativo no WorkVisual.
 Criar um novo programa KRL no WorkVisual.
 Transmitir e ativar o projeto atualizado na unidade de comando.
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 É necessário um PC com WorkVisual 3.x instalado.
 Conhecimentos teóricos sobre a gestão de projeto com WorkVisual
Definição de  Conecte o PC com o WorkVisual 3.x à KSI - KUKA Service Interface do ar-
funções mário de comando.
 Carregue o projeto ativo da unidade de comando no WorkVisual.
 Crie um novo programa com o nome my1prog.
 Crie um comentário entre os dois conjuntos de movimentos PTP HOME.
 Gere a estrutura de dados específica de projeto com o botão Gerar có-
digo .
 Instale o projeto com o botão Instalar projeto na unidade de coman-

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

6. Para o que são usados Snippets?

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


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

dos:
 Metodologia de programação padronizada
 Recursos auxiliares para a criação de programas de robô estruturados
 Fluxograma do programa
2.2 Objetivo de um método de programação padronizado
Objetivo do Um método de programação padronizado serve para:

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

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

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

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

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

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

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

SPTP HOME Vel=100% DEFAULT
SPTP Pre_Pos ; A posição prévia para a coleta é acessada
SLIN Grip_Pos ; Posição de coleta do cubo é acessada

...
END
Nota sobre trabalhos a serem executados:

Comentários podem identificar partes de código insuficientes ou ser variáveis
para partes de código faltantes.
DEF PICK_CUBE()
INI
;Aqui deve ser inserido ainda o cálculo das posições de paletes!
SPTP Pre_Pos ; A posição prévia para a coleta é acessada
SLIN Grip_Pos ; Posição de coleta do cubo é acessada
;Aqui falta ainda o fechamento da garra
END
Descomentário:
Se uma parte do código for excluído provisoriamente mas posteriormente
reinserido, ele será descomentado. A parte do código, depois de embalado no
comentário, no ponto de vista não é mais código, ou seja, já não existe mais.
DEF Palletize()
INI
PICK_CUBE()
;CUBE_TO_TABLE()
CUBE_TO_MAGAZINE()
END
Qual é o efeito do  Em PASTAS podem ser ocultadas partes do programa

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

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

segundo plano.
Inicialmente as pastas em geral são exibidas fechadas após a sua criação.
DEF Main()
...
INI ; PASTA KUKA fechada
SET_EA ; PASTA criada pelo usuário fechada
SPTP HOME Vel=100% DEFAULT ; PASTA KUKA fechada
SPTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table

...
SPTP HOME Vel=100% Default
END
DEF Main()
...
SET_EA ; PASTA criada pelo usuário aberta

$OUT[12]=TRUE
$OUT[102]=FALSE
PART=0
Position=0
SPTP HOME Vel=100% DEFAULT ; PASTA KUKA fechada

...
END
DEF Main()
...
SET_EA ; PASTA criada pelo usuário fechada
; PASTA KUKA aberta

SPTP XHOME WITH $VEL_AXIS[1]= SVEL_JOINT( 100), $TOOL= STOOL2(
FHOME), $BASE= SBASE( FHOME.BASE_NO),
$IPO_MODE= SIPO_MODE( FHOME.IPO_FRAME), $LOAD= SLOAD( FHOME.TOOL_NO),
$ACC_AXIS[1]= SACC_JOINT( PDEFAULT),
$GEAR_JERK[1]= SGEAR_JERK( PDEFAULT)
...
END
Por que se Na programação, os subprogramas são utilizados especialmente para permi-

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

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

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

subprogramas
INI
LOOP
GET_PEN()
PAINT_PATH()
PEN_BACK()
GET_PLATE()
GLUE_PLATE()
PLATE_BACK()
IF $IN[1]== TRUE THEN

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

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

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

através de uma robô, recomendamos usar termos que fazem sentido na definição de nomes.
identificação A estes pertencem, p.ex.:
adequada de  Nomes de textos descritivos para sinais de entrada e de saída
nomes de dados?  Nomes de ferramentas e base
 Acordos de sinais para sinais de entrada e de saída
 Nomes de pontos
2.4 Como é elaborado um fluxograma do programa
O que é um PAP? Um fluxograma do programa (PAP) é um diagrama de execução para um pro-

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

Fig. 2-3
Instruções gerais no código de programa
Fig. 2-4
Acesso ao subprograma
Fig. 2-5
Instrução de entrada/saída
Fig. 2-6

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

3 Introdução no nível de perito

t
3.1 Visão geral

dos:
 Usar nível de perito
3.2 Usar nível de perito
Descrição A unidade de comando do robô oferece diferentes Grupos de usuários com

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

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

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

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

tão disponíveis os seguintes Filtros:
 Cancelar programa ou fechar.
 Selecionar o botão Editar > Filtro e depois Detalhe ou Módulo
 Detalhe
Os programas são exibidos como arquivos SRC e DAT. (Ajuste predefini-
do)
 Módulos
Os programas são exibidos como módulos.
Fig. 3-1: Menu Editor
Abrir/Fechar PASTA
 As FOLDs estão sempre fechadas para o usuário e podem ser abertas
como perito.
 O perito também pode programar suas PASTAS próprias.

 A sintaxe para uma pasta é:

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

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

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

3.3 Exercício: Medição de ferramentas e base
 Medição da ferramenta com o método XYZ 4-Pontos e o método World 5D
 Medição da ferramenta com introdução numérica de valor
 Medição da base conforme o método 3 pontos
te exercício:
 Conhecimentos teóricos sobre a medição de uma ferramenta
 Conhecimentos teóricos sobre a medição de uma base
Função: Intro- Introduza para a sua garra de treinamento com introdução numérica:
dução de dados
de ferramenta de
garra
Fig. 3-3: College garra: Posição do TCP
 Garra de treinamento KR 16
Fig. 3-4: Garra de treinamento KR 16

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

X Y Z
122,64 mm 177,73 mm 172,49 mm
A B C
45 0 180
 Garra de treinamento Célula modular
Fig. 3-5: Garra de treinamento Célula modular
Massa:
M = 4,4 kg
X = 7 mm Y = -24 mm Z = 80 mm
Orientação:
A = 0° B = 0° C = 0°

X Y Z
175,38 mm -123,97 mm 172,71 mm
A B C
-45 0 -180
 Garra de treinamento Célula móvel

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

X Y Z
12 mm 0 mm 77 mm
A B C
0 0 0
Definição de Medição de pino

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

da ferramenta de
garra com pino

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

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

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

3.4 Exercício: Navigator perito loop sem fim
 Criação de módulos no plano de perícia
 Vínculo de determinados módulos em um programa principal
 Uso de um loop sem fim
te exercício:
 Conhecimentos teóricos sobre o Navigator no plano de peritos
 Conhecimentos teóricos sobre o uso de subprogramas globais
 Conhecimentos teóricos sobre um loop sem-fim
Definição de 1. Antes do início da programação elabore um fluxograma do programa

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


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

v

dos:
 Manutenção de dados no KRL
 Tipos de dados simples com KRL
 Exibir variáveis
 Arrays/Campos com KRL
 Estruturas com KRL
 Tipo de dados de enumeração ENUM
4.2 Manutenção de dados no KRL
Dados gerais
sobre variáveis
Fig. 4-1: Identificação de variáveis
 Na programação do robô com KRL, uma variável no sentido mais geral é

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

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

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

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

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

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

Tipos de dados Número Valores
vírgula ado
simples inteiro lógicos
alterável caractere
Palavra chave INT REAL BOOL CHAR
Faixa de valores -231 ... ± 1.1 10-38... ± TRUE / Conjunto
FALSE de carac-
(231-1) 3.4 10+38
teres
ASCII
Exemplos -199 ou -0,0000123 ou TRUE ou "A" ou "q"
56 3,1415 FALSE ou "7"
 Campos /Array
Voltage[10] = 12.75
Voltage[11] = 15.59
 Salvar diversas variáveis do mesmo tipo de dados com índice

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

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

 Os componentes podem consistir de tipos de dados simples mas tam-
bém de estruturas
 Um acesso a determinados componentes é possível
Criação de Declaração de variáveis

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

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

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

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

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

 Informações de sistema são obtidas das variáveis de sistema KUKA. Es-
tas
 leem as informações de sistema atuais,
 alteram as configurações de sistema atuais,
 são predefinidas e começam com o caractere "$"
 $DATE (horário e data atual)
 $POS_ACT (posição atual do robô)
 $MODE_OP(modo de operação atual)
 ...
4.3 Trabalhar com tipos de dados simples
A seguir é explicada a elaboração, inicialização e a alteração de variáveis.

Aqui são usados somente tipos de dados simples.
Tipos de dados simples com KRL
 Números inteiros (INT)
 Números de vírgula variável (REAL)
 Valores lógicos (BOOL)
 Caracter individual (CHAR)
4.3.1 Declaração de variáveis
Princípio da Estrutura de programa no exemplo SRC-File

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

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

Procedimento na Criar variável no SRC-File

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

Criar variável no DAT-File
1. Grupo de usuários Peritos
2. Abrir DAT-File no Editor
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol
...
ENDDAT
4. Fechar e salvar lista de dados

Criar variável na $CONFIG.DAT
2. Na pasta SYSTEM abrir o $CONFIG.DAT no Editor
DEFDAT $CONFIG
BASISTECH GLOBALS
AUTOEXT GLOBALS
USER GLOBALS
ENDDAT
3. Selecionar a pasta "USER GLOBALS" e abri-la com o softkey "Abr/Fech

pasta"
DEFDAT $CONFIG
...
;==================================
; Userdefined Types
;==================================
;==================================
; Userdefined Externals
;==================================
;==================================
; Userdefined Variables
;==================================
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol

...
ENDDAT

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

DEFDAT MY_PROG PUBLIC
DECL GLOBAL INT counter
DECL GLOBAL REAL price
DECL GLOBAL BOOL error
DECL GLOBAL CHAR symbol
...
ENDDAT
4.3.2 Inicialização de variáveis com simples tipos de dados
Descrição da  Após a declaração uma variável reservou apenas um espaço de memória,

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

inicialização  Inicialização de decimais
value = 58
 Inicialização como número binário

value = 'B111010'
Cálculo: 1*32+1*16+1*8+0*4+1*2+0*1 = 58
Binário 25 24 23 22 21 20
Dez 32 16 8 4 2 1
 Inicialização hexadecimal
value = 'H3A'
Cálculo: 3*16 +10 = 58
Hex 0 1 2 3 4 5 6 7 8 9 A B C D E F
Dez 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

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

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

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

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

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

Declaração e Descrição
inicialização de  Constantes são criadas com a palavra chave CONST.
uma constante
 Constantes só podem ser criadas em listas de dados.
Criação de constantes
1. Abrir DAT-File no editor.
2. Realizar declaração e inicialização.
DEFDAT MY_PROG
DECL CONST INT max_size = 99
DECL CONST REAL PI = 3.1415
...
ENDDAT
3. Fechar e salvar lista de dados.
4.3.3 Manipulação de valores de variáveis de tipos de dados simples com KRL
Listagem de Os valores de variáveis são alterados de forma distinta de acordo com a de-
possibilidades finição de funções nas rotinas de programa (SRC-File) conforme a tarefa. A
para a alteração seguir são abordados os métodos mais comuns. A manipulação com opera-
ções bit e funções padrão é possível, mas não será detalhada.
de valores de
variáveis com Manipulação de dados através de
KRL  Tipos de cálculo básico
 (+) Adição
 (-) Subtração
 (*) Multiplicação
 (/) Divisão
 Operações comparativas
 (==) idêntico / igualdade
 (<>) desigual
 (>) maior
 (<) menor
 (>=) maior ou igual
 (<=) menor ou igual
 Operações lógicas
 (NOT) Inversão
 (AND) (E) lógico
 (OR) OU lógico
 (EXOR)OU exclusivo
 Operações Bit
 (B_NOT) Inversão de bit
 (B_AND) vinculação E de bits
 (B_OR) vinculação OU de bits
 (B_EXOR) vinculação OU exclusiva de bits
Funções padrão
 Função absoluta
 Função de raiz
 Função seno e coseno

 Função tangente
 Função arco seno
 Função arco tangente
 Diversas funções para a manipulação de strings
Contextos na Modificação de valores usando os tipos de dados REAL e INT

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

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

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

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

W = W/4 ; W=2.5
Operações comparativas
Com operações comparativas podem ser formadas expressões lógicas O re-
sultado de uma comparação é sempre o tipo de dados BOOL.
Operador/
Descrição Tipos de dados admissíveis
KRL
== idêntico/igual- INT, REAL, CHAR, BOOL
dade
<> desigual INT, REAL, CHAR, BOOL
> maior INT, REAL, CHAR
< menor INT, REAL, CHAR
>= maior igual INT, REAL, CHAR
<= menor igual INT, REAL, CHAR
; Declaração
DECL BOOL G,H
; Inicialização/Seção de instrução
G = 10>10.1 ; G=FALSE
H = 10/3 == 3 ; H=TRUE
G = G<>H ; G=TRUE
Operações lógicas
Com operações lógicas podem ser formadas expressões lógicas. O resultado
dessa operação é sempre o tipo de dados BOOL.
A EXOR
Operações NOT A A AND B A OR B
B
A=FALSE B=FALSE TRUE FALSE FALSE FALSE
A=FALSE B=TRUE TRUE FALSE TRUE TRUE
A=TRUE B=FALSE FALSE FALSE TRUE TRUE
A=TRUE B=TRUE FALSE TRUE TRUE FALSE
; Declaração
DECL BOOL K,L,M
K = TRUE
L = NOT K ; L=FALSE
M = (K AND L) OR (K EXOR L) ; M=TRUE
L = NOT (NOT K) ; L=TRUE
Operadores são executados na sequência de suas prioridades
Prioridade Operador
1 NOT (B_NOT)
2 Multiplicação (*); Divisão (/)
3 Adição (+), Subtração (-)
4 AND (B_AND)
5 EXOR (B_EXOR)

Prioridade Operador
6 OR (B_OR)
7 qualquer comparação (==; <>; ...)
; Declaração
DECL BOOL X, Y
DECL INT Z
X = TRUE
Z = 4
Y = (4*Z+16 <> 32) AND X ; Y=FALSE
Procedimento na 1. Definir tipo de dados para a(s) variável(eis)

manipulação de 2. Calcular a validade e vida útil das variáveis
dados 3. Realizar a declaração das variáveis
4. Inicializar a variável
5. Nas rotinas de programa, ou seja, sempre no arquivo *.SRC, manipular a
variável
6. Fechar e salvar o arquivo *.SRC
Comando PARAR PARAR é utilizado principalmente durante a fase de programação para fins de
teste. Por exemplo, para levar à exibição o conteúdo de uma variável de tem-
po de execução.
 O comando PARAR para o programa. Contudo, a última instrução de mo-
vimento percorrida ainda é executada por completo.
 O programa somente pode ser continuado com a tecla Iniciar. Depois é
executada a próxima instrução após PARAR.
Em um programa Interrupt o programa somente é parado após a exe-

cução completa do avanço.
Exemplo:
DEF program()
DECL BOOL a,b
INI
...
SPTP XP1
a=$IN[1]
b=$IN[2]
HALT
IF ((a == TRUE) AND (b == FALSE)) THEN
..
ENDIF
...
4.4 Exibir variáveis
Exibir e alterar o 1. No menu principal, selecionar Exibir > Variável > Individual.
valor de uma Abre-se a janela Display de variáveis - individual.
variável 2. No campo Nome introduzir o nome da variável.
3. Quando um programa está selecionado, no campo Módulo está inserido
automaticamente o programa.

Caso deva ser exibida uma variável de outro programa, introduzir o pro-
grama como a seguir:
/R1/Nome de programa
Não especificar nenhuma pasta entre /R1/ e o nome de programa. Não
especificar nenhuma extensão de arquivo no nome de programa.
4. Pressionar a tecla Enter.
No campo Valor atual é exibido o valor atual das variáveis. Se nada for
exibido, ainda não foi atribuído nenhum valor às variáveis.
5. No campo Novo valor digitar o valor desejado.
6. Pressionar a tecla Enter.
No campo Valor atual é exibido o novo valor.
Fig. 4-2: Janela Exibição de variável - individual
Pos. Descrição
1 Nome das variáveis, que devem ser alteradas
2 Novo valor, que deve ser atribuído às variáveis
3 Programa, no qual são procuradas variáveis
Em variáveis de sistema o campo Módulo é irrelevante.
4 Este campo tem dois estados:
 : o valor exibido não é atualizado automaticamente.
 : o valor exibido é atualizado automaticamente.

Alternar entre os estados:
 Pressionar Atual..
 Alternativamente: Shift + Enter
Exibição de infor- Procedimento para a exibição de flags, contadores e temporizadores:

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

4.5 Arrays / Campos com KRL
Descrição de Campos ou também Arrays oferecem espaço de memória para várias variá-
campos com KRL veis do mesmo tipo de dados, que são diferenciados através de index
 O espaço de memória para campos é finito, ou seja, o tamanho de campo
máximo depende da necessidade de memória do tipo de dados
 na declaração devem ser conhecidos o tamanho de campo e o tipo de da-
dos
 O índice de partida no KRL sempre começa com 1
 Uma inicialização pode ser realizada sempre individualmente
 Uma inicialização no SRC-File também pode ser realizada através de loop
Dimensões de campo
 Campo unidimensional
dimension[4]= TRUE
 Campo bidimensional
dimension[2,1]= 3.25
 Campo tridimensional
dimension[3,4,1]= 21
 Um campo quadridimensional ou superior não é suportado pelo KRL
Contextos no uso A vida útil e a validade de variáveis de campos é igual, como no uso de vari-
de campos áveis de um tipo de dados simples
Declaração de campo
 Criar no SRC_File
DEF MY_PROG ( )
DECL BOOL error[10]
DECL REAL value[50,2]
DECL INT parts[10,10,10]
INI
...
END
 Criação de uma lista de dados (inclusive $CONFIG.DAT)

DEFDAT MY_PROG
DECL BOOL error[10]
DECL REAL value[50,2]
DECL INT parts[10,10,10]
...
ENDDAT
Declarar e inicializar campo no SRC-File

 Cada campo individualmente com acesso de índice
DECL BOOL error[10]

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

error[6]=FALSE
error[7]=FALSE
error[8]=FALSE
error[9]=FALSE
error[10]=FALSE
 Com loops adequados

DECL BOOL error[10]
DECL INT x
INI
FOR x = 1 TO 10
error[x]=FALSE
ENDFOR
Após o término do loop x tem o valor 11
Inicializar o campo na lista de dados

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

DEFDAT MY_PROG
DECL BOOL error[10]
DECL INT size = 32
error[1]=FALSE
error[2]=FALSE
error[3]=FALSE
error[4]=FALSE
error[5]=FALSE
error[6]=FALSE
error[7]=FALSE
error[8]=FALSE
error[9]=FALSE
error[10]=FALSE
Gera dez mensagens de erro "Passo de valor inicial não está na se-
ção inicial"
O campo completo pode ser exibido quando no menu principal se se-

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

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

 Se um campo for criado deste modo na lista de dados, os valores atuais
não podem ser lidos na lista de dados; os valores atuais podem ser veri-
ficados somente com a exibição de variáveis.
DEFDAT MY_PROG
DECL BOOL error[10]
DEF MY_PROG ( )
INI
error[1]=FALSE
error[2]=FALSE
error[3]=FALSE
...
error[10]=FALSE
ou
DEF MY_PROG ( )
INI
FOR x = 1 TO 10
error[x]=FALSE
ENDFOR
Inicialização através de loops

 Campo unidimensional
DECL INT parts[15]
DECL INT x
FOR x = 1 TO 15
parts[x]= 4
ENDFOR
 Campo bidimensional
DECL INT parts_table[10,5]
DECL INT x, y
FOR x = 1 TO 10
FOR y = 1 TO 5
parts_table[x, y]= 6
ENDFOR
ENDFOR
 Campo tridimensional
DECL INT parts_palette[5,4,3]
DECL INT x, y, z
FOR x = 1 TO 5
FOR y = 1 TO 4
FOR z = 1 TO 3
parts_palette[x, y, z]= 12
ENDFOR
ENDFOR
ENDFOR
Procedimento na 1. Definir tipos de dados para o campo

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

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

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

4.6 Exercício: Campos com tipos de dados simples e loop de contagem
 Declarar e inicializar campos com tipos de dados simples
 Editar elementos individuais de campo
 Trabalhar com a exibição de variáveis (configuração/exibição)
te exercício:
 Conhecimentos sobre tipos de dados simples
 Conhecimentos teóricos sobre campos
 Conhecimentos teóricos sobre loop FOR
 Conhecimentos teóricos sobre a exibição da variável
Definição de Amplie os seus programas criados com o seguinte:

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

 Amplie o seu fluxograma do programa existente, incluindo esse campo.
 Crie um novo grupo para a exibição das variáveis de campo necessárias.
 Teste o seu programa nos modos de operação T1, T2 e Automático. Aqui
1. Onde o tamanho de um campo é dimensionado?
............................................................

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

4.7 Estruturas com KRL
Variáveis com
diversas infor-
mações indivi-
duais
Fig. 4-4
Tipo de dados composto: estruturas

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

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

STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition, CHAR
car_model[15]
 Em uma estrutura também podem ser usadas estruturas conhecidas,

como uma posição POS.
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition, POS car_pos
 Após a definição da estrutura é necessário declarar uma variável de tra-

balho para isto
DECL CAR_TYPE my_car
Inicialização / Modificação de uma estrutura

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

my_car = {price 14999.95, motor 50, air_condition TRUE}
 Em uma estrutura não precisam ser indicados todos os elementos de es-

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

my_car.price = 9999.0
 Um elemento de estrutura pode ser alterado individualmente a qualquer

momento através de separador de ponto. Os demais elementos de estru-
tura não são excluídos ou alterados.
my_car.price = 12000.0 ; Os valores para motor e ar condicionado são
mantidos
Porém:
my_car = {price 12000.0} ; Os valores para motor e ar condicionado
são excluídos
A KUKA trabalha muito com estruturas pré-definidas depositadas no sistema.

É possível encontrar exemplos nas posições e na programação da mensa-
gem.
Estruturas KUKA pré-definidas da área das posições

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

my_car.motor = 50
my_car.air_condition = TRUE
my_car.car_pos = {X 1000, Y 500, A 0}
 Na inicialização com o separador de ponto também podem ser usadas va-

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

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

estrutura STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition
2. Declaração das variáveis de trabalho

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

my_car = {motor 50, price 14999.95, air_condition TRUE}
4. Modificação dos valores e/ou comparação de valores das variáveis de tra-

balho
my_car.price = value_car
IF my_car.price >= 20000.0 THEN

...
ENDIF

4.8 Exercício: Criar estruturas com KRL
 Geração de estruturas próprias (declaração, inicialização)
 Trabalhar com o separador de pontos
te exercício:
 Conhecimentos teóricos sobre tipos de dados e estruturas simples
Definição de Crie um programa com o nome Estrutura.

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

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

4.9 O tipo de dados de enumeração ENUM
Texto inequívoco
como valor de
variável
Fig. 4-5
 O tipo de dados de enumeração consiste de uma quantidade limitada de

constantes como verde, amarelo ou azul
ENUM COLOR_TYPE green, blue, red, yellow
 As constantes são nomes livremente selecionáveis

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

dados de enume-  Somente constantes conhecidas podem ser usadas
ração
 Um tipo de enumeração finalmente pode ser ampliado (mais de 250 cons-
tantes e mais de 2000 caracteres)
 Um tipo de enumeração pode ser usado sozinho
 Um tipo de enumeração pode ser incluído em uma estrutura

STRUC CAR_TYPE INT motor, REAL price, COLOR_TYPE car_color
 Tipos de dados de enumeração, que são usados em vários programas,

devem ser declarados na $CONFIG.DAT
 Tipos de enumeração auto-definidos devem terminar com TYPE para um
melhor reconhecimento
Criação de um 1. Definição das variáveis de enumeração e das constantes

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

my_land = #be
4. Comparação de valores das variáveis de trabalho

IF my_land == #es THEN
...
ENDIF

4.10 Exercício: Criar tipo de enumeração com KRL
 Gerar variáveis ENUM próprias (declaração)
 Trabalhar com variáveis ENUM
te exercício:
 Conhecimentos teóricos sobre tipos de dados e estruturas simples
 Conhecimentos teóricos sobre variáveis ENUM simples
Definição de Amplie a sua estrutura de programa com o seguinte:

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


5 Subprogramas e funções
5.1 Visão geral
s
dos:
 Subprogramas locais
 Subprogramas globais
 Transferência de parâmetros a subprogramas
 Programação de funções
5.2 Trabalhar com subprogramas locais
Definição de  Subprogramas locais estão após o programa principal e são caracteriza-

subprogramas dos com DEF Nome_Subprograma( ) e END
locais DEF MY_PROG( )
; este é o programa principal
...
END
_______________________________________
DEF LOCAL_PROG1( )
; este é o subprograma local 1
...
END
_______________________________________
DEF LOCAL_PROG2( )
...
END
_______________________________________
DEF LOCAL_PROG3( )
...
END
 Um arquivo SRC pode consistir em até 255 subprogramas locais

 Subprogramas locais podem ser acessados diversas vezes
 Para os nomes de programas locais há necessidade de parênteses
Contextos no  Após o processamento de um subprograma local é realizado o retorno no

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

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

 Coordenadas de pontos são salvas na respectiva lista DAT e estão dispo-
níveis para o programa completo (*.src)
DEF MY_PROG( )
...
SPTP P1 Vel=100% PDAT1
...
END
_______________________________________
DEF LOCAL_PROG1( )
...
; esta é a mesma posição que no programa principal
...
END
DEFDAT MY_PROG
...
DECL E6POS XP1={X 100, Y 200, Z 300 ... E6 0.0}
...
ENDDAT
 Com RETURN pode ser finalizado um subprograma, o que causa um retor-

no ao módulo de programa acessado, no exemplo após LOCAL_PROG1().
DEF MY_PROG( )
...
LOCAL_PROG1( )
...
END
_______________________________________
DEF LOCAL_PROG1( )
...
IF $IN[12]==FALSE THEN
RETURN ; retorno ao programa principal
ENDIF
...
END
Procedimento ao 1. Grupo de usuários Peritos

criar subpro- 2. Abrir o SRC-File no Editor
gramas locais 3. Deixar exibir linha DEF
DEF MY_PROG( )
...
END
4. Saltar com o Cursor sob a linha END

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

DEF MY_PROG( )
...
END
DEF PICK_PART( )
END
7. Após acionar retorno, é inserida uma barra transversal entre programa

principal e subprograma
DEF MY_PROG( )
...
END
_______________________________________
DEF PICK_PART( )
END
8. Programa principal e subprograma podem agora ser processados

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

subprogramas DEF GLOBAL1( )
globais ...
END
DEF GLOBAL2( )
...
END
 Subprogramas globais podem ser acessados diversas vezes
Contextos no  Após o processamento de um subprograma local é realizado o retorno no

trabalho com próximo comando na chamada do subprograma
subprogramas DEF GLOBAL1( )
locais ...
GLOBAL2( )
...
END
DEF GLOBAL2( )
...
GLOBAL3( )
...
END
DEF GLOBAL3( )
...
END
 Podem ser colocados no máx. 20 subprogramas em cascata

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

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

DEF GLOBAL2( )
...
END
DEFDAT GLOBAL2( )
DECL E6POS XP1={X 800, Z 775, Z 999 ... E6 0.0}
ENDDAT
 Com RETURN pode ser finalizado um subprograma, o que causa um re-

torno ao componente de programa acessado, no exemplo após
GLOBAL2().
DEF GLOBAL1( )
...
GLOBAL2( )
...
END
DEF GLOBAL2( )
...
IF $IN[12]==FALSE THEN
RETURN ; Retorno ao GLOBAL1( )
ENDIF
...
END
Procedimento na 1. Grupo de usuários Peritos

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

DEF PICK_PART( )
...
END
4. Abrir o arquivo SRC do programa MY_PROG no Editor

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

...
END
5.4 Transmitir parâmetros a subprogramas
Descrição da  Sintaxe
transferência de DEF MY_PROG( )
parâmetros ...
CALC (K, L)
...
END
DEF CALC(R:IN, S:OUT) ; Possibilidade de transferência como IN/OUT-

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

cais, mas também globais
Princípio da  Transferência de parâmetros como parâmetro IN (Call by value):

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

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

...
END
DEF CALC_1(num1:IN)
; O valor "r" é transferido somente para leitura para num1
DECL REAL num1
...
END
DEF CALC_2(num2:OUT)
; O valor "s" é transferido para num2, alterado e retornado
DECL REAL num2
...
END
 Transferência de valores ao mesmo tipo de dados é sempre possível

 Transferência de valores a outros tipos de dados:
DEF MY_PROG( )
DECL DATATYPE1 value
CALC(value)
END
_______________________________________
DEF CALC(num:IN)
DECL DATATYPE2 num
...
END
DATATYPE 1 DATATYPE 2 Observação

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

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

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

culado sem esses valores. Exemplo: RECHNE(w,, a)
 Transferência de parâmetros com campos

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

FELD_2D[,] (bidimensional), FELD_3D[,,] (tridimensio-
nal)
 Respectivos elementos de campo também podem ser transferidos

DEF MY_PROG( )
DECL CHAR name[10]
...
name[]="PETER"
CALC(name[1])
...
END
_______________________________________
DEF calc(symbol:IN)
; é transferido somente um caractere
DECL CHAR symbol
...
END
Ao transferir elementos de campo individuais, pode haver também

apenas uma única variável como destino e nenhum campo. Aqui so-
mente a letra "P" é transferida para o subprograma.
Procedimento na Considerações
transferência de 1. Definir quais parâmetros são necessários no subprograma
parâmetros 2. Determinar o tipo de transferência de parâmetros (parâmetros IN ou OUT)
3. Definir tipos de dados de saída e de dados de destino (no ideal o mesmo
tipo de dados)
4. Determinar a sequência da transferência de parâmetros
A observar: primeiro parâmetro enviado é escrito no primeiro parâ-

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

Procedimento
1. Carregar um programa principal no editor
2. No programa principal, declarar, inicializar e possivelmente manipular va-
riáveis
3. Criar acesso de subprograma com transferência de variável
4. Fechar e salvar o programa principal
5. Carregar um subprograma no editor
6. Complementar linha DEFcom variáveis e IN/OUT
7. No subprograma, declarar, inicializar e possivelmente manipular variáveis
8. Fechar e salvar o subprograma
Exemplo completo:
DEF MY_PROG( )
DECL REAL w
DECL INT a, b
w = 1.5
a = 3
b = 5
CALC(w, b, a)
; valores atuais
; w = 3.8
; a = 13
; b = 5
END
_______________________________________
DEF CALC(ww:OUT, bb:IN, aa:OUT)
; w <-> ww, b -> bb, a <-> aa
DECL REAL ww
DECL INT aa, bb
ww = ww + 2.3 ; ww = 1.5 + 2.3 =3.8 ->w
bb = bb + 5 ; bb = 5 + 5 = 10
aa = bb + aa ; aa = 10 + 3= 13 -> a
END

5.5 Exercício: Subprogramas com transferência de parâmetros
 Técnica de subprogramas com transferência de parâmetros
te exercício:
 Conhecimentos sobre técnica de subprograma
 Conhecimentos teóricos sobre a transferência de parâmetros
 Conhecimentos teóricos sobre funções
Definição de Definição de tarefas: complete os resultados após o término dos programas.

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

END
---------------------------------------------------------------------
-------------------------------
;Sub program
DEF Calc (X1:OUT, X2:IN, X3:OUT, X4:IN, X6:IN, X5:OUT)
INT X1, X2, X3, X4, X5, X6
; Calculation
X1 = X1 + 211 ; X1 = …………………
X2 = X2 - 312 ; X2 = …………………
X3 = X2 + X3 ; X3 = …………………
X4 = X4 * X5 ; X4 = …………………
X5 = X5 * 8 ; X5 = …………………
X6 = X6 – 40 ; X6 = …………………
END

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

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

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

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

funções com KRL grama principal.
 Frequentemente são necessários determinados valores de introdução,
para poder calcular o valor de retorno.
 No cabeçalho da função é definido o tipo de dado, que é retornado no pro-
grama principal.
 O valor a ser entregue é transferido com a instrução R

Idioma

Apostila Treinamento Robo Kuka 2 de 3

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila Treinamento Robo Kuka 2 de 3

Enviado por

Direitos autorais:

Formatos disponíveis

Training KUKA Roboter GmbH

KUKA System Software 8

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1 Programação com WorkVisual

1.1 Visão geral

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

1.2 Gerenciar projeto com o WorkVisual

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

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

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

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

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

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

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

Nunca conectar a KSI - KUKA Service Interface com uma

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

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

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

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

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

1.2.3 Carregar projeto existente no WorkVisual

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

Fig. 1-3: Projeto ativo antes do Transfer

Fig. 1-4: Project Explorer

 Últimos arquivos exibe os últimos arquivos utilizados

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

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

Carregar projeto Procedimento

Fig. 1-5: Find IP Address

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

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

1.2.4 Gravar localmente o projeto WorkVisual

Fig. 1-6: Salvar o projeto carregado

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

1.2.5 Modos WorkVisual

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

Fig. 1-7: Janela Áreas de trabalho

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

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

1.2.6 Estrutura de projeto WorkVisual (guia Arquivos)

Guia Estrutura de  Guia Estrutura de projeto