FUNCTION_BLOCK "INTEGRATOR"
TITLE =
//THE FUNCTION IS TO INTEGRATE A VARIABLE,AND THE VARIABLE CHANGES WITH TIME.
//
//START TIME:2004-4-27 20:30
//
//END TIME:2004-4-27 22:40
//
//AMEND TIME:2004-4-28 19:40 AMEND SOME BUGS
//
//VERSION:B
//
//PROGRAMMED BY QHM
//
//AMEND SOME SYMBLES OF INPUTS AND OUTPUTS IN 2004-6-8.
//and amends some bugs again.
AUTHOR : QHM
FAMILY : NIE
NAME : QHM
VERSION : 0.1


VAR_INPUT
IN_INPUT : INT ;
IN_Tn : INT ;
IN_Tz : INT ;
END_VAR
VAR_OUTPUT
OUT_OUTPUT : INT ;
END_VAR
VAR
OUTK : REAL ;
OUTK_1 : REAL ;
INK : REAL ;
INK_1 : REAL ;
INM_1 : REAL ;
INTE_TK : REAL ;
INTE_TK_1 : REAL ;
END_VAR
VAR_TEMP
FLAG : BOOL ;
END_VAR
BEGIN
NETWORK
TITLE =

//处理输入变量为实数
L #IN_INPUT;
ITD ;
DTR ;
T #INK;
//求积分时间常数,#INTE_TK==#IN_Tn/ #IN_Tz
L #IN_Tn;
ITD ;
DTR ;
L #IN_Tz;
ITD ;
DTR ;
/R ;
T #INTE_TK;
NETWORK
TITLE =

//判断K时刻与M-1时刻的值是否相同
L #INK;
L #INM_1;
<>R ;
JNB COM;
//如果不相等，就赋值，也就是说输入积分器的值发生了变化
L #INK;
T #INM_1;
L #OUTK;
T #INK_1;
T #OUTK_1;
//如果相等，就进行积分运算
//K时刻的输入与K-1时刻的输入不相等，就求差，判断差值的正负，并设标志位FLAG
COM: NOP 0;
L #INK;
L #INK_1;
<>R ;
JNB _001;
-R ;
JP _004;
SET ;
R #FLAG;
JU _005;
_004: SET ;
S #FLAG;
_005: NOP 0;
//乘以积分时间常数求解积分
L #INTE_TK;
*R ;
L #OUTK_1;
+R ;
T #OUTK;
//判断OUTK是否超过INK，在正方向时，如果大于就把输入给输出
//反方向时，如果小于输入，那么仍然把输入给输出
L #OUTK;
L #INK;
A #FLAG;
JNB _006;
>=R ;
JU _007;
_006: <=R ;
_007: NOP 0;
JNB _002;
T #OUTK;
JU _003;
//如果在两个方向上都没有超限，那么就把输出付给K-1时刻准备下一扫描周期重新积分运算
_002: L #OUTK;
T #OUTK_1;
JU _003;
//K时刻的输入与K-1时刻的输入相等
_001: L #OUTK;
T #INK_1;
T #OUTK_1;
NETWORK
TITLE =

_003: RND ;
T #OUT_OUTPUT;
//可以在积分过程中改变积分时间常数
L #INTE_TK;
L #INTE_TK_1;
<>R ;
JNB _008;
L #OUTK;
T #OUTK_1;
JU _009;
_008: NOP 0;
L #INTE_TK;
T #INTE_TK_1;
_009: NOP 0;
END_FUNCTION_BLOCK

FUNCTION_BLOCK "FILT-I"
TITLE =
//THIS FUNCTION BLOCK IS CLAER DITURBED SIGNAL OF THE INPUT SIGNAL .
AUTHOR : QHM
FAMILY : NIE
NAME : QHM
VERSION : 0.1


VAR_INPUT
IN : INT ;
T_S : INT ; //INTERRUPT TIME
T_1 : INT ; //FILTER CONSTANT =0MS-32767MS
END_VAR
VAR_OUTPUT
OUT : INT ;
END_VAR
VAR
OUTK_1 : REAL ;
OUTK : REAL ;
END_VAR
VAR_TEMP
Exp : REAL ;
END_VAR
BEGIN
NETWORK
TITLE =
//if T_1==0
//then output=input
A( ;
L #T_1;
L 0;
==I ;
) ;
JNB _001;
L #IN;
T #OUT;
BEU ;
_001: NOP 0;
NETWORK
TITLE =
//COMPUTE THE FILTER CONSTANT =1-EXP(-T_S/T_1)
//球LD0
L #T_S;
ITD ;
DTR ;
L #T_1;
ITD ;
DTR ;
/R ;
NEGR ;
EXP ;
NEGR ;
L 1.000000e+000;
+R ;
T #Exp;
NETWORK
TITLE =
//OUT(K)=OUT(K-1)+LD0*(IN(K)-OUT(K-1))
L #IN;
ITD ;
DTR ;
L #OUTK_1;
-R ;
L #Exp;
*R ;
L #OUTK_1;
+R ;
T #OUTK;
NETWORK
TITLE =
//NOTE:THE STATE VARIABLE IS SET AS 0 IN THE OB100
L #OUTK;
T #OUTK_1;
RND ;
T #OUT;
END_FUNCTION_BLOCK

FUNCTION_BLOCK "DIAMETER CALCULATOR"
TITLE =
//THE FUNCTION IS TO CALCULATE THE DIAMETER ON TIMING.
//START TIME:2004-3-19
//END TIME:2004-3-19
//AMEND TIME:2004-4-28 19:21
//VERSION:B
//
//
//amended time in the afternoon of 2004,6,9.
//amended contents:
//1,correct this programm before correct the integrator function
//2,find that when the OUTK and IN_INPUT of the integrator function changes at
//the
//same time,OUT_OUTPUT changes from OUTK to value concerned.After that,OUT_OUTPUT
//changes from one value concerned to another value concerned.
//3,Above all,before rolling mill starts,in that,it stops,loading the IN_DIAREL
//to
//OUTK of STAT INTEGRATOR by pointer.
//4,AS the same way,when it stops and IN_SET is true,loading the initiate value
//of
//diameter to OUTK of STAT INTEGRATOR by pointer.
//5,Diameter computed is limited in front of INTEGRATOR function in this
//version,which is different from the version A.
AUTHOR : QHM
FAMILY : NIE
NAME : QHM
VERSION : 0.1


VAR_INPUT
DIAREL : INT ; //Diameter Ratio
VELACT : INT ;
SPEACT : INT ;
SIGREW : BOOL ;
LIMWR : INT := 2000;
LIMRI : INT := 2000;
TN : INT := 5;
LEVSP : INT := 100;
LEVVEL : INT := 100;
STOP : BOOL ;
SET : BOOL ;
SETVAL : INT := 2800;
END_VAR
VAR_OUTPUT
CALCDIA : INT ;
UPLIM : BOOL ;
LWLIM : BOOL ;
END_VAR
VAR
INTE_DIAK : INT ;
DIAK_1 : INT ;
INTEGRATOR : "INTEGRATOR";
S_Function : "FILT-I";
END_VAR
VAR_TEMP
Y : REAL ;
Z : REAL ;
X : REAL ;
INC_LIM : INT ;
DEC_LIM : INT ;
STOP1 : BOOL ;
STOP2 : BOOL ;
STOP_CAL : BOOL ;
DIAk : INT ;
DB_ID : WORD ;
END_VAR
BEGIN
NETWORK
TITLE =



NETWORK
TITLE =
//ABS VELACT AND SPEACT
L #VELACT;
ITD ;
DTR ;
ABS ;
T #Y;
L #SPEACT;
ITD ;
DTR ;
ABS ;
T #Z;
NETWORK
TITLE =
//VELO COMPARES WITH LEVVEL AND SPEED COMPARES WITH LEVSP
L #LEVVEL;
ITD ;
DTR ;
L #Y;
>R ;
= #STOP1;
L #LEVSP;
ITD ;
DTR ;
L #Z;
>R ;
= #STOP2;
A( ;
O #STOP1;
O #STOP2;
O #STOP;
) ;
= #STOP_CAL;
NETWORK
TITLE =
//CALCULATE X*Y/Z;
//NOTE: X=DIAREL
// Y=VELACT
// Z=SPEACT
AN #STOP_CAL;
JNB _END;
L #DIAREL;
ITD ;
DTR ;
T #X;
L #Y;
L #Z;
/R ;
L #X;
*R ;
RND ;
T #DIAk;
NETWORK
TITLE =
//LIMIT LOGIC
A #SIGREW;
JNB _001;
L #LIMWR;
T #DEC_LIM;
L #LIMRI;
T #INC_LIM;
JU _002;
_001: L #LIMWR;
T #INC_LIM;
L #LIMRI;
T #DEC_LIM;
_002: NOP 0;
NETWORK
TITLE =
//LIMITING THE CHANGING RANGE OF THE CALCULATED DIAMETER BY "INC_LIM" AND "
//DEC_LIM" WHETHER WINDER OR UNWINDER.
L #DIAk;
// T #DIAK_1
L #INTE_DIAK; //#DIAK_1
>I ;
JNB _005;
-I ;
L #INC_LIM;
>I ;
JNB _006;
L #INTE_DIAK; // #DIAK_1
+I ;
T #DIAk;
_006: NOP 0;
JU _008;
_005: -I ;
NEGI ;
L #DEC_LIM;
>I ;
JNB _007;
L #INTE_DIAK; //#DIAK_1
-I ;
NEGI ;
T #DIAk;
_007: NOP 0;
_008: NOP 0;
NETWORK
TITLE =
//ESTIMATE THE OUPUT
//SET OVER-LIMIT FLAG
L #DIAk;
L #DIAREL;
JNB _009;
T #DIAk;
_009: L #INTE_DIAK;
L 4000;
>I ;
JNB _010;
T #DIAk;
_010: NOP 0;

NETWORK
TITLE =

L #DIAk;
T #DIAK_1;
JU _011;
_END: NOP 0;
// L #INTE_DIAK
// T #DIAK_1
_011: NOP 0;
NETWORK
TITLE =

TAR2 ;
L DW#16#FFFFFF;
AD ;
LAR1 P##INTEGRATOR; //主要是这部分难懂，是否相当于LAR1 P#L30.0，P#30.0，接口见后图

+AR1 ;
AN #STOP_CAL;
JNB _003;
CALL #INTEGRATOR (
IN_INPUT := #DIAk,
IN_Tn := 1,
IN_Tz := #TN,
OUT_OUTPUT := #INTE_DIAK);
_003: NOP 0;
A #STOP_CAL;
A #SET;
JNB _004;
L #SETVAL;
T #INTE_DIAK;
ITD ;
DTR ;
T DID [AR1,P#8.0];
_004: NOP 0;

NETWORK
TITLE =

L #INTE_DIAK;
L #DIAREL;
==I ;
= #LWLIM;
L #INTE_DIAK;
L 4000;
==I ;
= #UPLIM;
NETWORK
TITLE =

CALL #S_Function (
IN := #INTE_DIAK,
T_S := 30,
T_1 := 0,
OUT := #CALCDIA);

END_FUNCTION_BLOCK