Treinamento do Robô Kuka Nível 2

Prévia do material em texto

Training
Programação do robô 2
KUKA System Software 8
Documento de treinamento
KUKA Roboter GmbH
Edição: 17.10.2012
Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
 
Programação do robô 2
2 / 147 Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
© Copyright 2012
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ções: Pub COLLEGE P2KSS8 Roboterprogrammierung 2 (PDF-COL) pt
Estrutura do livro: P2KSS8 Roboterprogrammierung 2 V3.1
Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
Índice
Índice
1 Programação estruturada ........................................................................... 5
1.1 Visão geral ................................................................................................................. 5
1.2 Objetivo de um método de programação padronizado .............................................. 5
1.3 Recursos auxiliares para a criação de programas de robô estruturados .................. 5
1.4 Como é elaborado um fluxograma do programa ....................................................... 10
1.5 Exercício: Criar um processo do programa ............................................................... 12
2 Introdução no nível de perito ..................................................................... 15
2.1 Visão geral ................................................................................................................. 15
2.2 Usar nível de perito .................................................................................................... 15
2.3 Exercício: Medição de ferramentas e base ................................................................ 17
2.4 Exercício: Navigator perito loop sem fim ................................................................... 19
3 Variáveis e acordos ..................................................................................... 21
3.1 Visão geral ................................................................................................................. 21
3.2 Manutenção de dados no KRL .................................................................................. 21
3.3 Trabalhar com tipos de dados simples ...................................................................... 24
3.3.1 Declaração de variáveis ....................................................................................... 24
3.3.2 Inicialização de variáveis com simples tipos de dados ......................................... 27
3.3.3 Manipulação de valores de variáveis de tipos de dados simples com KRL ......... 28
3.3.4 Exercício: Tipos de dados simples ....................................................................... 32
3.4 Arrays / Campos com KRL ........................................................................................ 33
3.5 Exercício: Campos com tipos de dados simples e loop de contagem ....................... 36
3.6 Estruturas com KRL ................................................................................................... 38
3.7 Exercício: criar estruturas com KRL .......................................................................... 40
3.8 O tipo de dados de enumeração ENUM .................................................................... 42
3.9 Exercício: Criar tipos de enumeração com KRL ........................................................ 43
4 Subprogramas e funções .......................................................................... 45
4.1 Visão geral ................................................................................................................. 45
4.2 Trabalhar com subprogramas locais .......................................................................... 45
4.3 Trabalhar com subprogramas globais ....................................................................... 47
4.4 Transmitir parâmetros a subprogramas ..................................................................... 49
4.5 Exercício: Subprogramas com transferência de parâmetros ..................................... 52
4.6 Programação de funções ........................................................................................... 54
4.7 Trabalhar com funções padrão KUKA ....................................................................... 56
5 Programação de movimento com KRL ..................................................... 59
5.1 Visão geral ................................................................................................................. 59
5.2 Programar movimentos com KRL .............................................................................. 59
5.3 Programar movimentos relativos através do KRL ..................................................... 67
5.4 Calcular ou manipular posições de robô .................................................................... 74
5.5 Modificar exatamente bits de Status e Turn .............................................................. 75
5.6 Exercício: Paletizar e despaletizar ............................................................................. 78
6 Trabalho com variáveis de sistema ........................................................... 83
6.1 Visão geral ................................................................................................................. 83
6.2 Medição do tempo de ciclo com temporizador .......................................................... 83
3 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
4 / 147
Programação do robô 2
6.3 Exercício: Medição de ciclo e otimização .................................................................. 84
7 Aplicação de Controles de execução de programa ................................. 87
7.1 Visão geral ................................................................................................................. 87
7.2 Consultar ou programar ramificações ....................................................................... 87
7.3 Programar distribuidor ............................................................................................... 89
7.4 Programar comando de salto .................................................................................... 92
7.5 Programar loops ........................................................................................................ 93
7.5.1 Programar loop sem-fim ....................................................................................... 93
7.5.2 Programar loop de contagem ............................................................................... 94
7.5.3 Programar o loop de rejeição ............................................................................... 96
7.5.4 Programar loop não rejeitante .............................................................................. 98
7.6 Programar funções de espera ................................................................................... 99
7.6.1 Função de espera dependente do tempo ............................................................ 99
7.6.2 Função de espera dependente do sinal ...............................................................100
7.7 Exercício: Técnicas de loop ....................................................................................... 102
8 Funções de comutação KRL ...................................................................... 105
8.1 Visão geral ................................................................................................................. 105
8.2 Programação das funções de comutação simples .................................................... 105
8.3 Programação de funções de comutação referentes à trajetória TRIGGER WHEN DISTANCE 
109
8.4 Programação de funções referentes à trajetória TRIGGER WHEN PATH .................. 112
8.5 Exercício: Funções de controle de trajetória em KRL ............................................... 115
9 Programação com WorkVisual ................................................................... 117
9.1 Visão geral ................................................................................................................. 117
9.2 Gerenciar projeto com o WorkVisual ......................................................................... 117
9.2.1 Abrir projeto com WorkVisual ............................................................................... 117
9.2.2 Comparar projetos com WorkVisual ..................................................................... 121
9.2.3 Transmitir o projeto na unidade de comando do robô (instalar) ........................... 126
9.2.4 Ativar o projeto na unidade de comando do robô ................................................. 130
9.3 Processar programas KRL com WorkVisual ............................................................. 133
9.3.1 Importar manuseio de arquivos ............................................................................ 133
9.3.2 Manuseio com o editor KRL ................................................................................. 139
Índice ............................................................................................................ 145
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
1 Programação estruturada
1 Programação estruturada
1.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 metodologia de programação padronizada
 Recursos auxiliares para a criação de programas de robô estruturados
 Fluxograma do programa
1.2 Objetivo de um método de programação padronizado
Objetivo do 
método de 
programação 
padronizado
Um método de programação padronizado serve para:
 dominar mais facilmente os problemas complexos com uma estrutura ri-
gorosamente desmembrada
 representar o procedimento básico de forma compreensível (sem ter co-
nhecimentos mais profundos de programação)
 aumentar a eficiência na manutenção, alteração e ampliação de progra-
mas
O planejamento antecipado do programa leva ao seguinte:
 definições de tarefas complexas podem ser divididas em tarefas simples
 o tempo total aplicado na programação é reduzido
 permite-se a intercambiabilidade dos componentes com o mesmo desem-
penho
 se podem desenvolver componentes separadamente
As 6 exigências para um programa do robô:
1. Eficiência
2. Ausência de erros
3. Compreensão
4. Facilidade de manutenção
5. Visibilidade
6. Economia
1.3 Recursos auxiliares para a criação de programas de robô estruturados
Qual é o sentido 
de um comen-
tário?
Comentários são complementos/notas dentro das linguagens de programa-
ção. Todas as linguagens de programação consistem de instruções para o 
computador (código) e notas para os processadores de textos (comentários). 
Se um texto fonte for processado (compilado, interpretado, etc.), os comentá-
rios são ignorados pelo software de processamento e não têm influência so-
bre o resultado.
Na unidade de comando KUKA são usados comentários de linhas, ou seja, os 
comentários terminam automaticamente no final da linha.
Comentários por si só não podem tornar um programa legível, mas podem au-
mentar consideravelmente a legibilidade de programas bem estruturados. 
Com os comentários, o programador tem a possibilidade de incluir notas, ex-
plicações no programa, sem que estas sejam registradas pela unidade de co-
mando como sintaxe.
O programador tem a responsabilidade de garantir que o conteúdo dos co-
mentários corresponda ao estado atual das orientações de programação. Em 
5 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
6 / 147
Programação do robô 2
caso de alterações de programa também os comentários deverão ser verifi-
cados e, se necessário, adaptados.
O conteúdo de um comentário e, portanto, também a sua utilidade, pode ser 
livremente selecionado pelo processador e não tem sintaxe obrigatória. Ge-
ralmente, comentários são registrados em linguagem "humana", na lingua 
materna do autor ou em um idioma comum. 
 Notas sobre o conteúdo ou a função de um programa
 Conteúdo ou utilidade são livremente selecionáveis
 Melhoram a legibilidade de um programa
 Contribuem para a estruturação de um programa
 A responsabilidade pela atualidade é do programador
 A KUKA usa comentários de linhas
 Os comentários não são registrados pela unidade de comando como sin-
taxe
Onde e quando 
são usados 
comentários?
Informações sobre todo o texto fonte: 
No início de um texto fonte o autor pode incluir comentários prévios, sob os 
quais seguem a indicação do autor, da licença, da data de criação, do ende-
reço de contato para perguntas, uma lista de outros arquivos necessários, etc. 
Classificação do texto fonte: 
Títulos e parágrafos podem ser identificados como tal. Aqui muitas vezes não 
são usados somente recursos linguísticos, mas também recursos gráficos, 
que podem ser convertidos através de textos. 
Explicação de uma única linha: 
Assim, o modo de trabalho ou o significado de uma parte de texto (por exem-
plo, linha de programa) podem ser explicados, para que outros ou o próprio 
autor possam compreender isso mais facilmente mais tarde. 
DEF PICK_CUBE()
;Este programa busca o cubo do magazine
;Autor: Max Mustermann
;Data de criação: 09.08.2011
INI
...
END
DEF PALLETIZE()
;*****************************************************
;*Este programa paletiza 16 cubos sobre a mesa*
;*Autor: Max Mustermann------------------------------*
;*Data de criação: 09.08.2011-----------------------*
;*****************************************************
INI
...
;------------Cálculo das posições----------------
...
;------------Paletização de 16 cubos---------------
...
;----------Despaletização de 16 cubos---------------
...
END
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
1 Programação estruturada
Nota sobre trabalhos a serem executados: 
Comentários podem identificar partes de código insuficientes ou ser variáveis 
para partes de código faltantes.
Descomentário: 
Se uma parte do código for excluído provisoriamente mas posteriormente 
reinserido, ele será descomentado. A parte do código, depois de embalado no 
comentário, no ponto de vista não é mais código, ou seja, já não existe mais.
Qual é o efeito do 
uso de pastas em 
um programa de 
robô?
 em PASTAS podem ser ocultadas partes do programa
 Conteúdos de PASTAS não são visíveis para o usuário
 Conteúdos de PASTAS são processados normalmente na execução do 
programa
 através do uso de pastas (folds) pode ser melhorada a legibilidade de um 
programa 
Que exemplos há 
para o uso de 
pastas?
Na unidade de comando KUKA pastas já são usadas, como padrão, pelo sis-
tema, por exemplo, na exibição de formulários Inline. As pastas simplificam a 
visibilidade dos valores introduzidos no formulário Inline, ocultando partes do 
programa não relevantes para o operador.
Além disso, o usuário (a partir do grupo de usuários peritos) tem a possibili-
dade de criar pastas próprias. Essas pastas podem ser usadas pelo progra-
mador, por exemplo, para comunicar ao operador algo que ocorre em uma 
determinada posição do programa, porém,mantendo a sintaxe KRL efetiva 
em segundo plano. 
DEF PICK_CUBE()
INI
PTP HOME Vel=100% DEFAULT
PTP Pre_Pos ; A posição prévia para a coleta é acessada
LIN Grip_Pos ; Posição de coleta do cubo é acessada
...
END
DEF PICK_CUBE()
INI
;Aqui deve ser inserido ainda o cálculo das posições de paletes!
PTP HOME Vel=100% DEFAULT
PTP Pre_Pos ; A posição prévia para a coleta é acessada
LIN Grip_Pos ; Posição de coleta do cubo é acessada
;Aqui falta ainda o fechamento da garra
END
DEF Palletize()
INI
PICK_CUBE()
;CUBE_TO_TABLE()
CUBE_TO_MAGAZINE()
END
7 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
8 / 147
Programação do robô 2
Inicialmente as pastas em geral são exibidas fechadas após a sua criação.
Por que se 
trabalha com a 
técnica de 
subprogramas?
Na programação, os subprogramas são utilizados especialmente para permi-
tir um uso múltiplo de partes de tarefas iguais e com isso, conseguir evitar as 
repetições de códigos. Isso, entre outros, também economiza espaço de me-
mória.
Outro motivo importante para o uso de subprogramas é também a decorrente 
estruturação do programa.
Um subprograma deve resolver uma tarefa parcial completa em si e fácil de 
se descrever.
Os subprogramas hoje devem ser curtos e compreensíveis para facilitar a ma-
nutenção e eliminar erros de programação, uma vez que o dispêndio de tem-
po e a administração interna do computador praticamente não são mais 
importantes para acessar subprogramas em computadores modernos.
 Uso múltiplo possível
DEF Main()
...
INI ; PASTA KUKA fechada
SET_EA ; PASTA criada pelo usuário fechada
PTP HOME Vel=100% DEFAULT ; PASTA KUKA fechada
PTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table
...
PTP HOME Vel=100% Default
END
DEF Main()
...
INI ; PASTA KUKA fechada
SET_EA ; PASTA criada pelo usuário aberta
$OUT[12]=TRUE
$OUT[102]=FALSE
PART=0
Position=0
PTP HOME Vel=100% DEFAULT ; PASTA KUKA fechada
...
PTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table
PTP HOME Vel=100% Default
END
DEF Main()
...
INI ; PASTA KUKA fechada
SET_EA ; PASTA criada pelo usuário fechada
PTP HOME Vel=100% DEFAULT ; PASTA KUKA aberta
$BWDSSTART=FALSE
PDAT_ACT=PDEFAULT
FDAT_ACT=FHOME
BAS(#PTP_PARAMS,100)
$H_POS=XHOME
PTP XHOME
...
PTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table
PTP HOME Vel=100% Default
END
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
1 Programação estruturada
 Evitar repetições de códigos 
 Economizar espaço de memória
 Componentes podem ser desenvolvidos separadamente
 A troca de componentes da mesma potência é possível a qualquer mo-
mento
 Estruturação do programa
 Tarefa total dividida em tarefas parciais
 Melhor manutenção e correção dos erros de programação 
Aplicação de 
subprogramas
O que provoca o 
recuo de linhas 
de comando?
Para mostrar a relação de componentes de programa, recomendamos fazer 
um recuo da margem em sequências de comandos encadeadas e escrever 
instruções na mesma profundidade de encadeamento diretamente na se-
quência.
O efeito obtido é meramente visual, ele se refere somente ao valor de um pro-
grama como recurso de comunicação de pessoa para pessoa.
O que se obtém 
através de uma 
identificação 
adequada de 
nomes de dados?
Para interpretar corretamente a função de dados e sinais em um programa do 
robô, recomendamos usar termos que fazem sentido na definição de nomes. 
A estes pertencem, p.ex.: 
 Nomes de textos descritivos para sinais de entrada e de saída
 Nomes de ferramentas e base
 Acordos de sinais para sinais de entrada e de saída
 Nomes de pontos
DEF MAIN()
INI
LOOP
 GET_PEN()
 PAINT_PATH()
 PEN_BACK()
 GET_PLATE()
 GLUE_PLATE()
 PLATE_BACK()
 IF $IN[1]== TRUE THEN
 EXIT
 ENDIF
ENDLOOP
END
DEF INSERT()
INT PART, COUNTER
INI
PTP HOME Vel=100% DEFAULT
LOOP
 FOR COUNTER = 1 TO 20
 PART = PART+1
 ;não é possível recuar formulários Inline!!!
PTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table
 PTP XP5 ; Movimento com KRL
 ENDFOR
...
ENDLOOP
9 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
10 / 147
Programação do robô 2
1.4 Como é elaborado um fluxograma do programa
O que é um PAP? Um fluxograma do programa (PAP) é um diagrama de execução para um pro-
grama que também é denominado de fluxograma ou plano de estrutura de 
programa. É uma representação gráfica para a realização de um algoritmo em 
um programa, descrevendo a consequência de operações para a solução da 
tarefa. Os ícones para fluxogramas do programa seguem a norma DIN 66001. 
Fluxogramas do programa muitas vezes são usados independente de progra-
mas de computador também para a representação de processos e atividades.
O algoritmo de programa é legível com maior facilidade em comparação com 
uma descrição baseada em código, uma vez que a representação gráfica per-
mite um reconhecimento melhor da estrutura.
Erros de estrutura e de programação são facilmente reconhecidos em uma re-
alização posterior em códigos de programa, uma vez que o uso correto do 
PAP permite uma realização direta em códigos de programação. Ao mesmo 
tempo, com a criação de um PAP, obtém-se uma documentação do programa 
a ser criado.
 Ferramenta para a estruturação da execução de um programa
 A execução de um programa é mais facilmente legível
 Erros estruturais podem ser reconhecidos com maior facilidade
 Documentação simultânea do programa
Ícones PAP Início ou fim de um processo ou programa
Integração de instruções e operações
Ramificação
Instruções gerais no código de programa
Fig. 1-1
Fig. 1-2
Fig. 1-3
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
1 Programação estruturada
Acesso ao subprograma
Instrução de entrada/saída
Exemplo PAP
Como é 
elaborado um 
PAP
Partindo da ideia do usuário o problema é detalhado passo a passo, até que 
os componentes elaborados sejam suficientemente visualizáveis, para poder 
realizá-los no KRL.
As minutas geradas nos passos subsequentes de desenvolvimento se destin-
guem pela crescente profundidade de detalhes.
Fig. 1-4
Fig. 1-5
Fig. 1-6
Fig. 1-7
11 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
12 / 147
Programação do robô 2
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
1.5 Exercício: Criar um processo do programa
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Dividir a tarefa total em tarefas parciais
 Detalhamento de uma classificação geral
 Criação de um PAP (fluxograma do programa)
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 conhecimentos teóricos sobre metodologia de programação
Definição de 
funções
Descrição da instalação
A tarefa do robô consiste da retirada de peças de plástico de uma máquina de 
injeção. As peças são levantadas com aspiradores de vácuo e empilhadas em 
uma esteira de ciclo ao lado da injetora.
Descrição do processo
1. Depois que a injetora (SGM) produziu uma peça, abre-se uma porta na 
sua frente.
2. Após o controle do interruptor de fim de curso da porta o robô se desloca 
até a posição de retirada e pega o componente.
3. O ejetor ejeta o componente da ferramenta.
4. O robô sai da máquina e o ejetor retorna.
5. Assim que o robô tiver deixado a máquina com segurança, a porta pode 
ser fechada e uma nova peça produzida.
6. Agora, o componente pronto é colocado no lugar livre na esteira de ciclo.
7. Depois a esteira é movimentada até a posição de depósito estar liberada 
novamente.Fig. 1-8
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
1 Programação estruturada
Definição de funções
1. Classifique a definição de funções em módulos de programa adequados.
2. Detalhe novamente a classificação geral.
3. Elabore um fluxograma do programa.
O que você deve saber agora:
1. Quais são as exigências para um programa?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
2. O que se entende por caderno de obrigações?
3. Quais são as vantagens de uma boa legibilidade de um programa?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
4. Quais são as vantagens no uso de pastas (folds)?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
13 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
14 / 147
Programação do robô 2
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
2 Introdução no nível de perito
2 Introdução no nível de perito
2.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Usar nível de perito
2.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.
 Programador
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.
 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.
 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.
Funções ampliadas do grupo de usuários Peritos:
 Protegido por senha (padrão: kuka)
 Programação no Editor é possível com KRL
 Vista detalhada para módulos disponível
 Exibir e ocultar linha DEF
 Abrir e fechar pastas (FOLD)
 Exibir vista detalhada no programa
 Na geração de programa podem ser selecionados templates pré-defini-
dos
 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)
15 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
16 / 147
Programação do robô 2
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, mas o retorno 
ainda deverá ser programado primeiro.
 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:
 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. 2-1
Como Perito, estão disponíveis todas as funções no menuEditar.
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
2 Introdução no nível de perito
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.
Abrir/Fechar PASTA
 As PASTAs estão sempre fechadas para o usuário e podem ser abertas 
como Perito.
 O perito também pode programar PASTAs próprias.
 A sintaxe para uma pasta é:
;PASTA 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.
Ativar procedi-
mento para nível 
de Perito e 
corrigir erros
Ativar nível de Peritos
1. Selecionar o menu principal Configuração > Grupo de usuários.
2. Login como Peritos: Clicar em Login. Marcar o grupo de usuários Peritos 
e confirmar com Login.
3. Inserir a senha requerida (padrão: kuka) e confirmar com Login.
Eliminar erros no programa. 
1. Selecionar módulo com erro no Navegador
2. Selecionar menu Lista de erros
3. A exibição de erros (nome de programa.ERR) abre
4. Selecionar erros, a descrição ampla é apresentada em baixo na exibição 
de erros
5. Na janela exibição de erros pressionar a tecla Exibir e saltar para o pro-
grama com defeitos
6. Corrigir erros
7. Fechar editor e salvar
2.3 Exercício: Medição de ferramentas e base
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Medição da ferramenta com o método XYZ 4-Pontos e o método World 5D
 Medição da ferramenta com introdução numérica de valor
Fig. 2-2: Programa com erro
17 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
18 / 147
Programação do robô 2
 Medição da base conforme o método 3 pontos
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos teóricos sobre a medição de uma ferramenta
 Conhecimentos teóricos sobre a medição de uma base
Definição de 
funções
Medição de garras
 Medir a garra com ajuda da "introdução numérica".
 Atribua o número de ferramenta 3 e o nome "Garra".
 Os dados de medição são:
 Dados de carga da garra:
Medição de pino
 Use o pino superior do magazine de pinos e fixe-o manualmente na garra. 
 Meça o pino com o método XYZ 4-Pontos e o método ABC-World 5D. 
 Como número de ferramenta use o 2 e como nome "Pino 1"
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".
O que você deve saber agora:
1. Quais são as vantagens da medição de uma base sobre a mesa?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2. Onde está o ponto de referência para a medição de uma ferramenta?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3. Quantos sistemas base diferentes o software KUKA comporta?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4. Qual é a diferença entre os métodos ABC-World 5D e 6D?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5. Onde há uma base não medida (estado de fornecimento)?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
X Y Z A B C
163 mm 146 mm 146 mm 45° 0° 180°
M X Y Z A B C
6,68 Kg 21 mm 21 mm 98 mm 0° 0° 0°
JX JY JZ
0,1 kgm2 0,4 kgm2 0,46 kgm2
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
2 Introdução no nível de perito
2.4 Exercício: Navigator perito loop sem fim
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Criação de módulos no plano de perícia
 Vínculo de determinados módulos em um programa principal
 Uso de um loop sem fim
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos teóricos sobre o Navigator no plano de peritos
 Conhecimentos teóricos sobre o uso de subprogramas globais
 Conhecimentos teóricos sobre um loop sem-fim 
Definição de 
funções
1. Antes do início da programação elabore um fluxograma do programa 
(PAP).
2. Crie dois módulos sensatos (Wuerfel_ab/Wuerfel_hol).
3. O acesso e o loop sem-fim deverão ser realizados no módulo MAGAZIN.
4. Teste o seu programa nos modos de operação T1, T2 e Automático. Aqui 
devem ser observadas as prescrições de segurança ensinadas.
O que você deve saber agora:
1. Na criação de um programa, qual é a diferença entre a seleção MODUL e 
EXPERT?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
2. O que se entende por tipo de execução do programa ISTEP?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
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?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
19 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
20 / 147
Programação do robô 2
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
3 Variáveis e acordos
3 Variáveis e acordos
3.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Manutenção de dados no KRL
 Trabalhar com tipos de dados simples
 Campos
 Estruturas
 Tipo de dados de contagem
3.2 Manutenção de dados no KRL
Trabalhar com 
variáveis com 
KRL
Dados gerais sobre variáveis
 Na programação do robô com KRL, uma variável no sentido mais geral é 
simplesmente um recipiente para dimensões de cálculo ("valores") que 
ocorrem na execução processo do robô.
 Uma variável tem um determinado endereço atribuído na memória do 
computador.
 Uma variável é determinada com um nome, que não seja a palavra-chave 
da KUKA.
 Cada variável é vinculada a um determinado tipo de dados
 A declaração do tipo de dados é necessária antes do uso.
 Em KRL há diferenciação entre variáveis locais e globais.
Vida útil de variáveis em KRL
 Por vida útil subentende-se um período, no qual a variável reservou a me-
mória.
 A variável de vida útil libera a sua memória ao sair do programa ou da fun-
ção.
 Variáveis da lista de dados recebem o valor atual em sua memória a longo 
prazo.
Validade de variáveis em KRL
 Variáveis de declaração local estão disponíveis e visíveis somente nesse 
programa.
 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 receber a palavra-chave global na declaração.
Tipos de dados com KRL
 Um tipo de dados descreve um resumo de objetos para uma quantidade
 Tipos de dados padrão pré-definidos
 Tipos de dados padrão definidos autonomamente
 Tipos de dados KUKA pré-definidos
Uso de variáveis 
com KRL
Convenções de 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.
21 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
22 / 147
Programação do robô 2
 Letras maiúsculas e minúsculas não são relevantes.
Tipos de dados com KRL
 Tipos de dados pré-definidos
 Campos /Array
 Salvar diversas variáveis do mesmo tipo de dados com índice
 Inicialização ou alteração de valor é realizada com índice
 O tamanho máximo do campo depende da necessidade de memória 
do tipo de dados
 Tipo de dados de enumeração
 Todos os valores do tipo de dados de enumeração são definidos com 
nomes (texto explícito) na criação
 O sistema define ainda a sequência
 O número máximo de elementos depende da memória
 Tipo de dados composto /estrutura
 Tipo de dados composto de componentes de diversos tipos de dados 
 Os componentes podem consistir de tipos de dados simples mas tam-
bém de estruturas
 Um acesso a determinados componentes é possível
Vida útil / Validade
 Variáveis criadas no arquivo SRC são denominadas variáveis de va-
lidade e
 não podem ser exibidas sempre
 só valem na parte de programa declarada
 liberam o seu local de memória ao alcançar a última linha do programa 
(linha END)
 Variáveis no arquivo local DAT
 podem ser exibidas sempre na execução do programa do respectivo 
SRC-File
 estão disponíveis no SRC-File completo inclusive nos subprogramas 
locais
 podem ser criadas também como variáveis globais
 contêm o valor atual no DAT-File e iniciam com o novo acesso com o 
valor salvo
 Variáveisno arquivo de sistema $CONFIG.DAT
 estão disponíveis em todos os programas (global),
Tipos de dados 
simples
Número 
inteiro
Número com 
vírgula alterável
Valores 
lógicos
Determi-
nado 
caractere
Palavra chave INT REAL BOOL CHAR
Faixa de valores -231 ... 
(231-1)
± 1.1 10-38... ± 
3.4 10+38
TRUE / 
FALSE
Conjunto 
de carac-
teres 
ASCII
Exemplos -199 ou 
56
-0,0000123 ou 
3,1415
TRUE ou 
FALSE
"A" ou "q" 
ou "7"
Voltage[10] = 12.75
Voltage[11] = 15.59
color = #red
Date = {day 14, month 12, year 1996}
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
3 Variáveis e acordos
 podem ser exibidas sempre, mesmo que não haja programa ativado,
 recebem o valor atual no $CONFIG.DAT.
Declarações duplas de variáveis
 Uma declaração dupla é criada sempre com o uso de uma sequência de 
caracteres igual (nome).
 O uso do mesmo nome em diferentes SRC-Files ou DAT-Files não repre-
senta declaração dupla
 Declarações duplas no mesmo arquivo SRC e DAT não são permitidas e 
geram uma mensagem de erro.
 Declarações duplas no SRC-File ou DAT e na $CONFIG.DAT são permi-
tidas:
 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.
Dados de sistema KUKA
 Há dados de sistema KUKA como sendo
 tipo de dados de enumeração como modo de operação (mode_op)
 estrutura como sendo data/hora (date)
 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 pré-definidas e começam com o símbolo "$"
 $DATE (horário e data atual)
 $POS_ACT (posição atual do robô)
 ...
23 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
24 / 147
Programação do robô 2
3.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)
3.3.1 Declaração de variáveis
Criação de 
variáveis
Declaração de variáveis
 A declaração deverá ser realizada sempre antes do uso
 A cada variável deverá ser atribuído um tipo de dados
 Na atribuição do nome deverão ser observadas as convenções de nomes
 A palavra-chave para a declaração é DECL
 A palavra-chave DECL pode ser descartada nos quatro tipos de dados 
simples
 Atribuições de valores são realizadas com o indicador de avanço
 A declaração de variáveis pode ser realizada de diferentes formas, mas 
indica a vida útil e a validade das respectivas variáveis
 Declaração no SRC-File
 Declaração no arquivo local DAT
 Declaração no $CONFIG.DAT
 Declaração no DAT-File com a palavra-chave "global"
 Criação de constantes
 Constantes são criadas com a palavra-chave CONST 
 Constantes só podem ser criadas em listas de dados
Princípio da 
declaração de 
variáveis
Estrutura de programa no SRC-File
 Na parte de declaração deverão ser declaradas variáveis 
 A parte de inicialização inicia com a primeira atribuição de valores, em ge-
ral com a linha "INI"
 Na parte de instruções os valores são atribuídos ou alterados 
Modificar vista padrão
 Apenas peritos podem exibir a linha DEF. 
 O procedimento é necessário para chegar à parte de declaração em mó-
dulos antes da linha "INI"
 Para poder visualizar as linhas DEF e END, importante também para a 
transferência de variáveis em subprogramas
DEF main( )
; Seção de declaração
...
; Seção de inicialização
INI
...
; Seção de instrução
PTP HOME Vel=100% DEFAULT
...
END
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
3 Variáveis e acordos
Planejar declaração de variáveis
 Definir vida útil
 SRC-File: a variável de tempo de execução "morre" no final da rotina 
do programa
 DAT-File: a variável é mantida após o término
 Definir validade/disponibilidade
 Local no SRC-File: somente disponível na rotina de programa, na qual 
esta foi declarada. Com isso a variável só é disponível entre a DEF lo-
cal e a linha END (programa principal ou subprograma local).
 Local no DAT-File: válido no programa completo, ou também nos sub-
programas locais.
 $CONFIG.DAT: disponível globalmente, ou seja, em todas as rotinas 
de programa é possível um acesso de leitura e escrita
 Local no DAT-File como variável global: disponibilidade global, em to-
das as rotinas de programa é possível um acesso de leitura e escrita, 
assim que o DAT-File for munido da palavra-chave PUBLIC e na de-
claração, adicionalmente, da palavra-chave GLOBAL. 
 Definir tipo de dados
 BOOL: resultados clássicos "SIM"/"NÃO"
 REAL: Resultados das operações de cálculo para poder evitar erros 
de arredondamento
 INT: variáveis de contagem clássicas para loops de contagem ou con-
tadores de unidades
 CHAR: somente um caracter
String ou texto só pode ser realizado como campo CHAR
 Atribuição de nome e declaração
 Usar DECL para facilitar a legibilidade do programa.
 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 
caracteres.
Procedimento na 
declaração de 
variáveis com 
tipos de dados 
simples
Criar variável no SRC-File
1. Grupo de usuários Peritos
2. Deixar exibir linha DEF
3. Abrir SRC-File no Editor
4. Realizar a declaração da variável
5. Fechar e salvar programas
Criar variável no DAT-File
1. Grupo de usuários Peritos
2. Abrir DAT-File no Editor
3. Realizar a declaração da variável
DEF MY_PROG ( )
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol
INI
...
END
25 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
26 / 147
Programação do robô 2
4. Fechar e salvar lista de dados
Criar variável na $CONFIG.DAT
1. Grupo de usuários Peritos
2. Na pasta SYSTEM abrir o $CONFIG.DAT no Editor
3. Selecionar a pasta "USER GLOBALS" e abri-la com o softkey "Abr/Fech 
pasta"
4. Realizar a declaração da variável
5. Fechar e salvar lista de dados
Criar variável global no DAT-File
1. Grupo de usuários Peritos
2. Abrir DAT-File no Editor
3. Ampliar a lista de dados no cabeçalho do programa com a palavra-chave 
PUBLIC
4. Realizar a declaração da variável
5. Fechar e salvar lista de dados
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol
...
ENDDAT
DEFDAT $CONFIG
BASISTECH GLOBALS
AUTOEXT GLOBALS
USER GLOBALS
ENDDAT
DEFDAT $CONFIG
...
;==================================
; Userdefined Types 
;==================================
;==================================
; Userdefined Externals 
;==================================
;==================================
; Userdefined Variables 
;==================================
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol
...
ENDDAT
DEFDAT MY_PROG PUBLIC
DEFDAT MY_PROG PUBLIC
EXTERNAL DECLARATIONS
DECL GLOBAL INT counter
DECL GLOBAL REAL price
DECL GLOBAL BOOL error
DECL GLOBAL CHAR symbol
...
ENDDAT
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
3 Variáveis e acordos
3.3.2 Inicialização de variáveis com simples tipos de dados
Descrição da 
inicialização com 
KRL
 Após cada declaração uma variável só reservou uma memória, o valor é 
sempre um valor inválido.
 No SRC-File é realizada a declaração e a inicialização sempre em duas 
linhas separadas.
 No DAT-File é realizada a declaração e a inicialização sempre em uma li-
nha.
Uma constante deverá ser inicializada imediatamente na declaração.
 A parte da inicialização inicia com a primeira atribuição de valor.
Princípio da 
inicialização
Inicialização de números inteiros
 Inicialização de decimais Inicialização como número binário
Cálculo: 1*32+1*16+1*8+0*4+1*2+0*1 = 58
 Inicialização hexadecimal
Cálculo: 3*16 +10 = 58
Procedimento na 
inicialização com 
KRL
Declaração e inicialização no SRC-File
1. Abrir SRC-File no Editor
2. A declaração foi retornada
3. Realizar inicialização
4. Fechar e salvar programas
Declaração e inicialização no DAT-File
1. Abrir DAT-File no Editor
2. A declaração foi retornada
3. Realizar inicialização
value = 58
value = 'B111010'
Binário 25 24 23 22 21 20
Dez 32 16 8 4 2 1
value = 'H3A'
He
x
0 1 2 3 4 5 6 7 8 9 A B C D E F
De
z
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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
27 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
28 / 147
Programação do robô 2
4. Fechar e salvar lista de dados
Declaração no DAT-File e inicialização no SRC-File
1. Abrir DAT-File no Editor
2. Realizar declaração
3. Fechar e salvar lista de dados
4. Abrir SRC-File no Editor
5. Realizar inicialização
6. Fechar e salvar programas
Declaração e inicialização de uma constante
1. Abrir DAT-File no Editor
2. Realizar declaração e inicialização
3. Fechar e salvar lista de dados
3.3.3 Manipulação de valores de variáveis de tipos de dados simples com KRL
Listagem de 
possibilidades 
para a alteração 
de valores de 
variáveis com 
KRL
Os valores de variáveis são alterados de forma distinta nas rotinas de progra-
ma (SRC-File) conforme a tarefa. A seguir são abordados os métodos mais 
comuns. A manipulação com operações bit e funções padrão é possível, mas 
não será detalhada.
Manipulação de dados através de
 Tipos de cálculo básico
 (+) Adição
 (-) Subtração
 (*) Multiplicação
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL INT counter = 10
DECL REAL price = 0.0
DECL BOOL error = FALSE
DECL CHAR symbol = "X"
...
ENDDAT
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL INT counter
DECL REAL price
DECL BOOL error
DECL CHAR symbol
...
ENDDAT
DEF MY_PROG ( )
...
INI
counter = 10
price = 0.0
error = FALSE
symbol = "X"
...
END
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL CONST INT max_size = 99
DECL CONST REAL PI = 3.1415
...
ENDDAT
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
3 Variáveis e acordos
 (/) 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 
manipulação de 
dados
Modificação de valores usando os tipos de dados REAL e INT
 Arredondar para cima/ para baixo
 Resultados de operações aritméticas (+;-;*)
; Declaração
DECL INT A,B,C
DECL REAL R,S,T
; Inicialização
A = 3 ; A=3
B = 5.5 ; B=6 (a partir de x.5 é arredondado para cima)
C = 2.25 ; C=2 (arredondar para baixo)
R = 4 ; R=4.0
S = 6.5 ; S=6.5
T = C ; T=2.0 (aplica-se o valor arredondado para baixo)
Operandos INT REAL
INT INT REAL
REAL REAL REAL
29 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
30 / 147
Programação do robô 2
 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.
Operações comparativas
Com operações comparativas podem ser formadas expressões lógicas O re-
sultado de uma comparação é sempre o tipo de dados BOOL.
Operações lógicas
Com operações lógicas podem ser formadas expressões lógicas. O resultado 
dessa operação é sempre o tipo de dados BOOL.
; Declaração
DECL INT D,E
DECL REAL U,V
; Inicialização
D = 2
E = 5
U = 0.5
V = 10.6
; Seção de instrução (manipulação de dados)
D = D*E ; D = 2 * 5 = 10
E = E+V ; E= 5 + 10.6 = 15.6 -> arredondar para cima E=16
U = U*V ; U= 0.5 * 10.6 = 5.3
V = E+V ; V= 16 + 10.6 = 26.6
; Declaração
DECL INT F
DECL REAL W
; Inicialização
F = 10
W = 10.0
; Seção de instrução (manipulação de dados)
; INT / INT -> INT
F = F/2 ; F=5
F = 10/4 ; F=2 (10/4 = 2.5 -> Cortar a casa decimal)
; REAL / INT -> REAL
F = W/4 ; F=3 (10.0/4=2.5 -> arredondar para cima)
W = W/4 ; W=2.5
Operador/
KRL
Descrição Tipos de dados admissíveis
== idêntico/igual-
dade
INT, REAL, CHAR, BOOL
<> desigual INT, REAL, CHAR, BOOL
> maior INT, REAL, CHAR
< menor INT, REAL, CHAR
>= maior igual INT, REAL, CHAR
<= menor igual INT, REAL, CHAR
; Declaração
DECL BOOL G,H
; Inicialização/Seção de instrução
G = 10>10.1 ; G=FALSE
H = 10/3 == 3 ; H=TRUE
G = G<>H ; G=TRUE
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
3 Variáveis e acordos
Operadores são executados na sequência de suas prioridades
Procedimento na 
manipulação de 
dados
1. Definir tipo de dados para a(s) variável(eis)
2. Calcular a validade e vida útil das variáveis
3. Realizar a declaração das variáveis
4. Inicializar a variável
5. Nas rotinas de programa, ou seja, sempre no SRC-File, manipule a vari-
ável
6. Fechar e salvar SRC-File
Comando Stop O comando STOP para o programa. Contudo, a última instrução de movimen-
to percorrida ainda é executada por completo.
O programa somente pode ser continuado com a tecla Iniciar. Depois é exe-
cutada a próxima instrução após STOP.
Operações NOT A A AND B A OR B A 
EXOR 
B
A=TRUE B=TRUE FALSE TRUE TRUE FAL-
SE
A=TRUE B=FALS
E
FALSE FALSE TRUE TRUE
A=FALSE B=TRUE TRUE FALSE TRUE TRUE
A=FALSE B=FALS
E
TRUE FALSE FALSE FAL-
SE
; Declaração
DECL BOOL K,L,M
; Inicialização/Seção de instrução
K = TRUE
L = NOT K ; L=FALSE
M = (K AND L) OR (K EXOR L) ; M=TRUE
L = NOT (NOT K) ; L=TRUE
Prioridade Operador
1 NOT (B_NOT)
2 Multiplicação (*); Divisão (/)
3 Adição (+), Subtração (-)
4 AND (B_AND)
5 EXOR (B_EXOR)
6 OR (B_OR)
7 qualquer comparação (==; <>; ...)
; Declaração
DECL BOOL X, Y
DECL INT Z
; Inicialização/Seção de instrução
X = TRUE
Z = 4
Y = (4*Z+16 <> 32) AND X ; Y=FALSE
Em um programa Interrupt o programa somente é parado após a exe-
cução completa do avanço.
31 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
32 / 147
Programação do robô 2
3.3.4 Exercício: Tipos de dados simples
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Uso de tipos de dados simples
 Declaração, inicialização e uso de variáveis
 uso correto das variáveis em relação à sua vida útil 
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 conhecimentos teóricos sobre tipos de dados simples e seu manuseio 
Definição de 
funções
Amplie os seus programas criados com o seguinte:
 Uma variável conta o número dos módulos transportados desde a última 
seleção de programa. 
 Uma variável deverá salvar o número absoluto de todos os módulos até o 
momento transportados
 Uma variável deverá contar o peso total (em kg) dos módulos transporta-
dos. Um módulo pesa 0,329 kg.
 Uma variável, que no processo de retirada do módulo for TRUE, em ou-
tros momentos FALSE. 
 Uma variável, que com a garra aberta contém a letra "O" e com a garra 
fechada a letra "G". No estado não definido a variável receberá o valor "X". 
Use nomes de variáveis e tipos de dados adequados. É importante também 
declarar as variáveis no local correto. 
 Defina, onde as suas variáveis são declaradas.
 Amplieo seu fluxograma do programa existente, incluindo essas novas 
variáveis.
 Observe as diferentes inicializações das variáveis.
 Teste o seu programa nos modos de operação T1, T2 e Automático. Aqui 
devem ser observadas as prescrições de segurança ensinadas.
O que você deve saber agora:
1. Qual é o tamanho máximo de um nome da variável?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2. Quais tipos de dados simples existem?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3. Onde as variáveis são declaradas no SRC-File?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4. Que vida útil tem uma variável declarada na $CONFIG.DAT?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5. Declare um número com vírgula alterável com o nome "Value" no DAT-File 
com o valor 138,74.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
3 Variáveis e acordos
3.4 Arrays / Campos com KRL
Descrição de 
campos com KRL
Campos ou também Arrays oferecem espaço de memória para várias variá-
veis do mesmo tipo de dados, que são diferenciados através de index
 O espaço de memória para campos é finito, ou seja, o tamanho de campo 
máximo depende da necessidade de memória do tipo de dados
 na declaração devem ser conhecidos o tamanho de campo e o tipo de da-
dos
 O índice de partida no KRL sempre começa com 1
 Uma inicialização pode ser realizada sempre individualmente
 Uma inicialização no SRC-File também pode ser realizada através de loop
Dimensões de campo
 Campo unidimensional
 Campo bidimensional
 Campo tridimensional
 Um campo quadridimensional ou superior não é suportado pelo KRL
Contextos no uso 
de campos
A vida útil e a validade de variáveis de campos é igual, como no uso de vari-
áveis de um tipo de dados simples
Declaração de campo
 Criar no SRC_File
 Criação de uma lista de dados (inclusive $CONFIG.DAT)
Declarar e inicializar campo no SRC-File
 Cada campo individualmente com acesso de índice
dimension1[4]= TRUE
dimension2[2,1]= 3.25
dimension1[3,4,1]= 21
DEF MY_PROG ( )
DECL BOOL error[10]
DECL REAL value[50,2]
DECL INT parts[10,10,10]
INI
...
END
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL BOOL error[10]
DECL REAL value[50,2]
DECL INT parts[10,10,10]
...
ENDDAT
DECL BOOL error[10]
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
33 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
34 / 147
Programação do robô 2
 Com loops adequados
Inicializar o campo na lista de dados
 Cada campo individualmente com acesso de índice e posterior exibição 
de valor na lista de dados
 Declaração não permitida e inicialização na lista de dados 
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.
DECL BOOL error[10]
DECL INT x
FOR x = 1 TO 10
error[x]=FALSE
ENDFOR
Após o término do loop x tem o valor 11
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL BOOL error[10]
error[1]=FALSE
error[2]=FALSE
error[3]=FALSE
error[4]=FALSE
error[5]=FALSE
error[6]=FALSE
error[7]=FALSE
error[8]=FALSE
error[9]=FALSE
error[10]=FALSE
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL BOOL error[10]
DECL INT size = 32
error[1]=FALSE
error[2]=FALSE
error[3]=FALSE
error[4]=FALSE
error[5]=FALSE
error[6]=FALSE
error[7]=FALSE
error[8]=FALSE
error[9]=FALSE
error[10]=FALSE
Gera dez mensagens de erro "Passo de valor inicial não está na se-
ção inicial"
DEFDAT MY_PROG
EXTERNAL DECLARATIONS
DECL BOOL error[10]
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
3 Variáveis e acordos
ou 
Inicialização através de loops 
 Campo unidimensional
 Campo bidimensional
 Campo tridimensional
Procedimento ao 
usar Arrays
1. Definir tipos de dados para o campo
2. Calcular a validade e vida útil do campo
3. Realizar declaração de campo
4. Inicializar elementos de campo
5. nas rotinas de programa, isto é, sempre no SRC-File, manipular o campo
6. Fechar e salvar SRC-File
DEF MY_PROG ( )
INI
error[1]=FALSE
error[2]=FALSE
error[3]=FALSE
...
error[10]=FALSE
DEF MY_PROG ( )
INI
FOR x = 1 TO 10
error[x]=FALSE
ENDFOR
DECL INT parts[15]
DECL INT x
FOR x = 1 TO 15
parts[x]= 4
ENDFOR
DECL INT parts_table[10,5]
DECL INT x, y
FOR x = 1 TO 10
 FOR y = 1 TO 5
 parts_table[x, y]= 6
 ENDFOR
ENDFOR
DECL INT parts_palette[5,4,3]
DECL INT x, y, z
FOR x = 1 TO 5
 FOR y = 1 TO 4
 FOR z = 1 TO 3
 parts_palette[x, y, z]= 12
 ENDFOR
 ENDFOR
ENDFOR
35 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
36 / 147
Programação do robô 2
3.5 Exercício: Campos com tipos de dados simples e loop de contagem
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Declarar e inicializar campos com tipos de dados simples
 editar elementos individuais de campo
 Trabalhar com a exibição de variáveis (configuração/exibição) 
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 Conhecimentos sobre tipos de dados simples 
 conhecimentos teóricos sobre campos 
 conhecimentos teóricos sobre loop FOR 
 conhecimentos teóricos sobre a exibição da variável
Definição de 
funções
Amplie os seus programas criados com o seguinte:
 Crie um campo unidimensional com o tamanho 12. O conteúdo dos cam-
pos deverá ser a letra "O" ou "X". 
 Antes do início da execução todos os campos devem estar pré-preenchi-
dos com "O". 
 Após a entrega do 1º módulo, o 1º campo deverá receber a letra "X". Para 
as demais entregas deve-se proceder da mesma forma.
 Verifique o index de campo atual e o conteúdo do campo. 
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
...
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
3 Variáveis e acordos
 Defina, onde as suas variáveis são declaradas. 
 Amplie o seu fluxograma do programa existente, incluindo esse campo. 
 Crie um novo grupo para a exibição das variáveis de campo necessárias. 
 Teste o seu programa nos modos de operação T1, T2 e Automático. Aqui 
devem ser observadas as prescrições de segurança ensinadas. 
O que você deve saber agora:
1. Onde o tamanho de um campo é dimensionado? 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
2. Qual é a diferença dadeclaraçã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. O que pode ser ativado com o softkey "Info start." na exibição da variável?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
Fig. 3-1
37 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
38 / 147
Programação do robô 2
3.6 Estruturas com KRL
Variáveis com 
diversas infor-
mações indivi-
duais
Tipo de dados composto: estruturas
 Com campos podem ser combinadas variáveis do mesmo tipo de dados. 
No mundo real as variáveis geralmente consistem de 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.
 Uma estrutura primeiro precisa ser definida, depois pode ser reutilizada.
Uso de uma 
estrutura
Disponibilidade/definição de uma estrutura
 Em uma estrutura podem ser usados os tipos de dados simples INT, RE-
AL, BOOL e CHAR.
 Em uma estrutura podem ser inseridos campos CHAR.
 Em uma estrutura também podem ser usadas estruturas conhecidas, 
como uma posição POS.
 Após a definição da estrutura é necessário declarar uma variável de tra-
balho para isto
Inicialização / Modificação de uma estrutura
 A inicialização pode ser realizada através de parênteses.
 Na inicialização com parênteses só podem ser usadas constantes (valo-
res fixos).
 A sequência da atribuição de valores não deve ser observada.
 Em uma estrutura não precisam ser indicados todos os elementos de es-
trutura.
 Uma estrutura é inicializada com um elemento de estrutura.
Fig. 3-2
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition, CHAR 
car_model[15]
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition, POS 
car_pos
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition
DECL CAR_TYPE my_car
my_car = {motor 50, price 14999.95, air_condition = TRUE}
my_car = {price 14999.95, motor 50, air_condition = TRUE}
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
3 Variáveis e acordos
 Valores não inicializados estão ou serão colocados em desconhecido.
 A inicialização também pode ser feita com separador de ponto.
 Na inicialização com separador de ponto também podem ser usadas va-
riáveis.
 Um elemento de estrutura pode ser alterado individualmente a qualquer 
momento através de separador de ponto.
Vida útil / Validade
 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
Atribuição de nome
 Não podem ser usadas palavras-chave
 Tipos de enumeração definidos por conta própria deverão terminar com 
TYPE para facilitar o reconhecimento
A KUKA trabalha muito com estruturas pré-definidas depositadas no sistema. 
É possível encontrar exemplos nas posições e na programação da mensa-
gem.
Estruturas KUKA pré-definidas da área das posições
 AXIS: STRUC AXIS REAL A1, A2, A3, A4, A5, A6
 E6AXIS: STRUC E6AXIS REAL A1, A2, A3, A4, A5, A6, E1, E2, E3, E4, 
E5, E6
 FRAME: STRUC FRAME REAL X, Y, Z, A, B, C
 POS: STRUC POS REAL X, Y, Z, A, B, C INT S,T
 E6POS: STRUC E6POS REAL X, Y, Z, A, B, C, E1, E2, E3, E4, E5, E6 
INT S,T
Inicialização de uma estrutura com uma posição
 Na inicialização com parênteses só podem ser usadas constantes (valo-
res fixos)
 A inicialização também poderá ser realizada com o separador de ponto
 Na inicialização com o separador de ponto também podem ser usadas va-
riáveis
Criação de uma 
estrutura
1. Definição da estrutura
my_car = {motor 75} ; nenhum preço conhecido
my_car.price = 9999.0
my_car.price = value_car
my_car.price = 12000.0
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition, POS 
car_pos
DECL CAR_TYPE my_car
my_car = {price 14999.95, motor 50, air_condition = TRUE, car_pos {X 
1000, Y 500, A 0}}
my_car.price = 14999.95
my_car.car_pos = {X 1000, Y 500, A 0}
my_car.price = 14999.95
my_car.car_pos.X = x_value
my_car.car_pos.Y = 750
STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition
39 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
40 / 147
Programação do robô 2
2. Declaração das variáveis de trabalho
3. Inicialização das variáveis de trabalho
4. Modificação dos valores e/ou comparação de valores das variáveis de tra-
balho
3.7 Exercício: criar estruturas com KRL
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Geração de estruturas próprias (declaração, inicialização) 
 Trabalhar com o separador de pontos
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 conhecimentos teóricos sobre tipos de dados e estruturas simples 
Definição de 
funções
Crie um programa com o nome Estrutura.
 Gere uma estrutura com o nome BOX_Typ. Nessa estrutura deverão ser 
depositados os seguintes valores característicos:
 Comprimento
 Largura
 Altura
 Estado da esmaltagem (sim/não)
 Número de garrafas 
 Atribua à variável KISTE (CAIXA) a estrutura BOX_Typ e inicialize com os 
seguintes valores de início:
 Comprimento 25,2
 Largura 18,5
 Altura 5,0 
 Conteúdo: 4 garrafas 
 Não esmaltado
 No primeiro processo de usinagem ainda serão acrescentadas 8 garrafas. 
No 2º passo a KISTE (CAIXA) será ainda pintada. Entre o passo um e dois 
programe um período de espera de 3 segundos.
 Solicite a exibição do conteúdo da variável KISTE (CAIXA) durante o pro-
cedimento. 
 Defina, onde as suas variáveis são declaradas. 
 Amplie o seu fluxograma do programa existente, incluindo esse campo. 
 Crie um novo grupo para a exibição das variáveis de campo necessárias. 
 Teste o seu programa nos modos de operação T1, T2 e Automático. Aqui 
devem ser observadas as prescrições de segurança ensinadas. 
O que você deve saber agora:
DECL CAR_TYPE my_car
my_car = {motor 50, price 14999.95, air_condition TRUE}
my_car.price = 5000.0
my_car.price = value_car
IF my_car.price >= 20000.0 THEN
...
ENDIF
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
3 Variáveis e acordos
1. O que é uma estrutura?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
2. Que estruturasKUKA 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?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
41 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
42 / 147
Programação do robô 2
3.8 O tipo de dados de enumeração ENUM
Texto inequívoco 
como valor de 
variável
 O tipo de dados de enumeração consiste de uma quantidade limitada de 
constantes como verde, amarelo ou azul
 As constantes são nomes 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 
dados de enume-
ração
Disponibilidade / Uso
 Somente constantes conhecidas podem ser usadas
 Um tipo de enumeração pode ser ampliado à vontade
 um tipo de enumeração pode ser usado sozinho 
 Um tipo de enumeração pode ser incluído em uma estrutura 
Vida útil / Validade
 Tipos de dados de enumeração são inválidos ao alcançar a linha END
 Tipos de dados de enumeração usados em vários programas, deverão 
ser declarados na $CONFIG.DAT
Atribuição de nome
 Nomes de tipos de enumeração e suas constantes deverão ser auto-ex-
plicativos
 Não podem ser usadas palavras-chave
 Tipos de enumeração auto-explicativos deverão terminar com TYPE para 
facilitar o reconhecimento
Criação de um 
tipo de dados de 
enumeração
1. Definição das variáveis de enumeração e das constantes
2. Declaração das variáveis de trabalho
3. Inicialização das variáveis de trabalho
Fig. 3-3
ENUM COLOR_TYPE green, blue, red, yellow
ENUM COLOR_TYPE green, blue, red, yellow
ENUM COLOR_TYPE green, blue, red, yellow
STRUC CAR_TYPE INT motor, REAL price, COLOR_TYPE car_color
ENUM LAND_TYPE de, be, cn, fr, es, br, us, ch
DECL LAND_TYPE my_land
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
3 Variáveis e acordos
4. Comparação de valores das variáveis de trabalho
3.9 Exercício: Criar tipos de enumeração com KRL
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Gerar variáveis ENUM próprias (declaração) 
 Trabalhar com variáveis ENUM
Pré-requisitos São necessários os seguintes pré-requisitos para a conclusão com êxito des-
te exercício:
 conhecimentos teóricos sobre tipos de dados e estruturas simples 
 conhecimentos teóricos sobre variáveis ENUM simples 
Definição de 
funções
Amplie a sua estrutura de programa com o seguinte:
1. Gere uma variável ENUM cujo conteúdo inclua as cores vermelho, ama-
relo, verde e azul. 
2. Crie uma variável Lâmpada, à qual você atribui a cor azul.
3. No segundo passo, atribua à lâmpada a cor amarela. 
4. Amplie a sua estrutura BOX_Typ com o agregado cor e atribua à KISTE 
(CAIXA) no início a cor vermelha, depois amarela e no final a cor verde.
5. Exiba o conteúdo da variável KISTE (CAIXA) durante o procedimento. 
O que você deve saber agora:
1. Quem define a quantidade e os nomes das constantes no tipo de enume-
ração ENUM? 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
2. Quando é usado o ícone "#"?
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
3. O que está errado na seguinte geração? 
ENUM Tag_typ mo, di, mi, do, fr, sa, so
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
my_land = #be
IF my_land == #es THEN
...
ENDIF
43 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
44 / 147
Programação do robô 2
Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
4 Subprogramas e funções
4 Subprogramas e funções
4.1 Visão geral
Nesta unidade de aprendizagem são repassados os seguintes conteú-
dos:
 Subprogramas locais
 Subprogramas globais
 Transferência de parâmetros a subprogramas
 Programação de funções
4.2 Trabalhar com subprogramas locais
Definição de 
subprogramas 
locais
 Subprogramas locais estão após o programa principal e são caracteriza-
dos com DEF Nome_Subprograma( ) e END
 Um arquivo SRC pode consistir em até 255 subprogramas locais
 Subprogramas locais podem ser acessados diversas vezes
 Para os nomes de programas locais há necessidade de parênteses
Contextos no 
trabalho com 
subprogramas 
locais
 Após o processamento de um subprograma local é realizado o retorno no 
próximo comando na chamada do subprograma
 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 arquivo completo
DEF MY_PROG( )
; este é o programa principal
...
END
_______________________________________
DEF LOCAL_PROG1( )
; este é o subprograma local 1
...
END
_______________________________________
DEF LOCAL_PROG2( )
; este é o subprograma local 2
...
END
_______________________________________
DEF LOCAL_PROG3( )
; este é o subprograma local 3
...
END
DEF MY_PROG( )
; este é o programa principal
...
LOCAL_PROG1( )
...
END
_______________________________________
DEF LOCAL_PROG1( )
...
LOCAL_PROG2( )
...
END
_______________________________________
DEF LOCAL_PROG2( )
...
END
45 / 147Edição: 17.10.2012 Versão: P2KSS8 Roboterprogrammierung 2 V2 pt (PDF-COL)
46 / 147
Programação do robô 2
 com RETURN pode ser concluído um subprograma, provocando um retor-
no para o componente de programa acessado
Procedimento ao 
criar subpro-
gramas locais
1. Grupo de usuários Peritos
2. Deixar exibir linha DEF
3. Abrir SRC-File no Editor
4. Saltar com o Cursor sob a linha END
5. Atribuir cabeçalho de programa local com DEF, nomes de programas e pa-
rênteses
6. Concluir novo subprograma com um comando END
DEF MY_PROG( )
; este é o programa principal
...
PTP P1 Vel=100% PDAT1
...
END
_______________________________________
DEF LOCAL_PROG1( )
...
; esta é a mesma posição que no programa principal
PTP P1 Vel=100% PDAT1
...
END
DEFDAT MY_PROG( )
...
DECL E6POS XP1={X 100, Z 200, Z 300 ... E6 0.0}
...
ENDDAT
DEF MY_PROG( )
; este é o programa principal
...
LOCAL_PROG1( )
...
END
_______________________________________
DEF LOCAL_PROG1( )
...
IF $IN[12]==FALSE THEN
RETURN ; retorno ao programa principal
ENDIF
...
END
DEF MY_PROG( )
...
END
DEF MY_PROG( )
...
END