comau programação PDL BASIC

Prévia do material em texto

ESTRUTURA DO PROGRMA PDL2
PROGRAM (nome programa) EZ à Editavel no ambiente IDE
CONST }
VAR }
ROUTINE call_(nome do programa) EXPORTED FROM nome do programa }
 }
ROUTINE sub_1 }
BEGIN }
... }
END sub_1 } à Área de declaração
}
}
ROUTINE call_(nome do programa) }
BEGIN }
... }
END call_(nome do programa) }
BEGIN
CYCLE }
 Sub_1 } à Área Executável
 Call_(nome do programa) }
END nome do programa
O programa inicia com a instrução PROGRAM. Esta instrução identifica o programa
com um nome definido pelo usuário. O mesmo identifica, também o arquivo no qual
o programa foi memorizado. O programa em si pode ser definido como HOLD ou
NOHOLD, os programas HOLD (holdable) são controlados mediante os comandos START
e HOLD, geralmente tais programas incluem um movimento. Os programas NOHOLD
geralmente são utilizados para controle de processo e não pode incluir um
movimento, uma vez ativado não necessita de um START.
Os programas são subdivididos em uma área de declaração e uma área de seção
executável. A área de declaração consiste em um elenco de todas as rotinas e de
todas as categorias de dados que serão utilizados pelo programa, enquanto a
seção executável é formada por um elenco de instruções que o controlador deverá
executar para efetuar um task.
As duas áreas são separadas pela instrução BEGIN. Para esta instrução, o
programador pode associar a opção CYCLE de modo a criar um ciclo contínuo, a
instrução END indica o fim do programa.
CATEGORIAS DE DADOS:
CONST
input_1 = 1
 error = TRUE
 angle = 180
VAR
Ponto_home : JOINTPOS
ponto_1 : POSITION
contador : INTEGER
flag_error : BOOLEAN
 message : STRING[50]
n_pontos : ARRAY [100] OF POSITION
ROUTINE
EXEMPLO DE UM PROGRAMA PDL2
PROGRAM prog_flay EZ, PROG_ARM = 1, STACK = 2048
VAR pnt0002p, pnt0003p, pnt0004p, pnt0005p, pnt0006p : POSITION
 jnt0001j : JOINTPOS FOR ARM[1]
ROUTINE a_tool(ai_t_idx : INTEGER) EXPORTED FROM tt_tool
ROUTINE call_prog_flay EXPORTED FROM prog_flay
ROUTINE call_prog_flay
BEGIN
 MOVE JOINT TO jnt0001j
 a_tool(13) –- chamada da ferramenta 13
 MOVEFLY JOINT TO pnt0002p ADVANCE
 MOVE LINEAR TO pnt0003p
 MOVE LINEAR TO pnt0004p
 DELAY 2000 –- espera por 2 segundos
 MOVE LINEAR TO pnt0005p
 MOVEFLY JOINT TO pnt0006p ADVANCE
 MOVE JOINT TO jnt0001j
END call_prog_flay
BEGIN
CYCLE
 call_prog_flay
END prog_flay
INSERIDO UMA NOVA VARIÁVEL
PROGRAM prog_flay EZ, PROG_ARM = 1, STACK = 2048
VAR pnt0002p, pnt0003p, pnt0004p, pnt0005p, pnt0006p : POSITION
 jnt0001j : JOINTPOS FOR ARM[1]
 c1 : INTEGER
ROUTINE a_tool(ai_t_idx : INTEGER) EXPORTED FROM tt_tool
ROUTINE call_prog_flay EXPORTED FROM prog_flay
ROUTINE call_prog_flay
BEGIN
 MOVE JOINT TO jnt0001j
 a_tool(13) –- chamada da ferramenta 13
 MOVEFLY JOINT TO pnt0002p ADVANCE
 MOVE LINEAR TO pnt0003p
 MOVE LINEAR TO pnt0004p
 DELAY 2000 –- espera por 2 segundos
 MOVE LINEAR TO pnt0005p
 MOVEFLY JOINT TO pnt0006p ADVANCE
 MOVE JOINT TO jnt0001j
END call_prog_flay
BEGIN
 c1 := 0
CYCLE
 call_prog_flay
 c1 := c1 + 1
END prog_flay
DECLARAÇÕES DE CONSTANTES E VARIÁVEIS
As variáveis e constantes declaradas na seção VAR e CONST de uma rotina são
chamadas locais à rotina. Isto significa que podem ser utilizadas somente ao
interno da própria rotina e que não poder ser utilizadas em outras partes do
programa.
As variáveis e constantes declaradas na seção VAR e CONST do programa principal
podem ser utilizadas em um ponto qualquer do programa, mesmo ao interno de
rotinas. Por isto, são chamadas de globais ao programa. Se uma variável
declarada ao interno de uma rotina tem o mesmo nome de uma variável global, a
rotina terá acesso à variável declarada localmente.
PROGRAM exemplo
VAR
 x : INTEGER
ROUTINE teste_a
VAR
 x : INTEGER
BEGIN
 x := 4
 WRITE LUN_CRT(‘Dentro de teste_a x = ‘, x, NL)
END teste_a
ROUTINE teste_b
BEGIN
 WRITE LUN_CRT(‘Dentro de teste_b x = ‘, x, NL)
END teste_b
BEGIN
 x := 10
 WRITE LUN_CRT(‘O valor inicial de x = ‘, x, NL)
 teste_a
 WRITE LUN_CRT(‘Apos teste_a ter sido chamada x = ‘, x, NL)
 teste_b
 WRITE LUN_CRT(‘Apos teste_b ter sido chamada x = ‘, x, NL)
END exemplo
Os resultados na saída sera de :
O valor inicial de x = 10
Dentro de teste_a x = 4
Apos teste_a ter sido chamada x = 10
Dentro de teste_b x = 10
Apos teste_b ter sido chamada x = 10
ROTINAS DE PROCEDIMENTO E FUNÇÃO
A rotiona de procedimento consiste em uma seqüência de instruções que são
chamadas e executadas como uma única instrução executável.
A rotina de função é formada por um seqüência de cálculos e comparações eo valor
que resultar destas operações será restituído. Uma rotina de função é chamada ao
interno de uma expressão.
A rotina de função são utilizadas como parte de um teste de controle em um loop
ou em um salto condicional ou como parte de um expressão no lado direito de uma
intruçao de atribuição, no exemplo seguinte, a rotina é utilizada como teste em
uma instrução IF.
PROGRAM check_entrada
ROUTINE time_out : BOOLEAN
CONST
 Limite_tempo = 3000
VAR
 Janela_tempo : INTEGER
BEGIN
 $TIMER[1] := 0
 REPEAT
 Janela_tempo := $TIMER[1]
 UNTIL ($DIN[1] = ON) OR (janela_tempo > limite_tempo)
 IF janela_tempo > limite_tempo THEN
 RETURN(TRUE)
 ELSE
 RETURN(FALSE)
 ENDIF
END time_out
BEGIN
 IF time_out THEN
 WRITE LUN_CRT(‘Ocorreu um time out’)
 ENDIF
END check_entrada
PARÂMETROS
Para generalizar rotinas de modo poder utilizá-las em diferentes circunstâncias,
o programador pode utilizar parâmetros de rotinas ao invés de constantes ou
variáveis. Os parâmetros são declarados no titulo da rotina. Quando uma rotina e
chamada, os dados são passados aos parâmetros da rotina por um elenco de
argumentos indicados na chamada da rotina. O numero de argumentos deve ser igual
ao numero de parâmetros declarados para a rotina. Alem do mais deve haver
compatibilidade com o tipo de dados com o qual os parâmetros foram declarados.
No exemplo seguinte, a rotina time_out pode ser usada em modo geral incluindo um
parâmetro que fornece o índice do sinal de entrada. A rotina assim modificada,
pode ser utilizada para o controle de qualquer sinal de entrada.
PROGRAM check_entrada
ROUTINE time_out(input : INTEGER) : BOOLEAN
CONST
 Limite_tempo = 3000
VAR
 Janela_tempo : INTEGER
BEGIN
 $TIMER[1] := 0
 REPEAT
 Janela_tempo := $TIMER[1]
 UNTIL ($DIN[input] = ON) OR (janela_tempo > limite_tempo)
 IF janela_tempo > limite_tempo THEN
 RETURN(TRUE)
 ELSE
 RETURN(FALSE)
 ENDIF
END time_out
BEGIN
 IF time_out(1) THEN
 WRITE LUN_CRT(‘Ocorreu um time out no ciclo 1’)
 ELSE
 IF time_out(6) THEN
 WRITE LUN_CRT(‘Ocorreu um time out no ciclo 6’)
 ENDIF
 ENDIF
END check_entrada
INSERIDO UMA INTRUÇÃO IF
A instrução IF é utilizada para escolha entre dois possíveis fluxos de execução,
em base ao resultado de uma expressão.
SINTAXE:
IF expressão THEN
...
ELSE
...
ENDIF
PROGRAM prog_flay EZ, PROG_ARM = 1, STACK = 2048
VAR
 c1 : INTEGER
ROUTINE a_tool(ai_t_idx : INTEGER) EXPORTED FROM tt_tool
ROUTINE call_pega_peca EXPORTED FROM pega_peca
ROUTINE call_descart_pallet EXPORTED FROM descart_pallet
BEGIN
 c1 := 0
CYCLE
 Call_pega_peca
 IF c1 = 10 THEN
call_descart_pallet
 c1 := 0
 ELSE
 c1 := c1 + 1
 ENDIF
END prog_flay
GOTO
PROGRAM prog_flay EZ, PROG_ARM = 1, STACK = 2048
VAR
 c1 : INTEGER
ROUTINE a_tool(ai_t_idx : INTEGER) EXPORTED FROM tt_tool
ROUTINE call_pega_peca EXPORTED FROM pega_peca
ROUTINE call_descart_pallet EXPORTED FROM descart_pallet
BEGIN
 c1 := 0
CYCLE
l_1::
 Call_pega_peca
 IF c1 = 10 THEN
 GOTO l_2
 ELSE
 c1 := c1 + 1
 GOTO l_1
 ENDIF
l_2::
call_descart_pallet
 c1 := 0
END prog_flayINSERIDO UMA INTRUÇÃO REPEAT
A instrução REPEAT executa uma sequência de instruções até que uma expressão
booleana seja true.
SINTAXE:
REPEAT
 ...
UNTIL expressão
PROGRAM prog_flay EZ, PROG_ARM = 1, STACK = 2048
VAR
 c1 : INTEGER
ROUTINE a_tool(ai_t_idx : INTEGER) EXPORTED FROM tt_tool
ROUTINE call_pega_peca EXPORTED FROM pega_peca
ROUTINE call_descart_pallet EXPORTED FROM descart_pallet
BEGIN
 c1 := 0
CYCLE
 REPEAT
 Call_pega_peca
 c1 := c1 + 1
 UNTIL c1 = 10
call_descart_pallet
 c1 := 0
END prog_flay
FOR
A instrução FOR executa por um certo número de vezes uma seqüência de instruções
SINTAXE:
FOR var := valor inicio TO | DOWNTO valor fim DO
 ...
ENDFOR
PROGRAM prog_flay EZ, PROG_ARM = 1, STACK = 2048
VAR
 n_for : INTEGER
 descart_ok : BOOLEAN
ROUTINE a_tool(ai_t_idx : INTEGER) EXPORTED FROM tt_tool
ROUTINE call_pega_peca EXPORTED FROM pega_peca
ROUTINE call_descart_pallet EXPORTED FROM descart_pallet
BEGIN
CYCLE
 FOR n_for := 1 TO 10 DO
 Call_pega_peca
 ENDFOR
call_descart_pallet
 descart_ok := TRUE
END prog_flay
INSERIDO UMA INTRUÇÃO SELECT
A instrução SELECT é utilizada para escolher entre diferentes possíveis fluxos
de execução, em base ao resultado de uma expressão inteira.
SITAXE:
SELECT expr_int OF
 CASE(valor 1):
 ...
 CASE(valor 2):
 ...
 ELSE:
 ...
ENDSELECT
WAIT FOR
A instrução WAIT FOR suspende a execução do programa até que seja satisfeita a
condição especificada.
SINTAXE: WAIT FOR expressão
PROGRAM prog_flay EZ, PROG_ARM = 1, STACK = 2048
CONST
 din_1 = 50
 din_2 = 51
 din_3 = 53
VAR
 Tipo_ciclo : INTEGER
ROUTINE call_prog_1 EXPORTED FROM prog_1
ROUTINE call_prog_2 EXPORTED FROM prog_2
ROUTINE call_prog_3 EXPORTED FROM prog_3
BEGIN
CYCLE
 WAIT FOR $DIN[din_1] OR $DIN[din_2] OR $DIN[din_3]
 IF $DIN[din_1] THEN
 Tipo_ciclo := 1
 ELSE
 IF $DIN[din_2] THEN
 Tipo_ciclo := 2
 ELSE
 IF $DIN[din_3] THEN
 Tipo_ciclo := 3
 ELSE
 ENDIF
 ENDIF
 ENDIF
 SELECT tipo_ciclo OF
 CASE(1):
 Call_prog_1
 CASE(2):
 Call_prog_2
 CASE(3):
 Call_prog_3
 ELSE:
 WRITE(‘ERRO CODIGO DE PROGRAMA’, NL)
 ENDSELECT
END prog_flay
GESTORES DE CONDIÇÃO
Os gestores de condição permitem a um programa monitorar determinadas condições
em paralelo com a execução normal e executar as ações associadas no caso em que
tais condições sejam satisfeitas. Utilizações típicas compreendem no
monitoramento e o controle das unidades periféricas e a gestão dos erros.
O gestor é inicialmente definido, o que permite, a seguir, a sua habilitação. Os
gestores de condição podem ser desabilitados ou removidos.
Os gestores são definidos na área de execução do programa, utilizando a
instrução CONDITION.
SINTAXE:
CONDITION[n] :
 WHEN expressão DO
 ...
 WHEN expressão DO
 ...
ENDCONDITION
As condições a serem monitoradas estão especificadas na expressão de condição
(expressão). Muitas condições podem ser combinadas em uma única expressão
utilizando os operadores BOOLEAN, AND, OR. As condições que podem ser
monitoradas serão vistas a seguir. Quando a expressão se torna TRUE, o gestor de
condição é ativado.
A habilitação global de gestores de condição é possível utilizando-se a
instrução: ENABLE CONDITION[n].
Os gestores de condição podem ser temporariamente habilitados como parte de uma
instrução MOVE através da cláusula WITH.
EXEMPLO:
CONDITION[1]:
 WHEN AT START DO
 $DOUT[22] := ON
ENDCONDITION
...
...
MOVE TO ponto_1,
 WITH CONDITION[1]
ENDMOVE
...
A desabilitaçao global de gestores de condição é possível utilizando-se a
instrução DISABLE CONDITION[n]. Utilizando a opção ALL, todos os gestores serão
desabilitados, DISABLE CONDITION ALL.
Se um gestor de condição estiver habilitado como parte de uma cláusula WITH, o
mesmo será desabilitado no final do movimento.
As funções internas COND_ENABLED e COND_ENABLED_ALL podem ser utilizadas para
controlar se uma determinada condição está habilitada.
EXEMPLO:
IF COND_ENABLED(1) = OFF THEN
 ENABLE CONDITION[1]
ENDIF
OUTRAS INSTRUÇÕES:
HOLD: para a execução do programa, somente com um novo START para
restabelecer o ciclo
EXIT CYCLE : faz com que durante a execução de um programa, seja
omitida a parte restante do ciclo atual e seja iniciado
imediatamente o ciclo sucessivo
LOCK: interrompe o movimento de um braço especifico
UNLOK: permite retomar o movimento de um braço bloqueado. O
movimento pode recomeçar somente no momento da execução de uma
instrução RESUME
RESUME: para restabelecer o movimento à espera de ser executado, é
necessário enviar a instrução RESUME.
ROUTINE: declara uma rotina definida pelo usuário na área de
declaração de um programa
RETURN: restitui o controle do programa da rotina em execução a
ponto a partir do qual a mesma foi chamada
ELENCO DE ALGUMAS VARIÁVEIS PREDEFINIDAS (SISTEMA)
$TIMER: temporizador do relógio dado em ms
exemplo: $TIMER[1] := 0 (seta o temporizador 1 a 0)
 IF $TIMER[1] > 2000 THEN...
$DIN: input digital
exemplo: WAIT FOR $DIN[1] ...
 IF $DIN[20] = TRUE THEN ...
 IF $DIN[imput_2] = OFF THEN ...
$DOUT: output digital
exemplo: $DOUT[4] := OFF
 $DOUT[liga_vacuo] := ON
$WORD: dados PLC word, representa a memoria V da lógica ladder do
PLC. Pode ser usada para a troca de dados entre um programa PLC e
um programa PDL2.
Exemplo: BIT_SET($WORD[21], 2) – seta o bit 2 da palavra 21 (saída
do PDL para a entrada do PLC)
 WAIT FOR BIT_TEST($WORD[32], 4, ON) – esperando o sinal
do PLC a ON.
 BIT_CLEAR($WORD[21], 2)