Programação Do Robô Kuka 3

Training KUKA Roboter GmbH
Programação do robô 3
KUKA System Software 8
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)
2 / 95 Edição: 17.10.2012 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
Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL) 3 / 95


1 Programação estruturada
1.1 Objetivo de um método de programação padronizado
Objetivo do Um método de programação padronizado serve para:

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

de um comen- ção. Todas as linguagens de programação consistem de instruções para o
tário? computador (código) e notas para os processadores de textos (comentários).
Se um texto fonte for processado (compilado, interpretado, etc.), os comentá-
rios são ignorados pelo software de processamento e não têm influência so-
bre o resultado.
Na unidade de comando KUKA são usados comentários de linhas, ou seja, os
comentários terminam automaticamente no final da linha.
Comentários por si só não podem tornar um programa legível, mas podem au-
mentar consideravelmente a legibilidade de programas bem estruturados.
Com os comentários, o programador tem a possibilidade de incluir notas, ex-
plicações no programa, sem que estas sejam registradas pela unidade de co-
mando como sintaxe.
O programador tem a responsabilidade de garantir que o conteúdo dos co-
mentários corresponda ao estado atual das orientações de programação. Em
caso de alterações de programa também os comentários deverão ser verifi-
cados e, se necessário, adaptados.
O conteúdo de um comentário e, portanto, também a sua utilidade, pode ser
livremente selecionado pelo processador e não tem sintaxe obrigatória. Ge-
ralmente, comentários são registrados em linguagem "humana", na 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 Informações sobre todo o texto fonte:

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

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

Assim, o modo de trabalho ou o significado de uma parte de texto (por exem-
plo, linha de programa) podem ser explicados, para que outros ou o próprio
autor possam compreender isso mais facilmente mais tarde.
DEF PICK_CUBE()
INI
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
Nota sobre trabalhos a serem executados:

Comentários podem identificar partes de código insuficientes ou ser variáveis
para partes de código faltantes.

DEF PICK_CUBE()
INI
;Aqui deve ser inserido ainda o cálculo das posições de paletes!
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
Descomentário:
Se uma parte do código for excluído provisoriamente mas posteriormente
reinserido, ele será descomentado. A parte do código, depois de embalado no
comentário, no ponto de vista não é mais código, ou seja, já não existe mais.
DEF Palletize()
INI
PICK_CUBE()
;CUBE_TO_TABLE()
CUBE_TO_MAGAZINE()
END
Qual é o efeito do  em PASTAS podem ser ocultadas partes do programa

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

...
END
DEF Main()
...
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
...
END
Por que se Na programação, os subprogramas são utilizados especialmente para permi-

trabalha com a tir um uso múltiplo de partes de tarefas iguais e com isso, conseguir evitar as
técnica de repetições de códigos. Isso, entre outros, também economiza espaço de me-
mória.
subprogramas?
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

Aplicação de DEF MAIN()

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

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

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

através de uma robô, recomendamos usar termos que fazem sentido na definição de nomes.
identificação A estes pertencem, p.ex.:
adequada de  Nomes de textos descritivos para sinais de entrada e de saída
nomes de dados?  Nomes de ferramentas e base
 Acordos de sinais para sinais de entrada e de saída
 Nomes de pontos
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.

Erros de estrutura e de programação são facilmente reconhecidos em uma re-

alização posterior em códigos de programa, uma vez que o uso correto do
PAP permite uma realização direta em códigos de programação. Ao mesmo
tempo, com a criação de um PAP, obtém-se uma documentação do programa
a ser criado.
 Ferramenta para a estruturação da execução de um programa
 A execução de um programa é mais facilmente legível
 Erros estruturais podem ser reconhecidos com maior facilidade
 Documentação simultânea do programa
Ícones PAP Início ou fim de um processo ou programa
Fig. 1-1
Integração de instruções e operações
Fig. 1-2
Ramificação
Fig. 1-3
Instruções gerais no código de programa
Fig. 1-4
Acesso ao subprograma
Fig. 1-5
Instrução de entrada/saída

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


2 Interpretador Submit
2.1 Status do Interpretador Submit
Descrição do No KSS 8.x rodam duas Tasks

Interpretador  Interpretador de robô (execução dos programas de movimento do robô e
Submit sua lógica)
 Interpretador de comando (execução de um programa de controle parale-
lo)
Estrutura do programa SPS.SUB:
1 DEF SPS ( )
2 DECLARATIONS
3 INI
4
5 LOOP
6 WAIT FOR NOT($POWER_FAIL)
7 TORQUE_MONITORING()
8
9 USER PLC
10 ENDLOOP
O estado do Interpretador Submit
O Interpretador Submit Interpretador Submit Interpretador Submit

está em execução parado desselecionado
O interpretador de comando
 pode ser iniciado automática ou manualmente
 também pode ser parado ou desselecionado manualmente
 pode assumir funções de operação e de comando no ambiente do robô
 como padrão está criado com o nome SPS.sub no diretório R1/SYSTEM
 pode ser programado com o conjunto de comandos KRL
 não pode processar nenhum comando KRL, que esteja relacionado com
movimentos de robô
 permite movimentos assíncronos de eixos adicionais
 pode acessar variáveis de sistema lendo e gravando
 pode acessar entradas/saídas lendo e gravando
Correlações na
Atenção!
programação do O Interpretador Submit não pode ser usado para aplica-
Interpretador ções críticas de tempo! Para estes casos é necessário usar um PLC. Moti-
Submit vos:
 O Interpretador Submit divide a capacidade do sistema com o Interpre-
tador de robô e a gestão de IO, que têm prioridades maiores. Por isto, o
Interpretador Submit não operará regularmente no ciclo de interpolação
da unidade de comando do robô de 12ms.
 Além disso, o tempo de execução do Interpretador Submit é inconstante.
O tempo de execução do Interpretador Submit é influenciado pelo núme-
ro das linhas no SUB-programa. Também as linhas de comentário e va-
zias exercem um efeito.

 Início automático do Interpretador Submit

 O interpretador Submit é iniciado automaticamente quando a unidade
de comando do robô é ligada após uma partida a frio.
 É iniciado o programa, que está definido no arquivo KRC/STEU/
MADA/$custom.dat.
$PRO_I_O[]="/R1/SPS()"
 Operação manual do Interpretador Submit

 selecionar a operação através da sequência de menu Configuração
> Interpretador SUBMIT > Iniciar/Selecionar.
 Operação direta através da barra de status da exibição de status In-
terpretador Submit. Ao ser selecionado, abre-se uma janela com as
opções executáveis.
Quando um arquivo de sistema, p.ex. $config.dat ou $custom.dat, é

modificado, e ocorre um erro através disto, o Interpretador Submit é
desselecionado automaticamente. Se o erro estiver solucionado no
arquivo de sistema, o Interpretador Submit deve ser novamente selecionado
manualmente.
Particularidades na programação do Interpretador Submit

 Não é possível executar nenhuma instrução para movimentos do robô
como
 PTP, LIN, CIRC etc.
 acessos de subprogramas, que contêm movimentos de robô
 Instruções, que se referem a movimentos do robô, TRIGGER ou BRA-
KE.
 Podem ser controlados eixos assíncronos, como E1.
IF (($IN[12] == TRUE) AND ( NOT $IN[13] == TRUE)) THEN
ASYPTP {E1 45}
ENDIF
...
IF ((NOT $IN[12] == TRUE) AND ($IN[13] == TRUE)) THEN
ASYPTP {E1 0}
ENDIF
 Instruções entre a linha LOOP e ENDLOOP são processadas continuamen-

te em "segundo plano".
 Qualquer parada através de comandos de espera ou loops de espera
deve ser impedida, uma vez que isto retarda adicionalmente o processa-
mento do Interpretador Submit.
 É possível uma comutação de saídas.
Aviso!
Não é verificado, se o Interpretador do robô ou o Inter-
pretador Submit acessam simultaneamente a mesma saída, uma vez que
isto pode ser desejado em determinados casos.
Por isso, a atribuição das saídas deve ser cuidadosamente verificada pelo
usuário. Caso contrário, podem ocorrer sinais de saída inesperados, p.ex.,
em dispositivos de segurança. Pode ocorrer morte, lesões corporais graves
ou danos materiais significativos.
Nos modos de teste o $OV_PRO não pode ser escrito a

partir do Interpretador Submit, porque a alteração pode
ser inesperada para usuários que trabalham no robô industrial. As conse-
quências podem ser morte, lesões graves e danos materiais significativos.

Aviso!
Não processar sinais relevantes de segurança, sinais
críticos de tempo e variáveis através do Interpretador Submit.
Procedimento na 1. A programação ocorre no estado parado ou desselecionado.

programação do 2. O programa padrão SPS.sub é carregado no editor.
Interpretador 3. Executar declarações necessárias e a inicialização. Aqui devem ser admi-
Submit nistradas as pastas preparadas.
4. Executar as expansões de programa na pasta USER PLC.
5. Fechar e salvar o Interpretador Submit.
6. Caso o Submit não inicie automaticamente, iniciar manualmente.
Exemplo de programa com base em uma programação de sinalizador inter-
mitente no Interpretador Submit
DEF SPS( )
DECLARATIONS
DECL BOOL flash ;Declaração no $CONFIG.dat
INI
flash = FALSE
$TIMER[32]=0 ; Resetar TIMER[32]
$TIMER_STOP[32]=false ; Iniciar TIMER[32]
...
LOOP
...
USER PLC
IF ($TIMER[32]>500) AND (flash==FALSE) THEN
flash=TRUE
ENDIF
IF $TIMER[32]>1000 THEN
flash=FALSE
$TIMER[32]=0
ENDIF
; Atribuir a uma lâmpada (saída 99)
$OUT[99] = flash
...
ENDLOOP


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 seguros para 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.
Fig. 3-1: Exemplo de espaços de trabalho expecíficos dos eixos para A1
 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-2: Exemplo de espaço de trabalho cartesiano
 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-3: Espaços não permitidos

 Espaços admissíveis: O robô não pode se mover fora de um espaço de

trabalho destes.
Fig. 3-4: Espaços admissíveis
 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

bloqueio de  Execução em acoplamento direto (sem PLC).
espaço de
trabalho e
espaços de
trabalho
Fig. 3-6
 Execução com um PLC. Este somente pode encaminhar os sinais ou usa

adicionalmente uma lógica.

Fig. 3-10
 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.
Em caso de solicitação de entrada simultânea, contudo,

os dois robôs recebem a permissão. Normalmente isto
resulta em um crash.
 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 Modo para espaços de trabalho

configuração do  #OFF
espaço de
O monitoramento do espaço de trabalho está desligado.
trabalho
 #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
TCP ou o sistema de coordenadas do flange se encontra fora do es-
paço de trabalho.


quando o eixo encontra-se fora do espaço de trabalho.
 #INSIDE_STOP
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)
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
TCP ou o sistema de coordenadas do flange se encontra fora do es-
paço de trabalho.
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
Fig. 3-13: Espaço de trabalho cartesiano, origem U
 Dimensões do espaço de trabalho, a partir da origem

Fig. 3-14: Espaço de trabalho cartesiano, dimensões
Procedimento na Configurar espaços de trabalho específicos dos eixos

configuração e 1. No menu principal, selecionar Configuração > Extras > Monitoramento
uso de espaços do espaço de trabalho > Configuração.
de trabalho 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.
Fig. 3-15: Exemplo de espaços de trabalho expecíficos dos eixos para

A1
3. Introduzir os valores e pressionar Salvar.

Fig. 3-16: Exemplo de espaço de trabalho específico de eixo
4. Pressionar Sinal. A janela Sinais abre-se.
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

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)

Fig. 3-19: Exemplo de configuração de espaço de trabalho cartesiano

(P2 está na origem)
 Neste exemplo o espaço de trabalho possui as dimensões x = 300mm, y

= 250mm e z= 450mm. Em relação ao sistema de coordenadas mundial,
ele está girado em 30 graus no eixo Y. A origem "U" não se encontra no
centro do retângulo.
Fig. 3-20: Exemplo de espaço de trabalho cartesiano (girado)

Fig. 3-21: Exemplo de configuração de espaço de trabalho cartesiano

(girado)
Trabalhar com espaços de trabalho

 Espaços de trabalho específicos dos eixos (R1\Mada\$machine.dat)
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}
 Espaços de trabalho cartesianos (STEU\Mada\$custom.dat)

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}
 Sinais dos espaços de trabalho (STEU\Mada\$machine.dat)

DEFDAT $MACHINE PUBLIC
...
SIGNAL $WORKSTATE1 $OUT[912]
SIGNAL $WORKSTATE4 FALSE
...
SIGNAL $AXWORKSTATE1 $OUT[712]
SIGNAL $AXWORKSTATE2 $OUT[713]
SIGNAL $AXWORKSTATE3 FALSE
 Ligar/desligar o espaço de trabalho com KRL

DEF myprog( )
...
$WORKSPACE[3].MODE = #INSIDE
...
$WORKSPACE[3].MODE = #OFF
...
$AXWORKSPACE[1].MODE = #OUTSIDE_STOP
...
$AXWORKSPACE[1].MODE = #OFF

3.2 Exercício: Monitoramento do espaço de trabalho
Objetivo do Após a conclusão com êxito deste exercício, você estará em condições de
exercício 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 Tarefa parcial 1

funções 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.
Fig. 3-22
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.
Fig. 3-23
O que você deve saber agora:

1. Quantos espaços de trabalho podem ser configurados no máximo?
............................................................

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

4 Programação de mensagens com KRL
4.1 Generalidades sobre mensagens definidas pelo usuário
Descrição de Propriedades da programação de mensagens

mensagens  Com KRL o programador pode programas mensagens próprias.
definidas pelo
 É possível emitir várias mensagens simultaneamente.
usuário
 Mensagens emitidas encontram-se em um buffer de mensagens, até que
sejam novamente excluídas.
 As mensagens de informação não são administradas no buffer de mensa-
gens. (Princípio "fire and forget").
 Mensagens podem ser testadas e excluídas de forma simples, já as men-
sagens de informação não.
 Em cada mensagem podem ser integrados até 3 parâmetros.
Na janela de mensagens da KUKA.HMI é exibido um ícone para cada men-
sagem. Os ícones estão atribuídos fixamente aos tipos de mensagem e não
podem ser alterados pelo programador.
Podem ser programados os seguintes tipos de mensagem:
Ícone Tipo
Mensagem de confirmação
Mensagem de estado
Mensagem de informação
Mensagem de espera
Mensagem de diálogo (é exibida em uma janela POP-UP

própria)
Nenhuma reação especificada do sistema de robô está ligada com os

diferentes tipos de mensagens (p.ex. o robô freia ou o programa é
parado). As reações desejadas devem ser programadas.
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

Princípio da
programação de
mensagens
definida pelo
usuário:
Variáveis/Estru-
turas
Fig. 4-1: Mensagem de informação
Estrutura para emitente, número da mensagem, texto de mensagem

 estrutura KUKA predefinida: KrlMsg_T
STRUC KrlMsg_T CHAR Modul[24], INT Nr, CHAR Msg_txt[80]
DECL KrlMsg_T mymessage

mymessage = {Modul[ ] "College", Nr 1906, Msg_txt[ ] "My first
Message"}
 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 contagem EKrlMsgType
ENUM EKrlMsgType Notify, State, Quit, Waiting
 #Quit: Emite esta mensagem como mensagem de confirmação
 #STATE: Emite esta mensagem como mensagem de estado
 #NOTIFY: Emite esta mensagem como mensagem de informação
 #WAITING: Emite esta mensagem como mensagem de espera

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:

Enum KrlMsgParType_T Value, Key, Empty

STRUC KrlMsgPar_T KrlMsgParType_T Par_Type, CHAR Par_txt[26], INT
Par_Int, REAL Par_Real, BOOL Par_Bool
Uso dos respectivos agregados

 Par_Type: Tipo do parâmetro/dummy
 #VALUE: O parâmetro é inserido diretamente no texto de mensagem
na forma entregue (portanto, como string, valor INT, REAL ou BOOL)
 #KEY: O parâmetro é uma palavra-chave, pela qual deve ser procura-
do no banco de dados de mensagens, para carregar o texto corres-
pondente
 #EMPTY: O parâmetro está vazio.
 Par_txt[26]: Texto ou palavra-chave para o parâmetro
 Par_Int: Transmissão de um valor inteiro como parâmetro
 Par_Real: Transmissão de um valor real como parâmetro
 Par_Bool: Transmissão de um valor booleano como parâmetro, o texto
de exibição é TRUE ou FALSE
Exemplos de programa para a transmissão direta de parâmetros nos dum-
mies:
O texto de mensagem é Msg_txt[ ] "Falha no %1"
DECL KrlMsgPar_T Parameter[3] ; Criar 3 conjuntos de parâmetros
...
Parameter[1] = {Par_Type #VALUE, Par_txt[ ] "Finisher"}
Parameter[2] = {Par_Type #EMPTY}
...
Emissão de mensagem: Defeito no Finisher
Uma vez que os parâmetros raramente são escritos através de uma

introdução constante, os respectivos agregados são transmitidos
com o separador de ponto.
Exemplos de programa para a transmissão com separador de ponto de parâ-

metros nos dummies:
O texto de mensagem é Msg_txt[ ] "Faltam %1 componentes"
DECL KrlMsgPar_T Parameter[3] ; Criar 3 conjuntos de parâmetros
DECL INT missing_part
...
misssing_part = 13
...
Parameter[1] = {Par_Type #VALUE}
Parameter[1].Par_Int = missing_part
...
Emissão de mensagem: Faltam 13 componentes

Fig. 4-2: Diálogo
Estrutura para a ocupação de botões em diálogos:

 estrutura KUKA predefinida: KrlMsgDlgSK_T
Enum KrlMsgParType_T Value, Key, Empty
Struc KrlMsgDlgSK_T KrlMsgParType_T Sk_Type, Char SK_txt[10]
 Sk_Type: Tipo de 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:
DECL KRLMSGDLGSK_T Softkey[7] ; Preparar 7 possíveis softkeys
...
softkey[1]={sk_type #value, sk_txt[] "key1"}
...
Podem ser atribuídos, no máximo, 10 caracteres por botão. De acor-

do com os caracteres utilizados surgem botões de diferentes largu-
ras.
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
STRUC KrlMsgOpt_T BOOL VL_Stop, BOOL Clear_P_Reset, BOOL
Clear_SAW, BOOL Log_To_DB
 VL_Stop: TRUE aciona uma parada de avanço

 Padrão: TRUE

 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
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.
 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 Setar, testar e excluir uma mensagem

programação de  Setar ou emitir uma mensagem
mensagens
Com esta função é emitida uma mensagem no programa KRL. Isto signi-
definida pelo
fica, que a respectiva mensagem é inserida em um buffer de mensagens
usuário: Funções 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
DEFFCT INT Set_KrlMsg(Type:IN, MyMessage:OUT, Parameter[ ]:OUT,
Option:OUT)
DECL EKrlMsgType Type
DECL KrlMsg_T MyMessage
DECL KrlMsgPar_T Parameter[ ]
DECL KrlMsgOpt_T Option
 Tipo: Tipo da mensagem (#Notify, #State, #Quit, #Waiting)

 MyMessage: 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.
DEF MyProg( )
DECL INT handle
...
handle = Set_KrlMsg(Type, MyMessage, Parameter[ ], Option)
 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 informação são processadas segundo o princípio

"fire e forget". Em mensagens de informação sempre é devolvido um
handle = 0, caso a mensagem tenha sido emitida com sucesso.
 Verificar uma 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
DEFFCT BOOL Exists_KrlMsg(nHandle:IN)
DECL INT nHandle
 nHandle: O handle disponibilizado pela função "Set_KrlMsg(…)"

para a mensagem
 Valor de retorno da função:
DEF MyProg( )
DECL INT handle
DECL BOOL present
...
...
present= Exists_KrlMsg(handle)
 present == TRUE: Esta mensagem ainda existe no buffer de

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

para a mensagem
DEF MyProg( )
DECL INT handle
DECL BOOL erase
...
...
eraser = Clear_KrlMsg(handle)
 eraser == TRUE: Esta mensagem pôde ser excluída

 eraser == FALSE: Esta mensagem não pôde ser excluída
Funções especiais para a exclusão com a função

Clear_KrlMsg(handle):
Clear_KrlMsg(-1): todas as mensagens iniciadas com este pro-
cesso são excluídas.
Clear_KrlMsg(-99): todas as mensagens de usuário KRL são excluídas.

Princípio da Setar e testar um diálogo

programação de  Setar ou emitir um diálogo
diálogo definida
Com a função Set_KrlDlg( ) é emitida uma mensagem de diálogo. Isto
pelo usuário:
significa que a mensagem é transmitida ao buffer de mensagens e exibida
Funções em uma janela de mensagens com botões.
 Funções build-in para a emissão de um diálogo
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
 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.
DEF MyProg( )
DECL INT handle
...
handle = Set_KrlDlg(MyQuestion, Parameter[ ], Button[ ], Option)
 handle == -1: Não foi possível emitir o diálogo (p.ex. porque

um outro diálogo ainda está ativo e não foi respondido ou o buffer
de 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.
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.
 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.
DEFFCT BOOL Exists_KrlDlg(INT nHandle:IN, INT Answer:OUT)
DECL INT nHandle, answer
 nHandle: O handle disponibilizado pela função "Set_KrlDlg(…)"

para o diálogo
 answer: Feedback de qual botão foi pressionado. O botão 1, que foi
definido como "Botão[1]" devolve, portanto, o valor 1

A função não aguarda até que o diálogo esteja respondido, mas sim-
plesmente faz uma busca no buffer pelo diálogo com este handle.
Portanto, a consulta no programa KRL deve ocorrer ciclicamente, até
que o diálogo tenha sido respondido ou excluído de outra forma.

DEF MyProg( )
DECL INT handle, answer
DECL BOOL present
...
handle = Set_KrlDlg(MyQuestion, Parameter[ ], Button[ ], Option)
...
present = Exists_KrlDlg(handle, answer)
 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)
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.
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  Mensagens de informação são apropriadas, para exibir informações ge-
mensagem de rais.
informação  Uma mensagem de informação somente é criada. Eventualmente verifi-
definida pelo ca-se, se a mensagem chegou com sucesso.
usuário  Uma vez que as mensagens de informação não são administradas, po-
dem ser criadas aprox. 3 milhões de mensagens.
Programação de 1. Carregar um programa principal no editor

mensagens de 2. Declarar variáveis de trabalho para:
observação  remetente, número da mensagem, texto de mensagem (de
definidas pelo KrlMsg_T)
usuário  campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
 opções gerais de mensagens (de KrlMsgOpt_T)
 "Handle" (como INT)
3. Iniciar variáveis de trabalho com os valores desejados

4. Programar o acesso de função Set_KrlMsg(…)

5. Se necessário, avaliar "handle", para determinar se a emissão teve êxito
6. Fechar e salvar o programa principal
Exemplo de programação para a exibição acima:

DECL KRLMSG_T mymessage
DECL KRLMSGPAR_T Parameter[3]
DECL KRLMSGOPT_T Option
DECL INT handle
...
mymessage={modul[] "College", Nr 1906, msg_txt[] "My first Message"}
Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE,
Log_to_DB TRUE}
;Dummies estão vazios Dummy[1..3]
handle = Set_KrlMsg(#NOTIFY, mymessage, Parameter[ ], Option)
4.3 Exercício: Programar mensagem de informação
Objetivo do Após a conclusão com êxito deste exercício, você está em condições de exe-
exercício 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 Tarefa parcial 1: Mensagem de informação

tarefas 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.
O que você deveria saber agora::
1. Como é excluída novamente uma mensagem de informação?

.............................................................
.............................................................
2. Qual parte integrante da estrutura de mensagens é responsável pelo "dis-
paro" do texto de mensagem?
.............................................................
.............................................................

4.4 Trabalhar com uma mensagem de estado
Descrição de uma
mensagem de
estado definida
pelo usuário
Fig. 4-5: Mensagem de estado
 As mensagens de estado são administradas no buffer de mensagens.

 As mensagens de estado não podem ser excluídas novamente através da
barra de comutação "Todas OK".
 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  As mensagens de estado são apropriadas para exibir a alteração de um

mensagem de estado (p.ex. a supressão de uma entrada).
estado definida  São administradas, no máximo, 100 mensagens no buffer de mensagens.
pelo usuário  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 1. Carregar um programa principal no editor

estado definidas  remetente, número da mensagem, texto de mensagem (de
pelo usuário KrlMsg_T)
 campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
 variável para o resultado do teste (como BOOL)
 variável para o resultado da exclusão (como BOOL)
3. Iniciar variáveis de trabalho com os valores desejados
4. Programar o acesso de função Set_KrlMsg(…)
5. Parar o programa com um loop, até que o estado desencadeador deixe
de existir
6. Excluir a mensagem de estado com o acesso de função Clear_KrlMsg(
)
7. Fechar e salvar o programa principal

Fig. 4-6: Mensagem de estado
Exemplo de programação para a exibição/mensagem acima:
A mensagem de estado é gerada através do estado entrada 12

(FALSE). O programa é parado após a emissão da mensagem. A
mensagem é excluída através do estado entrada 17 (TRUE). Depois
disto é dada continuidade no programa.
Da mesma forma 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 INT handle
DECL BOOL present, eraser
...
IF $IN[12]==FALSE THEN
mymessage={modul[] "College", Nr 1909, msg_txt[] "My Messagetext"}
Log_to_DB TRUE}
handle = Set_KrlMsg(#STATE, mymessage, Parameter[ ], Option)
ENDIF
eraser=FALSE
;Loop para parar até que esta mensagem tenha sido excluída
REPEAT
IF $IN[12]==TRUE THEN
eraser=Clear_KrlMsg(handle) ;Excluir mensagem
ENDIF
present=Exists_KrlMsg(handle) ;controle adicional
UNTIL NOT(present) or eraser
4.5 Exercício: Programar mensagem de estado
 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:
Definição de Tarefa parcial 1: Mensagem de estado

tarefas 1. Crie uma mensagem de status com o texto "Magazine quase vazio".
ração.

3. Através da remoção da entrada 14 no painel de operação a mensagem

deve ser novamente excluída.
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".
ração.
3. Através da remoção da entrada 15 no painel de operação a mensagem
deve ser novamente excluída.
O que você deveria saber agora:
1. O que significa %2 no texto de mensagem?
............................................................
............................................................

4.6 Trabalhando com mensagem de confirmação
Descrição de uma
mensagem de
confirmação
definida pelo
usuário
Fig. 4-7: Mensagem de confirmação
 As mensagens de confirmação são administradas no buffer de mensa-

gens.
 As mensagens de confirmação podem ser novamente excluídas através
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  As mensagens de confirmação são apropriadas para exibir informações,

mensagem de que o usuário precisar tomar conhecimento.
confirmação  São administradas, no máximo, 100 mensagens no buffer de mensagens.
definida pelo  Na mensagem de confirmação (ao contrário da mensagem de informa-
usuário çã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 1. Carregar um programa principal no editor.

confirmação  remetente, número da mensagem, texto de mensagem (de
definidas pelo KrlMsg_T)
usuário  campos com 3 elementos para os parâmetros (de KrlMsgPar_T)
3. Iniciar variáveis de trabalho com os valores desejados.
4. Programar o acesso de função Set_KrlMsg(…).
5. 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-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.

DECL INT handle
DECL BOOL present
...
Log_to_DB TRUE}
handle = Set_KrlMsg(#QUIT, mymessage, Parameter[ ], Option)
REPEAT
present=Exists_KrlMsg(handle)
UNTIL NOT(present)
4.7 Exercício: Programar mensagens de confirmação
 Programar mensagens de confirmação próprias
Definição de Tarefa parcial 1: Mensagem de confirmação

tarefas 1. Crie uma mensagem de confirmação com o texto "Confirmar falha Vácuo
não atingido".
raçã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".


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.
1. Qual é o número máximo de mensagens de confirmação administradas no
buffer de mensagens?
.............................................................
.............................................................

4.8 Trabalhar com uma mensagem de espera
Descrição de uma
mensagem de
espera definida
pelo usuário
Fig. 4-9: Mensagem de espera
 As mensagens de espera são administradas no buffer de mensagens.

 As mensagens de espera podem ser excluídas novamente através da
barra de comutação 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  Mensagens de espera são apropriadas para aguardar um estado e exibir
mensagem de nisto o símbolo de espera.
espera definida  São administradas, no máximo, 100 mensagens no buffer de mensagens.
pelo usuário  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( ).

espera definidas  remetente, número da mensagem, texto de mensagem (de
pelo usuário KrlMsg_T)
 variável para o resultado da exclusão (como BOOL)
4. Programar o acesso de função Set_KrlMsg(…).
5. Parar o programa com um loop, até que ocorra o estado pelo qual é es-
perado ou até que a mensagem seja excluída através do botão Simuliere.
6. Excluir a mensagem de espera com o acesso de função Clear_KrlMsg(
).
Fig. 4-10: Mensagem de espera

O programa é parado após a emissão da mensagem. A mensagem

é excluída através do estado entrada 12 (TRUE). Depois disto é dada
continuidade no programa.

DECL INT handle
DECL BOOL present, eraser
...
IF $IN[12]==FALSE THEN
Log_to_DB TRUE}
handle = Set_KrlMsg(#WAITING, mymessage, Parameter[ ], Option)
ENDIF
eraser=FALSE
REPEAT
IF $IN[12]==TRUE THEN
eraser=Clear_KrlMsg(handle) ;Meldung loeschen
ENDIF
present=Exists_KrlMsg(handle) ;kann über simuliere geloescht worden
sein
UNTIL NOT(present) or eraser
4.9 Exercício: Programar mensagens de espera
 Programar mensagens de espera próprias
Definição de 1. Crie uma mensagem de espera com o texto "Esperando por entrada do
tarefas operador" e ative a mesma através da entrada 12.
2. Apague a mensagem de espera, resetando a entrada 12.
1. Qual é a diferença entre uma mensagem "STATE" e uma mensagem "WAI-
TING"?
.............................................................
.............................................................

4.10 Trabalhar com diálogos
Descrição de um
diálogo definido
por usuário
Fig. 4-11: Diálogo
 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álogos são apropriados para exibir perguntas, que o usuário precisar
diálogo definido responder.
pelo usuário  Com a função Set_KrlDlg( ) é emitido um diálogo.
 A função simplesmente emite o diálogo.
 Ela não aguarda até que ele 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.
Fig. 4-12: Diálogo
Avaliação dos botões

 Declaração e inicialização dos botões

DECL KRLMSGDLGSK_T Softkey[7] ; Preparar 7 possíveis softkeys

 Avaliação via Exists_KrlDlg(): o botão, que foi criado sob o index 4,

também fornece o 4 como feedback.
; softkey n° 4 dá como feedback 4
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.

diálogos 2. Declarar variáveis de trabalho para:
definidos pelo  remetente, número da mensagem, texto de mensagem (de
usuário KrlMsg_T)
 7 possíveis botões (de KrlMsgDlgSK_T)
 variável para o resultado da resposta de qual botão foi pressionado
(como INT)
4. Programar o acesso de função Set_KrlDlg(…).
5. Parar o programa com um loop, até que o diálogo esteja respondido.
6. Avaliar o diálogo com o acesso de função Exists_KrlDlg( ).
7. Planejar e programar outras derivações no programa.

Fig. 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.
DECL KRLMSG_T myQuestion

DECL KRLMSGDLGSK_T Softkey[7] ;Preparar 7 possíveis softkeys
DECL INT handle, answer
DECL BOOL present
...
myQuestion={modul[] "College", Nr 1909, msg_txt[] "My Questiontext"}

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

...; 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
...
...
CASE 7 ; Botão 7
ENDSWITCH
...
4.11 Exercício: Programar diálogo
 programar mensagens próprias de informação, status e confirmação
 programar consultas próprias de diálogo
Definição de Tarefa parcial 1: Mensagem de diálogo

tarefas 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.
1. Como são inscritas as teclas das softkeys no diálogo?
.............................................................
.............................................................

5 Programação de Interrupt
5.1 Programação de rotinas de Interrupt
Descrição de
rotinas de cance-
lamento
Fig. 5-1: Trabalhar com rotinas Interrupt
 Em um evento definido, p.ex., uma entrada, a unidade de comando inter-

rompe o programa atual e executa um subprograma definido.
 Um subprograma, que é acessado por um Interrupt, é chamado de pro-
grama Interrupt.
 Podem estar declarados, no máximo, 32 Interrupts ao mesmo tempo.
 Simultaneamente, podem estar ativos, no máximo, 16 Interrupts.
Passos importantes ao usar o Interrupt
 Declaração de Interrupt
 Ativar/desativar ou bloquear/liberar Interrupt
 se for o caso, parar o robô
 se for o caso, descartar o planejamento da trajetória atual e percorrer
nova trajetória
Princípio da Generalidades sobre a declaração de Interrupts

declaração de  Em um evento definido, p.ex., uma entrada, a unidade de comando inter-
Interrupt rompe o programa atual e executa um subprograma definido.
 O evento e o subprograma são definidos com INTERRUPT ... DECL
... WHEN ... DO ....

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!
Sintaxe da declaração de Interrupt


<GLOBAL> INTERRUPT DECL Prio WHEN Ereignis DO Interruptprogramm

 Global
 Um Interrupt é reconhecido apenas a partir do nível no qual está de-
clarado.
Fig. 5-2: Validade de Interrupts
 Um Interrupt, que foi declarado em um subprograma, não é conhecido

no programa principal (aqui Interrupt 23).
 Um Interrupt com a palavra-chave GLOBAL anteposta na declaração,
também é conhecido nos níveis superiores (aqui Interrupt 2).

<GLOBAL> INTERRUPT DECL Prio WHEN Ereignis DO Unterprogramm
 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-3: Prioridades de Interrupts
<GLOBAL> INTERRUPT DECL Prio WHEN Ereignis DO Unterprogramm
 Evento: Evento, que deve ocorrer no Interrupt.
Este evento é reconhecido em sua ocorrência através de um flanco

(disparado por flanco).
 Programa Interrupt
 Nome do programa Interrupt, que deve ser processado.
 Este subprograma é chamado de programa Interrupt.
 As variáveis de tempo de execução não podem ser entregues como
parâmetro ao programa Interrupt
 São permitidas variáveis, que estão declaradas em uma lista de da-
dos.
 Exemplo: Declaração de um Interrupt
INTERRUPT DECL 23 WHEN $IN[12]==TRUE DO INTERRUPT_PROG(20,VALUE)
 nenhum Interrupt global

 Prioridade: 23
 Evento: entrada 12 flanco positivo
 Programa Interrupt: INTERRUPT_PROG(20,VALUE)

Após a declaração um Interrupt primeiramente está desativado. O In-

terrupt deve ser ativado antes que o evento definido possa ser reagi-
do!
Descrição ligar/ Após uma declaração de Interrupt, este deve ser ativado em seguida.
desligar/ Possibilidades através do comando INTERRUPT ...
bloquear/liberar
 Ativa um Interrupt.
Interrupt
 Desativa um Interrupt.
 Bloqueia um Interrupt.
 Libera um Interrupt.

Sintaxe
 INTERRUPT Ação <Número>
Ação
 ON: Ativa um Interrupt.
 OFF: Desativa um Interrupt.
 DISABLE: Bloqueia um Interrupt ativado.
 ENABLE: Libera um Interrupt bloqueado.
Número
 Número (=prioridade) do Interrupt, ao qual a ação deve se referir.
 O número pode ser suprimido.
Neste caso ON ou OFF referem-se a todos os Interrupts declarados,
DISABLE ou ENABLE a todos os Interrupts ativos.
Interrupt - ativar e desativar
INTERRUPT DECL 20 WHEN $IN[22]==TRUE DO SAVE_POS( )
...
INTERRUPT ON 20
;O Interrupt é detectado e executado (flanco positivo)
...
INTERRUPT OFF 20 ; Interrupt está desligado
Neste caso, o Interrupt é ativado por uma mudança do estado,

p.ex., em $IN[22]==TRUE através da troca de FALSE para TRUE.
Portanto, o estado não pode já existir no INTERRUPT ON, pois o In-
terrupt não seria ativado!
 Neste caso deve ser observado adicionalmente o seguinte: A mudança
de estado pode ocorrer somente um ciclo de interpolação depois do IN-
TERRUPT ON.
(Isto pode ser obtido, programando-se um WAIT SEC 0.012 após o IN-
TERRUPT ON. Se não for desejada uma parada de avanço, pode ser
programado adicionalmente um CONTINUE antes do WAIT SEC.)
O motivo é que o INTERRUPT ON necessita de um ciclo de interpolação
(= 12ms), até que o Interrupt esteja de fato ativado. Se o estado mudar
antes, o Interrupt não consegue identificar a mudança.
Interrupt - ativar e desativar: Duplo comando de teclas
Quando existe o risco de um Interrupt acionado incorretamente em

duplicidade por causa de sensores hipersensíveis ("duplo comando
de teclas"), você pode impedir isto através da desativação do Inter-
rupt na primeira linha do programa Interrupt.
No entanto, nesse caso, também não é mais detectado um Interrupt real,
que ocorre durante o processamento do Interrupt. Se desejar que o Interrupt
continue ativo, é necessário reativá-lo antes do retorno.
Interrupt – bloquear e liberar

INTERRUPT DECL 21 WHEN $IN[25]==TRUE DO INTERRUPT_PROG( )

...
INTERRUPT ON 21
;O Interrupt é detectado e executado imediatamente (flanco positivo)
...
INTERRUPT DISABLE 21
;O Interrupt é detectado e salvo, mas não executado (flanco
positivo)
...
INTERRUPT ENABLE 21
; Interrupts armazenados são executados somente agora
...
INTERRUPT OFF 21 ; Interrupt está desligado
...
Um Interrupt bloqueado é detectado e gravado. A execução ocorre

diretamente após a liberação do Interrupt. Aqui deve-se observar a
isenção de colisão em movimentos.
Descrição frear Frear o robô

robô ou cancelar  Um robô deve parar imediatamente após a ocorrência de um evento.
movimentos de
 Para parar estão disponíveis duas rampas de frenagem (STOP 1 e STOP
deslocamento 2).
atuais com rotina  O programa Interrupt somente é continuado depois que o robô parar.
de Interrupt
 Tão logo o programa Interrupt esteja concluído, é continuado o movimen-
to do robô iniciado.
 Sintaxe:
 BRAKE: STOP 2
 BRAKE F: STOP 1
BRAKE somente pode ser usado com um programa Interrupt.
Movimentos e rotinas de Interrupt

 O robô opera em paralelo, até que a rotina de Interrupt esteja processada
Fig. 5-4: Processamento de rotinas Interrupt

Se o tempo para o processamento da rotina de Interrupt for menor

que o planejamento da trajetória feito no programa principal, o robô
pode mover sem interrupção. Se o tempo necessário da rotina de In-
terrupt for maior que a trajetória planejada, o robô para no final do seu pla-
nejamento da trajetória e se move tão logo a rotina de Interrupt tenha sido
executada totalmente.
 Não são permitidos formulários Inline para a inicialização (INI) ou para

movimentos (p.ex. PTP ou LIN ...). No processamento eles resultam em
mensagens de erro.
 O robô é parado com BRAKE e, no final da rotina de Interrupt continua com
a trajetória planejada do programa principal.
 O robô é parado com BRAKE e deslocado na rotina de Interrupt. Após o
término da rotina de Interrupt é continuada a trajetória do programa prin-
cipal.
Aqui deve ser observada a isenção de colisão!

Se isto não for observado, as consequências podem ser
morte, lesões corporais ou danos materiais.
 O robô é parado com BRAKE e deve executar uma nova trajetória após o
término da rotina de Interrupt. Isto pode ser realizado com o comando RE-
SUME.
 O robô é parado com BRAKE e deslocado na rotina de Interrupt. Após o
término da rotina de Interrupt, a trajetória atual não deve mais ser conti-
nuada e deve ser realizado um novo planejamento de trajetória. Isto tam-
bém pode ser realizado com o comando RESUME.
Depois que não é possível estimar com precisão quando

o Interrupt vai ser ativado, deve ser possível, em todas
as possíveis posições do deslocamento atual do robô, um movimento sem
colisão dentro da rotina de Interrupt e do deslocamento subsequente.
Se isto não for observado, as consequências podem ser morte, lesões cor-
porais ou danos materiais.
Cancelar o movimento de deslocamento atual com RESUME

 RESUME cancela todos os programas Interrupt em curso e todos os sub-
programas até o nível em que o Interrupt atual foi declarado.
 No momento da instrução RESUME, o indicador de avanço não pode estar
no nível em que o Interrupt foi declarado, mas deve se encontrar, no mí-
nimo, em um nível abaixo deste.
 RESUME somente pode ocorrer com programas Interrupt.
 Tão logo um Interrupt tenha sido declarado como GLOBAL, não é permiti-
do usar nenhum RESUME na rotina de Interrupt.
 Alterações da variável $BASE no programa Interrupt atuam somente lá.
 O avanço do computador, isto é, a variável $ADVANCE, não pode ser al-
terado no programa Interrupt.
 Movimentos de deslocamento, que devem ser interrompidos com BRAKE
e RESUME, sempre devem ser programados em um subprograma.
 O comportamento da unidade de comando do robô após RESUME depen-
de da seguinte instrução de movimento:
 Instrução PTP: É deslocado como movimento PTP.
 Instrução LIN: É deslocado como movimento LIN.
 Instrução CIRC: Sempre é deslocado como movimento LIN!
Após um RESUME o robô não se encontra no ponto de partida original
do movimento CIRC. O movimento ocorreria de forma diferente do

que originalmente planejado, o que abriga um potencial de perigo con-

siderável, especialmente em movimentos CIRC.
Se a primeira instrução de movimento após RESUME é

um movimento CIRC, este sempre é executado como
LIN! Este comportamento deve ser levado em consideração na programa-
ção de instruções RESUME. O robô deve poder acessar o ponto de destino
do movimento CIRC sem perigo como LIN, a partir de qualquer posição na
qual ele poderia se encontrar no RESUME.
Se isto não for observado, as consequências podem ser morte, ferimentos
ou danos materiais.
 Variáveis de sistema úteis em uma parada exata
Fig. 5-5: Variáveis de sistema na parada exata
 Variáveis de sistema úteis em uma aproximação
Fig. 5-6: Variáveis de sistema na aproximação
Programação de Processamento da lógica paralelamente ao movimento do robô

rotinas Interrupt 1. Declaração de Interrupt
 Definir a prioridade
 Determinar o evento de disparo
 Definir e criar rotina de Interrupt
DEF MY_PROG( )
INI
INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( )
END
_________________________________________________
DEF ERROR()
END
2. Ativar e desativar Interrupt

DEF MY_PROG( )
INI
INTERRUPT ON 25
...
...
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR()
END
3. Expandir o programa com movimentos e definir ações na rotina de Inter-

rupt
DEF MY_PROG( )
INI
INTERRUPT ON 25
PTP P1 Vel=100% PDAT1
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR()
$OUT[20]=FALSE
$OUT[21]=TRUE
END
Processamento da lógica depois que o robô foi parado e depois conti-

nuar o movimento do robô
1. Declaração de Interrupt
 Ativar e desativar Interrupt
DEF MY_PROG( )
INI
INTERRUPT ON 25
...
...
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR()
END
2. Expandir o programa com movimentos e frear o robô na rotina de Interrupt

e definir a lógica

DEF MY_PROG( )
INI
INTERRUPT ON 25
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR()
BRAKE
$OUT[20]=FALSE
$OUT[21]=TRUE
END
Parar os movimentos atuais do robô, reposicionar, descartar o planeja-

mento da trajetória e percorrer uma nova trajetória
1. Declaração de Interrupt
DEF MY_PROG( )
INI
...
END
_________________________________________________
DEF ERROR()
...
END
2. Expandir o programa com movimentos

 para poder cancelar, o movimento deve ocorrer em um subprograma
 O indicador de avanço deve permanecer no subprograma
 Ativar e desativar Interrupt
DEF MY_PROG( )
INI
SEARCH()
END
_________________________________________________
DEF SEARCH()
INTERRUPT ON 25
WAIT SEC 0 ; Parar o ponteiro de avanço
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR()
...
END
3. Processar a rotina de Interrupt

 Parar robô
 Reposicionar o robô para $POS_INT

 Descartar o movimento atual

 Novo movimento no programa principal
DEF MY_PROG( )
INI
SEARCH()
END
_________________________________________________
DEF SEARCH()
INTERRUPT ON 25
WAIT SEC 0 ; Parar o ponteiro de avanço
INTERRUPT OFF 25
END
_________________________________________________
DEF ERROR()
BRAKE
PTP $POS_INT
RESUME
END
5.2 Exercício: Trabalhar com Interrupts
 Declaração de um Interrupt
 Criação de um subprograma Interrupt
 Avaliação e edição de Interrupts na execução do programa
te exercício:
 conhecimentos teóricos sobre a programação de Interrupts
Definição de O objetivo desta tarefa é, através de deslocamento de medição definido, de-

funções tectar a posição de 3 cubos e salvar estas posições.
1. Crie um novo programa com o nome "LOCALIZAR".
2. Retire (sem o robô) três cubos do magazine de cubos e coloque-os em
uma linha sobre a mesa.
3. Faça o teach de um movimento LIN como deslocamento de localização
pelos três cubos. A velocidade deve ser definida em 0,2 m/s.
4. É necessário ativar ou desativar o sensor com a saída 27. Como feedback
da determinação de posição você recebe um sinal na entrada 27.
5. Ao detectar um cubo a saída 10 deve ser comutada por 1 segundo. Ao
mesmo tempo, deve ser salva a posição na detecção. Para isto, use um
campo, que você cria no DAT-file local ou no $config.dat.
6. Após o deslocamento de localização, as três posições salvas devem ser
exibidas através de acesso, isto é, acessar a posição, aguardar 1 segun-
do, e então ir à posição seguinte.
1. Em qual parte do programa é declarado o Interrupt?
.............................................................

............................................................
2. Qual é a diferença entre INTERRUPT OFF 99 e INTERRUPT DISABLE 99?
............................................................
............................................................
............................................................
............................................................
3. Quando é acessado o subprograma Interrupt?
............................................................
............................................................
4. O que faz o comando INTERRUPT OFF no início de um subprograma In-
terrupt?
............................................................
............................................................
5. Qual área de prioridade para o Interrupt não está liberada?
............................................................
............................................................

5.3 Exercício: Cancelar movimentos de deslocamento com Interrupts
 Declaração de um Interrupt
 Criação de um subprograma Interrupt
 Avaliação e edição de Interrupts na execução do programa
 Frear o movimento do robô com comando KRL
 Frear e cancelar o movimento do robô com comandos KRL
te exercício:
 conhecimentos teóricos sobre a programação de Interrupts
 conhecimentos teóricos sobre os comandos KRL para frear e cancelar
movimentos do robô e o seu uso correto
Definição de Através de deslocamento de medição definido você deve poder identificar a

funções posição de 3 cubos e salvar estas posições. Além disso, o deslocamento de
medição deve ser cancelado imediatamente após a detecção do 3° cubo.
1. Duplique o seu programa LOCALIZAR e atribua o nome
"SUCHEN_ABBRUCH" (CANCELAR LOCALIZAR).
2. Retire (sem o robô) três cubos do magazine de cubos e coloque-os em
uma linha sobre a mesa.
3. Faça o teach de um movimento LIN como deslocamento de localização
pelos três cubos. A velocidade deve ser definida em 0,2 m/s. É necessário
ativar ou desativar o sensor com a saída 27. Como feedback da determi-
nação de posição você recebe um sinal na entrada 27.
4. Ao detectar um cubo a saída 10 deve ser comutada por 1 segundo. Ao
mesmo tempo, deve ser salva a posição na detecção. Para isto, use um
campo, que você cria no DAT-file local.
5. Imediatamente após a localização do terceiro cubo o robô deve ser para-
do e o deslocamento de localização cancelado.
6. Após o deslocamento de localização, as três posições salvas devem ser
exibidas através de acesso, isto é, acessar a posição, aguardar 1 segun-
do, e então ir à posição seguinte.
7. Teste o seu programa conforme a prescrição
1. Qual é a diferença entre BRAKE e BRAKE F?
.............................................................
.............................................................
2. Por que o comando RESUME não funciona corretamente aqui?
INTERRUPT DECL 21 WHEN $IN[1] DO located( )
INTERRUPT ON 21
Pto_inic LIN
Pto_final LIN
$ADVANCE = 0
INTERRUPT OFF 21 ...
END
___________________________________________
DEF located( )
INTERRUPT OFF 21
BRAKE
;pick_part

RESUME
END
3. Quando é acionado um Interrupt?
............................................................
............................................................


6 Programar a estratégia de retrocesso
6.1 Programar estratégias de retrocesso
O que é uma Após a criação de um programa de execução e o seu teste no uso prático,
estratégia de sempre se faz adicionalmente a pergunta de como o programa reage a falhas.
retrocesso? Naturalmente, o desejado em caso de uma falha é a reação automática do
sistema.
Para isto se usam estratégias de retrocesso.
Por uma estratégia de retrocesso entendem-se movimentos de retrocesso
que o robô executa em caso de uma falha para, por exemplo, poder voltar au-
tomaticamente à posição inicial, independente de onde ele se encontra no
momento.
Estes movimentos de retrocesso devem ser livremente programados pelo
programador.
Onde são As estratégias de retrocesso são usadas lá onde se deseja atingir uma auto-
aplicadas estra- mação plena de uma célula de produção (também em caso de uma falha).
tégias de retro- Uma estratégia de retrocesso corretamente programada oferece ainda ao
cesso? operador somente a possibilidade de decidir, o que deve ocorrer na continui-
dade da execução.
Assim é possível contornar um deslocamento manual para sair de uma situa-
ção de risco.
Fig. 6-1
Como se  Criar a zona de movimento em áreas de trabalho

programa uma  Configurar IOs
estratégia de  Declarar Interrupts
retrocesso?  Salvar posições
 Programar mensagens de usuário
 Se for o caso, definir posições Home
 Se for o caso, usar pontos globais

Fig. 6-2
Fig. 6-3
6.2 Exercício: Programar a estratégia de retrocesso
 Programação de movimentos de retrocesso automáticos
 Inclusão de mensagens em um processo de trabalho
 Identificação de falhas sob utilização de Interrupts
 finalização do movimento do robô em função do processo
te exercício:

 Conhecimentos sobre a programação de mensagens

 Conhecimentos sobre a programação de Interrupts
 Conhecimentos sobre os comandos KRL para frear e cancelar o movi-
mento do robô e o seu uso correto
 conhecimentos teóricos sobre o comando Trigger
Definição de O programa base consiste em retirar o cubo do magazine e recolocá-lo no

funções magazine. Através de uma entrada (n° 11) é removida a liberação do PLC. O
robô deve ser parado imediatamente. Através de uma pergunta o operador
deve decidir, se o robô vai para a posição inicial ou se o procedimento é con-
tinuado. Em todo o caso o robô somente pode mover depois da decisão, se a
liberação estiver novamente disponível e esta falha estiver confirmada. Se for
escolhida a posição inicial, este deslocamento ocorre com velocidade reduzi-
da (POV = 10%). Na posição inicial é perguntado se o equipamento está pron-
to. Caso "sim", pode ser continuado com o override de programa, que estava
ajustado antes da falha. Com "não", o programa é finalizado.
Fig. 6-4
1. Inicie com a criação do fluxograma do programa.

2. Na realização para a estrutura de programa, observe a estruturação do
seu conceito geral.
3. O objetivo do projeto é a programação limpa e visualizável, e a funciona-
lidade dos programas ou módulos.
4. Na atribuição de nomes de arquivo e de variáveis, observe a sua fácil
compreensão.
5. Tome o cuidado, para que você possa retornar a todo instante à posição
inicial sem colisões.
6. Na reinicialização a partir da posição inicial, cuide para que seja executa-
do o procedimento correto (buscar ou depositar) em função da posição da
garra. Nota: Entrada 26 significa que a garra está aberta.
1. Com qual comando de especialistas podem ser comutadas variáveis defi-
nidas pelo usuário na trajetória?

.............................................................
.............................................................
2. Como é o comando KRL para a finalização imediata de um subprograma e
de um subprograma Interrupt?
.............................................................
.............................................................
3. Qual é o sentido de um deslocamento SAK?
.............................................................
.............................................................
4. Com qual variável você pode influenciar o override de programa?
.............................................................
.............................................................
5. O que pode ser comutado adicionalmente com o comando trigger em com-
paração com o formulário Inline SYNOUT?
.............................................................
.............................................................

7 Trabalhar com sinais analógicos
7.1 Programar entradas analógicas
Descrição
Fig. 7-1: Sinais analógicos
 A KR C4 dispõe de mais de 32 entradas analógicas.

 Para os sinais analógicos é necessário um sistema de bus opcional e
deve ser projetado via WorkVisual.
 Entradas analógicas são lidas através das variáveis de sistema
$ANIN[1] ... $ANIN[32].
 Leitura cíclica (a cada 12ms) de uma entrada analógica.
 Os valores em $ANIN[nr] movem-se entre 1,0 e -1,0 e representam a
tensão de entrada de +10 V a -10 V.
Função Atribuição estática de valores

 atribuição direta de valores
...
REAL value
value = $ANIN[2]
...
 Atribuição de valores de um acordo de sinais

...
SIGNAL sensor $ANIN[6]
REAL value
value = sensor
...
Atribuição dinâmica de valores

 Todas as variáveis utilizadas em uma instrução ANIN devem estar decla-
radas em listas de dados (localmente ou no $CONFIG.DAT).
 São permitidas, no máximo, três instruções ANIN ON simultaneamente.
 No máximo duas instruções ANIN ON podem usar a mesma variável Valor
ou acessar a mesma entrada analógica.
 Sintaxe
 Iniciar leitura cíclica:
ANIN ON valor = fator * nome do sinal <±Offset>

Elemento Descrição
Valor Tipo: REAL
Em Valor é gravado o resultado da leitura cíclica. Valor
pode ser uma variável ou um nome do sinal para uma
saída.
Fator Tipo: REAL
Fator qualquer. Pode ser uma constante, uma variável ou
um nome do sinal.
Nome do Tipo: REAL
sinal
Indica a entrada analógica. Nome do sinal deve ter sido
declarado anteriormente com SINAL. Não é possível indi-
car, em vez do nome do sinal, diretamente a entrada ana-
lógica $ANIN[x].
Os valores de uma entrada analógica $ANIN[x] movem-se
entre +1.0 e -1.0 e representam uma tensão de +10 V até
-10 V.
Offset Tipo: REAL
Pode ser uma constante, uma variável ou um nome do
sinal.
 Finalizar a leitura cíclica:

ANIN OFF nome do sinal
 Exemplo 1
DEFDAT myprog
DECL REAL value = 0
ENDDAT
DEF myprog( )
...
ANIN ON value = 1.99*sensor-0.75
...
ANIN OFF sensor
 Exemplo 2
DEFDAT myprog
DECL REAL value = 0
DECL REAL corr = 0.25
DECL REAL offset = 0.45
ENDDAT
DEF myprog( )
...
ANIN ON value = corr*sensor-offset
...
ANIN OFF sensor
Procedimento na
O pré-requisito para o uso dos sinais analógicos é uma
programação projeção correta do sistema de bus com os sinais analó-
com entradas gicos conectados.
analógicas
Programação de ANIN ON /OFF
1. Seleção da entrada analógica correta
2. Realização do acordo de sinais
3. Declaração das variáveis necessárias em uma lista de dados
4. Ligar: Programação da instrução ANIN ON

5. Teste para verificar se, no máximo, 3 entradas dinâmicas estão ativas

6. Desligar: Programação da instrução ANIN OFF
7.2 Programar saídas analógicas
Descrição
Fig. 7-2: Sinais analógicos
 A KR C4 dispõe de 32 saídas analógicas.

 Para os sinais analógicos é necessário um sistema de bus opcional e
deve ser projetado via WorkVisual.
 Entradas analógicas são lidas através das variáveis de sistema
$ANOUT[1] ... $ANOUT[32].
 Gravação cíclica (a cada 12ms) em uma saída analógica
 Os valores $ANOUT[nr] movem-se entre 1,0 e -1,0 e representam a ten-
são de saída de +10 V a -10 V.
Função
Podem ser utilizadas no máximo 8 saídas analógicas
(estáticas e dinâmicas) ao mesmo tempo. ANOUT ativa
uma parada de avanço.
Atribuição estática de valores

 atribuição direta de valores
...
ANOUT[2] = 0.7 ; 7 V na saída analógica 2
...
 atribuição de valores através de variáveis

...
REAL value
value = -0.8
ANOUT[4] = value ; -8 V na saída analógica 4
...
 programação através de formulários Inline
Fig. 7-3: Formulário Inline ANOUT estático

Pos. Descrição
1 Número da saída analógica
 CHANNEL_1 … CHANNEL_32
2 Fator para a tensão
 0 … 1 (Escalonamento: 0.01)
Atribuição dinâmica de valores

 Todas as variáveis utilizadas em uma instrução ANOUT devem estar de-
claradas em listas de dados (localmente ou no $CONFIG.DAT).
 São permitidas, no máximo, quatro instruções ANOUT ON simultanea-
mente.
 ANOUT ativa uma parada de avanço.
 Sintaxe
 Iniciar gravação cíclica:
DelayANOUT ON nome do sinal = fator * elemento regulador <±Offset>
<DELAY = ±tempo> <MÍNIMO = valor mínimo> <MÁXIMO = valor
máximo>
Elemento Descrição
Nome do Tipo: REAL
sinal
Indica a saída analógica. Nome do sinal deve ter sido decla-
rado anteriormente com SINAL . Não é possível indicar,
em vez do nome do sinal, diretamente a saída analógica
$ANOUT[x].
Os valores de uma saída analógica $ANOUT[x] movem-se
entre +1.0 e -1.0 e representam uma tensão de +10 V até
-10 V.
Fator Tipo: REAL
Fator qualquer. Pode ser uma constante, uma variável ou
um nome do sinal.
Elemento Tipo: REAL
regulador
sinal.
Offset Tipo: REAL
sinal.
Horário Tipo: REAL
Unidade: Segundos. Com a palavra-chave DELAY e uma
indicação de tempo positiva ou negativa o sinal de saída
pode ser emitido com retardo (+) ou antecipado (-).
Valor mínimo, Tipo: REAL
Valor máximo
Tensão mínima e/ou máxima, que deve estar aplicada na
saída. Não fica abaixo nem é ultrapassada, mesmo que os
valores calculados estejam abaixo ou acima.
Valores admissíveis: -1.0 até +1.0 (corresponde a -10 V
até +10 V).
Pode ser uma constante, uma variável, um componente
estrutural ou um elemento de campo. Em todo o caso, o
valor mínimo deve ser menor que o valor máximo. A
sequência das palavras-chave MÍNIMO e MÁXIMO deve
ser mantida.

 Finalizar a gravação cíclica:

ANOUT OFF nome do sinal
 Exemplo 1
DEF myprog( )
SIGNAL motor $ANOUT[3]
...
ANOUT ON motor = 3.5*$VEL_ACT-0.75 DELAY=0.5
...
ANOUT OFF motor
 Exemplo 2
DEFDAT myprog
DECL REAL corr = 1.45
DECL REAL offset = 0.25
ENDDAT
DEF myprog( )
...
ANOUT ON motor = corr*$VEL_ACT-offset
...
ANOUT OFF motor
Procedimento na
O pré-requisito para o uso dos sinais analógicos é uma
programação projeção correta do sistema de bus com os sinais analó-
com entradas gicos conectados.
analógicas
Programação de ANOUT ON /OFF
1. Seleção da saída analógica correta
2. Realização do acordo de sinais
3. Declaração das variáveis necessárias em uma lista de dados
4. Ligar: Programação da instrução ANOUT ON
5. Teste para verificar se, no máximo, 4 saídas dinâmicas estão ativas
6. Desligar: Programação da instrução ANOUT OFF
Exemplo:
Fig. 7-4: Exemplo de sinal de saída analógico
DEF myprog( )
...
ANOUT ON motor = 3.375*$VEL_ACT MINIMUM=0.30 MAXIMUM=0.97
...
ANOUT OFF motor

7.3 Exercício: Trabalhando com E/Ss analógicas
 Uso de acordos de sinais em entradas/saídas
 inclusão estática ou dinâmica de entradas analógicas em processos de
trabalho
 inclusão estática ou dinâmica de saídas analógicas em processos de tra-
balho
te exercício:
 conhecimentos teóricos de acordos de sinais
 conhecimentos teóricos sobre a inclusão de entradas/saídas analógicas
Definição de Configure o seu sistema de tal forma, que você possa alterar o override de
funções programa através da entrada analógica. Adicionalmente a velocidade de robô
efetivamente percorrida deve controlar uma saída analógica.
Tarefa parcial 1
1. Crie um programa com o nome Velocidade.
2. Use a entrada analógica 1, que é controlada pelo potenciômetro.
3. Adapte o override de programa no Interpretador Submit.
Tarefa parcial 2
1. Expanda o seu programa com movimentos de trajetória (velocidade: até
2 m/s), que estão em um loop sem fim.
2. Use a saída analógica 1, da indicação do painel.
3. Use a variável de sistema $VEL_ACT para a velocidade atualmente exe-
cutada.
5. Adicionalmente: Se a velocidade for menor que 0,2 m/s a saída deve mes-
mo assim ser sujeitada com 1,0 V e se a velocidade foi maior que 1,8 m/
s a saída não deve emitir mais que 9,0 V.
Tome o cuidado para ativar somente uma vez a E/S analógica.

1. Quantas E/S analógicas podem ser usadas na unidade de comando KRC?
.............................................................
.............................................................
2. Quantas entradas digitais, entradas analógicas e saídas analógicas prede-
finidas a unidade de comando KUKA pode usar simultaneamente?
.............................................................
.............................................................
3. Como se chamam os comandos KRL para a inicialização e finalização cí-
clica da saída analógica?
.............................................................
.............................................................
4. Como é consultada estaticamente uma entrada analógica?

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


8 Execução e configuração de Automático externo
8.1 Configurar e usar Automático externo
Descrição
Fig. 8-1: Conexão de PLC
 Com a interface Automático externo os processos de robô são controla-

dos por uma unidade de comando superior (p.ex. por um PLC).
 Através da interface Automático externo, a unidade de comando superior
transmite à unidade de comando do robô os sinais para os processos do
robô (p. ex., liberação de deslocamento, confirmação de erro, início de
programa, etc.). A unidade de comando do robô transmite à unidade de
comando superior informações sobre os estados de operação e de falha.
Para poder utilizar a interface Automático externo, é necessário efetuar as se-
guintes configurações:
1. Configurar programa CELL.SRC.
2. Configurar entradas/saídas da interface Automático externo.
Uso de entradas/ Visão geral sobre os principais sinais da interface

saídas da
interface
Automático
externo

Fig. 8-2: Visão geral dos principais sinais Automático externo
Entradas (do ponto de vista da unidade de comando do robô)

 PGNO_TYPE - tipo de número de programa
Esta variável determina em qual formato o número de programa transmi-
tido da unidade de comando superior será carregado.
Valor Descrição Exemplo
1 Gravar como número binário. 00100111
O número de programa é transmitido pela => PGNO = 39
unidade de comando superior como valor
inteiro binário codificado.
2 Gravar como valor BCD. 00100111
unidade de comando superior como valor
decimal binário codificado.
3 Gravar como "1 de N"*. 00000001
unidade de comando superior ou pela peri-
00001000
feria como valor codificado "1 de N".
=> PGNO = 4
* Neste formato de transferência, os valores de PGNO_REQ,

PGNO_PARITY e PGNO_VALID não são avaliados sendo, por isso, sem
importância.
 PGNO_LENGTH - tamanho de número de programa
Esta variável determina a largura de bit do número de programa transmi-
tido pela unidade de comando superior. Faixa de valores: 1 … 16.
Se PGNO_TYPE tem o valor 2, são permitidas somente as larguras de bit
4, 8, 12 e 16.
 PGNO_PARITY - bit de paridade de número de programa
Entrada, para a qual o bit de paridade é transmitido pela unidade de co-
mando superior.

Entrada Função
Valor negativo Paridade ímpar
0 Sem avaliação
Valor positivo Paridade par
Se PGNO_TYPE tem o valor 3, PGNO_PARITY não é avaliado.

 PGNO_VALID - número de programa válido
Entrada para a qual o comando para a gravação do número de programa
é transmitido pela unidade de comando superior.
Entrada Função
Valor negativo O número é assumido com o flanco de descida do sinal.
0 O número é assumido com o flanco de subida do sinal
na linha EXT_START.
Valor positivo O número é assumido com o flanco de subida do sinal.
 $EXT_START - partida externa

Com o setamento desta entrada, com a interface de E/S ativada, é possí-
vel iniciar ou continuar um programa (normalmente CELL.SRC).
Somente é avaliado o flanco de subida do sinal.
No modo Automático externo não existe deslocamento

SAK. Isto significa, que o robô acessa a primeira posição
programada após o início com velocidade programada (não reduzida) e não
pára lá.
 $MOVE_ENABLE - Liberação de movimento

Esta entrada é utilizada para o controle dos acionamentos do robô através
da unidade de comando superior.
Sinal Função
TRUE Possibilidade de deslocamento manual e execução do
programa
FALSE Imobilização de todos os acionamentos e bloqueio de
todos os comandos ativos
Se os acionamentos foram imobilizados pela unidade de comando

superior, é exibida a mensagem "LIBERAÇÃO DE MOVIMENTO GE-
RAL". O movimento do robô só é possível novamente depois da ex-
clusão desta mensagem e com um novo sinal de partida externo.
Durante a colocação em funcionamento, a variável

$MOVE_ENABLE é projetada para o valor $IN[1025]. Se depois for
esquecido de projetar uma outra entrada, não é possível uma partida
externa.
 $CONF_MESS - Confirmação de mensagem

Através do setamento desta entrada, a própria unidade de comando su-
perior confirma mensagens de erro, tão logo a causa da falha tenha sido
eliminada.
Somente é avaliado o flanco de subida do sinal.

 $DRIVES_ON - Acionamentos ligados

Quando nesta entrada está presente um pulso High com duração mínima
de 20ms, a unidade de comando superior liga os acionamentos do robô.
 $DRIVES_OFF - Acionamentos desligados
Se nesta entrada houver um pulso Low com duração mínima de 20ms, a
unidade de comando superior desliga os acionamentos do robô.
Saídas (do ponto de vista da unidade de comando do robô)
 $ALARM_STOP - Parada de emergência
Esta saída é resetada nas seguintes situações de PARADA DE EMER-
GÊNCIA:
 O botão de PARADA DE EMERGÊNCIA no KCP é pressionado. (Pa-
radEmergInt)
 PARADA DE EMERGÊNCIA externa
Em uma PARADA DE EMERGÊNCIA é possível detectar nos esta-

dos das saídas $ALARM_STOP e ParadEmergInt, de que tipo de
PARADA DE EMERGÊNCIA se trata:
 As duas saídas são FALSE: A PARADA DE EMERGÊNCIA foi acionada
no KCP
 $ALARM_STOP é FALSE, ParadEmergInt é TRUE: PARADA DE
EMERGÊNCIA externa
 $USER_SAF - Proteção do operador/Porta de proteção

Esta saída é resetada ao abrir o interruptor interrogador da grade de se-
gurança (modo AUTO) ou ao soltar uma das teclas de habilitação (modo
T1 ou T2).
 $PERI_RDY - Acionamentos preparados
Ao setar esta saída, a unidade de comando do robô informa à unidade de
comando superior que os acionamentos do robô estão ligados.
 $STOPMESS - Mensagens de parada
Esta saída é setada pela unidade de comando do robô, para indicar à uni-
dade de comando superior a ocorrência de uma mensagem, que tornou
necessária a parada do robô. (Exemplos: PARADA DE EMERGÊNCIA, li-
beração de movimento ou proteção do operador)
 $I_O_ACTCONF - Automático externo ativo
Esta saída é TRUE, se estiver selecionado o modo Automático externo e
a entrada $I_O_ACT TRUE for TRUE (normalmente sempre em
$IN[1025]).
 $PRO_ACT - Programa está ativo/opera
Esta saída é setada sempre que um processo esteja ativo no nível de ro-
bô. O processo mantém-se ativo, enquanto é processado um programa
ou um Interrupt. O processamento do programa no fim do programa só se
torna inativo, depois que todas as saídas de impulso e triggers estiverem
processados.
 PGNO_REQ - Consulta de número de programa
Através de uma mudança do sinal nesta saída, a unidade de comando su-
perior é solicitada a transmitir um número de programa.
Se PGNO_TYPE tem o valor 3, PGNO_REQ não é avaliado.
 APPL_RUN - Programa de aplicação em execução
Ao setar esta saída, a unidade de comando do robô informa à unidade de
comando superior, que um programa está sendo executado.
 $IN_HOME - Robô em posição HOME
Esta saída informa à unidade de comando superior, se o robô se encontra
na sua posição HOME.

 $ON_PATH - Robô sobre a trajetória

Esta saída mantém-se setada, até que o robô se encontre em sua trajetó-
ria programada. Depois do deslocamento SAK é setada a saída
ON_PATH. Esta saída mantém-se setada, até que o robô saia da trajetó-
ria, até que seja o programa resetado ou até que seja realizada uma se-
leção de passo. O sinal ON_PATH não tem uma janela de tolerância; tão
logo o robô saia da trajetória, este sinal é resetado.
Princípio da Visão geral do fluxo total

comunicação
Automático
externo
Fig. 8-3: Partida automática do equipamento e operação normal com

confirmação do número de programa através de PGNO_VALID
Desmembramento em áreas parciais

1. Ligar os acionamentos
2. Confirmar mensagens
3. Iniciar o programa Cell
4. Fornecer o número de programa e processar a aplicação
Para cada uma destas áreas devem ser atendidas condições, bem como a
possibilidade de informar os estados do robô ao PLC.
Fig. 8-4: Handshake
É adequado usar estes handshakes especificados.

Ligar os acionamentos

Fig. 8-7
 Pré-requisitos
 $USER_SAF - Porta de proteção fechada
 $ALARM_STOP - Não há parada de emergência
 $I_O_ACTCONF - Automático externo está ativo
 $MOVE_ENABLE - Liberação de movimento existente
 $DRIVER_OFF - Acionamentos desligados não está ativado
 Ligar os acionamentos
$DRIVES_ON - Ligar acionamentos por pelo menos 20ms
 Acionamentos preparados
$PERI_RDY - Tão logo chegue o feedback para acionamentos, é cance-
lado o sinal $DRIVES_ON
Confirmar mensagens
Fig. 8-11
 Pré-requisitos
$STOPMESS - Há uma mensagem de parada
 Confirmar mensagem
$CONF_MESS - Confirmar mensagem
 Mensagens confirmáveis estão excluídas
$STOPMESS - A mensagem de parada não existe mais, $CONF_MESS
agora pode ser cancelado
Iniciar programa (CELL.SRC) externamente

Fig. 8-16
 Pré-requisitos
 $PERI_RDY - Acionamentos estão preparados
 $IN_HOME - Robô está na posição HOME
 sem $STOPMESS - Não há mensagem de parada
 Partida externa
$EXT_START- Ligar partida externa (flanco positivo)
 Programa CELL em execução
 $PRO_ACT - Informa programa CELL em execução
 $ON_PATH - Tão logo o robô se encontre em sua trajetória programa-
da, o sinal $EXT_START é cancelado
Processar transferência de número de programa e programa aplicativo
Fig. 8-23
 Pré-requisitos
 $PERI_RDY - Acionamentos estão preparados
 $PRO_ACT - Programa CELL em execução
 $ON_PATH - Robô sobre a trajetória
 $IN_HOME - Robô está na posição HOME, não necessário na reini-
cialização
 PGNO_REQ - Há uma consulta de número de programa
 Transmissão de número de programa e confirmação
 Entrega de número de programa

(tipo de dados correto (PGNO_TYPE), tamanho de número de progra-

ma (PGNO_LENGTH) e primeiro bit para número de programa
(PGNO_FBIT) ajustados)
 PGNO_VALID- Comutar número de programa válido (confirmação)
(flanco positivo)
 Programa aplicativo em execução
 APPL_RUN - informa programa aplicativo em execução
 O robô sai da posição HOME. Ao finalizar o programa aplicativo o robô
retorna novamente à posição HOME.
Procedimento 1. No menu principal, selecionar Configuração > Entradas/saídas > Auto-

mático externo.
2. Na coluna Valor, marcar a célula que deve ser processada e então pres-
sionar Editar.
3. Introduzir o valor desejado e salvar com OK .
4. Repetir os passos 2 e 3 para todos os valores a serem editados.
5. Fechar a janela. As alterações são assumidas.
Fig. 8-26: Configuração entradas Automático externo
Pos. Descrição
1 Número
2 Nome de texto descritivo da entrada/saída
3 Tipo
 Verde: Entrada/Saída
 Amarelo: Variável ou variável de sistema ($...)
4 Nome do sinal ou da variável

Pos. Descrição
5 Número de entrada/saída ou número de canal
6 As saídas são divididas nas guias de acordo com o tema.
Fig. 8-27: Configuração saídas Automático externo
8.2 Exercício: Automático externo
 Inclusão objetiva de um programa de robô no modo Automático externo
 Adaptação do programa "Cell"
 Configuração da interface Automático externo
 Conhecer a execução do modo Automático externo
te exercício:
 Conhecimentos sobre o processamento do programa "Cell"
 Conhecimentos sobre a configuração da interface Automático externo
 conhecimentos teóricos sobre o fluxo de técnica de sinais no Automático
externo
Definição de 1. Configure a interface Automático externo de acordo com as especifica-

funções ções do seu console de operação.
2. Expanda o seu programa Cell em 3 módulos quaisquer, cuja função você
assegurou anteriormente.
3. 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.
4. Simule via botão a funcionalidade do comando PLC.

1. Qual pré-requisito é necessário, para que PGNO_REQ não seja avaliado?

.............................................................
.............................................................
2. Com qual sinal os acionamentos são ligados e o que deve ser observado
aqui?
.............................................................
.............................................................
3. Qual variável da interface Automático externo também tem efeito sobre o
deslocamento manual?
.............................................................
.............................................................
4. Qual pasta a posição HOME verifica no programa CELL?
.............................................................
.............................................................
5. Quais pré-requisitos são necessários para o modo Automático externo?
.............................................................
.............................................................

9 Programar a detecção de colisão
9.1 Programar movimentos com detecção de colisões
Descrição
Fig. 9-1: Colisão
É usado um monitoramento dos momentos do eixo na robótica para detectar

se o robô colidiu com um objeto. Na maioria dos casos, esta colisão não é de-
sejada e pode resultar na destruição do robô, da ferramenta ou de componen-
tes.
Monitoramento de colisão
 Quando um robô colide com um objeto, a unidade de comando do robô
aumenta os momentos do eixo, para superar a resistência. Com isto o ro-
bô, a ferramenta ou outras partes podem ser danificados.
 A detecção de colisão reduz o risco e a gravidade de tais danos. Ela mo-
nitora os momentos de eixo.
 O usuário pode determinar como deve ser procedido após uma colisão,
depois que o algoritmo detectou uma colisão e parou o robô
 O robô para com um STOP 1.
 A unidade de comando do robô acessa o programa tm_useraction.
Ele se encontra na pasta Programa e contém a instrução PARAR. Al-
ternativamente o usuário pode programar outras reações no progra-
ma tm_useraction.
 A unidade de comando do robô determina automaticamente a faixa de to-
lerância
 Normalmente um programa deve ser executado 2 a 3 vezes, até que a
unidade de comando do robô tenha determinado uma faixa de tolerância
útil na prática.
 Para a faixa de tolerância determinada pela unidade de comando do robô,
o usuário pode definir um offset através da interface de operação
 Quando o robô não é operado por um longo período (p.ex. final de sema-
na), os motores, redutores esfriam. Durante os primeiros percursos após
um intervalo destes são necessários outros momentos de eixo do que em
um robô em temperatura de operação. A unidade de comando do robô
adapta a detecção de colisão automaticamente à temperatura alterada.
Restrições
 No modo T1 não é possível nenhuma detecção de colisão.
 Para posições HOME e outras posições globais não é possível uma de-
tecção de colisão.

 Para eixos adicionais não é possível uma detecção de colisão.

 No movimento para trás não é possível uma detecção de colisão.
 Quando o robô está parado, ocorrem elevados momentos de eixo no ar-
ranque. Por isso os momentos de eixo não são monitorados na fase de
arranque (aprox. 700ms).
 Após uma alteração do override de programa a detecção de colisão reage
durante 2 a 3 execuções do programa com considerável falta de sensibi-
lidade. Em seguida, a unidade de comando do robô adaptou a faixa de to-
lerância ao novo override de programa.
Princípio da Fazer o teach de um programa com detecção de colisão

detecção de  A adaptação de aceleração deve estar ligada com a variável de sistema
colisão $ADAP_ACC .
 A variável de sistema está no arquivo C:\KRC\Roboter\KRC\R1\Ma-
Da\$ROBCOR.DAT
 $ADAP_ACC = #NONE Adaptação de aceleração não ativada
 $ADAP_ACC = #STEP1 Modelo dinâmico sem energia cinética
 $ADAP_ACC = #STEP2 Modelo dinâmico com energia cinética
 Para ligar a detecção de colisão para um movimento, o parâmetro Detec-
ção de colisão deve ser setado em TRUE na programação. Isto é identi-
ficável no código de programa no adicional CD:
PTP P2 Vel= 100 % PDAT1 Tool[1] Base[1] CD
O parâmetro detecção de colisão somente está disponível, se o mo-

vimento for programado via formulário Inline.
 A faixa de tolerância é apurada somente para conjuntos de movimentos,

que foram realizados por completo.
Criação dos valores offset
 Para a faixa de tolerância pode ser definido um offset para o torque e para
o momento de impulso.
 Torque: O torque age quando ao robô é contraposta uma resistência con-
tínua. Exemplos:
 O robô colide com uma parede e pressiona contra a parede.
 O robô colide com um container. O robô pressiona contra o container
e o move.
 Momento de impulso: O momento de impulso age quando ao robô é
contraposta uma resistência breve. Exemplo:
 O robô colide com uma placa, que é catapultada através do impacto.
 Quanto menor for o offset, maior será a sensibilidade de reação da detec-
ção de colisão.
 Quanto maior for o offset, menor será a sensibilidade de reação da detec-
ção de colisão.
Se a detecção de colisão reagir de forma muito sensível, não aumen-

tar imediatamente o offset. Em vez disso, primeiro determinar a faixa
de tolerância e verificar se a detecção de colisão agora reage confor-
me desejado.
 Janela de opções Janela de colisão

Fig. 9-2: Janela de opções Detecção de colisão
Os dados na janela de opções Detecção de colisão nem sempre se

referem ao movimento atual. Em especial em pequenas distâncias
entre pontos e movimentos de aproximação são possíveis desvios.
Pos. Descrição
1 O botão mostra o estado de um movimento.
 vermelho: O movimento atual não é monitorado.
 verde: O movimento atual é monitorado.
 laranja: Foi pressionada uma tecla para o ajuste de valores
à esquerda e à direita do valor numérico para torque ou
momento de impulso. A janela pára no movimento e o off-
set pode ser alterado. A alteração pode ser assumida com
Salvar.
 selecionado: Normalmente um programa deve ser execu-
tado 2 a 3 vezes, até que a unidade de comando do robô
tenha determinado uma faixa de tolerância útil na prática.
Enquanto a unidade de comando do robô se encontrar
nesta fase de aprendizado, o botão é exibido como sele-
cionado.
2 Número das variáveis TMx
Para cada conjunto de movimentos no qual o parâmetro detec-
ção de colisão está em TRUE, a unidade de comando do robô
cria uma variável TMx. TMx contém todos os valores para a faixa
de tolerância deste conjunto de movimentos. Se dois conjuntos
de movimentos se referirem ao mesmo ponto Px, a unidade de
comando do robô cria 2 variáveis TMx.
3 Caminho e nome do programa selecionado.
4 Nome do ponto

Pos. Descrição
5 Este campo somente está ativo no modo "Automático externo".
Caso contrário, ele está cinza.
MonOn: A detecção de colisão foi ativada pelo PLC.
Se a detecção de colisão é ativada pelo PLC, o PLC transmite o
sinal de entrada sTQM_SPSACTIVE à unidade de comando do
robô. A unidade de comando do robô responde com o sinal de
saída sTQM_SPSSTATUS. Os sinais estão definidos no arquivo
$config.dat.
Nota: No modo Automático externo a detecção de colisão
somente está ativa se, tanto o campo PLC como também o
campo KCP, exibirem o registro MonOn.
6 MonOn: A detecção de colisão foi ativada a partir do KCP.
Nota: No modo Automático externo a detecção de colisão
somente está ativa se, tanto o campo PLC como também o
campo KCP, exibirem o registro MonOn.
7 Offset para o torque. Quanto menor for o offset, maior será a sen-
sibilidade de reação da detecção de colisão. Valor padrão: 20.
A janela pára no movimento e o offset pode ser alterado. A altera-
ção pode ser assumida com Salvar.
N.A.: Para este movimento a opção Detecção de colisão no for-
mulário Inline está em FALSE.
8 Offset para o momento de impulso. Quanto menor for o offset,
maior será a sensibilidade de reação da detecção de colisão.
Valor padrão: 30.
A janela pára no movimento e o offset pode ser alterado. A altera-
ção pode ser assumida com Salvar.
N.A.: Para este movimento a opção Detecção de colisão no for-
mulário Inline está em FALSE.
Botão Descrição
Ativar Ativa a detecção de colisão.
Este botão não é exibido, se o torque ou momen-
to de impulso foi alterado, mas as alterações ain-
da não foram salvas.
Desativar Desativa a detecção de colisão.
Este botão não é exibido, se o torque ou momen-
to de impulso foi alterado, mas as alterações ain-
da não foram salvas.
Salvar Assume alterações no torque e/ou momento de
impulso.
Cancelar Rejeita alterações no torque e/ou momento de
impulso.
Procedimento
Alternativamente pode-se excluir as linhas com o monitoramento de
torque e em vez disso usar a detecção de colisão nestes programas.
A detecção de colisão não pode ser usada junto com o monitoramen-
to de torque em um programa.
A adaptação de aceleração está ligada, quando a variável de sistema
$ADAP_ACC for diferente de #NONE. (Este é o ajuste padrão.) A variável
de sistema se encontra no arquivo C:\KRC\Roboter\KRC\R1\MaDa\$ROB-
COR.DAT.

Programar a detecção de colisão

1. Criar movimento com formulário Inline
2. Abrir a janela de opções Frames e ativar a detecção de colisão
Fig. 9-3: Janela de opções Frames
Pos. Descrição
1 Selecionar a ferramenta.
Quando True no campo TCP externo: selecionar a peça.
Faixa de valores: [1] … [16]
2 Selecionar a base.
Quando True no campo TCP externo: selecionar a ferramenta fi-
xa.
Faixa de valores: [1] … [32]
3 Modo de interpolação
 False: A ferramenta está montada no flange de monta-
gem.
 True: A ferramenta é uma ferramenta fixa.
4  True: para este movimento a unidade de comando do robô
determina os momentos do eixo. Eles são necessários
para a detecção de colisão.
 False: para este movimento a unidade de comando do
robô não determina nenhum momento do eixo. Portanto,
uma detecção de colisão para este movimento não é pos-
sível.
3. Fechar o movimento
Determinar a faixa de tolerância e ativar a detecção de colisão
1. No menu principal, selecionar Configuração > Extras > Detecção de co-
lisão.
(>>> Fig. 9-2 )
2. No campo KCP deve constar o registro MonOff. Se este não for o caso,
pressionar Desativar.
3. Iniciar o programa e deixá-lo rodar várias vezes. Após 2 a 3 execuções a
unidade de comando do robô determinou uma faixa de tolerância útil na
prática.
4. Pressionar Ativar. Na janela Detecção de colisão consta agora no cam-
po KCP o registro MonOn.
Salvar a configuração com Fechar.

Adaptar offset para movimentos

1. Selecionar programa.
2. No menu principal, selecionar Configuração > Extras > Detecção de co-
lisão.
3. O offset para o movimento pode ser alterado com o programa em anda-
mento: Quando o movimento desejado for exibido na janela Detecção de
colisão, pressionar as teclas ao lado de torque e momento de impulso. A
janela para neste movimento. Alterar o offset através destas teclas.
Fig. 9-6: Detecção de colisão - valores alterados
Alternativamente pode ser executada uma seleção de passo no movimen-

to desejado.
4. Assumir a alteração com Salvar.
5. Salvar a configuração com Fechar.
6. Ajustar o modo de operação e tipo de execução do programa original.

Índice
Índice
Símbolos Monitoramento do espaço de trabalho 27
$ADAP_ACC 90 Monitoramento do espaço de trabalho, exercício
27
A
Automático externo 77 N
Nomes de dados 9
C Número da mensagem 30
Comentário 5
Configuração 77 P
Configurar Automático externo, exercício 85 PAP 9
Pasta 7
D Ponto raiz da mão 21
Declarar Interrupt, exercício 60 Prioridade 52
Detecção de colisão 87, 91 Programação estruturada 5
Detecção de colisão (item de menu) 91, 92 Programar diálogo, exercício 50
Detecção de colisão, Automático externo 90 Programar mensagem de estado, exercício 40
Detecção de colisão, variável 89 Programar mensagem de informação, exercício
Diálogo 47 37
Programar mensagens de confirmação,
E exercício 43
E/Ss analógicas, exercício 74 Programar mensagens de espera, exercício 46
EKrlMsgType 30
Emitente 30 S
Entradas analógicas 69 Saídas analógicas 71
Espaços de trabalho 17 Sinais analógicos 69
Espaços de trabalho, modo 20 Submit 13
Estratégia de retrocesso, exercício 66 Subprogramas 8
Estratégias de retrocesso 65
Exemplo PAP 11 T
Tensão 72
F Texto de mensagem 30
Fluxograma do programa, PAP 9 tipo de mensagem 30
tm_useraction 87
G TMx 89
Global 52 Torque 88
I Z
Interpretador Submit 13 Ícones PAP 10
Interrupt 51
Interrupt Cancelar movimentos de deslocamen-
to, exercício 62
K
KrlMsg_T 30
KrlMsgDlgSK_T 32
KrlMsgOpt_T 32
M
Mensagem de confirmação 29, 42
Mensagem de diálogo 29
Mensagem de espera 29, 45
Mensagem de estado 29, 39
Mensagem de informação 29, 36
Mensagens 29
Mensagens de usuário 29
Método de programação, exemplo PAP 11
Modo de interpolação 91
Momento de impulso 88



Programação Do Robô Kuka 3

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Programação Do Robô Kuka 3

Enviado por

Direitos autorais:

Formatos disponíveis

Training KUKA Roboter GmbH

KUKA System Software 8

Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)

Publicações: Pub COLLEGE P3KSS8 Roboterprogrammierung 3 (PDF-COL) pt

2 / 95 Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)

2 Interpretador Submit ................................................................................... 13

3 Espaços de trabalho com KRL ................................................................... 17

4 Programação de mensagens com KRL ..................................................... 29

5 Programação de Interrupt ........................................................................... 51

6 Programar a estratégia de retrocesso ....................................................... 65

7 Trabalhar com sinais analógicos ............................................................... 69

8 Execução e configuração de Automático externo ................................... 77

9 Programar a detecção de colisão .............................................................. 87

Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL) 3 / 95

4 / 95 Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)

1.1 Objetivo de um método de programação padronizado

Objetivo do Um método de programação padronizado serve para:

1.2 Recursos auxiliares para a criação de programas de robô estruturados

Qual é o sentido Comentários são complementos/notas dentro das linguagens de programa-

Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL) 5 / 95

 Contribuem para a estruturação de um programa

Onde e quando Informações sobre todo o texto fonte:

Classificação do texto fonte:

Explicação de uma única linha:

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

Nota sobre trabalhos a serem executados:

6 / 95 Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)

;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

Qual é o efeito do  em PASTAS podem ser ocultadas partes do programa

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

Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL) 7 / 95

SET_EA ; PASTA criada pelo usuário aberta

PTP HOME Vel=100% DEFAULT ; PASTA KUKA fechada

PTP HOME Vel=100% Default

SET_EA ; PASTA criada pelo usuário fechada

PTP HOME Vel=100% DEFAULT ; PASTA KUKA aberta

PTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table

PTP HOME Vel=100% Default

Por que se Na programação, os subprogramas são utilizados especialmente para permi-

8 / 95 Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)

Aplicação de DEF MAIN()

IF $IN[1]== TRUE THEN

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

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

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-

Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL) 9 / 95

Erros de estrutura e de programação são facilmente reconhecidos em uma re-

Ícones PAP Início ou fim de um processo ou programa

Integração de instruções e operações

Instruções gerais no código de programa

10 / 95 Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)

Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL) 11 / 95

12 / 95 Edição: 17.10.2012 Versão: P3KSS8 Roboterprogrammierung 3 V2 pt (PDF-COL)

2.1 Status do Interpretador Submit

Descrição do No KSS 8.x rodam duas Tasks