PROGRAM DAHU VAR_EXTERNAL END_VAR VAR_GLOBAL END_VAR VAR DAHU03G01_IN :DAHU_IN; DAHU03G01_OUT:DAHU_OUT; AHU03G01_SyncControl:IJ_SyncControl; AHU03G01_DAHU:IJ_DAHU; AHU03G01_RT_AVE :BS_Average; AHU03G01_WVB_AVE:BS_Average; DAHU03G02_IN :DAHU_IN; DAHU03G02_OUT:DAHU_OUT; AHU03G02_SyncControl:IJ_SyncControl; AHU03G02_DAHU:IJ_DAHU; AHU03G02_RT_AVE :BS_Average; AHU03G02_WVB_AVE:BS_Average; DAHU03G03_IN :DAHU_IN; DAHU03G03_OUT:DAHU_OUT; AHU03G03_SyncControl:IJ_SyncControl; AHU03G03_DAHU:IJ_DAHU; AHU03G03_RT_AVE :BS_Average; AHU03G03_WVB_AVE:BS_Average; DAHU03G04_IN :DAHU_IN; DAHU03G04_OUT:DAHU_OUT; AHU03G04_SyncControl:IJ_SyncControl; AHU03G04_DAHU:IJ_DAHU; AHU03G04_RT_AVE :BS_Average; AHU03G04_WVB_AVE:BS_Average; DAHU03G05_IN :DAHU_IN; DAHU03G05_OUT:DAHU_OUT; AHU03G05_SyncControl:IJ_SyncControl; AHU03G05_DAHU:IJ_DAHU; AHU03G05_RT_AVE :BS_Average; AHU03G05_WVB_AVE:BS_Average; DAHU03G06_IN :DAHU_IN; DAHU03G06_OUT:DAHU_OUT; AHU03G06_SyncControl:IJ_SyncControl; AHU03G06_DAHU:IJ_DAHU; AHU03G06_RT_AVE :BS_Average; AHU03G06_WVB_AVE:BS_Average; DAHU03G07_IN :DAHU_IN; DAHU03G07_OUT:DAHU_OUT; AHU03G07_SyncControl:IJ_SyncControl; AHU03G07_DAHU:IJ_DAHU; AHU03G07_RT_AVE :BS_Average; AHU03G07_WVB_AVE:BS_Average; DAHU03G08_IN :DAHU_IN; DAHU03G08_OUT:DAHU_OUT; AHU03G08_SyncControl:IJ_SyncControl; AHU03G08_DAHU:IJ_DAHU; AHU03G08_RT_AVE :BS_Average; AHU03G08_WVB_AVE:BS_Average; DAHU03G09_IN :DAHU_IN; DAHU03G09_OUT:DAHU_OUT; AHU03G09_SyncControl:IJ_SyncControl; AHU03G09_DAHU:IJ_DAHU; AHU03G09_RT_AVE :BS_Average; AHU03G09_WVB_AVE:BS_Average; DAHU03G10_IN :DAHU_IN; DAHU03G10_OUT:DAHU_OUT; AHU03G10_SyncControl:IJ_SyncControl; AHU03G10_DAHU:IJ_DAHU; AHU03G10_RT_AVE :BS_Average; AHU03G10_WVB_AVE:BS_Average; DAHU03G11_IN :DAHU_IN; DAHU03G11_OUT:DAHU_OUT; AHU03G11_SyncControl:IJ_SyncControl; AHU03G11_DAHU:IJ_DAHU; AHU03G11_RT_AVE :BS_Average; AHU03G11_WVB_AVE:BS_Average; DAHU03G12_IN :DAHU_IN; DAHU03G12_OUT:DAHU_OUT; AHU03G12_SyncControl:IJ_SyncControl; AHU03G12_DAHU:IJ_DAHU; AHU03G12_RT_AVE :BS_Average; AHU03G12_WVB_AVE:BS_Average; DAHU04G01_IN :DAHU_IN; DAHU04G01_OUT:DAHU_OUT; AHU04G01_SyncControl:IJ_SyncControl; AHU04G01_DAHU:IJ_DAHU; AHU04G01_RT_AVE :BS_Average; AHU04G01_WVB_AVE:BS_Average; DAHU04G02_IN :DAHU_IN; DAHU04G02_OUT:DAHU_OUT; AHU04G02_SyncControl:IJ_SyncControl; AHU04G02_DAHU:IJ_DAHU; AHU04G02_RT_AVE :BS_Average; AHU04G02_WVB_AVE:BS_Average; DAHU04G03_IN :DAHU_IN; DAHU04G03_OUT:DAHU_OUT; AHU04G03_SyncControl:IJ_SyncControl; AHU04G03_DAHU:IJ_DAHU; AHU04G03_RT_AVE :BS_Average; AHU04G03_WVB_AVE:BS_Average; DAHU04G04_IN :DAHU_IN; DAHU04G04_OUT:DAHU_OUT; AHU04G04_SyncControl:IJ_SyncControl; AHU04G04_DAHU:IJ_DAHU; AHU04G04_RT_AVE :BS_Average; AHU04G04_WVB_AVE:BS_Average; DAHU04G05_IN :DAHU_IN; DAHU04G05_OUT:DAHU_OUT; AHU04G05_SyncControl:IJ_SyncControl; AHU04G05_DAHU:IJ_DAHU; AHU04G05_RT_AVE :BS_Average; AHU04G05_WVB_AVE:BS_Average; DAHU04G06_IN :DAHU_IN; DAHU04G06_OUT:DAHU_OUT; AHU04G06_SyncControl:IJ_SyncControl; AHU04G06_DAHU:IJ_DAHU; AHU04G06_RT_AVE :BS_Average; AHU04G06_WVB_AVE:BS_Average; END_VAR (*Automatically declared*) VAR_EXTERNAL LAHU04G06_PC : BOOL; LAHU04G06_WVCS : INT; RAHU04G06_PC : BOOL; LAHU04G04_WVMV : REAL; LAHU04G04_WVMC : BOOL; RAHU04G04_TSET : REAL; LAHU04G03_SN : INT; LAHU04G03_RSTV : REAL; LAHU04G03_RST : BOOL; LAHU04G03_SM : INT; LAHU04G03_TSET : REAL; LAHU04G02_WVMV : REAL; LAHU04G02_WVMC : BOOL; LAHU03G12_WVMV : REAL; LAHU03G12_WVMC : BOOL; LAHU03G10_WVCS : INT; LAHU03G10_SN : INT; LAHU03G10_SM : INT; RAHU03G10_TSET : REAL; LAHU03G06_PC : BOOL; LAHU03G06_WVCS : INT; RAHU03G06_PC : BOOL; LAHU03G04_WVMV : REAL; LAHU03G04_WVMC : BOOL; RAHU03G04_TSET : REAL; LAHU03G03_SN : INT; LAHU03G03_RSTV : REAL; LAHU03G03_RST : BOOL; LAHU03G03_SM : INT; LAHU03G03_TSET : REAL; LAHU03G02_WVMV : REAL; LAHU03G02_WVMC : BOOL; LCMD00000_RM : INT; LAHU04G06_WVC : INT; LAHU04G05_FPS : BOOL; LAHU03G10_WVC : INT; LAHU03G06_WVC : INT; LAHU03G09_F : BOOL; LAHU03G05_FPS : BOOL; LAHU04G06_WVBS : REAL; RAHU04G05_SM : INT; LAHU04G03_RH : REAL; LAHU04G02_PC : BOOL; LAHU03G12_PC : BOOL; LAHU03G10_PC : BOOL; LAHU03G10_RTS : REAL; LAHU03G10_WVBS : REAL; LAHU03G09_VI : REAL; LAHU03G09_VP : REAL; LAHU03G08_RTS : REAL; RAHU03G08_PC : BOOL; LAHU03G06_WVBS : REAL; RAHU03G05_SM : INT; LAHU03G03_RH : REAL; LAHU03G02_PC : BOOL; LAHU04G06_WVB : INT; LAHU04G03_RT : INT; LAHU04G03_C : BOOL; LAHU04G03_R : BOOL; LAHU04G02_A : BOOL; LAHU03G10_WVB : INT; LAHU03G06_WVB : INT; LAHU03G03_RT : INT; LAHU03G03_C : BOOL; LAHU03G12_A : BOOL; LAHU03G10_A : BOOL; LAHU03G03_R : BOOL; LAHU03G02_A : BOOL; LAHU04G06_RH : REAL; RAHU04G06_TSET : REAL; LAHU04G05_ISO2 : BOOL; LAHU04G05_ISO1 : BOOL; LAHU04G04_RTS : REAL; RAHU04G04_PC : BOOL; LAHU03G10_ISO2 : BOOL; LAHU03G10_ISO1 : BOOL; LAHU03G08_TSET : REAL; LAHU03G06_RH : REAL; RAHU03G06_TSET : REAL; LAHU03G05_ISO2 : BOOL; LAHU03G05_ISO1 : BOOL; LAHU03G04_RTS : REAL; RAHU03G04_PC : BOOL; LAHU04G06_RT : INT; LAHU04G06_A : BOOL; LAHU04G06_R : BOOL; LAHU04G01_F : BOOL; LAHU03G06_RT : INT; LAHU03G11_F : BOOL; LAHU03G06_A : BOOL; LAHU03G06_R : BOOL; LAHU03G01_F : BOOL; LAHU04G06_SN : INT; LAHU04G06_SM : INT; RAHU04G05_TSET : REAL; LAHU04G04_RSTV : REAL; LAHU04G04_RST : BOOL; LAHU04G03_PC : BOOL; LAHU04G02_RH : REAL; LAHU04G01_VI : REAL; LAHU04G01_VP : REAL; LAHU04G01_ISO2 : BOOL; LAHU04G01_ISO1 : BOOL; LAHU03G12_RH : REAL; LAHU03G11_VI : REAL; LAHU03G11_VP : REAL; LAHU03G11_ISO2 : BOOL; LAHU03G11_ISO1 : BOOL; LAHU03G08_WVMV : REAL; LAHU03G08_WVMC : BOOL; LAHU03G07_WVBS : REAL; LAHU03G06_SN : INT; LAHU03G06_SM : INT; RAHU03G05_TSET : REAL; LAHU03G04_RSTV : REAL; LAHU03G04_RST : BOOL; LAHU03G03_PC : BOOL; LAHU03G02_RH : REAL; LAHU03G01_VI : REAL; LAHU03G01_VP : REAL; LAHU03G01_ISO2 : BOOL; LAHU03G01_ISO1 : BOOL; LAHU04G02_RT : INT; LAHU04G02_C : BOOL; LAHU04G03_A : BOOL; LAHU04G02_R : BOOL; LAHU03G12_RT : INT; LAHU03G07_WVB : INT; LAHU03G02_RT : INT; LAHU03G12_C : BOOL; LAHU03G02_C : BOOL; LAHU03G12_R : BOOL; LAHU03G10_FPS : BOOL; LAHU03G08_FPS : BOOL; LAHU03G03_A : BOOL; LAHU03G02_R : BOOL; RAHU04G05_PC : BOOL; RAHU04G03_PC : BOOL; LAHU04G02_SN : INT; LAHU04G02_RSTV : REAL; LAHU04G02_RST : BOOL; LAHU04G02_SM : INT; LAHU03G12_SN : INT; LAHU03G12_RSTV : REAL; LAHU03G12_RST : BOOL; LAHU03G12_SM : INT; LAHU03G09_RTS : REAL; RAHU03G08_SM : INT; LAHU03G07_WVCS : INT; LAHU03G07_RSTV : REAL; LAHU03G07_RST : BOOL; RAHU03G05_PC : BOOL; RAHU03G03_PC : BOOL; LAHU03G02_SN : INT; LAHU03G02_RSTV : REAL; LAHU03G02_RST : BOOL; LAHU03G02_SM : INT; LAHU04G06_C : BOOL; LAHU04G05_F : BOOL; LAHU03G07_WVC : INT; LAHU03G06_C : BOOL; LAHU03G05_F : BOOL; LAHU04G05_VI : REAL; LAHU04G05_VP : REAL; RAHU04G04_SM : INT; LAHU04G03_VI : REAL; LAHU04G03_VP : REAL; RAHU04G03_SM : INT; LAHU04G02_ISO2 : BOOL; LAHU04G02_ISO1 : BOOL; LAHU04G02_TSET : REAL; LAHU04G01_RTS : REAL; LAHU03G12_ISO2 : BOOL; LAHU03G12_ISO1 : BOOL; LAHU03G12_TSET : REAL; LAHU03G11_RTS : REAL; LAHU03G07_RTS : REAL; LAHU03G05_VI : REAL; LAHU03G05_VP : REAL; RAHU03G04_SM : INT; LAHU03G03_VI : REAL; LAHU03G03_VP : REAL; RAHU03G03_SM : INT; LAHU03G02_ISO2 : BOOL; LAHU03G02_ISO1 : BOOL; LAHU03G02_TSET : REAL; LAHU03G01_RTS : REAL; LAHU04G06_FPS : BOOL; LAHU04G05_A : BOOL; LAHU03G06_FPS : BOOL; LAHU03G05_A : BOOL; RNIAHU04X00_TSET : REAL; RNIAHU03X00_TSET : REAL; LAHU04G05_WVBS : REAL; RAHU04G01_TSET : REAL; RAHU03G11_TSET : REAL; LAHU03G09_ISO2 : BOOL; LAHU03G09_ISO1 : BOOL; LAHU03G09_TSET : REAL; LAHU03G08_WVCS : INT; RAHU03G08_TSET : REAL; LAHU03G05_WVBS : REAL; RAHU03G01_TSET : REAL; LAHU04G05_WVB : INT; LAHU04G03_F : BOOL; LAHU04G02_F : BOOL; LAHU03G08_WVC : INT; LAHU03G05_WVB : INT; LAHU03G12_F : BOOL; LAHU03G09_FPS : BOOL; LAHU03G07_FPS : BOOL; LAHU03G03_F : BOOL; LAHU03G02_F : BOOL; LAHU04G06_ISO2 : BOOL; LAHU04G06_ISO1 : BOOL; LAHU04G06_TSET : REAL; LAHU04G05_PC : BOOL; LAHU04G05_WVCS : INT; LAHU04G04_RH : REAL; LAHU04G02_VI : REAL; LAHU04G02_VP : REAL; LAHU04G02_RTS : REAL; LAHU04G01_TSET : REAL; LAHU03G12_VI : REAL; LAHU03G12_VP : REAL; LAHU03G12_RTS : REAL; LAHU03G11_TSET : REAL; LAHU03G09_RSTV : REAL; LAHU03G09_RST : BOOL; LAHU03G08_WVBS : REAL; LAHU03G06_ISO2 : BOOL; LAHU03G06_ISO1 : BOOL; LAHU03G06_TSET : REAL; LAHU03G05_PC : BOOL; LAHU03G05_WVCS : INT; LAHU03G04_RH : REAL; LAHU03G02_VI : REAL; LAHU03G02_VP : REAL; LAHU03G02_RTS : REAL; LAHU03G01_TSET : REAL; LAHU04G05_WVC : INT; LAHU04G04_RT : INT; LAHU04G05_C : BOOL; LAHU04G04_R : BOOL; LAHU04G03_FPS : BOOL; LAHU03G05_WVC : INT; LAHU03G08_WVB : INT; LAHU03G04_RT : INT; LAHU03G05_C : BOOL; LAHU03G04_R : BOOL; LAHU03G03_FPS : BOOL; LAHU04G05_SN : INT; LAHU04G05_SM : INT; LAHU04G04_SN : INT; LAHU04G04_SM : INT; LAHU04G01_RSTV : REAL; LAHU04G01_RST : BOOL; LAHU03G11_RSTV : REAL; LAHU03G11_RST : BOOL; RAHU03G09_TSET : REAL; LAHU03G08_VI : REAL; LAHU03G08_VP : REAL; LAHU03G05_SN : INT; LAHU03G05_SM : INT; LAHU03G04_SN : INT; LAHU03G04_SM : INT; LAHU03G01_RSTV : REAL; LAHU03G01_RST : BOOL; LAHU04G04_FPS : BOOL; LAHU03G07_F : BOOL; LAHU03G04_FPS : BOOL; LAHU04G05_RH : REAL; LAHU04G04_PC : BOOL; RAHU04G02_SM : INT; RAHU04G01_SM : INT; RAHU03G12_SM : INT; RAHU03G11_SM : INT; RAHU03G10_PC : BOOL; LAHU03G07_VI : REAL; LAHU03G07_VP : REAL; LAHU03G07_TSET : REAL; LAHU03G05_RH : REAL; LAHU03G04_PC : BOOL; RAHU03G02_SM : INT; RAHU03G01_SM : INT; LAHU04G05_RT : INT; LAHU04G04_C : BOOL; LAHU04G05_R : BOOL; LAHU03G05_RT : INT; LAHU03G04_C : BOOL; LAHU03G08_F : BOOL; LAHU03G05_R : BOOL; RNIAHU04X00_SM : INT; RNIAHU03X00_SM : INT; LAHU04G06_RTS : REAL; LAHU04G03_RTS : REAL; RAHU04G02_PC : BOOL; RAHU04G02_TSET : REAL; RAHU03G12_PC : BOOL; RAHU03G12_TSET : REAL; RAHU03G07_TSET : REAL; LAHU03G06_RTS : REAL; LAHU03G03_RTS : REAL; RAHU03G02_PC : BOOL; RAHU03G02_TSET : REAL; LAHU04G01_FPS : BOOL; LAHU03G11_FPS : BOOL; LAHU03G09_A : BOOL; LAHU03G01_FPS : BOOL; RNIAHU04X00_PC : BOOL; RNIAHU03X00_PC : BOOL; RNIAHU00000_CM : BOOL; LAHU04G06_WVMV : REAL; LAHU04G06_WVMC : BOOL; LAHU04G05_RSTV : REAL; LAHU04G05_RST : BOOL; LAHU04G04_WVCS : INT; LAHU04G04_VI : REAL; LAHU04G04_VP : REAL; LAHU04G03_WVBS : REAL; LAHU03G10_RSTV : REAL; LAHU03G10_RST : BOOL; LAHU03G08_RSTV : REAL; LAHU03G08_RST : BOOL; LAHU03G07_ISO2 : BOOL; LAHU03G07_ISO1 : BOOL; LAHU03G06_WVMV : REAL; LAHU03G06_WVMC : BOOL; LAHU03G05_RSTV : REAL; LAHU03G05_RST : BOOL; LAHU03G04_WVCS : INT; LAHU03G04_VI : REAL; LAHU03G04_VP : REAL; LAHU03G03_WVBS : REAL; LAHU04G04_WVC : INT; LAHU04G03_WVB : INT; LAHU04G04_A : BOOL; LAHU03G04_WVC : INT; LAHU03G03_WVB : INT; LAHU03G07_C : BOOL; LAHU03G10_F : BOOL; LAHU03G04_A : BOOL; LAHU04G04_WVBS : REAL; LAHU04G03_WVCS : INT; LAHU04G01_WVMV : REAL; LAHU04G01_WVMC : BOOL; RAHU04G01_PC : BOOL; LAHU03G11_WVMV : REAL; LAHU03G11_WVMC : BOOL; RAHU03G11_PC : BOOL; LAHU03G10_VI : REAL; LAHU03G10_VP : REAL; RAHU03G10_SM : INT; LAHU03G09_PC : BOOL; LAHU03G08_RH : REAL; LAHU03G07_SN : INT; LAHU03G07_SM : INT; LAHU03G04_WVBS : REAL; LAHU03G03_WVCS : INT; LAHU03G01_WVMV : REAL; LAHU03G01_WVMC : BOOL; RAHU03G01_PC : BOOL; LAHU04G03_WVC : INT; LAHU04G04_WVB : INT; LAHU04G04_F : BOOL; LAHU04G02_FPS : BOOL; LAHU04G01_A : BOOL; LAHU03G03_WVC : INT; LAHU03G08_RT : INT; LAHU03G04_WVB : INT; LAHU03G09_C : BOOL; LAHU03G12_FPS : BOOL; LAHU03G11_A : BOOL; LAHU03G08_R : BOOL; LAHU03G04_F : BOOL; LAHU03G02_FPS : BOOL; LAHU03G01_A : BOOL; LAHU04G04_ISO2 : BOOL; LAHU04G04_ISO1 : BOOL; RAHU04G03_TSET : REAL; LAHU03G10_TSET : REAL; LAHU03G09_SN : INT; LAHU03G09_WVMV : REAL; LAHU03G09_WVMC : BOOL; LAHU03G09_SM : INT; RAHU03G09_SM : INT; LAHU03G08_SN : INT; LAHU03G08_SM : INT; LAHU03G07_RH : REAL; LAHU03G04_ISO2 : BOOL; LAHU03G04_ISO1 : BOOL; RAHU03G03_TSET : REAL; LAHU03G07_RT : INT; LAHU03G07_A : BOOL; LAHU03G07_R : BOOL; LAHU04G05_WVMV : REAL; LAHU04G05_WVMC : BOOL; LAHU04G03_ISO2 : BOOL; LAHU04G03_ISO1 : BOOL; LAHU04G03_WVMV : REAL; LAHU04G03_WVMC : BOOL; LAHU04G02_WVCS : INT; LAHU04G01_PC : BOOL; LAHU04G01_WVBS : REAL; LAHU03G12_WVCS : INT; LAHU03G11_PC : BOOL; LAHU03G11_WVBS : REAL; LAHU03G09_RH : REAL; LAHU03G09_WVBS : REAL; LAHU03G08_PC : BOOL; LAHU03G07_WVMV : REAL; LAHU03G07_WVMC : BOOL; LAHU03G05_WVMV : REAL; LAHU03G05_WVMC : BOOL; LAHU03G03_ISO2 : BOOL; LAHU03G03_ISO1 : BOOL; LAHU03G03_WVMV : REAL; LAHU03G03_WVMC : BOOL; LAHU03G02_WVCS : INT; LAHU03G01_PC : BOOL; LAHU03G01_WVBS : REAL; LAHU04G02_WVC : INT; LAHU04G01_WVB : INT; LAHU04G01_C : BOOL; LAHU03G12_WVC : INT; LAHU03G02_WVC : INT; LAHU03G11_WVB : INT; LAHU03G09_WVB : INT; LAHU03G09_RT : INT; LAHU03G01_WVB : INT; LAHU03G11_C : BOOL; LAHU03G08_C : BOOL; LAHU03G01_C : BOOL; LAHU03G09_R : BOOL; LAHU04G06_VI : REAL; LAHU04G06_VP : REAL; LAHU04G06_RSTV : REAL; LAHU04G06_RST : BOOL; LAHU04G05_TSET : REAL; LAHU04G04_TSET : REAL; LAHU04G02_WVBS : REAL; LAHU04G01_WVCS : INT; LAHU04G01_SN : INT; LAHU04G01_SM : INT; LAHU03G12_WVBS : REAL; LAHU03G11_WVCS : INT; LAHU03G11_SN : INT; LAHU03G11_SM : INT; LAHU03G10_WVMV : REAL; LAHU03G10_WVMC : BOOL; LAHU03G09_WVCS : INT; LAHU03G08_ISO2 : BOOL; LAHU03G08_ISO1 : BOOL; LAHU03G07_PC : BOOL; RAHU03G07_PC : BOOL; LAHU03G06_VI : REAL; LAHU03G06_VP : REAL; LAHU03G06_RSTV : REAL; LAHU03G06_RST : BOOL; LAHU03G05_TSET : REAL; LAHU03G04_TSET : REAL; LAHU03G02_WVBS : REAL; LAHU03G01_WVCS : INT; LAHU03G01_SN : INT; LAHU03G01_SM : INT; LAHU04G01_WVC : INT; LAHU04G02_WVB : INT; LAHU03G11_WVC : INT; LAHU03G09_WVC : INT; LAHU03G01_WVC : INT; LAHU03G12_WVB : INT; LAHU03G02_WVB : INT; RAHU04G06_SM : INT; LAHU04G05_RTS : REAL; LAHU04G01_RH : REAL; LAHU03G11_RH : REAL; LAHU03G10_RH : REAL; RAHU03G09_PC : BOOL; RAHU03G07_SM : INT; RAHU03G06_SM : INT; LAHU03G05_RTS : REAL; LAHU03G01_RH : REAL; LAHU04G01_RT : INT; LAHU04G06_F : BOOL; LAHU04G01_R : BOOL; LAHU03G11_RT : INT; LAHU03G10_RT : INT; LAHU03G01_RT : INT; LAHU03G10_C : BOOL; LAHU03G11_R : BOOL; LAHU03G10_R : BOOL; LAHU03G08_A : BOOL; LAHU03G06_F : BOOL; LAHU03G01_R : BOOL; END_VAR (** {********************************************AHU03G01********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU03G01_WVB_AVE(INPUT:=LAHU03G01_WVB); **) (* call - Stmt *) CAL AHU03G01_WVB_AVE ( INPUT := LAHU03G01_WVB ) (** AHU03G01_RT_AVE (INPUT:=LAHU03G01_RT) ; **) (* call - Stmt *) CAL AHU03G01_RT_AVE ( INPUT := LAHU03G01_RT ) (** LAHU03G01_RTS := BS_Scale(AHU03G01_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G01_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU03G01_RTS (** LAHU03G01_WVBS:= BS_Scale(AHU03G01_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G01_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU03G01_WVBS (** LAHU03G01_WVC :=REAL_TO_INT(BS_Scale(LAHU03G01_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU03G01_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU03G01_WVC (** {*主程序*} **) (** AHU03G01_DAHU(DAHU_STRUCT_IN:=DAHU03G01_IN | DAHU03G01_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU03G01_DAHU ( DAHU_STRUCT_IN := DAHU03G01_IN | DAHU03G01_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU03G01_IN.SM :=LAHU03G01_SM ; **) (* assign - Stmt *) LD LAHU03G01_SM ST DAHU03G01_IN.SM (** DAHU03G01_IN.Run :=LAHU03G01_R ; **) (* assign - Stmt *) LD LAHU03G01_R ST DAHU03G01_IN.Run (** DAHU03G01_IN.Fault :=LAHU03G01_F ; **) (* assign - Stmt *) LD LAHU03G01_F ST DAHU03G01_IN.Fault (** DAHU03G01_IN.Auto :=LAHU03G01_A ; **) (* assign - Stmt *) LD LAHU03G01_A ST DAHU03G01_IN.Auto (** DAHU03G01_IN.ContRol:=LAHU03G01_PC ; **) (* assign - Stmt *) LD LAHU03G01_PC ST DAHU03G01_IN.ContRol (** DAHU03G01_IN.TSET :=LAHU03G01_TSET ; **) (* assign - Stmt *) LD LAHU03G01_TSET ST DAHU03G01_IN.TSET (** DAHU03G01_IN.WVMC :=LAHU03G01_WVMC ; **) (* assign - Stmt *) LD LAHU03G01_WVMC ST DAHU03G01_IN.WVMC (** DAHU03G01_IN.WVMV :=LAHU03G01_WVMV ; **) (* assign - Stmt *) LD LAHU03G01_WVMV ST DAHU03G01_IN.WVMV (** DAHU03G01_IN.RTS :=LAHU03G01_RTS ; **) (* assign - Stmt *) LD LAHU03G01_RTS ST DAHU03G01_IN.RTS (** DAHU03G01_IN.RST :=LAHU03G01_RST ; **) (* assign - Stmt *) LD LAHU03G01_RST ST DAHU03G01_IN.RST (** DAHU03G01_IN.RSTV :=LAHU03G01_RSTV ; **) (* assign - Stmt *) LD LAHU03G01_RSTV ST DAHU03G01_IN.RSTV (** DAHU03G01_IN.FPS :=LAHU03G01_FPS ; **) (* assign - Stmt *) LD LAHU03G01_FPS ST DAHU03G01_IN.FPS (** DAHU03G01_IN.ISO1 :=LAHU03G01_ISO1 ; **) (* assign - Stmt *) LD LAHU03G01_ISO1 ST DAHU03G01_IN.ISO1 (** DAHU03G01_IN.ISO2 :=LAHU03G01_ISO2 ; **) (* assign - Stmt *) LD LAHU03G01_ISO2 ST DAHU03G01_IN.ISO2 (** DAHU03G01_IN.VP :=LAHU03G01_VP ; **) (* assign - Stmt *) LD LAHU03G01_VP ST DAHU03G01_IN.VP (** DAHU03G01_IN.VI :=LAHU03G01_VI ; **) (* assign - Stmt *) LD LAHU03G01_VI ST DAHU03G01_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU03G01_WVCS :=DAHU03G01_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU03G01_OUT.WVCS ST LAHU03G01_WVCS (** LAHU03G01_C :=DAHU03G01_OUT.ContRol; **) (* assign - Stmt *) LD DAHU03G01_OUT.ContRol ST LAHU03G01_C (** LAHU03G01_RH :=DAHU03G01_OUT.RH ; **) (* assign - Stmt *) LD DAHU03G01_OUT.RH ST LAHU03G01_RH (** LAHU03G01_SN :=DAHU03G01_OUT.SN ; **) (* assign - Stmt *) LD DAHU03G01_OUT.SN ST LAHU03G01_SN (** {*同步程序*} **) (** AHU03G01_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU03G01_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU03X00_PC ,BOOL_IN1:=LAHU03G01_PC ,BOOL_IN2 :=RAHU03G01_PC , **) BOOL_IN0 := RNIAHU03X00_PC, BOOL_IN1 := LAHU03G01_PC, BOOL_IN2 := RAHU03G01_PC, (** REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03G01_TSET,REAL_IN2 :=RAHU03G01_TSET, **) REAL_IN0 := RNIAHU03X00_TSET, REAL_IN1 := LAHU03G01_TSET, REAL_IN2 := RAHU03G01_TSET, (** INT_IN0 :=RNIAHU03X00_SM ,INT_IN1 :=LAHU03G01_SM ,INT_IN2 :=RAHU03G01_SM | **) INT_IN0 := RNIAHU03X00_SM, INT_IN1 := LAHU03G01_SM, INT_IN2 := RAHU03G01_SM | (** LAHU03G01_PC :=BOOL_OUT1 ,RAHU03G01_PC :=BOOL_OUT2 , **) LAHU03G01_PC := BOOL_OUT1, RAHU03G01_PC := BOOL_OUT2, (** LAHU03G01_TSET:=REAL_OUT1 ,RAHU03G01_TSET:=REAL_OUT2 , **) LAHU03G01_TSET := REAL_OUT1, RAHU03G01_TSET := REAL_OUT2, (** LAHU03G01_SM :=INT_OUT1 ,RAHU03G01_SM :=INT_OUT2) ; **) LAHU03G01_SM := INT_OUT1, RAHU03G01_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU03G02********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU03G02_WVB_AVE(INPUT:=LAHU03G02_WVB); **) (* call - Stmt *) CAL AHU03G02_WVB_AVE ( INPUT := LAHU03G02_WVB ) (** AHU03G02_RT_AVE (INPUT:=LAHU03G02_RT) ; **) (* call - Stmt *) CAL AHU03G02_RT_AVE ( INPUT := LAHU03G02_RT ) (** LAHU03G02_RTS := BS_Scale(AHU03G02_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G02_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU03G02_RTS (** LAHU03G02_WVBS:= BS_Scale(AHU03G02_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G02_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU03G02_WVBS (** LAHU03G02_WVC :=REAL_TO_INT(BS_Scale(LAHU03G02_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU03G02_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU03G02_WVC (** {*主程序*} **) (** AHU03G02_DAHU(DAHU_STRUCT_IN:=DAHU03G02_IN | DAHU03G02_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU03G02_DAHU ( DAHU_STRUCT_IN := DAHU03G02_IN | DAHU03G02_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU03G02_IN.SM :=LAHU03G02_SM ; **) (* assign - Stmt *) LD LAHU03G02_SM ST DAHU03G02_IN.SM (** DAHU03G02_IN.Run :=LAHU03G02_R ; **) (* assign - Stmt *) LD LAHU03G02_R ST DAHU03G02_IN.Run (** DAHU03G02_IN.Fault :=LAHU03G02_F ; **) (* assign - Stmt *) LD LAHU03G02_F ST DAHU03G02_IN.Fault (** DAHU03G02_IN.Auto :=LAHU03G02_A ; **) (* assign - Stmt *) LD LAHU03G02_A ST DAHU03G02_IN.Auto (** DAHU03G02_IN.ContRol:=LAHU03G02_PC ; **) (* assign - Stmt *) LD LAHU03G02_PC ST DAHU03G02_IN.ContRol (** DAHU03G02_IN.TSET :=LAHU03G02_TSET ; **) (* assign - Stmt *) LD LAHU03G02_TSET ST DAHU03G02_IN.TSET (** DAHU03G02_IN.WVMC :=LAHU03G02_WVMC ; **) (* assign - Stmt *) LD LAHU03G02_WVMC ST DAHU03G02_IN.WVMC (** DAHU03G02_IN.WVMV :=LAHU03G02_WVMV ; **) (* assign - Stmt *) LD LAHU03G02_WVMV ST DAHU03G02_IN.WVMV (** DAHU03G02_IN.RTS :=LAHU03G02_RTS ; **) (* assign - Stmt *) LD LAHU03G02_RTS ST DAHU03G02_IN.RTS (** DAHU03G02_IN.RST :=LAHU03G02_RST ; **) (* assign - Stmt *) LD LAHU03G02_RST ST DAHU03G02_IN.RST (** DAHU03G02_IN.RSTV :=LAHU03G02_RSTV ; **) (* assign - Stmt *) LD LAHU03G02_RSTV ST DAHU03G02_IN.RSTV (** DAHU03G02_IN.FPS :=LAHU03G02_FPS ; **) (* assign - Stmt *) LD LAHU03G02_FPS ST DAHU03G02_IN.FPS (** DAHU03G02_IN.ISO1 :=LAHU03G02_ISO1 ; **) (* assign - Stmt *) LD LAHU03G02_ISO1 ST DAHU03G02_IN.ISO1 (** DAHU03G02_IN.ISO2 :=LAHU03G02_ISO2 ; **) (* assign - Stmt *) LD LAHU03G02_ISO2 ST DAHU03G02_IN.ISO2 (** DAHU03G02_IN.VP :=LAHU03G02_VP ; **) (* assign - Stmt *) LD LAHU03G02_VP ST DAHU03G02_IN.VP (** DAHU03G02_IN.VI :=LAHU03G02_VI ; **) (* assign - Stmt *) LD LAHU03G02_VI ST DAHU03G02_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU03G02_WVCS :=DAHU03G02_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU03G02_OUT.WVCS ST LAHU03G02_WVCS (** LAHU03G02_C :=DAHU03G02_OUT.ContRol; **) (* assign - Stmt *) LD DAHU03G02_OUT.ContRol ST LAHU03G02_C (** LAHU03G02_RH :=DAHU03G02_OUT.RH ; **) (* assign - Stmt *) LD DAHU03G02_OUT.RH ST LAHU03G02_RH (** LAHU03G02_SN :=DAHU03G02_OUT.SN ; **) (* assign - Stmt *) LD DAHU03G02_OUT.SN ST LAHU03G02_SN (** {*同步程序*} **) (** AHU03G02_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU03G02_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU03X00_PC ,BOOL_IN1:=LAHU03G02_PC ,BOOL_IN2 :=RAHU03G02_PC , **) BOOL_IN0 := RNIAHU03X00_PC, BOOL_IN1 := LAHU03G02_PC, BOOL_IN2 := RAHU03G02_PC, (** REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03G02_TSET,REAL_IN2 :=RAHU03G02_TSET, **) REAL_IN0 := RNIAHU03X00_TSET, REAL_IN1 := LAHU03G02_TSET, REAL_IN2 := RAHU03G02_TSET, (** INT_IN0 :=RNIAHU03X00_SM ,INT_IN1 :=LAHU03G02_SM ,INT_IN2 :=RAHU03G02_SM | **) INT_IN0 := RNIAHU03X00_SM, INT_IN1 := LAHU03G02_SM, INT_IN2 := RAHU03G02_SM | (** LAHU03G02_PC :=BOOL_OUT1 ,RAHU03G02_PC :=BOOL_OUT2 , **) LAHU03G02_PC := BOOL_OUT1, RAHU03G02_PC := BOOL_OUT2, (** LAHU03G02_TSET:=REAL_OUT1 ,RAHU03G02_TSET:=REAL_OUT2 , **) LAHU03G02_TSET := REAL_OUT1, RAHU03G02_TSET := REAL_OUT2, (** LAHU03G02_SM :=INT_OUT1 ,RAHU03G02_SM :=INT_OUT2) ; **) LAHU03G02_SM := INT_OUT1, RAHU03G02_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU03G03********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU03G03_WVB_AVE(INPUT:=LAHU03G03_WVB); **) (* call - Stmt *) CAL AHU03G03_WVB_AVE ( INPUT := LAHU03G03_WVB ) (** AHU03G03_RT_AVE (INPUT:=LAHU03G03_RT) ; **) (* call - Stmt *) CAL AHU03G03_RT_AVE ( INPUT := LAHU03G03_RT ) (** LAHU03G03_RTS := BS_Scale(AHU03G03_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G03_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU03G03_RTS (** LAHU03G03_WVBS:= BS_Scale(AHU03G03_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G03_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU03G03_WVBS (** LAHU03G03_WVC :=REAL_TO_INT(BS_Scale(LAHU03G03_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU03G03_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU03G03_WVC (** {*主程序*} **) (** AHU03G03_DAHU(DAHU_STRUCT_IN:=DAHU03G03_IN | DAHU03G03_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU03G03_DAHU ( DAHU_STRUCT_IN := DAHU03G03_IN | DAHU03G03_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU03G03_IN.SM :=LAHU03G03_SM ; **) (* assign - Stmt *) LD LAHU03G03_SM ST DAHU03G03_IN.SM (** DAHU03G03_IN.Run :=LAHU03G03_R ; **) (* assign - Stmt *) LD LAHU03G03_R ST DAHU03G03_IN.Run (** DAHU03G03_IN.Fault :=LAHU03G03_F ; **) (* assign - Stmt *) LD LAHU03G03_F ST DAHU03G03_IN.Fault (** DAHU03G03_IN.Auto :=LAHU03G03_A ; **) (* assign - Stmt *) LD LAHU03G03_A ST DAHU03G03_IN.Auto (** DAHU03G03_IN.ContRol:=LAHU03G03_PC ; **) (* assign - Stmt *) LD LAHU03G03_PC ST DAHU03G03_IN.ContRol (** DAHU03G03_IN.TSET :=LAHU03G03_TSET ; **) (* assign - Stmt *) LD LAHU03G03_TSET ST DAHU03G03_IN.TSET (** DAHU03G03_IN.WVMC :=LAHU03G03_WVMC ; **) (* assign - Stmt *) LD LAHU03G03_WVMC ST DAHU03G03_IN.WVMC (** DAHU03G03_IN.WVMV :=LAHU03G03_WVMV ; **) (* assign - Stmt *) LD LAHU03G03_WVMV ST DAHU03G03_IN.WVMV (** DAHU03G03_IN.RTS :=LAHU03G03_RTS ; **) (* assign - Stmt *) LD LAHU03G03_RTS ST DAHU03G03_IN.RTS (** DAHU03G03_IN.RST :=LAHU03G03_RST ; **) (* assign - Stmt *) LD LAHU03G03_RST ST DAHU03G03_IN.RST (** DAHU03G03_IN.RSTV :=LAHU03G03_RSTV ; **) (* assign - Stmt *) LD LAHU03G03_RSTV ST DAHU03G03_IN.RSTV (** DAHU03G03_IN.FPS :=LAHU03G03_FPS ; **) (* assign - Stmt *) LD LAHU03G03_FPS ST DAHU03G03_IN.FPS (** DAHU03G03_IN.ISO1 :=LAHU03G03_ISO1 ; **) (* assign - Stmt *) LD LAHU03G03_ISO1 ST DAHU03G03_IN.ISO1 (** DAHU03G03_IN.ISO2 :=LAHU03G03_ISO2 ; **) (* assign - Stmt *) LD LAHU03G03_ISO2 ST DAHU03G03_IN.ISO2 (** DAHU03G03_IN.VP :=LAHU03G03_VP ; **) (* assign - Stmt *) LD LAHU03G03_VP ST DAHU03G03_IN.VP (** DAHU03G03_IN.VI :=LAHU03G03_VI ; **) (* assign - Stmt *) LD LAHU03G03_VI ST DAHU03G03_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU03G03_WVCS :=DAHU03G03_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU03G03_OUT.WVCS ST LAHU03G03_WVCS (** LAHU03G03_C :=DAHU03G03_OUT.ContRol; **) (* assign - Stmt *) LD DAHU03G03_OUT.ContRol ST LAHU03G03_C (** LAHU03G03_RH :=DAHU03G03_OUT.RH ; **) (* assign - Stmt *) LD DAHU03G03_OUT.RH ST LAHU03G03_RH (** LAHU03G03_SN :=DAHU03G03_OUT.SN ; **) (* assign - Stmt *) LD DAHU03G03_OUT.SN ST LAHU03G03_SN (** {*同步程序*} **) (** AHU03G03_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU03G03_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU03X00_PC ,BOOL_IN1:=LAHU03G03_PC ,BOOL_IN2 :=RAHU03G03_PC , **) BOOL_IN0 := RNIAHU03X00_PC, BOOL_IN1 := LAHU03G03_PC, BOOL_IN2 := RAHU03G03_PC, (** REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03G03_TSET,REAL_IN2 :=RAHU03G03_TSET, **) REAL_IN0 := RNIAHU03X00_TSET, REAL_IN1 := LAHU03G03_TSET, REAL_IN2 := RAHU03G03_TSET, (** INT_IN0 :=RNIAHU03X00_SM ,INT_IN1 :=LAHU03G03_SM ,INT_IN2 :=RAHU03G03_SM | **) INT_IN0 := RNIAHU03X00_SM, INT_IN1 := LAHU03G03_SM, INT_IN2 := RAHU03G03_SM | (** LAHU03G03_PC :=BOOL_OUT1 ,RAHU03G03_PC :=BOOL_OUT2 , **) LAHU03G03_PC := BOOL_OUT1, RAHU03G03_PC := BOOL_OUT2, (** LAHU03G03_TSET:=REAL_OUT1 ,RAHU03G03_TSET:=REAL_OUT2 , **) LAHU03G03_TSET := REAL_OUT1, RAHU03G03_TSET := REAL_OUT2, (** LAHU03G03_SM :=INT_OUT1 ,RAHU03G03_SM :=INT_OUT2) ; **) LAHU03G03_SM := INT_OUT1, RAHU03G03_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU03G04********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU03G04_WVB_AVE(INPUT:=LAHU03G04_WVB); **) (* call - Stmt *) CAL AHU03G04_WVB_AVE ( INPUT := LAHU03G04_WVB ) (** AHU03G04_RT_AVE (INPUT:=LAHU03G04_RT) ; **) (* call - Stmt *) CAL AHU03G04_RT_AVE ( INPUT := LAHU03G04_RT ) (** LAHU03G04_RTS := BS_Scale(AHU03G04_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G04_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU03G04_RTS (** LAHU03G04_WVBS:= BS_Scale(AHU03G04_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G04_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU03G04_WVBS (** LAHU03G04_WVC :=REAL_TO_INT(BS_Scale(LAHU03G04_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU03G04_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU03G04_WVC (** {*主程序*} **) (** AHU03G04_DAHU(DAHU_STRUCT_IN:=DAHU03G04_IN | DAHU03G04_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU03G04_DAHU ( DAHU_STRUCT_IN := DAHU03G04_IN | DAHU03G04_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU03G04_IN.SM :=LAHU03G04_SM ; **) (* assign - Stmt *) LD LAHU03G04_SM ST DAHU03G04_IN.SM (** DAHU03G04_IN.Run :=LAHU03G04_R ; **) (* assign - Stmt *) LD LAHU03G04_R ST DAHU03G04_IN.Run (** DAHU03G04_IN.Fault :=LAHU03G04_F ; **) (* assign - Stmt *) LD LAHU03G04_F ST DAHU03G04_IN.Fault (** DAHU03G04_IN.Auto :=LAHU03G04_A ; **) (* assign - Stmt *) LD LAHU03G04_A ST DAHU03G04_IN.Auto (** DAHU03G04_IN.ContRol:=LAHU03G04_PC ; **) (* assign - Stmt *) LD LAHU03G04_PC ST DAHU03G04_IN.ContRol (** DAHU03G04_IN.TSET :=LAHU03G04_TSET ; **) (* assign - Stmt *) LD LAHU03G04_TSET ST DAHU03G04_IN.TSET (** DAHU03G04_IN.WVMC :=LAHU03G04_WVMC ; **) (* assign - Stmt *) LD LAHU03G04_WVMC ST DAHU03G04_IN.WVMC (** DAHU03G04_IN.WVMV :=LAHU03G04_WVMV ; **) (* assign - Stmt *) LD LAHU03G04_WVMV ST DAHU03G04_IN.WVMV (** DAHU03G04_IN.RTS :=LAHU03G04_RTS ; **) (* assign - Stmt *) LD LAHU03G04_RTS ST DAHU03G04_IN.RTS (** DAHU03G04_IN.RST :=LAHU03G04_RST ; **) (* assign - Stmt *) LD LAHU03G04_RST ST DAHU03G04_IN.RST (** DAHU03G04_IN.RSTV :=LAHU03G04_RSTV ; **) (* assign - Stmt *) LD LAHU03G04_RSTV ST DAHU03G04_IN.RSTV (** DAHU03G04_IN.FPS :=LAHU03G04_FPS ; **) (* assign - Stmt *) LD LAHU03G04_FPS ST DAHU03G04_IN.FPS (** DAHU03G04_IN.ISO1 :=LAHU03G04_ISO1 ; **) (* assign - Stmt *) LD LAHU03G04_ISO1 ST DAHU03G04_IN.ISO1 (** DAHU03G04_IN.ISO2 :=LAHU03G04_ISO2 ; **) (* assign - Stmt *) LD LAHU03G04_ISO2 ST DAHU03G04_IN.ISO2 (** DAHU03G04_IN.VP :=LAHU03G04_VP ; **) (* assign - Stmt *) LD LAHU03G04_VP ST DAHU03G04_IN.VP (** DAHU03G04_IN.VI :=LAHU03G04_VI ; **) (* assign - Stmt *) LD LAHU03G04_VI ST DAHU03G04_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU03G04_WVCS :=DAHU03G04_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU03G04_OUT.WVCS ST LAHU03G04_WVCS (** LAHU03G04_C :=DAHU03G04_OUT.ContRol; **) (* assign - Stmt *) LD DAHU03G04_OUT.ContRol ST LAHU03G04_C (** LAHU03G04_RH :=DAHU03G04_OUT.RH ; **) (* assign - Stmt *) LD DAHU03G04_OUT.RH ST LAHU03G04_RH (** LAHU03G04_SN :=DAHU03G04_OUT.SN ; **) (* assign - Stmt *) LD DAHU03G04_OUT.SN ST LAHU03G04_SN (** {*同步程序*} **) (** AHU03G04_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU03G04_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU03X00_PC ,BOOL_IN1:=LAHU03G04_PC ,BOOL_IN2 :=RAHU03G04_PC , **) BOOL_IN0 := RNIAHU03X00_PC, BOOL_IN1 := LAHU03G04_PC, BOOL_IN2 := RAHU03G04_PC, (** REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03G04_TSET,REAL_IN2 :=RAHU03G04_TSET, **) REAL_IN0 := RNIAHU03X00_TSET, REAL_IN1 := LAHU03G04_TSET, REAL_IN2 := RAHU03G04_TSET, (** INT_IN0 :=RNIAHU03X00_SM ,INT_IN1 :=LAHU03G04_SM ,INT_IN2 :=RAHU03G04_SM | **) INT_IN0 := RNIAHU03X00_SM, INT_IN1 := LAHU03G04_SM, INT_IN2 := RAHU03G04_SM | (** LAHU03G04_PC :=BOOL_OUT1 ,RAHU03G04_PC :=BOOL_OUT2 , **) LAHU03G04_PC := BOOL_OUT1, RAHU03G04_PC := BOOL_OUT2, (** LAHU03G04_TSET:=REAL_OUT1 ,RAHU03G04_TSET:=REAL_OUT2 , **) LAHU03G04_TSET := REAL_OUT1, RAHU03G04_TSET := REAL_OUT2, (** LAHU03G04_SM :=INT_OUT1 ,RAHU03G04_SM :=INT_OUT2) ; **) LAHU03G04_SM := INT_OUT1, RAHU03G04_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU03G05********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU03G05_WVB_AVE(INPUT:=LAHU03G05_WVB); **) (* call - Stmt *) CAL AHU03G05_WVB_AVE ( INPUT := LAHU03G05_WVB ) (** AHU03G05_RT_AVE (INPUT:=LAHU03G05_RT) ; **) (* call - Stmt *) CAL AHU03G05_RT_AVE ( INPUT := LAHU03G05_RT ) (** LAHU03G05_RTS := BS_Scale(AHU03G05_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G05_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU03G05_RTS (** LAHU03G05_WVBS:= BS_Scale(AHU03G05_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G05_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU03G05_WVBS (** LAHU03G05_WVC :=REAL_TO_INT(BS_Scale(LAHU03G05_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU03G05_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU03G05_WVC (** {*主程序*} **) (** AHU03G05_DAHU(DAHU_STRUCT_IN:=DAHU03G05_IN | DAHU03G05_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU03G05_DAHU ( DAHU_STRUCT_IN := DAHU03G05_IN | DAHU03G05_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU03G05_IN.SM :=LAHU03G05_SM ; **) (* assign - Stmt *) LD LAHU03G05_SM ST DAHU03G05_IN.SM (** DAHU03G05_IN.Run :=LAHU03G05_R ; **) (* assign - Stmt *) LD LAHU03G05_R ST DAHU03G05_IN.Run (** DAHU03G05_IN.Fault :=LAHU03G05_F ; **) (* assign - Stmt *) LD LAHU03G05_F ST DAHU03G05_IN.Fault (** DAHU03G05_IN.Auto :=LAHU03G05_A ; **) (* assign - Stmt *) LD LAHU03G05_A ST DAHU03G05_IN.Auto (** DAHU03G05_IN.ContRol:=LAHU03G05_PC ; **) (* assign - Stmt *) LD LAHU03G05_PC ST DAHU03G05_IN.ContRol (** DAHU03G05_IN.TSET :=LAHU03G05_TSET ; **) (* assign - Stmt *) LD LAHU03G05_TSET ST DAHU03G05_IN.TSET (** DAHU03G05_IN.WVMC :=LAHU03G05_WVMC ; **) (* assign - Stmt *) LD LAHU03G05_WVMC ST DAHU03G05_IN.WVMC (** DAHU03G05_IN.WVMV :=LAHU03G05_WVMV ; **) (* assign - Stmt *) LD LAHU03G05_WVMV ST DAHU03G05_IN.WVMV (** DAHU03G05_IN.RTS :=LAHU03G05_RTS ; **) (* assign - Stmt *) LD LAHU03G05_RTS ST DAHU03G05_IN.RTS (** DAHU03G05_IN.RST :=LAHU03G05_RST ; **) (* assign - Stmt *) LD LAHU03G05_RST ST DAHU03G05_IN.RST (** DAHU03G05_IN.RSTV :=LAHU03G05_RSTV ; **) (* assign - Stmt *) LD LAHU03G05_RSTV ST DAHU03G05_IN.RSTV (** DAHU03G05_IN.FPS :=LAHU03G05_FPS ; **) (* assign - Stmt *) LD LAHU03G05_FPS ST DAHU03G05_IN.FPS (** DAHU03G05_IN.ISO1 :=LAHU03G05_ISO1 ; **) (* assign - Stmt *) LD LAHU03G05_ISO1 ST DAHU03G05_IN.ISO1 (** DAHU03G05_IN.ISO2 :=LAHU03G05_ISO2 ; **) (* assign - Stmt *) LD LAHU03G05_ISO2 ST DAHU03G05_IN.ISO2 (** DAHU03G05_IN.VP :=LAHU03G05_VP ; **) (* assign - Stmt *) LD LAHU03G05_VP ST DAHU03G05_IN.VP (** DAHU03G05_IN.VI :=LAHU03G05_VI ; **) (* assign - Stmt *) LD LAHU03G05_VI ST DAHU03G05_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU03G05_WVCS :=DAHU03G05_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU03G05_OUT.WVCS ST LAHU03G05_WVCS (** LAHU03G05_C :=DAHU03G05_OUT.ContRol; **) (* assign - Stmt *) LD DAHU03G05_OUT.ContRol ST LAHU03G05_C (** LAHU03G05_RH :=DAHU03G05_OUT.RH ; **) (* assign - Stmt *) LD DAHU03G05_OUT.RH ST LAHU03G05_RH (** LAHU03G05_SN :=DAHU03G05_OUT.SN ; **) (* assign - Stmt *) LD DAHU03G05_OUT.SN ST LAHU03G05_SN (** {*同步程序*} **) (** AHU03G05_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU03G05_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU03X00_PC ,BOOL_IN1:=LAHU03G05_PC ,BOOL_IN2 :=RAHU03G05_PC , **) BOOL_IN0 := RNIAHU03X00_PC, BOOL_IN1 := LAHU03G05_PC, BOOL_IN2 := RAHU03G05_PC, (** REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03G05_TSET,REAL_IN2 :=RAHU03G05_TSET, **) REAL_IN0 := RNIAHU03X00_TSET, REAL_IN1 := LAHU03G05_TSET, REAL_IN2 := RAHU03G05_TSET, (** INT_IN0 :=RNIAHU03X00_SM ,INT_IN1 :=LAHU03G05_SM ,INT_IN2 :=RAHU03G05_SM | **) INT_IN0 := RNIAHU03X00_SM, INT_IN1 := LAHU03G05_SM, INT_IN2 := RAHU03G05_SM | (** LAHU03G05_PC :=BOOL_OUT1 ,RAHU03G05_PC :=BOOL_OUT2 , **) LAHU03G05_PC := BOOL_OUT1, RAHU03G05_PC := BOOL_OUT2, (** LAHU03G05_TSET:=REAL_OUT1 ,RAHU03G05_TSET:=REAL_OUT2 , **) LAHU03G05_TSET := REAL_OUT1, RAHU03G05_TSET := REAL_OUT2, (** LAHU03G05_SM :=INT_OUT1 ,RAHU03G05_SM :=INT_OUT2) ; **) LAHU03G05_SM := INT_OUT1, RAHU03G05_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU03G06********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU03G06_WVB_AVE(INPUT:=LAHU03G06_WVB); **) (* call - Stmt *) CAL AHU03G06_WVB_AVE ( INPUT := LAHU03G06_WVB ) (** AHU03G06_RT_AVE (INPUT:=LAHU03G06_RT) ; **) (* call - Stmt *) CAL AHU03G06_RT_AVE ( INPUT := LAHU03G06_RT ) (** LAHU03G06_RTS := BS_Scale(AHU03G06_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G06_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU03G06_RTS (** LAHU03G06_WVBS:= BS_Scale(AHU03G06_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G06_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU03G06_WVBS (** LAHU03G06_WVC :=REAL_TO_INT(BS_Scale(LAHU03G06_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU03G06_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU03G06_WVC (** {*主程序*} **) (** AHU03G06_DAHU(DAHU_STRUCT_IN:=DAHU03G06_IN | DAHU03G06_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU03G06_DAHU ( DAHU_STRUCT_IN := DAHU03G06_IN | DAHU03G06_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU03G06_IN.SM :=LAHU03G06_SM ; **) (* assign - Stmt *) LD LAHU03G06_SM ST DAHU03G06_IN.SM (** DAHU03G06_IN.Run :=LAHU03G06_R ; **) (* assign - Stmt *) LD LAHU03G06_R ST DAHU03G06_IN.Run (** DAHU03G06_IN.Fault :=LAHU03G06_F ; **) (* assign - Stmt *) LD LAHU03G06_F ST DAHU03G06_IN.Fault (** DAHU03G06_IN.Auto :=LAHU03G06_A ; **) (* assign - Stmt *) LD LAHU03G06_A ST DAHU03G06_IN.Auto (** DAHU03G06_IN.ContRol:=LAHU03G06_PC ; **) (* assign - Stmt *) LD LAHU03G06_PC ST DAHU03G06_IN.ContRol (** DAHU03G06_IN.TSET :=LAHU03G06_TSET ; **) (* assign - Stmt *) LD LAHU03G06_TSET ST DAHU03G06_IN.TSET (** DAHU03G06_IN.WVMC :=LAHU03G06_WVMC ; **) (* assign - Stmt *) LD LAHU03G06_WVMC ST DAHU03G06_IN.WVMC (** DAHU03G06_IN.WVMV :=LAHU03G06_WVMV ; **) (* assign - Stmt *) LD LAHU03G06_WVMV ST DAHU03G06_IN.WVMV (** DAHU03G06_IN.RTS :=LAHU03G06_RTS ; **) (* assign - Stmt *) LD LAHU03G06_RTS ST DAHU03G06_IN.RTS (** DAHU03G06_IN.RST :=LAHU03G06_RST ; **) (* assign - Stmt *) LD LAHU03G06_RST ST DAHU03G06_IN.RST (** DAHU03G06_IN.RSTV :=LAHU03G06_RSTV ; **) (* assign - Stmt *) LD LAHU03G06_RSTV ST DAHU03G06_IN.RSTV (** DAHU03G06_IN.FPS :=LAHU03G06_FPS ; **) (* assign - Stmt *) LD LAHU03G06_FPS ST DAHU03G06_IN.FPS (** DAHU03G06_IN.ISO1 :=LAHU03G06_ISO1 ; **) (* assign - Stmt *) LD LAHU03G06_ISO1 ST DAHU03G06_IN.ISO1 (** DAHU03G06_IN.ISO2 :=LAHU03G06_ISO2 ; **) (* assign - Stmt *) LD LAHU03G06_ISO2 ST DAHU03G06_IN.ISO2 (** DAHU03G06_IN.VP :=LAHU03G06_VP ; **) (* assign - Stmt *) LD LAHU03G06_VP ST DAHU03G06_IN.VP (** DAHU03G06_IN.VI :=LAHU03G06_VI ; **) (* assign - Stmt *) LD LAHU03G06_VI ST DAHU03G06_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU03G06_WVCS :=DAHU03G06_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU03G06_OUT.WVCS ST LAHU03G06_WVCS (** LAHU03G06_C :=DAHU03G06_OUT.ContRol; **) (* assign - Stmt *) LD DAHU03G06_OUT.ContRol ST LAHU03G06_C (** LAHU03G06_RH :=DAHU03G06_OUT.RH ; **) (* assign - Stmt *) LD DAHU03G06_OUT.RH ST LAHU03G06_RH (** LAHU03G06_SN :=DAHU03G06_OUT.SN ; **) (* assign - Stmt *) LD DAHU03G06_OUT.SN ST LAHU03G06_SN (** {*同步程序*} **) (** AHU03G06_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU03G06_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU03X00_PC ,BOOL_IN1:=LAHU03G06_PC ,BOOL_IN2 :=RAHU03G06_PC , **) BOOL_IN0 := RNIAHU03X00_PC, BOOL_IN1 := LAHU03G06_PC, BOOL_IN2 := RAHU03G06_PC, (** REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03G06_TSET,REAL_IN2 :=RAHU03G06_TSET, **) REAL_IN0 := RNIAHU03X00_TSET, REAL_IN1 := LAHU03G06_TSET, REAL_IN2 := RAHU03G06_TSET, (** INT_IN0 :=RNIAHU03X00_SM ,INT_IN1 :=LAHU03G06_SM ,INT_IN2 :=RAHU03G06_SM | **) INT_IN0 := RNIAHU03X00_SM, INT_IN1 := LAHU03G06_SM, INT_IN2 := RAHU03G06_SM | (** LAHU03G06_PC :=BOOL_OUT1 ,RAHU03G06_PC :=BOOL_OUT2 , **) LAHU03G06_PC := BOOL_OUT1, RAHU03G06_PC := BOOL_OUT2, (** LAHU03G06_TSET:=REAL_OUT1 ,RAHU03G06_TSET:=REAL_OUT2 , **) LAHU03G06_TSET := REAL_OUT1, RAHU03G06_TSET := REAL_OUT2, (** LAHU03G06_SM :=INT_OUT1 ,RAHU03G06_SM :=INT_OUT2) ; **) LAHU03G06_SM := INT_OUT1, RAHU03G06_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU03G07********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU03G07_WVB_AVE(INPUT:=LAHU03G07_WVB); **) (* call - Stmt *) CAL AHU03G07_WVB_AVE ( INPUT := LAHU03G07_WVB ) (** AHU03G07_RT_AVE (INPUT:=LAHU03G07_RT) ; **) (* call - Stmt *) CAL AHU03G07_RT_AVE ( INPUT := LAHU03G07_RT ) (** LAHU03G07_RTS := BS_Scale(AHU03G07_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G07_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU03G07_RTS (** LAHU03G07_WVBS:= BS_Scale(AHU03G07_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G07_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU03G07_WVBS (** LAHU03G07_WVC :=REAL_TO_INT(BS_Scale(LAHU03G07_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU03G07_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU03G07_WVC (** {*主程序*} **) (** AHU03G07_DAHU(DAHU_STRUCT_IN:=DAHU03G07_IN | DAHU03G07_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU03G07_DAHU ( DAHU_STRUCT_IN := DAHU03G07_IN | DAHU03G07_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU03G07_IN.SM :=LAHU03G07_SM ; **) (* assign - Stmt *) LD LAHU03G07_SM ST DAHU03G07_IN.SM (** DAHU03G07_IN.Run :=LAHU03G07_R ; **) (* assign - Stmt *) LD LAHU03G07_R ST DAHU03G07_IN.Run (** DAHU03G07_IN.Fault :=LAHU03G07_F ; **) (* assign - Stmt *) LD LAHU03G07_F ST DAHU03G07_IN.Fault (** DAHU03G07_IN.Auto :=LAHU03G07_A ; **) (* assign - Stmt *) LD LAHU03G07_A ST DAHU03G07_IN.Auto (** DAHU03G07_IN.ContRol:=LAHU03G07_PC ; **) (* assign - Stmt *) LD LAHU03G07_PC ST DAHU03G07_IN.ContRol (** DAHU03G07_IN.TSET :=LAHU03G07_TSET ; **) (* assign - Stmt *) LD LAHU03G07_TSET ST DAHU03G07_IN.TSET (** DAHU03G07_IN.WVMC :=LAHU03G07_WVMC ; **) (* assign - Stmt *) LD LAHU03G07_WVMC ST DAHU03G07_IN.WVMC (** DAHU03G07_IN.WVMV :=LAHU03G07_WVMV ; **) (* assign - Stmt *) LD LAHU03G07_WVMV ST DAHU03G07_IN.WVMV (** DAHU03G07_IN.RTS :=LAHU03G07_RTS ; **) (* assign - Stmt *) LD LAHU03G07_RTS ST DAHU03G07_IN.RTS (** DAHU03G07_IN.RST :=LAHU03G07_RST ; **) (* assign - Stmt *) LD LAHU03G07_RST ST DAHU03G07_IN.RST (** DAHU03G07_IN.RSTV :=LAHU03G07_RSTV ; **) (* assign - Stmt *) LD LAHU03G07_RSTV ST DAHU03G07_IN.RSTV (** DAHU03G07_IN.FPS :=LAHU03G07_FPS ; **) (* assign - Stmt *) LD LAHU03G07_FPS ST DAHU03G07_IN.FPS (** DAHU03G07_IN.ISO1 :=LAHU03G07_ISO1 ; **) (* assign - Stmt *) LD LAHU03G07_ISO1 ST DAHU03G07_IN.ISO1 (** DAHU03G07_IN.ISO2 :=LAHU03G07_ISO2 ; **) (* assign - Stmt *) LD LAHU03G07_ISO2 ST DAHU03G07_IN.ISO2 (** DAHU03G07_IN.VP :=LAHU03G07_VP ; **) (* assign - Stmt *) LD LAHU03G07_VP ST DAHU03G07_IN.VP (** DAHU03G07_IN.VI :=LAHU03G07_VI ; **) (* assign - Stmt *) LD LAHU03G07_VI ST DAHU03G07_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU03G07_WVCS :=DAHU03G07_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU03G07_OUT.WVCS ST LAHU03G07_WVCS (** LAHU03G07_C :=DAHU03G07_OUT.ContRol; **) (* assign - Stmt *) LD DAHU03G07_OUT.ContRol ST LAHU03G07_C (** LAHU03G07_RH :=DAHU03G07_OUT.RH ; **) (* assign - Stmt *) LD DAHU03G07_OUT.RH ST LAHU03G07_RH (** LAHU03G07_SN :=DAHU03G07_OUT.SN ; **) (* assign - Stmt *) LD DAHU03G07_OUT.SN ST LAHU03G07_SN (** {*同步程序*} **) (** AHU03G07_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU03G07_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU03X00_PC ,BOOL_IN1:=LAHU03G07_PC ,BOOL_IN2 :=RAHU03G07_PC , **) BOOL_IN0 := RNIAHU03X00_PC, BOOL_IN1 := LAHU03G07_PC, BOOL_IN2 := RAHU03G07_PC, (** REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03G07_TSET,REAL_IN2 :=RAHU03G07_TSET, **) REAL_IN0 := RNIAHU03X00_TSET, REAL_IN1 := LAHU03G07_TSET, REAL_IN2 := RAHU03G07_TSET, (** INT_IN0 :=RNIAHU03X00_SM ,INT_IN1 :=LAHU03G07_SM ,INT_IN2 :=RAHU03G07_SM | **) INT_IN0 := RNIAHU03X00_SM, INT_IN1 := LAHU03G07_SM, INT_IN2 := RAHU03G07_SM | (** LAHU03G07_PC :=BOOL_OUT1 ,RAHU03G07_PC :=BOOL_OUT2 , **) LAHU03G07_PC := BOOL_OUT1, RAHU03G07_PC := BOOL_OUT2, (** LAHU03G07_TSET:=REAL_OUT1 ,RAHU03G07_TSET:=REAL_OUT2 , **) LAHU03G07_TSET := REAL_OUT1, RAHU03G07_TSET := REAL_OUT2, (** LAHU03G07_SM :=INT_OUT1 ,RAHU03G07_SM :=INT_OUT2) ; **) LAHU03G07_SM := INT_OUT1, RAHU03G07_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU03G08********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU03G08_WVB_AVE(INPUT:=LAHU03G08_WVB); **) (* call - Stmt *) CAL AHU03G08_WVB_AVE ( INPUT := LAHU03G08_WVB ) (** AHU03G08_RT_AVE (INPUT:=LAHU03G08_RT) ; **) (* call - Stmt *) CAL AHU03G08_RT_AVE ( INPUT := LAHU03G08_RT ) (** LAHU03G08_RTS := BS_Scale(AHU03G08_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G08_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU03G08_RTS (** LAHU03G08_WVBS:= BS_Scale(AHU03G08_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G08_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU03G08_WVBS (** LAHU03G08_WVC :=REAL_TO_INT(BS_Scale(LAHU03G08_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU03G08_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU03G08_WVC (** {*主程序*} **) (** AHU03G08_DAHU(DAHU_STRUCT_IN:=DAHU03G08_IN | DAHU03G08_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU03G08_DAHU ( DAHU_STRUCT_IN := DAHU03G08_IN | DAHU03G08_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU03G08_IN.SM :=LAHU03G08_SM ; **) (* assign - Stmt *) LD LAHU03G08_SM ST DAHU03G08_IN.SM (** DAHU03G08_IN.Run :=LAHU03G08_R ; **) (* assign - Stmt *) LD LAHU03G08_R ST DAHU03G08_IN.Run (** DAHU03G08_IN.Fault :=LAHU03G08_F ; **) (* assign - Stmt *) LD LAHU03G08_F ST DAHU03G08_IN.Fault (** DAHU03G08_IN.Auto :=LAHU03G08_A ; **) (* assign - Stmt *) LD LAHU03G08_A ST DAHU03G08_IN.Auto (** DAHU03G08_IN.ContRol:=LAHU03G08_PC ; **) (* assign - Stmt *) LD LAHU03G08_PC ST DAHU03G08_IN.ContRol (** DAHU03G08_IN.TSET :=LAHU03G08_TSET ; **) (* assign - Stmt *) LD LAHU03G08_TSET ST DAHU03G08_IN.TSET (** DAHU03G08_IN.WVMC :=LAHU03G08_WVMC ; **) (* assign - Stmt *) LD LAHU03G08_WVMC ST DAHU03G08_IN.WVMC (** DAHU03G08_IN.WVMV :=LAHU03G08_WVMV ; **) (* assign - Stmt *) LD LAHU03G08_WVMV ST DAHU03G08_IN.WVMV (** DAHU03G08_IN.RTS :=LAHU03G08_RTS ; **) (* assign - Stmt *) LD LAHU03G08_RTS ST DAHU03G08_IN.RTS (** DAHU03G08_IN.RST :=LAHU03G08_RST ; **) (* assign - Stmt *) LD LAHU03G08_RST ST DAHU03G08_IN.RST (** DAHU03G08_IN.RSTV :=LAHU03G08_RSTV ; **) (* assign - Stmt *) LD LAHU03G08_RSTV ST DAHU03G08_IN.RSTV (** DAHU03G08_IN.FPS :=LAHU03G08_FPS ; **) (* assign - Stmt *) LD LAHU03G08_FPS ST DAHU03G08_IN.FPS (** DAHU03G08_IN.ISO1 :=LAHU03G08_ISO1 ; **) (* assign - Stmt *) LD LAHU03G08_ISO1 ST DAHU03G08_IN.ISO1 (** DAHU03G08_IN.ISO2 :=LAHU03G08_ISO2 ; **) (* assign - Stmt *) LD LAHU03G08_ISO2 ST DAHU03G08_IN.ISO2 (** DAHU03G08_IN.VP :=LAHU03G08_VP ; **) (* assign - Stmt *) LD LAHU03G08_VP ST DAHU03G08_IN.VP (** DAHU03G08_IN.VI :=LAHU03G08_VI ; **) (* assign - Stmt *) LD LAHU03G08_VI ST DAHU03G08_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU03G08_WVCS :=DAHU03G08_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU03G08_OUT.WVCS ST LAHU03G08_WVCS (** LAHU03G08_C :=DAHU03G08_OUT.ContRol; **) (* assign - Stmt *) LD DAHU03G08_OUT.ContRol ST LAHU03G08_C (** LAHU03G08_RH :=DAHU03G08_OUT.RH ; **) (* assign - Stmt *) LD DAHU03G08_OUT.RH ST LAHU03G08_RH (** LAHU03G08_SN :=DAHU03G08_OUT.SN ; **) (* assign - Stmt *) LD DAHU03G08_OUT.SN ST LAHU03G08_SN (** {*同步程序*} **) (** AHU03G08_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU03G08_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU03X00_PC ,BOOL_IN1:=LAHU03G08_PC ,BOOL_IN2 :=RAHU03G08_PC , **) BOOL_IN0 := RNIAHU03X00_PC, BOOL_IN1 := LAHU03G08_PC, BOOL_IN2 := RAHU03G08_PC, (** REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03G08_TSET,REAL_IN2 :=RAHU03G08_TSET, **) REAL_IN0 := RNIAHU03X00_TSET, REAL_IN1 := LAHU03G08_TSET, REAL_IN2 := RAHU03G08_TSET, (** INT_IN0 :=RNIAHU03X00_SM ,INT_IN1 :=LAHU03G08_SM ,INT_IN2 :=RAHU03G08_SM | **) INT_IN0 := RNIAHU03X00_SM, INT_IN1 := LAHU03G08_SM, INT_IN2 := RAHU03G08_SM | (** LAHU03G08_PC :=BOOL_OUT1 ,RAHU03G08_PC :=BOOL_OUT2 , **) LAHU03G08_PC := BOOL_OUT1, RAHU03G08_PC := BOOL_OUT2, (** LAHU03G08_TSET:=REAL_OUT1 ,RAHU03G08_TSET:=REAL_OUT2 , **) LAHU03G08_TSET := REAL_OUT1, RAHU03G08_TSET := REAL_OUT2, (** LAHU03G08_SM :=INT_OUT1 ,RAHU03G08_SM :=INT_OUT2) ; **) LAHU03G08_SM := INT_OUT1, RAHU03G08_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU03G09********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU03G09_WVB_AVE(INPUT:=LAHU03G09_WVB); **) (* call - Stmt *) CAL AHU03G09_WVB_AVE ( INPUT := LAHU03G09_WVB ) (** AHU03G09_RT_AVE (INPUT:=LAHU03G09_RT) ; **) (* call - Stmt *) CAL AHU03G09_RT_AVE ( INPUT := LAHU03G09_RT ) (** LAHU03G09_RTS := BS_Scale(AHU03G09_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G09_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU03G09_RTS (** LAHU03G09_WVBS:= BS_Scale(AHU03G09_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G09_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU03G09_WVBS (** LAHU03G09_WVC :=REAL_TO_INT(BS_Scale(LAHU03G09_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU03G09_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU03G09_WVC (** {*主程序*} **) (** AHU03G09_DAHU(DAHU_STRUCT_IN:=DAHU03G09_IN | DAHU03G09_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU03G09_DAHU ( DAHU_STRUCT_IN := DAHU03G09_IN | DAHU03G09_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU03G09_IN.SM :=LAHU03G09_SM ; **) (* assign - Stmt *) LD LAHU03G09_SM ST DAHU03G09_IN.SM (** DAHU03G09_IN.Run :=LAHU03G09_R ; **) (* assign - Stmt *) LD LAHU03G09_R ST DAHU03G09_IN.Run (** DAHU03G09_IN.Fault :=LAHU03G09_F ; **) (* assign - Stmt *) LD LAHU03G09_F ST DAHU03G09_IN.Fault (** DAHU03G09_IN.Auto :=LAHU03G09_A ; **) (* assign - Stmt *) LD LAHU03G09_A ST DAHU03G09_IN.Auto (** DAHU03G09_IN.ContRol:=LAHU03G09_PC ; **) (* assign - Stmt *) LD LAHU03G09_PC ST DAHU03G09_IN.ContRol (** DAHU03G09_IN.TSET :=LAHU03G09_TSET ; **) (* assign - Stmt *) LD LAHU03G09_TSET ST DAHU03G09_IN.TSET (** DAHU03G09_IN.WVMC :=LAHU03G09_WVMC ; **) (* assign - Stmt *) LD LAHU03G09_WVMC ST DAHU03G09_IN.WVMC (** DAHU03G09_IN.WVMV :=LAHU03G09_WVMV ; **) (* assign - Stmt *) LD LAHU03G09_WVMV ST DAHU03G09_IN.WVMV (** DAHU03G09_IN.RTS :=LAHU03G09_RTS ; **) (* assign - Stmt *) LD LAHU03G09_RTS ST DAHU03G09_IN.RTS (** DAHU03G09_IN.RST :=LAHU03G09_RST ; **) (* assign - Stmt *) LD LAHU03G09_RST ST DAHU03G09_IN.RST (** DAHU03G09_IN.RSTV :=LAHU03G09_RSTV ; **) (* assign - Stmt *) LD LAHU03G09_RSTV ST DAHU03G09_IN.RSTV (** DAHU03G09_IN.FPS :=LAHU03G09_FPS ; **) (* assign - Stmt *) LD LAHU03G09_FPS ST DAHU03G09_IN.FPS (** DAHU03G09_IN.ISO1 :=LAHU03G09_ISO1 ; **) (* assign - Stmt *) LD LAHU03G09_ISO1 ST DAHU03G09_IN.ISO1 (** DAHU03G09_IN.ISO2 :=LAHU03G09_ISO2 ; **) (* assign - Stmt *) LD LAHU03G09_ISO2 ST DAHU03G09_IN.ISO2 (** DAHU03G09_IN.VP :=LAHU03G09_VP ; **) (* assign - Stmt *) LD LAHU03G09_VP ST DAHU03G09_IN.VP (** DAHU03G09_IN.VI :=LAHU03G09_VI ; **) (* assign - Stmt *) LD LAHU03G09_VI ST DAHU03G09_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU03G09_WVCS :=DAHU03G09_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU03G09_OUT.WVCS ST LAHU03G09_WVCS (** LAHU03G09_C :=DAHU03G09_OUT.ContRol; **) (* assign - Stmt *) LD DAHU03G09_OUT.ContRol ST LAHU03G09_C (** LAHU03G09_RH :=DAHU03G09_OUT.RH ; **) (* assign - Stmt *) LD DAHU03G09_OUT.RH ST LAHU03G09_RH (** LAHU03G09_SN :=DAHU03G09_OUT.SN ; **) (* assign - Stmt *) LD DAHU03G09_OUT.SN ST LAHU03G09_SN (** {*同步程序*} **) (** AHU03G09_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU03G09_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU03X00_PC ,BOOL_IN1:=LAHU03G09_PC ,BOOL_IN2 :=RAHU03G09_PC , **) BOOL_IN0 := RNIAHU03X00_PC, BOOL_IN1 := LAHU03G09_PC, BOOL_IN2 := RAHU03G09_PC, (** REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03G09_TSET,REAL_IN2 :=RAHU03G09_TSET, **) REAL_IN0 := RNIAHU03X00_TSET, REAL_IN1 := LAHU03G09_TSET, REAL_IN2 := RAHU03G09_TSET, (** INT_IN0 :=RNIAHU03X00_SM ,INT_IN1 :=LAHU03G09_SM ,INT_IN2 :=RAHU03G09_SM | **) INT_IN0 := RNIAHU03X00_SM, INT_IN1 := LAHU03G09_SM, INT_IN2 := RAHU03G09_SM | (** LAHU03G09_PC :=BOOL_OUT1 ,RAHU03G09_PC :=BOOL_OUT2 , **) LAHU03G09_PC := BOOL_OUT1, RAHU03G09_PC := BOOL_OUT2, (** LAHU03G09_TSET:=REAL_OUT1 ,RAHU03G09_TSET:=REAL_OUT2 , **) LAHU03G09_TSET := REAL_OUT1, RAHU03G09_TSET := REAL_OUT2, (** LAHU03G09_SM :=INT_OUT1 ,RAHU03G09_SM :=INT_OUT2) ; **) LAHU03G09_SM := INT_OUT1, RAHU03G09_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU03G10********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU03G10_WVB_AVE(INPUT:=LAHU03G10_WVB); **) (* call - Stmt *) CAL AHU03G10_WVB_AVE ( INPUT := LAHU03G10_WVB ) (** AHU03G10_RT_AVE (INPUT:=LAHU03G10_RT) ; **) (* call - Stmt *) CAL AHU03G10_RT_AVE ( INPUT := LAHU03G10_RT ) (** LAHU03G10_RTS := BS_Scale(AHU03G10_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G10_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU03G10_RTS (** LAHU03G10_WVBS:= BS_Scale(AHU03G10_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G10_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU03G10_WVBS (** LAHU03G10_WVC :=REAL_TO_INT(BS_Scale(LAHU03G10_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU03G10_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU03G10_WVC (** {*主程序*} **) (** AHU03G10_DAHU(DAHU_STRUCT_IN:=DAHU03G10_IN | DAHU03G10_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU03G10_DAHU ( DAHU_STRUCT_IN := DAHU03G10_IN | DAHU03G10_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU03G10_IN.SM :=LAHU03G10_SM ; **) (* assign - Stmt *) LD LAHU03G10_SM ST DAHU03G10_IN.SM (** DAHU03G10_IN.Run :=LAHU03G10_R ; **) (* assign - Stmt *) LD LAHU03G10_R ST DAHU03G10_IN.Run (** DAHU03G10_IN.Fault :=LAHU03G10_F ; **) (* assign - Stmt *) LD LAHU03G10_F ST DAHU03G10_IN.Fault (** DAHU03G10_IN.Auto :=LAHU03G10_A ; **) (* assign - Stmt *) LD LAHU03G10_A ST DAHU03G10_IN.Auto (** DAHU03G10_IN.ContRol:=LAHU03G10_PC ; **) (* assign - Stmt *) LD LAHU03G10_PC ST DAHU03G10_IN.ContRol (** DAHU03G10_IN.TSET :=LAHU03G10_TSET ; **) (* assign - Stmt *) LD LAHU03G10_TSET ST DAHU03G10_IN.TSET (** DAHU03G10_IN.WVMC :=LAHU03G10_WVMC ; **) (* assign - Stmt *) LD LAHU03G10_WVMC ST DAHU03G10_IN.WVMC (** DAHU03G10_IN.WVMV :=LAHU03G10_WVMV ; **) (* assign - Stmt *) LD LAHU03G10_WVMV ST DAHU03G10_IN.WVMV (** DAHU03G10_IN.RTS :=LAHU03G10_RTS ; **) (* assign - Stmt *) LD LAHU03G10_RTS ST DAHU03G10_IN.RTS (** DAHU03G10_IN.RST :=LAHU03G10_RST ; **) (* assign - Stmt *) LD LAHU03G10_RST ST DAHU03G10_IN.RST (** DAHU03G10_IN.RSTV :=LAHU03G10_RSTV ; **) (* assign - Stmt *) LD LAHU03G10_RSTV ST DAHU03G10_IN.RSTV (** DAHU03G10_IN.FPS :=LAHU03G10_FPS ; **) (* assign - Stmt *) LD LAHU03G10_FPS ST DAHU03G10_IN.FPS (** DAHU03G10_IN.ISO1 :=LAHU03G10_ISO1 ; **) (* assign - Stmt *) LD LAHU03G10_ISO1 ST DAHU03G10_IN.ISO1 (** DAHU03G10_IN.ISO2 :=LAHU03G10_ISO2 ; **) (* assign - Stmt *) LD LAHU03G10_ISO2 ST DAHU03G10_IN.ISO2 (** DAHU03G10_IN.VP :=LAHU03G10_VP ; **) (* assign - Stmt *) LD LAHU03G10_VP ST DAHU03G10_IN.VP (** DAHU03G10_IN.VI :=LAHU03G10_VI ; **) (* assign - Stmt *) LD LAHU03G10_VI ST DAHU03G10_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU03G10_WVCS :=DAHU03G10_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU03G10_OUT.WVCS ST LAHU03G10_WVCS (** LAHU03G10_C :=DAHU03G10_OUT.ContRol; **) (* assign - Stmt *) LD DAHU03G10_OUT.ContRol ST LAHU03G10_C (** LAHU03G10_RH :=DAHU03G10_OUT.RH ; **) (* assign - Stmt *) LD DAHU03G10_OUT.RH ST LAHU03G10_RH (** LAHU03G10_SN :=DAHU03G10_OUT.SN ; **) (* assign - Stmt *) LD DAHU03G10_OUT.SN ST LAHU03G10_SN (** {*同步程序*} **) (** AHU03G10_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU03G10_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU03X00_PC ,BOOL_IN1:=LAHU03G10_PC ,BOOL_IN2 :=RAHU03G10_PC , **) BOOL_IN0 := RNIAHU03X00_PC, BOOL_IN1 := LAHU03G10_PC, BOOL_IN2 := RAHU03G10_PC, (** REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03G10_TSET,REAL_IN2 :=RAHU03G10_TSET, **) REAL_IN0 := RNIAHU03X00_TSET, REAL_IN1 := LAHU03G10_TSET, REAL_IN2 := RAHU03G10_TSET, (** INT_IN0 :=RNIAHU03X00_SM ,INT_IN1 :=LAHU03G10_SM ,INT_IN2 :=RAHU03G10_SM | **) INT_IN0 := RNIAHU03X00_SM, INT_IN1 := LAHU03G10_SM, INT_IN2 := RAHU03G10_SM | (** LAHU03G10_PC :=BOOL_OUT1 ,RAHU03G10_PC :=BOOL_OUT2 , **) LAHU03G10_PC := BOOL_OUT1, RAHU03G10_PC := BOOL_OUT2, (** LAHU03G10_TSET:=REAL_OUT1 ,RAHU03G10_TSET:=REAL_OUT2 , **) LAHU03G10_TSET := REAL_OUT1, RAHU03G10_TSET := REAL_OUT2, (** LAHU03G10_SM :=INT_OUT1 ,RAHU03G10_SM :=INT_OUT2) ; **) LAHU03G10_SM := INT_OUT1, RAHU03G10_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU03G11********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU03G11_WVB_AVE(INPUT:=LAHU03G11_WVB); **) (* call - Stmt *) CAL AHU03G11_WVB_AVE ( INPUT := LAHU03G11_WVB ) (** AHU03G11_RT_AVE (INPUT:=LAHU03G11_RT) ; **) (* call - Stmt *) CAL AHU03G11_RT_AVE ( INPUT := LAHU03G11_RT ) (** LAHU03G11_RTS := BS_Scale(AHU03G11_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G11_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU03G11_RTS (** LAHU03G11_WVBS:= BS_Scale(AHU03G11_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G11_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU03G11_WVBS (** LAHU03G11_WVC :=REAL_TO_INT(BS_Scale(LAHU03G11_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU03G11_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU03G11_WVC (** {*主程序*} **) (** AHU03G11_DAHU(DAHU_STRUCT_IN:=DAHU03G11_IN | DAHU03G11_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU03G11_DAHU ( DAHU_STRUCT_IN := DAHU03G11_IN | DAHU03G11_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU03G11_IN.SM :=LAHU03G11_SM ; **) (* assign - Stmt *) LD LAHU03G11_SM ST DAHU03G11_IN.SM (** DAHU03G11_IN.Run :=LAHU03G11_R ; **) (* assign - Stmt *) LD LAHU03G11_R ST DAHU03G11_IN.Run (** DAHU03G11_IN.Fault :=LAHU03G11_F ; **) (* assign - Stmt *) LD LAHU03G11_F ST DAHU03G11_IN.Fault (** DAHU03G11_IN.Auto :=LAHU03G11_A ; **) (* assign - Stmt *) LD LAHU03G11_A ST DAHU03G11_IN.Auto (** DAHU03G11_IN.ContRol:=LAHU03G11_PC ; **) (* assign - Stmt *) LD LAHU03G11_PC ST DAHU03G11_IN.ContRol (** DAHU03G11_IN.TSET :=LAHU03G11_TSET ; **) (* assign - Stmt *) LD LAHU03G11_TSET ST DAHU03G11_IN.TSET (** DAHU03G11_IN.WVMC :=LAHU03G11_WVMC ; **) (* assign - Stmt *) LD LAHU03G11_WVMC ST DAHU03G11_IN.WVMC (** DAHU03G11_IN.WVMV :=LAHU03G11_WVMV ; **) (* assign - Stmt *) LD LAHU03G11_WVMV ST DAHU03G11_IN.WVMV (** DAHU03G11_IN.RTS :=LAHU03G11_RTS ; **) (* assign - Stmt *) LD LAHU03G11_RTS ST DAHU03G11_IN.RTS (** DAHU03G11_IN.RST :=LAHU03G11_RST ; **) (* assign - Stmt *) LD LAHU03G11_RST ST DAHU03G11_IN.RST (** DAHU03G11_IN.RSTV :=LAHU03G11_RSTV ; **) (* assign - Stmt *) LD LAHU03G11_RSTV ST DAHU03G11_IN.RSTV (** DAHU03G11_IN.FPS :=LAHU03G11_FPS ; **) (* assign - Stmt *) LD LAHU03G11_FPS ST DAHU03G11_IN.FPS (** DAHU03G11_IN.ISO1 :=LAHU03G11_ISO1 ; **) (* assign - Stmt *) LD LAHU03G11_ISO1 ST DAHU03G11_IN.ISO1 (** DAHU03G11_IN.ISO2 :=LAHU03G11_ISO2 ; **) (* assign - Stmt *) LD LAHU03G11_ISO2 ST DAHU03G11_IN.ISO2 (** DAHU03G11_IN.VP :=LAHU03G11_VP ; **) (* assign - Stmt *) LD LAHU03G11_VP ST DAHU03G11_IN.VP (** DAHU03G11_IN.VI :=LAHU03G11_VI ; **) (* assign - Stmt *) LD LAHU03G11_VI ST DAHU03G11_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU03G11_WVCS :=DAHU03G11_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU03G11_OUT.WVCS ST LAHU03G11_WVCS (** LAHU03G11_C :=DAHU03G11_OUT.ContRol; **) (* assign - Stmt *) LD DAHU03G11_OUT.ContRol ST LAHU03G11_C (** LAHU03G11_RH :=DAHU03G11_OUT.RH ; **) (* assign - Stmt *) LD DAHU03G11_OUT.RH ST LAHU03G11_RH (** LAHU03G11_SN :=DAHU03G11_OUT.SN ; **) (* assign - Stmt *) LD DAHU03G11_OUT.SN ST LAHU03G11_SN (** {*同步程序*} **) (** AHU03G11_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU03G11_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU03X00_PC ,BOOL_IN1:=LAHU03G11_PC ,BOOL_IN2 :=RAHU03G11_PC , **) BOOL_IN0 := RNIAHU03X00_PC, BOOL_IN1 := LAHU03G11_PC, BOOL_IN2 := RAHU03G11_PC, (** REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03G11_TSET,REAL_IN2 :=RAHU03G11_TSET, **) REAL_IN0 := RNIAHU03X00_TSET, REAL_IN1 := LAHU03G11_TSET, REAL_IN2 := RAHU03G11_TSET, (** INT_IN0 :=RNIAHU03X00_SM ,INT_IN1 :=LAHU03G11_SM ,INT_IN2 :=RAHU03G11_SM | **) INT_IN0 := RNIAHU03X00_SM, INT_IN1 := LAHU03G11_SM, INT_IN2 := RAHU03G11_SM | (** LAHU03G11_PC :=BOOL_OUT1 ,RAHU03G11_PC :=BOOL_OUT2 , **) LAHU03G11_PC := BOOL_OUT1, RAHU03G11_PC := BOOL_OUT2, (** LAHU03G11_TSET:=REAL_OUT1 ,RAHU03G11_TSET:=REAL_OUT2 , **) LAHU03G11_TSET := REAL_OUT1, RAHU03G11_TSET := REAL_OUT2, (** LAHU03G11_SM :=INT_OUT1 ,RAHU03G11_SM :=INT_OUT2) ; **) LAHU03G11_SM := INT_OUT1, RAHU03G11_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU03G12********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU03G12_WVB_AVE(INPUT:=LAHU03G12_WVB); **) (* call - Stmt *) CAL AHU03G12_WVB_AVE ( INPUT := LAHU03G12_WVB ) (** AHU03G12_RT_AVE (INPUT:=LAHU03G12_RT) ; **) (* call - Stmt *) CAL AHU03G12_RT_AVE ( INPUT := LAHU03G12_RT ) (** LAHU03G12_RTS := BS_Scale(AHU03G12_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G12_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU03G12_RTS (** LAHU03G12_WVBS:= BS_Scale(AHU03G12_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU03G12_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU03G12_WVBS (** LAHU03G12_WVC :=REAL_TO_INT(BS_Scale(LAHU03G12_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU03G12_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU03G12_WVC (** {*主程序*} **) (** AHU03G12_DAHU(DAHU_STRUCT_IN:=DAHU03G12_IN | DAHU03G12_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU03G12_DAHU ( DAHU_STRUCT_IN := DAHU03G12_IN | DAHU03G12_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU03G12_IN.SM :=LAHU03G12_SM ; **) (* assign - Stmt *) LD LAHU03G12_SM ST DAHU03G12_IN.SM (** DAHU03G12_IN.Run :=LAHU03G12_R ; **) (* assign - Stmt *) LD LAHU03G12_R ST DAHU03G12_IN.Run (** DAHU03G12_IN.Fault :=LAHU03G12_F ; **) (* assign - Stmt *) LD LAHU03G12_F ST DAHU03G12_IN.Fault (** DAHU03G12_IN.Auto :=LAHU03G12_A ; **) (* assign - Stmt *) LD LAHU03G12_A ST DAHU03G12_IN.Auto (** DAHU03G12_IN.ContRol:=LAHU03G12_PC ; **) (* assign - Stmt *) LD LAHU03G12_PC ST DAHU03G12_IN.ContRol (** DAHU03G12_IN.TSET :=LAHU03G12_TSET ; **) (* assign - Stmt *) LD LAHU03G12_TSET ST DAHU03G12_IN.TSET (** DAHU03G12_IN.WVMC :=LAHU03G12_WVMC ; **) (* assign - Stmt *) LD LAHU03G12_WVMC ST DAHU03G12_IN.WVMC (** DAHU03G12_IN.WVMV :=LAHU03G12_WVMV ; **) (* assign - Stmt *) LD LAHU03G12_WVMV ST DAHU03G12_IN.WVMV (** DAHU03G12_IN.RTS :=LAHU03G12_RTS ; **) (* assign - Stmt *) LD LAHU03G12_RTS ST DAHU03G12_IN.RTS (** DAHU03G12_IN.RST :=LAHU03G12_RST ; **) (* assign - Stmt *) LD LAHU03G12_RST ST DAHU03G12_IN.RST (** DAHU03G12_IN.RSTV :=LAHU03G12_RSTV ; **) (* assign - Stmt *) LD LAHU03G12_RSTV ST DAHU03G12_IN.RSTV (** DAHU03G12_IN.FPS :=LAHU03G12_FPS ; **) (* assign - Stmt *) LD LAHU03G12_FPS ST DAHU03G12_IN.FPS (** DAHU03G12_IN.ISO1 :=LAHU03G12_ISO1 ; **) (* assign - Stmt *) LD LAHU03G12_ISO1 ST DAHU03G12_IN.ISO1 (** DAHU03G12_IN.ISO2 :=LAHU03G12_ISO2 ; **) (* assign - Stmt *) LD LAHU03G12_ISO2 ST DAHU03G12_IN.ISO2 (** DAHU03G12_IN.VP :=LAHU03G12_VP ; **) (* assign - Stmt *) LD LAHU03G12_VP ST DAHU03G12_IN.VP (** DAHU03G12_IN.VI :=LAHU03G12_VI ; **) (* assign - Stmt *) LD LAHU03G12_VI ST DAHU03G12_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU03G12_WVCS :=DAHU03G12_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU03G12_OUT.WVCS ST LAHU03G12_WVCS (** LAHU03G12_C :=DAHU03G12_OUT.ContRol; **) (* assign - Stmt *) LD DAHU03G12_OUT.ContRol ST LAHU03G12_C (** LAHU03G12_RH :=DAHU03G12_OUT.RH ; **) (* assign - Stmt *) LD DAHU03G12_OUT.RH ST LAHU03G12_RH (** LAHU03G12_SN :=DAHU03G12_OUT.SN ; **) (* assign - Stmt *) LD DAHU03G12_OUT.SN ST LAHU03G12_SN (** {*同步程序*} **) (** AHU03G12_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU03G12_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU03X00_PC ,BOOL_IN1:=LAHU03G12_PC ,BOOL_IN2 :=RAHU03G12_PC , **) BOOL_IN0 := RNIAHU03X00_PC, BOOL_IN1 := LAHU03G12_PC, BOOL_IN2 := RAHU03G12_PC, (** REAL_IN0:=RNIAHU03X00_TSET,REAL_IN1:=LAHU03G12_TSET,REAL_IN2 :=RAHU03G12_TSET, **) REAL_IN0 := RNIAHU03X00_TSET, REAL_IN1 := LAHU03G12_TSET, REAL_IN2 := RAHU03G12_TSET, (** INT_IN0 :=RNIAHU03X00_SM ,INT_IN1 :=LAHU03G12_SM ,INT_IN2 :=RAHU03G12_SM | **) INT_IN0 := RNIAHU03X00_SM, INT_IN1 := LAHU03G12_SM, INT_IN2 := RAHU03G12_SM | (** LAHU03G12_PC :=BOOL_OUT1 ,RAHU03G12_PC :=BOOL_OUT2 , **) LAHU03G12_PC := BOOL_OUT1, RAHU03G12_PC := BOOL_OUT2, (** LAHU03G12_TSET:=REAL_OUT1 ,RAHU03G12_TSET:=REAL_OUT2 , **) LAHU03G12_TSET := REAL_OUT1, RAHU03G12_TSET := REAL_OUT2, (** LAHU03G12_SM :=INT_OUT1 ,RAHU03G12_SM :=INT_OUT2) ; **) LAHU03G12_SM := INT_OUT1, RAHU03G12_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU04G01********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU04G01_WVB_AVE(INPUT:=LAHU04G01_WVB); **) (* call - Stmt *) CAL AHU04G01_WVB_AVE ( INPUT := LAHU04G01_WVB ) (** AHU04G01_RT_AVE (INPUT:=LAHU04G01_RT) ; **) (* call - Stmt *) CAL AHU04G01_RT_AVE ( INPUT := LAHU04G01_RT ) (** LAHU04G01_RTS := BS_Scale(AHU04G01_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU04G01_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU04G01_RTS (** LAHU04G01_WVBS:= BS_Scale(AHU04G01_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU04G01_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU04G01_WVBS (** LAHU04G01_WVC :=REAL_TO_INT(BS_Scale(LAHU04G01_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU04G01_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU04G01_WVC (** {*主程序*} **) (** AHU04G01_DAHU(DAHU_STRUCT_IN:=DAHU04G01_IN | DAHU04G01_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU04G01_DAHU ( DAHU_STRUCT_IN := DAHU04G01_IN | DAHU04G01_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU04G01_IN.SM :=LAHU04G01_SM ; **) (* assign - Stmt *) LD LAHU04G01_SM ST DAHU04G01_IN.SM (** DAHU04G01_IN.Run :=LAHU04G01_R ; **) (* assign - Stmt *) LD LAHU04G01_R ST DAHU04G01_IN.Run (** DAHU04G01_IN.Fault :=LAHU04G01_F ; **) (* assign - Stmt *) LD LAHU04G01_F ST DAHU04G01_IN.Fault (** DAHU04G01_IN.Auto :=LAHU04G01_A ; **) (* assign - Stmt *) LD LAHU04G01_A ST DAHU04G01_IN.Auto (** DAHU04G01_IN.ContRol:=LAHU04G01_PC ; **) (* assign - Stmt *) LD LAHU04G01_PC ST DAHU04G01_IN.ContRol (** DAHU04G01_IN.TSET :=LAHU04G01_TSET ; **) (* assign - Stmt *) LD LAHU04G01_TSET ST DAHU04G01_IN.TSET (** DAHU04G01_IN.WVMC :=LAHU04G01_WVMC ; **) (* assign - Stmt *) LD LAHU04G01_WVMC ST DAHU04G01_IN.WVMC (** DAHU04G01_IN.WVMV :=LAHU04G01_WVMV ; **) (* assign - Stmt *) LD LAHU04G01_WVMV ST DAHU04G01_IN.WVMV (** DAHU04G01_IN.RTS :=LAHU04G01_RTS ; **) (* assign - Stmt *) LD LAHU04G01_RTS ST DAHU04G01_IN.RTS (** DAHU04G01_IN.RST :=LAHU04G01_RST ; **) (* assign - Stmt *) LD LAHU04G01_RST ST DAHU04G01_IN.RST (** DAHU04G01_IN.RSTV :=LAHU04G01_RSTV ; **) (* assign - Stmt *) LD LAHU04G01_RSTV ST DAHU04G01_IN.RSTV (** DAHU04G01_IN.FPS :=LAHU04G01_FPS ; **) (* assign - Stmt *) LD LAHU04G01_FPS ST DAHU04G01_IN.FPS (** DAHU04G01_IN.ISO1 :=LAHU04G01_ISO1 ; **) (* assign - Stmt *) LD LAHU04G01_ISO1 ST DAHU04G01_IN.ISO1 (** DAHU04G01_IN.ISO2 :=LAHU04G01_ISO2 ; **) (* assign - Stmt *) LD LAHU04G01_ISO2 ST DAHU04G01_IN.ISO2 (** DAHU04G01_IN.VP :=LAHU04G01_VP ; **) (* assign - Stmt *) LD LAHU04G01_VP ST DAHU04G01_IN.VP (** DAHU04G01_IN.VI :=LAHU04G01_VI ; **) (* assign - Stmt *) LD LAHU04G01_VI ST DAHU04G01_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU04G01_WVCS :=DAHU04G01_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU04G01_OUT.WVCS ST LAHU04G01_WVCS (** LAHU04G01_C :=DAHU04G01_OUT.ContRol; **) (* assign - Stmt *) LD DAHU04G01_OUT.ContRol ST LAHU04G01_C (** LAHU04G01_RH :=DAHU04G01_OUT.RH ; **) (* assign - Stmt *) LD DAHU04G01_OUT.RH ST LAHU04G01_RH (** LAHU04G01_SN :=DAHU04G01_OUT.SN ; **) (* assign - Stmt *) LD DAHU04G01_OUT.SN ST LAHU04G01_SN (** {*同步程序*} **) (** AHU04G01_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU04G01_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU04X00_PC ,BOOL_IN1:=LAHU04G01_PC ,BOOL_IN2 :=RAHU04G01_PC , **) BOOL_IN0 := RNIAHU04X00_PC, BOOL_IN1 := LAHU04G01_PC, BOOL_IN2 := RAHU04G01_PC, (** REAL_IN0:=RNIAHU04X00_TSET,REAL_IN1:=LAHU04G01_TSET,REAL_IN2 :=RAHU04G01_TSET, **) REAL_IN0 := RNIAHU04X00_TSET, REAL_IN1 := LAHU04G01_TSET, REAL_IN2 := RAHU04G01_TSET, (** INT_IN0 :=RNIAHU04X00_SM ,INT_IN1 :=LAHU04G01_SM ,INT_IN2 :=RAHU04G01_SM | **) INT_IN0 := RNIAHU04X00_SM, INT_IN1 := LAHU04G01_SM, INT_IN2 := RAHU04G01_SM | (** LAHU04G01_PC :=BOOL_OUT1 ,RAHU04G01_PC :=BOOL_OUT2 , **) LAHU04G01_PC := BOOL_OUT1, RAHU04G01_PC := BOOL_OUT2, (** LAHU04G01_TSET:=REAL_OUT1 ,RAHU04G01_TSET:=REAL_OUT2 , **) LAHU04G01_TSET := REAL_OUT1, RAHU04G01_TSET := REAL_OUT2, (** LAHU04G01_SM :=INT_OUT1 ,RAHU04G01_SM :=INT_OUT2) ; **) LAHU04G01_SM := INT_OUT1, RAHU04G01_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU04G02********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU04G02_WVB_AVE(INPUT:=LAHU04G02_WVB); **) (* call - Stmt *) CAL AHU04G02_WVB_AVE ( INPUT := LAHU04G02_WVB ) (** AHU04G02_RT_AVE (INPUT:=LAHU04G02_RT) ; **) (* call - Stmt *) CAL AHU04G02_RT_AVE ( INPUT := LAHU04G02_RT ) (** LAHU04G02_RTS := BS_Scale(AHU04G02_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU04G02_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU04G02_RTS (** LAHU04G02_WVBS:= BS_Scale(AHU04G02_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU04G02_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU04G02_WVBS (** LAHU04G02_WVC :=REAL_TO_INT(BS_Scale(LAHU04G02_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU04G02_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU04G02_WVC (** {*主程序*} **) (** AHU04G02_DAHU(DAHU_STRUCT_IN:=DAHU04G02_IN | DAHU04G02_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU04G02_DAHU ( DAHU_STRUCT_IN := DAHU04G02_IN | DAHU04G02_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU04G02_IN.SM :=LAHU04G02_SM ; **) (* assign - Stmt *) LD LAHU04G02_SM ST DAHU04G02_IN.SM (** DAHU04G02_IN.Run :=LAHU04G02_R ; **) (* assign - Stmt *) LD LAHU04G02_R ST DAHU04G02_IN.Run (** DAHU04G02_IN.Fault :=LAHU04G02_F ; **) (* assign - Stmt *) LD LAHU04G02_F ST DAHU04G02_IN.Fault (** DAHU04G02_IN.Auto :=LAHU04G02_A ; **) (* assign - Stmt *) LD LAHU04G02_A ST DAHU04G02_IN.Auto (** DAHU04G02_IN.ContRol:=LAHU04G02_PC ; **) (* assign - Stmt *) LD LAHU04G02_PC ST DAHU04G02_IN.ContRol (** DAHU04G02_IN.TSET :=LAHU04G02_TSET ; **) (* assign - Stmt *) LD LAHU04G02_TSET ST DAHU04G02_IN.TSET (** DAHU04G02_IN.WVMC :=LAHU04G02_WVMC ; **) (* assign - Stmt *) LD LAHU04G02_WVMC ST DAHU04G02_IN.WVMC (** DAHU04G02_IN.WVMV :=LAHU04G02_WVMV ; **) (* assign - Stmt *) LD LAHU04G02_WVMV ST DAHU04G02_IN.WVMV (** DAHU04G02_IN.RTS :=LAHU04G02_RTS ; **) (* assign - Stmt *) LD LAHU04G02_RTS ST DAHU04G02_IN.RTS (** DAHU04G02_IN.RST :=LAHU04G02_RST ; **) (* assign - Stmt *) LD LAHU04G02_RST ST DAHU04G02_IN.RST (** DAHU04G02_IN.RSTV :=LAHU04G02_RSTV ; **) (* assign - Stmt *) LD LAHU04G02_RSTV ST DAHU04G02_IN.RSTV (** DAHU04G02_IN.FPS :=LAHU04G02_FPS ; **) (* assign - Stmt *) LD LAHU04G02_FPS ST DAHU04G02_IN.FPS (** DAHU04G02_IN.ISO1 :=LAHU04G02_ISO1 ; **) (* assign - Stmt *) LD LAHU04G02_ISO1 ST DAHU04G02_IN.ISO1 (** DAHU04G02_IN.ISO2 :=LAHU04G02_ISO2 ; **) (* assign - Stmt *) LD LAHU04G02_ISO2 ST DAHU04G02_IN.ISO2 (** DAHU04G02_IN.VP :=LAHU04G02_VP ; **) (* assign - Stmt *) LD LAHU04G02_VP ST DAHU04G02_IN.VP (** DAHU04G02_IN.VI :=LAHU04G02_VI ; **) (* assign - Stmt *) LD LAHU04G02_VI ST DAHU04G02_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU04G02_WVCS :=DAHU04G02_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU04G02_OUT.WVCS ST LAHU04G02_WVCS (** LAHU04G02_C :=DAHU04G02_OUT.ContRol; **) (* assign - Stmt *) LD DAHU04G02_OUT.ContRol ST LAHU04G02_C (** LAHU04G02_RH :=DAHU04G02_OUT.RH ; **) (* assign - Stmt *) LD DAHU04G02_OUT.RH ST LAHU04G02_RH (** LAHU04G02_SN :=DAHU04G02_OUT.SN ; **) (* assign - Stmt *) LD DAHU04G02_OUT.SN ST LAHU04G02_SN (** {*同步程序*} **) (** AHU04G02_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU04G02_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU04X00_PC ,BOOL_IN1:=LAHU04G02_PC ,BOOL_IN2 :=RAHU04G02_PC , **) BOOL_IN0 := RNIAHU04X00_PC, BOOL_IN1 := LAHU04G02_PC, BOOL_IN2 := RAHU04G02_PC, (** REAL_IN0:=RNIAHU04X00_TSET,REAL_IN1:=LAHU04G02_TSET,REAL_IN2 :=RAHU04G02_TSET, **) REAL_IN0 := RNIAHU04X00_TSET, REAL_IN1 := LAHU04G02_TSET, REAL_IN2 := RAHU04G02_TSET, (** INT_IN0 :=RNIAHU04X00_SM ,INT_IN1 :=LAHU04G02_SM ,INT_IN2 :=RAHU04G02_SM | **) INT_IN0 := RNIAHU04X00_SM, INT_IN1 := LAHU04G02_SM, INT_IN2 := RAHU04G02_SM | (** LAHU04G02_PC :=BOOL_OUT1 ,RAHU04G02_PC :=BOOL_OUT2 , **) LAHU04G02_PC := BOOL_OUT1, RAHU04G02_PC := BOOL_OUT2, (** LAHU04G02_TSET:=REAL_OUT1 ,RAHU04G02_TSET:=REAL_OUT2 , **) LAHU04G02_TSET := REAL_OUT1, RAHU04G02_TSET := REAL_OUT2, (** LAHU04G02_SM :=INT_OUT1 ,RAHU04G02_SM :=INT_OUT2) ; **) LAHU04G02_SM := INT_OUT1, RAHU04G02_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU04G03********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU04G03_WVB_AVE(INPUT:=LAHU04G03_WVB); **) (* call - Stmt *) CAL AHU04G03_WVB_AVE ( INPUT := LAHU04G03_WVB ) (** AHU04G03_RT_AVE (INPUT:=LAHU04G03_RT) ; **) (* call - Stmt *) CAL AHU04G03_RT_AVE ( INPUT := LAHU04G03_RT ) (** LAHU04G03_RTS := BS_Scale(AHU04G03_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU04G03_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU04G03_RTS (** LAHU04G03_WVBS:= BS_Scale(AHU04G03_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU04G03_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU04G03_WVBS (** LAHU04G03_WVC :=REAL_TO_INT(BS_Scale(LAHU04G03_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU04G03_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU04G03_WVC (** {*主程序*} **) (** AHU04G03_DAHU(DAHU_STRUCT_IN:=DAHU04G03_IN | DAHU04G03_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU04G03_DAHU ( DAHU_STRUCT_IN := DAHU04G03_IN | DAHU04G03_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU04G03_IN.SM :=LAHU04G03_SM ; **) (* assign - Stmt *) LD LAHU04G03_SM ST DAHU04G03_IN.SM (** DAHU04G03_IN.Run :=LAHU04G03_R ; **) (* assign - Stmt *) LD LAHU04G03_R ST DAHU04G03_IN.Run (** DAHU04G03_IN.Fault :=LAHU04G03_F ; **) (* assign - Stmt *) LD LAHU04G03_F ST DAHU04G03_IN.Fault (** DAHU04G03_IN.Auto :=LAHU04G03_A ; **) (* assign - Stmt *) LD LAHU04G03_A ST DAHU04G03_IN.Auto (** DAHU04G03_IN.ContRol:=LAHU04G03_PC ; **) (* assign - Stmt *) LD LAHU04G03_PC ST DAHU04G03_IN.ContRol (** DAHU04G03_IN.TSET :=LAHU04G03_TSET ; **) (* assign - Stmt *) LD LAHU04G03_TSET ST DAHU04G03_IN.TSET (** DAHU04G03_IN.WVMC :=LAHU04G03_WVMC ; **) (* assign - Stmt *) LD LAHU04G03_WVMC ST DAHU04G03_IN.WVMC (** DAHU04G03_IN.WVMV :=LAHU04G03_WVMV ; **) (* assign - Stmt *) LD LAHU04G03_WVMV ST DAHU04G03_IN.WVMV (** DAHU04G03_IN.RTS :=LAHU04G03_RTS ; **) (* assign - Stmt *) LD LAHU04G03_RTS ST DAHU04G03_IN.RTS (** DAHU04G03_IN.RST :=LAHU04G03_RST ; **) (* assign - Stmt *) LD LAHU04G03_RST ST DAHU04G03_IN.RST (** DAHU04G03_IN.RSTV :=LAHU04G03_RSTV ; **) (* assign - Stmt *) LD LAHU04G03_RSTV ST DAHU04G03_IN.RSTV (** DAHU04G03_IN.FPS :=LAHU04G03_FPS ; **) (* assign - Stmt *) LD LAHU04G03_FPS ST DAHU04G03_IN.FPS (** DAHU04G03_IN.ISO1 :=LAHU04G03_ISO1 ; **) (* assign - Stmt *) LD LAHU04G03_ISO1 ST DAHU04G03_IN.ISO1 (** DAHU04G03_IN.ISO2 :=LAHU04G03_ISO2 ; **) (* assign - Stmt *) LD LAHU04G03_ISO2 ST DAHU04G03_IN.ISO2 (** DAHU04G03_IN.VP :=LAHU04G03_VP ; **) (* assign - Stmt *) LD LAHU04G03_VP ST DAHU04G03_IN.VP (** DAHU04G03_IN.VI :=LAHU04G03_VI ; **) (* assign - Stmt *) LD LAHU04G03_VI ST DAHU04G03_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU04G03_WVCS :=DAHU04G03_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU04G03_OUT.WVCS ST LAHU04G03_WVCS (** LAHU04G03_C :=DAHU04G03_OUT.ContRol; **) (* assign - Stmt *) LD DAHU04G03_OUT.ContRol ST LAHU04G03_C (** LAHU04G03_RH :=DAHU04G03_OUT.RH ; **) (* assign - Stmt *) LD DAHU04G03_OUT.RH ST LAHU04G03_RH (** LAHU04G03_SN :=DAHU04G03_OUT.SN ; **) (* assign - Stmt *) LD DAHU04G03_OUT.SN ST LAHU04G03_SN (** {*同步程序*} **) (** AHU04G03_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU04G03_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU04X00_PC ,BOOL_IN1:=LAHU04G03_PC ,BOOL_IN2 :=RAHU04G03_PC , **) BOOL_IN0 := RNIAHU04X00_PC, BOOL_IN1 := LAHU04G03_PC, BOOL_IN2 := RAHU04G03_PC, (** REAL_IN0:=RNIAHU04X00_TSET,REAL_IN1:=LAHU04G03_TSET,REAL_IN2 :=RAHU04G03_TSET, **) REAL_IN0 := RNIAHU04X00_TSET, REAL_IN1 := LAHU04G03_TSET, REAL_IN2 := RAHU04G03_TSET, (** INT_IN0 :=RNIAHU04X00_SM ,INT_IN1 :=LAHU04G03_SM ,INT_IN2 :=RAHU04G03_SM | **) INT_IN0 := RNIAHU04X00_SM, INT_IN1 := LAHU04G03_SM, INT_IN2 := RAHU04G03_SM | (** LAHU04G03_PC :=BOOL_OUT1 ,RAHU04G03_PC :=BOOL_OUT2 , **) LAHU04G03_PC := BOOL_OUT1, RAHU04G03_PC := BOOL_OUT2, (** LAHU04G03_TSET:=REAL_OUT1 ,RAHU04G03_TSET:=REAL_OUT2 , **) LAHU04G03_TSET := REAL_OUT1, RAHU04G03_TSET := REAL_OUT2, (** LAHU04G03_SM :=INT_OUT1 ,RAHU04G03_SM :=INT_OUT2) ; **) LAHU04G03_SM := INT_OUT1, RAHU04G03_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU04G04********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU04G04_WVB_AVE(INPUT:=LAHU04G04_WVB); **) (* call - Stmt *) CAL AHU04G04_WVB_AVE ( INPUT := LAHU04G04_WVB ) (** AHU04G04_RT_AVE (INPUT:=LAHU04G04_RT) ; **) (* call - Stmt *) CAL AHU04G04_RT_AVE ( INPUT := LAHU04G04_RT ) (** LAHU04G04_RTS := BS_Scale(AHU04G04_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU04G04_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU04G04_RTS (** LAHU04G04_WVBS:= BS_Scale(AHU04G04_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU04G04_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU04G04_WVBS (** LAHU04G04_WVC :=REAL_TO_INT(BS_Scale(LAHU04G04_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU04G04_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU04G04_WVC (** {*主程序*} **) (** AHU04G04_DAHU(DAHU_STRUCT_IN:=DAHU04G04_IN | DAHU04G04_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU04G04_DAHU ( DAHU_STRUCT_IN := DAHU04G04_IN | DAHU04G04_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU04G04_IN.SM :=LAHU04G04_SM ; **) (* assign - Stmt *) LD LAHU04G04_SM ST DAHU04G04_IN.SM (** DAHU04G04_IN.Run :=LAHU04G04_R ; **) (* assign - Stmt *) LD LAHU04G04_R ST DAHU04G04_IN.Run (** DAHU04G04_IN.Fault :=LAHU04G04_F ; **) (* assign - Stmt *) LD LAHU04G04_F ST DAHU04G04_IN.Fault (** DAHU04G04_IN.Auto :=LAHU04G04_A ; **) (* assign - Stmt *) LD LAHU04G04_A ST DAHU04G04_IN.Auto (** DAHU04G04_IN.ContRol:=LAHU04G04_PC ; **) (* assign - Stmt *) LD LAHU04G04_PC ST DAHU04G04_IN.ContRol (** DAHU04G04_IN.TSET :=LAHU04G04_TSET ; **) (* assign - Stmt *) LD LAHU04G04_TSET ST DAHU04G04_IN.TSET (** DAHU04G04_IN.WVMC :=LAHU04G04_WVMC ; **) (* assign - Stmt *) LD LAHU04G04_WVMC ST DAHU04G04_IN.WVMC (** DAHU04G04_IN.WVMV :=LAHU04G04_WVMV ; **) (* assign - Stmt *) LD LAHU04G04_WVMV ST DAHU04G04_IN.WVMV (** DAHU04G04_IN.RTS :=LAHU04G04_RTS ; **) (* assign - Stmt *) LD LAHU04G04_RTS ST DAHU04G04_IN.RTS (** DAHU04G04_IN.RST :=LAHU04G04_RST ; **) (* assign - Stmt *) LD LAHU04G04_RST ST DAHU04G04_IN.RST (** DAHU04G04_IN.RSTV :=LAHU04G04_RSTV ; **) (* assign - Stmt *) LD LAHU04G04_RSTV ST DAHU04G04_IN.RSTV (** DAHU04G04_IN.FPS :=LAHU04G04_FPS ; **) (* assign - Stmt *) LD LAHU04G04_FPS ST DAHU04G04_IN.FPS (** DAHU04G04_IN.ISO1 :=LAHU04G04_ISO1 ; **) (* assign - Stmt *) LD LAHU04G04_ISO1 ST DAHU04G04_IN.ISO1 (** DAHU04G04_IN.ISO2 :=LAHU04G04_ISO2 ; **) (* assign - Stmt *) LD LAHU04G04_ISO2 ST DAHU04G04_IN.ISO2 (** DAHU04G04_IN.VP :=LAHU04G04_VP ; **) (* assign - Stmt *) LD LAHU04G04_VP ST DAHU04G04_IN.VP (** DAHU04G04_IN.VI :=LAHU04G04_VI ; **) (* assign - Stmt *) LD LAHU04G04_VI ST DAHU04G04_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU04G04_WVCS :=DAHU04G04_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU04G04_OUT.WVCS ST LAHU04G04_WVCS (** LAHU04G04_C :=DAHU04G04_OUT.ContRol; **) (* assign - Stmt *) LD DAHU04G04_OUT.ContRol ST LAHU04G04_C (** LAHU04G04_RH :=DAHU04G04_OUT.RH ; **) (* assign - Stmt *) LD DAHU04G04_OUT.RH ST LAHU04G04_RH (** LAHU04G04_SN :=DAHU04G04_OUT.SN ; **) (* assign - Stmt *) LD DAHU04G04_OUT.SN ST LAHU04G04_SN (** {*同步程序*} **) (** AHU04G04_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU04G04_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU04X00_PC ,BOOL_IN1:=LAHU04G04_PC ,BOOL_IN2 :=RAHU04G04_PC , **) BOOL_IN0 := RNIAHU04X00_PC, BOOL_IN1 := LAHU04G04_PC, BOOL_IN2 := RAHU04G04_PC, (** REAL_IN0:=RNIAHU04X00_TSET,REAL_IN1:=LAHU04G04_TSET,REAL_IN2 :=RAHU04G04_TSET, **) REAL_IN0 := RNIAHU04X00_TSET, REAL_IN1 := LAHU04G04_TSET, REAL_IN2 := RAHU04G04_TSET, (** INT_IN0 :=RNIAHU04X00_SM ,INT_IN1 :=LAHU04G04_SM ,INT_IN2 :=RAHU04G04_SM | **) INT_IN0 := RNIAHU04X00_SM, INT_IN1 := LAHU04G04_SM, INT_IN2 := RAHU04G04_SM | (** LAHU04G04_PC :=BOOL_OUT1 ,RAHU04G04_PC :=BOOL_OUT2 , **) LAHU04G04_PC := BOOL_OUT1, RAHU04G04_PC := BOOL_OUT2, (** LAHU04G04_TSET:=REAL_OUT1 ,RAHU04G04_TSET:=REAL_OUT2 , **) LAHU04G04_TSET := REAL_OUT1, RAHU04G04_TSET := REAL_OUT2, (** LAHU04G04_SM :=INT_OUT1 ,RAHU04G04_SM :=INT_OUT2) ; **) LAHU04G04_SM := INT_OUT1, RAHU04G04_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU04G05********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU04G05_WVB_AVE(INPUT:=LAHU04G05_WVB); **) (* call - Stmt *) CAL AHU04G05_WVB_AVE ( INPUT := LAHU04G05_WVB ) (** AHU04G05_RT_AVE (INPUT:=LAHU04G05_RT) ; **) (* call - Stmt *) CAL AHU04G05_RT_AVE ( INPUT := LAHU04G05_RT ) (** LAHU04G05_RTS := BS_Scale(AHU04G05_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU04G05_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU04G05_RTS (** LAHU04G05_WVBS:= BS_Scale(AHU04G05_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU04G05_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU04G05_WVBS (** LAHU04G05_WVC :=REAL_TO_INT(BS_Scale(LAHU04G05_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU04G05_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU04G05_WVC (** {*主程序*} **) (** AHU04G05_DAHU(DAHU_STRUCT_IN:=DAHU04G05_IN | DAHU04G05_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU04G05_DAHU ( DAHU_STRUCT_IN := DAHU04G05_IN | DAHU04G05_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU04G05_IN.SM :=LAHU04G05_SM ; **) (* assign - Stmt *) LD LAHU04G05_SM ST DAHU04G05_IN.SM (** DAHU04G05_IN.Run :=LAHU04G05_R ; **) (* assign - Stmt *) LD LAHU04G05_R ST DAHU04G05_IN.Run (** DAHU04G05_IN.Fault :=LAHU04G05_F ; **) (* assign - Stmt *) LD LAHU04G05_F ST DAHU04G05_IN.Fault (** DAHU04G05_IN.Auto :=LAHU04G05_A ; **) (* assign - Stmt *) LD LAHU04G05_A ST DAHU04G05_IN.Auto (** DAHU04G05_IN.ContRol:=LAHU04G05_PC ; **) (* assign - Stmt *) LD LAHU04G05_PC ST DAHU04G05_IN.ContRol (** DAHU04G05_IN.TSET :=LAHU04G05_TSET ; **) (* assign - Stmt *) LD LAHU04G05_TSET ST DAHU04G05_IN.TSET (** DAHU04G05_IN.WVMC :=LAHU04G05_WVMC ; **) (* assign - Stmt *) LD LAHU04G05_WVMC ST DAHU04G05_IN.WVMC (** DAHU04G05_IN.WVMV :=LAHU04G05_WVMV ; **) (* assign - Stmt *) LD LAHU04G05_WVMV ST DAHU04G05_IN.WVMV (** DAHU04G05_IN.RTS :=LAHU04G05_RTS ; **) (* assign - Stmt *) LD LAHU04G05_RTS ST DAHU04G05_IN.RTS (** DAHU04G05_IN.RST :=LAHU04G05_RST ; **) (* assign - Stmt *) LD LAHU04G05_RST ST DAHU04G05_IN.RST (** DAHU04G05_IN.RSTV :=LAHU04G05_RSTV ; **) (* assign - Stmt *) LD LAHU04G05_RSTV ST DAHU04G05_IN.RSTV (** DAHU04G05_IN.FPS :=LAHU04G05_FPS ; **) (* assign - Stmt *) LD LAHU04G05_FPS ST DAHU04G05_IN.FPS (** DAHU04G05_IN.ISO1 :=LAHU04G05_ISO1 ; **) (* assign - Stmt *) LD LAHU04G05_ISO1 ST DAHU04G05_IN.ISO1 (** DAHU04G05_IN.ISO2 :=LAHU04G05_ISO2 ; **) (* assign - Stmt *) LD LAHU04G05_ISO2 ST DAHU04G05_IN.ISO2 (** DAHU04G05_IN.VP :=LAHU04G05_VP ; **) (* assign - Stmt *) LD LAHU04G05_VP ST DAHU04G05_IN.VP (** DAHU04G05_IN.VI :=LAHU04G05_VI ; **) (* assign - Stmt *) LD LAHU04G05_VI ST DAHU04G05_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU04G05_WVCS :=DAHU04G05_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU04G05_OUT.WVCS ST LAHU04G05_WVCS (** LAHU04G05_C :=DAHU04G05_OUT.ContRol; **) (* assign - Stmt *) LD DAHU04G05_OUT.ContRol ST LAHU04G05_C (** LAHU04G05_RH :=DAHU04G05_OUT.RH ; **) (* assign - Stmt *) LD DAHU04G05_OUT.RH ST LAHU04G05_RH (** LAHU04G05_SN :=DAHU04G05_OUT.SN ; **) (* assign - Stmt *) LD DAHU04G05_OUT.SN ST LAHU04G05_SN (** {*同步程序*} **) (** AHU04G05_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU04G05_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU04X00_PC ,BOOL_IN1:=LAHU04G05_PC ,BOOL_IN2 :=RAHU04G05_PC , **) BOOL_IN0 := RNIAHU04X00_PC, BOOL_IN1 := LAHU04G05_PC, BOOL_IN2 := RAHU04G05_PC, (** REAL_IN0:=RNIAHU04X00_TSET,REAL_IN1:=LAHU04G05_TSET,REAL_IN2 :=RAHU04G05_TSET, **) REAL_IN0 := RNIAHU04X00_TSET, REAL_IN1 := LAHU04G05_TSET, REAL_IN2 := RAHU04G05_TSET, (** INT_IN0 :=RNIAHU04X00_SM ,INT_IN1 :=LAHU04G05_SM ,INT_IN2 :=RAHU04G05_SM | **) INT_IN0 := RNIAHU04X00_SM, INT_IN1 := LAHU04G05_SM, INT_IN2 := RAHU04G05_SM | (** LAHU04G05_PC :=BOOL_OUT1 ,RAHU04G05_PC :=BOOL_OUT2 , **) LAHU04G05_PC := BOOL_OUT1, RAHU04G05_PC := BOOL_OUT2, (** LAHU04G05_TSET:=REAL_OUT1 ,RAHU04G05_TSET:=REAL_OUT2 , **) LAHU04G05_TSET := REAL_OUT1, RAHU04G05_TSET := REAL_OUT2, (** LAHU04G05_SM :=INT_OUT1 ,RAHU04G05_SM :=INT_OUT2) ; **) LAHU04G05_SM := INT_OUT1, RAHU04G05_SM := INT_OUT2 ) (** **) (** **) (** {********************************************AHU04G06********************************************} **) (** {*输入，类型，示值上限，示值下限，基准补偿，输出补偿*} **) (** AHU04G06_WVB_AVE(INPUT:=LAHU04G06_WVB); **) (* call - Stmt *) CAL AHU04G06_WVB_AVE ( INPUT := LAHU04G06_WVB ) (** AHU04G06_RT_AVE (INPUT:=LAHU04G06_RT) ; **) (* call - Stmt *) CAL AHU04G06_RT_AVE ( INPUT := LAHU04G06_RT ) (** LAHU04G06_RTS := BS_Scale(AHU04G06_RT_AVE.Output ,1,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU04G06_RT_AVE.Output BS_Scale 1, 0, 100, 0, 0.0 ST LAHU04G06_RTS (** LAHU04G06_WVBS:= BS_Scale(AHU04G06_WVB_AVE.Output,2,0,100,0,0.0) ; **) (* assign - Stmt *) LD AHU04G06_WVB_AVE.Output BS_Scale 2, 0, 100, 0, 0.0 ST LAHU04G06_WVBS (** LAHU04G06_WVC :=REAL_TO_INT(BS_Scale(LAHU04G06_WVCS ,4,0,100,0,0.0)); **) (* assign - Stmt *) LD LAHU04G06_WVCS BS_Scale 4, 0, 100, 0, 0.0 REAL_TO_INT ST LAHU04G06_WVC (** {*主程序*} **) (** AHU04G06_DAHU(DAHU_STRUCT_IN:=DAHU04G06_IN | DAHU04G06_OUT:=DAHU_STRUCT_OUT); **) (* call - Stmt *) CAL AHU04G06_DAHU ( DAHU_STRUCT_IN := DAHU04G06_IN | DAHU04G06_OUT := DAHU_STRUCT_OUT ) (** {*AHU_INSTRUCT*} **) (** DAHU04G06_IN.SM :=LAHU04G06_SM ; **) (* assign - Stmt *) LD LAHU04G06_SM ST DAHU04G06_IN.SM (** DAHU04G06_IN.Run :=LAHU04G06_R ; **) (* assign - Stmt *) LD LAHU04G06_R ST DAHU04G06_IN.Run (** DAHU04G06_IN.Fault :=LAHU04G06_F ; **) (* assign - Stmt *) LD LAHU04G06_F ST DAHU04G06_IN.Fault (** DAHU04G06_IN.Auto :=LAHU04G06_A ; **) (* assign - Stmt *) LD LAHU04G06_A ST DAHU04G06_IN.Auto (** DAHU04G06_IN.ContRol:=LAHU04G06_PC ; **) (* assign - Stmt *) LD LAHU04G06_PC ST DAHU04G06_IN.ContRol (** DAHU04G06_IN.TSET :=LAHU04G06_TSET ; **) (* assign - Stmt *) LD LAHU04G06_TSET ST DAHU04G06_IN.TSET (** DAHU04G06_IN.WVMC :=LAHU04G06_WVMC ; **) (* assign - Stmt *) LD LAHU04G06_WVMC ST DAHU04G06_IN.WVMC (** DAHU04G06_IN.WVMV :=LAHU04G06_WVMV ; **) (* assign - Stmt *) LD LAHU04G06_WVMV ST DAHU04G06_IN.WVMV (** DAHU04G06_IN.RTS :=LAHU04G06_RTS ; **) (* assign - Stmt *) LD LAHU04G06_RTS ST DAHU04G06_IN.RTS (** DAHU04G06_IN.RST :=LAHU04G06_RST ; **) (* assign - Stmt *) LD LAHU04G06_RST ST DAHU04G06_IN.RST (** DAHU04G06_IN.RSTV :=LAHU04G06_RSTV ; **) (* assign - Stmt *) LD LAHU04G06_RSTV ST DAHU04G06_IN.RSTV (** DAHU04G06_IN.FPS :=LAHU04G06_FPS ; **) (* assign - Stmt *) LD LAHU04G06_FPS ST DAHU04G06_IN.FPS (** DAHU04G06_IN.ISO1 :=LAHU04G06_ISO1 ; **) (* assign - Stmt *) LD LAHU04G06_ISO1 ST DAHU04G06_IN.ISO1 (** DAHU04G06_IN.ISO2 :=LAHU04G06_ISO2 ; **) (* assign - Stmt *) LD LAHU04G06_ISO2 ST DAHU04G06_IN.ISO2 (** DAHU04G06_IN.VP :=LAHU04G06_VP ; **) (* assign - Stmt *) LD LAHU04G06_VP ST DAHU04G06_IN.VP (** DAHU04G06_IN.VI :=LAHU04G06_VI ; **) (* assign - Stmt *) LD LAHU04G06_VI ST DAHU04G06_IN.VI (** {*AHU_OUTSTRUCT*} **) (** LAHU04G06_WVCS :=DAHU04G06_OUT.WVCS ; **) (* assign - Stmt *) LD DAHU04G06_OUT.WVCS ST LAHU04G06_WVCS (** LAHU04G06_C :=DAHU04G06_OUT.ContRol; **) (* assign - Stmt *) LD DAHU04G06_OUT.ContRol ST LAHU04G06_C (** LAHU04G06_RH :=DAHU04G06_OUT.RH ; **) (* assign - Stmt *) LD DAHU04G06_OUT.RH ST LAHU04G06_RH (** LAHU04G06_SN :=DAHU04G06_OUT.SN ; **) (* assign - Stmt *) LD DAHU04G06_OUT.SN ST LAHU04G06_SN (** {*同步程序*} **) (** AHU04G06_SyncContRol(CM:=RNIAHU00000_CM,RM:=LCMD00000_RM, **) (* call - Stmt *) CAL AHU04G06_SyncContRol ( CM := RNIAHU00000_CM, RM := LCMD00000_RM, (** BOOL_IN0:=RNIAHU04X00_PC ,BOOL_IN1:=LAHU04G06_PC ,BOOL_IN2 :=RAHU04G06_PC , **) BOOL_IN0 := RNIAHU04X00_PC, BOOL_IN1 := LAHU04G06_PC, BOOL_IN2 := RAHU04G06_PC, (** REAL_IN0:=RNIAHU04X00_TSET,REAL_IN1:=LAHU04G06_TSET,REAL_IN2 :=RAHU04G06_TSET, **) REAL_IN0 := RNIAHU04X00_TSET, REAL_IN1 := LAHU04G06_TSET, REAL_IN2 := RAHU04G06_TSET, (** INT_IN0 :=RNIAHU04X00_SM ,INT_IN1 :=LAHU04G06_SM ,INT_IN2 :=RAHU04G06_SM | **) INT_IN0 := RNIAHU04X00_SM, INT_IN1 := LAHU04G06_SM, INT_IN2 := RAHU04G06_SM | (** LAHU04G06_PC :=BOOL_OUT1 ,RAHU04G06_PC :=BOOL_OUT2 , **) LAHU04G06_PC := BOOL_OUT1, RAHU04G06_PC := BOOL_OUT2, (** LAHU04G06_TSET:=REAL_OUT1 ,RAHU04G06_TSET:=REAL_OUT2 , **) LAHU04G06_TSET := REAL_OUT1, RAHU04G06_TSET := REAL_OUT2, (** LAHU04G06_SM :=INT_OUT1 ,RAHU04G06_SM :=INT_OUT2) ; **) LAHU04G06_SM := INT_OUT1, RAHU04G06_SM := INT_OUT2 ) END_PROGRAM