Treinamento Robô Kuka Nível 3

Prévia do material em texto

Training
Programação do robô 3
KUKA System Software 8
KUKA Roboter GmbH
Edição: 17.10.2012
Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
 
Programação do robô 3
2 / 95 Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 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 P3KSS8 Roboterprogrammierung 3 (PDF-COL) pt
Estrutura do livro: P3KSS8 Roboterprogrammierung 3 V2.1
Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
Índice
Índice
1 Programação estruturada ........................................................................... 5
1.1 Objetivo de um método de programação padronizado .............................................. 5
1.2 Recursos auxiliares para a criação de programas de robô estruturados .................. 5
1.3 Como é elaborado um fluxograma do programa ....................................................... 9
2 Interpretador Submit ................................................................................... 13
2.1 Status do Interpretador Submit .................................................................................. 13
3 Espaços de trabalho com KRL ................................................................... 17
3.1 Usar espaços de trabalho .......................................................................................... 17
3.2 Exercício: Monitoramento do espaço de trabalho ...................................................... 27
4 Programação de mensagens com KRL ..................................................... 29
4.1 Generalidades sobre mensagens definidas pelo usuário .......................................... 29
4.2 Trabalhar com uma mensagem de informação ........................................................ 36
4.3 Exercício: Programar mensagem de informação ....................................................... 37
4.4 Trabalhar com uma mensagem de estado ................................................................ 39
4.5 Exercício: Programar mensagem de estado .............................................................. 40
4.6 Trabalhando com mensagem de confirmação ........................................................... 42
4.7 Exercício: Programar mensagens de confirmação .................................................... 43
4.8 Trabalhar com uma mensagem de espera ................................................................ 45
4.9 Exercício: Programar mensagens de espera ............................................................. 46
4.10 Trabalhar com diálogos ............................................................................................. 47
4.11 Exercício: Programar diálogo ..................................................................................... 50
5 Programação de Interrupt ........................................................................... 51
5.1 Programação de rotinas de Interrupt ......................................................................... 51
5.2 Exercício: Trabalhar com Interrupts ........................................................................... 60
5.3 Exercício: Cancelar movimentos de deslocamento com Interrupts ........................... 62
6 Programar a estratégia de retrocesso ....................................................... 65
6.1 Programar estratégias de retrocesso ......................................................................... 65
6.2 Exercício: Programar a estratégia de retrocesso ....................................................... 66
7 Trabalhar com sinais analógicos ............................................................... 69
7.1 Programar entradas analógicas ................................................................................. 69
7.2 Programar saídas analógicas .................................................................................... 71
7.3 Exercício: Trabalhando com E/Ss analógicas ........................................................... 74
8 Execução e configuração de Automático externo ................................... 77
8.1 Configurar e usar Automático externo ....................................................................... 77
8.2 Exercício: Automático externo ................................................................................... 85
9 Programar a detecção de colisão .............................................................. 87
9.1 Programar movimentos com detecção de colisões ................................................... 87
Índice ............................................................................................................ 93
3 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
4 / 95
Programação do robô 3
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
1 Programação estruturada
1 Programação estruturada
1.1 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.2 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 
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áriossã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
5 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
6 / 95
Programação do robô 3
 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. 
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()
;Este programa busca o cubo do magazine
;Autor: Max Mustermann
;Data de criação: 09.08.2011
INI
...
END
DEF PALLETIZE()
;*****************************************************
;*Este programa paletiza 16 cubos sobre a mesa*
;*Autor: Max Mustermann------------------------------*
;*Data de criação: 09.08.2011-----------------------*
;*****************************************************
INI
...
;------------Cálculo das posições----------------
...
;------------Paletização de 16 cubos---------------
...
;----------Despaletização de 16 cubos---------------
...
END
DEF PICK_CUBE()
INI
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
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
1 Programação estruturada
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. 
Inicialmente as pastas em geral são exibidas fechadas após a sua criação.
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
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
7 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
8 / 95
Programação do robô 3
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
 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 
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: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
1 Programação estruturada
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
1.3 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.
DEF MAIN()
INI
LOOP
 GET_PEN()
 PAINT_PATH()
 PEN_BACK()
 GET_PLATE()
 GLUE_PLATE()
 PLATE_BACK()
 IF $IN[1]== TRUE THENEXIT
 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 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
10 / 95
Programação do robô 3
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
Acesso ao subprograma
Instrução de entrada/saída
Fig. 1-1
Fig. 1-2
Fig. 1-3
Fig. 1-4
Fig. 1-5
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
1 Programação estruturada
Exemplo PAP
Como é 
elaborado um 
PAP
Partindo da ideia do usuário o problema é detalhado passo a passo, até que 
os componentes elaborados sejam suficientemente visualizáveis, para poder 
realizá-los no KRL.
As minutas geradas nos passos subsequentes de desenvolvimento se destin-
guem pela crescente profundidade de detalhes.
1. Desmembramento grosseiro de todo o processo em aprox. 1 - 2 páginas
2. Divisão da tarefa total em diversas tarefas parciais
3. Classificação geral das tarefas parciais
4. Detalhamento da classificação das tarefas parciais
5. Transposição em código KRL
Fig. 1-6
Fig. 1-7
11 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
12 / 95
Programação do robô 3
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
2 Interpretador Submit
2 Interpretador Submit
2.1 Status do Interpretador Submit
Descrição do 
Interpretador 
Submit
No KSS 8.x rodam duas Tasks
 Interpretador de robô (execução dos programas de movimento do robô e 
sua lógica)
 Interpretador de comando (execução de um programa de controle parale-
lo)
Estrutura do programa SPS.SUB:
O estado do Interpretador Submit
O interpretador de comando
 pode ser iniciado automática ou manualmente
 também pode ser parado ou desselecionado manualmente
 pode assumir funções de operação e de comando no ambiente do robô
 como padrão está criado com o nome SPS.sub no diretório R1/SYSTEM
 pode ser programado com o conjunto de comandos KRL
 não pode processar nenhum comando KRL, que esteja relacionado com 
movimentos de robô
 permite movimentos assíncronos de eixos adicionais
 pode acessar variáveis de sistema lendo e gravando 
 pode acessar entradas/saídas lendo e gravando 
Correlações na 
programação do 
Interpretador 
Submit
 1 DEF SPS ( )
 2 DECLARATIONS
 3 INI
 4 
 5 LOOP
 6 WAIT FOR NOT($POWER_FAIL)
 7 TORQUE_MONITORING()
 8 
 9 USER PLC
 10 ENDLOOP
O Interpretador Submit 
está em execução
Interpretador Submit 
parado
Interpretador Submit 
desselecionado
Atenção!
O Interpretador Submit não pode ser usado para aplica-
ções críticas de tempo! Para estes casos é necessário usar um PLC. Moti-
vos:
 O Interpretador Submit divide a capacidade do sistema com o Interpre-
tador de robô e a gestão de IO, que têm prioridades maiores. Por isto, o 
Interpretador Submit não operará regularmente no ciclo de interpolação 
da unidade de comando do robô de 12ms. 
 Além disso, o tempo de execução do Interpretador Submit é inconstante. 
O tempo de execução do Interpretador Submit é influenciado pelo núme-
ro das linhas no SUB-programa. Também as linhas de comentário e va-
zias exercem um efeito.
13 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
14 / 95
Programação do robô 3
 Início automático do Interpretador Submit
 O interpretador Submit é iniciado automaticamente quando a unidade 
de comando do robô é ligada após uma partida a frio.
 É iniciado o programa, que está definido no arquivo KRC/STEU/
MADA/$custom.dat.
 Operação manual do Interpretador Submit
 selecionar a operação através da sequência de menu Configuração 
> Interpretador SUBMIT > Iniciar/Selecionar.
 Operação direta através da barra de status da exibição de status In-
terpretador Submit. Ao ser selecionado, abre-se uma janela com as 
opções executáveis.
Particularidades na programação do Interpretador Submit
 Não é possível executar nenhuma instrução para movimentos do robô 
como 
 PTP, LIN, CIRC etc.
 acessos de subprogramas, que contêm movimentos de robô
 Instruções, que se referem a movimentos do robô, TRIGGER ou BRA-
KE.
 Podem ser controlados eixos assíncronos, como E1.
 Instruções entre a linha LOOP e ENDLOOP são processadas continuamen-
te em "segundo plano".
 Qualquer parada através de comandos de espera ou loops de espera 
deve ser impedida, uma vez que isto retarda adicionalmente o processa-
mento do Interpretador Submit.
 É possível uma comutação de saídas.
$PRO_I_O[]="/R1/SPS()"
Quando um arquivo de sistema, p.ex. $config.dat ou $custom.dat, é 
modificado, e ocorre um erro através disto, o Interpretador Submit é 
desselecionado automaticamente. Se o erro estiver solucionado no 
arquivo de sistema, o Interpretador Submit deve ser novamente selecionado 
manualmente.
IF (($IN[12] == TRUE) AND ( NOT $IN[13] == TRUE)) THEN
ASYPTP {E1 45}
ENDIF
...
IF ((NOT $IN[12] == TRUE) AND ($IN[13] == TRUE)) THEN
ASYPTP {E1 0}
ENDIF
Aviso!
Não é verificado, se o Interpretador do robô ou o Inter-
pretador Submit acessam simultaneamente a mesma saída, uma vez que 
isto pode ser desejado em determinados casos.
Por isso, a atribuição das saídas deve ser cuidadosamente verificada pelo 
usuário. Caso contrário, podem ocorrer sinais de saída inesperados, p.ex., 
em dispositivos de segurança. Pode ocorrer morte, lesões corporais graves 
ou danos materiais significativos.
Nos modos de teste o $OV_PRO não pode ser escrito a 
partir do Interpretador Submit, porque a alteração pode 
ser inesperada para usuários que trabalham no robô industrial. As conse-
quências podem ser morte, lesões graves e danos materiais significativos.
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
2 Interpretador Submit
Procedimento na 
programação do 
Interpretador 
Submit
1. A programação ocorre no estado parado ou desselecionado.
2. O programa padrão SPS.sub é carregado no editor.
3. Executar declarações necessárias e a inicialização. Aqui devem ser admi-
nistradas as pastas preparadas.
4. Executar as expansões de programa na pasta USER PLC.
5. Fechar e salvar o Interpretador Submit.
6. Caso o Submit não inicie automaticamente, iniciar manualmente.
Exemplo de programa com base em uma programação de sinalizador inter-
mitente no Interpretador Submit
Aviso!
Não processar sinais relevantes de segurança, sinais 
críticos de tempo e variáveis através do Interpretador Submit.
DEF SPS( )
DECLARATIONS
DECL BOOL flash ;Declaração no $CONFIG.dat
INI
flash = FALSE
$TIMER[32]=0 ; Resetar TIMER[32]
$TIMER_STOP[32]=false ; Iniciar TIMER[32]
...
LOOP
...
USER PLC
IF ($TIMER[32]>500) AND (flash==FALSE) THEN
 flash=TRUE
ENDIF
IF $TIMER[32]>1000 THEN
 flash=FALSE
 $TIMER[32]=0
ENDIF
; Atribuir a uma lâmpada (saída 99)
$OUT[99] = flash
...
ENDLOOP
15 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
16 / 95
Programação do robô 3
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
3 Espaços de trabalho com KRL
3 Espaços de trabalho com KRL
3.1 Usar espaços de trabalho
Descrição Espaços de trabalho "seguros para pessoas" e "não segurospara pessoas"
 Espaços de trabalho seguros para pessoas servem para a proteção pes-
soal e somente podem ser instalados com a opção adicional SafeOpera-
tion.
 Com o software de sistema 8.x da KUKA podem ser configurados espa-
ços de trabalho para o robô. Estes servem somente para a proteção do 
equipamento.
Espaços de trabalho/proteção de equipamentos "não seguros para pessoas"
 Estes espaços de trabalho apropriados apenas para a proteção de máqui-
nas são configurados diretamente no software de sistema KUKA.
 Podem ser criados 8 espaços de trabalho específicos dos eixos.
 Com os espaços de trabalho expecíficos dos eixos é possível limitar ainda 
mais as áreas definidas pelos interruptores de fim de curso de software, a 
fim de proteger o robô ou a ferramenta ou a peça.
 Podem ser criados 8 espaços de trabalho cartesianos.
Fig. 3-1: Exemplo de espaços de trabalho expecíficos dos eixos para A1
17 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
18 / 95
Programação do robô 3
 Nos espaços de trabalho cartesianos somente a posição do TCP é moni-
torada. Não pode ser supervisionado se outras partes do robô violam o 
espaço de trabalho.
 Para formar formas complexas é possível ativar vários espaços de traba-
lho e estes podem se sobrepor.
 Espaços não permitidos: O robô só pode se mover fora de um espaço 
de trabalho destes.
Fig. 3-2: Exemplo de espaço de trabalho cartesiano
Fig. 3-3: Espaços não permitidos
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
3 Espaços de trabalho com KRL
 Espaços admissíveis: O robô não pode se mover fora de um espaço de 
trabalho destes.
 Quais são as reações que ocorrem, quando um robô viola um espaço de 
trabalho, depende da configuração.
 Por espaço de trabalho pode ser emitida uma saída (sinal).
Princípio de 
bloqueio de 
espaço de 
trabalho e 
espaços de 
trabalho
Bloqueio de espaço de trabalho
 Execução em acoplamento direto (sem PLC).
 Execução com um PLC. Este somente pode encaminhar os sinais ou usa 
adicionalmente uma lógica.
Fig. 3-4: Espaços admissíveis
Fig. 3-6
19 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
20 / 95
Programação do robô 3
 Encaminhamento direto de sinais (em caso de uso de um PLC: sem lógi-
ca)
 Sem tempo de espera: É feita uma solicitação de entrada e, se o es-
paço não estiver bloqueado, o robô pode entrar imediatamente no es-
paço. 
 Com tempo de monitoramento: É feita uma solicitação de entrada e 
o próprio espaço é bloqueado. Após um tempo de monitoramento pri-
meiramente é verificado o novo espaço. Caso o espaço não esteja 
bloqueado, o robô pode entrar imediatamente no espaço. Se as duas 
solicitações chegarem praticamente ao mesmo tempo, os espaços 
serão bloqueados.
 Encaminhamento de sinal com comando lógico (prioridade)
 Os requisitos de entrada, assim como a liberação de entrada, são in-
tegrados entre si através da lógica. O comando de prioridades regu-
lamenta também em solicitação de entrada simultânea, qual robô 
pode entrar na área de trabalho comum. 
 Adicionalmente ao comando de prioridades ainda pode ser verificado 
para a liberação de entrada, se o robô se encontra na área de trabalho 
(TCP de robô). Para isto devem ser definidos espaços de trabalho.
Princípio da 
configuração do 
espaço de 
trabalho
Modo para espaços de trabalho
 #OFF
O monitoramento do espaço de trabalho está desligado.
 #INSIDE
 Espaço de trabalho cartesiano: A saída definida é setada quando o 
TCP ou o sistema de coordenadas do flange se encontra dentro do es-
paço de trabalho.
 Espaço de trabalho específico do eixo: A saída definida é ativada 
quando o eixo encontra-se dentro do espaço de trabalho.
 #OUTSIDE
 Espaço de trabalho cartesiano: A saída definida é setada quando o 
TCP ou o sistema de coordenadas do flange se encontra fora do es-
paço de trabalho.
Fig. 3-10
Em caso de solicitação de entrada simultânea, contudo, 
os dois robôs recebem a permissão. Normalmente isto 
resulta em um crash.
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
3 Espaços de trabalho com KRL
 Espaço de trabalho específico do eixo: A saída definida é ativada 
quando o eixo encontra-se fora do espaço de trabalho.
 #INSIDE_STOP
 Espaço de trabalho cartesiano: A saída definida é setada quando o 
TCP, o sistema de coordenadas do flange ou ponto raiz da mão se en-
contra dentro do espaço de trabalho. (Ponto raiz da mão = ponto cen-
tral A4/A5/A6)
 Espaço de trabalho específico do eixo: A saída definida é ativada 
quando o eixo encontra-se dentro do espaço de trabalho.
Além disso, o robô é parado e são exibidas mensagens. O robô só pode 
ser movido novamente, se o monitoramento do espaço de trabalho foi 
desligado ou curto-circuitado.
 #OUTSIDE_STOP
 Espaço de trabalho cartesiano: A saída definida é setada quando o 
TCP ou o sistema de coordenadas do flange se encontra fora do es-
paço de trabalho.
 Espaço de trabalho específico do eixo: A saída definida é ativada 
quando o eixo encontra-se fora do espaço de trabalho.
Além disso, o robô é parado e são exibidas mensagens. O robô só pode 
ser movido novamente, se o monitoramento do espaço de trabalho foi 
desligado ou curto-circuitado.
Os seguintes parâmetros definem a posição e o tamanho do espaço de 
trabalho cartesiano:
 Origem do espaço de trabalho em relação ao sistema de coordenadas 
WORLD
 Dimensões do espaço de trabalho, a partir da origem
Fig. 3-13: Espaço de trabalho cartesiano, origem U
21 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
22 / 95
Programação do robô 3
Procedimento na 
configuração e 
uso de espaços 
de trabalho
Configurar espaços de trabalho específicos dos eixos
1. No menu principal, selecionar Configuração > Extras > Monitoramento 
do espaço de trabalho > Configuração.
A janela Espaços de trabalho cartesianos abre-se.
2. Pressionar Espec. do eixo, e mudar para a janela Espaços de trabalho 
específicos dos eixos.
3. Introduzir os valores e pressionar Salvar.
Fig. 3-14: Espaço de trabalho cartesiano, dimensões
Fig. 3-15: Exemplo de espaços de trabalho expecíficos dos eixos para 
A1
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
3 Espaços de trabalho com KRL
4. Pressionar Sinal. A janela Sinais abre-se.
Fig. 3-16: Exemplo de espaço de trabalho específico de eixo
Fig. 3-17: Sinais de espaço de trabalho
Pos. Descrição
1 Saídas para o monitoramento dos espaços de trabalho cartesia-
nos
2 Saídas para o monitoramento dos espaços de trabalho específi-
cos dos eixos
23 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
24 / 95
Programação do robô 3
Quando não deve ser ativada uma saída em caso de violação do espaço 
de trabalho, deve ser inserido FALSE.
5. No grupo Específico do eixo: Junto ao número do espaço de trabalho, 
inserir a saída que deve ser ativada em caso de violação do espaço de 
trabalho.
6. Pressionar Salvar.
7. Fechar a janela.
Configurar espaços de trabalho cartesianos
1. No menu principal, selecionar Configuração > Extras > Monitoramento 
do espaço de trabalho > Configuração.
A janela Espaços de trabalho cartesianos abre-se.
2. Introduzir os valores e pressionar Salvar.
3. Pressionar Sinal. A janela Sinais abre-se.
4. No grupo Cartesiano: Junto ao número do espaço de trabalho, inserir a 
saída que deve ser ativada em caso de violação do espaço de trabalho.
5. Pressionar Salvar.
6. Fechar a janela.
Exemplos de espaços de trabalho cartesianos
 Se o ponto "P2" se situar na origem do espaço de trabalho, é necessário 
apenas determinar as coordenadas de "P1".
Fig. 3-18: Exemplo de espaço de trabalho cartesiano (P2 está na origem)
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
3 Espaços de trabalho com KRL
 Neste exemplo o espaço de trabalho possui as dimensões x = 300mm, y 
= 250mm e z= 450mm. Em relação ao sistema de coordenadasmundial, 
ele está girado em 30 graus no eixo Y. A origem "U" não se encontra no 
centro do retângulo.
Fig. 3-19: Exemplo de configuração de espaço de trabalho cartesiano 
(P2 está na origem) 
Fig. 3-20: Exemplo de espaço de trabalho cartesiano (girado)
25 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
26 / 95
Programação do robô 3
Trabalhar com espaços de trabalho
 Espaços de trabalho específicos dos eixos (R1\Mada\$machine.dat)
 Espaços de trabalho cartesianos (STEU\Mada\$custom.dat)
 Sinais dos espaços de trabalho (STEU\Mada\$machine.dat)
 Ligar/desligar o espaço de trabalho com KRL
Fig. 3-21: Exemplo de configuração de espaço de trabalho cartesiano 
(girado)
DEFDAT $MACHINE PUBLIC
...
$AXWORKSPACE[1]={A1_N 0.0,A1_P 0.0,A2_N 0.0,A2_P 0.0,A3_N 0.0,A3_P 
0.0,A4_N 0.0,A4_P 0.0,A5_N 0.0,A5_P 0.0,A6_N 0.0,A6_P 0.0,E1_N 
0.0,E1_P 0.0,E2_N 0.0,E2_P 0.0,E3_N 0.0,E3_P 0.0,E4_N 0.0,E4_P 
0.0,E5_N 0.0,E5_P 0.0,E6_N 0.0,E6_P 0.0,MODE #OFF} 
$AXWORKSPACE[2]={A1_N 45.0,A1_P 160.0,A2_N 0.0,A2_P 0.0,A3_N 
0.0,A3_P 0.0,A4_N 0.0,A4_P 0.0,A5_N 0.0,A5_P 0.0,A6_N 0.0,A6_P 
0.0,E1_N 0.0,E1_P 0.0,E2_N 0.0,E2_P 0.0,E3_N 0.0,E3_P 0.0,E4_N 
0.0,E4_P 0.0,E5_N 0.0,E5_P 0.0,E6_N 0.0,E6_P 0.0,MODE #INSIDE_STOP}
DEFDAT $CUSTOM PUBLIC
...
$WORKSPACE[1]={X 400.0,Y -100.0,Z 1200.0,A 0.0,B 30.0,C 0.0,X1 
250.0,Y1 150.0,Z1 200.0,X2 -50.0,Y2 -100.0,Z2 -250.0,MODE #OUTSIDE} 
$WORKSPACE[2]={X 0.0,Y 0.0,Z 0.0,A 0.0,B 0.0,C 0.0,X1 0.0,Y1 0.0,Z1 
0.0,X2 0.0,Y2 0.0,Z2 0.0,MODE #OFF}
DEFDAT $MACHINE PUBLIC
...
SIGNAL $WORKSTATE1 $OUT[912] 
SIGNAL $WORKSTATE2 $OUT[915] 
SIGNAL $WORKSTATE3 $OUT[921] 
SIGNAL $WORKSTATE4 FALSE
...
SIGNAL $AXWORKSTATE1 $OUT[712]
SIGNAL $AXWORKSTATE2 $OUT[713]
SIGNAL $AXWORKSTATE3 FALSE
DEF myprog( )
...
$WORKSPACE[3].MODE = #INSIDE
...
$WORKSPACE[3].MODE = #OFF
...
$AXWORKSPACE[1].MODE = #OUTSIDE_STOP
...
$AXWORKSPACE[1].MODE = #OFF
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
3 Espaços de trabalho com KRL
3.2 Exercício: Monitoramento do espaço de trabalho
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você estará em condições de 
executar as seguintes atividades:
 Configuração de espaços de trabalho 
 Utilização dos diferentes modos em espaços de trabalho 
 Curto-circuitamento do monitoramento do espaço de trabalho
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 monitoramento do espaço de trabalho
Definição de 
funções
Tarefa parcial 1
1. Configure o espaço de trabalho 1 como dado com o comprimento de ares-
ta de 400 mm. 
2. Transmita um sinal ao entrar na área. Use para isto a saída 14. 
3. Configure o espaço de trabalho 2 como dado com o comprimento de ares-
ta de 400 mm. 
4. Transmita um sinal ao sair da área. Use para isto a saída 15. 
5. Teste os dois espaços de trabalho e compare as informações com as exi-
bições no painel de operação. 
Tarefa parcial 2
1. Configure o espaço de trabalho 3 como bloco com o comprimento de 
aresta de 400 mm e 200 mm. 
2. Bloqueie a entrada neste espaço de trabalho e transmita um sinal. Use 
para isto a saída 16. 
3. Teste este espaço de trabalho e compare as informações com as exibi-
ções no painel de operação. 
4. Para sair deste espaço de trabalho, curto-circuite o mesmo com o item de 
menu previsto para isto.
O que você deve saber agora:
1. Quantos espaços de trabalho podem ser configurados no máximo? 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
Fig. 3-22
Fig. 3-23
27 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
28 / 95
Programação do robô 3
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2. Quais possibilidades de ajuste para o MODO você tem na configuração do 
espaço de trabalho?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3. A qual sistema de coordenadas se refere a ORIGEM na configuração de 
espaço de trabalho cartesiana?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4. Quais vantagens oferece um bloqueio de robô, que foi realizado através de 
acoplamento direto de E/S e tempo de monitoramento?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5. Quais desvantagens ocorrem no caso acima (pergunta 4), quando é traba-
lhado sem tempo de monitoramento?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
4 Programação de mensagens com KRL
4 Programação de mensagens com KRL
4.1 Generalidades sobre mensagens definidas pelo usuário
Descrição de 
mensagens 
definidas pelo 
usuário
Propriedades da programação de mensagens
 Com KRL o programador pode programas mensagens próprias.
 É possível emitir várias mensagens simultaneamente.
 Mensagens emitidas encontram-se em um buffer de mensagens, até que 
sejam novamente excluídas.
 As mensagens de informação não são administradas no buffer de mensa-
gens. (Princípio "fire and forget").
 Mensagens podem ser testadas e excluídas de forma simples, já as men-
sagens de informação não. 
 Em cada mensagem podem ser integrados até 3 parâmetros.
Na janela de mensagens da KUKA.HMI é exibido um ícone para cada men-
sagem. Os ícones estão atribuídos fixamente aos tipos de mensagem e não 
podem ser alterados pelo programador.
Podem ser programados os seguintes tipos de mensagem:
A emissão, o cancelamento ou o teste de mensagens ocorre através de fun-
ções KUKA pré-realizadas. Para isto são necessárias diversas variáveis.
Funções para a programação de mensagens
 Emitir mensagem
 Verificar mensagem
 Excluir mensagem
 Emitir diálogo
 Verificar diálogo
Variáveis complexas para a programação de mensagens
 Estrutura para emissor, número da mensagem, texto de mensagem
 Estrutura como dummy para 3 possíveis parâmetros
 Estrutura para o comportamento geral de mensagens
 Estrutura para a inscrição dos botões em mensagens de diálogo
Ícone Tipo
Mensagem de confirmação
Mensagem de estado
Mensagem de informação
Mensagem de espera
Mensagem de diálogo (é exibida em uma janela POP-UP 
própria)
Nenhuma reação especificada do sistema de robô está ligada com os 
diferentes tipos de mensagens (p.ex. o robô freia ou o programa é 
parado). As reações desejadas devem ser programadas.
29 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
30 / 95
Programação do robô 3
Princípio da 
programação de 
mensagens 
definida pelo 
usuário: 
Variáveis/Estru-
turas
Estrutura para emitente, número da mensagem, texto de mensagem
 estrutura KUKA predefinida: KrlMsg_T

 Emitente: Modul[ ]"College"
 máximo 24 caracteres
 O texto do emitente é colocado pelo sistema na exibição entre "< >"
 Número da mensagem: N° 1906
 número inteiro de livre escolha
 números selecionados em duplicidade não são detectados
 Texto de mensagem: Msg_txt[ ] "My first Message"
 máximo 80 caracteres
 O texto é exibido na segunda linha da mensagem
Ao enviar uma mensagem é necessário escolher o tipo de mensagem:
 Tipo de dados de contagemEKrlMsgType
 #Quit: Emite esta mensagem como mensagem de confirmação
 #STATE: Emite esta mensagem como mensagem de estado
 #NOTIFY: Emite esta mensagem como mensagem de informação
 #WAITING: Emite esta mensagem como mensagem de espera
Em um texto de mensagem deve ser exibido o valor de uma variável. Por 
exemplo, deve ser exibida a quantidade atual. Para isto são necessários dum-
mies no texto de mensagem. A quantidade máxima de dummies é 3. A exibi-
ção é %1, %2 e %3.
Por este motivo são necessários 3 conjuntos de parâmetros. Cada conjunto 
de parâmetros consiste na estrutura KUKA KrlMsgPar_T:
Fig. 4-1: Mensagem de informação
STRUC KrlMsg_T CHAR Modul[24], INT Nr, CHAR Msg_txt[80]
DECL KrlMsg_T mymessage
mymessage = {Modul[ ] "College", Nr 1906, Msg_txt[ ] "My first 
Message"}
ENUM EKrlMsgType Notify, State, Quit, Waiting
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
4 Programação de mensagens com KRL
Uso dos respectivos agregados
 Par_Type: Tipo do parâmetro/dummy 
 #VALUE: O parâmetro é inserido diretamente no texto de mensagem 
na forma entregue (portanto, como string, valor INT, REAL ou BOOL)
 #KEY: O parâmetro é uma palavra-chave, pela qual deve ser procura-
do no banco de dados de mensagens, para carregar o texto corres-
pondente
 #EMPTY: O parâmetro está vazio.
 Par_txt[26]: Texto ou palavra-chave para o parâmetro
 Par_Int: Transmissão de um valor inteiro como parâmetro
 Par_Real: Transmissão de um valor real como parâmetro
 Par_Bool: Transmissão de um valor booleano como parâmetro, o texto 
de exibição é TRUE ou FALSE
Exemplos de programa para a transmissão direta de parâmetros nos dum-
mies:
O texto de mensagem é Msg_txt[ ] "Falha no %1"
Emissão de mensagem: Defeito no Finisher
Exemplos de programa para a transmissão com separador de ponto de parâ-
metros nos dummies:
O texto de mensagem é Msg_txt[ ] "Faltam %1 componentes"
Emissão de mensagem: Faltam 13 componentes
Enum KrlMsgParType_T Value, Key, Empty
STRUC KrlMsgPar_T KrlMsgParType_T Par_Type, CHAR Par_txt[26], INT 
Par_Int, REAL Par_Real, BOOL Par_Bool
DECL KrlMsgPar_T Parameter[3] ; Criar 3 conjuntos de parâmetros
...
Parameter[1] = {Par_Type #VALUE, Par_txt[ ] "Finisher"}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
...
Uma vez que os parâmetros raramente são escritos através de uma 
introdução constante, os respectivos agregados são transmitidos 
com o separador de ponto.
DECL KrlMsgPar_T Parameter[3] ; Criar 3 conjuntos de parâmetros
DECL INT missing_part
...
misssing_part = 13
...
Parameter[1] = {Par_Type #VALUE}
Parameter[1].Par_Int = missing_part
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
...
31 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
32 / 95
Programação do robô 3
Estrutura para a ocupação de botões em diálogos:
 estrutura KUKA predefinida: KrlMsgDlgSK_T
 Sk_Type: Tipo de inscrição em superfície
 #VALUE: O parâmetro é inserido diretamente no texto de mensagem 
na forma entregue. 
 #KEY: O parâmetro é uma palavra-chave, pela qual deve ser procura-
do no banco de dados de mensagens, para carregar o texto corres-
pondente.
 #EMPTY: O botão não está ocupado
 Sk_txt[ ]: Texto ou palavra-chave para o botão
Exemplo de programa para a inscrição de 7 botões de um diálogo:
Na emissão de uma mensagem ou diálogo, são transmitidas mais 4 opções 
de mensagens. Com estas opções podem ser influenciados o avanço, exclu-
são de mensagens e o banco de dados log.
Estrutura para opções gerais de mensagens:
 estrutura KUKA predefinida: KrlMsgOpt_T
 VL_Stop: TRUE aciona uma parada de avanço
 Padrão: TRUE
Fig. 4-2: Diálogo
Enum KrlMsgParType_T Value, Key, Empty
Struc KrlMsgDlgSK_T KrlMsgParType_T Sk_Type, Char SK_txt[10]
DECL KRLMSGDLGSK_T Softkey[7] ; Preparar 7 possíveis softkeys
...
softkey[1]={sk_type #value, sk_txt[] "key1"}
softkey[2]={sk_type #value, sk_txt[] "key2"}
softkey[3]={sk_type #value, sk_txt[] "key3"}
softkey[4]={sk_type #value, sk_txt[] "key4"}
softkey[5]={sk_type #value, sk_txt[] "key5"}
softkey[6]={sk_type #value, sk_txt[] "key6"}
softkey[7]={sk_type #value, sk_txt[] "key7"}
...
Podem ser atribuídos, no máximo, 10 caracteres por botão. De acor-
do com os caracteres utilizados surgem botões de diferentes largu-
ras.
STRUC KrlMsgOpt_T BOOL VL_Stop, BOOL Clear_P_Reset, BOOL 
Clear_SAW, BOOL Log_To_DB
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
4 Programação de mensagens com KRL
 Clear_P_Reset : TRUE exclui todas as mensagens de estado, de con-
firmação e de espera, quando o programa é resetado ou desselecionado
 Padrão: TRUE
 Clear_P_SAW: TRUE exclui todas as mensagens de estado, de confirma-
ção e de espera, quando uma seleção de passo for realizada através da 
barra de comutação de seleção de passo.
 Padrão: FALSE
 Log_To_DB: TRUE faz com que esta mensagem seja logada no banco de 
dados log.
 Padrão: FALSE
Princípio da 
programação de 
mensagens 
definida pelo 
usuário: Funções
Setar, testar e excluir uma mensagem
 Setar ou emitir uma mensagem
Com esta função é emitida uma mensagem no programa KRL. Isto signi-
fica, que a respectiva mensagem é inserida em um buffer de mensagens 
interno. Exceção são mensagens de informação, que não são adminis-
tradas no buffer de mensagens.
 Funções build-in para a emissão de uma mensagem
 Tipo: Tipo da mensagem (#Notify, #State, #Quit, #Waiting)
 MyMessage: Informações gerais de mensagem (emissor, número da 
mensagem, texto de mensagem)
 Parâmetro[ ]: os 3 parâmetros possíveis para os dummies %1, %2 
e %3 (também devem ser transmitidos, caso não sejam usados)
 Opção: opções de mensagem gerais (parada de avanço, logar no 
banco de dados de mensagens, excluir implicitamente mensagem no 
reset de programa ou na seleção de passo) 
 Valor de retorno da função: é designado como "handle" (número de 
ticket). Com esse handle é possível verificar se a mensagem foi emi-
tida com êxito. Além disso, o handle também é o número de identifi-
cação no buffer de mensagens. Assim é possível verificar ou excluir 
uma determinada mensagem.
 handle == -1: A mensagem não pôde ser emitida (p. ex. porque 
o buffer de mensagens está lotado).
 handle > 0: A mensagem foi emitida com sucesso e é adminis-
trada com o respectivo número de identificação no buffer de men-
sagens.
As mensagens de observação podem ser excluídas somente através 
das barras de comutação OK ou Todos OK. Para mensagens de di-
álogo sempre vale: Clear_P_Reset=TRUE.
DEFFCT INT Set_KrlMsg(Type:IN, MyMessage:OUT, Parameter[ ]:OUT, 
Option:OUT)
DECL EKrlMsgType Type
DECL KrlMsg_T MyMessage
DECL KrlMsgPar_T Parameter[ ]
DECL KrlMsgOpt_T Option
DEF MyProg( )
DECL INT handle
...
handle = Set_KrlMsg(Type, MyMessage, Parameter[ ], Option)
33 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
34 / 95
Programação do robô 3
 Verificar uma mensagem
Com esta função pode ser verificado, se uma determinada mensagem 
com um determinado handle ainda existe. Portanto, é verificado se esta 
mensagem ainda se encontra no buffer de mensagens interno.
 Funções build-in para a verificação de uma mensagem
 nHandle: O handle disponibilizado pela função "Set_KrlMsg(…)" 
para a mensagem
 Valor de retorno da função:
 present == TRUE: Esta mensagem ainda existe no buffer de 
mensagens
 present == FALSE: Esta mensagem não se encontra mais no 
buffer de mensagens (portanto, foi confirmada ou excluída)
 Exclusão de uma mensagem
Com esta função pode ser excluída uma mensagem. Isto significa que a 
respectiva mensagem é excluída no buffer de mensagens interno.
 Funções build-in para a verificação de uma mensagem
 nHandle: O handle disponibilizado pela função "Set_KrlMsg(…)" 
para a mensagem
 Valor de retorno da função:
 eraser == TRUE: Esta mensagem pôde ser excluída
 eraser == FALSE: Esta mensagem não pôde ser excluída
As mensagens de informação são processadas segundoo princípio 
"fire e forget". Em mensagens de informação sempre é devolvido um 
handle = 0, caso a mensagem tenha sido emitida com sucesso. 
DEFFCT BOOL Exists_KrlMsg(nHandle:IN)
DECL INT nHandle
DEF MyProg( )
DECL INT handle
DECL BOOL present
...
handle = Set_KrlMsg(Type, MyMessage, Parameter[ ], Option)
...
present= Exists_KrlMsg(handle)
DEFFCT BOOL Clear_KrlMsg(nHandle:IN)
DECL INT nHandle
DEF MyProg( )
DECL INT handle
DECL BOOL erase
...
handle = Set_KrlMsg(Type, MyMessage, Parameter[ ], Option)
...
eraser = Clear_KrlMsg(handle)
Funções especiais para a exclusão com a função 
Clear_KrlMsg(handle):
Clear_KrlMsg(-1): todas as mensagens iniciadas com este pro-
cesso são excluídas.
Clear_KrlMsg(-99): todas as mensagens de usuário KRL são excluídas.
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
4 Programação de mensagens com KRL
Princípio da 
programação de 
diálogo definida 
pelo usuário: 
Funções
Setar e testar um diálogo
 Setar ou emitir um diálogo
Com a função Set_KrlDlg( ) é emitida uma mensagem de diálogo. Isto 
significa que a mensagem é transmitida ao buffer de mensagens e exibida 
em uma janela de mensagens com botões.
 Funções build-in para a emissão de um diálogo
 MyQuestion: Informações gerais de mensagem (emissor, número 
da mensagem, texto de mensagem)
 Parâmetro[ ]: os 3 parâmetros possíveis para os dummies %1, %2 
e %3 (também devem ser transmitidos, caso não sejam usados)
 Botão[ ]: a inscrição para os 7 botões possíveis (também devem 
ser transmitidos, caso não sejam usados)
 Opção: opções de mensagem gerais (parada de avanço, logar no 
banco de dados de mensagens, excluir implicitamente mensagem no 
reset de programa ou na seleção de passo) 
 Valor de retorno da função: handle para o diálogo. Com esse handle 
é possível verificar, se o diálogo foi emitido com êxito. Além disso, o 
handle também é o número de identificação no buffer de mensagens.
 handle == -1: Não foi possível emitir o diálogo (p.ex. porque 
um outro diálogo ainda está ativo e não foi respondido ou o buffer 
de mensagens está muito cheio)
 handle > 0: A mensagem foi emitida com sucesso e é adminis-
trada com o respectivo número de identificação no buffer de men-
sagens.
 Verificação de um diálogo
Com a função Exists_KrlDlg( ) pode ser verificado, se um determi-
nado diálogo ainda existe. Portanto, é verificado se este diálogo ainda se 
encontra no buffer de mensagens.
 Funções build-in para a verificação de uma mensagem
 nHandle: O handle disponibilizado pela função "Set_KrlDlg(…)" 
para o diálogo
 answer: Feedback de qual botão foi pressionado. O botão 1, que foi 
definido como "Botão[1]" devolve, portanto, o valor 1
DEFFCT Extfctp Int Set_KrlDlg (MyQuestion:OUT, Parameter[ ]:OUT, 
Button[ ]:OUT, Option:OUT)
DECL KrlMsg_T MyQuestion
DECL KrlMsgPar_T Parameter[ ]
DECL KrlMsgDlgSK_T Button[ ]
DECL KrlMsgOpt_T Option
DEF MyProg( )
DECL INT handle
...
handle = Set_KrlDlg(MyQuestion, Parameter[ ], Button[ ], Option)
Um diálogo sempre pode ser emitido somente depois que não houver 
mais nenhum outro diálogo.
A função simplesmente emite o diálogo. Ela não aguarda até que ele 
tenha sido respondido.
DEFFCT BOOL Exists_KrlDlg(INT nHandle:IN, INT Answer:OUT)
DECL INT nHandle, answer
35 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
36 / 95
Programação do robô 3
 Valor de retorno da função:
 present == TRUE: Este diálogo ainda existe no buffer de men-
sagens
 present == FALSE: Este diálogo não se encontra mais no buffer 
de mensagens (portanto, foi respondido)
4.2 Trabalhar com uma mensagem de informação
Descrição de uma 
mensagem de 
informação 
definida pelo 
usuário
 As mensagens de informação não são administradas no buffer de mensa-
gens.
 As mensagens de informação só podem ser novamente excluídas através 
das barras de comutação OK ou Todos OK.
Função de uma 
mensagem de 
informação 
definida pelo 
usuário
 Mensagens de informação são apropriadas, para exibir informações ge-
rais. 
 Uma mensagem de informação somente é criada. Eventualmente verifi-
ca-se, se a mensagem chegou com sucesso.
 Uma vez que as mensagens de informação não são administradas, po-
dem ser criadas aprox. 3 milhões de mensagens.
Programação de 
mensagens de 
observação 
definidas pelo 
usuário
1. Carregar um programa principal no editor
2. Declarar variáveis de trabalho para:
 remetente, número da mensagem, texto de mensagem (de 
KrlMsg_T)
 campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
3. Iniciar variáveis de trabalho com os valores desejados
A função não aguarda até que o diálogo esteja respondido, mas sim-
plesmente faz uma busca no buffer pelo diálogo com este handle. 
Portanto, a consulta no programa KRL deve ocorrer ciclicamente, até 
que o diálogo tenha sido respondido ou excluído de outra forma.
DEF MyProg( )
DECL INT handle, answer
DECL BOOL present
...
handle = Set_KrlDlg(MyQuestion, Parameter[ ], Button[ ], Option)
...
present = Exists_KrlDlg(handle, answer)
answer agora é devolvida com o valor do botão pressionado. Valo-
res válidos entre 1 e 7, dependendo dos números de botão progra-
mados.
Fig. 4-3: Mensagem de informação
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
4 Programação de mensagens com KRL
4. Programar o acesso de função Set_KrlMsg(…)
5. Se necessário, avaliar "handle", para determinar se a emissão teve êxito
6. Fechar e salvar o programa principal
Exemplo de programação para a exibição acima:
4.3 Exercício: Programar mensagem de informação
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você está em condições de exe-
cutar as seguintes atividades:
 Programar mensagens de informação próprias
 Emitir parâmetros quaisquer em mensagens
Requisitos Os seguintes requisitos são necessários para realizar o exercício com êxito.
 Conhecimentos da linguagem de programação KRL 
 Conhecimentos teóricos sobre a programação de mensagens 
Definição de 
tarefas
Tarefa parcial 1: Mensagem de informação
1. Crie uma mensagem de informação com o texto "Magazine quase vazio 
– reabastecer". 
2. Esta mensagem deve ser exibida através da entrada 13 no painel de ope-
ração. 
3. Teste o seu programa conforme a prescrição.
Tarefa parcial 2: Mensagem de informação com parâmetros
1. Crie uma mensagem de informação com o texto "Componente número 
xxx pronto". 
2. Através da entrada 16 no painel de operação esta mensagem deve ser 
exibida, o contador de peças para o componente aumentado e exibido na 
posição xxx. 
3. Teste o seu programa conforme a prescrição.
O que você deveria saber agora::
1. Como é excluída novamente uma mensagem de informação? 
Fig. 4-4: Mensagem de informação
DECL KRLMSG_T mymessage
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGOPT_T Option
DECL INT handle
...
mymessage={modul[] "College", Nr 1906, msg_txt[] "My first Message"}
Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, 
Log_to_DB TRUE} 
;Dummies estão vazios Dummy[1..3]
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
handle = Set_KrlMsg(#NOTIFY, mymessage, Parameter[ ], Option)
37 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
38 / 95
Programação do robô 3
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2. Qual parte integrante da estrutura de mensagens é responsável pelo "dis-
paro" do texto de mensagem?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Edição: 17.10.2012 Versão:P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
4 Programação de mensagens com KRL
4.4 Trabalhar com uma mensagem de estado
Descrição de uma 
mensagem de 
estado definida 
pelo usuário
 As mensagens de estado são administradas no buffer de mensagens.
 As mensagens de estado não podem ser excluídas novamente através da 
barra de comutação "Todas OK".
 Mensagens de estado devem ser excluídas com uma função no progra-
ma.
 As mensagens de estado também podem ser excluídas da mesma forma 
através dos ajustes nas opções de mensagens no reset do programa ou 
ao fechar o programa ou uma seleção de passo
Função de uma 
mensagem de 
estado definida 
pelo usuário
 As mensagens de estado são apropriadas para exibir a alteração de um 
estado (p.ex. a supressão de uma entrada).
 São administradas, no máximo, 100 mensagens no buffer de mensagens.
 O programa, por exemplo, é retido até que não exista mais o estado de-
sencadeador.
 A mensagem de estado é excluída novamente através da função 
Clear_KrlMsg( ).
Programação de 
mensagens de 
estado definidas 
pelo usuário
1. Carregar um programa principal no editor
2. Declarar variáveis de trabalho para:
 remetente, número da mensagem, texto de mensagem (de 
KrlMsg_T)
 campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
 variável para o resultado do teste (como BOOL)
 variável para o resultado da exclusão (como BOOL)
3. Iniciar variáveis de trabalho com os valores desejados
4. Programar o acesso de função Set_KrlMsg(…)
5. Parar o programa com um loop, até que o estado desencadeador deixe 
de existir
6. Excluir a mensagem de estado com o acesso de função Clear_KrlMsg( 
)
7. Fechar e salvar o programa principal
Fig. 4-5: Mensagem de estado
Nenhuma reação especificada do sistema de robô está ligada com os 
diferentes tipos de mensagens (p.ex. o robô freia ou o programa é 
parado). As reações desejadas devem ser programadas.
39 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
40 / 95
Programação do robô 3
Exemplo de programação para a exibição/mensagem acima:
4.5 Exercício: Programar mensagem de estado
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você está em condições de exe-
cutar as seguintes atividades:
 programar mensagens de estado próprias 
 emitir parâmetros quaisquer em mensagens 
Requisitos Os seguintes requisitos são necessários para realizar o exercício com êxito:
 Conhecimentos da linguagem de programação KRL 
 Conhecimentos teóricos sobre a programação de mensagens 
Definição de 
tarefas
Tarefa parcial 1: Mensagem de estado
1. Crie uma mensagem de status com o texto "Magazine quase vazio". 
2. Esta mensagem deve ser exibida através da entrada 14 no painel de ope-
ração. 
Fig. 4-6: Mensagem de estado
A mensagem de estado é gerada através do estado entrada 12 
(FALSE). O programa é parado após a emissão da mensagem. A 
mensagem é excluída através do estado entrada 17 (TRUE). Depois 
disto é dada continuidade no programa. 
Da mesma forma desaparece a mensagem ao dar um reset no programa ou 
ao fechar o programa. Isto ocorre através do ajuste nas opções de mensa-
gens Clear_P_Reset TRUE.
DECL KRLMSG_T mymessage
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGOPT_T Option
DECL INT handle
DECL BOOL present, eraser
...
IF $IN[12]==FALSE THEN
mymessage={modul[] "College", Nr 1909, msg_txt[] "My Messagetext"}
Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, 
Log_to_DB TRUE} 
;Dummies estão vazios Dummy[1..3]
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
handle = Set_KrlMsg(#STATE, mymessage, Parameter[ ], Option)
ENDIF
eraser=FALSE
;Loop para parar até que esta mensagem tenha sido excluída
REPEAT
IF $IN[12]==TRUE THEN
eraser=Clear_KrlMsg(handle) ;Excluir mensagem
ENDIF
present=Exists_KrlMsg(handle) ;controle adicional
UNTIL NOT(present) or eraser
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
4 Programação de mensagens com KRL
3. Através da remoção da entrada 14 no painel de operação a mensagem 
deve ser novamente excluída. 
4. Teste o seu programa conforme a prescrição. 
Tarefa parcial 2: Mensagem de estado com parâmetro
1. Crie uma mensagem de status com o texto "Ainda há xxx cubos de yyy no 
magazine". 
2. Esta mensagem deve ser exibida através da entrada 15 no painel de ope-
ração. 
3. Através da remoção da entrada 15 no painel de operação a mensagem 
deve ser novamente excluída. 
4. Teste o seu programa conforme a prescrição. 
O que você deveria saber agora:
1. O que significa %2 no texto de mensagem? 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
41 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
42 / 95
Programação do robô 3
4.6 Trabalhando com mensagem de confirmação
Descrição de uma 
mensagem de 
confirmação 
definida pelo 
usuário
 As mensagens de confirmação são administradas no buffer de mensa-
gens.
 As mensagens de confirmação podem ser novamente excluídas através 
das barras de comutação OK ou Todos OK.
 As mensagens de confirmação também podem ser excluídas através de 
uma função no programa.
 As mensagens de confirmação também podem ser excluídas da mesma 
forma através dos ajustes nas opções de mensagens no reset do progra-
ma ou ao fechar o programa ou uma seleção de passo.
Função de uma 
mensagem de 
confirmação 
definida pelo 
usuário
 As mensagens de confirmação são apropriadas para exibir informações, 
que o usuário precisar tomar conhecimento.
 São administradas, no máximo, 100 mensagens no buffer de mensagens.
 Na mensagem de confirmação (ao contrário da mensagem de informa-
ção) pode ser verificado, se o usuário a confirmou ou não.
 O programa será retido, por exemplo, até que a mensagem tenha sido 
confirmada.
Programação de 
mensagens de 
confirmação 
definidas pelo 
usuário
1. Carregar um programa principal no editor.
2. Declarar variáveis de trabalho para:
 remetente, número da mensagem, texto de mensagem (de 
KrlMsg_T)
 campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
 variável para o resultado do teste (como BOOL)
3. Iniciar variáveis de trabalho com os valores desejados.
4. Programar o acesso de função Set_KrlMsg(…).
5. Parar o programa com o loop.
6. Com o acesso de função Exists_KrlMsg(...), verificar se a mensa-
gem já foi confirmada pelo usuário. Se a mensagem já tiver sido confirma-
da, abandonar o loop superior. 
7. Fechar e salvar o programa principal.
Fig. 4-7: Mensagem de confirmação
Nenhuma reação especificada do sistema de robô está ligada com os 
diferentes tipos de mensagens (p.ex. o robô freia ou o programa é 
parado). As reações desejadas devem ser programadas.
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
4 Programação de mensagens com KRL
Exemplo de programação para a exibição/mensagem acima:
4.7 Exercício: Programar mensagens de confirmação
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você está em condições de exe-
cutar as seguintes atividades:
 Programar mensagens de confirmação próprias
 Emitir parâmetros quaisquer em mensagens
Requisitos Os seguintes requisitos são necessários para realizar o exercício com êxito:
 Conhecimentos da linguagem de programação KRL 
 Conhecimentos teóricos sobre a programação de mensagens 
Definição de 
tarefas
Tarefa parcial 1: Mensagem de confirmação
1. Crie uma mensagem de confirmação com o texto "Confirmar falha Vácuo 
não atingido". 
2. Esta mensagem deve ser exibida através da entrada 15 no painel de ope-
ração. 
3. Teste o seu programa conforme a prescrição.Tarefa parcial 2: Mensagem de estado com mensagem de confirmação
1. Crie uma mensagem de estado com o texto "Falha Vácuo não atingido". 
Fig. 4-8: Mensagem de confirmação
O programa é parado após a emissão da mensagem. A mensagem 
é excluída através do pressionamento do botão OK ou Todos OK. 
Depois disto é dada continuidade no programa. 
Da mesma forma desaparece a mensagem ao dar um reset no programa ou 
ao fechar o programa. Isto ocorre através do ajuste nas opções de mensa-
gens Clear_P_Reset TRUE.
DECL KRLMSG_T mymessage
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGOPT_T Option
DECL INT handle
DECL BOOL present
...
mymessage={modul[] "College", Nr 1909, msg_txt[] "My Messagetext"}
Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, 
Log_to_DB TRUE} 
;Dummies estão vazios Dummy[1..3]
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
handle = Set_KrlMsg(#QUIT, mymessage, Parameter[ ], Option)
;Loop para parar até que esta mensagem tenha sido excluída
REPEAT
present=Exists_KrlMsg(handle)
UNTIL NOT(present)
43 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
44 / 95
Programação do robô 3
2. Esta mensagem deve ser exibida através da entrada 13 no painel de ope-
ração. 
3. Após resetar a entrada, a mensagem de estado deve ser cancelada e 
deve ser exibida a sua mensagem de confirmação programada na tarefa 
parcial 1.
4. Teste o seu programa conforme a prescrição. 
O que você deveria saber agora:
1. Qual é o número máximo de mensagens de confirmação administradas no 
buffer de mensagens? 
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
4 Programação de mensagens com KRL
4.8 Trabalhar com uma mensagem de espera
Descrição de uma 
mensagem de 
espera definida 
pelo usuário
 As mensagens de espera são administradas no buffer de mensagens.
 As mensagens de espera podem ser excluídas novamente através da 
barra de comutação Simuliere.
 As mensagens de espera não podem ser excluídas novamente através 
da barra de comutação Todas OK.
 As mensagens de espera também podem ser excluídas da mesma forma 
através dos ajustes nas opções de mensagens no reset do programa ou 
ao fechar o programa ou uma seleção de passo.
Função de uma 
mensagem de 
espera definida 
pelo usuário
 Mensagens de espera são apropriadas para aguardar um estado e exibir 
nisto o símbolo de espera.
 São administradas, no máximo, 100 mensagens no buffer de mensagens. 
 o programa, por exemplo, é retido até que o seja obtido o estado pelo qual 
está se esperando.
 A mensagem de espera é excluída novamente através da função 
Clear_KrlMsg( ).
Programação de 
mensagens de 
espera definidas 
pelo usuário
1. Carregar um programa principal no editor.
2. Declarar variáveis de trabalho para:
 remetente, número da mensagem, texto de mensagem (de 
KrlMsg_T)
 campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
 variável para o resultado do teste (como BOOL)
 variável para o resultado da exclusão (como BOOL)
3. Iniciar variáveis de trabalho com os valores desejados.
4. Programar o acesso de função Set_KrlMsg(…).
5. Parar o programa com um loop, até que ocorra o estado pelo qual é es-
perado ou até que a mensagem seja excluída através do botão Simuliere.
6. Excluir a mensagem de espera com o acesso de função Clear_KrlMsg( 
).
7. Fechar e salvar o programa principal.
Exemplo de programação para a exibição/mensagem acima:
Fig. 4-9: Mensagem de espera
Fig. 4-10: Mensagem de espera
45 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
46 / 95
Programação do robô 3
4.9 Exercício: Programar mensagens de espera
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você está em condições de exe-
cutar as seguintes atividades:
 Programar mensagens de espera próprias
 Emitir parâmetros quaisquer em mensagens
Requisitos Os seguintes requisitos são necessários para realizar o exercício com êxito:
 Conhecimentos da linguagem de programação KRL 
 Conhecimentos teóricos sobre a programação de mensagens 
Definição de 
tarefas
1. Crie uma mensagem de espera com o texto "Esperando por entrada do 
operador" e ative a mesma através da entrada 12. 
2. Apague a mensagem de espera, resetando a entrada 12.
3. Teste o seu programa conforme a prescrição.
O que você deveria saber agora:
1. Qual é a diferença entre uma mensagem "STATE" e uma mensagem "WAI-
TING"? 
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 O programa é parado após a emissão da mensagem. A mensagem 
é excluída através do estado entrada 12 (TRUE). Depois disto é dada 
continuidade no programa. 
Da mesma forma desaparece a mensagem ao dar um reset no programa ou 
ao fechar o programa. Isto ocorre através do ajuste nas opções de mensa-
gens Clear_P_Reset TRUE.
DECL KRLMSG_T mymessage
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGOPT_T Option
DECL INT handle
DECL BOOL present, eraser
...
IF $IN[12]==FALSE THEN
mymessage={modul[] "College", Nr 1909, msg_txt[] "My Messagetext"}
Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, 
Log_to_DB TRUE} 
;Dummies estão vazios Dummy[1..3]
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
handle = Set_KrlMsg(#WAITING, mymessage, Parameter[ ], Option)
ENDIF
eraser=FALSE
;Loop para parar até que esta mensagem tenha sido excluída
REPEAT
IF $IN[12]==TRUE THEN
eraser=Clear_KrlMsg(handle) ;Meldung loeschen
ENDIF
present=Exists_KrlMsg(handle) ;kann über simuliere geloescht worden 
sein
UNTIL NOT(present) or eraser
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
4 Programação de mensagens com KRL
4.10 Trabalhar com diálogos
Descrição de um 
diálogo definido 
por usuário
 Um diálogo sempre pode ser emitido somente depois que não houver 
mais nenhum outro diálogo.
 Os diálogos podem ser excluídos através de uma softkey, cuja inscrição 
é definida pelo programador.
 Podem ser definidas até 7 softkeys.
Função de um 
diálogo definido 
pelo usuário
 Diálogos são apropriados para exibir perguntas, que o usuário precisar 
responder.
 Com a função Set_KrlDlg( ) é emitido um diálogo.
 A função simplesmente emite o diálogo.
 Ela não aguarda até que ele tenha sido respondido.
 Com a função Exists_KrlDlg( ) pode ser verificado, se um determi-
nado diálogo ainda existe.
 Também esta função não aguarda, até que o diálogo esteja respondido, 
mas simplesmente faz uma busca no buffer pelo diálogo com este handle.
 Portanto, a consulta no programa KRL deve ocorrer ciclicamente, até que 
o diálogo tenha sido respondido ou excluído de outra forma.
 A continuidade da execução do programa pode ser tornada dependente 
de qual softkey o usuário seleciona.
Avaliação dos botões
 Declaração e inicialização dos botões
Fig. 4-11: Diálogo
Fig. 4-12: Diálogo
47 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
48 / 95
Programação do robô 3
 Avaliação via Exists_KrlDlg(): o botão, que foi criado sob o index 4, 
também fornece o 4 como feedback.
Programação de 
diálogos 
definidos pelo 
usuário
1. Carregar um programa principal no editor.
2. Declarar variáveis de trabalho para:
 remetente, número da mensagem, texto de mensagem (de 
KrlMsg_T)
 campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
 7 possíveis botões (de KrlMsgDlgSK_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
variável para o resultado do teste (como BOOL)
 variável para o resultado da resposta de qual botão foi pressionado 
(como INT)
3. Iniciar variáveis de trabalho com os valores desejados.
4. Programar o acesso de função Set_KrlDlg(…).
5. Parar o programa com um loop, até que o diálogo esteja respondido.
6. Avaliar o diálogo com o acesso de função Exists_KrlDlg( ).
7. Planejar e programar outras derivações no programa.
8. Fechar e salvar o programa principal.
DECL KRLMSGDLGSK_T Softkey[7] ; Preparar 7 possíveis softkeys
softkey[1]={sk_type #value, sk_txt[] "key1"}
softkey[2]={sk_type #value, sk_txt[] "key2"}
softkey[3]={sk_type #value, sk_txt[] "key3"}
softkey[4]={sk_type #value, sk_txt[] "key4"}
softkey[5]={sk_type #value, sk_txt[] "key5"}
softkey[6]={sk_type #value, sk_txt[] "key6"}
softkey[7]={sk_type #value, sk_txt[] "key7"}
; softkey n° 4 dá como feedback 4
softkey[4]={sk_type #value, sk_txt[] "key4"}
Fig. 4-13: Diálogo com 3 botões
Se os botões não forem programados de maneira completa, mas 
com lacunas (n° 1, 4, 6), estes botões são colocados em sequência. 
Se forem utilizados apenas os botões 1, 4 e 6, também serão possí-
veis apenas os feedbacks 1, 4 e 6.
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
4 Programação de mensagens com KRL
Exemplo de programação para a exibição/mensagem acima:
Fig. 4-14: Diálogo
O programa é parado após a remoção do diálogo. A mensagem é ex-
cluída após a resposta. Depois disto é dada continuidade no progra-
ma. Em seguida, é programado um distribuidor. 
Da mesma forma desaparece a mensagem ao dar um reset no programa ou 
ao fechar o programa. Isto ocorre através do ajuste nas opções de mensa-
gens Clear_P_Reset TRUE.
DECL KRLMSG_T myQuestion
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGDLGSK_T Softkey[7] ;Preparar 7 possíveis softkeys
DECL KRLMSGOPT_T Option
DECL INT handle, answer
DECL BOOL present
...
myQuestion={modul[] "College", Nr 1909, msg_txt[] "My Questiontext"}
Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, 
Log_to_DB TRUE} 
;Dummies estão vazios Dummy[1..3]
Parameter[1] = {Par_Type #EMPTY}
Parameter[2] = {Par_Type #EMPTY}
Parameter[3] = {Par_Type #EMPTY}
softkey[1]={sk_type #value, sk_txt[] "key1"} ; Botão 1
softkey[2]={sk_type #value, sk_txt[] "key2"} ; Botão 2
softkey[3]={sk_type #value, sk_txt[] "key3"} ; Botão 3
softkey[4]={sk_type #value, sk_txt[] "key4"} ; Botão 4
softkey[5]={sk_type #value, sk_txt[] "key5"} ; Botão 5
softkey[6]={sk_type #value, sk_txt[] "key6"} ; Botão 6
softkey[7]={sk_type #value, sk_txt[] "key7"} ; Botão 7
...
49 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
50 / 95
Programação do robô 3
4.11 Exercício: Programar diálogo
Objetivo do 
exercício
Após a conclusão com êxito deste exercício, você está em condições de exe-
cutar as seguintes atividades:
 programar mensagens próprias de informação, status e confirmação 
 programar consultas próprias de diálogo 
 Emitir parâmetros quaisquer em mensagens 
Requisitos Os seguintes requisitos são necessários para realizar o exercício com êxito:
 Conhecimentos da linguagem de programação KRL 
 Conhecimentos teóricos sobre a programação de mensagens 
Definição de 
tarefas
Tarefa parcial 1: Mensagem de diálogo
1. Crie uma mensagem de diálogo com o texto "Selecione um novo compo-
nente". 
2. Disponibilize 4 componentes diferentes e ocupe a 5ª softkey com "FIM".
3. Após a seleção do componente emita uma mensagem de informação com 
o texto "Componente xxx foi selecionado". Use para isto módulos base 
eventualmente já existentes.
4. Teste o seu programa conforme a prescrição.
O que você deveria saber agora:
1. Como são inscritas as teclas das softkeys no diálogo? 
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
...; Emitir diálogo
handle = Set_KrlDlg(myQuestion, Parameter[ ],Softkey[ ], Option)
answer=0
REPEAT ; Loop para parar até que este diálogo seja respondido
present = exists_KrlDlg(handle ,answer) ; A resposta é descrita pelo 
sistema
UNTIL NOT(present)
...
SWITCH answer
CASE 1 ; Botão 1
; Ação no botão 1
...
CASE 2 ; Botão 2
; Ação no botão 2
...
...
CASE 7 ; Botão 7
; Ação no botão 7
ENDSWITCH
...
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
5 Programação de Interrupt
5 Programação de Interrupt
5.1 Programação de rotinas de Interrupt
Descrição de 
rotinas de cance-
lamento
 Em um evento definido, p.ex., uma entrada, a unidade de comando inter-
rompe o programa atual e executa um subprograma definido.
 Um subprograma, que é acessado por um Interrupt, é chamado de pro-
grama Interrupt.
 Podem estar declarados, no máximo, 32 Interrupts ao mesmo tempo.
 Simultaneamente, podem estar ativos, no máximo, 16 Interrupts.
Passos importantes ao usar o Interrupt
 Declaração de Interrupt
 Ativar/desativar ou bloquear/liberar Interrupt
 se for o caso, parar o robô
 se for o caso, descartar o planejamento da trajetória atual e percorrer 
nova trajetória
Princípio da 
declaração de 
Interrupt
Generalidades sobre a declaração de Interrupts
 Em um evento definido, p.ex., uma entrada, a unidade de comando inter-
rompe o programa atual e executa um subprograma definido. 
 O evento e o subprograma são definidos com INTERRUPT ... DECL 
... WHEN ... DO ....


Sintaxe da declaração de Interrupt

Fig. 5-1: Trabalhar com rotinas Interrupt
A declaração de Interrupt é uma instrução. Ela deve constar na parte 
de instrução do programa e não pode constar na parte de declara-
ção!
Após a declaração um Interrupt primeiramente está desativado. O In-
terrupt deve ser ativado antes que o evento definido possa ser reagi-
do!
<GLOBAL> INTERRUPT DECL Prio WHEN Ereignis DO Interruptprogramm
51 / 95Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
52 / 95
Programação do robô 3
 Global
 Um Interrupt é reconhecido apenas a partir do nível no qual está de-
clarado.
 Um Interrupt, que foi declarado em um subprograma, não é conhecido 
no programa principal (aqui Interrupt 23).
 Um Interrupt com a palavra-chave GLOBAL anteposta na declaração, 
também é conhecido nos níveis superiores (aqui Interrupt 2).

 Prio: Prioridade
 Estão disponíveis as prioridades 1, 2, 4 - 39 e 81 - 128.
 As prioridades 3 e 40 - 80 estão reservadas para o uso pelo sistema.
 Eventualmente o Interrupt 19 está pré-ocupado para o teste dos 
freios.
 Se vários Interrupts ocorrerem simultaneamente, é processado pri-
meiro o Interrupt com a máxima prioridade, depois os Interrupts com 
menor prioridade. (1 = máxima prioridade)
Fig. 5-2: Validade de Interrupts
<GLOBAL> INTERRUPT DECL Prio WHEN Ereignis DO Unterprogramm
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)
5 Programação de Interrupt

 Evento: Evento, que deve ocorrer no Interrupt.
 Programa Interrupt
 Nome do programa Interrupt, que deve ser processado. 
 Este subprograma é chamado de programa Interrupt. 
 As variáveis de tempo de execução não podem ser entregues como 
parâmetro ao programa Interrupt
 São permitidas variáveis, que estão declaradas em uma lista de da-
dos.
 Exemplo: Declaração de um Interrupt
 nenhum Interrupt global
 Prioridade: 23
 Evento: entrada 12 flanco positivo
 Programa Interrupt: INTERRUPT_PROG(20,VALUE)

Descrição ligar/
desligar/
bloquear/liberar 
Interrupt
Após uma declaração de Interrupt, este deve ser ativado em seguida.
Possibilidades através do comando INTERRUPT ...
 Ativa um Interrupt.
 Desativa um Interrupt.
 Bloqueia um Interrupt.
 Libera um Interrupt.
Fig. 5-3: Prioridades de Interrupts
<GLOBAL> INTERRUPT DECL Prio WHEN Ereignis DO Unterprogramm
Este evento é reconhecido em sua ocorrência através de um flanco 
(disparado por flanco).
INTERRUPT DECL 23 WHEN $IN[12]==TRUE