wuyue_latest/M26/DAHU.POE

PROGRAM DAHU
VAR_EXTERNAL

 
END_VAR

VAR_GLOBAL

END_VAR

VAR

DAHU03H01_IN :DAHU_IN;
DAHU03H01_OUT:DAHU_OUT;
AHU03H01_SyncControl:IJ_SyncControl;
AHU03H01_DAHU:IJ_DAHU;
AHU03H01_RT_AVE :BS_Average;
AHU03H01_WVB_AVE:BS_Average;


DAHU03H02_IN :DAHU_IN;
DAHU03H02_OUT:DAHU_OUT;
AHU03H02_SyncControl:IJ_SyncControl;
AHU03H02_DAHU:IJ_DAHU;
AHU03H02_RT_AVE :BS_Average;
AHU03H02_WVB_AVE:BS_Average;


DAHU03H03_IN :DAHU_IN;
DAHU03H03_OUT:DAHU_OUT;
AHU03H03_SyncControl:IJ_SyncControl;
AHU03H03_DAHU:IJ_DAHU;
AHU03H03_RT_AVE :BS_Average;
AHU03H03_WVB_AVE:BS_Average;


DAHU03H04_IN :DAHU_IN;
DAHU03H04_OUT:DAHU_OUT;
AHU03H04_SyncControl:IJ_SyncControl;
AHU03H04_DAHU:IJ_DAHU;
AHU03H04_RT_AVE :BS_Average;
AHU03H04_WVB_AVE:BS_Average;


DAHU03H05_IN :DAHU_IN;
DAHU03H05_OUT:DAHU_OUT;
AHU03H05_SyncControl:IJ_SyncControl;
AHU03H05_DAHU:IJ_DAHU;
AHU03H05_RT_AVE :BS_Average;
AHU03H05_WVB_AVE:BS_Average;


DAHU03H06_IN :DAHU_IN;
DAHU03H06_OUT:DAHU_OUT;
AHU03H06_SyncControl:IJ_SyncControl;
AHU03H06_DAHU:IJ_DAHU;
AHU03H06_RT_AVE :BS_Average;
AHU03H06_WVB_AVE:BS_Average;


DAHU03H07_IN :DAHU_IN;
DAHU03H07_OUT:DAHU_OUT;
AHU03H07_SyncControl:IJ_SyncControl;
AHU03H07_DAHU:IJ_DAHU;
AHU03H07_RT_AVE :BS_Average;
AHU03H07_WVB_AVE:BS_Average;


DAHU03H08_IN :DAHU_IN;
DAHU03H08_OUT:DAHU_OUT;
AHU03H08_SyncControl:IJ_SyncControl;
AHU03H08_DAHU:IJ_DAHU;
AHU03H08_RT_AVE :BS_Average;
AHU03H08_WVB_AVE:BS_Average;


DAHU03H09_IN :DAHU_IN;
DAHU03H09_OUT:DAHU_OUT;
AHU03H09_SyncControl:IJ_SyncControl;
AHU03H09_DAHU:IJ_DAHU;
AHU03H09_RT_AVE :BS_Average;
AHU03H09_WVB_AVE:BS_Average;


DAHU03H10_IN :DAHU_IN;
DAHU03H10_OUT:DAHU_OUT;
AHU03H10_SyncControl:IJ_SyncControl;
AHU03H10_DAHU:IJ_DAHU;
AHU03H10_RT_AVE :BS_Average;
AHU03H10_WVB_AVE:BS_Average;


DAHU04H01_IN :DAHU_IN;
DAHU04H01_OUT:DAHU_OUT;
AHU04H01_SyncControl:IJ_SyncControl;
AHU04H01_DAHU:IJ_DAHU;
AHU04H01_RT_AVE :BS_Average;
AHU04H01_WVB_AVE:BS_Average;


DAHU04H02_IN :DAHU_IN;
DAHU04H02_OUT:DAHU_OUT;
AHU04H02_SyncControl:IJ_SyncControl;
AHU04H02_DAHU:IJ_DAHU;
AHU04H02_RT_AVE :BS_Average;
AHU04H02_WVB_AVE:BS_Average;


DAHU04H03_IN :DAHU_IN;
DAHU04H03_OUT:DAHU_OUT;
AHU04H03_SyncControl:IJ_SyncControl;
AHU04H03_DAHU:IJ_DAHU;
AHU04H03_RT_AVE :BS_Average;
AHU04H03_WVB_AVE:BS_Average;


DAHU04H04_IN :DAHU_IN;
DAHU04H04_OUT:DAHU_OUT;
AHU04H04_SyncControl:IJ_SyncControl;
AHU04H04_DAHU:IJ_DAHU;
AHU04H04_RT_AVE :BS_Average;
AHU04H04_WVB_AVE:BS_Average;


DAHU04H05_IN :DAHU_IN;
DAHU04H05_OUT:DAHU_OUT;
AHU04H05_SyncControl:IJ_SyncControl;
AHU04H05_DAHU:IJ_DAHU;
AHU04H05_RT_AVE :BS_Average;
AHU04H05_WVB_AVE:BS_Average;


DAHU04H06_IN :DAHU_IN;
DAHU04H06_OUT:DAHU_OUT;
AHU04H06_SyncControl:IJ_SyncControl;
AHU04H06_DAHU:IJ_DAHU;
AHU04H06_RT_AVE :BS_Average;
AHU04H06_WVB_AVE:BS_Average;


DAHU04H07_IN :DAHU_IN;
DAHU04H07_OUT:DAHU_OUT;
AHU04H07_SyncControl:IJ_SyncControl;
AHU04H07_DAHU:IJ_DAHU;
AHU04H07_RT_AVE :BS_Average;
AHU04H07_WVB_AVE:BS_Average;
END_VAR

(*Automatically declared*)
VAR_EXTERNAL
	LAHU04H07_SN : INT;
	LAHU04H07_SM : INT;
	LAHU04H01_WVBS : REAL;
	LAHU03H10_SN : INT;
	LAHU03H10_SM : INT;
	LAHU03H09_WVCS : INT;
	LAHU03H07_SN : INT;
	LAHU03H07_SM : INT;
	LAHU03H01_WVBS : REAL;
	LCMD00000_RM : INT;
	LAHU04H01_WVB : INT;
	LAHU03H09_WVC : INT;
	LAHU03H01_WVB : INT;
	LAHU03H09_F : BOOL;
	RAHU04H07_TSET : REAL;
	LAHU04H02_ISO2 : BOOL;
	LAHU04H02_ISO1 : BOOL;
	RAHU04H02_PC : BOOL;
	LAHU04H01_RTS : REAL;
	LAHU03H10_RH : REAL;
	RAHU03H10_PC : BOOL;
	LAHU03H09_WVBS : REAL;
	RAHU03H09_PC : BOOL;
	LAHU03H08_WVBS : REAL;
	RAHU03H07_TSET : REAL;
	LAHU03H02_ISO2 : BOOL;
	LAHU03H02_ISO1 : BOOL;
	RAHU03H02_PC : BOOL;
	LAHU03H01_RTS : REAL;
	LAHU03H10_RT : INT;
	LAHU03H09_WVB : INT;
	LAHU03H08_WVB : INT;
	LAHU03H10_C : BOOL;
	LAHU03H10_R : BOOL;
	LAHU04H07_TSET : REAL;
	LAHU04H06_WVMV : REAL;
	LAHU04H06_WVMC : BOOL;
	LAHU04H04_RTS : REAL;
	LAHU04H04_WVMV : REAL;
	LAHU04H04_WVMC : BOOL;
	LAHU04H03_WVCS : INT;
	LAHU04H03_TSET : REAL;
	RAHU04H03_SM : INT;
	LAHU04H02_WVBS : REAL;
	RAHU04H02_SM : INT;
	LAHU03H08_WVCS : INT;
	LAHU03H08_TSET : REAL;
	LAHU03H07_TSET : REAL;
	LAHU03H06_WVMV : REAL;
	LAHU03H06_WVMC : BOOL;
	LAHU03H04_RTS : REAL;
	LAHU03H04_WVMV : REAL;
	LAHU03H04_WVMC : BOOL;
	LAHU03H03_WVCS : INT;
	LAHU03H03_TSET : REAL;
	RAHU03H03_SM : INT;
	LAHU03H02_WVBS : REAL;
	RAHU03H02_SM : INT;
	LAHU04H03_WVC : INT;
	LAHU04H02_WVB : INT;
	LAHU04H06_FPS : BOOL;
	LAHU03H08_WVC : INT;
	LAHU03H03_WVC : INT;
	LAHU03H02_WVB : INT;
	LAHU03H10_FPS : BOOL;
	LAHU03H06_FPS : BOOL;
	RAHU04H07_SM : INT;
	LAHU04H06_ISO2 : BOOL;
	LAHU04H06_ISO1 : BOOL;
	RAHU04H04_SM : INT;
	LAHU04H03_WVBS : REAL;
	RAHU04H03_PC : BOOL;
	LAHU04H02_WVCS : INT;
	LAHU04H01_RH : REAL;
	RAHU04H01_PC : BOOL;
	LAHU03H10_RTS : REAL;
	LAHU03H09_RH : REAL;
	RAHU03H07_SM : INT;
	LAHU03H06_ISO2 : BOOL;
	LAHU03H06_ISO1 : BOOL;
	RAHU03H04_SM : INT;
	LAHU03H03_WVBS : REAL;
	RAHU03H03_PC : BOOL;
	LAHU03H02_WVCS : INT;
	LAHU03H01_RH : REAL;
	RAHU03H01_PC : BOOL;
	LAHU04H02_WVC : INT;
	LAHU04H03_WVB : INT;
	LAHU04H01_RT : INT;
	LAHU04H01_C : BOOL;
	LAHU04H01_R : BOOL;
	LAHU03H02_WVC : INT;
	LAHU03H09_RT : INT;
	LAHU03H03_WVB : INT;
	LAHU03H01_RT : INT;
	LAHU03H01_C : BOOL;
	LAHU03H09_R : BOOL;
	LAHU03H01_R : BOOL;
	LAHU04H07_WVMV : REAL;
	LAHU04H07_WVMC : BOOL;
	RAHU04H07_PC : BOOL;
	LAHU04H05_TSET : REAL;
	RAHU04H05_TSET : REAL;
	LAHU04H03_PC : BOOL;
	LAHU04H03_WVMV : REAL;
	LAHU04H03_WVMC : BOOL;
	LAHU04H02_SN : INT;
	LAHU04H02_SM : INT;
	LAHU04H01_SN : INT;
	LAHU04H01_SM : INT;
	LAHU03H09_SN : INT;
	LAHU03H09_ISO2 : BOOL;
	LAHU03H09_ISO1 : BOOL;
	LAHU03H09_RTS : REAL;
	LAHU03H09_SM : INT;
	RAHU03H09_SM : INT;
	LAHU03H07_WVMV : REAL;
	LAHU03H07_WVMC : BOOL;
	RAHU03H07_PC : BOOL;
	LAHU03H05_TSET : REAL;
	RAHU03H05_TSET : REAL;
	LAHU03H03_PC : BOOL;
	LAHU03H03_WVMV : REAL;
	LAHU03H03_WVMC : BOOL;
	LAHU03H02_SN : INT;
	LAHU03H02_SM : INT;
	LAHU03H01_SN : INT;
	LAHU03H01_SM : INT;
	LAHU04H03_A : BOOL;
	LAHU03H03_A : BOOL;
	LAHU04H07_RTS : REAL;
	LAHU04H06_TSET : REAL;
	LAHU04H05_ISO2 : BOOL;
	LAHU04H05_ISO1 : BOOL;
	LAHU04H02_RH : REAL;
	LAHU04H01_PC : BOOL;
	LAHU03H10_VI : REAL;
	LAHU03H10_VP : REAL;
	LAHU03H09_PC : BOOL;
	LAHU03H09_TSET : REAL;
	LAHU03H07_RTS : REAL;
	LAHU03H06_TSET : REAL;
	LAHU03H05_ISO2 : BOOL;
	LAHU03H05_ISO1 : BOOL;
	LAHU03H02_RH : REAL;
	LAHU03H01_PC : BOOL;
	LAHU04H02_RT : INT;
	LAHU04H02_C : BOOL;
	LAHU04H05_FPS : BOOL;
	LAHU04H04_FPS : BOOL;
	LAHU04H02_R : BOOL;
	LAHU04H01_A : BOOL;
	LAHU03H02_RT : INT;
	LAHU03H09_C : BOOL;
	LAHU03H02_C : BOOL;
	LAHU03H05_FPS : BOOL;
	LAHU03H04_FPS : BOOL;
	LAHU03H02_R : BOOL;
	LAHU03H01_A : BOOL;
	RNIAHU04X00_TSET : REAL;
	RNIAHU03X00_TSET : REAL;
	LAHU04H06_RSTV : REAL;
	LAHU04H06_RST : BOOL;
	RAHU04H04_PC : BOOL;
	LAHU04H03_RH : REAL;
	LAHU04H02_WVMV : REAL;
	LAHU04H02_WVMC : BOOL;
	RAHU04H01_SM : INT;
	LAHU03H10_RSTV : REAL;
	LAHU03H10_RST : BOOL;
	LAHU03H08_RTS : REAL;
	LAHU03H06_RSTV : REAL;
	LAHU03H06_RST : BOOL;
	RAHU03H04_PC : BOOL;
	LAHU03H03_RH : REAL;
	LAHU03H02_WVMV : REAL;
	LAHU03H02_WVMC : BOOL;
	RAHU03H01_SM : INT;
	LAHU04H03_RT : INT;
	LAHU04H03_C : BOOL;
	LAHU04H03_R : BOOL;
	LAHU03H03_RT : INT;
	LAHU03H03_C : BOOL;
	LAHU03H10_F : BOOL;
	LAHU03H03_R : BOOL;
	LAHU04H06_RTS : REAL;
	LAHU04H06_WVBS : REAL;
	LAHU04H03_SN : INT;
	LAHU04H03_SM : INT;
	LAHU04H02_PC : BOOL;
	LAHU03H10_ISO2 : BOOL;
	LAHU03H10_ISO1 : BOOL;
	LAHU03H08_ISO2 : BOOL;
	LAHU03H08_ISO1 : BOOL;
	LAHU03H06_RTS : REAL;
	LAHU03H06_WVBS : REAL;
	LAHU03H03_SN : INT;
	LAHU03H03_SM : INT;
	LAHU03H02_PC : BOOL;
	LAHU04H06_WVB : INT;
	LAHU04H04_F : BOOL;
	LAHU04H02_FPS : BOOL;
	LAHU04H02_A : BOOL;
	LAHU03H06_WVB : INT;
	LAHU03H09_A : BOOL;
	LAHU03H04_F : BOOL;
	LAHU03H02_FPS : BOOL;
	LAHU03H02_A : BOOL;
	LAHU04H06_WVCS : INT;
	LAHU04H05_WVCS : INT;
	LAHU04H04_VI : REAL;
	LAHU04H04_VP : REAL;
	LAHU04H03_RSTV : REAL;
	LAHU04H03_RST : BOOL;
	LAHU04H02_RTS : REAL;
	LAHU04H02_TSET : REAL;
	LAHU03H06_WVCS : INT;
	LAHU03H05_WVCS : INT;
	LAHU03H04_VI : REAL;
	LAHU03H04_VP : REAL;
	LAHU03H03_RSTV : REAL;
	LAHU03H03_RST : BOOL;
	LAHU03H02_RTS : REAL;
	LAHU03H02_TSET : REAL;
	LAHU04H06_WVC : INT;
	LAHU04H05_WVC : INT;
	LAHU04H07_FPS : BOOL;
	LAHU04H04_A : BOOL;
	LAHU03H06_WVC : INT;
	LAHU03H05_WVC : INT;
	LAHU03H07_FPS : BOOL;
	LAHU03H04_A : BOOL;
	RAHU04H06_PC : BOOL;
	LAHU04H05_WVBS : REAL;
	LAHU04H02_VI : REAL;
	LAHU04H02_VP : REAL;
	LAHU03H08_PC : BOOL;
	LAHU03H08_RSTV : REAL;
	LAHU03H08_RST : BOOL;
	RAHU03H06_PC : BOOL;
	LAHU03H05_WVBS : REAL;
	LAHU03H02_VI : REAL;
	LAHU03H02_VP : REAL;
	LAHU04H05_WVB : INT;
	LAHU04H03_F : BOOL;
	LAHU03H05_WVB : INT;
	LAHU03H08_A : BOOL;
	LAHU03H03_F : BOOL;
	RNIAHU04X00_SM : INT;
	RNIAHU03X00_SM : INT;
	LAHU04H07_RSTV : REAL;
	LAHU04H07_RST : BOOL;
	LAHU04H06_VI : REAL;
	LAHU04H06_VP : REAL;
	RAHU04H06_SM : INT;
	RAHU04H06_TSET : REAL;
	LAHU04H05_RH : REAL;
	LAHU04H05_RTS : REAL;
	LAHU04H04_PC : BOOL;
	LAHU04H04_ISO2 : BOOL;
	LAHU04H04_ISO1 : BOOL;
	LAHU04H03_VI : REAL;
	LAHU04H03_VP : REAL;
	LAHU03H08_SN : INT;
	LAHU03H08_SM : INT;
	LAHU03H07_RSTV : REAL;
	LAHU03H07_RST : BOOL;
	LAHU03H06_VI : REAL;
	LAHU03H06_VP : REAL;
	RAHU03H06_SM : INT;
	RAHU03H06_TSET : REAL;
	LAHU03H05_RH : REAL;
	LAHU03H05_RTS : REAL;
	LAHU03H04_PC : BOOL;
	LAHU03H04_ISO2 : BOOL;
	LAHU03H04_ISO1 : BOOL;
	LAHU03H03_VI : REAL;
	LAHU03H03_VP : REAL;
	LAHU04H05_RT : INT;
	LAHU04H04_C : BOOL;
	LAHU04H05_R : BOOL;
	LAHU04H02_F : BOOL;
	LAHU03H05_RT : INT;
	LAHU03H04_C : BOOL;
	LAHU03H05_R : BOOL;
	LAHU03H02_F : BOOL;
	RNIAHU04X00_PC : BOOL;
	RNIAHU03X00_PC : BOOL;
	RNIAHU00000_CM : BOOL;
	LAHU04H07_WVCS : INT;
	LAHU04H05_SN : INT;
	LAHU04H05_RSTV : REAL;
	LAHU04H05_RST : BOOL;
	LAHU04H05_SM : INT;
	LAHU04H04_SN : INT;
	LAHU04H04_SM : INT;
	LAHU04H03_RTS : REAL;
	LAHU04H01_RSTV : REAL;
	LAHU04H01_RST : BOOL;
	RAHU03H09_TSET : REAL;
	LAHU03H08_RH : REAL;
	LAHU03H07_WVCS : INT;
	LAHU03H05_SN : INT;
	LAHU03H05_RSTV : REAL;
	LAHU03H05_RST : BOOL;
	LAHU03H05_SM : INT;
	LAHU03H04_SN : INT;
	LAHU03H04_SM : INT;
	LAHU03H03_RTS : REAL;
	LAHU03H01_RSTV : REAL;
	LAHU03H01_RST : BOOL;
	LAHU04H07_WVC : INT;
	LAHU04H07_F : BOOL;
	LAHU04H06_F : BOOL;
	LAHU03H07_WVC : INT;
	LAHU03H08_RT : INT;
	LAHU03H08_C : BOOL;
	LAHU03H08_R : BOOL;
	LAHU03H07_F : BOOL;
	LAHU03H06_F : BOOL;
	LAHU04H07_VI : REAL;
	LAHU04H07_VP : REAL;
	LAHU04H07_WVBS : REAL;
	LAHU04H05_PC : BOOL;
	RAHU04H05_PC : BOOL;
	LAHU04H04_RH : REAL;
	LAHU04H04_WVBS : REAL;
	LAHU04H04_TSET : REAL;
	LAHU04H01_TSET : REAL;
	RAHU04H01_TSET : REAL;
	LAHU03H07_VI : REAL;
	LAHU03H07_VP : REAL;
	LAHU03H07_WVBS : REAL;
	LAHU03H05_PC : BOOL;
	RAHU03H05_PC : BOOL;
	LAHU03H04_RH : REAL;
	LAHU03H04_WVBS : REAL;
	LAHU03H04_TSET : REAL;
	LAHU03H01_TSET : REAL;
	RAHU03H01_TSET : REAL;
	LAHU04H07_WVB : INT;
	LAHU04H04_WVB : INT;
	LAHU04H04_RT : INT;
	LAHU04H05_C : BOOL;
	LAHU04H04_R : BOOL;
	LAHU03H07_WVB : INT;
	LAHU03H04_WVB : INT;
	LAHU03H04_RT : INT;
	LAHU03H05_C : BOOL;
	LAHU03H08_FPS : BOOL;
	LAHU03H04_R : BOOL;
	LAHU04H06_SN : INT;
	LAHU04H06_SM : INT;
	LAHU04H04_WVCS : INT;
	LAHU04H01_WVMV : REAL;
	LAHU04H01_WVMC : BOOL;
	LAHU03H10_WVMV : REAL;
	LAHU03H10_WVMC : BOOL;
	RAHU03H08_SM : INT;
	RAHU03H08_TSET : REAL;
	LAHU03H06_SN : INT;
	LAHU03H06_SM : INT;
	LAHU03H04_WVCS : INT;
	LAHU03H01_WVMV : REAL;
	LAHU03H01_WVMC : BOOL;
	LAHU04H04_WVC : INT;
	LAHU03H04_WVC : INT;
	LAHU04H07_PC : BOOL;
	LAHU04H06_RH : REAL;
	LAHU04H05_VI : REAL;
	LAHU04H05_VP : REAL;
	LAHU04H04_RSTV : REAL;
	LAHU04H04_RST : BOOL;
	RAHU04H04_TSET : REAL;
	LAHU03H10_WVBS : REAL;
	RAHU03H10_TSET : REAL;
	LAHU03H09_RSTV : REAL;
	LAHU03H09_RST : BOOL;
	LAHU03H07_PC : BOOL;
	LAHU03H06_RH : REAL;
	LAHU03H05_VI : REAL;
	LAHU03H05_VP : REAL;
	LAHU03H04_RSTV : REAL;
	LAHU03H04_RST : BOOL;
	RAHU03H04_TSET : REAL;
	LAHU04H06_RT : INT;
	LAHU04H06_C : BOOL;
	LAHU04H07_A : BOOL;
	LAHU04H06_R : BOOL;
	LAHU04H05_A : BOOL;
	LAHU04H01_FPS : BOOL;
	LAHU03H10_WVB : INT;
	LAHU03H06_RT : INT;
	LAHU03H06_C : BOOL;
	LAHU03H07_A : BOOL;
	LAHU03H06_R : BOOL;
	LAHU03H05_A : BOOL;
	LAHU03H01_FPS : BOOL;
	LAHU04H07_ISO2 : BOOL;
	LAHU04H07_ISO1 : BOOL;
	LAHU04H05_WVMV : REAL;
	LAHU04H05_WVMC : BOOL;
	RAHU04H05_SM : INT;
	RAHU04H03_TSET : REAL;
	LAHU04H02_RSTV : REAL;
	LAHU04H02_RST : BOOL;
	RAHU04H02_TSET : REAL;
	LAHU03H10_WVCS : INT;
	LAHU03H10_TSET : REAL;
	RAHU03H10_SM : INT;
	LAHU03H09_WVMV : REAL;
	LAHU03H09_WVMC : BOOL;
	LAHU03H08_VI : REAL;
	LAHU03H08_VP : REAL;
	LAHU03H07_ISO2 : BOOL;
	LAHU03H07_ISO1 : BOOL;
	LAHU03H05_WVMV : REAL;
	LAHU03H05_WVMC : BOOL;
	RAHU03H05_SM : INT;
	RAHU03H03_TSET : REAL;
	LAHU03H02_RSTV : REAL;
	LAHU03H02_RST : BOOL;
	RAHU03H02_TSET : REAL;
	LAHU04H05_F : BOOL;
	LAHU04H01_F : BOOL;
	LAHU03H10_WVC : INT;
	LAHU03H05_F : BOOL;
	LAHU03H01_F : BOOL;
	LAHU04H07_RH : REAL;
	LAHU04H06_PC : BOOL;
	LAHU04H03_ISO2 : BOOL;
	LAHU04H03_ISO1 : BOOL;
	LAHU04H01_WVCS : INT;
	LAHU04H01_VI : REAL;
	LAHU04H01_VP : REAL;
	LAHU04H01_ISO2 : BOOL;
	LAHU04H01_ISO1 : BOOL;
	LAHU03H10_PC : BOOL;
	LAHU03H09_VI : REAL;
	LAHU03H09_VP : REAL;
	LAHU03H08_WVMV : REAL;
	LAHU03H08_WVMC : BOOL;
	RAHU03H08_PC : BOOL;
	LAHU03H07_RH : REAL;
	LAHU03H06_PC : BOOL;
	LAHU03H03_ISO2 : BOOL;
	LAHU03H03_ISO1 : BOOL;
	LAHU03H01_WVCS : INT;
	LAHU03H01_VI : REAL;
	LAHU03H01_VP : REAL;
	LAHU03H01_ISO2 : BOOL;
	LAHU03H01_ISO1 : BOOL;
	LAHU04H01_WVC : INT;
	LAHU04H07_RT : INT;
	LAHU04H07_C : BOOL;
	LAHU04H07_R : BOOL;
	LAHU04H06_A : BOOL;
	LAHU04H03_FPS : BOOL;
	LAHU03H01_WVC : INT;
	LAHU03H07_RT : INT;
	LAHU03H07_C : BOOL;
	LAHU03H10_A : BOOL;
	LAHU03H09_FPS : BOOL;
	LAHU03H08_F : BOOL;
	LAHU03H07_R : BOOL;
	LAHU03H06_A : BOOL;
	LAHU03H03_FPS : BOOL;
END_VAR
(** 	{********************************************AHU03H01********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU03H01_WVB_AVE(INPUT:=LAHU03H01_WVB); **)
	(* call - Stmt *)
	CAL AHU03H01_WVB_AVE (
		INPUT := LAHU03H01_WVB
	)

(** 	AHU03H01_RT_AVE (INPUT:=LAHU03H01_RT) ; **)
	(* call - Stmt *)
	CAL AHU03H01_RT_AVE (
		INPUT := LAHU03H01_RT
	)

(** 	LAHU03H01_RTS :=            BS_Scale(AHU03H01_RT_AVE.Output ,1,0,100,0,-5.0) ; **)
	(* assign - Stmt *)
	LD AHU03H01_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, -5.0
	ST LAHU03H01_RTS

(** 	LAHU03H01_WVBS:=            BS_Scale(AHU03H01_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H01_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU03H01_WVBS

(** 	LAHU03H01_WVC :=REAL_TO_INT(BS_Scale(LAHU03H01_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU03H01_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU03H01_WVC

(** 	{*������*} **)
(** 	AHU03H01_DAHU(DAHU_STRUCT_IN:=DAHU03H01_IN | DAHU03H01_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU03H01_DAHU (
		DAHU_STRUCT_IN := DAHU03H01_IN
		|
		DAHU03H01_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU03H01_IN.SM     :=LAHU03H01_SM         ; **)
	(* assign - Stmt *)
	LD LAHU03H01_SM
	ST DAHU03H01_IN.SM

(** 	DAHU03H01_IN.Run    :=LAHU03H01_R          ; **)
	(* assign - Stmt *)
	LD LAHU03H01_R
	ST DAHU03H01_IN.Run

(** 	DAHU03H01_IN.Fault  :=LAHU03H01_F          ; **)
	(* assign - Stmt *)
	LD LAHU03H01_F
	ST DAHU03H01_IN.Fault

(** 	DAHU03H01_IN.Auto   :=LAHU03H01_A          ; **)
	(* assign - Stmt *)
	LD LAHU03H01_A
	ST DAHU03H01_IN.Auto

(** 	DAHU03H01_IN.ContRol:=LAHU03H01_PC         ; **)
	(* assign - Stmt *)
	LD LAHU03H01_PC
	ST DAHU03H01_IN.ContRol

(** 	DAHU03H01_IN.TSET   :=LAHU03H01_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU03H01_TSET
	ST DAHU03H01_IN.TSET

(** 	DAHU03H01_IN.WVMC   :=LAHU03H01_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU03H01_WVMC
	ST DAHU03H01_IN.WVMC

(** 	DAHU03H01_IN.WVMV   :=LAHU03H01_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU03H01_WVMV
	ST DAHU03H01_IN.WVMV

(** 	DAHU03H01_IN.RTS    :=LAHU03H01_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU03H01_RTS
	ST DAHU03H01_IN.RTS

(** 	DAHU03H01_IN.RST    :=LAHU03H01_RST        ; **)
	(* assign - Stmt *)
	LD LAHU03H01_RST
	ST DAHU03H01_IN.RST

(** 	DAHU03H01_IN.RSTV   :=LAHU03H01_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU03H01_RSTV
	ST DAHU03H01_IN.RSTV

(** 	DAHU03H01_IN.FPS    :=LAHU03H01_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU03H01_FPS
	ST DAHU03H01_IN.FPS

(** 	DAHU03H01_IN.ISO1   :=LAHU03H01_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU03H01_ISO1
	ST DAHU03H01_IN.ISO1

(** 	DAHU03H01_IN.ISO2   :=LAHU03H01_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU03H01_ISO2
	ST DAHU03H01_IN.ISO2

(** 	DAHU03H01_IN.VP     :=LAHU03H01_VP         ; **)
	(* assign - Stmt *)
	LD LAHU03H01_VP
	ST DAHU03H01_IN.VP

(** 	DAHU03H01_IN.VI     :=LAHU03H01_VI         ; **)
	(* assign - Stmt *)
	LD LAHU03H01_VI
	ST DAHU03H01_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU03H01_WVCS      :=DAHU03H01_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU03H01_OUT.WVCS
	ST LAHU03H01_WVCS

(** 	LAHU03H01_C         :=DAHU03H01_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU03H01_OUT.ContRol
	ST LAHU03H01_C

(** 	LAHU03H01_RH        :=DAHU03H01_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU03H01_OUT.RH
	ST LAHU03H01_RH

(** 	LAHU03H01_SN        :=DAHU03H01_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU03H01_OUT.SN
	ST LAHU03H01_SN

(** 	{*ͬ������*} **)
(** 	AHU03H01_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU03H01_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU03X00_PC  ,BOOL_IN1:=LAHU03H01_PC  ,BOOL_IN2      :=RAHU03H01_PC  , **)
		BOOL_IN0 := RNIAHU03X00_PC,
		BOOL_IN1 := LAHU03H01_PC,
		BOOL_IN2 := RAHU03H01_PC,
(** 	                             REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03H01_TSET,REAL_IN2      :=RAHU03H01_TSET, **)
		REAL_IN0 := RNIAHU03X00_TSET,
		REAL_IN1 := LAHU03H01_TSET,
		REAL_IN2 := RAHU03H01_TSET,
(** 	                             INT_IN0 :=RNIAHU03X00_SM  ,INT_IN1 :=LAHU03H01_SM  ,INT_IN2       :=RAHU03H01_SM  | **)
		INT_IN0 := RNIAHU03X00_SM,
		INT_IN1 := LAHU03H01_SM,
		INT_IN2 := RAHU03H01_SM
		|
(** 	                                                  LAHU03H01_PC  :=BOOL_OUT1     ,RAHU03H01_PC  :=BOOL_OUT2     , **)
		LAHU03H01_PC := BOOL_OUT1,
		RAHU03H01_PC := BOOL_OUT2,
(** 	                                                  LAHU03H01_TSET:=REAL_OUT1     ,RAHU03H01_TSET:=REAL_OUT2     , **)
		LAHU03H01_TSET := REAL_OUT1,
		RAHU03H01_TSET := REAL_OUT2,
(** 	                                                  LAHU03H01_SM  :=INT_OUT1      ,RAHU03H01_SM  :=INT_OUT2)     ; **)
		LAHU03H01_SM := INT_OUT1,
		RAHU03H01_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU03H02********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU03H02_WVB_AVE(INPUT:=LAHU03H02_WVB); **)
	(* call - Stmt *)
	CAL AHU03H02_WVB_AVE (
		INPUT := LAHU03H02_WVB
	)

(** 	AHU03H02_RT_AVE (INPUT:=LAHU03H02_RT) ; **)
	(* call - Stmt *)
	CAL AHU03H02_RT_AVE (
		INPUT := LAHU03H02_RT
	)

(** 	LAHU03H02_RTS :=            BS_Scale(AHU03H02_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H02_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU03H02_RTS

(** 	LAHU03H02_WVBS:=            BS_Scale(AHU03H02_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H02_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU03H02_WVBS

(** 	LAHU03H02_WVC :=REAL_TO_INT(BS_Scale(LAHU03H02_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU03H02_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU03H02_WVC

(** 	{*������*} **)
(** 	AHU03H02_DAHU(DAHU_STRUCT_IN:=DAHU03H02_IN | DAHU03H02_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU03H02_DAHU (
		DAHU_STRUCT_IN := DAHU03H02_IN
		|
		DAHU03H02_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU03H02_IN.SM     :=LAHU03H02_SM         ; **)
	(* assign - Stmt *)
	LD LAHU03H02_SM
	ST DAHU03H02_IN.SM

(** 	DAHU03H02_IN.Run    :=LAHU03H02_R          ; **)
	(* assign - Stmt *)
	LD LAHU03H02_R
	ST DAHU03H02_IN.Run

(** 	DAHU03H02_IN.Fault  :=LAHU03H02_F          ; **)
	(* assign - Stmt *)
	LD LAHU03H02_F
	ST DAHU03H02_IN.Fault

(** 	DAHU03H02_IN.Auto   :=LAHU03H02_A          ; **)
	(* assign - Stmt *)
	LD LAHU03H02_A
	ST DAHU03H02_IN.Auto

(** 	DAHU03H02_IN.ContRol:=LAHU03H02_PC         ; **)
	(* assign - Stmt *)
	LD LAHU03H02_PC
	ST DAHU03H02_IN.ContRol

(** 	DAHU03H02_IN.TSET   :=LAHU03H02_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU03H02_TSET
	ST DAHU03H02_IN.TSET

(** 	DAHU03H02_IN.WVMC   :=LAHU03H02_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU03H02_WVMC
	ST DAHU03H02_IN.WVMC

(** 	DAHU03H02_IN.WVMV   :=LAHU03H02_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU03H02_WVMV
	ST DAHU03H02_IN.WVMV

(** 	DAHU03H02_IN.RTS    :=LAHU03H02_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU03H02_RTS
	ST DAHU03H02_IN.RTS

(** 	DAHU03H02_IN.RST    :=LAHU03H02_RST        ; **)
	(* assign - Stmt *)
	LD LAHU03H02_RST
	ST DAHU03H02_IN.RST

(** 	DAHU03H02_IN.RSTV   :=LAHU03H02_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU03H02_RSTV
	ST DAHU03H02_IN.RSTV

(** 	DAHU03H02_IN.FPS    :=LAHU03H02_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU03H02_FPS
	ST DAHU03H02_IN.FPS

(** 	DAHU03H02_IN.ISO1   :=LAHU03H02_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU03H02_ISO1
	ST DAHU03H02_IN.ISO1

(** 	DAHU03H02_IN.ISO2   :=LAHU03H02_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU03H02_ISO2
	ST DAHU03H02_IN.ISO2

(** 	DAHU03H02_IN.VP     :=LAHU03H02_VP         ; **)
	(* assign - Stmt *)
	LD LAHU03H02_VP
	ST DAHU03H02_IN.VP

(** 	DAHU03H02_IN.VI     :=LAHU03H02_VI         ; **)
	(* assign - Stmt *)
	LD LAHU03H02_VI
	ST DAHU03H02_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU03H02_WVCS      :=DAHU03H02_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU03H02_OUT.WVCS
	ST LAHU03H02_WVCS

(** 	LAHU03H02_C         :=DAHU03H02_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU03H02_OUT.ContRol
	ST LAHU03H02_C

(** 	LAHU03H02_RH        :=DAHU03H02_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU03H02_OUT.RH
	ST LAHU03H02_RH

(** 	LAHU03H02_SN        :=DAHU03H02_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU03H02_OUT.SN
	ST LAHU03H02_SN

(** 	{*ͬ������*} **)
(** 	AHU03H02_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU03H02_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU03X00_PC  ,BOOL_IN1:=LAHU03H02_PC  ,BOOL_IN2      :=RAHU03H02_PC  , **)
		BOOL_IN0 := RNIAHU03X00_PC,
		BOOL_IN1 := LAHU03H02_PC,
		BOOL_IN2 := RAHU03H02_PC,
(** 	                             REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03H02_TSET,REAL_IN2      :=RAHU03H02_TSET, **)
		REAL_IN0 := RNIAHU03X00_TSET,
		REAL_IN1 := LAHU03H02_TSET,
		REAL_IN2 := RAHU03H02_TSET,
(** 	                             INT_IN0 :=RNIAHU03X00_SM  ,INT_IN1 :=LAHU03H02_SM  ,INT_IN2       :=RAHU03H02_SM  | **)
		INT_IN0 := RNIAHU03X00_SM,
		INT_IN1 := LAHU03H02_SM,
		INT_IN2 := RAHU03H02_SM
		|
(** 	                                                  LAHU03H02_PC  :=BOOL_OUT1     ,RAHU03H02_PC  :=BOOL_OUT2     , **)
		LAHU03H02_PC := BOOL_OUT1,
		RAHU03H02_PC := BOOL_OUT2,
(** 	                                                  LAHU03H02_TSET:=REAL_OUT1     ,RAHU03H02_TSET:=REAL_OUT2     , **)
		LAHU03H02_TSET := REAL_OUT1,
		RAHU03H02_TSET := REAL_OUT2,
(** 	                                                  LAHU03H02_SM  :=INT_OUT1      ,RAHU03H02_SM  :=INT_OUT2)     ; **)
		LAHU03H02_SM := INT_OUT1,
		RAHU03H02_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU03H03********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU03H03_WVB_AVE(INPUT:=LAHU03H03_WVB); **)
	(* call - Stmt *)
	CAL AHU03H03_WVB_AVE (
		INPUT := LAHU03H03_WVB
	)

(** 	AHU03H03_RT_AVE (INPUT:=LAHU03H03_RT) ; **)
	(* call - Stmt *)
	CAL AHU03H03_RT_AVE (
		INPUT := LAHU03H03_RT
	)

(** 	LAHU03H03_RTS :=            BS_Scale(AHU03H03_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H03_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU03H03_RTS

(** 	LAHU03H03_WVBS:=            BS_Scale(AHU03H03_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H03_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU03H03_WVBS

(** 	LAHU03H03_WVC :=REAL_TO_INT(BS_Scale(LAHU03H03_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU03H03_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU03H03_WVC

(** 	{*������*} **)
(** 	AHU03H03_DAHU(DAHU_STRUCT_IN:=DAHU03H03_IN | DAHU03H03_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU03H03_DAHU (
		DAHU_STRUCT_IN := DAHU03H03_IN
		|
		DAHU03H03_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU03H03_IN.SM     :=LAHU03H03_SM         ; **)
	(* assign - Stmt *)
	LD LAHU03H03_SM
	ST DAHU03H03_IN.SM

(** 	DAHU03H03_IN.Run    :=LAHU03H03_R          ; **)
	(* assign - Stmt *)
	LD LAHU03H03_R
	ST DAHU03H03_IN.Run

(** 	DAHU03H03_IN.Fault  :=LAHU03H03_F          ; **)
	(* assign - Stmt *)
	LD LAHU03H03_F
	ST DAHU03H03_IN.Fault

(** 	DAHU03H03_IN.Auto   :=LAHU03H03_A          ; **)
	(* assign - Stmt *)
	LD LAHU03H03_A
	ST DAHU03H03_IN.Auto

(** 	DAHU03H03_IN.ContRol:=LAHU03H03_PC         ; **)
	(* assign - Stmt *)
	LD LAHU03H03_PC
	ST DAHU03H03_IN.ContRol

(** 	DAHU03H03_IN.TSET   :=LAHU03H03_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU03H03_TSET
	ST DAHU03H03_IN.TSET

(** 	DAHU03H03_IN.WVMC   :=LAHU03H03_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU03H03_WVMC
	ST DAHU03H03_IN.WVMC

(** 	DAHU03H03_IN.WVMV   :=LAHU03H03_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU03H03_WVMV
	ST DAHU03H03_IN.WVMV

(** 	DAHU03H03_IN.RTS    :=LAHU03H03_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU03H03_RTS
	ST DAHU03H03_IN.RTS

(** 	DAHU03H03_IN.RST    :=LAHU03H03_RST        ; **)
	(* assign - Stmt *)
	LD LAHU03H03_RST
	ST DAHU03H03_IN.RST

(** 	DAHU03H03_IN.RSTV   :=LAHU03H03_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU03H03_RSTV
	ST DAHU03H03_IN.RSTV

(** 	DAHU03H03_IN.FPS    :=LAHU03H03_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU03H03_FPS
	ST DAHU03H03_IN.FPS

(** 	DAHU03H03_IN.ISO1   :=LAHU03H03_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU03H03_ISO1
	ST DAHU03H03_IN.ISO1

(** 	DAHU03H03_IN.ISO2   :=LAHU03H03_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU03H03_ISO2
	ST DAHU03H03_IN.ISO2

(** 	DAHU03H03_IN.VP     :=LAHU03H03_VP         ; **)
	(* assign - Stmt *)
	LD LAHU03H03_VP
	ST DAHU03H03_IN.VP

(** 	DAHU03H03_IN.VI     :=LAHU03H03_VI         ; **)
	(* assign - Stmt *)
	LD LAHU03H03_VI
	ST DAHU03H03_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU03H03_WVCS      :=DAHU03H03_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU03H03_OUT.WVCS
	ST LAHU03H03_WVCS

(** 	LAHU03H03_C         :=DAHU03H03_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU03H03_OUT.ContRol
	ST LAHU03H03_C

(** 	LAHU03H03_RH        :=DAHU03H03_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU03H03_OUT.RH
	ST LAHU03H03_RH

(** 	LAHU03H03_SN        :=DAHU03H03_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU03H03_OUT.SN
	ST LAHU03H03_SN

(** 	{*ͬ������*} **)
(** 	AHU03H03_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU03H03_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU03X00_PC  ,BOOL_IN1:=LAHU03H03_PC  ,BOOL_IN2      :=RAHU03H03_PC  , **)
		BOOL_IN0 := RNIAHU03X00_PC,
		BOOL_IN1 := LAHU03H03_PC,
		BOOL_IN2 := RAHU03H03_PC,
(** 	                             REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03H03_TSET,REAL_IN2      :=RAHU03H03_TSET, **)
		REAL_IN0 := RNIAHU03X00_TSET,
		REAL_IN1 := LAHU03H03_TSET,
		REAL_IN2 := RAHU03H03_TSET,
(** 	                             INT_IN0 :=RNIAHU03X00_SM  ,INT_IN1 :=LAHU03H03_SM  ,INT_IN2       :=RAHU03H03_SM  | **)
		INT_IN0 := RNIAHU03X00_SM,
		INT_IN1 := LAHU03H03_SM,
		INT_IN2 := RAHU03H03_SM
		|
(** 	                                                  LAHU03H03_PC  :=BOOL_OUT1     ,RAHU03H03_PC  :=BOOL_OUT2     , **)
		LAHU03H03_PC := BOOL_OUT1,
		RAHU03H03_PC := BOOL_OUT2,
(** 	                                                  LAHU03H03_TSET:=REAL_OUT1     ,RAHU03H03_TSET:=REAL_OUT2     , **)
		LAHU03H03_TSET := REAL_OUT1,
		RAHU03H03_TSET := REAL_OUT2,
(** 	                                                  LAHU03H03_SM  :=INT_OUT1      ,RAHU03H03_SM  :=INT_OUT2)     ; **)
		LAHU03H03_SM := INT_OUT1,
		RAHU03H03_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU03H04********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU03H04_WVB_AVE(INPUT:=LAHU03H04_WVB); **)
	(* call - Stmt *)
	CAL AHU03H04_WVB_AVE (
		INPUT := LAHU03H04_WVB
	)

(** 	AHU03H04_RT_AVE (INPUT:=LAHU03H04_RT) ; **)
	(* call - Stmt *)
	CAL AHU03H04_RT_AVE (
		INPUT := LAHU03H04_RT
	)

(** 	LAHU03H04_RTS :=            BS_Scale(AHU03H04_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H04_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU03H04_RTS

(** 	LAHU03H04_WVBS:=            BS_Scale(AHU03H04_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H04_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU03H04_WVBS

(** 	LAHU03H04_WVC :=REAL_TO_INT(BS_Scale(LAHU03H04_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU03H04_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU03H04_WVC

(** 	{*������*} **)
(** 	AHU03H04_DAHU(DAHU_STRUCT_IN:=DAHU03H04_IN | DAHU03H04_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU03H04_DAHU (
		DAHU_STRUCT_IN := DAHU03H04_IN
		|
		DAHU03H04_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU03H04_IN.SM     :=LAHU03H04_SM         ; **)
	(* assign - Stmt *)
	LD LAHU03H04_SM
	ST DAHU03H04_IN.SM

(** 	DAHU03H04_IN.Run    :=LAHU03H04_R          ; **)
	(* assign - Stmt *)
	LD LAHU03H04_R
	ST DAHU03H04_IN.Run

(** 	DAHU03H04_IN.Fault  :=LAHU03H04_F          ; **)
	(* assign - Stmt *)
	LD LAHU03H04_F
	ST DAHU03H04_IN.Fault

(** 	DAHU03H04_IN.Auto   :=LAHU03H04_A          ; **)
	(* assign - Stmt *)
	LD LAHU03H04_A
	ST DAHU03H04_IN.Auto

(** 	DAHU03H04_IN.ContRol:=LAHU03H04_PC         ; **)
	(* assign - Stmt *)
	LD LAHU03H04_PC
	ST DAHU03H04_IN.ContRol

(** 	DAHU03H04_IN.TSET   :=LAHU03H04_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU03H04_TSET
	ST DAHU03H04_IN.TSET

(** 	DAHU03H04_IN.WVMC   :=LAHU03H04_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU03H04_WVMC
	ST DAHU03H04_IN.WVMC

(** 	DAHU03H04_IN.WVMV   :=LAHU03H04_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU03H04_WVMV
	ST DAHU03H04_IN.WVMV

(** 	DAHU03H04_IN.RTS    :=LAHU03H04_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU03H04_RTS
	ST DAHU03H04_IN.RTS

(** 	DAHU03H04_IN.RST    :=LAHU03H04_RST        ; **)
	(* assign - Stmt *)
	LD LAHU03H04_RST
	ST DAHU03H04_IN.RST

(** 	DAHU03H04_IN.RSTV   :=LAHU03H04_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU03H04_RSTV
	ST DAHU03H04_IN.RSTV

(** 	DAHU03H04_IN.FPS    :=LAHU03H04_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU03H04_FPS
	ST DAHU03H04_IN.FPS

(** 	DAHU03H04_IN.ISO1   :=LAHU03H04_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU03H04_ISO1
	ST DAHU03H04_IN.ISO1

(** 	DAHU03H04_IN.ISO2   :=LAHU03H04_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU03H04_ISO2
	ST DAHU03H04_IN.ISO2

(** 	DAHU03H04_IN.VP     :=LAHU03H04_VP         ; **)
	(* assign - Stmt *)
	LD LAHU03H04_VP
	ST DAHU03H04_IN.VP

(** 	DAHU03H04_IN.VI     :=LAHU03H04_VI         ; **)
	(* assign - Stmt *)
	LD LAHU03H04_VI
	ST DAHU03H04_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU03H04_WVCS      :=DAHU03H04_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU03H04_OUT.WVCS
	ST LAHU03H04_WVCS

(** 	LAHU03H04_C         :=DAHU03H04_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU03H04_OUT.ContRol
	ST LAHU03H04_C

(** 	LAHU03H04_RH        :=DAHU03H04_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU03H04_OUT.RH
	ST LAHU03H04_RH

(** 	LAHU03H04_SN        :=DAHU03H04_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU03H04_OUT.SN
	ST LAHU03H04_SN

(** 	{*ͬ������*} **)
(** 	AHU03H04_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU03H04_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU03X00_PC  ,BOOL_IN1:=LAHU03H04_PC  ,BOOL_IN2      :=RAHU03H04_PC  , **)
		BOOL_IN0 := RNIAHU03X00_PC,
		BOOL_IN1 := LAHU03H04_PC,
		BOOL_IN2 := RAHU03H04_PC,
(** 	                             REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03H04_TSET,REAL_IN2      :=RAHU03H04_TSET, **)
		REAL_IN0 := RNIAHU03X00_TSET,
		REAL_IN1 := LAHU03H04_TSET,
		REAL_IN2 := RAHU03H04_TSET,
(** 	                             INT_IN0 :=RNIAHU03X00_SM  ,INT_IN1 :=LAHU03H04_SM  ,INT_IN2       :=RAHU03H04_SM  | **)
		INT_IN0 := RNIAHU03X00_SM,
		INT_IN1 := LAHU03H04_SM,
		INT_IN2 := RAHU03H04_SM
		|
(** 	                                                  LAHU03H04_PC  :=BOOL_OUT1     ,RAHU03H04_PC  :=BOOL_OUT2     , **)
		LAHU03H04_PC := BOOL_OUT1,
		RAHU03H04_PC := BOOL_OUT2,
(** 	                                                  LAHU03H04_TSET:=REAL_OUT1     ,RAHU03H04_TSET:=REAL_OUT2     , **)
		LAHU03H04_TSET := REAL_OUT1,
		RAHU03H04_TSET := REAL_OUT2,
(** 	                                                  LAHU03H04_SM  :=INT_OUT1      ,RAHU03H04_SM  :=INT_OUT2)     ; **)
		LAHU03H04_SM := INT_OUT1,
		RAHU03H04_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU03H05********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU03H05_WVB_AVE(INPUT:=LAHU03H05_WVB); **)
	(* call - Stmt *)
	CAL AHU03H05_WVB_AVE (
		INPUT := LAHU03H05_WVB
	)

(** 	AHU03H05_RT_AVE (INPUT:=LAHU03H05_RT) ; **)
	(* call - Stmt *)
	CAL AHU03H05_RT_AVE (
		INPUT := LAHU03H05_RT
	)

(** 	LAHU03H05_RTS :=            BS_Scale(AHU03H05_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H05_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU03H05_RTS

(** 	LAHU03H05_WVBS:=            BS_Scale(AHU03H05_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H05_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU03H05_WVBS

(** 	LAHU03H05_WVC :=REAL_TO_INT(BS_Scale(LAHU03H05_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU03H05_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU03H05_WVC

(** 	{*������*} **)
(** 	AHU03H05_DAHU(DAHU_STRUCT_IN:=DAHU03H05_IN | DAHU03H05_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU03H05_DAHU (
		DAHU_STRUCT_IN := DAHU03H05_IN
		|
		DAHU03H05_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU03H05_IN.SM     :=LAHU03H05_SM         ; **)
	(* assign - Stmt *)
	LD LAHU03H05_SM
	ST DAHU03H05_IN.SM

(** 	DAHU03H05_IN.Run    :=LAHU03H05_R          ; **)
	(* assign - Stmt *)
	LD LAHU03H05_R
	ST DAHU03H05_IN.Run

(** 	DAHU03H05_IN.Fault  :=LAHU03H05_F          ; **)
	(* assign - Stmt *)
	LD LAHU03H05_F
	ST DAHU03H05_IN.Fault

(** 	DAHU03H05_IN.Auto   :=LAHU03H05_A          ; **)
	(* assign - Stmt *)
	LD LAHU03H05_A
	ST DAHU03H05_IN.Auto

(** 	DAHU03H05_IN.ContRol:=LAHU03H05_PC         ; **)
	(* assign - Stmt *)
	LD LAHU03H05_PC
	ST DAHU03H05_IN.ContRol

(** 	DAHU03H05_IN.TSET   :=LAHU03H05_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU03H05_TSET
	ST DAHU03H05_IN.TSET

(** 	DAHU03H05_IN.WVMC   :=LAHU03H05_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU03H05_WVMC
	ST DAHU03H05_IN.WVMC

(** 	DAHU03H05_IN.WVMV   :=LAHU03H05_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU03H05_WVMV
	ST DAHU03H05_IN.WVMV

(** 	DAHU03H05_IN.RTS    :=LAHU03H05_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU03H05_RTS
	ST DAHU03H05_IN.RTS

(** 	DAHU03H05_IN.RST    :=LAHU03H05_RST        ; **)
	(* assign - Stmt *)
	LD LAHU03H05_RST
	ST DAHU03H05_IN.RST

(** 	DAHU03H05_IN.RSTV   :=LAHU03H05_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU03H05_RSTV
	ST DAHU03H05_IN.RSTV

(** 	DAHU03H05_IN.FPS    :=LAHU03H05_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU03H05_FPS
	ST DAHU03H05_IN.FPS

(** 	DAHU03H05_IN.ISO1   :=LAHU03H05_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU03H05_ISO1
	ST DAHU03H05_IN.ISO1

(** 	DAHU03H05_IN.ISO2   :=LAHU03H05_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU03H05_ISO2
	ST DAHU03H05_IN.ISO2

(** 	DAHU03H05_IN.VP     :=LAHU03H05_VP         ; **)
	(* assign - Stmt *)
	LD LAHU03H05_VP
	ST DAHU03H05_IN.VP

(** 	DAHU03H05_IN.VI     :=LAHU03H05_VI         ; **)
	(* assign - Stmt *)
	LD LAHU03H05_VI
	ST DAHU03H05_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU03H05_WVCS      :=DAHU03H05_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU03H05_OUT.WVCS
	ST LAHU03H05_WVCS

(** 	LAHU03H05_C         :=DAHU03H05_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU03H05_OUT.ContRol
	ST LAHU03H05_C

(** 	LAHU03H05_RH        :=DAHU03H05_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU03H05_OUT.RH
	ST LAHU03H05_RH

(** 	LAHU03H05_SN        :=DAHU03H05_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU03H05_OUT.SN
	ST LAHU03H05_SN

(** 	{*ͬ������*} **)
(** 	AHU03H05_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU03H05_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU03X00_PC  ,BOOL_IN1:=LAHU03H05_PC  ,BOOL_IN2      :=RAHU03H05_PC  , **)
		BOOL_IN0 := RNIAHU03X00_PC,
		BOOL_IN1 := LAHU03H05_PC,
		BOOL_IN2 := RAHU03H05_PC,
(** 	                             REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03H05_TSET,REAL_IN2      :=RAHU03H05_TSET, **)
		REAL_IN0 := RNIAHU03X00_TSET,
		REAL_IN1 := LAHU03H05_TSET,
		REAL_IN2 := RAHU03H05_TSET,
(** 	                             INT_IN0 :=RNIAHU03X00_SM  ,INT_IN1 :=LAHU03H05_SM  ,INT_IN2       :=RAHU03H05_SM  | **)
		INT_IN0 := RNIAHU03X00_SM,
		INT_IN1 := LAHU03H05_SM,
		INT_IN2 := RAHU03H05_SM
		|
(** 	                                                  LAHU03H05_PC  :=BOOL_OUT1     ,RAHU03H05_PC  :=BOOL_OUT2     , **)
		LAHU03H05_PC := BOOL_OUT1,
		RAHU03H05_PC := BOOL_OUT2,
(** 	                                                  LAHU03H05_TSET:=REAL_OUT1     ,RAHU03H05_TSET:=REAL_OUT2     , **)
		LAHU03H05_TSET := REAL_OUT1,
		RAHU03H05_TSET := REAL_OUT2,
(** 	                                                  LAHU03H05_SM  :=INT_OUT1      ,RAHU03H05_SM  :=INT_OUT2)     ; **)
		LAHU03H05_SM := INT_OUT1,
		RAHU03H05_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU03H06********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU03H06_WVB_AVE(INPUT:=LAHU03H06_WVB); **)
	(* call - Stmt *)
	CAL AHU03H06_WVB_AVE (
		INPUT := LAHU03H06_WVB
	)

(** 	AHU03H06_RT_AVE (INPUT:=LAHU03H06_RT) ; **)
	(* call - Stmt *)
	CAL AHU03H06_RT_AVE (
		INPUT := LAHU03H06_RT
	)

(** 	LAHU03H06_RTS :=            BS_Scale(AHU03H06_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H06_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU03H06_RTS

(** 	LAHU03H06_WVBS:=            BS_Scale(AHU03H06_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H06_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU03H06_WVBS

(** 	LAHU03H06_WVC :=REAL_TO_INT(BS_Scale(LAHU03H06_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU03H06_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU03H06_WVC

(** 	{*������*} **)
(** 	AHU03H06_DAHU(DAHU_STRUCT_IN:=DAHU03H06_IN | DAHU03H06_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU03H06_DAHU (
		DAHU_STRUCT_IN := DAHU03H06_IN
		|
		DAHU03H06_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU03H06_IN.SM     :=LAHU03H06_SM         ; **)
	(* assign - Stmt *)
	LD LAHU03H06_SM
	ST DAHU03H06_IN.SM

(** 	DAHU03H06_IN.Run    :=LAHU03H06_R          ; **)
	(* assign - Stmt *)
	LD LAHU03H06_R
	ST DAHU03H06_IN.Run

(** 	DAHU03H06_IN.Fault  :=LAHU03H06_F          ; **)
	(* assign - Stmt *)
	LD LAHU03H06_F
	ST DAHU03H06_IN.Fault

(** 	DAHU03H06_IN.Auto   :=LAHU03H06_A          ; **)
	(* assign - Stmt *)
	LD LAHU03H06_A
	ST DAHU03H06_IN.Auto

(** 	DAHU03H06_IN.ContRol:=LAHU03H06_PC         ; **)
	(* assign - Stmt *)
	LD LAHU03H06_PC
	ST DAHU03H06_IN.ContRol

(** 	DAHU03H06_IN.TSET   :=LAHU03H06_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU03H06_TSET
	ST DAHU03H06_IN.TSET

(** 	DAHU03H06_IN.WVMC   :=LAHU03H06_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU03H06_WVMC
	ST DAHU03H06_IN.WVMC

(** 	DAHU03H06_IN.WVMV   :=LAHU03H06_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU03H06_WVMV
	ST DAHU03H06_IN.WVMV

(** 	DAHU03H06_IN.RTS    :=LAHU03H06_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU03H06_RTS
	ST DAHU03H06_IN.RTS

(** 	DAHU03H06_IN.RST    :=LAHU03H06_RST        ; **)
	(* assign - Stmt *)
	LD LAHU03H06_RST
	ST DAHU03H06_IN.RST

(** 	DAHU03H06_IN.RSTV   :=LAHU03H06_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU03H06_RSTV
	ST DAHU03H06_IN.RSTV

(** 	DAHU03H06_IN.FPS    :=LAHU03H06_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU03H06_FPS
	ST DAHU03H06_IN.FPS

(** 	DAHU03H06_IN.ISO1   :=LAHU03H06_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU03H06_ISO1
	ST DAHU03H06_IN.ISO1

(** 	DAHU03H06_IN.ISO2   :=LAHU03H06_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU03H06_ISO2
	ST DAHU03H06_IN.ISO2

(** 	DAHU03H06_IN.VP     :=LAHU03H06_VP         ; **)
	(* assign - Stmt *)
	LD LAHU03H06_VP
	ST DAHU03H06_IN.VP

(** 	DAHU03H06_IN.VI     :=LAHU03H06_VI         ; **)
	(* assign - Stmt *)
	LD LAHU03H06_VI
	ST DAHU03H06_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU03H06_WVCS      :=DAHU03H06_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU03H06_OUT.WVCS
	ST LAHU03H06_WVCS

(** 	LAHU03H06_C         :=DAHU03H06_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU03H06_OUT.ContRol
	ST LAHU03H06_C

(** 	LAHU03H06_RH        :=DAHU03H06_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU03H06_OUT.RH
	ST LAHU03H06_RH

(** 	LAHU03H06_SN        :=DAHU03H06_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU03H06_OUT.SN
	ST LAHU03H06_SN

(** 	{*ͬ������*} **)
(** 	AHU03H06_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU03H06_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU03X00_PC  ,BOOL_IN1:=LAHU03H06_PC  ,BOOL_IN2      :=RAHU03H06_PC  , **)
		BOOL_IN0 := RNIAHU03X00_PC,
		BOOL_IN1 := LAHU03H06_PC,
		BOOL_IN2 := RAHU03H06_PC,
(** 	                             REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03H06_TSET,REAL_IN2      :=RAHU03H06_TSET, **)
		REAL_IN0 := RNIAHU03X00_TSET,
		REAL_IN1 := LAHU03H06_TSET,
		REAL_IN2 := RAHU03H06_TSET,
(** 	                             INT_IN0 :=RNIAHU03X00_SM  ,INT_IN1 :=LAHU03H06_SM  ,INT_IN2       :=RAHU03H06_SM  | **)
		INT_IN0 := RNIAHU03X00_SM,
		INT_IN1 := LAHU03H06_SM,
		INT_IN2 := RAHU03H06_SM
		|
(** 	                                                  LAHU03H06_PC  :=BOOL_OUT1     ,RAHU03H06_PC  :=BOOL_OUT2     , **)
		LAHU03H06_PC := BOOL_OUT1,
		RAHU03H06_PC := BOOL_OUT2,
(** 	                                                  LAHU03H06_TSET:=REAL_OUT1     ,RAHU03H06_TSET:=REAL_OUT2     , **)
		LAHU03H06_TSET := REAL_OUT1,
		RAHU03H06_TSET := REAL_OUT2,
(** 	                                                  LAHU03H06_SM  :=INT_OUT1      ,RAHU03H06_SM  :=INT_OUT2)     ; **)
		LAHU03H06_SM := INT_OUT1,
		RAHU03H06_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU03H07********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU03H07_WVB_AVE(INPUT:=LAHU03H07_WVB); **)
	(* call - Stmt *)
	CAL AHU03H07_WVB_AVE (
		INPUT := LAHU03H07_WVB
	)

(** 	AHU03H07_RT_AVE (INPUT:=LAHU03H07_RT) ; **)
	(* call - Stmt *)
	CAL AHU03H07_RT_AVE (
		INPUT := LAHU03H07_RT
	)

(** 	LAHU03H07_RTS :=            BS_Scale(AHU03H07_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H07_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU03H07_RTS

(** 	LAHU03H07_WVBS:=            BS_Scale(AHU03H07_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H07_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU03H07_WVBS

(** 	LAHU03H07_WVC :=REAL_TO_INT(BS_Scale(LAHU03H07_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU03H07_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU03H07_WVC

(** 	{*������*} **)
(** 	AHU03H07_DAHU(DAHU_STRUCT_IN:=DAHU03H07_IN | DAHU03H07_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU03H07_DAHU (
		DAHU_STRUCT_IN := DAHU03H07_IN
		|
		DAHU03H07_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU03H07_IN.SM     :=LAHU03H07_SM         ; **)
	(* assign - Stmt *)
	LD LAHU03H07_SM
	ST DAHU03H07_IN.SM

(** 	DAHU03H07_IN.Run    :=LAHU03H07_R          ; **)
	(* assign - Stmt *)
	LD LAHU03H07_R
	ST DAHU03H07_IN.Run

(** 	DAHU03H07_IN.Fault  :=LAHU03H07_F          ; **)
	(* assign - Stmt *)
	LD LAHU03H07_F
	ST DAHU03H07_IN.Fault

(** 	DAHU03H07_IN.Auto   :=LAHU03H07_A          ; **)
	(* assign - Stmt *)
	LD LAHU03H07_A
	ST DAHU03H07_IN.Auto

(** 	DAHU03H07_IN.ContRol:=LAHU03H07_PC         ; **)
	(* assign - Stmt *)
	LD LAHU03H07_PC
	ST DAHU03H07_IN.ContRol

(** 	DAHU03H07_IN.TSET   :=LAHU03H07_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU03H07_TSET
	ST DAHU03H07_IN.TSET

(** 	DAHU03H07_IN.WVMC   :=LAHU03H07_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU03H07_WVMC
	ST DAHU03H07_IN.WVMC

(** 	DAHU03H07_IN.WVMV   :=LAHU03H07_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU03H07_WVMV
	ST DAHU03H07_IN.WVMV

(** 	DAHU03H07_IN.RTS    :=LAHU03H07_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU03H07_RTS
	ST DAHU03H07_IN.RTS

(** 	DAHU03H07_IN.RST    :=LAHU03H07_RST        ; **)
	(* assign - Stmt *)
	LD LAHU03H07_RST
	ST DAHU03H07_IN.RST

(** 	DAHU03H07_IN.RSTV   :=LAHU03H07_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU03H07_RSTV
	ST DAHU03H07_IN.RSTV

(** 	DAHU03H07_IN.FPS    :=LAHU03H07_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU03H07_FPS
	ST DAHU03H07_IN.FPS

(** 	DAHU03H07_IN.ISO1   :=LAHU03H07_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU03H07_ISO1
	ST DAHU03H07_IN.ISO1

(** 	DAHU03H07_IN.ISO2   :=LAHU03H07_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU03H07_ISO2
	ST DAHU03H07_IN.ISO2

(** 	DAHU03H07_IN.VP     :=LAHU03H07_VP         ; **)
	(* assign - Stmt *)
	LD LAHU03H07_VP
	ST DAHU03H07_IN.VP

(** 	DAHU03H07_IN.VI     :=LAHU03H07_VI         ; **)
	(* assign - Stmt *)
	LD LAHU03H07_VI
	ST DAHU03H07_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU03H07_WVCS      :=DAHU03H07_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU03H07_OUT.WVCS
	ST LAHU03H07_WVCS

(** 	LAHU03H07_C         :=DAHU03H07_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU03H07_OUT.ContRol
	ST LAHU03H07_C

(** 	LAHU03H07_RH        :=DAHU03H07_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU03H07_OUT.RH
	ST LAHU03H07_RH

(** 	LAHU03H07_SN        :=DAHU03H07_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU03H07_OUT.SN
	ST LAHU03H07_SN

(** 	{*ͬ������*} **)
(** 	AHU03H07_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU03H07_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU03X00_PC  ,BOOL_IN1:=LAHU03H07_PC  ,BOOL_IN2      :=RAHU03H07_PC  , **)
		BOOL_IN0 := RNIAHU03X00_PC,
		BOOL_IN1 := LAHU03H07_PC,
		BOOL_IN2 := RAHU03H07_PC,
(** 	                             REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03H07_TSET,REAL_IN2      :=RAHU03H07_TSET, **)
		REAL_IN0 := RNIAHU03X00_TSET,
		REAL_IN1 := LAHU03H07_TSET,
		REAL_IN2 := RAHU03H07_TSET,
(** 	                             INT_IN0 :=RNIAHU03X00_SM  ,INT_IN1 :=LAHU03H07_SM  ,INT_IN2       :=RAHU03H07_SM  | **)
		INT_IN0 := RNIAHU03X00_SM,
		INT_IN1 := LAHU03H07_SM,
		INT_IN2 := RAHU03H07_SM
		|
(** 	                                                  LAHU03H07_PC  :=BOOL_OUT1     ,RAHU03H07_PC  :=BOOL_OUT2     , **)
		LAHU03H07_PC := BOOL_OUT1,
		RAHU03H07_PC := BOOL_OUT2,
(** 	                                                  LAHU03H07_TSET:=REAL_OUT1     ,RAHU03H07_TSET:=REAL_OUT2     , **)
		LAHU03H07_TSET := REAL_OUT1,
		RAHU03H07_TSET := REAL_OUT2,
(** 	                                                  LAHU03H07_SM  :=INT_OUT1      ,RAHU03H07_SM  :=INT_OUT2)     ; **)
		LAHU03H07_SM := INT_OUT1,
		RAHU03H07_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU03H08********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU03H08_WVB_AVE(INPUT:=LAHU03H08_WVB); **)
	(* call - Stmt *)
	CAL AHU03H08_WVB_AVE (
		INPUT := LAHU03H08_WVB
	)

(** 	AHU03H08_RT_AVE (INPUT:=LAHU03H08_RT) ; **)
	(* call - Stmt *)
	CAL AHU03H08_RT_AVE (
		INPUT := LAHU03H08_RT
	)

(** 	LAHU03H08_RTS :=            BS_Scale(AHU03H08_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H08_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU03H08_RTS

(** 	LAHU03H08_WVBS:=            BS_Scale(AHU03H08_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H08_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU03H08_WVBS

(** 	LAHU03H08_WVC :=REAL_TO_INT(BS_Scale(LAHU03H08_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU03H08_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU03H08_WVC

(** 	{*������*} **)
(** 	AHU03H08_DAHU(DAHU_STRUCT_IN:=DAHU03H08_IN | DAHU03H08_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU03H08_DAHU (
		DAHU_STRUCT_IN := DAHU03H08_IN
		|
		DAHU03H08_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU03H08_IN.SM     :=LAHU03H08_SM         ; **)
	(* assign - Stmt *)
	LD LAHU03H08_SM
	ST DAHU03H08_IN.SM

(** 	DAHU03H08_IN.Run    :=LAHU03H08_R          ; **)
	(* assign - Stmt *)
	LD LAHU03H08_R
	ST DAHU03H08_IN.Run

(** 	DAHU03H08_IN.Fault  :=LAHU03H08_F          ; **)
	(* assign - Stmt *)
	LD LAHU03H08_F
	ST DAHU03H08_IN.Fault

(** 	DAHU03H08_IN.Auto   :=LAHU03H08_A          ; **)
	(* assign - Stmt *)
	LD LAHU03H08_A
	ST DAHU03H08_IN.Auto

(** 	DAHU03H08_IN.ContRol:=LAHU03H08_PC         ; **)
	(* assign - Stmt *)
	LD LAHU03H08_PC
	ST DAHU03H08_IN.ContRol

(** 	DAHU03H08_IN.TSET   :=LAHU03H08_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU03H08_TSET
	ST DAHU03H08_IN.TSET

(** 	DAHU03H08_IN.WVMC   :=LAHU03H08_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU03H08_WVMC
	ST DAHU03H08_IN.WVMC

(** 	DAHU03H08_IN.WVMV   :=LAHU03H08_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU03H08_WVMV
	ST DAHU03H08_IN.WVMV

(** 	DAHU03H08_IN.RTS    :=LAHU03H08_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU03H08_RTS
	ST DAHU03H08_IN.RTS

(** 	DAHU03H08_IN.RST    :=LAHU03H08_RST        ; **)
	(* assign - Stmt *)
	LD LAHU03H08_RST
	ST DAHU03H08_IN.RST

(** 	DAHU03H08_IN.RSTV   :=LAHU03H08_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU03H08_RSTV
	ST DAHU03H08_IN.RSTV

(** 	DAHU03H08_IN.FPS    :=LAHU03H08_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU03H08_FPS
	ST DAHU03H08_IN.FPS

(** 	DAHU03H08_IN.ISO1   :=LAHU03H08_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU03H08_ISO1
	ST DAHU03H08_IN.ISO1

(** 	DAHU03H08_IN.ISO2   :=LAHU03H08_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU03H08_ISO2
	ST DAHU03H08_IN.ISO2

(** 	DAHU03H08_IN.VP     :=LAHU03H08_VP         ; **)
	(* assign - Stmt *)
	LD LAHU03H08_VP
	ST DAHU03H08_IN.VP

(** 	DAHU03H08_IN.VI     :=LAHU03H08_VI         ; **)
	(* assign - Stmt *)
	LD LAHU03H08_VI
	ST DAHU03H08_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU03H08_WVCS      :=DAHU03H08_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU03H08_OUT.WVCS
	ST LAHU03H08_WVCS

(** 	LAHU03H08_C         :=DAHU03H08_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU03H08_OUT.ContRol
	ST LAHU03H08_C

(** 	LAHU03H08_RH        :=DAHU03H08_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU03H08_OUT.RH
	ST LAHU03H08_RH

(** 	LAHU03H08_SN        :=DAHU03H08_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU03H08_OUT.SN
	ST LAHU03H08_SN

(** 	{*ͬ������*} **)
(** 	AHU03H08_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU03H08_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU03X00_PC  ,BOOL_IN1:=LAHU03H08_PC  ,BOOL_IN2      :=RAHU03H08_PC  , **)
		BOOL_IN0 := RNIAHU03X00_PC,
		BOOL_IN1 := LAHU03H08_PC,
		BOOL_IN2 := RAHU03H08_PC,
(** 	                             REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03H08_TSET,REAL_IN2      :=RAHU03H08_TSET, **)
		REAL_IN0 := RNIAHU03X00_TSET,
		REAL_IN1 := LAHU03H08_TSET,
		REAL_IN2 := RAHU03H08_TSET,
(** 	                             INT_IN0 :=RNIAHU03X00_SM  ,INT_IN1 :=LAHU03H08_SM  ,INT_IN2       :=RAHU03H08_SM  | **)
		INT_IN0 := RNIAHU03X00_SM,
		INT_IN1 := LAHU03H08_SM,
		INT_IN2 := RAHU03H08_SM
		|
(** 	                                                  LAHU03H08_PC  :=BOOL_OUT1     ,RAHU03H08_PC  :=BOOL_OUT2     , **)
		LAHU03H08_PC := BOOL_OUT1,
		RAHU03H08_PC := BOOL_OUT2,
(** 	                                                  LAHU03H08_TSET:=REAL_OUT1     ,RAHU03H08_TSET:=REAL_OUT2     , **)
		LAHU03H08_TSET := REAL_OUT1,
		RAHU03H08_TSET := REAL_OUT2,
(** 	                                                  LAHU03H08_SM  :=INT_OUT1      ,RAHU03H08_SM  :=INT_OUT2)     ; **)
		LAHU03H08_SM := INT_OUT1,
		RAHU03H08_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU03H09********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU03H09_WVB_AVE(INPUT:=LAHU03H09_WVB); **)
	(* call - Stmt *)
	CAL AHU03H09_WVB_AVE (
		INPUT := LAHU03H09_WVB
	)

(** 	AHU03H09_RT_AVE (INPUT:=LAHU03H09_RT) ; **)
	(* call - Stmt *)
	CAL AHU03H09_RT_AVE (
		INPUT := LAHU03H09_RT
	)

(** 	LAHU03H09_RTS :=            BS_Scale(AHU03H09_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H09_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU03H09_RTS

(** 	LAHU03H09_WVBS:=            BS_Scale(AHU03H09_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H09_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU03H09_WVBS

(** 	LAHU03H09_WVC :=REAL_TO_INT(BS_Scale(LAHU03H09_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU03H09_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU03H09_WVC

(** 	{*������*} **)
(** 	AHU03H09_DAHU(DAHU_STRUCT_IN:=DAHU03H09_IN | DAHU03H09_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU03H09_DAHU (
		DAHU_STRUCT_IN := DAHU03H09_IN
		|
		DAHU03H09_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU03H09_IN.SM     :=LAHU03H09_SM         ; **)
	(* assign - Stmt *)
	LD LAHU03H09_SM
	ST DAHU03H09_IN.SM

(** 	DAHU03H09_IN.Run    :=LAHU03H09_R          ; **)
	(* assign - Stmt *)
	LD LAHU03H09_R
	ST DAHU03H09_IN.Run

(** 	DAHU03H09_IN.Fault  :=LAHU03H09_F          ; **)
	(* assign - Stmt *)
	LD LAHU03H09_F
	ST DAHU03H09_IN.Fault

(** 	DAHU03H09_IN.Auto   :=LAHU03H09_A          ; **)
	(* assign - Stmt *)
	LD LAHU03H09_A
	ST DAHU03H09_IN.Auto

(** 	DAHU03H09_IN.ContRol:=LAHU03H09_PC         ; **)
	(* assign - Stmt *)
	LD LAHU03H09_PC
	ST DAHU03H09_IN.ContRol

(** 	DAHU03H09_IN.TSET   :=LAHU03H09_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU03H09_TSET
	ST DAHU03H09_IN.TSET

(** 	DAHU03H09_IN.WVMC   :=LAHU03H09_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU03H09_WVMC
	ST DAHU03H09_IN.WVMC

(** 	DAHU03H09_IN.WVMV   :=LAHU03H09_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU03H09_WVMV
	ST DAHU03H09_IN.WVMV

(** 	DAHU03H09_IN.RTS    :=LAHU03H09_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU03H09_RTS
	ST DAHU03H09_IN.RTS

(** 	DAHU03H09_IN.RST    :=LAHU03H09_RST        ; **)
	(* assign - Stmt *)
	LD LAHU03H09_RST
	ST DAHU03H09_IN.RST

(** 	DAHU03H09_IN.RSTV   :=LAHU03H09_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU03H09_RSTV
	ST DAHU03H09_IN.RSTV

(** 	DAHU03H09_IN.FPS    :=LAHU03H09_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU03H09_FPS
	ST DAHU03H09_IN.FPS

(** 	DAHU03H09_IN.ISO1   :=LAHU03H09_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU03H09_ISO1
	ST DAHU03H09_IN.ISO1

(** 	DAHU03H09_IN.ISO2   :=LAHU03H09_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU03H09_ISO2
	ST DAHU03H09_IN.ISO2

(** 	DAHU03H09_IN.VP     :=LAHU03H09_VP         ; **)
	(* assign - Stmt *)
	LD LAHU03H09_VP
	ST DAHU03H09_IN.VP

(** 	DAHU03H09_IN.VI     :=LAHU03H09_VI         ; **)
	(* assign - Stmt *)
	LD LAHU03H09_VI
	ST DAHU03H09_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU03H09_WVCS      :=DAHU03H09_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU03H09_OUT.WVCS
	ST LAHU03H09_WVCS

(** 	LAHU03H09_C         :=DAHU03H09_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU03H09_OUT.ContRol
	ST LAHU03H09_C

(** 	LAHU03H09_RH        :=DAHU03H09_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU03H09_OUT.RH
	ST LAHU03H09_RH

(** 	LAHU03H09_SN        :=DAHU03H09_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU03H09_OUT.SN
	ST LAHU03H09_SN

(** 	{*ͬ������*} **)
(** 	AHU03H09_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU03H09_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU03X00_PC  ,BOOL_IN1:=LAHU03H09_PC  ,BOOL_IN2      :=RAHU03H09_PC  , **)
		BOOL_IN0 := RNIAHU03X00_PC,
		BOOL_IN1 := LAHU03H09_PC,
		BOOL_IN2 := RAHU03H09_PC,
(** 	                             REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03H09_TSET,REAL_IN2      :=RAHU03H09_TSET, **)
		REAL_IN0 := RNIAHU03X00_TSET,
		REAL_IN1 := LAHU03H09_TSET,
		REAL_IN2 := RAHU03H09_TSET,
(** 	                             INT_IN0 :=RNIAHU03X00_SM  ,INT_IN1 :=LAHU03H09_SM  ,INT_IN2       :=RAHU03H09_SM  | **)
		INT_IN0 := RNIAHU03X00_SM,
		INT_IN1 := LAHU03H09_SM,
		INT_IN2 := RAHU03H09_SM
		|
(** 	                                                  LAHU03H09_PC  :=BOOL_OUT1     ,RAHU03H09_PC  :=BOOL_OUT2     , **)
		LAHU03H09_PC := BOOL_OUT1,
		RAHU03H09_PC := BOOL_OUT2,
(** 	                                                  LAHU03H09_TSET:=REAL_OUT1     ,RAHU03H09_TSET:=REAL_OUT2     , **)
		LAHU03H09_TSET := REAL_OUT1,
		RAHU03H09_TSET := REAL_OUT2,
(** 	                                                  LAHU03H09_SM  :=INT_OUT1      ,RAHU03H09_SM  :=INT_OUT2)     ; **)
		LAHU03H09_SM := INT_OUT1,
		RAHU03H09_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU03H10********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU03H10_WVB_AVE(INPUT:=LAHU03H10_WVB); **)
	(* call - Stmt *)
	CAL AHU03H10_WVB_AVE (
		INPUT := LAHU03H10_WVB
	)

(** 	AHU03H10_RT_AVE (INPUT:=LAHU03H10_RT) ; **)
	(* call - Stmt *)
	CAL AHU03H10_RT_AVE (
		INPUT := LAHU03H10_RT
	)

(** 	LAHU03H10_RTS :=            BS_Scale(AHU03H10_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H10_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU03H10_RTS

(** 	LAHU03H10_WVBS:=            BS_Scale(AHU03H10_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU03H10_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU03H10_WVBS

(** 	LAHU03H10_WVC :=REAL_TO_INT(BS_Scale(LAHU03H10_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU03H10_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU03H10_WVC

(** 	{*������*} **)
(** 	AHU03H10_DAHU(DAHU_STRUCT_IN:=DAHU03H10_IN | DAHU03H10_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU03H10_DAHU (
		DAHU_STRUCT_IN := DAHU03H10_IN
		|
		DAHU03H10_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU03H10_IN.SM     :=LAHU03H10_SM         ; **)
	(* assign - Stmt *)
	LD LAHU03H10_SM
	ST DAHU03H10_IN.SM

(** 	DAHU03H10_IN.Run    :=LAHU03H10_R          ; **)
	(* assign - Stmt *)
	LD LAHU03H10_R
	ST DAHU03H10_IN.Run

(** 	DAHU03H10_IN.Fault  :=LAHU03H10_F          ; **)
	(* assign - Stmt *)
	LD LAHU03H10_F
	ST DAHU03H10_IN.Fault

(** 	DAHU03H10_IN.Auto   :=LAHU03H10_A          ; **)
	(* assign - Stmt *)
	LD LAHU03H10_A
	ST DAHU03H10_IN.Auto

(** 	DAHU03H10_IN.ContRol:=LAHU03H10_PC         ; **)
	(* assign - Stmt *)
	LD LAHU03H10_PC
	ST DAHU03H10_IN.ContRol

(** 	DAHU03H10_IN.TSET   :=LAHU03H10_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU03H10_TSET
	ST DAHU03H10_IN.TSET

(** 	DAHU03H10_IN.WVMC   :=LAHU03H10_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU03H10_WVMC
	ST DAHU03H10_IN.WVMC

(** 	DAHU03H10_IN.WVMV   :=LAHU03H10_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU03H10_WVMV
	ST DAHU03H10_IN.WVMV

(** 	DAHU03H10_IN.RTS    :=LAHU03H10_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU03H10_RTS
	ST DAHU03H10_IN.RTS

(** 	DAHU03H10_IN.RST    :=LAHU03H10_RST        ; **)
	(* assign - Stmt *)
	LD LAHU03H10_RST
	ST DAHU03H10_IN.RST

(** 	DAHU03H10_IN.RSTV   :=LAHU03H10_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU03H10_RSTV
	ST DAHU03H10_IN.RSTV

(** 	DAHU03H10_IN.FPS    :=LAHU03H10_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU03H10_FPS
	ST DAHU03H10_IN.FPS

(** 	DAHU03H10_IN.ISO1   :=LAHU03H10_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU03H10_ISO1
	ST DAHU03H10_IN.ISO1

(** 	DAHU03H10_IN.ISO2   :=LAHU03H10_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU03H10_ISO2
	ST DAHU03H10_IN.ISO2

(** 	DAHU03H10_IN.VP     :=LAHU03H10_VP         ; **)
	(* assign - Stmt *)
	LD LAHU03H10_VP
	ST DAHU03H10_IN.VP

(** 	DAHU03H10_IN.VI     :=LAHU03H10_VI         ; **)
	(* assign - Stmt *)
	LD LAHU03H10_VI
	ST DAHU03H10_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU03H10_WVCS      :=DAHU03H10_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU03H10_OUT.WVCS
	ST LAHU03H10_WVCS

(** 	LAHU03H10_C         :=DAHU03H10_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU03H10_OUT.ContRol
	ST LAHU03H10_C

(** 	LAHU03H10_RH        :=DAHU03H10_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU03H10_OUT.RH
	ST LAHU03H10_RH

(** 	LAHU03H10_SN        :=DAHU03H10_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU03H10_OUT.SN
	ST LAHU03H10_SN

(** 	{*ͬ������*} **)
(** 	AHU03H10_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU03H10_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU03X00_PC  ,BOOL_IN1:=LAHU03H10_PC  ,BOOL_IN2      :=RAHU03H10_PC  , **)
		BOOL_IN0 := RNIAHU03X00_PC,
		BOOL_IN1 := LAHU03H10_PC,
		BOOL_IN2 := RAHU03H10_PC,
(** 	                             REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03H10_TSET,REAL_IN2      :=RAHU03H10_TSET, **)
		REAL_IN0 := RNIAHU03X00_TSET,
		REAL_IN1 := LAHU03H10_TSET,
		REAL_IN2 := RAHU03H10_TSET,
(** 	                             INT_IN0 :=RNIAHU03X00_SM  ,INT_IN1 :=LAHU03H10_SM  ,INT_IN2       :=RAHU03H10_SM  | **)
		INT_IN0 := RNIAHU03X00_SM,
		INT_IN1 := LAHU03H10_SM,
		INT_IN2 := RAHU03H10_SM
		|
(** 	                                                  LAHU03H10_PC  :=BOOL_OUT1     ,RAHU03H10_PC  :=BOOL_OUT2     , **)
		LAHU03H10_PC := BOOL_OUT1,
		RAHU03H10_PC := BOOL_OUT2,
(** 	                                                  LAHU03H10_TSET:=REAL_OUT1     ,RAHU03H10_TSET:=REAL_OUT2     , **)
		LAHU03H10_TSET := REAL_OUT1,
		RAHU03H10_TSET := REAL_OUT2,
(** 	                                                  LAHU03H10_SM  :=INT_OUT1      ,RAHU03H10_SM  :=INT_OUT2)     ; **)
		LAHU03H10_SM := INT_OUT1,
		RAHU03H10_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU04H01********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU04H01_WVB_AVE(INPUT:=LAHU04H01_WVB); **)
	(* call - Stmt *)
	CAL AHU04H01_WVB_AVE (
		INPUT := LAHU04H01_WVB
	)

(** 	AHU04H01_RT_AVE (INPUT:=LAHU04H01_RT) ; **)
	(* call - Stmt *)
	CAL AHU04H01_RT_AVE (
		INPUT := LAHU04H01_RT
	)

(** 	LAHU04H01_RTS :=            BS_Scale(AHU04H01_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU04H01_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU04H01_RTS

(** 	LAHU04H01_WVBS:=            BS_Scale(AHU04H01_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU04H01_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU04H01_WVBS

(** 	LAHU04H01_WVC :=REAL_TO_INT(BS_Scale(LAHU04H01_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU04H01_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU04H01_WVC

(** 	{*������*} **)
(** 	AHU04H01_DAHU(DAHU_STRUCT_IN:=DAHU04H01_IN | DAHU04H01_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU04H01_DAHU (
		DAHU_STRUCT_IN := DAHU04H01_IN
		|
		DAHU04H01_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU04H01_IN.SM     :=LAHU04H01_SM         ; **)
	(* assign - Stmt *)
	LD LAHU04H01_SM
	ST DAHU04H01_IN.SM

(** 	DAHU04H01_IN.Run    :=LAHU04H01_R          ; **)
	(* assign - Stmt *)
	LD LAHU04H01_R
	ST DAHU04H01_IN.Run

(** 	DAHU04H01_IN.Fault  :=LAHU04H01_F          ; **)
	(* assign - Stmt *)
	LD LAHU04H01_F
	ST DAHU04H01_IN.Fault

(** 	DAHU04H01_IN.Auto   :=LAHU04H01_A          ; **)
	(* assign - Stmt *)
	LD LAHU04H01_A
	ST DAHU04H01_IN.Auto

(** 	DAHU04H01_IN.ContRol:=LAHU04H01_PC         ; **)
	(* assign - Stmt *)
	LD LAHU04H01_PC
	ST DAHU04H01_IN.ContRol

(** 	DAHU04H01_IN.TSET   :=LAHU04H01_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU04H01_TSET
	ST DAHU04H01_IN.TSET

(** 	DAHU04H01_IN.WVMC   :=LAHU04H01_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU04H01_WVMC
	ST DAHU04H01_IN.WVMC

(** 	DAHU04H01_IN.WVMV   :=LAHU04H01_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU04H01_WVMV
	ST DAHU04H01_IN.WVMV

(** 	DAHU04H01_IN.RTS    :=LAHU04H01_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU04H01_RTS
	ST DAHU04H01_IN.RTS

(** 	DAHU04H01_IN.RST    :=LAHU04H01_RST        ; **)
	(* assign - Stmt *)
	LD LAHU04H01_RST
	ST DAHU04H01_IN.RST

(** 	DAHU04H01_IN.RSTV   :=LAHU04H01_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU04H01_RSTV
	ST DAHU04H01_IN.RSTV

(** 	DAHU04H01_IN.FPS    :=LAHU04H01_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU04H01_FPS
	ST DAHU04H01_IN.FPS

(** 	DAHU04H01_IN.ISO1   :=LAHU04H01_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU04H01_ISO1
	ST DAHU04H01_IN.ISO1

(** 	DAHU04H01_IN.ISO2   :=LAHU04H01_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU04H01_ISO2
	ST DAHU04H01_IN.ISO2

(** 	DAHU04H01_IN.VP     :=LAHU04H01_VP         ; **)
	(* assign - Stmt *)
	LD LAHU04H01_VP
	ST DAHU04H01_IN.VP

(** 	DAHU04H01_IN.VI     :=LAHU04H01_VI         ; **)
	(* assign - Stmt *)
	LD LAHU04H01_VI
	ST DAHU04H01_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU04H01_WVCS      :=DAHU04H01_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU04H01_OUT.WVCS
	ST LAHU04H01_WVCS

(** 	LAHU04H01_C         :=DAHU04H01_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU04H01_OUT.ContRol
	ST LAHU04H01_C

(** 	LAHU04H01_RH        :=DAHU04H01_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU04H01_OUT.RH
	ST LAHU04H01_RH

(** 	LAHU04H01_SN        :=DAHU04H01_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU04H01_OUT.SN
	ST LAHU04H01_SN

(** 	{*ͬ������*} **)
(** 	AHU04H01_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU04H01_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU04X00_PC  ,BOOL_IN1:=LAHU04H01_PC  ,BOOL_IN2      :=RAHU04H01_PC  , **)
		BOOL_IN0 := RNIAHU04X00_PC,
		BOOL_IN1 := LAHU04H01_PC,
		BOOL_IN2 := RAHU04H01_PC,
(** 	                             REAL_IN0:=RNIAHU04X00_TSET,REAL_IN1:=LAHU04H01_TSET,REAL_IN2      :=RAHU04H01_TSET, **)
		REAL_IN0 := RNIAHU04X00_TSET,
		REAL_IN1 := LAHU04H01_TSET,
		REAL_IN2 := RAHU04H01_TSET,
(** 	                             INT_IN0 :=RNIAHU04X00_SM  ,INT_IN1 :=LAHU04H01_SM  ,INT_IN2       :=RAHU04H01_SM  | **)
		INT_IN0 := RNIAHU04X00_SM,
		INT_IN1 := LAHU04H01_SM,
		INT_IN2 := RAHU04H01_SM
		|
(** 	                                                  LAHU04H01_PC  :=BOOL_OUT1     ,RAHU04H01_PC  :=BOOL_OUT2     , **)
		LAHU04H01_PC := BOOL_OUT1,
		RAHU04H01_PC := BOOL_OUT2,
(** 	                                                  LAHU04H01_TSET:=REAL_OUT1     ,RAHU04H01_TSET:=REAL_OUT2     , **)
		LAHU04H01_TSET := REAL_OUT1,
		RAHU04H01_TSET := REAL_OUT2,
(** 	                                                  LAHU04H01_SM  :=INT_OUT1      ,RAHU04H01_SM  :=INT_OUT2)     ; **)
		LAHU04H01_SM := INT_OUT1,
		RAHU04H01_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU04H02********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU04H02_WVB_AVE(INPUT:=LAHU04H02_WVB); **)
	(* call - Stmt *)
	CAL AHU04H02_WVB_AVE (
		INPUT := LAHU04H02_WVB
	)

(** 	AHU04H02_RT_AVE (INPUT:=LAHU04H02_RT) ; **)
	(* call - Stmt *)
	CAL AHU04H02_RT_AVE (
		INPUT := LAHU04H02_RT
	)

(** 	LAHU04H02_RTS :=            BS_Scale(AHU04H02_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU04H02_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU04H02_RTS

(** 	LAHU04H02_WVBS:=            BS_Scale(AHU04H02_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU04H02_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU04H02_WVBS

(** 	LAHU04H02_WVC :=REAL_TO_INT(BS_Scale(LAHU04H02_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU04H02_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU04H02_WVC

(** 	{*������*} **)
(** 	AHU04H02_DAHU(DAHU_STRUCT_IN:=DAHU04H02_IN | DAHU04H02_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU04H02_DAHU (
		DAHU_STRUCT_IN := DAHU04H02_IN
		|
		DAHU04H02_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU04H02_IN.SM     :=LAHU04H02_SM         ; **)
	(* assign - Stmt *)
	LD LAHU04H02_SM
	ST DAHU04H02_IN.SM

(** 	DAHU04H02_IN.Run    :=LAHU04H02_R          ; **)
	(* assign - Stmt *)
	LD LAHU04H02_R
	ST DAHU04H02_IN.Run

(** 	DAHU04H02_IN.Fault  :=LAHU04H02_F          ; **)
	(* assign - Stmt *)
	LD LAHU04H02_F
	ST DAHU04H02_IN.Fault

(** 	DAHU04H02_IN.Auto   :=LAHU04H02_A          ; **)
	(* assign - Stmt *)
	LD LAHU04H02_A
	ST DAHU04H02_IN.Auto

(** 	DAHU04H02_IN.ContRol:=LAHU04H02_PC         ; **)
	(* assign - Stmt *)
	LD LAHU04H02_PC
	ST DAHU04H02_IN.ContRol

(** 	DAHU04H02_IN.TSET   :=LAHU04H02_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU04H02_TSET
	ST DAHU04H02_IN.TSET

(** 	DAHU04H02_IN.WVMC   :=LAHU04H02_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU04H02_WVMC
	ST DAHU04H02_IN.WVMC

(** 	DAHU04H02_IN.WVMV   :=LAHU04H02_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU04H02_WVMV
	ST DAHU04H02_IN.WVMV

(** 	DAHU04H02_IN.RTS    :=LAHU04H02_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU04H02_RTS
	ST DAHU04H02_IN.RTS

(** 	DAHU04H02_IN.RST    :=LAHU04H02_RST        ; **)
	(* assign - Stmt *)
	LD LAHU04H02_RST
	ST DAHU04H02_IN.RST

(** 	DAHU04H02_IN.RSTV   :=LAHU04H02_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU04H02_RSTV
	ST DAHU04H02_IN.RSTV

(** 	DAHU04H02_IN.FPS    :=LAHU04H02_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU04H02_FPS
	ST DAHU04H02_IN.FPS

(** 	DAHU04H02_IN.ISO1   :=LAHU04H02_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU04H02_ISO1
	ST DAHU04H02_IN.ISO1

(** 	DAHU04H02_IN.ISO2   :=LAHU04H02_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU04H02_ISO2
	ST DAHU04H02_IN.ISO2

(** 	DAHU04H02_IN.VP     :=LAHU04H02_VP         ; **)
	(* assign - Stmt *)
	LD LAHU04H02_VP
	ST DAHU04H02_IN.VP

(** 	DAHU04H02_IN.VI     :=LAHU04H02_VI         ; **)
	(* assign - Stmt *)
	LD LAHU04H02_VI
	ST DAHU04H02_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU04H02_WVCS      :=DAHU04H02_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU04H02_OUT.WVCS
	ST LAHU04H02_WVCS

(** 	LAHU04H02_C         :=DAHU04H02_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU04H02_OUT.ContRol
	ST LAHU04H02_C

(** 	LAHU04H02_RH        :=DAHU04H02_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU04H02_OUT.RH
	ST LAHU04H02_RH

(** 	LAHU04H02_SN        :=DAHU04H02_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU04H02_OUT.SN
	ST LAHU04H02_SN

(** 	{*ͬ������*} **)
(** 	AHU04H02_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU04H02_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU04X00_PC  ,BOOL_IN1:=LAHU04H02_PC  ,BOOL_IN2      :=RAHU04H02_PC  , **)
		BOOL_IN0 := RNIAHU04X00_PC,
		BOOL_IN1 := LAHU04H02_PC,
		BOOL_IN2 := RAHU04H02_PC,
(** 	                             REAL_IN0:=RNIAHU04X00_TSET,REAL_IN1:=LAHU04H02_TSET,REAL_IN2      :=RAHU04H02_TSET, **)
		REAL_IN0 := RNIAHU04X00_TSET,
		REAL_IN1 := LAHU04H02_TSET,
		REAL_IN2 := RAHU04H02_TSET,
(** 	                             INT_IN0 :=RNIAHU04X00_SM  ,INT_IN1 :=LAHU04H02_SM  ,INT_IN2       :=RAHU04H02_SM  | **)
		INT_IN0 := RNIAHU04X00_SM,
		INT_IN1 := LAHU04H02_SM,
		INT_IN2 := RAHU04H02_SM
		|
(** 	                                                  LAHU04H02_PC  :=BOOL_OUT1     ,RAHU04H02_PC  :=BOOL_OUT2     , **)
		LAHU04H02_PC := BOOL_OUT1,
		RAHU04H02_PC := BOOL_OUT2,
(** 	                                                  LAHU04H02_TSET:=REAL_OUT1     ,RAHU04H02_TSET:=REAL_OUT2     , **)
		LAHU04H02_TSET := REAL_OUT1,
		RAHU04H02_TSET := REAL_OUT2,
(** 	                                                  LAHU04H02_SM  :=INT_OUT1      ,RAHU04H02_SM  :=INT_OUT2)     ; **)
		LAHU04H02_SM := INT_OUT1,
		RAHU04H02_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU04H03********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU04H03_WVB_AVE(INPUT:=LAHU04H03_WVB); **)
	(* call - Stmt *)
	CAL AHU04H03_WVB_AVE (
		INPUT := LAHU04H03_WVB
	)

(** 	AHU04H03_RT_AVE (INPUT:=LAHU04H03_RT) ; **)
	(* call - Stmt *)
	CAL AHU04H03_RT_AVE (
		INPUT := LAHU04H03_RT
	)

(** 	LAHU04H03_RTS :=            BS_Scale(AHU04H03_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU04H03_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU04H03_RTS

(** 	LAHU04H03_WVBS:=            BS_Scale(AHU04H03_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU04H03_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU04H03_WVBS

(** 	LAHU04H03_WVC :=REAL_TO_INT(BS_Scale(LAHU04H03_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU04H03_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU04H03_WVC

(** 	{*������*} **)
(** 	AHU04H03_DAHU(DAHU_STRUCT_IN:=DAHU04H03_IN | DAHU04H03_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU04H03_DAHU (
		DAHU_STRUCT_IN := DAHU04H03_IN
		|
		DAHU04H03_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU04H03_IN.SM     :=LAHU04H03_SM         ; **)
	(* assign - Stmt *)
	LD LAHU04H03_SM
	ST DAHU04H03_IN.SM

(** 	DAHU04H03_IN.Run    :=LAHU04H03_R          ; **)
	(* assign - Stmt *)
	LD LAHU04H03_R
	ST DAHU04H03_IN.Run

(** 	DAHU04H03_IN.Fault  :=LAHU04H03_F          ; **)
	(* assign - Stmt *)
	LD LAHU04H03_F
	ST DAHU04H03_IN.Fault

(** 	DAHU04H03_IN.Auto   :=LAHU04H03_A          ; **)
	(* assign - Stmt *)
	LD LAHU04H03_A
	ST DAHU04H03_IN.Auto

(** 	DAHU04H03_IN.ContRol:=LAHU04H03_PC         ; **)
	(* assign - Stmt *)
	LD LAHU04H03_PC
	ST DAHU04H03_IN.ContRol

(** 	DAHU04H03_IN.TSET   :=LAHU04H03_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU04H03_TSET
	ST DAHU04H03_IN.TSET

(** 	DAHU04H03_IN.WVMC   :=LAHU04H03_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU04H03_WVMC
	ST DAHU04H03_IN.WVMC

(** 	DAHU04H03_IN.WVMV   :=LAHU04H03_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU04H03_WVMV
	ST DAHU04H03_IN.WVMV

(** 	DAHU04H03_IN.RTS    :=LAHU04H03_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU04H03_RTS
	ST DAHU04H03_IN.RTS

(** 	DAHU04H03_IN.RST    :=LAHU04H03_RST        ; **)
	(* assign - Stmt *)
	LD LAHU04H03_RST
	ST DAHU04H03_IN.RST

(** 	DAHU04H03_IN.RSTV   :=LAHU04H03_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU04H03_RSTV
	ST DAHU04H03_IN.RSTV

(** 	DAHU04H03_IN.FPS    :=LAHU04H03_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU04H03_FPS
	ST DAHU04H03_IN.FPS

(** 	DAHU04H03_IN.ISO1   :=LAHU04H03_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU04H03_ISO1
	ST DAHU04H03_IN.ISO1

(** 	DAHU04H03_IN.ISO2   :=LAHU04H03_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU04H03_ISO2
	ST DAHU04H03_IN.ISO2

(** 	DAHU04H03_IN.VP     :=LAHU04H03_VP         ; **)
	(* assign - Stmt *)
	LD LAHU04H03_VP
	ST DAHU04H03_IN.VP

(** 	DAHU04H03_IN.VI     :=LAHU04H03_VI         ; **)
	(* assign - Stmt *)
	LD LAHU04H03_VI
	ST DAHU04H03_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU04H03_WVCS      :=DAHU04H03_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU04H03_OUT.WVCS
	ST LAHU04H03_WVCS

(** 	LAHU04H03_C         :=DAHU04H03_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU04H03_OUT.ContRol
	ST LAHU04H03_C

(** 	LAHU04H03_RH        :=DAHU04H03_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU04H03_OUT.RH
	ST LAHU04H03_RH

(** 	LAHU04H03_SN        :=DAHU04H03_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU04H03_OUT.SN
	ST LAHU04H03_SN

(** 	{*ͬ������*} **)
(** 	AHU04H03_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU04H03_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU04X00_PC  ,BOOL_IN1:=LAHU04H03_PC  ,BOOL_IN2      :=RAHU04H03_PC  , **)
		BOOL_IN0 := RNIAHU04X00_PC,
		BOOL_IN1 := LAHU04H03_PC,
		BOOL_IN2 := RAHU04H03_PC,
(** 	                             REAL_IN0:=RNIAHU04X00_TSET,REAL_IN1:=LAHU04H03_TSET,REAL_IN2      :=RAHU04H03_TSET, **)
		REAL_IN0 := RNIAHU04X00_TSET,
		REAL_IN1 := LAHU04H03_TSET,
		REAL_IN2 := RAHU04H03_TSET,
(** 	                             INT_IN0 :=RNIAHU04X00_SM  ,INT_IN1 :=LAHU04H03_SM  ,INT_IN2       :=RAHU04H03_SM  | **)
		INT_IN0 := RNIAHU04X00_SM,
		INT_IN1 := LAHU04H03_SM,
		INT_IN2 := RAHU04H03_SM
		|
(** 	                                                  LAHU04H03_PC  :=BOOL_OUT1     ,RAHU04H03_PC  :=BOOL_OUT2     , **)
		LAHU04H03_PC := BOOL_OUT1,
		RAHU04H03_PC := BOOL_OUT2,
(** 	                                                  LAHU04H03_TSET:=REAL_OUT1     ,RAHU04H03_TSET:=REAL_OUT2     , **)
		LAHU04H03_TSET := REAL_OUT1,
		RAHU04H03_TSET := REAL_OUT2,
(** 	                                                  LAHU04H03_SM  :=INT_OUT1      ,RAHU04H03_SM  :=INT_OUT2)     ; **)
		LAHU04H03_SM := INT_OUT1,
		RAHU04H03_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU04H04********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU04H04_WVB_AVE(INPUT:=LAHU04H04_WVB); **)
	(* call - Stmt *)
	CAL AHU04H04_WVB_AVE (
		INPUT := LAHU04H04_WVB
	)

(** 	AHU04H04_RT_AVE (INPUT:=LAHU04H04_RT) ; **)
	(* call - Stmt *)
	CAL AHU04H04_RT_AVE (
		INPUT := LAHU04H04_RT
	)

(** 	LAHU04H04_RTS :=            BS_Scale(AHU04H04_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU04H04_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU04H04_RTS

(** 	LAHU04H04_WVBS:=            BS_Scale(AHU04H04_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU04H04_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU04H04_WVBS

(** 	LAHU04H04_WVC :=REAL_TO_INT(BS_Scale(LAHU04H04_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU04H04_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU04H04_WVC

(** 	{*������*} **)
(** 	AHU04H04_DAHU(DAHU_STRUCT_IN:=DAHU04H04_IN | DAHU04H04_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU04H04_DAHU (
		DAHU_STRUCT_IN := DAHU04H04_IN
		|
		DAHU04H04_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU04H04_IN.SM     :=LAHU04H04_SM         ; **)
	(* assign - Stmt *)
	LD LAHU04H04_SM
	ST DAHU04H04_IN.SM

(** 	DAHU04H04_IN.Run    :=LAHU04H04_R          ; **)
	(* assign - Stmt *)
	LD LAHU04H04_R
	ST DAHU04H04_IN.Run

(** 	DAHU04H04_IN.Fault  :=LAHU04H04_F          ; **)
	(* assign - Stmt *)
	LD LAHU04H04_F
	ST DAHU04H04_IN.Fault

(** 	DAHU04H04_IN.Auto   :=LAHU04H04_A          ; **)
	(* assign - Stmt *)
	LD LAHU04H04_A
	ST DAHU04H04_IN.Auto

(** 	DAHU04H04_IN.ContRol:=LAHU04H04_PC         ; **)
	(* assign - Stmt *)
	LD LAHU04H04_PC
	ST DAHU04H04_IN.ContRol

(** 	DAHU04H04_IN.TSET   :=LAHU04H04_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU04H04_TSET
	ST DAHU04H04_IN.TSET

(** 	DAHU04H04_IN.WVMC   :=LAHU04H04_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU04H04_WVMC
	ST DAHU04H04_IN.WVMC

(** 	DAHU04H04_IN.WVMV   :=LAHU04H04_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU04H04_WVMV
	ST DAHU04H04_IN.WVMV

(** 	DAHU04H04_IN.RTS    :=LAHU04H04_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU04H04_RTS
	ST DAHU04H04_IN.RTS

(** 	DAHU04H04_IN.RST    :=LAHU04H04_RST        ; **)
	(* assign - Stmt *)
	LD LAHU04H04_RST
	ST DAHU04H04_IN.RST

(** 	DAHU04H04_IN.RSTV   :=LAHU04H04_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU04H04_RSTV
	ST DAHU04H04_IN.RSTV

(** 	DAHU04H04_IN.FPS    :=LAHU04H04_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU04H04_FPS
	ST DAHU04H04_IN.FPS

(** 	DAHU04H04_IN.ISO1   :=LAHU04H04_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU04H04_ISO1
	ST DAHU04H04_IN.ISO1

(** 	DAHU04H04_IN.ISO2   :=LAHU04H04_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU04H04_ISO2
	ST DAHU04H04_IN.ISO2

(** 	DAHU04H04_IN.VP     :=LAHU04H04_VP         ; **)
	(* assign - Stmt *)
	LD LAHU04H04_VP
	ST DAHU04H04_IN.VP

(** 	DAHU04H04_IN.VI     :=LAHU04H04_VI         ; **)
	(* assign - Stmt *)
	LD LAHU04H04_VI
	ST DAHU04H04_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU04H04_WVCS      :=DAHU04H04_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU04H04_OUT.WVCS
	ST LAHU04H04_WVCS

(** 	LAHU04H04_C         :=DAHU04H04_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU04H04_OUT.ContRol
	ST LAHU04H04_C

(** 	LAHU04H04_RH        :=DAHU04H04_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU04H04_OUT.RH
	ST LAHU04H04_RH

(** 	LAHU04H04_SN        :=DAHU04H04_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU04H04_OUT.SN
	ST LAHU04H04_SN

(** 	{*ͬ������*} **)
(** 	AHU04H04_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU04H04_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU04X00_PC  ,BOOL_IN1:=LAHU04H04_PC  ,BOOL_IN2      :=RAHU04H04_PC  , **)
		BOOL_IN0 := RNIAHU04X00_PC,
		BOOL_IN1 := LAHU04H04_PC,
		BOOL_IN2 := RAHU04H04_PC,
(** 	                             REAL_IN0:=RNIAHU04X00_TSET,REAL_IN1:=LAHU04H04_TSET,REAL_IN2      :=RAHU04H04_TSET, **)
		REAL_IN0 := RNIAHU04X00_TSET,
		REAL_IN1 := LAHU04H04_TSET,
		REAL_IN2 := RAHU04H04_TSET,
(** 	                             INT_IN0 :=RNIAHU04X00_SM  ,INT_IN1 :=LAHU04H04_SM  ,INT_IN2       :=RAHU04H04_SM  | **)
		INT_IN0 := RNIAHU04X00_SM,
		INT_IN1 := LAHU04H04_SM,
		INT_IN2 := RAHU04H04_SM
		|
(** 	                                                  LAHU04H04_PC  :=BOOL_OUT1     ,RAHU04H04_PC  :=BOOL_OUT2     , **)
		LAHU04H04_PC := BOOL_OUT1,
		RAHU04H04_PC := BOOL_OUT2,
(** 	                                                  LAHU04H04_TSET:=REAL_OUT1     ,RAHU04H04_TSET:=REAL_OUT2     , **)
		LAHU04H04_TSET := REAL_OUT1,
		RAHU04H04_TSET := REAL_OUT2,
(** 	                                                  LAHU04H04_SM  :=INT_OUT1      ,RAHU04H04_SM  :=INT_OUT2)     ; **)
		LAHU04H04_SM := INT_OUT1,
		RAHU04H04_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU04H05********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU04H05_WVB_AVE(INPUT:=LAHU04H05_WVB); **)
	(* call - Stmt *)
	CAL AHU04H05_WVB_AVE (
		INPUT := LAHU04H05_WVB
	)

(** 	AHU04H05_RT_AVE (INPUT:=LAHU04H05_RT) ; **)
	(* call - Stmt *)
	CAL AHU04H05_RT_AVE (
		INPUT := LAHU04H05_RT
	)

(** 	LAHU04H05_RTS :=            BS_Scale(AHU04H05_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU04H05_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU04H05_RTS

(** 	LAHU04H05_WVBS:=            BS_Scale(AHU04H05_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU04H05_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU04H05_WVBS

(** 	LAHU04H05_WVC :=REAL_TO_INT(BS_Scale(LAHU04H05_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU04H05_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU04H05_WVC

(** 	{*������*} **)
(** 	AHU04H05_DAHU(DAHU_STRUCT_IN:=DAHU04H05_IN | DAHU04H05_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU04H05_DAHU (
		DAHU_STRUCT_IN := DAHU04H05_IN
		|
		DAHU04H05_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU04H05_IN.SM     :=LAHU04H05_SM         ; **)
	(* assign - Stmt *)
	LD LAHU04H05_SM
	ST DAHU04H05_IN.SM

(** 	DAHU04H05_IN.Run    :=LAHU04H05_R          ; **)
	(* assign - Stmt *)
	LD LAHU04H05_R
	ST DAHU04H05_IN.Run

(** 	DAHU04H05_IN.Fault  :=LAHU04H05_F          ; **)
	(* assign - Stmt *)
	LD LAHU04H05_F
	ST DAHU04H05_IN.Fault

(** 	DAHU04H05_IN.Auto   :=LAHU04H05_A          ; **)
	(* assign - Stmt *)
	LD LAHU04H05_A
	ST DAHU04H05_IN.Auto

(** 	DAHU04H05_IN.ContRol:=LAHU04H05_PC         ; **)
	(* assign - Stmt *)
	LD LAHU04H05_PC
	ST DAHU04H05_IN.ContRol

(** 	DAHU04H05_IN.TSET   :=LAHU04H05_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU04H05_TSET
	ST DAHU04H05_IN.TSET

(** 	DAHU04H05_IN.WVMC   :=LAHU04H05_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU04H05_WVMC
	ST DAHU04H05_IN.WVMC

(** 	DAHU04H05_IN.WVMV   :=LAHU04H05_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU04H05_WVMV
	ST DAHU04H05_IN.WVMV

(** 	DAHU04H05_IN.RTS    :=LAHU04H05_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU04H05_RTS
	ST DAHU04H05_IN.RTS

(** 	DAHU04H05_IN.RST    :=LAHU04H05_RST        ; **)
	(* assign - Stmt *)
	LD LAHU04H05_RST
	ST DAHU04H05_IN.RST

(** 	DAHU04H05_IN.RSTV   :=LAHU04H05_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU04H05_RSTV
	ST DAHU04H05_IN.RSTV

(** 	DAHU04H05_IN.FPS    :=LAHU04H05_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU04H05_FPS
	ST DAHU04H05_IN.FPS

(** 	DAHU04H05_IN.ISO1   :=LAHU04H05_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU04H05_ISO1
	ST DAHU04H05_IN.ISO1

(** 	DAHU04H05_IN.ISO2   :=LAHU04H05_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU04H05_ISO2
	ST DAHU04H05_IN.ISO2

(** 	DAHU04H05_IN.VP     :=LAHU04H05_VP         ; **)
	(* assign - Stmt *)
	LD LAHU04H05_VP
	ST DAHU04H05_IN.VP

(** 	DAHU04H05_IN.VI     :=LAHU04H05_VI         ; **)
	(* assign - Stmt *)
	LD LAHU04H05_VI
	ST DAHU04H05_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU04H05_WVCS      :=DAHU04H05_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU04H05_OUT.WVCS
	ST LAHU04H05_WVCS

(** 	LAHU04H05_C         :=DAHU04H05_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU04H05_OUT.ContRol
	ST LAHU04H05_C

(** 	LAHU04H05_RH        :=DAHU04H05_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU04H05_OUT.RH
	ST LAHU04H05_RH

(** 	LAHU04H05_SN        :=DAHU04H05_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU04H05_OUT.SN
	ST LAHU04H05_SN

(** 	{*ͬ������*} **)
(** 	AHU04H05_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU04H05_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU04X00_PC  ,BOOL_IN1:=LAHU04H05_PC  ,BOOL_IN2      :=RAHU04H05_PC  , **)
		BOOL_IN0 := RNIAHU04X00_PC,
		BOOL_IN1 := LAHU04H05_PC,
		BOOL_IN2 := RAHU04H05_PC,
(** 	                             REAL_IN0:=RNIAHU04X00_TSET,REAL_IN1:=LAHU04H05_TSET,REAL_IN2      :=RAHU04H05_TSET, **)
		REAL_IN0 := RNIAHU04X00_TSET,
		REAL_IN1 := LAHU04H05_TSET,
		REAL_IN2 := RAHU04H05_TSET,
(** 	                             INT_IN0 :=RNIAHU04X00_SM  ,INT_IN1 :=LAHU04H05_SM  ,INT_IN2       :=RAHU04H05_SM  | **)
		INT_IN0 := RNIAHU04X00_SM,
		INT_IN1 := LAHU04H05_SM,
		INT_IN2 := RAHU04H05_SM
		|
(** 	                                                  LAHU04H05_PC  :=BOOL_OUT1     ,RAHU04H05_PC  :=BOOL_OUT2     , **)
		LAHU04H05_PC := BOOL_OUT1,
		RAHU04H05_PC := BOOL_OUT2,
(** 	                                                  LAHU04H05_TSET:=REAL_OUT1     ,RAHU04H05_TSET:=REAL_OUT2     , **)
		LAHU04H05_TSET := REAL_OUT1,
		RAHU04H05_TSET := REAL_OUT2,
(** 	                                                  LAHU04H05_SM  :=INT_OUT1      ,RAHU04H05_SM  :=INT_OUT2)     ; **)
		LAHU04H05_SM := INT_OUT1,
		RAHU04H05_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU04H06********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU04H06_WVB_AVE(INPUT:=LAHU04H06_WVB); **)
	(* call - Stmt *)
	CAL AHU04H06_WVB_AVE (
		INPUT := LAHU04H06_WVB
	)

(** 	AHU04H06_RT_AVE (INPUT:=LAHU04H06_RT) ; **)
	(* call - Stmt *)
	CAL AHU04H06_RT_AVE (
		INPUT := LAHU04H06_RT
	)

(** 	LAHU04H06_RTS :=            BS_Scale(AHU04H06_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU04H06_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU04H06_RTS

(** 	LAHU04H06_WVBS:=            BS_Scale(AHU04H06_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU04H06_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU04H06_WVBS

(** 	LAHU04H06_WVC :=REAL_TO_INT(BS_Scale(LAHU04H06_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU04H06_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU04H06_WVC

(** 	{*������*} **)
(** 	AHU04H06_DAHU(DAHU_STRUCT_IN:=DAHU04H06_IN | DAHU04H06_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU04H06_DAHU (
		DAHU_STRUCT_IN := DAHU04H06_IN
		|
		DAHU04H06_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU04H06_IN.SM     :=LAHU04H06_SM         ; **)
	(* assign - Stmt *)
	LD LAHU04H06_SM
	ST DAHU04H06_IN.SM

(** 	DAHU04H06_IN.Run    :=LAHU04H06_R          ; **)
	(* assign - Stmt *)
	LD LAHU04H06_R
	ST DAHU04H06_IN.Run

(** 	DAHU04H06_IN.Fault  :=LAHU04H06_F          ; **)
	(* assign - Stmt *)
	LD LAHU04H06_F
	ST DAHU04H06_IN.Fault

(** 	DAHU04H06_IN.Auto   :=LAHU04H06_A          ; **)
	(* assign - Stmt *)
	LD LAHU04H06_A
	ST DAHU04H06_IN.Auto

(** 	DAHU04H06_IN.ContRol:=LAHU04H06_PC         ; **)
	(* assign - Stmt *)
	LD LAHU04H06_PC
	ST DAHU04H06_IN.ContRol

(** 	DAHU04H06_IN.TSET   :=LAHU04H06_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU04H06_TSET
	ST DAHU04H06_IN.TSET

(** 	DAHU04H06_IN.WVMC   :=LAHU04H06_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU04H06_WVMC
	ST DAHU04H06_IN.WVMC

(** 	DAHU04H06_IN.WVMV   :=LAHU04H06_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU04H06_WVMV
	ST DAHU04H06_IN.WVMV

(** 	DAHU04H06_IN.RTS    :=LAHU04H06_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU04H06_RTS
	ST DAHU04H06_IN.RTS

(** 	DAHU04H06_IN.RST    :=LAHU04H06_RST        ; **)
	(* assign - Stmt *)
	LD LAHU04H06_RST
	ST DAHU04H06_IN.RST

(** 	DAHU04H06_IN.RSTV   :=LAHU04H06_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU04H06_RSTV
	ST DAHU04H06_IN.RSTV

(** 	DAHU04H06_IN.FPS    :=LAHU04H06_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU04H06_FPS
	ST DAHU04H06_IN.FPS

(** 	DAHU04H06_IN.ISO1   :=LAHU04H06_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU04H06_ISO1
	ST DAHU04H06_IN.ISO1

(** 	DAHU04H06_IN.ISO2   :=LAHU04H06_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU04H06_ISO2
	ST DAHU04H06_IN.ISO2

(** 	DAHU04H06_IN.VP     :=LAHU04H06_VP         ; **)
	(* assign - Stmt *)
	LD LAHU04H06_VP
	ST DAHU04H06_IN.VP

(** 	DAHU04H06_IN.VI     :=LAHU04H06_VI         ; **)
	(* assign - Stmt *)
	LD LAHU04H06_VI
	ST DAHU04H06_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU04H06_WVCS      :=DAHU04H06_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU04H06_OUT.WVCS
	ST LAHU04H06_WVCS

(** 	LAHU04H06_C         :=DAHU04H06_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU04H06_OUT.ContRol
	ST LAHU04H06_C

(** 	LAHU04H06_RH        :=DAHU04H06_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU04H06_OUT.RH
	ST LAHU04H06_RH

(** 	LAHU04H06_SN        :=DAHU04H06_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU04H06_OUT.SN
	ST LAHU04H06_SN

(** 	{*ͬ������*} **)
(** 	AHU04H06_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU04H06_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU04X00_PC  ,BOOL_IN1:=LAHU04H06_PC  ,BOOL_IN2      :=RAHU04H06_PC  , **)
		BOOL_IN0 := RNIAHU04X00_PC,
		BOOL_IN1 := LAHU04H06_PC,
		BOOL_IN2 := RAHU04H06_PC,
(** 	                             REAL_IN0:=RNIAHU04X00_TSET,REAL_IN1:=LAHU04H06_TSET,REAL_IN2      :=RAHU04H06_TSET, **)
		REAL_IN0 := RNIAHU04X00_TSET,
		REAL_IN1 := LAHU04H06_TSET,
		REAL_IN2 := RAHU04H06_TSET,
(** 	                             INT_IN0 :=RNIAHU04X00_SM  ,INT_IN1 :=LAHU04H06_SM  ,INT_IN2       :=RAHU04H06_SM  | **)
		INT_IN0 := RNIAHU04X00_SM,
		INT_IN1 := LAHU04H06_SM,
		INT_IN2 := RAHU04H06_SM
		|
(** 	                                                  LAHU04H06_PC  :=BOOL_OUT1     ,RAHU04H06_PC  :=BOOL_OUT2     , **)
		LAHU04H06_PC := BOOL_OUT1,
		RAHU04H06_PC := BOOL_OUT2,
(** 	                                                  LAHU04H06_TSET:=REAL_OUT1     ,RAHU04H06_TSET:=REAL_OUT2     , **)
		LAHU04H06_TSET := REAL_OUT1,
		RAHU04H06_TSET := REAL_OUT2,
(** 	                                                  LAHU04H06_SM  :=INT_OUT1      ,RAHU04H06_SM  :=INT_OUT2)     ; **)
		LAHU04H06_SM := INT_OUT1,
		RAHU04H06_SM := INT_OUT2
	)

(**  **)
(**  **)
(** 	{********************************************AHU04H07********************************************} **)
(** 	{*���룬���ͣ�ʾֵ���ޣ�ʾֵ���ޣ���׼��������������*} **)
(** 	AHU04H07_WVB_AVE(INPUT:=LAHU04H07_WVB); **)
	(* call - Stmt *)
	CAL AHU04H07_WVB_AVE (
		INPUT := LAHU04H07_WVB
	)

(** 	AHU04H07_RT_AVE (INPUT:=LAHU04H07_RT) ; **)
	(* call - Stmt *)
	CAL AHU04H07_RT_AVE (
		INPUT := LAHU04H07_RT
	)

(** 	LAHU04H07_RTS :=            BS_Scale(AHU04H07_RT_AVE.Output ,1,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU04H07_RT_AVE.Output
	BS_Scale 1, 0, 100, 0, 0.0
	ST LAHU04H07_RTS

(** 	LAHU04H07_WVBS:=            BS_Scale(AHU04H07_WVB_AVE.Output,2,0,100,0,0.0) ; **)
	(* assign - Stmt *)
	LD AHU04H07_WVB_AVE.Output
	BS_Scale 2, 0, 100, 0, 0.0
	ST LAHU04H07_WVBS

(** 	LAHU04H07_WVC :=REAL_TO_INT(BS_Scale(LAHU04H07_WVCS         ,4,0,100,0,0.0)); **)
	(* assign - Stmt *)
	LD LAHU04H07_WVCS
	BS_Scale 4, 0, 100, 0, 0.0
	REAL_TO_INT 
	ST LAHU04H07_WVC

(** 	{*������*} **)
(** 	AHU04H07_DAHU(DAHU_STRUCT_IN:=DAHU04H07_IN | DAHU04H07_OUT:=DAHU_STRUCT_OUT); **)
	(* call - Stmt *)
	CAL AHU04H07_DAHU (
		DAHU_STRUCT_IN := DAHU04H07_IN
		|
		DAHU04H07_OUT := DAHU_STRUCT_OUT
	)

(** 	{*AHU_INSTRUCT*} **)
(** 	DAHU04H07_IN.SM     :=LAHU04H07_SM         ; **)
	(* assign - Stmt *)
	LD LAHU04H07_SM
	ST DAHU04H07_IN.SM

(** 	DAHU04H07_IN.Run    :=LAHU04H07_R          ; **)
	(* assign - Stmt *)
	LD LAHU04H07_R
	ST DAHU04H07_IN.Run

(** 	DAHU04H07_IN.Fault  :=LAHU04H07_F          ; **)
	(* assign - Stmt *)
	LD LAHU04H07_F
	ST DAHU04H07_IN.Fault

(** 	DAHU04H07_IN.Auto   :=LAHU04H07_A          ; **)
	(* assign - Stmt *)
	LD LAHU04H07_A
	ST DAHU04H07_IN.Auto

(** 	DAHU04H07_IN.ContRol:=LAHU04H07_PC         ; **)
	(* assign - Stmt *)
	LD LAHU04H07_PC
	ST DAHU04H07_IN.ContRol

(** 	DAHU04H07_IN.TSET   :=LAHU04H07_TSET       ; **)
	(* assign - Stmt *)
	LD LAHU04H07_TSET
	ST DAHU04H07_IN.TSET

(** 	DAHU04H07_IN.WVMC   :=LAHU04H07_WVMC       ; **)
	(* assign - Stmt *)
	LD LAHU04H07_WVMC
	ST DAHU04H07_IN.WVMC

(** 	DAHU04H07_IN.WVMV   :=LAHU04H07_WVMV       ; **)
	(* assign - Stmt *)
	LD LAHU04H07_WVMV
	ST DAHU04H07_IN.WVMV

(** 	DAHU04H07_IN.RTS    :=LAHU04H07_RTS        ; **)
	(* assign - Stmt *)
	LD LAHU04H07_RTS
	ST DAHU04H07_IN.RTS

(** 	DAHU04H07_IN.RST    :=LAHU04H07_RST        ; **)
	(* assign - Stmt *)
	LD LAHU04H07_RST
	ST DAHU04H07_IN.RST

(** 	DAHU04H07_IN.RSTV   :=LAHU04H07_RSTV       ; **)
	(* assign - Stmt *)
	LD LAHU04H07_RSTV
	ST DAHU04H07_IN.RSTV

(** 	DAHU04H07_IN.FPS    :=LAHU04H07_FPS        ; **)
	(* assign - Stmt *)
	LD LAHU04H07_FPS
	ST DAHU04H07_IN.FPS

(** 	DAHU04H07_IN.ISO1   :=LAHU04H07_ISO1       ; **)
	(* assign - Stmt *)
	LD LAHU04H07_ISO1
	ST DAHU04H07_IN.ISO1

(** 	DAHU04H07_IN.ISO2   :=LAHU04H07_ISO2       ; **)
	(* assign - Stmt *)
	LD LAHU04H07_ISO2
	ST DAHU04H07_IN.ISO2

(** 	DAHU04H07_IN.VP     :=LAHU04H07_VP         ; **)
	(* assign - Stmt *)
	LD LAHU04H07_VP
	ST DAHU04H07_IN.VP

(** 	DAHU04H07_IN.VI     :=LAHU04H07_VI         ; **)
	(* assign - Stmt *)
	LD LAHU04H07_VI
	ST DAHU04H07_IN.VI

(** 	{*AHU_OUTSTRUCT*} **)
(** 	LAHU04H07_WVCS      :=DAHU04H07_OUT.WVCS   ; **)
	(* assign - Stmt *)
	LD DAHU04H07_OUT.WVCS
	ST LAHU04H07_WVCS

(** 	LAHU04H07_C         :=DAHU04H07_OUT.ContRol; **)
	(* assign - Stmt *)
	LD DAHU04H07_OUT.ContRol
	ST LAHU04H07_C

(** 	LAHU04H07_RH        :=DAHU04H07_OUT.RH     ; **)
	(* assign - Stmt *)
	LD DAHU04H07_OUT.RH
	ST LAHU04H07_RH

(** 	LAHU04H07_SN        :=DAHU04H07_OUT.SN     ; **)
	(* assign - Stmt *)
	LD DAHU04H07_OUT.SN
	ST LAHU04H07_SN

(** 	{*ͬ������*} **)
(** 	AHU04H07_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **)
	(* call - Stmt *)
	CAL AHU04H07_SyncContRol (
		CM := RNIAHU00000_CM,
		RM := LCMD00000_RM,
(** 	                             BOOL_IN0:=RNIAHU04X00_PC  ,BOOL_IN1:=LAHU04H07_PC  ,BOOL_IN2      :=RAHU04H07_PC  , **)
		BOOL_IN0 := RNIAHU04X00_PC,
		BOOL_IN1 := LAHU04H07_PC,
		BOOL_IN2 := RAHU04H07_PC,
(** 	                             REAL_IN0:=RNIAHU04X00_TSET,REAL_IN1:=LAHU04H07_TSET,REAL_IN2      :=RAHU04H07_TSET, **)
		REAL_IN0 := RNIAHU04X00_TSET,
		REAL_IN1 := LAHU04H07_TSET,
		REAL_IN2 := RAHU04H07_TSET,
(** 	                             INT_IN0 :=RNIAHU04X00_SM  ,INT_IN1 :=LAHU04H07_SM  ,INT_IN2       :=RAHU04H07_SM  | **)
		INT_IN0 := RNIAHU04X00_SM,
		INT_IN1 := LAHU04H07_SM,
		INT_IN2 := RAHU04H07_SM
		|
(** 	                                                  LAHU04H07_PC  :=BOOL_OUT1     ,RAHU04H07_PC  :=BOOL_OUT2     , **)
		LAHU04H07_PC := BOOL_OUT1,
		RAHU04H07_PC := BOOL_OUT2,
(** 	                                                  LAHU04H07_TSET:=REAL_OUT1     ,RAHU04H07_TSET:=REAL_OUT2     , **)
		LAHU04H07_TSET := REAL_OUT1,
		RAHU04H07_TSET := REAL_OUT2,
(** 	                                                  LAHU04H07_SM  :=INT_OUT1      ,RAHU04H07_SM  :=INT_OUT2)     ; **)
		LAHU04H07_SM := INT_OUT1,
		RAHU04H07_SM := INT_OUT2
	)


END_PROGRAM