INTEGRAL

Calcula a integral XOUT de uma variável de entrada XIN ao longo do tempo de amostragem CYCLE; enquanto R1 estiver ativo, XOUT é forçado ao valor inicial X0. É um bloco de função (mantém estado entre scans; requer instância).

Biblioteca: IEC_STD · Namespace: IEC · Tipo: bloco de função

Bloco de função

            INTEGRAL
         +-------------+
BOOL ----|RUN         Q|---- BOOL
         |             |
BOOL ----|R1       XOUT|---- REAL
         |             |
REAL ----|XIN          |
         |             |
REAL ----|X0           |
         |             |
TIME ----|CYCLE        |
         +-------------+

Integração numérica pelo método retangular, acumulando a cada execução: XOUT = XOUT + (XIN * CYCLE).

Se a entrada R1 é TRUE, o valor de XOUT é definido pelo valor de X0 (reset com prioridade). Caso contrário:

• Quando RUN é TRUE, XOUT acumula a integral de XIN ao longo do tempo CYCLE.

• Quando RUN é FALSE, XOUT é mantido no último valor.

A saída Q reflete NOT R1.

Nota

O bloco deve ser executado a cada período de amostragem CYCLE para que a integração seja consistente (por exemplo, disparado por um TON).

Parâmetros

Nome	Direção	Tipo	Padrão	Faixa / Unidade	Descrição
RUN	IN	BOOL	FALSE	—	TRUE = integra; FALSE = mantém o valor de XOUT.
R1	IN	BOOL	FALSE	—	Reset com prioridade: força XOUT = X0.
XIN	IN	REAL	0.0	—	Variável de entrada a ser integrada.
X0	IN	REAL	0.0	—	Valor inicial atribuído a XOUT no reset.
CYCLE	IN	TIME	T#0ms	período de amostragem	Intervalo de tempo entre execuções do bloco.
Q	OUT	BOOL	FALSE	—	Reflete NOT R1.
XOUT	OUT	REAL	0.0	—	Saída integrada.

Pré-condições

• O bloco deve ser chamado a cada período CYCLE para uma integração correta.

Observações

• R1 tem prioridade sobre RUN: com R1 em TRUE a integração é suspensa e XOUT é mantido em X0.

Ver também

DERIVATIVE, TON

Exemplo

Clique aqui para baixar a tabela de variáveis

Código ST

VAR
    inp_RUN   : BOOL := TRUE;    (* 1 = integrate, 0 = hold *)
    inp_R1    : BOOL := FALSE;   (* Overriding reset *)
    inp_XIN   : REAL := 50.0;    (* Input variable *)
    inp_X0    : REAL := 1.0;     (* Initial value *)
    inp_CYCLE : TIME := T#200ms; (* Sampling period *)
    out_Q     : BOOL;            (* NOT R1 *)
    out_XOUT  : REAL;            (* Integrated output *)
    my_PI     : INTEGRAL;        (* Instancia do bloco de função INTEGRAL *)
    my_TON    : TON;             (* Timer para gerar o ciclo de amostragem *)
END_VAR

(* ... *)

(* Timer TON para gerar ciclo de execução do bloco de função INTEGRAL *)
my_TON(PT := inp_CYCLE);
my_TON.IN := TRUE;

(* se atingiu tempo de amostragem, executa bloco de função INTEGRAL *)
IF (my_TON.Q = TRUE) THEN

  (* executa o bloco de função INTEGRAL a cada ciclo de amostragem *)
  my_PI(
        RUN   := inp_RUN,   (* 1 = integrate, 0 = hold *)
        R1    := inp_R1,    (* Overriding reset        *)
        XIN   := inp_XIN,   (* Input variable          *)
        X0    := inp_X0,    (* Initial value           *)
        CYCLE := inp_CYCLE  (* Sampling period         *)
      );

  (* obtem valor de atuação gerado pelo bloco de função INTEGRAL *)
  out_XOUT := my_PI.XOUT;
  out_Q    := my_PI.Q;

  (* reseta timer para gerar novo ciclo de ativação do bloco de função INTEGRAL *)
  my_TON.IN := FALSE;

END_IF;
(* ... *)