From 524990ff02840484e67d8fcdd078c3bad5c9c203 Mon Sep 17 00:00:00 2001 From: "SUPPORT\\admin" Date: Mon, 31 Aug 2026 13:26:17 +0200 Subject: [PATCH] =?UTF-8?q?Differenzdruck=20anders=20skaliert=20und=20gegl?= =?UTF-8?q?=C3=A4ttet=20Projekt=20von=20intel=20MB=20migriert?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- KD_Pliessnigg_Reinraum.apj | 2 +- LastUser.set | 2 +- Logical/Libraries/LoopConR/Binary.lby | 13 + Logical/Libraries/LoopConR/LoopConR.fun | 798 ++++++++ Logical/Libraries/LoopConR/LoopConR.typ | 400 ++++ Logical/Libraries/LoopConR/LoopConR.var | 192 ++ Logical/Libraries/LoopConR/SG3/LoopConR.h | 1677 +++++++++++++++++ .../Libraries/LoopConR/SG4/Arm/LoopConR.br | Bin 0 -> 176592 bytes .../Libraries/LoopConR/SG4/Arm/libLoopConR.a | Bin 0 -> 9745 bytes Logical/Libraries/LoopConR/SG4/LoopConR.br | Bin 0 -> 139040 bytes Logical/Libraries/LoopConR/SG4/LoopConR.h | 1677 +++++++++++++++++ Logical/Libraries/LoopConR/SG4/libLoopConR.a | Bin 0 -> 14211 bytes Logical/Libraries/LoopConR/SGC/LoopConR.h | 1677 +++++++++++++++++ Logical/Libraries/Package.pkg | 3 + Logical/Libraries/brsystem/SG3/brsystem.h | 271 +++ Logical/Libraries/brsystem/SG4/brsystem.h | 347 ++++ Logical/Libraries/brsystem/binary.lby | 12 + Logical/Libraries/brsystem/brsystem.fun | 216 +++ Logical/Libraries/brsystem/brsystem.typ | 4 + Logical/Libraries/brsystem/brsystem.var | 49 + Logical/Libraries/sys_lib/SG3/sys_lib.h | 684 +++++++ Logical/Libraries/sys_lib/SG4/sys_lib.h | 730 +++++++ Logical/Libraries/sys_lib/binary.lby | 12 + Logical/Libraries/sys_lib/sys_lib.fun | 655 +++++++ Logical/Libraries/sys_lib/sys_lib.typ | 90 + Logical/Libraries/sys_lib/sys_lib.var | 131 ++ Logical/Machine/ConMon/Main.st | 11 +- Logical/Machine/ConMon/Types.typ | 1 + Logical/Machine/ConMon/Variables.var | 2 + Physical/Config2/X20CP0483/Cpu.sw | 3 + admin.set | 7 + 31 files changed, 9663 insertions(+), 3 deletions(-) create mode 100644 Logical/Libraries/LoopConR/Binary.lby create mode 100644 Logical/Libraries/LoopConR/LoopConR.fun create mode 100644 Logical/Libraries/LoopConR/LoopConR.typ create mode 100644 Logical/Libraries/LoopConR/LoopConR.var create mode 100644 Logical/Libraries/LoopConR/SG3/LoopConR.h create mode 100644 Logical/Libraries/LoopConR/SG4/Arm/LoopConR.br create mode 100644 Logical/Libraries/LoopConR/SG4/Arm/libLoopConR.a create mode 100644 Logical/Libraries/LoopConR/SG4/LoopConR.br create mode 100644 Logical/Libraries/LoopConR/SG4/LoopConR.h create mode 100644 Logical/Libraries/LoopConR/SG4/libLoopConR.a create mode 100644 Logical/Libraries/LoopConR/SGC/LoopConR.h create mode 100644 Logical/Libraries/brsystem/SG3/brsystem.h create mode 100644 Logical/Libraries/brsystem/SG4/brsystem.h create mode 100644 Logical/Libraries/brsystem/binary.lby create mode 100644 Logical/Libraries/brsystem/brsystem.fun create mode 100644 Logical/Libraries/brsystem/brsystem.typ create mode 100644 Logical/Libraries/brsystem/brsystem.var create mode 100644 Logical/Libraries/sys_lib/SG3/sys_lib.h create mode 100644 Logical/Libraries/sys_lib/SG4/sys_lib.h create mode 100644 Logical/Libraries/sys_lib/binary.lby create mode 100644 Logical/Libraries/sys_lib/sys_lib.fun create mode 100644 Logical/Libraries/sys_lib/sys_lib.typ create mode 100644 Logical/Libraries/sys_lib/sys_lib.var create mode 100644 admin.set diff --git a/KD_Pliessnigg_Reinraum.apj b/KD_Pliessnigg_Reinraum.apj index 28c293a..f675c2b 100644 --- a/KD_Pliessnigg_Reinraum.apj +++ b/KD_Pliessnigg_Reinraum.apj @@ -1,5 +1,5 @@  - + diff --git a/LastUser.set b/LastUser.set index 9cdd4bd..4be53a5 100644 --- a/LastUser.set +++ b/LastUser.set @@ -1,5 +1,5 @@  - + diff --git a/Logical/Libraries/LoopConR/Binary.lby b/Logical/Libraries/LoopConR/Binary.lby new file mode 100644 index 0000000..e15927a --- /dev/null +++ b/Logical/Libraries/LoopConR/Binary.lby @@ -0,0 +1,13 @@ + + + + + LoopConR.var + LoopConR.typ + LoopConR.fun + + + + + + \ No newline at end of file diff --git a/Logical/Libraries/LoopConR/LoopConR.fun b/Logical/Libraries/LoopConR/LoopConR.fun new file mode 100644 index 0000000..72608f8 --- /dev/null +++ b/Logical/Libraries/LoopConR/LoopConR.fun @@ -0,0 +1,798 @@ + +{REDUND_OK} FUNCTION_BLOCK LCRPID (* PID controller. *) + VAR_INPUT + enable : BOOL; + ident : {REDUND_UNREPLICABLE} UDINT; + W : REAL; + X : REAL; + Y_max : REAL; + Y_min : REAL; + A : REAL; + Y_man : REAL; + Y_fbk : REAL; + hold_I : BOOL; + mode : USINT; + END_VAR + VAR_OUTPUT + status : UINT; + e : REAL; + Y : REAL; + Yp : REAL; + Yi : REAL; + Yd : REAL; + END_VAR + VAR + Set_Yi : BOOL; + Yi_set : REAL; + force_Yi : BOOL; + Yi_min : REAL; + Yi_max : REAL; + joltFreeDoneLowerLim : BOOL; + joltFreeDoneUpperLim : BOOL; + Yi_minInternal : REAL; + Yi_maxInternal : REAL; + Tv_Tf_old : REAL; + enable_old : BOOL; + e_old : REAL; + deadband_state : UINT; + sysinfo_inst : {REDUND_UNREPLICABLE} SysInfo; + scal_inst : LCRScal; + store1 : {REDUND_UNREPLICABLE} UDINT; + store2 : {REDUND_UNREPLICABLE} UDINT; + timeCnt : {REDUND_UNREPLICABLE} UDINT; + musecs_old : {REDUND_UNREPLICABLE} UINT; + END_VAR +END_FUNCTION_BLOCK + +{REDUND_OK} FUNCTION_BLOCK LCRScal (* Scaling of REAL signals. *) + VAR_INPUT + x : REAL; + x1 : REAL; + y1 : REAL; + x2 : REAL; + y2 : REAL; + END_VAR + VAR_OUTPUT + y : REAL; + END_VAR +END_FUNCTION_BLOCK + +FUNCTION_BLOCK LCRCurveByPoints (* y=f(x) function using coordinates. *) + VAR_INPUT + x : REAL; + NoOfPoints : UINT; + ptr_table : REFERENCE TO lcrCurveByPoints_TabEntry_type; + END_VAR + VAR_OUTPUT + status : UINT; + y : REAL; + END_VAR + VAR + i_tab : INT; + iterations : UINT; + scal1 : LCRScal; + END_VAR +END_FUNCTION_BLOCK + +{REDUND_OK} FUNCTION_BLOCK LCRPIDpara (* Manual configuration of the PID controller. *) + VAR_INPUT + enable : BOOL; + enter : BOOL; + WX_max : REAL; + WX_min : REAL; + invert : BOOL; + deadband : REAL; + deadband_mode : USINT; + dY_max : REAL; + Kp : REAL; + Tn : REAL; + Tv : REAL; + Tf : REAL; + Kw : REAL; + Kfbk : REAL; + fbk_mode : USINT; + d_mode : USINT; + END_VAR + VAR_OUTPUT + status : UINT; + ident : {REDUND_UNREPLICABLE} UDINT; + END_VAR + VAR + internal_data : lcrpid_internal_typ; + END_VAR +END_FUNCTION_BLOCK + +FUNCTION_BLOCK LCRContinServo (* Control of a continuous servo drive without position feedback. *) + VAR_INPUT + enable : BOOL; + x : REAL; + max_value : REAL; + min_value : REAL; + t_impulse : REAL; + t_change_up : REAL; + t_change_down : REAL; + ref : BOOL; + END_VAR + VAR_OUTPUT + status : UINT; + up : BOOL; + down : BOOL; + hysteresis_up : REAL; + hysteresis_down : REAL; + refOk : BOOL; + END_VAR + VAR + enable_old : BOOL; + counter_state : UINT; + bootkey_old : {REDUND_UNREPLICABLE} UDINT; + systicks_old : {REDUND_UNREPLICABLE} UDINT; + musecs_old : {REDUND_UNREPLICABLE} UINT; + ref_old : BOOL; + t_cnt_1 : DINT; + t_cnt_2 : DINT; + y_dbl_1 : DINT; + y_dbl_2 : DINT; + sysInfo_inst : {REDUND_UNREPLICABLE} SysInfo; + END_VAR +END_FUNCTION_BLOCK + +FUNCTION_BLOCK LCRPT1 (* First-order delay element, see LCRPT1e(). *) + VAR_INPUT + enable : BOOL; + x : REAL; + t : REAL; + y_set : REAL; + set : BOOL; + END_VAR + VAR_OUTPUT + status : UINT; + y : REAL; + END_VAR + VAR + counter_state : UINT; + bootkey_old : {REDUND_UNREPLICABLE} UDINT; + systicks_old : {REDUND_UNREPLICABLE} UDINT; + musecs_old : {REDUND_UNREPLICABLE} UINT; + y_dbl_1 : DINT; + y_dbl_2 : DINT; + sysinfo_inst : {REDUND_UNREPLICABLE} SysInfo; + END_VAR +END_FUNCTION_BLOCK + +{REDUND_OK} FUNCTION_BLOCK LCRRamp (* Ramp generator. *) + VAR_INPUT + enable : BOOL; + x : REAL; + dy_up : REAL; + dy_down : REAL; + y_max : REAL; + y_min : REAL; + y_set : REAL; + set : BOOL; + END_VAR + VAR_OUTPUT + status : UINT; + y : REAL; + x_reached : BOOL; + max_limit : BOOL; + min_limit : BOOL; + END_VAR + VAR + y_dbl_1 : DINT; + y_dbl_2 : DINT; + timestore1 : UDINT; + timestore2 : UDINT; + getDtForceOff : UDINT; + sysinfo_inst : {REDUND_UNREPLICABLE} SysInfo; + END_VAR +END_FUNCTION_BLOCK + +{REDUND_OK} FUNCTION_BLOCK LCRIntegrate (* Integrator with limits and set value. *) + VAR_INPUT + enable : BOOL; + x : REAL; + tn : REAL; + y_max : REAL; + y_min : REAL; + y_set : REAL; + set : BOOL; + END_VAR + VAR_OUTPUT + status : UINT; + y : REAL; + max_limit : BOOL; + min_limit : BOOL; + END_VAR + VAR + counter_state : UINT; + bootkey_old : {REDUND_UNREPLICABLE} UDINT; + systicks_old : {REDUND_UNREPLICABLE} UDINT; + musecs_old : {REDUND_UNREPLICABLE} UINT; + y_dbl_1 : DINT; + y_dbl_2 : DINT; + sysinfo_inst : {REDUND_UNREPLICABLE} SysInfo; + END_VAR +END_FUNCTION_BLOCK + +{REDUND_OK} FUNCTION_BLOCK LCRLimit (* Limiter with overrun indicators. *) + VAR_INPUT + in : REAL; + max_value : DINT; + min_value : DINT; + END_VAR + VAR_OUTPUT + status : UINT; + out : DINT; + max_limit : BOOL; + min_limit : BOOL; + END_VAR +END_FUNCTION_BLOCK + +{REDUND_OK} FUNCTION_BLOCK LCRLimScal (* Scaling and limiting of REAL signals. *) + VAR_INPUT + x : REAL; + x1 : REAL; + y1 : REAL; + x2 : REAL; + y2 : REAL; + END_VAR + VAR_OUTPUT + y : REAL; + END_VAR +END_FUNCTION_BLOCK + +FUNCTION_BLOCK LCRPWM (* Pulse width modulator (can also be used as pulse frequency modulator). *) + VAR_INPUT + enable : BOOL; + x : REAL; + max_value : REAL; + min_value : REAL; + t_min_pulse : REAL; + t_period : REAL; + END_VAR + VAR_OUTPUT + status : UINT; + pulse : BOOL; + t_on : REAL; + t_off : REAL; + END_VAR + VAR + cnt_terron_1 : DINT; + cnt_terron_2 : DINT; + cnt_terroff_1 : DINT; + cnt_terroff_2 : DINT; + cnt_t_pulse_1 : DINT; + cnt_t_pulse_2 : DINT; + store1 : UDINT; + store2 : UDINT; + timeCnt : UDINT; + sysinfo_inst : SysInfo; + corr : BOOL; + END_VAR +END_FUNCTION_BLOCK + +{REDUND_OK} FUNCTION_BLOCK LCRMovAvgFlt (* Floating average value filter. *) + VAR_INPUT + enable : BOOL; + x : REAL; + base : UINT; + END_VAR + VAR_OUTPUT + status : UINT; + y : REAL; + END_VAR + VAR + sum_old_dbl_1 : DINT; + sum_old_dbl_2 : DINT; + p_xold : {REDUND_UNREPLICABLE} UDINT; + i_xold : UINT; + base_old : {REDUND_UNREPLICABLE} UINT; + enable_old : {REDUND_UNREPLICABLE} BOOL; + bootkey_old : {REDUND_UNREPLICABLE} UDINT; + END_VAR +END_FUNCTION_BLOCK + +FUNCTION_BLOCK LCRTimeBasedOnOff (* 3-position step output, see LCRContinServo(). *) + VAR_INPUT + enable : BOOL; + x : REAL; + max_value : REAL; + min_value : REAL; + timpulse : REAL; + tchange_up : REAL; + tchange_down : REAL; + ref : BOOL; + END_VAR + VAR_OUTPUT + status : UINT; + up : BOOL; + down : BOOL; + hysteresis_up : REAL; + hysteresis_down : REAL; + refOk : BOOL; + END_VAR + VAR + enable_old : BOOL; + counter_state : UINT; + bootkey_old : UDINT; + systicks_old : UDINT; + musecs_old : UINT; + ref_old : BOOL; + t_cnt_1 : DINT; + t_cnt_2 : DINT; + y_dbl_1 : DINT; + y_dbl_2 : DINT; + sysInfo_inst : SysInfo; + END_VAR +END_FUNCTION_BLOCK + +{REDUND_OK} FUNCTION_BLOCK LCRDifferentiate (* Differentiator with filter. *) + VAR_INPUT + enable : BOOL; + x : REAL; + tv : REAL; + tf : REAL; + END_VAR + VAR_OUTPUT + status : UINT; + y : REAL; + END_VAR + VAR + store1 : {REDUND_UNREPLICABLE} UDINT; + store2 : {REDUND_UNREPLICABLE} UDINT; + timeCnt : {REDUND_UNREPLICABLE} UDINT; + counter_state : UINT; + bootkey_old : {REDUND_UNREPLICABLE} UDINT; + systicks_old : {REDUND_UNREPLICABLE} UDINT; + musecs_old : {REDUND_UNREPLICABLE} UINT; + sysinfo_inst : {REDUND_UNREPLICABLE} SysInfo; + a11 : DINT; + a12 : DINT; + a21 : DINT; + a22 : DINT; + END_VAR +END_FUNCTION_BLOCK + +FUNCTION_BLOCK LCRSlimPID (* PID controller with integrated tuning. *) + VAR_INPUT + enable : BOOL; + W : REAL; + X : REAL; + request : UDINT; + pPar : REFERENCE TO lcrslimpid_par_typ; + END_VAR + VAR_OUTPUT + e : REAL; + Y : REAL; + status : UINT; + addInfo : UINT; + END_VAR + VAR + MovAvgFlt_inst : LCRMovAvgFlt; + PIDTune_inst : LCRPIDTune; + PID_inst : LCRPID; + enable_old : BOOL; + requ_old : UDINT; + END_VAR +END_FUNCTION_BLOCK + +FUNCTION_BLOCK LCRPIDTune (* Automatically determines the control parameters for an LCRPID() instance with different methods. *) + VAR_INPUT + enable : BOOL; + Y_min : REAL; + Y_max : REAL; + Y0 : REAL; + Y1 : REAL; + okToStep : BOOL; + X0 : REAL; + X_min : REAL; + X_max : REAL; + P_manualAdjust : INT; + I_manualAdjust : INT; + D_manualAdjust : INT; + request : UDINT; + pAddPar : REFERENCE TO lcrpid_tune_addpar_typ; + pOptions_osc : REFERENCE TO lcrpid_tune_osc_options_typ; + pOptions_step : REFERENCE TO lcrpid_tune_step_options_typ; + END_VAR + VAR_OUTPUT + status : UINT; + addInfo : UINT; + ident : UDINT; + state : UINT; + rdyToStep : BOOL; + END_VAR + VAR + t_autotune : REAL; + status_tmp : UINT; + counter_state : UINT; + bootkey_old : UDINT; + systicks_old : UDINT; + musecs_old : UINT; + curveDown : BOOL; + e : REAL; + e_minAmp : REAL; + e_old_up : REAL; + e_old_down : REAL; + curveUp : BOOL; + e_old : REAL; + sysinfo_inst : SysInfo; + MovAvgFlt_inst : LCRMovAvgFlt; + old : lcrpid_old_typ; + processPar : lcrpid_procPar_typ; + internal_data : lcrpid_internal_typ; + addPar : lcrpid_tune_addpar_typ; + oscillation : lcrpid_tune_osc_typ; + stepresponse : lcrpid_tune_step_typ; + END_VAR +END_FUNCTION_BLOCK + +FUNCTION_BLOCK LCRPFM (* Pulse frequency modulator. *) + VAR_INPUT + enable : BOOL; + x : REAL; + max_value : REAL; + min_value : REAL; + t_pulse : REAL; + t_pause : REAL; + END_VAR + VAR_OUTPUT + status : UINT; + pulse : BOOL; + END_VAR + VAR + area : REAL; + area_c : REAL; + range : REAL; + last : REAL; + tpls : REAL; + enable_old : BOOL; + counter_state : UINT; + bootkey_old : UDINT; + systicks_old : UDINT; + musecs_old : UINT; + sysinfo_inst : SysInfo; + END_VAR +END_FUNCTION_BLOCK + +FUNCTION_BLOCK LCRSimModExt (* Thermal simulation model of an extruder with heating zones and cooling circulation. *) + VAR_INPUT + enable : BOOL; + Tt_h : DINT; + Tt_c : DINT; + k_h : REAL; + k_c : REAL; + PT2_T1 : REAL; + PT2_T2 : REAL; + Temp_amb : REAL; + Temp_c : REAL; + Alpha_h : REAL; + Alpha_c : REAL; + END_VAR + VAR_OUTPUT + y : REAL; + status : UINT; + END_VAR + VAR + Tt_heat : LCRTt; + Tt_cool : LCRTt; + k_h_intern : REAL; + k_c_intern : REAL; + PT2 : LCRPT2; + y_c : REAL; + y_end : REAL; + y_h : REAL; + Bootkey : UDINT; + enable_old : BOOL; + END_VAR +END_FUNCTION_BLOCK + +{REDUND_OK} FUNCTION_BLOCK LCRTt (* Delay time. *) + VAR_INPUT + enable : BOOL; + Tt : DINT; + x : REAL; + y_set : REAL; + set : BOOL; + END_VAR + VAR_OUTPUT + y : REAL; + status : UINT; + END_VAR + VAR + Ts : DINT; + Tt_Max : DINT; + pRingBuf : {REDUND_UNREPLICABLE} REFERENCE TO REAL; + pBuf_OutIn : {REDUND_UNREPLICABLE} REFERENCE TO REAL; + set_old : USINT; + Set_y : USINT; + enable_old : {REDUND_UNREPLICABLE} BOOL; + Bootkey : {REDUND_UNREPLICABLE} UDINT; + END_VAR +END_FUNCTION_BLOCK + +{REDUND_OK} FUNCTION_BLOCK LCRPT2 (* Second-order delay element. *) + VAR_INPUT + enable : BOOL; + V : REAL; + T1 : REAL; + T2 : REAL; + x : REAL; + y_set : REAL; + set : USINT; + END_VAR + VAR_OUTPUT + y : REAL; + status : UINT; + END_VAR + VAR + x1_dbl_1 : UDINT; + x1_dbl_2 : UDINT; + x2_dbl_1 : UDINT; + x2_dbl_2 : UDINT; + Ts : DINT; + Ts_dbl_1 : UDINT; + Ts_dbl_2 : UDINT; + set_old : USINT; + Set_y : USINT; + Bootkey : {REDUND_UNREPLICABLE} UDINT; + END_VAR +END_FUNCTION_BLOCK + +{REDUND_OK} FUNCTION_BLOCK LCRPT1e (* First-order delay element. *) + VAR_INPUT + enable : BOOL; + V : REAL; + T1 : REAL; + x : REAL; + y_set : REAL; + set : USINT; + END_VAR + VAR_OUTPUT + y : REAL; + status : UINT; + END_VAR + VAR + x1_dbl_1 : UDINT; + x1_dbl_2 : UDINT; + Ts : DINT; + Ts_dbl_1 : UDINT; + Ts_dbl_2 : UDINT; + set_old : USINT; + Set_y : USINT; + Bootkey : {REDUND_UNREPLICABLE} UDINT; + END_VAR +END_FUNCTION_BLOCK + +FUNCTION_BLOCK LCRDblActPID (* PID controller with two outputs for two opposing manipulated variables and integrated tuning. *) + VAR_INPUT + enable : BOOL; + W : REAL; + X : REAL; + Y_man : REAL; + hold_I : BOOL; + mode : USINT; + okToStep : BOOL; + pPar1 : REFERENCE TO lcrdblpid_par_typ; + pPar2 : REFERENCE TO lcrdblpid_par_typ; + pAddPar : REFERENCE TO lcrpid_tune_addpar_typ; + pOpt : REFERENCE TO lcrdblpid_tune_typ; + END_VAR + VAR_OUTPUT + e : REAL; + Y1 : REAL; + Y2 : REAL; + status : UINT; + tuneState : USINT; + rdyToStep : BOOL; + END_VAR + VAR + enable_old : BOOL; + pid : LCRPID; + tune : LCRPIDTune; + sysinfo_inst : SysInfo; + gradient : REAL; + Y_avg : REAL; + tcnt_1 : UDINT; + tcnt_2 : UDINT; + Tmeas : REAL; + y_lim_old : REAL; + p_fact : REAL; + bootkey_old : UDINT; + systicks_old : UDINT; + musecs_old : UINT; + use_par : USINT; + meas : USINT; + mode_old : USINT; + tune_step : USINT; + tune_grad : USINT; + tune_2nd : USINT; + invert : USINT; + counter_state : USINT; + mode_int : USINT; + END_VAR +END_FUNCTION_BLOCK + +{REDUND_OK} FUNCTION_BLOCK LCRMinMax (* Smallest and largest peak value. *) + VAR_INPUT + reset : BOOL; + in : REAL; + END_VAR + VAR_OUTPUT + out_min : REAL; + out_max : REAL; + END_VAR +END_FUNCTION_BLOCK + +FUNCTION_BLOCK LCRTempPID (* PID controller especially for temperature systems. *) + VAR_INPUT + enable : BOOL; + Temp_set : REAL; + Temp : REAL; + Y_man : REAL; + mode : UDINT; + update : BOOL; + pSettings : REFERENCE TO lcrtemp_set_typ; + END_VAR + VAR_OUTPUT + y_heat : REAL; + y_cool : REAL; + status : UINT; + END_VAR + VAR + pid : LCRPID; + pid_para : LCRPIDpara; + Temp_set_delay : REAL; + Temp_set_int : REAL; + TempSetOld : REAL; + delayCnt : REAL; + delayFlag : BOOL; + enable_old : BOOL; + stateOld : SINT; + state : SINT; + a : REAL; + sysinfo_inst : SysInfo; + para_check_done : USINT; + internal_para : lcrtemp_pid_internal_typ; + dbl_dt : REAL; + tAlt : REAL; + altTime : REAL; + tKnick : REAL; + fAlt : REAL; + altActive : BOOL; + a_alt : REAL; + a_e : REAL; + a_internal : REAL; + err_flag : BOOL; + Temp_set_int_old1 : REAL; + Temp_set_int_old2 : REAL; + Temp_set_int_old3 : REAL; + mode_old : UDINT; + timestore1 : UDINT; + timestore2 : UDINT; + yManInternal : REAL; + timeCnt : UDINT; + END_VAR +END_FUNCTION_BLOCK + +FUNCTION_BLOCK LCRTempTune (* Precision tuning process especially for temperature systems. *) + VAR_INPUT + enable : BOOL; + start : BOOL; + Temp_set : REAL; + Temp : REAL; + okToHeat : BOOL; + okToFree : BOOL; + okToFreeEnd : BOOL; + okToCool : BOOL; + okToCoolEnd : BOOL; + pSettings : REFERENCE TO lcrtemp_set_typ; + END_VAR + VAR_OUTPUT + y_heat : REAL; + y_cool : REAL; + rdyToHeat : BOOL; + rdyToFree : BOOL; + rdyToFreeEnd : BOOL; + rdyToCool : BOOL; + rdyToCoolEnd : BOOL; + done : BOOL; + busy : BOOL; + status : UINT; + END_VAR + VAR + enable_old : BOOL; + pid : LCRPID; + pid_para : LCRPIDpara; + DT2 : LCRDifferentiate; + pt2 : LCRPT2o; + Temp_flt : REAL; + step : UINT; + t : REAL; + Temp_start : REAL; + mem00 : REAL; + cnt02 : REAL; + cnt33 : REAL; + cnt20 : REAL; + pem01 : REAL; + pem33 : REAL; + pem10 : REAL; + pem02 : REAL; + pem44 : REAL; + pem20 : REAL; + tol01 : REAL; + tol10 : REAL; + tol02 : REAL; + tol20 : REAL; + tol22 : REAL; + Temp_old : REAL; + delta_Temp : REAL; + tcnt_1 : UDINT; + tcnt_2 : UDINT; + tcnt_dT_1 : UDINT; + tcnt_dT_2 : UDINT; + sysinfo_inst : SysInfo; + Temp_set_internal : REAL; + timecounter : REAL; + internal_para : lcrtemp_tune_internal_typ; + dbl_dt : REAL; + call_counter : UDINT; + store1 : UDINT; + store2 : UDINT; + timeCnt : UDINT; + timer2 : REAL; + waitCounter : UINT; + Y_heat_tune_intern : REAL; + END_VAR +END_FUNCTION_BLOCK + +{REDUND_OK} FUNCTION_BLOCK LCRPT2o (* Oscillating 2nd order delay element. *) + VAR_INPUT + enable : BOOL; + V : REAL; + D : REAL; + Tf : REAL; + u : REAL; + Set_y : USINT; + y_set : REAL; + END_VAR + VAR_OUTPUT + y : REAL; + status : UINT; + END_VAR + VAR + Internal : lcrpt2o_Internal_typ; + END_VAR +END_FUNCTION_BLOCK + +FUNCTION_BLOCK LCRSchedulePWM (* Pulse width modulator for n inputs with a specified power limitation. *) + VAR_INPUT + enable : BOOL; + Pmax : REAL; + n : UINT; + pPar : UDINT; + min_value : REAL; + max_value : REAL; + t_min_pulse : REAL; + t_period : REAL; + END_VAR + VAR_OUTPUT + status : UINT; + END_VAR + VAR + sysinfo_inst : SysInfo; + store1 : UDINT; + store2 : UDINT; + timeCnt : UDINT; + numberUnits : UINT; + limFact : UINT; + enable_old : BOOL; + cmd_delay : BOOL; + err_flag : BOOL; + limAll : BOOL; + Pact : REAL; + Pman : REAL; + intern0 : ARRAY[0..5] OF REAL; + in : REFERENCE TO lcrschedule_par_typ; + END_VAR +END_FUNCTION_BLOCK diff --git a/Logical/Libraries/LoopConR/LoopConR.typ b/Logical/Libraries/LoopConR/LoopConR.typ new file mode 100644 index 0000000..74c20a0 --- /dev/null +++ b/Logical/Libraries/LoopConR/LoopConR.typ @@ -0,0 +1,400 @@ + +TYPE + lcrCurveByPoints_TabEntry_type : STRUCT + x : REAL; + y : REAL; + END_STRUCT; + lcrdblpid_par_typ : STRUCT + Y_max : REAL; + Y_min : REAL; + K_fact : INT; + Kp : REAL; + Tn : REAL; + Tv : REAL; + END_STRUCT; + lcrdblpid_tune_typ : STRUCT + P1_manualAdjust : INT; + I1_manualAdjust : INT; + D1_manualAdjust : INT; + P2_manualAdjust : INT; + I2_manualAdjust : INT; + D2_manualAdjust : INT; + X_min : REAL; + X_max : REAL; + X0 : REAL; + de_min : REAL; + Y0 : REAL; + Y1step : REAL; + Y2step : REAL; + tuneY1_opt : UDINT; + tuneY2_opt : UDINT; + tune_first : USINT; + hyst : REAL; + measDelta : REAL; + osc_opt : lcrpid_tune_osc_options_typ; + step_opt : lcrpid_tune_step_options_typ; + END_STRUCT; + lcrpid_internal_typ : {REDUND_REPLICABLE} STRUCT + size : UINT; + valid : BOOL; + WX_max : REAL; + WX_min : REAL; + invert : BOOL; + deadband : REAL; + deadband_mode : USINT; + dY_max : REAL; + Kp : REAL; + Kp_Tn : REAL; + Tv_Tf : REAL; + Tf_reciproc : REAL; + Kw : REAL; + Kfbk_Kp : REAL; + Kfbk_Kp_max : REAL; + fbk_mode : USINT; + d_mode : USINT; + force_mode : USINT; + Y_force : REAL; + W : REAL; + X : REAL; + pid_init : USINT; + Yp1 : DINT; + Yp2 : DINT; + dYi1 : DINT; + dYi2 : DINT; + Yi1 : DINT; + Yi2 : DINT; + dt_Tf : REAL; + a11 : DINT; + a12 : DINT; + a21 : DINT; + a22 : DINT; + Yd1 : DINT; + Yd2 : DINT; + Ytotal1 : DINT; + Ytotal2 : DINT; + Ylim1 : DINT; + Ylim2 : DINT; + Y1 : DINT; + Y2 : DINT; + deltaY_fbk : REAL; + e_fbk : REAL; + END_STRUCT; + lcrpid_old_typ : STRUCT + processPar : lcrpid_procPar_typ; + P_manualAdjust : INT; + I_manualAdjust : INT; + D_manualAdjust : INT; + Y_min : REAL; + Y_max : REAL; + dY_max : REAL; + Tf_Tv : REAL; + Kw : REAL; + Kfbk : REAL; + deadband : REAL; + W : REAL; + request : UDINT; + fbk_mode : USINT; + d_mode : USINT; + invert : BOOL; + enable : BOOL; + END_STRUCT; + lcrpid_osc_per_typ : STRUCT + max : lcrpid_osc_val_typ; + min : lcrpid_osc_val_typ; + END_STRUCT; + lcrpid_osc_val_typ : STRUCT + X : REAL; + t : REAL; + END_STRUCT; + lcrpid_procPar_typ : STRUCT + size : UINT; + valid : BOOL; + stepResp_valid : BOOL; + stepResp_v : REAL; + stepResp_t_u : REAL; + stepResp_t_g : REAL; + osc_valid : BOOL; + osc_amplitudeRatio : REAL; + osc_tPeriod : REAL; + force_params : BOOL; + Kp : REAL; + Kp_tune : REAL; + Tn : REAL; + Tn_tune : REAL; + Tv : REAL; + Tv_tune : REAL; + END_STRUCT; + lcrpid_tune_addpar_typ : STRUCT + t_max_tune : REAL; + WX_min : REAL; + WX_max : REAL; + dY_max : REAL; + Tf_Tv : REAL; + Kw : REAL; + Kfbk : REAL; + fbk_mode : USINT; + d_mode : USINT; + deadband : REAL; + deadband_mode : USINT; + invert : BOOL; + END_STRUCT; + lcrpid_tune_osc_options_typ : STRUCT + osc_minAmplitude : REAL; + Q_min : REAL; + END_STRUCT; + lcrpid_tune_osc_typ : STRUCT + options : lcrpid_tune_osc_options_typ; + oscPhase : UINT; + dir : SINT; + enHi : BOOL; + enLo : BOOL; + Y_hi : REAL; + Y_lo : REAL; + i_maxPeriod : UINT; + i_period : UINT; + X_ampl : REAL; + X_avg : REAL; + X_min_avg : REAL; + X_max_avg : REAL; + Y_avg : REAL; + deltaY : REAL; + t_Ylohi : ARRAY[0..4] OF REAL; + t_Yhilo : ARRAY[0..4] OF REAL; + Q_act : REAL; + a_wx : REAL; + amplitudeRatio : REAL; + Ku : REAL; + tPeriod : REAL; + period : ARRAY[0..4] OF lcrpid_osc_per_typ; + END_STRUCT; + lcrpid_tune_step_options_typ : STRUCT + eqDeltaX : REAL; + eqDeltaWX : REAL; + eqDeltat : REAL; + evalDeltaX : REAL; + evalNfilter : UINT; + exitNotMaxdXCount : UINT; + exitdXRatio : REAL; + END_STRUCT; + lcrpid_tune_step_typ : STRUCT + options : lcrpid_tune_step_options_typ; + Y0 : REAL; + Y1 : REAL; + t_jump : REAL; + W : REAL; + X0 : REAL; + Xmax : REAL; + Xmin : REAL; + Xfiltered : REAL; + deltaXok : BOOL; + deltaWXok : BOOL; + eqTime : REAL; + dir : SINT; + deltaX : REAL; + X1 : REAL; + t1 : REAL; + t1set : BOOL; + dX_dt : REAL; + dX_dt_max : REAL; + XmaxGrad : REAL; + maxX1 : REAL; + maxX2 : REAL; + maxt1 : REAL; + maxt2 : REAL; + tmaxGrad : REAL; + gainFactor : REAL; + deadTime : REAL; + riseTime : REAL; + notMaxCount : UINT; + gradientRatio : REAL; + END_STRUCT; + lcrpt2o_Internal_typ : STRUCT + Ts : DINT; + Ts_dbl_1 : UDINT; + Ts_dbl_2 : UDINT; + V_old : REAL; + D_old : REAL; + Tf_old : REAL; + Set_y_old : USINT; + Set_y_2 : USINT; + x1_dbl_1 : UDINT; + x1_dbl_2 : UDINT; + x2_dbl_1 : UDINT; + x2_dbl_2 : UDINT; + Sqrt_D_1_dbl_1 : UDINT; + Sqrt_D_1_dbl_2 : UDINT; + Ts_Tf_dbl_1 : UDINT; + Ts_Tf_dbl_2 : UDINT; + Exp_D_Ts_Tf_dbl_1 : UDINT; + Exp_D_Ts_Tf_dbl_2 : UDINT; + a0_dbl_1 : UDINT; + a0_dbl_2 : UDINT; + a1_dbl_1 : UDINT; + a1_dbl_2 : UDINT; + b0_dbl_1 : UDINT; + b0_dbl_2 : UDINT; + b1_dbl_1 : UDINT; + b1_dbl_2 : UDINT; + Bootkey : {REDUND_UNREPLICABLE} UDINT; + END_STRUCT; + lcrschedule_add_typ : STRUCT + periodTime : REAL; + onTime : REAL; + t_on_intern : REAL; + bcOnTime : REAL; + sortIndex : UINT; + fbkPWM : LCRPWM; + flagDelay : BOOL; + END_STRUCT; + lcrschedule_par_typ : STRUCT + P : REAL; + X : REAL; + pulse : BOOL; + Pout : REAL; + lim : BOOL; + Internal : lcrschedule_add_typ; + END_STRUCT; + lcrslimpid_par_typ : STRUCT + Y_max : REAL; + Y_min : REAL; + Kp : REAL; + Tn : REAL; + Tv : REAL; + Kfbk : REAL; + END_STRUCT; + lcrtemp_add_typ : STRUCT + mem01 : REAL; + mem02 : REAL; + mem10 : REAL; + mem20 : REAL; + exp_mem : REAL; + cnt01 : REAL; + cnt02 : REAL; + cnt10 : REAL; + cnt20 : REAL; + cnt03 : REAL; + cnt30 : REAL; + cnt00 : REAL; + t_ignore_dT_heat : REAL; + t_ignore_dT_free : REAL; + t_ignore_dT_cool : REAL; + yMin : REAL; + yMax : REAL; + reserved3 : UDINT; + reserved4 : UDINT; + reserved5 : BOOL; + reserved6 : BOOL; + END_STRUCT; + lcrtemp_pid_internal_typ : STRUCT + enable_cooling : BOOL; + disable_heating : BOOL; + hyst : REAL; + delay : REAL; + Kw : REAL; + Kfbk : REAL; + Kp_h : REAL; + Tn_h : REAL; + Tv_h : REAL; + Kp_c : REAL; + Tn_c : REAL; + Tv_c : REAL; + dynGeneral : REAL; + dynHeat : REAL; + dynCool : REAL; + mem01 : REAL; + mem02 : REAL; + mem10 : REAL; + mem20 : REAL; + exp_mem : REAL; + yMin : REAL; + yMax : REAL; + END_STRUCT; + lcrtemp_pid_opt_typ : STRUCT + Kp_h : REAL; + Tn_h : REAL; + Tv_h : REAL; + Tf_h : REAL; + Kp_c : REAL; + Tn_c : REAL; + Tv_c : REAL; + Tf_c : REAL; + dynGeneral : REAL; + dynHeat : REAL; + dynCool : REAL; + END_STRUCT; + lcrtemp_pid_set_typ : STRUCT + hyst : REAL; + hyst_mode : USINT; + delay : REAL; + Kw : REAL; + Kfbk : REAL; + END_STRUCT; + lcrtemp_set_typ : STRUCT + enable_cooling : BOOL; + disable_heating : BOOL; + PIDpara : lcrtemp_pid_opt_typ; + TuneSet : lcrtemp_tune_set_typ; + PIDSet : lcrtemp_pid_set_typ; + Internal : lcrtemp_add_typ; + END_STRUCT; + lcrtemp_tune_internal_typ : STRUCT + cool_tuning : BOOL; + disable_heating : BOOL; + mode : UDINT; + Temp_amb : REAL; + dRatio_heat : REAL; + cnt_tp_heat : REAL; + delta_T_heat : REAL; + dT_min_heat : REAL; + dRatio_free : REAL; + cnt_tp_free : REAL; + delta_T_free : REAL; + dT_min_free : REAL; + dRatio_cool : REAL; + cnt_tp_cool : REAL; + delta_T_cool : REAL; + dT_min_cool : REAL; + delta_T_sync_heat : REAL; + delta_dT_sync_heat : REAL; + cnt_wait_heat : REAL; + delta_T_sync_free : REAL; + delta_dT_sync_free : REAL; + cnt_wait_free : REAL; + delta_T_sync_cool : REAL; + delta_dT_sync_cool : REAL; + cnt_wait_cool : REAL; + filter_base_T : REAL; + t_ignore_dT_heat : REAL; + t_ignore_dT_free : REAL; + t_ignore_dT_cool : REAL; + delta_T_sync_stop : REAL; + END_STRUCT; + lcrtemp_tune_set_typ : STRUCT + mode : UDINT; + Temp_amb : REAL; + dRatio_heat : REAL; + cnt_tp_heat : REAL; + delta_T_heat : REAL; + dT_min_heat : REAL; + dRatio_free : REAL; + cnt_tp_free : REAL; + delta_T_free : REAL; + dT_min_free : REAL; + dRatio_cool : REAL; + cnt_tp_cool : REAL; + delta_T_cool : REAL; + dT_min_cool : REAL; + delta_T_sync_heat : REAL; + delta_dT_sync_heat : REAL; + cnt_wait_heat : REAL; + delta_T_sync_free : REAL; + delta_dT_sync_free : REAL; + cnt_wait_free : REAL; + delta_T_sync_cool : REAL; + delta_dT_sync_cool : REAL; + cnt_wait_cool : REAL; + filter_base_T : REAL; + delta_T_sync_stop : REAL; + Y_heat_tune : REAL; + END_STRUCT; +END_TYPE diff --git a/Logical/Libraries/LoopConR/LoopConR.var b/Logical/Libraries/LoopConR/LoopConR.var new file mode 100644 index 0000000..788a286 --- /dev/null +++ b/Logical/Libraries/LoopConR/LoopConR.var @@ -0,0 +1,192 @@ +VAR CONSTANT + LCRPID_DEADBAND_MODE_ZERO : USINT := 0; + LCRTEMP_HEAT : USINT := 0; + LCRPID_MODE_OFF : USINT := 0; + LCRPID_TUNE_STATE_READY : UINT := 0; + LCRSLIMPID_REQU_OFF : UDINT := 0; + LCRTEMP_PT1 : USINT := 0; + LCRTEMPTune_MODE_DEF : UDINT := 0; + LCRDBLPID_TSTATE_OFF : USINT := 0; + LCRPID_TUNE_REQU_OFF : UDINT := 0; + LCRTEMPTune_MODE_EXP : UDINT := 1; + LCRPID_MODE_AUTO : USINT := 1; + LCRPID_D_MODE_X : USINT := 1; + LCRPID_DEADBAND_MODE_STANDARD : USINT := 1; + LCRPID_FBK_MODE_INTERN : USINT := 1; + LCRDBLPID_TSTATE_Y1 : USINT := 1; + LCRPID_TUNE_REQU_OSCILLATE : UDINT := 1; + LCRTEMPPID_MODE_AUTO : UDINT := 1; + LCRTEMP_HYST_MODE_JOLTFREE : USINT := 1; + LCRTEMP_PT2 : USINT := 1; + LCRTEMP_COOL : USINT := 1; + LCRSLIMPID_REQU_OSCILLATE : UDINT := 1; + LCRPID_DEADBAND_MODE_STANDARD_I : USINT := 2; + LCRTEMPPID_MODE_MAN : UDINT := 2; + LCRDBLPID_TSTATE_Y2 : USINT := 2; + LCRPID_D_MODE_E : USINT := 2; + LCRSLIMPID_REQU_STEPRESPONSE : UDINT := 2; + LCRPID_MODE_MAN : USINT := 2; + LCRPID_FBK_MODE_EXTERN : USINT := 2; + LCRPID_TUNE_REQU_STEPRESPONSE : UDINT := 2; + LCRPID_MODE_OPEN : USINT := 3; + LCRDBLPID_TSTATE_FINISHED : USINT := 3; + LCRSLIMPID_REQU_READ_PARAS : UDINT := 3; + LCRPID_FBK_MODE_EXT_SELECTOR : USINT := 3; + LCRDBLPID_TSTATE_ERROR : USINT := 4; + LCRPID_FBK_MODE_LIMIT_YI : USINT := 4; + LCRPID_MODE_CLOSE : USINT := 4; + LCRSLIMPID_REQU_WRITE_PARAS : UDINT := 4; + LCRTEMP_STEP_WAIT : UINT := 5; + LCRPID_MODE_FREEZE : USINT := 5; + LCRPID_FBK_MODE_SET_YI : USINT := 5; + LCRDBLPID_MODE_TUNE_4 : USINT := 6; + LCRDBLPID_MODE_TUNE_6 : USINT := 7; + LCRDBLPID_MODE_TUNE_Y1 : USINT := 8; + LCRDBLPID_MODE_TUNE_Y2 : USINT := 9; + LCRPID_TUNE_REQU_DIR_POS : UDINT := 10; + LCRPID_TUNE_STATE_OSCILLATE : UINT := 10; + LCRSLIMPID_REQU_DIR_POS : UDINT := 10; + LCRTEMP_STEP_WAIT_HEAT : UINT := 10; + LCRPID_TUNE_STATE_OSC_SEQ_CNTL : UINT := 11; + LCRPID_TUNE_STATE_OSC_PERFORM_1 : UINT := 12; + LCRPID_TUNE_STATE_OSC_PERFORM_2 : UINT := 13; + LCRPID_TUNE_STATE_OSC_CNTLPAR : UINT := 19; + LCRPID_TUNE_REQU_DIR_NEG : UDINT := 20; + LCRPID_TUNE_STATE_STEP_WAITEQ1 : UINT := 20; + LCRTEMP_STEP_START_HEAT : UINT := 20; + LCRSLIMPID_REQU_DIR_NEG : UDINT := 20; + LCRPID_TUNE_STATE_STEP_MAXGRAD : UINT := 21; + LCRPID_TUNE_STATE_STEP_WAITEQ2 : UINT := 22; + LCRTEMP_STEP_HEAT : UINT := 30; + LCRTEMP_STEP_PID_FREE : UINT := 40; + LCRPID_TUNE_STATE_CALC_PARA : UINT := 45; + LCRPID_TUNE_STATE_RESET_CNTL : UINT := 49; + LCRPID_TUNE_STATE_FINISHED : UINT := 50; + LCRTEMP_STEP_WAIT_FREE : UINT := 50; + LCRTEMP_STEP_START_FREE : UINT := 60; + LCRTEMP_STEP_FREE : UINT := 70; + LCRTEMP_STEP_PID : UINT := 80; + LCRTEMP_STEP_PID_COOL : UINT := 90; + LCRSLIMPID_REQU_PID : UDINT := 100; + LCRPID_TUNE_REQU_PID : UDINT := 100; + LCRTEMP_STEP_WAIT_COOL : UINT := 100; + LCRPID_MODE_MAN_JOLTFREE : USINT := 102; + LCRPID_MODE_OPEN_JOLTFREE : USINT := 103; + LCRPID_MODE_CLOSE_JOLTFREE : USINT := 104; + LCRPID_MODE_FREEZE_JOLTFREE : USINT := 105; + LCRTEMP_STEP_WAIT_COOLONLY : UINT := 105; + LCRTEMP_STEP_START_COOL : UINT := 110; + LCRPID_TUNE_ADDINFO_OSC_PERIOD : UINT := 111; + LCRTEMP_STEP_COOL : UINT := 120; + LCRTEMP_STEP_PID_DONE_COOLONLY : UINT := 122; + LCRTEMP_STEP_PID_DONE : UINT := 125; + LCRTEMP_STEP_DONE : UINT := 130; + LCRPID_TUNE_REQU_PI : UDINT := 200; + LCRSLIMPID_REQU_PI : UDINT := 200; + LCRPID_TUNE_REQU_P : UDINT := 300; + LCRSLIMPID_REQU_P : UDINT := 300; + LCRSLIMPID_REQU_CHR_DIST_AP : UDINT := 1000; + LCRPID_TUNE_REQU_CHR_DIST_AP : UDINT := 1000; + LCRSLIMPID_REQU_CHR_DIST_OS : UDINT := 2000; + LCRPID_TUNE_REQU_CHR_DIST_OS : UDINT := 2000; + LCRSLIMPID_REQU_ZN_DIST : UDINT := 3000; + LCRPID_TUNE_REQU_ZN_DIST : UDINT := 3000; + LCRPID_TUNE_REQU_CHR_REF_AP : UDINT := 4000; + LCRSLIMPID_REQU_CHR_REF_AP : UDINT := 4000; + LCRPID_TUNE_REQU_CHR_REF_OS : UDINT := 5000; + LCRSLIMPID_REQU_CHR_REF_OS : UDINT := 5000; + LCRPID_TUNE_REQU_OSC_1 : UDINT := 10000; + LCRSLIMPID_REQU_OSC_1 : UDINT := 10000; + LCR_WARN_LCRPID_I_MAXLIMIT : UINT := 12001; + LCR_WARN_LCRPID_I_MINLIMIT : UINT := 12002; + LCR_WARN_LCRPID_YFBK_LIMIT : UINT := 12003; + LCR_WARN_LCRPIDTune_CYCLETIME : UINT := 12004; + LCR_WARN_LCRPT12_T1_ZERO : UINT := 12005; + LCR_WARN_Tx_DT : UINT := 12007; + LCR_WARN_LCRPID_A_LIMIT : UINT := 12008; + LCR_WARN_LCRPID_YMAN_LIMIT : UINT := 12009; + LCR_WARN_LCRPT12_T1_TS : UINT := 12010; + LCR_WARN_LCRPT12_T1_INT : UINT := 12011; + LCR_WARN_LCRPT12_T2_ZERO : UINT := 12012; + LCR_WARN_LCRPT12_T2_TS : UINT := 12013; + LCR_WARN_LCRPT12_T2_INT : UINT := 12014; + LCR_WARN_LCRTT_TT_ZERO : UINT := 12015; + LCR_WARN_LCRTT_TT_TS : UINT := 12016; + LCR_WARN_LCRTT_TT_INT : UINT := 12017; + LCR_WARN_LCRTT_MEM : UINT := 12018; + LCR_WARN_LCRDBLPID_TUNE_CHANGE : UINT := 12019; + LCR_WARN_LCRTEMPTune_HEAT_TP : UINT := 12021; + LCR_WARN_LCRTEMPTune_WR_PARA : UINT := 12022; + LCR_WARN_LCRTEMPTune_WR_BASE : UINT := 12023; + LCR_WARN_LCRTEMPPID_WR_PARA : UINT := 12024; + LCR_ERR_LCRPID_PAR_KFBK : UINT := 12025; + LCR_ERROR : UINT := 12025; + LCR_ERR_LCRPID_PAR_KP : UINT := 12026; + LCR_ERR_LCRPID_PAR_KW : UINT := 12027; + LCR_ERR_LCRPID_PAR_TF : UINT := 12028; + LCR_ERR_LCRPID_PAR_TN : UINT := 12029; + LCR_ERR_LCRPID_PAR_TV : UINT := 12030; + LCR_ERR_LCRPT1_T : UINT := 12031; + LCR_ERR_LCRPWM_TMINPULSE : UINT := 12032; + LCR_ERR_LCRPWM_TPULSE : UINT := 12033; + LCR_ERR_LCRPWM_TPERIOD : UINT := 12033; + LCR_ERR_LCRRamp_DYUP_DYDOWN : UINT := 12034; + LCR_ERR_LCRContinServo_TCHANGE : UINT := 12035; + LCR_ERR_LCRContinServo_TIMPULSE : UINT := 12036; + LCR_ERR_MAXMIN : UINT := 12037; + LCR_ERR_LCRPIDTune_ABORT : UINT := 12038; + LCR_ERR_LCRPIDTune_PARAMETER : UINT := 12039; + LCR_ERR_LCRPIDTune_TIMEOUT : UINT := 12040; + LCR_ERR_LCRPIDTune_W_CHANGED : UINT := 12041; + LCR_ERR_LCRPID_PAR_DEADBAND_MODE : UINT := 12042; + LCR_ERR_LCRPID_PAR_WX_MAXMIN : UINT := 12043; + LCR_ERR_LCRPID_PAR_DEADBAND : UINT := 12044; + LCR_ERR_LCRCurveByPoints_TABLE : UINT := 12045; + LCR_ERR_LCRPT12_T1_NEG : UINT := 12046; + LCR_ERR_LCRPT12_T2_NEG : UINT := 12047; + LCR_ERR_LCRTT_TT_NEG : UINT := 12048; + LCRSLIMPID_REQU_OSC_2 : UDINT := 20000; + LCRPID_TUNE_REQU_OSC_2 : UDINT := 20000; + LCRSLIMPID_REQU_OSC_3 : UDINT := 30000; + LCRPID_TUNE_REQU_OSC_3 : UDINT := 30000; + LCR_ERR_LCRIntegrate_TN : UINT := 31550; + LCR_ERR_LCRMovAvgFlt_BASE : UINT := 31551; + LCR_ERR_LCRPID_IDENT : UINT := 31552; + LCR_ERR_LCRPID_MODE : UINT := 31553; + LCR_ERR_LCRPID_PARADAT : UINT := 31554; + LCR_ERR_LCRPID_PAR_DMODE : UINT := 31556; + LCR_ERR_LCRPID_PAR_DYMAX : UINT := 31557; + LCR_ERR_LCRPID_PAR_FBKMODE : UINT := 31558; + LCR_ERR_LCRPIDTune_INVALID_REQU : UINT := 31559; + LCR_ERR_LCRPIDTune_CONTROL_VAR : UINT := 31560; + LCR_ERR_LCRDBLPID_WX_LOW : UINT := 31561; + LCR_ERR_LCRDBLPID_DX_DT : UINT := 31562; + LCR_ERR_POINTER : UINT := 31563; + LCR_ERR_LCRPIDTune_MAXMIN : UINT := 31564; + LCR_ERR_LCRTEMPTune_WR_PTR : UINT := 31566; + LCR_ERR_LCRTEMPTune_WR_TSET : UINT := 31567; + LCR_ERR_LCRTEMPPID_WR_PARA : UINT := 31567; + LCR_ERR_LCRTEMPPID_WR_PTR : UINT := 31568; + LCR_ERR_LCRTEMPPID_ILLEGALMODE : UINT := 31569; + LCR_ERR_LCRTEMPTune_TASKTIME_0 : UINT := 31570; + LCR_ERR_LCRTEMPPID_TKNICK : UINT := 31571; + LCR_ERR_LCRTEMPPID_NO_TALT : UINT := 31572; + LCR_ERR_SCHEDULE_P : UINT := 31573; + LCR_ERR_SCHEDULE_N : UINT := 31574; + LCR_WARN_LCRTEMPTune_DT_HIGH : UINT := 33100; + LCR_WARN_LCRTEMPTune_ASYNC : UINT := 33101; + LCR_WARN_PT2O_TF_TS : UINT := 33102; + LCR_ERR_LCRTEMPTune_INVALID_MODE : UINT := 33150; + LCR_ERR_LCRTEMPPID_INVALID_MODE : UINT := 33151; + LCR_ERR_LCRTEMPTune_DT_IGNORED : UINT := 33152; + LCR_ERR_PT2O_D_NEG : UINT := 33153; + LCR_ERR_PT2O_TF_NEG_ZERO : UINT := 33154; + LCR_ERR_DISABLED : UINT := 65534; + LCRTEMP_STEP_ERROR : UINT := 65535; + LCRSLIMPID_REQU_PER_3 : UDINT := 300000; + LCRPID_TUNE_REQU_PER_3 : UDINT := 300000; + LCRPID_TUNE_REQU_PER_4 : UDINT := 400000; + LCRSLIMPID_REQU_PER_4 : UDINT := 400000; + LCRSLIMPID_REQU_PER_5 : UDINT := 500000; + LCRPID_TUNE_REQU_PER_5 : UDINT := 500000; +END_VAR diff --git a/Logical/Libraries/LoopConR/SG3/LoopConR.h b/Logical/Libraries/LoopConR/SG3/LoopConR.h new file mode 100644 index 0000000..e88fcf4 --- /dev/null +++ b/Logical/Libraries/LoopConR/SG3/LoopConR.h @@ -0,0 +1,1677 @@ +/* Automation Studio generated header file */ +/* Do not edit ! */ +/* LoopConR 4.10.2 */ + +#ifndef _LOOPCONR_ +#define _LOOPCONR_ +#ifdef __cplusplus +extern "C" +{ +#endif +#ifndef _LoopConR_VERSION +#define _LoopConR_VERSION 4.10.2 +#endif + +#include + +#ifndef _BUR_PUBLIC +#define _BUR_PUBLIC +#endif +#ifdef _SG4 + #include "sys_lib.h" + #include "brsystem.h" +#endif +#ifdef _SG3 + #include "sys_lib.h" + #include "brsystem.h" +#endif +#ifdef _SGC + #include "sys_lib.h" + #include "brsystem.h" +#endif + +/* Constants */ +#ifdef _REPLACE_CONST + #define LCRPID_TUNE_REQU_PER_5 500000U + #define LCRSLIMPID_REQU_PER_5 500000U + #define LCRSLIMPID_REQU_PER_4 400000U + #define LCRPID_TUNE_REQU_PER_4 400000U + #define LCRPID_TUNE_REQU_PER_3 300000U + #define LCRSLIMPID_REQU_PER_3 300000U + #define LCRTEMP_STEP_ERROR 65535U + #define LCR_ERR_DISABLED 65534U + #define LCR_ERR_PT2O_TF_NEG_ZERO 33154U + #define LCR_ERR_PT2O_D_NEG 33153U + #define LCR_ERR_LCRTEMPTune_DT_IGNORED 33152U + #define LCR_ERR_LCRTEMPPID_INVALID_MODE 33151U + #define LCR_ERR_LCRTEMPTune_INVALID_MODE 33150U + #define LCR_WARN_PT2O_TF_TS 33102U + #define LCR_WARN_LCRTEMPTune_ASYNC 33101U + #define LCR_WARN_LCRTEMPTune_DT_HIGH 33100U + #define LCR_ERR_SCHEDULE_N 31574U + #define LCR_ERR_SCHEDULE_P 31573U + #define LCR_ERR_LCRTEMPPID_NO_TALT 31572U + #define LCR_ERR_LCRTEMPPID_TKNICK 31571U + #define LCR_ERR_LCRTEMPTune_TASKTIME_0 31570U + #define LCR_ERR_LCRTEMPPID_ILLEGALMODE 31569U + #define LCR_ERR_LCRTEMPPID_WR_PTR 31568U + #define LCR_ERR_LCRTEMPPID_WR_PARA 31567U + #define LCR_ERR_LCRTEMPTune_WR_TSET 31567U + #define LCR_ERR_LCRTEMPTune_WR_PTR 31566U + #define LCR_ERR_LCRPIDTune_MAXMIN 31564U + #define LCR_ERR_POINTER 31563U + #define LCR_ERR_LCRDBLPID_DX_DT 31562U + #define LCR_ERR_LCRDBLPID_WX_LOW 31561U + #define LCR_ERR_LCRPIDTune_CONTROL_VAR 31560U + #define LCR_ERR_LCRPIDTune_INVALID_REQU 31559U + #define LCR_ERR_LCRPID_PAR_FBKMODE 31558U + #define LCR_ERR_LCRPID_PAR_DYMAX 31557U + #define LCR_ERR_LCRPID_PAR_DMODE 31556U + #define LCR_ERR_LCRPID_PARADAT 31554U + #define LCR_ERR_LCRPID_MODE 31553U + #define LCR_ERR_LCRPID_IDENT 31552U + #define LCR_ERR_LCRMovAvgFlt_BASE 31551U + #define LCR_ERR_LCRIntegrate_TN 31550U + #define LCRPID_TUNE_REQU_OSC_3 30000U + #define LCRSLIMPID_REQU_OSC_3 30000U + #define LCRPID_TUNE_REQU_OSC_2 20000U + #define LCRSLIMPID_REQU_OSC_2 20000U + #define LCR_ERR_LCRTT_TT_NEG 12048U + #define LCR_ERR_LCRPT12_T2_NEG 12047U + #define LCR_ERR_LCRPT12_T1_NEG 12046U + #define LCR_ERR_LCRCurveByPoints_TABLE 12045U + #define LCR_ERR_LCRPID_PAR_DEADBAND 12044U + #define LCR_ERR_LCRPID_PAR_WX_MAXMIN 12043U + #define LCR_ERR_LCRPID_PAR_DEADBAND_MODE 12042U + #define LCR_ERR_LCRPIDTune_W_CHANGED 12041U + #define LCR_ERR_LCRPIDTune_TIMEOUT 12040U + #define LCR_ERR_LCRPIDTune_PARAMETER 12039U + #define LCR_ERR_LCRPIDTune_ABORT 12038U + #define LCR_ERR_MAXMIN 12037U + #define LCR_ERR_LCRContinServo_TIMPULSE 12036U + #define LCR_ERR_LCRContinServo_TCHANGE 12035U + #define LCR_ERR_LCRRamp_DYUP_DYDOWN 12034U + #define LCR_ERR_LCRPWM_TPERIOD 12033U + #define LCR_ERR_LCRPWM_TPULSE 12033U + #define LCR_ERR_LCRPWM_TMINPULSE 12032U + #define LCR_ERR_LCRPT1_T 12031U + #define LCR_ERR_LCRPID_PAR_TV 12030U + #define LCR_ERR_LCRPID_PAR_TN 12029U + #define LCR_ERR_LCRPID_PAR_TF 12028U + #define LCR_ERR_LCRPID_PAR_KW 12027U + #define LCR_ERR_LCRPID_PAR_KP 12026U + #define LCR_ERROR 12025U + #define LCR_ERR_LCRPID_PAR_KFBK 12025U + #define LCR_WARN_LCRTEMPPID_WR_PARA 12024U + #define LCR_WARN_LCRTEMPTune_WR_BASE 12023U + #define LCR_WARN_LCRTEMPTune_WR_PARA 12022U + #define LCR_WARN_LCRTEMPTune_HEAT_TP 12021U + #define LCR_WARN_LCRDBLPID_TUNE_CHANGE 12019U + #define LCR_WARN_LCRTT_MEM 12018U + #define LCR_WARN_LCRTT_TT_INT 12017U + #define LCR_WARN_LCRTT_TT_TS 12016U + #define LCR_WARN_LCRTT_TT_ZERO 12015U + #define LCR_WARN_LCRPT12_T2_INT 12014U + #define LCR_WARN_LCRPT12_T2_TS 12013U + #define LCR_WARN_LCRPT12_T2_ZERO 12012U + #define LCR_WARN_LCRPT12_T1_INT 12011U + #define LCR_WARN_LCRPT12_T1_TS 12010U + #define LCR_WARN_LCRPID_YMAN_LIMIT 12009U + #define LCR_WARN_LCRPID_A_LIMIT 12008U + #define LCR_WARN_Tx_DT 12007U + #define LCR_WARN_LCRPT12_T1_ZERO 12005U + #define LCR_WARN_LCRPIDTune_CYCLETIME 12004U + #define LCR_WARN_LCRPID_YFBK_LIMIT 12003U + #define LCR_WARN_LCRPID_I_MINLIMIT 12002U + #define LCR_WARN_LCRPID_I_MAXLIMIT 12001U + #define LCRSLIMPID_REQU_OSC_1 10000U + #define LCRPID_TUNE_REQU_OSC_1 10000U + #define LCRSLIMPID_REQU_CHR_REF_OS 5000U + #define LCRPID_TUNE_REQU_CHR_REF_OS 5000U + #define LCRSLIMPID_REQU_CHR_REF_AP 4000U + #define LCRPID_TUNE_REQU_CHR_REF_AP 4000U + #define LCRPID_TUNE_REQU_ZN_DIST 3000U + #define LCRSLIMPID_REQU_ZN_DIST 3000U + #define LCRPID_TUNE_REQU_CHR_DIST_OS 2000U + #define LCRSLIMPID_REQU_CHR_DIST_OS 2000U + #define LCRPID_TUNE_REQU_CHR_DIST_AP 1000U + #define LCRSLIMPID_REQU_CHR_DIST_AP 1000U + #define LCRSLIMPID_REQU_P 300U + #define LCRPID_TUNE_REQU_P 300U + #define LCRSLIMPID_REQU_PI 200U + #define LCRPID_TUNE_REQU_PI 200U + #define LCRTEMP_STEP_DONE 130U + #define LCRTEMP_STEP_PID_DONE 125U + #define LCRTEMP_STEP_PID_DONE_COOLONLY 122U + #define LCRTEMP_STEP_COOL 120U + #define LCRPID_TUNE_ADDINFO_OSC_PERIOD 111U + #define LCRTEMP_STEP_START_COOL 110U + #define LCRTEMP_STEP_WAIT_COOLONLY 105U + #define LCRPID_MODE_FREEZE_JOLTFREE 105U + #define LCRPID_MODE_CLOSE_JOLTFREE 104U + #define LCRPID_MODE_OPEN_JOLTFREE 103U + #define LCRPID_MODE_MAN_JOLTFREE 102U + #define LCRTEMP_STEP_WAIT_COOL 100U + #define LCRPID_TUNE_REQU_PID 100U + #define LCRSLIMPID_REQU_PID 100U + #define LCRTEMP_STEP_PID_COOL 90U + #define LCRTEMP_STEP_PID 80U + #define LCRTEMP_STEP_FREE 70U + #define LCRTEMP_STEP_START_FREE 60U + #define LCRTEMP_STEP_WAIT_FREE 50U + #define LCRPID_TUNE_STATE_FINISHED 50U + #define LCRPID_TUNE_STATE_RESET_CNTL 49U + #define LCRPID_TUNE_STATE_CALC_PARA 45U + #define LCRTEMP_STEP_PID_FREE 40U + #define LCRTEMP_STEP_HEAT 30U + #define LCRPID_TUNE_STATE_STEP_WAITEQ2 22U + #define LCRPID_TUNE_STATE_STEP_MAXGRAD 21U + #define LCRSLIMPID_REQU_DIR_NEG 20U + #define LCRTEMP_STEP_START_HEAT 20U + #define LCRPID_TUNE_STATE_STEP_WAITEQ1 20U + #define LCRPID_TUNE_REQU_DIR_NEG 20U + #define LCRPID_TUNE_STATE_OSC_CNTLPAR 19U + #define LCRPID_TUNE_STATE_OSC_PERFORM_2 13U + #define LCRPID_TUNE_STATE_OSC_PERFORM_1 12U + #define LCRPID_TUNE_STATE_OSC_SEQ_CNTL 11U + #define LCRTEMP_STEP_WAIT_HEAT 10U + #define LCRSLIMPID_REQU_DIR_POS 10U + #define LCRPID_TUNE_STATE_OSCILLATE 10U + #define LCRPID_TUNE_REQU_DIR_POS 10U + #define LCRDBLPID_MODE_TUNE_Y2 9U + #define LCRDBLPID_MODE_TUNE_Y1 8U + #define LCRDBLPID_MODE_TUNE_6 7U + #define LCRDBLPID_MODE_TUNE_4 6U + #define LCRPID_FBK_MODE_SET_YI 5U + #define LCRPID_MODE_FREEZE 5U + #define LCRTEMP_STEP_WAIT 5U + #define LCRSLIMPID_REQU_WRITE_PARAS 4U + #define LCRPID_MODE_CLOSE 4U + #define LCRPID_FBK_MODE_LIMIT_YI 4U + #define LCRDBLPID_TSTATE_ERROR 4U + #define LCRPID_FBK_MODE_EXT_SELECTOR 3U + #define LCRSLIMPID_REQU_READ_PARAS 3U + #define LCRDBLPID_TSTATE_FINISHED 3U + #define LCRPID_MODE_OPEN 3U + #define LCRPID_TUNE_REQU_STEPRESPONSE 2U + #define LCRPID_FBK_MODE_EXTERN 2U + #define LCRPID_MODE_MAN 2U + #define LCRSLIMPID_REQU_STEPRESPONSE 2U + #define LCRPID_D_MODE_E 2U + #define LCRDBLPID_TSTATE_Y2 2U + #define LCRTEMPPID_MODE_MAN 2U + #define LCRPID_DEADBAND_MODE_STANDARD_I 2U + #define LCRSLIMPID_REQU_OSCILLATE 1U + #define LCRTEMP_COOL 1U + #define LCRTEMP_PT2 1U + #define LCRTEMP_HYST_MODE_JOLTFREE 1U + #define LCRTEMPPID_MODE_AUTO 1U + #define LCRPID_TUNE_REQU_OSCILLATE 1U + #define LCRDBLPID_TSTATE_Y1 1U + #define LCRPID_FBK_MODE_INTERN 1U + #define LCRPID_DEADBAND_MODE_STANDARD 1U + #define LCRPID_D_MODE_X 1U + #define LCRPID_MODE_AUTO 1U + #define LCRTEMPTune_MODE_EXP 1U + #define LCRPID_TUNE_REQU_OFF 0U + #define LCRDBLPID_TSTATE_OFF 0U + #define LCRTEMPTune_MODE_DEF 0U + #define LCRTEMP_PT1 0U + #define LCRSLIMPID_REQU_OFF 0U + #define LCRPID_TUNE_STATE_READY 0U + #define LCRPID_MODE_OFF 0U + #define LCRTEMP_HEAT 0U + #define LCRPID_DEADBAND_MODE_ZERO 0U +#else + #ifndef _GLOBAL_CONST + #define _GLOBAL_CONST _WEAK const + #endif + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PER_5; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PER_5; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PER_4; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PER_4; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PER_3; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PER_3; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_ERROR; + _GLOBAL_CONST unsigned short LCR_ERR_DISABLED; + _GLOBAL_CONST unsigned short LCR_ERR_PT2O_TF_NEG_ZERO; + _GLOBAL_CONST unsigned short LCR_ERR_PT2O_D_NEG; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_DT_IGNORED; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_INVALID_MODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_INVALID_MODE; + _GLOBAL_CONST unsigned short LCR_WARN_PT2O_TF_TS; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_ASYNC; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_DT_HIGH; + _GLOBAL_CONST unsigned short LCR_ERR_SCHEDULE_N; + _GLOBAL_CONST unsigned short LCR_ERR_SCHEDULE_P; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_NO_TALT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_TKNICK; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_TASKTIME_0; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_ILLEGALMODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_WR_PTR; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_WR_PARA; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_WR_TSET; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_WR_PTR; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_MAXMIN; + _GLOBAL_CONST unsigned short LCR_ERR_POINTER; + _GLOBAL_CONST unsigned short LCR_ERR_LCRDBLPID_DX_DT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRDBLPID_WX_LOW; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_CONTROL_VAR; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_INVALID_REQU; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_FBKMODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_DYMAX; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_DMODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PARADAT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_MODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_IDENT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRMovAvgFlt_BASE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRIntegrate_TN; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OSC_3; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OSC_3; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OSC_2; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OSC_2; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTT_TT_NEG; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPT12_T2_NEG; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPT12_T1_NEG; + _GLOBAL_CONST unsigned short LCR_ERR_LCRCurveByPoints_TABLE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_DEADBAND; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_WX_MAXMIN; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_DEADBAND_MODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_W_CHANGED; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_TIMEOUT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_PARAMETER; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_ABORT; + _GLOBAL_CONST unsigned short LCR_ERR_MAXMIN; + _GLOBAL_CONST unsigned short LCR_ERR_LCRContinServo_TIMPULSE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRContinServo_TCHANGE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRRamp_DYUP_DYDOWN; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPWM_TPERIOD; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPWM_TPULSE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPWM_TMINPULSE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPT1_T; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_TV; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_TN; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_TF; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_KW; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_KP; + _GLOBAL_CONST unsigned short LCR_ERROR; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_KFBK; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPPID_WR_PARA; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_WR_BASE; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_WR_PARA; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_HEAT_TP; + _GLOBAL_CONST unsigned short LCR_WARN_LCRDBLPID_TUNE_CHANGE; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTT_MEM; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTT_TT_INT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTT_TT_TS; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTT_TT_ZERO; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T2_INT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T2_TS; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T2_ZERO; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T1_INT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T1_TS; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_YMAN_LIMIT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_A_LIMIT; + _GLOBAL_CONST unsigned short LCR_WARN_Tx_DT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T1_ZERO; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPIDTune_CYCLETIME; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_YFBK_LIMIT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_I_MINLIMIT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_I_MAXLIMIT; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OSC_1; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OSC_1; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_CHR_REF_OS; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_CHR_REF_OS; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_CHR_REF_AP; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_CHR_REF_AP; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_ZN_DIST; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_ZN_DIST; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_CHR_DIST_OS; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_CHR_DIST_OS; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_CHR_DIST_AP; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_CHR_DIST_AP; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_P; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_P; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PI; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PI; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_DONE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID_DONE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID_DONE_COOLONLY; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_COOL; + _GLOBAL_CONST unsigned short LCRPID_TUNE_ADDINFO_OSC_PERIOD; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_START_COOL; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT_COOLONLY; + _GLOBAL_CONST unsigned char LCRPID_MODE_FREEZE_JOLTFREE; + _GLOBAL_CONST unsigned char LCRPID_MODE_CLOSE_JOLTFREE; + _GLOBAL_CONST unsigned char LCRPID_MODE_OPEN_JOLTFREE; + _GLOBAL_CONST unsigned char LCRPID_MODE_MAN_JOLTFREE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT_COOL; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PID; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PID; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID_COOL; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_FREE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_START_FREE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT_FREE; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_FINISHED; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_RESET_CNTL; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_CALC_PARA; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID_FREE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_HEAT; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_STEP_WAITEQ2; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_STEP_MAXGRAD; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_DIR_NEG; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_START_HEAT; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_STEP_WAITEQ1; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_DIR_NEG; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSC_CNTLPAR; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSC_PERFORM_2; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSC_PERFORM_1; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSC_SEQ_CNTL; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT_HEAT; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_DIR_POS; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSCILLATE; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_DIR_POS; + _GLOBAL_CONST unsigned char LCRDBLPID_MODE_TUNE_Y2; + _GLOBAL_CONST unsigned char LCRDBLPID_MODE_TUNE_Y1; + _GLOBAL_CONST unsigned char LCRDBLPID_MODE_TUNE_6; + _GLOBAL_CONST unsigned char LCRDBLPID_MODE_TUNE_4; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_SET_YI; + _GLOBAL_CONST unsigned char LCRPID_MODE_FREEZE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_WRITE_PARAS; + _GLOBAL_CONST unsigned char LCRPID_MODE_CLOSE; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_LIMIT_YI; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_ERROR; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_EXT_SELECTOR; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_READ_PARAS; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_FINISHED; + _GLOBAL_CONST unsigned char LCRPID_MODE_OPEN; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_STEPRESPONSE; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_EXTERN; + _GLOBAL_CONST unsigned char LCRPID_MODE_MAN; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_STEPRESPONSE; + _GLOBAL_CONST unsigned char LCRPID_D_MODE_E; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_Y2; + _GLOBAL_CONST unsigned long LCRTEMPPID_MODE_MAN; + _GLOBAL_CONST unsigned char LCRPID_DEADBAND_MODE_STANDARD_I; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OSCILLATE; + _GLOBAL_CONST unsigned char LCRTEMP_COOL; + _GLOBAL_CONST unsigned char LCRTEMP_PT2; + _GLOBAL_CONST unsigned char LCRTEMP_HYST_MODE_JOLTFREE; + _GLOBAL_CONST unsigned long LCRTEMPPID_MODE_AUTO; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OSCILLATE; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_Y1; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_INTERN; + _GLOBAL_CONST unsigned char LCRPID_DEADBAND_MODE_STANDARD; + _GLOBAL_CONST unsigned char LCRPID_D_MODE_X; + _GLOBAL_CONST unsigned char LCRPID_MODE_AUTO; + _GLOBAL_CONST unsigned long LCRTEMPTune_MODE_EXP; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OFF; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_OFF; + _GLOBAL_CONST unsigned long LCRTEMPTune_MODE_DEF; + _GLOBAL_CONST unsigned char LCRTEMP_PT1; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OFF; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_READY; + _GLOBAL_CONST unsigned char LCRPID_MODE_OFF; + _GLOBAL_CONST unsigned char LCRTEMP_HEAT; + _GLOBAL_CONST unsigned char LCRPID_DEADBAND_MODE_ZERO; +#endif + + + + +/* Datatypes and datatypes of function blocks */ +typedef struct lcrCurveByPoints_TabEntry_type +{ float x; + float y; +} lcrCurveByPoints_TabEntry_type; + +typedef struct lcrdblpid_par_typ +{ float Y_max; + float Y_min; + signed short K_fact; + float Kp; + float Tn; + float Tv; +} lcrdblpid_par_typ; + +typedef struct lcrpid_tune_osc_options_typ +{ float osc_minAmplitude; + float Q_min; +} lcrpid_tune_osc_options_typ; + +typedef struct lcrpid_tune_step_options_typ +{ float eqDeltaX; + float eqDeltaWX; + float eqDeltat; + float evalDeltaX; + unsigned short evalNfilter; + unsigned short exitNotMaxdXCount; + float exitdXRatio; +} lcrpid_tune_step_options_typ; + +typedef struct lcrdblpid_tune_typ +{ signed short P1_manualAdjust; + signed short I1_manualAdjust; + signed short D1_manualAdjust; + signed short P2_manualAdjust; + signed short I2_manualAdjust; + signed short D2_manualAdjust; + float X_min; + float X_max; + float X0; + float de_min; + float Y0; + float Y1step; + float Y2step; + unsigned long tuneY1_opt; + unsigned long tuneY2_opt; + unsigned char tune_first; + float hyst; + float measDelta; + struct lcrpid_tune_osc_options_typ osc_opt; + struct lcrpid_tune_step_options_typ step_opt; +} lcrdblpid_tune_typ; + +typedef struct lcrpid_internal_typ +{ unsigned short size; + plcbit valid; + float WX_max; + float WX_min; + plcbit invert; + float deadband; + unsigned char deadband_mode; + float dY_max; + float Kp; + float Kp_Tn; + float Tv_Tf; + float Tf_reciproc; + float Kw; + float Kfbk_Kp; + float Kfbk_Kp_max; + unsigned char fbk_mode; + unsigned char d_mode; + unsigned char force_mode; + float Y_force; + float W; + float X; + unsigned char pid_init; + signed long Yp1; + signed long Yp2; + signed long dYi1; + signed long dYi2; + signed long Yi1; + signed long Yi2; + float dt_Tf; + signed long a11; + signed long a12; + signed long a21; + signed long a22; + signed long Yd1; + signed long Yd2; + signed long Ytotal1; + signed long Ytotal2; + signed long Ylim1; + signed long Ylim2; + signed long Y1; + signed long Y2; + float deltaY_fbk; + float e_fbk; +} lcrpid_internal_typ; + +typedef struct lcrpid_procPar_typ +{ unsigned short size; + plcbit valid; + plcbit stepResp_valid; + float stepResp_v; + float stepResp_t_u; + float stepResp_t_g; + plcbit osc_valid; + float osc_amplitudeRatio; + float osc_tPeriod; + plcbit force_params; + float Kp; + float Kp_tune; + float Tn; + float Tn_tune; + float Tv; + float Tv_tune; +} lcrpid_procPar_typ; + +typedef struct lcrpid_old_typ +{ struct lcrpid_procPar_typ processPar; + signed short P_manualAdjust; + signed short I_manualAdjust; + signed short D_manualAdjust; + float Y_min; + float Y_max; + float dY_max; + float Tf_Tv; + float Kw; + float Kfbk; + float deadband; + float W; + unsigned long request; + unsigned char fbk_mode; + unsigned char d_mode; + plcbit invert; + plcbit enable; +} lcrpid_old_typ; + +typedef struct lcrpid_osc_val_typ +{ float X; + float t; +} lcrpid_osc_val_typ; + +typedef struct lcrpid_osc_per_typ +{ struct lcrpid_osc_val_typ max; + struct lcrpid_osc_val_typ min; +} lcrpid_osc_per_typ; + +typedef struct lcrpid_tune_addpar_typ +{ float t_max_tune; + float WX_min; + float WX_max; + float dY_max; + float Tf_Tv; + float Kw; + float Kfbk; + unsigned char fbk_mode; + unsigned char d_mode; + float deadband; + unsigned char deadband_mode; + plcbit invert; +} lcrpid_tune_addpar_typ; + +typedef struct lcrpid_tune_osc_typ +{ struct lcrpid_tune_osc_options_typ options; + unsigned short oscPhase; + signed char dir; + plcbit enHi; + plcbit enLo; + float Y_hi; + float Y_lo; + unsigned short i_maxPeriod; + unsigned short i_period; + float X_ampl; + float X_avg; + float X_min_avg; + float X_max_avg; + float Y_avg; + float deltaY; + float t_Ylohi[5]; + float t_Yhilo[5]; + float Q_act; + float a_wx; + float amplitudeRatio; + float Ku; + float tPeriod; + struct lcrpid_osc_per_typ period[5]; +} lcrpid_tune_osc_typ; + +typedef struct lcrpid_tune_step_typ +{ struct lcrpid_tune_step_options_typ options; + float Y0; + float Y1; + float t_jump; + float W; + float X0; + float Xmax; + float Xmin; + float Xfiltered; + plcbit deltaXok; + plcbit deltaWXok; + float eqTime; + signed char dir; + float deltaX; + float X1; + float t1; + plcbit t1set; + float dX_dt; + float dX_dt_max; + float XmaxGrad; + float maxX1; + float maxX2; + float maxt1; + float maxt2; + float tmaxGrad; + float gainFactor; + float deadTime; + float riseTime; + unsigned short notMaxCount; + float gradientRatio; +} lcrpid_tune_step_typ; + +typedef struct lcrpt2o_Internal_typ +{ signed long Ts; + unsigned long Ts_dbl_1; + unsigned long Ts_dbl_2; + float V_old; + float D_old; + float Tf_old; + unsigned char Set_y_old; + unsigned char Set_y_2; + unsigned long x1_dbl_1; + unsigned long x1_dbl_2; + unsigned long x2_dbl_1; + unsigned long x2_dbl_2; + unsigned long Sqrt_D_1_dbl_1; + unsigned long Sqrt_D_1_dbl_2; + unsigned long Ts_Tf_dbl_1; + unsigned long Ts_Tf_dbl_2; + unsigned long Exp_D_Ts_Tf_dbl_1; + unsigned long Exp_D_Ts_Tf_dbl_2; + unsigned long a0_dbl_1; + unsigned long a0_dbl_2; + unsigned long a1_dbl_1; + unsigned long a1_dbl_2; + unsigned long b0_dbl_1; + unsigned long b0_dbl_2; + unsigned long b1_dbl_1; + unsigned long b1_dbl_2; + unsigned long Bootkey; +} lcrpt2o_Internal_typ; + +typedef struct LCRPWM +{ + /* VAR_INPUT (analog) */ + float x; + float max_value; + float min_value; + float t_min_pulse; + float t_period; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float t_on; + float t_off; + /* VAR (analog) */ + signed long cnt_terron_1; + signed long cnt_terron_2; + signed long cnt_terroff_1; + signed long cnt_terroff_2; + signed long cnt_t_pulse_1; + signed long cnt_t_pulse_2; + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR_OUTPUT (digital) */ + plcbit pulse; + /* VAR (digital) */ + plcbit corr; +} LCRPWM_typ; + +typedef struct lcrschedule_add_typ +{ float periodTime; + float onTime; + float t_on_intern; + float bcOnTime; + unsigned short sortIndex; + struct LCRPWM fbkPWM; + plcbit flagDelay; +} lcrschedule_add_typ; + +typedef struct lcrschedule_par_typ +{ float P; + float X; + plcbit pulse; + float Pout; + plcbit lim; + struct lcrschedule_add_typ Internal; +} lcrschedule_par_typ; + +typedef struct lcrslimpid_par_typ +{ float Y_max; + float Y_min; + float Kp; + float Tn; + float Tv; + float Kfbk; +} lcrslimpid_par_typ; + +typedef struct lcrtemp_add_typ +{ float mem01; + float mem02; + float mem10; + float mem20; + float exp_mem; + float cnt01; + float cnt02; + float cnt10; + float cnt20; + float cnt03; + float cnt30; + float cnt00; + float t_ignore_dT_heat; + float t_ignore_dT_free; + float t_ignore_dT_cool; + float yMin; + float yMax; + unsigned long reserved3; + unsigned long reserved4; + plcbit reserved5; + plcbit reserved6; +} lcrtemp_add_typ; + +typedef struct lcrtemp_pid_internal_typ +{ plcbit enable_cooling; + plcbit disable_heating; + float hyst; + float delay; + float Kw; + float Kfbk; + float Kp_h; + float Tn_h; + float Tv_h; + float Kp_c; + float Tn_c; + float Tv_c; + float dynGeneral; + float dynHeat; + float dynCool; + float mem01; + float mem02; + float mem10; + float mem20; + float exp_mem; + float yMin; + float yMax; +} lcrtemp_pid_internal_typ; + +typedef struct lcrtemp_pid_opt_typ +{ float Kp_h; + float Tn_h; + float Tv_h; + float Tf_h; + float Kp_c; + float Tn_c; + float Tv_c; + float Tf_c; + float dynGeneral; + float dynHeat; + float dynCool; +} lcrtemp_pid_opt_typ; + +typedef struct lcrtemp_pid_set_typ +{ float hyst; + unsigned char hyst_mode; + float delay; + float Kw; + float Kfbk; +} lcrtemp_pid_set_typ; + +typedef struct lcrtemp_tune_set_typ +{ unsigned long mode; + float Temp_amb; + float dRatio_heat; + float cnt_tp_heat; + float delta_T_heat; + float dT_min_heat; + float dRatio_free; + float cnt_tp_free; + float delta_T_free; + float dT_min_free; + float dRatio_cool; + float cnt_tp_cool; + float delta_T_cool; + float dT_min_cool; + float delta_T_sync_heat; + float delta_dT_sync_heat; + float cnt_wait_heat; + float delta_T_sync_free; + float delta_dT_sync_free; + float cnt_wait_free; + float delta_T_sync_cool; + float delta_dT_sync_cool; + float cnt_wait_cool; + float filter_base_T; + float delta_T_sync_stop; + float Y_heat_tune; +} lcrtemp_tune_set_typ; + +typedef struct lcrtemp_set_typ +{ plcbit enable_cooling; + plcbit disable_heating; + struct lcrtemp_pid_opt_typ PIDpara; + struct lcrtemp_tune_set_typ TuneSet; + struct lcrtemp_pid_set_typ PIDSet; + struct lcrtemp_add_typ Internal; +} lcrtemp_set_typ; + +typedef struct lcrtemp_tune_internal_typ +{ plcbit cool_tuning; + plcbit disable_heating; + unsigned long mode; + float Temp_amb; + float dRatio_heat; + float cnt_tp_heat; + float delta_T_heat; + float dT_min_heat; + float dRatio_free; + float cnt_tp_free; + float delta_T_free; + float dT_min_free; + float dRatio_cool; + float cnt_tp_cool; + float delta_T_cool; + float dT_min_cool; + float delta_T_sync_heat; + float delta_dT_sync_heat; + float cnt_wait_heat; + float delta_T_sync_free; + float delta_dT_sync_free; + float cnt_wait_free; + float delta_T_sync_cool; + float delta_dT_sync_cool; + float cnt_wait_cool; + float filter_base_T; + float t_ignore_dT_heat; + float t_ignore_dT_free; + float t_ignore_dT_cool; + float delta_T_sync_stop; +} lcrtemp_tune_internal_typ; + +typedef struct LCRScal +{ + /* VAR_INPUT (analog) */ + float x; + float x1; + float y1; + float x2; + float y2; + /* VAR_OUTPUT (analog) */ + float y; +} LCRScal_typ; + +typedef struct LCRPID +{ + /* VAR_INPUT (analog) */ + unsigned long ident; + float W; + float X; + float Y_max; + float Y_min; + float A; + float Y_man; + float Y_fbk; + unsigned char mode; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float e; + float Y; + float Yp; + float Yi; + float Yd; + /* VAR (analog) */ + float Yi_set; + float Yi_min; + float Yi_max; + float Yi_minInternal; + float Yi_maxInternal; + float Tv_Tf_old; + float e_old; + unsigned short deadband_state; + struct SysInfo sysinfo_inst; + struct LCRScal scal_inst; + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + unsigned short musecs_old; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit hold_I; + /* VAR (digital) */ + plcbit Set_Yi; + plcbit force_Yi; + plcbit joltFreeDoneLowerLim; + plcbit joltFreeDoneUpperLim; + plcbit enable_old; +} LCRPID_typ; + +typedef struct LCRCurveByPoints +{ + /* VAR_INPUT (analog) */ + float x; + unsigned short NoOfPoints; + struct lcrCurveByPoints_TabEntry_type* ptr_table; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + signed short i_tab; + unsigned short iterations; + struct LCRScal scal1; +} LCRCurveByPoints_typ; + +typedef struct LCRPIDpara +{ + /* VAR_INPUT (analog) */ + float WX_max; + float WX_min; + float deadband; + unsigned char deadband_mode; + float dY_max; + float Kp; + float Tn; + float Tv; + float Tf; + float Kw; + float Kfbk; + unsigned char fbk_mode; + unsigned char d_mode; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned long ident; + /* VAR (analog) */ + struct lcrpid_internal_typ internal_data; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit enter; + plcbit invert; +} LCRPIDpara_typ; + +typedef struct LCRContinServo +{ + /* VAR_INPUT (analog) */ + float x; + float max_value; + float min_value; + float t_impulse; + float t_change_up; + float t_change_down; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float hysteresis_up; + float hysteresis_down; + /* VAR (analog) */ + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + signed long t_cnt_1; + signed long t_cnt_2; + signed long y_dbl_1; + signed long y_dbl_2; + struct SysInfo sysInfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit ref; + /* VAR_OUTPUT (digital) */ + plcbit up; + plcbit down; + plcbit refOk; + /* VAR (digital) */ + plcbit enable_old; + plcbit ref_old; +} LCRContinServo_typ; + +typedef struct LCRPT1 +{ + /* VAR_INPUT (analog) */ + float x; + float t; + float y_set; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + signed long y_dbl_1; + signed long y_dbl_2; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit set; +} LCRPT1_typ; + +typedef struct LCRRamp +{ + /* VAR_INPUT (analog) */ + float x; + float dy_up; + float dy_down; + float y_max; + float y_min; + float y_set; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + signed long y_dbl_1; + signed long y_dbl_2; + unsigned long timestore1; + unsigned long timestore2; + unsigned long getDtForceOff; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit set; + /* VAR_OUTPUT (digital) */ + plcbit x_reached; + plcbit max_limit; + plcbit min_limit; +} LCRRamp_typ; + +typedef struct LCRIntegrate +{ + /* VAR_INPUT (analog) */ + float x; + float tn; + float y_max; + float y_min; + float y_set; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + signed long y_dbl_1; + signed long y_dbl_2; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit set; + /* VAR_OUTPUT (digital) */ + plcbit max_limit; + plcbit min_limit; +} LCRIntegrate_typ; + +typedef struct LCRLimit +{ + /* VAR_INPUT (analog) */ + float in; + signed long max_value; + signed long min_value; + /* VAR_OUTPUT (analog) */ + unsigned short status; + signed long out; + /* VAR_OUTPUT (digital) */ + plcbit max_limit; + plcbit min_limit; +} LCRLimit_typ; + +typedef struct LCRLimScal +{ + /* VAR_INPUT (analog) */ + float x; + float x1; + float y1; + float x2; + float y2; + /* VAR_OUTPUT (analog) */ + float y; +} LCRLimScal_typ; + +typedef struct LCRMovAvgFlt +{ + /* VAR_INPUT (analog) */ + float x; + unsigned short base; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + signed long sum_old_dbl_1; + signed long sum_old_dbl_2; + unsigned long p_xold; + unsigned short i_xold; + unsigned short base_old; + unsigned long bootkey_old; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR (digital) */ + plcbit enable_old; +} LCRMovAvgFlt_typ; + +typedef struct LCRTimeBasedOnOff +{ + /* VAR_INPUT (analog) */ + float x; + float max_value; + float min_value; + float timpulse; + float tchange_up; + float tchange_down; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float hysteresis_up; + float hysteresis_down; + /* VAR (analog) */ + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + signed long t_cnt_1; + signed long t_cnt_2; + signed long y_dbl_1; + signed long y_dbl_2; + struct SysInfo sysInfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit ref; + /* VAR_OUTPUT (digital) */ + plcbit up; + plcbit down; + plcbit refOk; + /* VAR (digital) */ + plcbit enable_old; + plcbit ref_old; +} LCRTimeBasedOnOff_typ; + +typedef struct LCRDifferentiate +{ + /* VAR_INPUT (analog) */ + float x; + float tv; + float tf; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + struct SysInfo sysinfo_inst; + signed long a11; + signed long a12; + signed long a21; + signed long a22; + /* VAR_INPUT (digital) */ + plcbit enable; +} LCRDifferentiate_typ; + +typedef struct LCRPIDTune +{ + /* VAR_INPUT (analog) */ + float Y_min; + float Y_max; + float Y0; + float Y1; + float X0; + float X_min; + float X_max; + signed short P_manualAdjust; + signed short I_manualAdjust; + signed short D_manualAdjust; + unsigned long request; + struct lcrpid_tune_addpar_typ* pAddPar; + struct lcrpid_tune_osc_options_typ* pOptions_osc; + struct lcrpid_tune_step_options_typ* pOptions_step; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned short addInfo; + unsigned long ident; + unsigned short state; + /* VAR (analog) */ + float t_autotune; + unsigned short status_tmp; + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + float e; + float e_minAmp; + float e_old_up; + float e_old_down; + float e_old; + struct SysInfo sysinfo_inst; + struct LCRMovAvgFlt MovAvgFlt_inst; + struct lcrpid_old_typ old; + struct lcrpid_procPar_typ processPar; + struct lcrpid_internal_typ internal_data; + struct lcrpid_tune_addpar_typ addPar; + struct lcrpid_tune_osc_typ oscillation; + struct lcrpid_tune_step_typ stepresponse; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit okToStep; + /* VAR_OUTPUT (digital) */ + plcbit rdyToStep; + /* VAR (digital) */ + plcbit curveDown; + plcbit curveUp; +} LCRPIDTune_typ; + +typedef struct LCRSlimPID +{ + /* VAR_INPUT (analog) */ + float W; + float X; + unsigned long request; + struct lcrslimpid_par_typ* pPar; + /* VAR_OUTPUT (analog) */ + float e; + float Y; + unsigned short status; + unsigned short addInfo; + /* VAR (analog) */ + struct LCRMovAvgFlt MovAvgFlt_inst; + struct LCRPIDTune PIDTune_inst; + struct LCRPID PID_inst; + unsigned long requ_old; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR (digital) */ + plcbit enable_old; +} LCRSlimPID_typ; + +typedef struct LCRPFM +{ + /* VAR_INPUT (analog) */ + float x; + float max_value; + float min_value; + float t_pulse; + float t_pause; + /* VAR_OUTPUT (analog) */ + unsigned short status; + /* VAR (analog) */ + float area; + float area_c; + float range; + float last; + float tpls; + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR_OUTPUT (digital) */ + plcbit pulse; + /* VAR (digital) */ + plcbit enable_old; +} LCRPFM_typ; + +typedef struct LCRTt +{ + /* VAR_INPUT (analog) */ + signed long Tt; + float x; + float y_set; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + signed long Ts; + signed long Tt_Max; + float* pRingBuf; + float* pBuf_OutIn; + unsigned char set_old; + unsigned char Set_y; + unsigned long Bootkey; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit set; + /* VAR (digital) */ + plcbit enable_old; +} LCRTt_typ; + +typedef struct LCRPT2 +{ + /* VAR_INPUT (analog) */ + float V; + float T1; + float T2; + float x; + float y_set; + unsigned char set; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + unsigned long x1_dbl_1; + unsigned long x1_dbl_2; + unsigned long x2_dbl_1; + unsigned long x2_dbl_2; + signed long Ts; + unsigned long Ts_dbl_1; + unsigned long Ts_dbl_2; + unsigned char set_old; + unsigned char Set_y; + unsigned long Bootkey; + /* VAR_INPUT (digital) */ + plcbit enable; +} LCRPT2_typ; + +typedef struct LCRSimModExt +{ + /* VAR_INPUT (analog) */ + signed long Tt_h; + signed long Tt_c; + float k_h; + float k_c; + float PT2_T1; + float PT2_T2; + float Temp_amb; + float Temp_c; + float Alpha_h; + float Alpha_c; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + struct LCRTt Tt_heat; + struct LCRTt Tt_cool; + float k_h_intern; + float k_c_intern; + struct LCRPT2 PT2; + float y_c; + float y_end; + float y_h; + unsigned long Bootkey; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR (digital) */ + plcbit enable_old; +} LCRSimModExt_typ; + +typedef struct LCRPT1e +{ + /* VAR_INPUT (analog) */ + float V; + float T1; + float x; + float y_set; + unsigned char set; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + unsigned long x1_dbl_1; + unsigned long x1_dbl_2; + signed long Ts; + unsigned long Ts_dbl_1; + unsigned long Ts_dbl_2; + unsigned char set_old; + unsigned char Set_y; + unsigned long Bootkey; + /* VAR_INPUT (digital) */ + plcbit enable; +} LCRPT1e_typ; + +typedef struct LCRDblActPID +{ + /* VAR_INPUT (analog) */ + float W; + float X; + float Y_man; + unsigned char mode; + struct lcrdblpid_par_typ* pPar1; + struct lcrdblpid_par_typ* pPar2; + struct lcrpid_tune_addpar_typ* pAddPar; + struct lcrdblpid_tune_typ* pOpt; + /* VAR_OUTPUT (analog) */ + float e; + float Y1; + float Y2; + unsigned short status; + unsigned char tuneState; + /* VAR (analog) */ + struct LCRPID pid; + struct LCRPIDTune tune; + struct SysInfo sysinfo_inst; + float gradient; + float Y_avg; + unsigned long tcnt_1; + unsigned long tcnt_2; + float Tmeas; + float y_lim_old; + float p_fact; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + unsigned char use_par; + unsigned char meas; + unsigned char mode_old; + unsigned char tune_step; + unsigned char tune_grad; + unsigned char tune_2nd; + unsigned char invert; + unsigned char counter_state; + unsigned char mode_int; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit hold_I; + plcbit okToStep; + /* VAR_OUTPUT (digital) */ + plcbit rdyToStep; + /* VAR (digital) */ + plcbit enable_old; +} LCRDblActPID_typ; + +typedef struct LCRMinMax +{ + /* VAR_INPUT (analog) */ + float in; + /* VAR_OUTPUT (analog) */ + float out_min; + float out_max; + /* VAR_INPUT (digital) */ + plcbit reset; +} LCRMinMax_typ; + +typedef struct LCRTempPID +{ + /* VAR_INPUT (analog) */ + float Temp_set; + float Temp; + float Y_man; + unsigned long mode; + struct lcrtemp_set_typ* pSettings; + /* VAR_OUTPUT (analog) */ + float y_heat; + float y_cool; + unsigned short status; + /* VAR (analog) */ + struct LCRPID pid; + struct LCRPIDpara pid_para; + float Temp_set_delay; + float Temp_set_int; + float TempSetOld; + float delayCnt; + signed char stateOld; + signed char state; + float a; + struct SysInfo sysinfo_inst; + unsigned char para_check_done; + struct lcrtemp_pid_internal_typ internal_para; + float dbl_dt; + float tAlt; + float altTime; + float tKnick; + float fAlt; + float a_alt; + float a_e; + float a_internal; + float Temp_set_int_old1; + float Temp_set_int_old2; + float Temp_set_int_old3; + unsigned long mode_old; + unsigned long timestore1; + unsigned long timestore2; + float yManInternal; + unsigned long timeCnt; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit update; + /* VAR (digital) */ + plcbit delayFlag; + plcbit enable_old; + plcbit altActive; + plcbit err_flag; +} LCRTempPID_typ; + +typedef struct LCRPT2o +{ + /* VAR_INPUT (analog) */ + float V; + float D; + float Tf; + float u; + unsigned char Set_y; + float y_set; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + struct lcrpt2o_Internal_typ Internal; + /* VAR_INPUT (digital) */ + plcbit enable; +} LCRPT2o_typ; + +typedef struct LCRTempTune +{ + /* VAR_INPUT (analog) */ + float Temp_set; + float Temp; + struct lcrtemp_set_typ* pSettings; + /* VAR_OUTPUT (analog) */ + float y_heat; + float y_cool; + unsigned short status; + /* VAR (analog) */ + struct LCRPID pid; + struct LCRPIDpara pid_para; + struct LCRDifferentiate DT2; + struct LCRPT2o pt2; + float Temp_flt; + unsigned short step; + float t; + float Temp_start; + float mem00; + float cnt02; + float cnt33; + float cnt20; + float pem01; + float pem33; + float pem10; + float pem02; + float pem44; + float pem20; + float tol01; + float tol10; + float tol02; + float tol20; + float tol22; + float Temp_old; + float delta_Temp; + unsigned long tcnt_1; + unsigned long tcnt_2; + unsigned long tcnt_dT_1; + unsigned long tcnt_dT_2; + struct SysInfo sysinfo_inst; + float Temp_set_internal; + float timecounter; + struct lcrtemp_tune_internal_typ internal_para; + float dbl_dt; + unsigned long call_counter; + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + float timer2; + unsigned short waitCounter; + float Y_heat_tune_intern; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit start; + plcbit okToHeat; + plcbit okToFree; + plcbit okToFreeEnd; + plcbit okToCool; + plcbit okToCoolEnd; + /* VAR_OUTPUT (digital) */ + plcbit rdyToHeat; + plcbit rdyToFree; + plcbit rdyToFreeEnd; + plcbit rdyToCool; + plcbit rdyToCoolEnd; + plcbit done; + plcbit busy; + /* VAR (digital) */ + plcbit enable_old; +} LCRTempTune_typ; + +typedef struct LCRSchedulePWM +{ + /* VAR_INPUT (analog) */ + float Pmax; + unsigned short n; + unsigned long pPar; + float min_value; + float max_value; + float t_min_pulse; + float t_period; + /* VAR_OUTPUT (analog) */ + unsigned short status; + /* VAR (analog) */ + struct SysInfo sysinfo_inst; + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + unsigned short numberUnits; + unsigned short limFact; + float Pact; + float Pman; + float intern0[6]; + struct lcrschedule_par_typ* in; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR (digital) */ + plcbit enable_old; + plcbit cmd_delay; + plcbit err_flag; + plcbit limAll; +} LCRSchedulePWM_typ; + + + +/* Prototyping of functions and function blocks */ +_BUR_PUBLIC void LCRPID(struct LCRPID* inst); +_BUR_PUBLIC void LCRScal(struct LCRScal* inst); +_BUR_PUBLIC void LCRCurveByPoints(struct LCRCurveByPoints* inst); +_BUR_PUBLIC void LCRPIDpara(struct LCRPIDpara* inst); +_BUR_PUBLIC void LCRContinServo(struct LCRContinServo* inst); +_BUR_PUBLIC void LCRPT1(struct LCRPT1* inst); +_BUR_PUBLIC void LCRRamp(struct LCRRamp* inst); +_BUR_PUBLIC void LCRIntegrate(struct LCRIntegrate* inst); +_BUR_PUBLIC void LCRLimit(struct LCRLimit* inst); +_BUR_PUBLIC void LCRLimScal(struct LCRLimScal* inst); +_BUR_PUBLIC void LCRPWM(struct LCRPWM* inst); +_BUR_PUBLIC void LCRMovAvgFlt(struct LCRMovAvgFlt* inst); +_BUR_PUBLIC void LCRTimeBasedOnOff(struct LCRTimeBasedOnOff* inst); +_BUR_PUBLIC void LCRDifferentiate(struct LCRDifferentiate* inst); +_BUR_PUBLIC void LCRSlimPID(struct LCRSlimPID* inst); +_BUR_PUBLIC void LCRPIDTune(struct LCRPIDTune* inst); +_BUR_PUBLIC void LCRPFM(struct LCRPFM* inst); +_BUR_PUBLIC void LCRSimModExt(struct LCRSimModExt* inst); +_BUR_PUBLIC void LCRTt(struct LCRTt* inst); +_BUR_PUBLIC void LCRPT2(struct LCRPT2* inst); +_BUR_PUBLIC void LCRPT1e(struct LCRPT1e* inst); +_BUR_PUBLIC void LCRDblActPID(struct LCRDblActPID* inst); +_BUR_PUBLIC void LCRMinMax(struct LCRMinMax* inst); +_BUR_PUBLIC void LCRTempPID(struct LCRTempPID* inst); +_BUR_PUBLIC void LCRTempTune(struct LCRTempTune* inst); +_BUR_PUBLIC void LCRPT2o(struct LCRPT2o* inst); +_BUR_PUBLIC void LCRSchedulePWM(struct LCRSchedulePWM* inst); + + +#ifdef __cplusplus +}; +#endif +#endif /* _LOOPCONR_ */ + diff --git a/Logical/Libraries/LoopConR/SG4/Arm/LoopConR.br b/Logical/Libraries/LoopConR/SG4/Arm/LoopConR.br new file mode 100644 index 0000000000000000000000000000000000000000..04fe924799c3a2f25759bf398c8abf76b20c2f7b GIT binary patch literal 176592 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 literal 0 HcmV?d00001 diff --git a/Logical/Libraries/LoopConR/SG4/Arm/libLoopConR.a b/Logical/Libraries/LoopConR/SG4/Arm/libLoopConR.a new file mode 100644 index 0000000000000000000000000000000000000000..d1881dcef0889d2cf74327e3ca1c95315fff0e04 GIT binary patch literal 9745 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 WSv2RDvf__ji~NntKQ<+G{C@ys)$xe{ literal 0 HcmV?d00001 diff --git a/Logical/Libraries/LoopConR/SG4/LoopConR.h b/Logical/Libraries/LoopConR/SG4/LoopConR.h new file mode 100644 index 0000000..e88fcf4 --- /dev/null +++ b/Logical/Libraries/LoopConR/SG4/LoopConR.h @@ -0,0 +1,1677 @@ +/* Automation Studio generated header file */ +/* Do not edit ! */ +/* LoopConR 4.10.2 */ + +#ifndef _LOOPCONR_ +#define _LOOPCONR_ +#ifdef __cplusplus +extern "C" +{ +#endif +#ifndef _LoopConR_VERSION +#define _LoopConR_VERSION 4.10.2 +#endif + +#include + +#ifndef _BUR_PUBLIC +#define _BUR_PUBLIC +#endif +#ifdef _SG4 + #include "sys_lib.h" + #include "brsystem.h" +#endif +#ifdef _SG3 + #include "sys_lib.h" + #include "brsystem.h" +#endif +#ifdef _SGC + #include "sys_lib.h" + #include "brsystem.h" +#endif + +/* Constants */ +#ifdef _REPLACE_CONST + #define LCRPID_TUNE_REQU_PER_5 500000U + #define LCRSLIMPID_REQU_PER_5 500000U + #define LCRSLIMPID_REQU_PER_4 400000U + #define LCRPID_TUNE_REQU_PER_4 400000U + #define LCRPID_TUNE_REQU_PER_3 300000U + #define LCRSLIMPID_REQU_PER_3 300000U + #define LCRTEMP_STEP_ERROR 65535U + #define LCR_ERR_DISABLED 65534U + #define LCR_ERR_PT2O_TF_NEG_ZERO 33154U + #define LCR_ERR_PT2O_D_NEG 33153U + #define LCR_ERR_LCRTEMPTune_DT_IGNORED 33152U + #define LCR_ERR_LCRTEMPPID_INVALID_MODE 33151U + #define LCR_ERR_LCRTEMPTune_INVALID_MODE 33150U + #define LCR_WARN_PT2O_TF_TS 33102U + #define LCR_WARN_LCRTEMPTune_ASYNC 33101U + #define LCR_WARN_LCRTEMPTune_DT_HIGH 33100U + #define LCR_ERR_SCHEDULE_N 31574U + #define LCR_ERR_SCHEDULE_P 31573U + #define LCR_ERR_LCRTEMPPID_NO_TALT 31572U + #define LCR_ERR_LCRTEMPPID_TKNICK 31571U + #define LCR_ERR_LCRTEMPTune_TASKTIME_0 31570U + #define LCR_ERR_LCRTEMPPID_ILLEGALMODE 31569U + #define LCR_ERR_LCRTEMPPID_WR_PTR 31568U + #define LCR_ERR_LCRTEMPPID_WR_PARA 31567U + #define LCR_ERR_LCRTEMPTune_WR_TSET 31567U + #define LCR_ERR_LCRTEMPTune_WR_PTR 31566U + #define LCR_ERR_LCRPIDTune_MAXMIN 31564U + #define LCR_ERR_POINTER 31563U + #define LCR_ERR_LCRDBLPID_DX_DT 31562U + #define LCR_ERR_LCRDBLPID_WX_LOW 31561U + #define LCR_ERR_LCRPIDTune_CONTROL_VAR 31560U + #define LCR_ERR_LCRPIDTune_INVALID_REQU 31559U + #define LCR_ERR_LCRPID_PAR_FBKMODE 31558U + #define LCR_ERR_LCRPID_PAR_DYMAX 31557U + #define LCR_ERR_LCRPID_PAR_DMODE 31556U + #define LCR_ERR_LCRPID_PARADAT 31554U + #define LCR_ERR_LCRPID_MODE 31553U + #define LCR_ERR_LCRPID_IDENT 31552U + #define LCR_ERR_LCRMovAvgFlt_BASE 31551U + #define LCR_ERR_LCRIntegrate_TN 31550U + #define LCRPID_TUNE_REQU_OSC_3 30000U + #define LCRSLIMPID_REQU_OSC_3 30000U + #define LCRPID_TUNE_REQU_OSC_2 20000U + #define LCRSLIMPID_REQU_OSC_2 20000U + #define LCR_ERR_LCRTT_TT_NEG 12048U + #define LCR_ERR_LCRPT12_T2_NEG 12047U + #define LCR_ERR_LCRPT12_T1_NEG 12046U + #define LCR_ERR_LCRCurveByPoints_TABLE 12045U + #define LCR_ERR_LCRPID_PAR_DEADBAND 12044U + #define LCR_ERR_LCRPID_PAR_WX_MAXMIN 12043U + #define LCR_ERR_LCRPID_PAR_DEADBAND_MODE 12042U + #define LCR_ERR_LCRPIDTune_W_CHANGED 12041U + #define LCR_ERR_LCRPIDTune_TIMEOUT 12040U + #define LCR_ERR_LCRPIDTune_PARAMETER 12039U + #define LCR_ERR_LCRPIDTune_ABORT 12038U + #define LCR_ERR_MAXMIN 12037U + #define LCR_ERR_LCRContinServo_TIMPULSE 12036U + #define LCR_ERR_LCRContinServo_TCHANGE 12035U + #define LCR_ERR_LCRRamp_DYUP_DYDOWN 12034U + #define LCR_ERR_LCRPWM_TPERIOD 12033U + #define LCR_ERR_LCRPWM_TPULSE 12033U + #define LCR_ERR_LCRPWM_TMINPULSE 12032U + #define LCR_ERR_LCRPT1_T 12031U + #define LCR_ERR_LCRPID_PAR_TV 12030U + #define LCR_ERR_LCRPID_PAR_TN 12029U + #define LCR_ERR_LCRPID_PAR_TF 12028U + #define LCR_ERR_LCRPID_PAR_KW 12027U + #define LCR_ERR_LCRPID_PAR_KP 12026U + #define LCR_ERROR 12025U + #define LCR_ERR_LCRPID_PAR_KFBK 12025U + #define LCR_WARN_LCRTEMPPID_WR_PARA 12024U + #define LCR_WARN_LCRTEMPTune_WR_BASE 12023U + #define LCR_WARN_LCRTEMPTune_WR_PARA 12022U + #define LCR_WARN_LCRTEMPTune_HEAT_TP 12021U + #define LCR_WARN_LCRDBLPID_TUNE_CHANGE 12019U + #define LCR_WARN_LCRTT_MEM 12018U + #define LCR_WARN_LCRTT_TT_INT 12017U + #define LCR_WARN_LCRTT_TT_TS 12016U + #define LCR_WARN_LCRTT_TT_ZERO 12015U + #define LCR_WARN_LCRPT12_T2_INT 12014U + #define LCR_WARN_LCRPT12_T2_TS 12013U + #define LCR_WARN_LCRPT12_T2_ZERO 12012U + #define LCR_WARN_LCRPT12_T1_INT 12011U + #define LCR_WARN_LCRPT12_T1_TS 12010U + #define LCR_WARN_LCRPID_YMAN_LIMIT 12009U + #define LCR_WARN_LCRPID_A_LIMIT 12008U + #define LCR_WARN_Tx_DT 12007U + #define LCR_WARN_LCRPT12_T1_ZERO 12005U + #define LCR_WARN_LCRPIDTune_CYCLETIME 12004U + #define LCR_WARN_LCRPID_YFBK_LIMIT 12003U + #define LCR_WARN_LCRPID_I_MINLIMIT 12002U + #define LCR_WARN_LCRPID_I_MAXLIMIT 12001U + #define LCRSLIMPID_REQU_OSC_1 10000U + #define LCRPID_TUNE_REQU_OSC_1 10000U + #define LCRSLIMPID_REQU_CHR_REF_OS 5000U + #define LCRPID_TUNE_REQU_CHR_REF_OS 5000U + #define LCRSLIMPID_REQU_CHR_REF_AP 4000U + #define LCRPID_TUNE_REQU_CHR_REF_AP 4000U + #define LCRPID_TUNE_REQU_ZN_DIST 3000U + #define LCRSLIMPID_REQU_ZN_DIST 3000U + #define LCRPID_TUNE_REQU_CHR_DIST_OS 2000U + #define LCRSLIMPID_REQU_CHR_DIST_OS 2000U + #define LCRPID_TUNE_REQU_CHR_DIST_AP 1000U + #define LCRSLIMPID_REQU_CHR_DIST_AP 1000U + #define LCRSLIMPID_REQU_P 300U + #define LCRPID_TUNE_REQU_P 300U + #define LCRSLIMPID_REQU_PI 200U + #define LCRPID_TUNE_REQU_PI 200U + #define LCRTEMP_STEP_DONE 130U + #define LCRTEMP_STEP_PID_DONE 125U + #define LCRTEMP_STEP_PID_DONE_COOLONLY 122U + #define LCRTEMP_STEP_COOL 120U + #define LCRPID_TUNE_ADDINFO_OSC_PERIOD 111U + #define LCRTEMP_STEP_START_COOL 110U + #define LCRTEMP_STEP_WAIT_COOLONLY 105U + #define LCRPID_MODE_FREEZE_JOLTFREE 105U + #define LCRPID_MODE_CLOSE_JOLTFREE 104U + #define LCRPID_MODE_OPEN_JOLTFREE 103U + #define LCRPID_MODE_MAN_JOLTFREE 102U + #define LCRTEMP_STEP_WAIT_COOL 100U + #define LCRPID_TUNE_REQU_PID 100U + #define LCRSLIMPID_REQU_PID 100U + #define LCRTEMP_STEP_PID_COOL 90U + #define LCRTEMP_STEP_PID 80U + #define LCRTEMP_STEP_FREE 70U + #define LCRTEMP_STEP_START_FREE 60U + #define LCRTEMP_STEP_WAIT_FREE 50U + #define LCRPID_TUNE_STATE_FINISHED 50U + #define LCRPID_TUNE_STATE_RESET_CNTL 49U + #define LCRPID_TUNE_STATE_CALC_PARA 45U + #define LCRTEMP_STEP_PID_FREE 40U + #define LCRTEMP_STEP_HEAT 30U + #define LCRPID_TUNE_STATE_STEP_WAITEQ2 22U + #define LCRPID_TUNE_STATE_STEP_MAXGRAD 21U + #define LCRSLIMPID_REQU_DIR_NEG 20U + #define LCRTEMP_STEP_START_HEAT 20U + #define LCRPID_TUNE_STATE_STEP_WAITEQ1 20U + #define LCRPID_TUNE_REQU_DIR_NEG 20U + #define LCRPID_TUNE_STATE_OSC_CNTLPAR 19U + #define LCRPID_TUNE_STATE_OSC_PERFORM_2 13U + #define LCRPID_TUNE_STATE_OSC_PERFORM_1 12U + #define LCRPID_TUNE_STATE_OSC_SEQ_CNTL 11U + #define LCRTEMP_STEP_WAIT_HEAT 10U + #define LCRSLIMPID_REQU_DIR_POS 10U + #define LCRPID_TUNE_STATE_OSCILLATE 10U + #define LCRPID_TUNE_REQU_DIR_POS 10U + #define LCRDBLPID_MODE_TUNE_Y2 9U + #define LCRDBLPID_MODE_TUNE_Y1 8U + #define LCRDBLPID_MODE_TUNE_6 7U + #define LCRDBLPID_MODE_TUNE_4 6U + #define LCRPID_FBK_MODE_SET_YI 5U + #define LCRPID_MODE_FREEZE 5U + #define LCRTEMP_STEP_WAIT 5U + #define LCRSLIMPID_REQU_WRITE_PARAS 4U + #define LCRPID_MODE_CLOSE 4U + #define LCRPID_FBK_MODE_LIMIT_YI 4U + #define LCRDBLPID_TSTATE_ERROR 4U + #define LCRPID_FBK_MODE_EXT_SELECTOR 3U + #define LCRSLIMPID_REQU_READ_PARAS 3U + #define LCRDBLPID_TSTATE_FINISHED 3U + #define LCRPID_MODE_OPEN 3U + #define LCRPID_TUNE_REQU_STEPRESPONSE 2U + #define LCRPID_FBK_MODE_EXTERN 2U + #define LCRPID_MODE_MAN 2U + #define LCRSLIMPID_REQU_STEPRESPONSE 2U + #define LCRPID_D_MODE_E 2U + #define LCRDBLPID_TSTATE_Y2 2U + #define LCRTEMPPID_MODE_MAN 2U + #define LCRPID_DEADBAND_MODE_STANDARD_I 2U + #define LCRSLIMPID_REQU_OSCILLATE 1U + #define LCRTEMP_COOL 1U + #define LCRTEMP_PT2 1U + #define LCRTEMP_HYST_MODE_JOLTFREE 1U + #define LCRTEMPPID_MODE_AUTO 1U + #define LCRPID_TUNE_REQU_OSCILLATE 1U + #define LCRDBLPID_TSTATE_Y1 1U + #define LCRPID_FBK_MODE_INTERN 1U + #define LCRPID_DEADBAND_MODE_STANDARD 1U + #define LCRPID_D_MODE_X 1U + #define LCRPID_MODE_AUTO 1U + #define LCRTEMPTune_MODE_EXP 1U + #define LCRPID_TUNE_REQU_OFF 0U + #define LCRDBLPID_TSTATE_OFF 0U + #define LCRTEMPTune_MODE_DEF 0U + #define LCRTEMP_PT1 0U + #define LCRSLIMPID_REQU_OFF 0U + #define LCRPID_TUNE_STATE_READY 0U + #define LCRPID_MODE_OFF 0U + #define LCRTEMP_HEAT 0U + #define LCRPID_DEADBAND_MODE_ZERO 0U +#else + #ifndef _GLOBAL_CONST + #define _GLOBAL_CONST _WEAK const + #endif + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PER_5; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PER_5; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PER_4; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PER_4; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PER_3; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PER_3; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_ERROR; + _GLOBAL_CONST unsigned short LCR_ERR_DISABLED; + _GLOBAL_CONST unsigned short LCR_ERR_PT2O_TF_NEG_ZERO; + _GLOBAL_CONST unsigned short LCR_ERR_PT2O_D_NEG; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_DT_IGNORED; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_INVALID_MODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_INVALID_MODE; + _GLOBAL_CONST unsigned short LCR_WARN_PT2O_TF_TS; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_ASYNC; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_DT_HIGH; + _GLOBAL_CONST unsigned short LCR_ERR_SCHEDULE_N; + _GLOBAL_CONST unsigned short LCR_ERR_SCHEDULE_P; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_NO_TALT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_TKNICK; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_TASKTIME_0; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_ILLEGALMODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_WR_PTR; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_WR_PARA; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_WR_TSET; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_WR_PTR; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_MAXMIN; + _GLOBAL_CONST unsigned short LCR_ERR_POINTER; + _GLOBAL_CONST unsigned short LCR_ERR_LCRDBLPID_DX_DT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRDBLPID_WX_LOW; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_CONTROL_VAR; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_INVALID_REQU; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_FBKMODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_DYMAX; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_DMODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PARADAT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_MODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_IDENT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRMovAvgFlt_BASE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRIntegrate_TN; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OSC_3; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OSC_3; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OSC_2; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OSC_2; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTT_TT_NEG; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPT12_T2_NEG; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPT12_T1_NEG; + _GLOBAL_CONST unsigned short LCR_ERR_LCRCurveByPoints_TABLE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_DEADBAND; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_WX_MAXMIN; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_DEADBAND_MODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_W_CHANGED; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_TIMEOUT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_PARAMETER; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_ABORT; + _GLOBAL_CONST unsigned short LCR_ERR_MAXMIN; + _GLOBAL_CONST unsigned short LCR_ERR_LCRContinServo_TIMPULSE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRContinServo_TCHANGE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRRamp_DYUP_DYDOWN; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPWM_TPERIOD; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPWM_TPULSE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPWM_TMINPULSE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPT1_T; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_TV; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_TN; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_TF; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_KW; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_KP; + _GLOBAL_CONST unsigned short LCR_ERROR; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_KFBK; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPPID_WR_PARA; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_WR_BASE; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_WR_PARA; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_HEAT_TP; + _GLOBAL_CONST unsigned short LCR_WARN_LCRDBLPID_TUNE_CHANGE; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTT_MEM; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTT_TT_INT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTT_TT_TS; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTT_TT_ZERO; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T2_INT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T2_TS; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T2_ZERO; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T1_INT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T1_TS; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_YMAN_LIMIT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_A_LIMIT; + _GLOBAL_CONST unsigned short LCR_WARN_Tx_DT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T1_ZERO; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPIDTune_CYCLETIME; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_YFBK_LIMIT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_I_MINLIMIT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_I_MAXLIMIT; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OSC_1; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OSC_1; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_CHR_REF_OS; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_CHR_REF_OS; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_CHR_REF_AP; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_CHR_REF_AP; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_ZN_DIST; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_ZN_DIST; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_CHR_DIST_OS; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_CHR_DIST_OS; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_CHR_DIST_AP; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_CHR_DIST_AP; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_P; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_P; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PI; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PI; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_DONE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID_DONE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID_DONE_COOLONLY; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_COOL; + _GLOBAL_CONST unsigned short LCRPID_TUNE_ADDINFO_OSC_PERIOD; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_START_COOL; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT_COOLONLY; + _GLOBAL_CONST unsigned char LCRPID_MODE_FREEZE_JOLTFREE; + _GLOBAL_CONST unsigned char LCRPID_MODE_CLOSE_JOLTFREE; + _GLOBAL_CONST unsigned char LCRPID_MODE_OPEN_JOLTFREE; + _GLOBAL_CONST unsigned char LCRPID_MODE_MAN_JOLTFREE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT_COOL; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PID; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PID; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID_COOL; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_FREE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_START_FREE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT_FREE; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_FINISHED; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_RESET_CNTL; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_CALC_PARA; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID_FREE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_HEAT; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_STEP_WAITEQ2; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_STEP_MAXGRAD; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_DIR_NEG; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_START_HEAT; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_STEP_WAITEQ1; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_DIR_NEG; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSC_CNTLPAR; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSC_PERFORM_2; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSC_PERFORM_1; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSC_SEQ_CNTL; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT_HEAT; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_DIR_POS; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSCILLATE; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_DIR_POS; + _GLOBAL_CONST unsigned char LCRDBLPID_MODE_TUNE_Y2; + _GLOBAL_CONST unsigned char LCRDBLPID_MODE_TUNE_Y1; + _GLOBAL_CONST unsigned char LCRDBLPID_MODE_TUNE_6; + _GLOBAL_CONST unsigned char LCRDBLPID_MODE_TUNE_4; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_SET_YI; + _GLOBAL_CONST unsigned char LCRPID_MODE_FREEZE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_WRITE_PARAS; + _GLOBAL_CONST unsigned char LCRPID_MODE_CLOSE; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_LIMIT_YI; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_ERROR; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_EXT_SELECTOR; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_READ_PARAS; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_FINISHED; + _GLOBAL_CONST unsigned char LCRPID_MODE_OPEN; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_STEPRESPONSE; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_EXTERN; + _GLOBAL_CONST unsigned char LCRPID_MODE_MAN; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_STEPRESPONSE; + _GLOBAL_CONST unsigned char LCRPID_D_MODE_E; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_Y2; + _GLOBAL_CONST unsigned long LCRTEMPPID_MODE_MAN; + _GLOBAL_CONST unsigned char LCRPID_DEADBAND_MODE_STANDARD_I; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OSCILLATE; + _GLOBAL_CONST unsigned char LCRTEMP_COOL; + _GLOBAL_CONST unsigned char LCRTEMP_PT2; + _GLOBAL_CONST unsigned char LCRTEMP_HYST_MODE_JOLTFREE; + _GLOBAL_CONST unsigned long LCRTEMPPID_MODE_AUTO; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OSCILLATE; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_Y1; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_INTERN; + _GLOBAL_CONST unsigned char LCRPID_DEADBAND_MODE_STANDARD; + _GLOBAL_CONST unsigned char LCRPID_D_MODE_X; + _GLOBAL_CONST unsigned char LCRPID_MODE_AUTO; + _GLOBAL_CONST unsigned long LCRTEMPTune_MODE_EXP; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OFF; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_OFF; + _GLOBAL_CONST unsigned long LCRTEMPTune_MODE_DEF; + _GLOBAL_CONST unsigned char LCRTEMP_PT1; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OFF; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_READY; + _GLOBAL_CONST unsigned char LCRPID_MODE_OFF; + _GLOBAL_CONST unsigned char LCRTEMP_HEAT; + _GLOBAL_CONST unsigned char LCRPID_DEADBAND_MODE_ZERO; +#endif + + + + +/* Datatypes and datatypes of function blocks */ +typedef struct lcrCurveByPoints_TabEntry_type +{ float x; + float y; +} lcrCurveByPoints_TabEntry_type; + +typedef struct lcrdblpid_par_typ +{ float Y_max; + float Y_min; + signed short K_fact; + float Kp; + float Tn; + float Tv; +} lcrdblpid_par_typ; + +typedef struct lcrpid_tune_osc_options_typ +{ float osc_minAmplitude; + float Q_min; +} lcrpid_tune_osc_options_typ; + +typedef struct lcrpid_tune_step_options_typ +{ float eqDeltaX; + float eqDeltaWX; + float eqDeltat; + float evalDeltaX; + unsigned short evalNfilter; + unsigned short exitNotMaxdXCount; + float exitdXRatio; +} lcrpid_tune_step_options_typ; + +typedef struct lcrdblpid_tune_typ +{ signed short P1_manualAdjust; + signed short I1_manualAdjust; + signed short D1_manualAdjust; + signed short P2_manualAdjust; + signed short I2_manualAdjust; + signed short D2_manualAdjust; + float X_min; + float X_max; + float X0; + float de_min; + float Y0; + float Y1step; + float Y2step; + unsigned long tuneY1_opt; + unsigned long tuneY2_opt; + unsigned char tune_first; + float hyst; + float measDelta; + struct lcrpid_tune_osc_options_typ osc_opt; + struct lcrpid_tune_step_options_typ step_opt; +} lcrdblpid_tune_typ; + +typedef struct lcrpid_internal_typ +{ unsigned short size; + plcbit valid; + float WX_max; + float WX_min; + plcbit invert; + float deadband; + unsigned char deadband_mode; + float dY_max; + float Kp; + float Kp_Tn; + float Tv_Tf; + float Tf_reciproc; + float Kw; + float Kfbk_Kp; + float Kfbk_Kp_max; + unsigned char fbk_mode; + unsigned char d_mode; + unsigned char force_mode; + float Y_force; + float W; + float X; + unsigned char pid_init; + signed long Yp1; + signed long Yp2; + signed long dYi1; + signed long dYi2; + signed long Yi1; + signed long Yi2; + float dt_Tf; + signed long a11; + signed long a12; + signed long a21; + signed long a22; + signed long Yd1; + signed long Yd2; + signed long Ytotal1; + signed long Ytotal2; + signed long Ylim1; + signed long Ylim2; + signed long Y1; + signed long Y2; + float deltaY_fbk; + float e_fbk; +} lcrpid_internal_typ; + +typedef struct lcrpid_procPar_typ +{ unsigned short size; + plcbit valid; + plcbit stepResp_valid; + float stepResp_v; + float stepResp_t_u; + float stepResp_t_g; + plcbit osc_valid; + float osc_amplitudeRatio; + float osc_tPeriod; + plcbit force_params; + float Kp; + float Kp_tune; + float Tn; + float Tn_tune; + float Tv; + float Tv_tune; +} lcrpid_procPar_typ; + +typedef struct lcrpid_old_typ +{ struct lcrpid_procPar_typ processPar; + signed short P_manualAdjust; + signed short I_manualAdjust; + signed short D_manualAdjust; + float Y_min; + float Y_max; + float dY_max; + float Tf_Tv; + float Kw; + float Kfbk; + float deadband; + float W; + unsigned long request; + unsigned char fbk_mode; + unsigned char d_mode; + plcbit invert; + plcbit enable; +} lcrpid_old_typ; + +typedef struct lcrpid_osc_val_typ +{ float X; + float t; +} lcrpid_osc_val_typ; + +typedef struct lcrpid_osc_per_typ +{ struct lcrpid_osc_val_typ max; + struct lcrpid_osc_val_typ min; +} lcrpid_osc_per_typ; + +typedef struct lcrpid_tune_addpar_typ +{ float t_max_tune; + float WX_min; + float WX_max; + float dY_max; + float Tf_Tv; + float Kw; + float Kfbk; + unsigned char fbk_mode; + unsigned char d_mode; + float deadband; + unsigned char deadband_mode; + plcbit invert; +} lcrpid_tune_addpar_typ; + +typedef struct lcrpid_tune_osc_typ +{ struct lcrpid_tune_osc_options_typ options; + unsigned short oscPhase; + signed char dir; + plcbit enHi; + plcbit enLo; + float Y_hi; + float Y_lo; + unsigned short i_maxPeriod; + unsigned short i_period; + float X_ampl; + float X_avg; + float X_min_avg; + float X_max_avg; + float Y_avg; + float deltaY; + float t_Ylohi[5]; + float t_Yhilo[5]; + float Q_act; + float a_wx; + float amplitudeRatio; + float Ku; + float tPeriod; + struct lcrpid_osc_per_typ period[5]; +} lcrpid_tune_osc_typ; + +typedef struct lcrpid_tune_step_typ +{ struct lcrpid_tune_step_options_typ options; + float Y0; + float Y1; + float t_jump; + float W; + float X0; + float Xmax; + float Xmin; + float Xfiltered; + plcbit deltaXok; + plcbit deltaWXok; + float eqTime; + signed char dir; + float deltaX; + float X1; + float t1; + plcbit t1set; + float dX_dt; + float dX_dt_max; + float XmaxGrad; + float maxX1; + float maxX2; + float maxt1; + float maxt2; + float tmaxGrad; + float gainFactor; + float deadTime; + float riseTime; + unsigned short notMaxCount; + float gradientRatio; +} lcrpid_tune_step_typ; + +typedef struct lcrpt2o_Internal_typ +{ signed long Ts; + unsigned long Ts_dbl_1; + unsigned long Ts_dbl_2; + float V_old; + float D_old; + float Tf_old; + unsigned char Set_y_old; + unsigned char Set_y_2; + unsigned long x1_dbl_1; + unsigned long x1_dbl_2; + unsigned long x2_dbl_1; + unsigned long x2_dbl_2; + unsigned long Sqrt_D_1_dbl_1; + unsigned long Sqrt_D_1_dbl_2; + unsigned long Ts_Tf_dbl_1; + unsigned long Ts_Tf_dbl_2; + unsigned long Exp_D_Ts_Tf_dbl_1; + unsigned long Exp_D_Ts_Tf_dbl_2; + unsigned long a0_dbl_1; + unsigned long a0_dbl_2; + unsigned long a1_dbl_1; + unsigned long a1_dbl_2; + unsigned long b0_dbl_1; + unsigned long b0_dbl_2; + unsigned long b1_dbl_1; + unsigned long b1_dbl_2; + unsigned long Bootkey; +} lcrpt2o_Internal_typ; + +typedef struct LCRPWM +{ + /* VAR_INPUT (analog) */ + float x; + float max_value; + float min_value; + float t_min_pulse; + float t_period; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float t_on; + float t_off; + /* VAR (analog) */ + signed long cnt_terron_1; + signed long cnt_terron_2; + signed long cnt_terroff_1; + signed long cnt_terroff_2; + signed long cnt_t_pulse_1; + signed long cnt_t_pulse_2; + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR_OUTPUT (digital) */ + plcbit pulse; + /* VAR (digital) */ + plcbit corr; +} LCRPWM_typ; + +typedef struct lcrschedule_add_typ +{ float periodTime; + float onTime; + float t_on_intern; + float bcOnTime; + unsigned short sortIndex; + struct LCRPWM fbkPWM; + plcbit flagDelay; +} lcrschedule_add_typ; + +typedef struct lcrschedule_par_typ +{ float P; + float X; + plcbit pulse; + float Pout; + plcbit lim; + struct lcrschedule_add_typ Internal; +} lcrschedule_par_typ; + +typedef struct lcrslimpid_par_typ +{ float Y_max; + float Y_min; + float Kp; + float Tn; + float Tv; + float Kfbk; +} lcrslimpid_par_typ; + +typedef struct lcrtemp_add_typ +{ float mem01; + float mem02; + float mem10; + float mem20; + float exp_mem; + float cnt01; + float cnt02; + float cnt10; + float cnt20; + float cnt03; + float cnt30; + float cnt00; + float t_ignore_dT_heat; + float t_ignore_dT_free; + float t_ignore_dT_cool; + float yMin; + float yMax; + unsigned long reserved3; + unsigned long reserved4; + plcbit reserved5; + plcbit reserved6; +} lcrtemp_add_typ; + +typedef struct lcrtemp_pid_internal_typ +{ plcbit enable_cooling; + plcbit disable_heating; + float hyst; + float delay; + float Kw; + float Kfbk; + float Kp_h; + float Tn_h; + float Tv_h; + float Kp_c; + float Tn_c; + float Tv_c; + float dynGeneral; + float dynHeat; + float dynCool; + float mem01; + float mem02; + float mem10; + float mem20; + float exp_mem; + float yMin; + float yMax; +} lcrtemp_pid_internal_typ; + +typedef struct lcrtemp_pid_opt_typ +{ float Kp_h; + float Tn_h; + float Tv_h; + float Tf_h; + float Kp_c; + float Tn_c; + float Tv_c; + float Tf_c; + float dynGeneral; + float dynHeat; + float dynCool; +} lcrtemp_pid_opt_typ; + +typedef struct lcrtemp_pid_set_typ +{ float hyst; + unsigned char hyst_mode; + float delay; + float Kw; + float Kfbk; +} lcrtemp_pid_set_typ; + +typedef struct lcrtemp_tune_set_typ +{ unsigned long mode; + float Temp_amb; + float dRatio_heat; + float cnt_tp_heat; + float delta_T_heat; + float dT_min_heat; + float dRatio_free; + float cnt_tp_free; + float delta_T_free; + float dT_min_free; + float dRatio_cool; + float cnt_tp_cool; + float delta_T_cool; + float dT_min_cool; + float delta_T_sync_heat; + float delta_dT_sync_heat; + float cnt_wait_heat; + float delta_T_sync_free; + float delta_dT_sync_free; + float cnt_wait_free; + float delta_T_sync_cool; + float delta_dT_sync_cool; + float cnt_wait_cool; + float filter_base_T; + float delta_T_sync_stop; + float Y_heat_tune; +} lcrtemp_tune_set_typ; + +typedef struct lcrtemp_set_typ +{ plcbit enable_cooling; + plcbit disable_heating; + struct lcrtemp_pid_opt_typ PIDpara; + struct lcrtemp_tune_set_typ TuneSet; + struct lcrtemp_pid_set_typ PIDSet; + struct lcrtemp_add_typ Internal; +} lcrtemp_set_typ; + +typedef struct lcrtemp_tune_internal_typ +{ plcbit cool_tuning; + plcbit disable_heating; + unsigned long mode; + float Temp_amb; + float dRatio_heat; + float cnt_tp_heat; + float delta_T_heat; + float dT_min_heat; + float dRatio_free; + float cnt_tp_free; + float delta_T_free; + float dT_min_free; + float dRatio_cool; + float cnt_tp_cool; + float delta_T_cool; + float dT_min_cool; + float delta_T_sync_heat; + float delta_dT_sync_heat; + float cnt_wait_heat; + float delta_T_sync_free; + float delta_dT_sync_free; + float cnt_wait_free; + float delta_T_sync_cool; + float delta_dT_sync_cool; + float cnt_wait_cool; + float filter_base_T; + float t_ignore_dT_heat; + float t_ignore_dT_free; + float t_ignore_dT_cool; + float delta_T_sync_stop; +} lcrtemp_tune_internal_typ; + +typedef struct LCRScal +{ + /* VAR_INPUT (analog) */ + float x; + float x1; + float y1; + float x2; + float y2; + /* VAR_OUTPUT (analog) */ + float y; +} LCRScal_typ; + +typedef struct LCRPID +{ + /* VAR_INPUT (analog) */ + unsigned long ident; + float W; + float X; + float Y_max; + float Y_min; + float A; + float Y_man; + float Y_fbk; + unsigned char mode; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float e; + float Y; + float Yp; + float Yi; + float Yd; + /* VAR (analog) */ + float Yi_set; + float Yi_min; + float Yi_max; + float Yi_minInternal; + float Yi_maxInternal; + float Tv_Tf_old; + float e_old; + unsigned short deadband_state; + struct SysInfo sysinfo_inst; + struct LCRScal scal_inst; + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + unsigned short musecs_old; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit hold_I; + /* VAR (digital) */ + plcbit Set_Yi; + plcbit force_Yi; + plcbit joltFreeDoneLowerLim; + plcbit joltFreeDoneUpperLim; + plcbit enable_old; +} LCRPID_typ; + +typedef struct LCRCurveByPoints +{ + /* VAR_INPUT (analog) */ + float x; + unsigned short NoOfPoints; + struct lcrCurveByPoints_TabEntry_type* ptr_table; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + signed short i_tab; + unsigned short iterations; + struct LCRScal scal1; +} LCRCurveByPoints_typ; + +typedef struct LCRPIDpara +{ + /* VAR_INPUT (analog) */ + float WX_max; + float WX_min; + float deadband; + unsigned char deadband_mode; + float dY_max; + float Kp; + float Tn; + float Tv; + float Tf; + float Kw; + float Kfbk; + unsigned char fbk_mode; + unsigned char d_mode; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned long ident; + /* VAR (analog) */ + struct lcrpid_internal_typ internal_data; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit enter; + plcbit invert; +} LCRPIDpara_typ; + +typedef struct LCRContinServo +{ + /* VAR_INPUT (analog) */ + float x; + float max_value; + float min_value; + float t_impulse; + float t_change_up; + float t_change_down; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float hysteresis_up; + float hysteresis_down; + /* VAR (analog) */ + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + signed long t_cnt_1; + signed long t_cnt_2; + signed long y_dbl_1; + signed long y_dbl_2; + struct SysInfo sysInfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit ref; + /* VAR_OUTPUT (digital) */ + plcbit up; + plcbit down; + plcbit refOk; + /* VAR (digital) */ + plcbit enable_old; + plcbit ref_old; +} LCRContinServo_typ; + +typedef struct LCRPT1 +{ + /* VAR_INPUT (analog) */ + float x; + float t; + float y_set; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + signed long y_dbl_1; + signed long y_dbl_2; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit set; +} LCRPT1_typ; + +typedef struct LCRRamp +{ + /* VAR_INPUT (analog) */ + float x; + float dy_up; + float dy_down; + float y_max; + float y_min; + float y_set; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + signed long y_dbl_1; + signed long y_dbl_2; + unsigned long timestore1; + unsigned long timestore2; + unsigned long getDtForceOff; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit set; + /* VAR_OUTPUT (digital) */ + plcbit x_reached; + plcbit max_limit; + plcbit min_limit; +} LCRRamp_typ; + +typedef struct LCRIntegrate +{ + /* VAR_INPUT (analog) */ + float x; + float tn; + float y_max; + float y_min; + float y_set; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + signed long y_dbl_1; + signed long y_dbl_2; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit set; + /* VAR_OUTPUT (digital) */ + plcbit max_limit; + plcbit min_limit; +} LCRIntegrate_typ; + +typedef struct LCRLimit +{ + /* VAR_INPUT (analog) */ + float in; + signed long max_value; + signed long min_value; + /* VAR_OUTPUT (analog) */ + unsigned short status; + signed long out; + /* VAR_OUTPUT (digital) */ + plcbit max_limit; + plcbit min_limit; +} LCRLimit_typ; + +typedef struct LCRLimScal +{ + /* VAR_INPUT (analog) */ + float x; + float x1; + float y1; + float x2; + float y2; + /* VAR_OUTPUT (analog) */ + float y; +} LCRLimScal_typ; + +typedef struct LCRMovAvgFlt +{ + /* VAR_INPUT (analog) */ + float x; + unsigned short base; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + signed long sum_old_dbl_1; + signed long sum_old_dbl_2; + unsigned long p_xold; + unsigned short i_xold; + unsigned short base_old; + unsigned long bootkey_old; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR (digital) */ + plcbit enable_old; +} LCRMovAvgFlt_typ; + +typedef struct LCRTimeBasedOnOff +{ + /* VAR_INPUT (analog) */ + float x; + float max_value; + float min_value; + float timpulse; + float tchange_up; + float tchange_down; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float hysteresis_up; + float hysteresis_down; + /* VAR (analog) */ + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + signed long t_cnt_1; + signed long t_cnt_2; + signed long y_dbl_1; + signed long y_dbl_2; + struct SysInfo sysInfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit ref; + /* VAR_OUTPUT (digital) */ + plcbit up; + plcbit down; + plcbit refOk; + /* VAR (digital) */ + plcbit enable_old; + plcbit ref_old; +} LCRTimeBasedOnOff_typ; + +typedef struct LCRDifferentiate +{ + /* VAR_INPUT (analog) */ + float x; + float tv; + float tf; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + struct SysInfo sysinfo_inst; + signed long a11; + signed long a12; + signed long a21; + signed long a22; + /* VAR_INPUT (digital) */ + plcbit enable; +} LCRDifferentiate_typ; + +typedef struct LCRPIDTune +{ + /* VAR_INPUT (analog) */ + float Y_min; + float Y_max; + float Y0; + float Y1; + float X0; + float X_min; + float X_max; + signed short P_manualAdjust; + signed short I_manualAdjust; + signed short D_manualAdjust; + unsigned long request; + struct lcrpid_tune_addpar_typ* pAddPar; + struct lcrpid_tune_osc_options_typ* pOptions_osc; + struct lcrpid_tune_step_options_typ* pOptions_step; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned short addInfo; + unsigned long ident; + unsigned short state; + /* VAR (analog) */ + float t_autotune; + unsigned short status_tmp; + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + float e; + float e_minAmp; + float e_old_up; + float e_old_down; + float e_old; + struct SysInfo sysinfo_inst; + struct LCRMovAvgFlt MovAvgFlt_inst; + struct lcrpid_old_typ old; + struct lcrpid_procPar_typ processPar; + struct lcrpid_internal_typ internal_data; + struct lcrpid_tune_addpar_typ addPar; + struct lcrpid_tune_osc_typ oscillation; + struct lcrpid_tune_step_typ stepresponse; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit okToStep; + /* VAR_OUTPUT (digital) */ + plcbit rdyToStep; + /* VAR (digital) */ + plcbit curveDown; + plcbit curveUp; +} LCRPIDTune_typ; + +typedef struct LCRSlimPID +{ + /* VAR_INPUT (analog) */ + float W; + float X; + unsigned long request; + struct lcrslimpid_par_typ* pPar; + /* VAR_OUTPUT (analog) */ + float e; + float Y; + unsigned short status; + unsigned short addInfo; + /* VAR (analog) */ + struct LCRMovAvgFlt MovAvgFlt_inst; + struct LCRPIDTune PIDTune_inst; + struct LCRPID PID_inst; + unsigned long requ_old; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR (digital) */ + plcbit enable_old; +} LCRSlimPID_typ; + +typedef struct LCRPFM +{ + /* VAR_INPUT (analog) */ + float x; + float max_value; + float min_value; + float t_pulse; + float t_pause; + /* VAR_OUTPUT (analog) */ + unsigned short status; + /* VAR (analog) */ + float area; + float area_c; + float range; + float last; + float tpls; + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR_OUTPUT (digital) */ + plcbit pulse; + /* VAR (digital) */ + plcbit enable_old; +} LCRPFM_typ; + +typedef struct LCRTt +{ + /* VAR_INPUT (analog) */ + signed long Tt; + float x; + float y_set; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + signed long Ts; + signed long Tt_Max; + float* pRingBuf; + float* pBuf_OutIn; + unsigned char set_old; + unsigned char Set_y; + unsigned long Bootkey; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit set; + /* VAR (digital) */ + plcbit enable_old; +} LCRTt_typ; + +typedef struct LCRPT2 +{ + /* VAR_INPUT (analog) */ + float V; + float T1; + float T2; + float x; + float y_set; + unsigned char set; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + unsigned long x1_dbl_1; + unsigned long x1_dbl_2; + unsigned long x2_dbl_1; + unsigned long x2_dbl_2; + signed long Ts; + unsigned long Ts_dbl_1; + unsigned long Ts_dbl_2; + unsigned char set_old; + unsigned char Set_y; + unsigned long Bootkey; + /* VAR_INPUT (digital) */ + plcbit enable; +} LCRPT2_typ; + +typedef struct LCRSimModExt +{ + /* VAR_INPUT (analog) */ + signed long Tt_h; + signed long Tt_c; + float k_h; + float k_c; + float PT2_T1; + float PT2_T2; + float Temp_amb; + float Temp_c; + float Alpha_h; + float Alpha_c; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + struct LCRTt Tt_heat; + struct LCRTt Tt_cool; + float k_h_intern; + float k_c_intern; + struct LCRPT2 PT2; + float y_c; + float y_end; + float y_h; + unsigned long Bootkey; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR (digital) */ + plcbit enable_old; +} LCRSimModExt_typ; + +typedef struct LCRPT1e +{ + /* VAR_INPUT (analog) */ + float V; + float T1; + float x; + float y_set; + unsigned char set; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + unsigned long x1_dbl_1; + unsigned long x1_dbl_2; + signed long Ts; + unsigned long Ts_dbl_1; + unsigned long Ts_dbl_2; + unsigned char set_old; + unsigned char Set_y; + unsigned long Bootkey; + /* VAR_INPUT (digital) */ + plcbit enable; +} LCRPT1e_typ; + +typedef struct LCRDblActPID +{ + /* VAR_INPUT (analog) */ + float W; + float X; + float Y_man; + unsigned char mode; + struct lcrdblpid_par_typ* pPar1; + struct lcrdblpid_par_typ* pPar2; + struct lcrpid_tune_addpar_typ* pAddPar; + struct lcrdblpid_tune_typ* pOpt; + /* VAR_OUTPUT (analog) */ + float e; + float Y1; + float Y2; + unsigned short status; + unsigned char tuneState; + /* VAR (analog) */ + struct LCRPID pid; + struct LCRPIDTune tune; + struct SysInfo sysinfo_inst; + float gradient; + float Y_avg; + unsigned long tcnt_1; + unsigned long tcnt_2; + float Tmeas; + float y_lim_old; + float p_fact; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + unsigned char use_par; + unsigned char meas; + unsigned char mode_old; + unsigned char tune_step; + unsigned char tune_grad; + unsigned char tune_2nd; + unsigned char invert; + unsigned char counter_state; + unsigned char mode_int; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit hold_I; + plcbit okToStep; + /* VAR_OUTPUT (digital) */ + plcbit rdyToStep; + /* VAR (digital) */ + plcbit enable_old; +} LCRDblActPID_typ; + +typedef struct LCRMinMax +{ + /* VAR_INPUT (analog) */ + float in; + /* VAR_OUTPUT (analog) */ + float out_min; + float out_max; + /* VAR_INPUT (digital) */ + plcbit reset; +} LCRMinMax_typ; + +typedef struct LCRTempPID +{ + /* VAR_INPUT (analog) */ + float Temp_set; + float Temp; + float Y_man; + unsigned long mode; + struct lcrtemp_set_typ* pSettings; + /* VAR_OUTPUT (analog) */ + float y_heat; + float y_cool; + unsigned short status; + /* VAR (analog) */ + struct LCRPID pid; + struct LCRPIDpara pid_para; + float Temp_set_delay; + float Temp_set_int; + float TempSetOld; + float delayCnt; + signed char stateOld; + signed char state; + float a; + struct SysInfo sysinfo_inst; + unsigned char para_check_done; + struct lcrtemp_pid_internal_typ internal_para; + float dbl_dt; + float tAlt; + float altTime; + float tKnick; + float fAlt; + float a_alt; + float a_e; + float a_internal; + float Temp_set_int_old1; + float Temp_set_int_old2; + float Temp_set_int_old3; + unsigned long mode_old; + unsigned long timestore1; + unsigned long timestore2; + float yManInternal; + unsigned long timeCnt; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit update; + /* VAR (digital) */ + plcbit delayFlag; + plcbit enable_old; + plcbit altActive; + plcbit err_flag; +} LCRTempPID_typ; + +typedef struct LCRPT2o +{ + /* VAR_INPUT (analog) */ + float V; + float D; + float Tf; + float u; + unsigned char Set_y; + float y_set; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + struct lcrpt2o_Internal_typ Internal; + /* VAR_INPUT (digital) */ + plcbit enable; +} LCRPT2o_typ; + +typedef struct LCRTempTune +{ + /* VAR_INPUT (analog) */ + float Temp_set; + float Temp; + struct lcrtemp_set_typ* pSettings; + /* VAR_OUTPUT (analog) */ + float y_heat; + float y_cool; + unsigned short status; + /* VAR (analog) */ + struct LCRPID pid; + struct LCRPIDpara pid_para; + struct LCRDifferentiate DT2; + struct LCRPT2o pt2; + float Temp_flt; + unsigned short step; + float t; + float Temp_start; + float mem00; + float cnt02; + float cnt33; + float cnt20; + float pem01; + float pem33; + float pem10; + float pem02; + float pem44; + float pem20; + float tol01; + float tol10; + float tol02; + float tol20; + float tol22; + float Temp_old; + float delta_Temp; + unsigned long tcnt_1; + unsigned long tcnt_2; + unsigned long tcnt_dT_1; + unsigned long tcnt_dT_2; + struct SysInfo sysinfo_inst; + float Temp_set_internal; + float timecounter; + struct lcrtemp_tune_internal_typ internal_para; + float dbl_dt; + unsigned long call_counter; + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + float timer2; + unsigned short waitCounter; + float Y_heat_tune_intern; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit start; + plcbit okToHeat; + plcbit okToFree; + plcbit okToFreeEnd; + plcbit okToCool; + plcbit okToCoolEnd; + /* VAR_OUTPUT (digital) */ + plcbit rdyToHeat; + plcbit rdyToFree; + plcbit rdyToFreeEnd; + plcbit rdyToCool; + plcbit rdyToCoolEnd; + plcbit done; + plcbit busy; + /* VAR (digital) */ + plcbit enable_old; +} LCRTempTune_typ; + +typedef struct LCRSchedulePWM +{ + /* VAR_INPUT (analog) */ + float Pmax; + unsigned short n; + unsigned long pPar; + float min_value; + float max_value; + float t_min_pulse; + float t_period; + /* VAR_OUTPUT (analog) */ + unsigned short status; + /* VAR (analog) */ + struct SysInfo sysinfo_inst; + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + unsigned short numberUnits; + unsigned short limFact; + float Pact; + float Pman; + float intern0[6]; + struct lcrschedule_par_typ* in; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR (digital) */ + plcbit enable_old; + plcbit cmd_delay; + plcbit err_flag; + plcbit limAll; +} LCRSchedulePWM_typ; + + + +/* Prototyping of functions and function blocks */ +_BUR_PUBLIC void LCRPID(struct LCRPID* inst); +_BUR_PUBLIC void LCRScal(struct LCRScal* inst); +_BUR_PUBLIC void LCRCurveByPoints(struct LCRCurveByPoints* inst); +_BUR_PUBLIC void LCRPIDpara(struct LCRPIDpara* inst); +_BUR_PUBLIC void LCRContinServo(struct LCRContinServo* inst); +_BUR_PUBLIC void LCRPT1(struct LCRPT1* inst); +_BUR_PUBLIC void LCRRamp(struct LCRRamp* inst); +_BUR_PUBLIC void LCRIntegrate(struct LCRIntegrate* inst); +_BUR_PUBLIC void LCRLimit(struct LCRLimit* inst); +_BUR_PUBLIC void LCRLimScal(struct LCRLimScal* inst); +_BUR_PUBLIC void LCRPWM(struct LCRPWM* inst); +_BUR_PUBLIC void LCRMovAvgFlt(struct LCRMovAvgFlt* inst); +_BUR_PUBLIC void LCRTimeBasedOnOff(struct LCRTimeBasedOnOff* inst); +_BUR_PUBLIC void LCRDifferentiate(struct LCRDifferentiate* inst); +_BUR_PUBLIC void LCRSlimPID(struct LCRSlimPID* inst); +_BUR_PUBLIC void LCRPIDTune(struct LCRPIDTune* inst); +_BUR_PUBLIC void LCRPFM(struct LCRPFM* inst); +_BUR_PUBLIC void LCRSimModExt(struct LCRSimModExt* inst); +_BUR_PUBLIC void LCRTt(struct LCRTt* inst); +_BUR_PUBLIC void LCRPT2(struct LCRPT2* inst); +_BUR_PUBLIC void LCRPT1e(struct LCRPT1e* inst); +_BUR_PUBLIC void LCRDblActPID(struct LCRDblActPID* inst); +_BUR_PUBLIC void LCRMinMax(struct LCRMinMax* inst); +_BUR_PUBLIC void LCRTempPID(struct LCRTempPID* inst); +_BUR_PUBLIC void LCRTempTune(struct LCRTempTune* inst); +_BUR_PUBLIC void LCRPT2o(struct LCRPT2o* inst); +_BUR_PUBLIC void LCRSchedulePWM(struct LCRSchedulePWM* inst); + + +#ifdef __cplusplus +}; +#endif +#endif /* _LOOPCONR_ */ + diff --git a/Logical/Libraries/LoopConR/SG4/libLoopConR.a b/Logical/Libraries/LoopConR/SG4/libLoopConR.a new file mode 100644 index 0000000000000000000000000000000000000000..20ece35c2b644e308de0a720faf20978a94339cf GIT binary patch literal 14211 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 M0CZV4qdZXl3(HMDcK`qY literal 0 HcmV?d00001 diff --git a/Logical/Libraries/LoopConR/SGC/LoopConR.h b/Logical/Libraries/LoopConR/SGC/LoopConR.h new file mode 100644 index 0000000..e88fcf4 --- /dev/null +++ b/Logical/Libraries/LoopConR/SGC/LoopConR.h @@ -0,0 +1,1677 @@ +/* Automation Studio generated header file */ +/* Do not edit ! */ +/* LoopConR 4.10.2 */ + +#ifndef _LOOPCONR_ +#define _LOOPCONR_ +#ifdef __cplusplus +extern "C" +{ +#endif +#ifndef _LoopConR_VERSION +#define _LoopConR_VERSION 4.10.2 +#endif + +#include + +#ifndef _BUR_PUBLIC +#define _BUR_PUBLIC +#endif +#ifdef _SG4 + #include "sys_lib.h" + #include "brsystem.h" +#endif +#ifdef _SG3 + #include "sys_lib.h" + #include "brsystem.h" +#endif +#ifdef _SGC + #include "sys_lib.h" + #include "brsystem.h" +#endif + +/* Constants */ +#ifdef _REPLACE_CONST + #define LCRPID_TUNE_REQU_PER_5 500000U + #define LCRSLIMPID_REQU_PER_5 500000U + #define LCRSLIMPID_REQU_PER_4 400000U + #define LCRPID_TUNE_REQU_PER_4 400000U + #define LCRPID_TUNE_REQU_PER_3 300000U + #define LCRSLIMPID_REQU_PER_3 300000U + #define LCRTEMP_STEP_ERROR 65535U + #define LCR_ERR_DISABLED 65534U + #define LCR_ERR_PT2O_TF_NEG_ZERO 33154U + #define LCR_ERR_PT2O_D_NEG 33153U + #define LCR_ERR_LCRTEMPTune_DT_IGNORED 33152U + #define LCR_ERR_LCRTEMPPID_INVALID_MODE 33151U + #define LCR_ERR_LCRTEMPTune_INVALID_MODE 33150U + #define LCR_WARN_PT2O_TF_TS 33102U + #define LCR_WARN_LCRTEMPTune_ASYNC 33101U + #define LCR_WARN_LCRTEMPTune_DT_HIGH 33100U + #define LCR_ERR_SCHEDULE_N 31574U + #define LCR_ERR_SCHEDULE_P 31573U + #define LCR_ERR_LCRTEMPPID_NO_TALT 31572U + #define LCR_ERR_LCRTEMPPID_TKNICK 31571U + #define LCR_ERR_LCRTEMPTune_TASKTIME_0 31570U + #define LCR_ERR_LCRTEMPPID_ILLEGALMODE 31569U + #define LCR_ERR_LCRTEMPPID_WR_PTR 31568U + #define LCR_ERR_LCRTEMPPID_WR_PARA 31567U + #define LCR_ERR_LCRTEMPTune_WR_TSET 31567U + #define LCR_ERR_LCRTEMPTune_WR_PTR 31566U + #define LCR_ERR_LCRPIDTune_MAXMIN 31564U + #define LCR_ERR_POINTER 31563U + #define LCR_ERR_LCRDBLPID_DX_DT 31562U + #define LCR_ERR_LCRDBLPID_WX_LOW 31561U + #define LCR_ERR_LCRPIDTune_CONTROL_VAR 31560U + #define LCR_ERR_LCRPIDTune_INVALID_REQU 31559U + #define LCR_ERR_LCRPID_PAR_FBKMODE 31558U + #define LCR_ERR_LCRPID_PAR_DYMAX 31557U + #define LCR_ERR_LCRPID_PAR_DMODE 31556U + #define LCR_ERR_LCRPID_PARADAT 31554U + #define LCR_ERR_LCRPID_MODE 31553U + #define LCR_ERR_LCRPID_IDENT 31552U + #define LCR_ERR_LCRMovAvgFlt_BASE 31551U + #define LCR_ERR_LCRIntegrate_TN 31550U + #define LCRPID_TUNE_REQU_OSC_3 30000U + #define LCRSLIMPID_REQU_OSC_3 30000U + #define LCRPID_TUNE_REQU_OSC_2 20000U + #define LCRSLIMPID_REQU_OSC_2 20000U + #define LCR_ERR_LCRTT_TT_NEG 12048U + #define LCR_ERR_LCRPT12_T2_NEG 12047U + #define LCR_ERR_LCRPT12_T1_NEG 12046U + #define LCR_ERR_LCRCurveByPoints_TABLE 12045U + #define LCR_ERR_LCRPID_PAR_DEADBAND 12044U + #define LCR_ERR_LCRPID_PAR_WX_MAXMIN 12043U + #define LCR_ERR_LCRPID_PAR_DEADBAND_MODE 12042U + #define LCR_ERR_LCRPIDTune_W_CHANGED 12041U + #define LCR_ERR_LCRPIDTune_TIMEOUT 12040U + #define LCR_ERR_LCRPIDTune_PARAMETER 12039U + #define LCR_ERR_LCRPIDTune_ABORT 12038U + #define LCR_ERR_MAXMIN 12037U + #define LCR_ERR_LCRContinServo_TIMPULSE 12036U + #define LCR_ERR_LCRContinServo_TCHANGE 12035U + #define LCR_ERR_LCRRamp_DYUP_DYDOWN 12034U + #define LCR_ERR_LCRPWM_TPERIOD 12033U + #define LCR_ERR_LCRPWM_TPULSE 12033U + #define LCR_ERR_LCRPWM_TMINPULSE 12032U + #define LCR_ERR_LCRPT1_T 12031U + #define LCR_ERR_LCRPID_PAR_TV 12030U + #define LCR_ERR_LCRPID_PAR_TN 12029U + #define LCR_ERR_LCRPID_PAR_TF 12028U + #define LCR_ERR_LCRPID_PAR_KW 12027U + #define LCR_ERR_LCRPID_PAR_KP 12026U + #define LCR_ERROR 12025U + #define LCR_ERR_LCRPID_PAR_KFBK 12025U + #define LCR_WARN_LCRTEMPPID_WR_PARA 12024U + #define LCR_WARN_LCRTEMPTune_WR_BASE 12023U + #define LCR_WARN_LCRTEMPTune_WR_PARA 12022U + #define LCR_WARN_LCRTEMPTune_HEAT_TP 12021U + #define LCR_WARN_LCRDBLPID_TUNE_CHANGE 12019U + #define LCR_WARN_LCRTT_MEM 12018U + #define LCR_WARN_LCRTT_TT_INT 12017U + #define LCR_WARN_LCRTT_TT_TS 12016U + #define LCR_WARN_LCRTT_TT_ZERO 12015U + #define LCR_WARN_LCRPT12_T2_INT 12014U + #define LCR_WARN_LCRPT12_T2_TS 12013U + #define LCR_WARN_LCRPT12_T2_ZERO 12012U + #define LCR_WARN_LCRPT12_T1_INT 12011U + #define LCR_WARN_LCRPT12_T1_TS 12010U + #define LCR_WARN_LCRPID_YMAN_LIMIT 12009U + #define LCR_WARN_LCRPID_A_LIMIT 12008U + #define LCR_WARN_Tx_DT 12007U + #define LCR_WARN_LCRPT12_T1_ZERO 12005U + #define LCR_WARN_LCRPIDTune_CYCLETIME 12004U + #define LCR_WARN_LCRPID_YFBK_LIMIT 12003U + #define LCR_WARN_LCRPID_I_MINLIMIT 12002U + #define LCR_WARN_LCRPID_I_MAXLIMIT 12001U + #define LCRSLIMPID_REQU_OSC_1 10000U + #define LCRPID_TUNE_REQU_OSC_1 10000U + #define LCRSLIMPID_REQU_CHR_REF_OS 5000U + #define LCRPID_TUNE_REQU_CHR_REF_OS 5000U + #define LCRSLIMPID_REQU_CHR_REF_AP 4000U + #define LCRPID_TUNE_REQU_CHR_REF_AP 4000U + #define LCRPID_TUNE_REQU_ZN_DIST 3000U + #define LCRSLIMPID_REQU_ZN_DIST 3000U + #define LCRPID_TUNE_REQU_CHR_DIST_OS 2000U + #define LCRSLIMPID_REQU_CHR_DIST_OS 2000U + #define LCRPID_TUNE_REQU_CHR_DIST_AP 1000U + #define LCRSLIMPID_REQU_CHR_DIST_AP 1000U + #define LCRSLIMPID_REQU_P 300U + #define LCRPID_TUNE_REQU_P 300U + #define LCRSLIMPID_REQU_PI 200U + #define LCRPID_TUNE_REQU_PI 200U + #define LCRTEMP_STEP_DONE 130U + #define LCRTEMP_STEP_PID_DONE 125U + #define LCRTEMP_STEP_PID_DONE_COOLONLY 122U + #define LCRTEMP_STEP_COOL 120U + #define LCRPID_TUNE_ADDINFO_OSC_PERIOD 111U + #define LCRTEMP_STEP_START_COOL 110U + #define LCRTEMP_STEP_WAIT_COOLONLY 105U + #define LCRPID_MODE_FREEZE_JOLTFREE 105U + #define LCRPID_MODE_CLOSE_JOLTFREE 104U + #define LCRPID_MODE_OPEN_JOLTFREE 103U + #define LCRPID_MODE_MAN_JOLTFREE 102U + #define LCRTEMP_STEP_WAIT_COOL 100U + #define LCRPID_TUNE_REQU_PID 100U + #define LCRSLIMPID_REQU_PID 100U + #define LCRTEMP_STEP_PID_COOL 90U + #define LCRTEMP_STEP_PID 80U + #define LCRTEMP_STEP_FREE 70U + #define LCRTEMP_STEP_START_FREE 60U + #define LCRTEMP_STEP_WAIT_FREE 50U + #define LCRPID_TUNE_STATE_FINISHED 50U + #define LCRPID_TUNE_STATE_RESET_CNTL 49U + #define LCRPID_TUNE_STATE_CALC_PARA 45U + #define LCRTEMP_STEP_PID_FREE 40U + #define LCRTEMP_STEP_HEAT 30U + #define LCRPID_TUNE_STATE_STEP_WAITEQ2 22U + #define LCRPID_TUNE_STATE_STEP_MAXGRAD 21U + #define LCRSLIMPID_REQU_DIR_NEG 20U + #define LCRTEMP_STEP_START_HEAT 20U + #define LCRPID_TUNE_STATE_STEP_WAITEQ1 20U + #define LCRPID_TUNE_REQU_DIR_NEG 20U + #define LCRPID_TUNE_STATE_OSC_CNTLPAR 19U + #define LCRPID_TUNE_STATE_OSC_PERFORM_2 13U + #define LCRPID_TUNE_STATE_OSC_PERFORM_1 12U + #define LCRPID_TUNE_STATE_OSC_SEQ_CNTL 11U + #define LCRTEMP_STEP_WAIT_HEAT 10U + #define LCRSLIMPID_REQU_DIR_POS 10U + #define LCRPID_TUNE_STATE_OSCILLATE 10U + #define LCRPID_TUNE_REQU_DIR_POS 10U + #define LCRDBLPID_MODE_TUNE_Y2 9U + #define LCRDBLPID_MODE_TUNE_Y1 8U + #define LCRDBLPID_MODE_TUNE_6 7U + #define LCRDBLPID_MODE_TUNE_4 6U + #define LCRPID_FBK_MODE_SET_YI 5U + #define LCRPID_MODE_FREEZE 5U + #define LCRTEMP_STEP_WAIT 5U + #define LCRSLIMPID_REQU_WRITE_PARAS 4U + #define LCRPID_MODE_CLOSE 4U + #define LCRPID_FBK_MODE_LIMIT_YI 4U + #define LCRDBLPID_TSTATE_ERROR 4U + #define LCRPID_FBK_MODE_EXT_SELECTOR 3U + #define LCRSLIMPID_REQU_READ_PARAS 3U + #define LCRDBLPID_TSTATE_FINISHED 3U + #define LCRPID_MODE_OPEN 3U + #define LCRPID_TUNE_REQU_STEPRESPONSE 2U + #define LCRPID_FBK_MODE_EXTERN 2U + #define LCRPID_MODE_MAN 2U + #define LCRSLIMPID_REQU_STEPRESPONSE 2U + #define LCRPID_D_MODE_E 2U + #define LCRDBLPID_TSTATE_Y2 2U + #define LCRTEMPPID_MODE_MAN 2U + #define LCRPID_DEADBAND_MODE_STANDARD_I 2U + #define LCRSLIMPID_REQU_OSCILLATE 1U + #define LCRTEMP_COOL 1U + #define LCRTEMP_PT2 1U + #define LCRTEMP_HYST_MODE_JOLTFREE 1U + #define LCRTEMPPID_MODE_AUTO 1U + #define LCRPID_TUNE_REQU_OSCILLATE 1U + #define LCRDBLPID_TSTATE_Y1 1U + #define LCRPID_FBK_MODE_INTERN 1U + #define LCRPID_DEADBAND_MODE_STANDARD 1U + #define LCRPID_D_MODE_X 1U + #define LCRPID_MODE_AUTO 1U + #define LCRTEMPTune_MODE_EXP 1U + #define LCRPID_TUNE_REQU_OFF 0U + #define LCRDBLPID_TSTATE_OFF 0U + #define LCRTEMPTune_MODE_DEF 0U + #define LCRTEMP_PT1 0U + #define LCRSLIMPID_REQU_OFF 0U + #define LCRPID_TUNE_STATE_READY 0U + #define LCRPID_MODE_OFF 0U + #define LCRTEMP_HEAT 0U + #define LCRPID_DEADBAND_MODE_ZERO 0U +#else + #ifndef _GLOBAL_CONST + #define _GLOBAL_CONST _WEAK const + #endif + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PER_5; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PER_5; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PER_4; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PER_4; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PER_3; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PER_3; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_ERROR; + _GLOBAL_CONST unsigned short LCR_ERR_DISABLED; + _GLOBAL_CONST unsigned short LCR_ERR_PT2O_TF_NEG_ZERO; + _GLOBAL_CONST unsigned short LCR_ERR_PT2O_D_NEG; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_DT_IGNORED; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_INVALID_MODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_INVALID_MODE; + _GLOBAL_CONST unsigned short LCR_WARN_PT2O_TF_TS; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_ASYNC; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_DT_HIGH; + _GLOBAL_CONST unsigned short LCR_ERR_SCHEDULE_N; + _GLOBAL_CONST unsigned short LCR_ERR_SCHEDULE_P; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_NO_TALT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_TKNICK; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_TASKTIME_0; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_ILLEGALMODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_WR_PTR; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPPID_WR_PARA; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_WR_TSET; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTEMPTune_WR_PTR; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_MAXMIN; + _GLOBAL_CONST unsigned short LCR_ERR_POINTER; + _GLOBAL_CONST unsigned short LCR_ERR_LCRDBLPID_DX_DT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRDBLPID_WX_LOW; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_CONTROL_VAR; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_INVALID_REQU; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_FBKMODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_DYMAX; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_DMODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PARADAT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_MODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_IDENT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRMovAvgFlt_BASE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRIntegrate_TN; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OSC_3; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OSC_3; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OSC_2; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OSC_2; + _GLOBAL_CONST unsigned short LCR_ERR_LCRTT_TT_NEG; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPT12_T2_NEG; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPT12_T1_NEG; + _GLOBAL_CONST unsigned short LCR_ERR_LCRCurveByPoints_TABLE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_DEADBAND; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_WX_MAXMIN; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_DEADBAND_MODE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_W_CHANGED; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_TIMEOUT; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_PARAMETER; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPIDTune_ABORT; + _GLOBAL_CONST unsigned short LCR_ERR_MAXMIN; + _GLOBAL_CONST unsigned short LCR_ERR_LCRContinServo_TIMPULSE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRContinServo_TCHANGE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRRamp_DYUP_DYDOWN; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPWM_TPERIOD; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPWM_TPULSE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPWM_TMINPULSE; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPT1_T; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_TV; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_TN; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_TF; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_KW; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_KP; + _GLOBAL_CONST unsigned short LCR_ERROR; + _GLOBAL_CONST unsigned short LCR_ERR_LCRPID_PAR_KFBK; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPPID_WR_PARA; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_WR_BASE; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_WR_PARA; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTEMPTune_HEAT_TP; + _GLOBAL_CONST unsigned short LCR_WARN_LCRDBLPID_TUNE_CHANGE; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTT_MEM; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTT_TT_INT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTT_TT_TS; + _GLOBAL_CONST unsigned short LCR_WARN_LCRTT_TT_ZERO; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T2_INT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T2_TS; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T2_ZERO; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T1_INT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T1_TS; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_YMAN_LIMIT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_A_LIMIT; + _GLOBAL_CONST unsigned short LCR_WARN_Tx_DT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPT12_T1_ZERO; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPIDTune_CYCLETIME; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_YFBK_LIMIT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_I_MINLIMIT; + _GLOBAL_CONST unsigned short LCR_WARN_LCRPID_I_MAXLIMIT; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OSC_1; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OSC_1; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_CHR_REF_OS; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_CHR_REF_OS; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_CHR_REF_AP; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_CHR_REF_AP; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_ZN_DIST; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_ZN_DIST; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_CHR_DIST_OS; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_CHR_DIST_OS; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_CHR_DIST_AP; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_CHR_DIST_AP; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_P; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_P; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PI; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PI; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_DONE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID_DONE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID_DONE_COOLONLY; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_COOL; + _GLOBAL_CONST unsigned short LCRPID_TUNE_ADDINFO_OSC_PERIOD; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_START_COOL; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT_COOLONLY; + _GLOBAL_CONST unsigned char LCRPID_MODE_FREEZE_JOLTFREE; + _GLOBAL_CONST unsigned char LCRPID_MODE_CLOSE_JOLTFREE; + _GLOBAL_CONST unsigned char LCRPID_MODE_OPEN_JOLTFREE; + _GLOBAL_CONST unsigned char LCRPID_MODE_MAN_JOLTFREE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT_COOL; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_PID; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_PID; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID_COOL; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_FREE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_START_FREE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT_FREE; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_FINISHED; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_RESET_CNTL; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_CALC_PARA; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_PID_FREE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_HEAT; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_STEP_WAITEQ2; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_STEP_MAXGRAD; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_DIR_NEG; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_START_HEAT; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_STEP_WAITEQ1; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_DIR_NEG; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSC_CNTLPAR; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSC_PERFORM_2; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSC_PERFORM_1; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSC_SEQ_CNTL; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT_HEAT; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_DIR_POS; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_OSCILLATE; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_DIR_POS; + _GLOBAL_CONST unsigned char LCRDBLPID_MODE_TUNE_Y2; + _GLOBAL_CONST unsigned char LCRDBLPID_MODE_TUNE_Y1; + _GLOBAL_CONST unsigned char LCRDBLPID_MODE_TUNE_6; + _GLOBAL_CONST unsigned char LCRDBLPID_MODE_TUNE_4; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_SET_YI; + _GLOBAL_CONST unsigned char LCRPID_MODE_FREEZE; + _GLOBAL_CONST unsigned short LCRTEMP_STEP_WAIT; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_WRITE_PARAS; + _GLOBAL_CONST unsigned char LCRPID_MODE_CLOSE; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_LIMIT_YI; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_ERROR; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_EXT_SELECTOR; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_READ_PARAS; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_FINISHED; + _GLOBAL_CONST unsigned char LCRPID_MODE_OPEN; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_STEPRESPONSE; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_EXTERN; + _GLOBAL_CONST unsigned char LCRPID_MODE_MAN; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_STEPRESPONSE; + _GLOBAL_CONST unsigned char LCRPID_D_MODE_E; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_Y2; + _GLOBAL_CONST unsigned long LCRTEMPPID_MODE_MAN; + _GLOBAL_CONST unsigned char LCRPID_DEADBAND_MODE_STANDARD_I; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OSCILLATE; + _GLOBAL_CONST unsigned char LCRTEMP_COOL; + _GLOBAL_CONST unsigned char LCRTEMP_PT2; + _GLOBAL_CONST unsigned char LCRTEMP_HYST_MODE_JOLTFREE; + _GLOBAL_CONST unsigned long LCRTEMPPID_MODE_AUTO; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OSCILLATE; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_Y1; + _GLOBAL_CONST unsigned char LCRPID_FBK_MODE_INTERN; + _GLOBAL_CONST unsigned char LCRPID_DEADBAND_MODE_STANDARD; + _GLOBAL_CONST unsigned char LCRPID_D_MODE_X; + _GLOBAL_CONST unsigned char LCRPID_MODE_AUTO; + _GLOBAL_CONST unsigned long LCRTEMPTune_MODE_EXP; + _GLOBAL_CONST unsigned long LCRPID_TUNE_REQU_OFF; + _GLOBAL_CONST unsigned char LCRDBLPID_TSTATE_OFF; + _GLOBAL_CONST unsigned long LCRTEMPTune_MODE_DEF; + _GLOBAL_CONST unsigned char LCRTEMP_PT1; + _GLOBAL_CONST unsigned long LCRSLIMPID_REQU_OFF; + _GLOBAL_CONST unsigned short LCRPID_TUNE_STATE_READY; + _GLOBAL_CONST unsigned char LCRPID_MODE_OFF; + _GLOBAL_CONST unsigned char LCRTEMP_HEAT; + _GLOBAL_CONST unsigned char LCRPID_DEADBAND_MODE_ZERO; +#endif + + + + +/* Datatypes and datatypes of function blocks */ +typedef struct lcrCurveByPoints_TabEntry_type +{ float x; + float y; +} lcrCurveByPoints_TabEntry_type; + +typedef struct lcrdblpid_par_typ +{ float Y_max; + float Y_min; + signed short K_fact; + float Kp; + float Tn; + float Tv; +} lcrdblpid_par_typ; + +typedef struct lcrpid_tune_osc_options_typ +{ float osc_minAmplitude; + float Q_min; +} lcrpid_tune_osc_options_typ; + +typedef struct lcrpid_tune_step_options_typ +{ float eqDeltaX; + float eqDeltaWX; + float eqDeltat; + float evalDeltaX; + unsigned short evalNfilter; + unsigned short exitNotMaxdXCount; + float exitdXRatio; +} lcrpid_tune_step_options_typ; + +typedef struct lcrdblpid_tune_typ +{ signed short P1_manualAdjust; + signed short I1_manualAdjust; + signed short D1_manualAdjust; + signed short P2_manualAdjust; + signed short I2_manualAdjust; + signed short D2_manualAdjust; + float X_min; + float X_max; + float X0; + float de_min; + float Y0; + float Y1step; + float Y2step; + unsigned long tuneY1_opt; + unsigned long tuneY2_opt; + unsigned char tune_first; + float hyst; + float measDelta; + struct lcrpid_tune_osc_options_typ osc_opt; + struct lcrpid_tune_step_options_typ step_opt; +} lcrdblpid_tune_typ; + +typedef struct lcrpid_internal_typ +{ unsigned short size; + plcbit valid; + float WX_max; + float WX_min; + plcbit invert; + float deadband; + unsigned char deadband_mode; + float dY_max; + float Kp; + float Kp_Tn; + float Tv_Tf; + float Tf_reciproc; + float Kw; + float Kfbk_Kp; + float Kfbk_Kp_max; + unsigned char fbk_mode; + unsigned char d_mode; + unsigned char force_mode; + float Y_force; + float W; + float X; + unsigned char pid_init; + signed long Yp1; + signed long Yp2; + signed long dYi1; + signed long dYi2; + signed long Yi1; + signed long Yi2; + float dt_Tf; + signed long a11; + signed long a12; + signed long a21; + signed long a22; + signed long Yd1; + signed long Yd2; + signed long Ytotal1; + signed long Ytotal2; + signed long Ylim1; + signed long Ylim2; + signed long Y1; + signed long Y2; + float deltaY_fbk; + float e_fbk; +} lcrpid_internal_typ; + +typedef struct lcrpid_procPar_typ +{ unsigned short size; + plcbit valid; + plcbit stepResp_valid; + float stepResp_v; + float stepResp_t_u; + float stepResp_t_g; + plcbit osc_valid; + float osc_amplitudeRatio; + float osc_tPeriod; + plcbit force_params; + float Kp; + float Kp_tune; + float Tn; + float Tn_tune; + float Tv; + float Tv_tune; +} lcrpid_procPar_typ; + +typedef struct lcrpid_old_typ +{ struct lcrpid_procPar_typ processPar; + signed short P_manualAdjust; + signed short I_manualAdjust; + signed short D_manualAdjust; + float Y_min; + float Y_max; + float dY_max; + float Tf_Tv; + float Kw; + float Kfbk; + float deadband; + float W; + unsigned long request; + unsigned char fbk_mode; + unsigned char d_mode; + plcbit invert; + plcbit enable; +} lcrpid_old_typ; + +typedef struct lcrpid_osc_val_typ +{ float X; + float t; +} lcrpid_osc_val_typ; + +typedef struct lcrpid_osc_per_typ +{ struct lcrpid_osc_val_typ max; + struct lcrpid_osc_val_typ min; +} lcrpid_osc_per_typ; + +typedef struct lcrpid_tune_addpar_typ +{ float t_max_tune; + float WX_min; + float WX_max; + float dY_max; + float Tf_Tv; + float Kw; + float Kfbk; + unsigned char fbk_mode; + unsigned char d_mode; + float deadband; + unsigned char deadband_mode; + plcbit invert; +} lcrpid_tune_addpar_typ; + +typedef struct lcrpid_tune_osc_typ +{ struct lcrpid_tune_osc_options_typ options; + unsigned short oscPhase; + signed char dir; + plcbit enHi; + plcbit enLo; + float Y_hi; + float Y_lo; + unsigned short i_maxPeriod; + unsigned short i_period; + float X_ampl; + float X_avg; + float X_min_avg; + float X_max_avg; + float Y_avg; + float deltaY; + float t_Ylohi[5]; + float t_Yhilo[5]; + float Q_act; + float a_wx; + float amplitudeRatio; + float Ku; + float tPeriod; + struct lcrpid_osc_per_typ period[5]; +} lcrpid_tune_osc_typ; + +typedef struct lcrpid_tune_step_typ +{ struct lcrpid_tune_step_options_typ options; + float Y0; + float Y1; + float t_jump; + float W; + float X0; + float Xmax; + float Xmin; + float Xfiltered; + plcbit deltaXok; + plcbit deltaWXok; + float eqTime; + signed char dir; + float deltaX; + float X1; + float t1; + plcbit t1set; + float dX_dt; + float dX_dt_max; + float XmaxGrad; + float maxX1; + float maxX2; + float maxt1; + float maxt2; + float tmaxGrad; + float gainFactor; + float deadTime; + float riseTime; + unsigned short notMaxCount; + float gradientRatio; +} lcrpid_tune_step_typ; + +typedef struct lcrpt2o_Internal_typ +{ signed long Ts; + unsigned long Ts_dbl_1; + unsigned long Ts_dbl_2; + float V_old; + float D_old; + float Tf_old; + unsigned char Set_y_old; + unsigned char Set_y_2; + unsigned long x1_dbl_1; + unsigned long x1_dbl_2; + unsigned long x2_dbl_1; + unsigned long x2_dbl_2; + unsigned long Sqrt_D_1_dbl_1; + unsigned long Sqrt_D_1_dbl_2; + unsigned long Ts_Tf_dbl_1; + unsigned long Ts_Tf_dbl_2; + unsigned long Exp_D_Ts_Tf_dbl_1; + unsigned long Exp_D_Ts_Tf_dbl_2; + unsigned long a0_dbl_1; + unsigned long a0_dbl_2; + unsigned long a1_dbl_1; + unsigned long a1_dbl_2; + unsigned long b0_dbl_1; + unsigned long b0_dbl_2; + unsigned long b1_dbl_1; + unsigned long b1_dbl_2; + unsigned long Bootkey; +} lcrpt2o_Internal_typ; + +typedef struct LCRPWM +{ + /* VAR_INPUT (analog) */ + float x; + float max_value; + float min_value; + float t_min_pulse; + float t_period; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float t_on; + float t_off; + /* VAR (analog) */ + signed long cnt_terron_1; + signed long cnt_terron_2; + signed long cnt_terroff_1; + signed long cnt_terroff_2; + signed long cnt_t_pulse_1; + signed long cnt_t_pulse_2; + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR_OUTPUT (digital) */ + plcbit pulse; + /* VAR (digital) */ + plcbit corr; +} LCRPWM_typ; + +typedef struct lcrschedule_add_typ +{ float periodTime; + float onTime; + float t_on_intern; + float bcOnTime; + unsigned short sortIndex; + struct LCRPWM fbkPWM; + plcbit flagDelay; +} lcrschedule_add_typ; + +typedef struct lcrschedule_par_typ +{ float P; + float X; + plcbit pulse; + float Pout; + plcbit lim; + struct lcrschedule_add_typ Internal; +} lcrschedule_par_typ; + +typedef struct lcrslimpid_par_typ +{ float Y_max; + float Y_min; + float Kp; + float Tn; + float Tv; + float Kfbk; +} lcrslimpid_par_typ; + +typedef struct lcrtemp_add_typ +{ float mem01; + float mem02; + float mem10; + float mem20; + float exp_mem; + float cnt01; + float cnt02; + float cnt10; + float cnt20; + float cnt03; + float cnt30; + float cnt00; + float t_ignore_dT_heat; + float t_ignore_dT_free; + float t_ignore_dT_cool; + float yMin; + float yMax; + unsigned long reserved3; + unsigned long reserved4; + plcbit reserved5; + plcbit reserved6; +} lcrtemp_add_typ; + +typedef struct lcrtemp_pid_internal_typ +{ plcbit enable_cooling; + plcbit disable_heating; + float hyst; + float delay; + float Kw; + float Kfbk; + float Kp_h; + float Tn_h; + float Tv_h; + float Kp_c; + float Tn_c; + float Tv_c; + float dynGeneral; + float dynHeat; + float dynCool; + float mem01; + float mem02; + float mem10; + float mem20; + float exp_mem; + float yMin; + float yMax; +} lcrtemp_pid_internal_typ; + +typedef struct lcrtemp_pid_opt_typ +{ float Kp_h; + float Tn_h; + float Tv_h; + float Tf_h; + float Kp_c; + float Tn_c; + float Tv_c; + float Tf_c; + float dynGeneral; + float dynHeat; + float dynCool; +} lcrtemp_pid_opt_typ; + +typedef struct lcrtemp_pid_set_typ +{ float hyst; + unsigned char hyst_mode; + float delay; + float Kw; + float Kfbk; +} lcrtemp_pid_set_typ; + +typedef struct lcrtemp_tune_set_typ +{ unsigned long mode; + float Temp_amb; + float dRatio_heat; + float cnt_tp_heat; + float delta_T_heat; + float dT_min_heat; + float dRatio_free; + float cnt_tp_free; + float delta_T_free; + float dT_min_free; + float dRatio_cool; + float cnt_tp_cool; + float delta_T_cool; + float dT_min_cool; + float delta_T_sync_heat; + float delta_dT_sync_heat; + float cnt_wait_heat; + float delta_T_sync_free; + float delta_dT_sync_free; + float cnt_wait_free; + float delta_T_sync_cool; + float delta_dT_sync_cool; + float cnt_wait_cool; + float filter_base_T; + float delta_T_sync_stop; + float Y_heat_tune; +} lcrtemp_tune_set_typ; + +typedef struct lcrtemp_set_typ +{ plcbit enable_cooling; + plcbit disable_heating; + struct lcrtemp_pid_opt_typ PIDpara; + struct lcrtemp_tune_set_typ TuneSet; + struct lcrtemp_pid_set_typ PIDSet; + struct lcrtemp_add_typ Internal; +} lcrtemp_set_typ; + +typedef struct lcrtemp_tune_internal_typ +{ plcbit cool_tuning; + plcbit disable_heating; + unsigned long mode; + float Temp_amb; + float dRatio_heat; + float cnt_tp_heat; + float delta_T_heat; + float dT_min_heat; + float dRatio_free; + float cnt_tp_free; + float delta_T_free; + float dT_min_free; + float dRatio_cool; + float cnt_tp_cool; + float delta_T_cool; + float dT_min_cool; + float delta_T_sync_heat; + float delta_dT_sync_heat; + float cnt_wait_heat; + float delta_T_sync_free; + float delta_dT_sync_free; + float cnt_wait_free; + float delta_T_sync_cool; + float delta_dT_sync_cool; + float cnt_wait_cool; + float filter_base_T; + float t_ignore_dT_heat; + float t_ignore_dT_free; + float t_ignore_dT_cool; + float delta_T_sync_stop; +} lcrtemp_tune_internal_typ; + +typedef struct LCRScal +{ + /* VAR_INPUT (analog) */ + float x; + float x1; + float y1; + float x2; + float y2; + /* VAR_OUTPUT (analog) */ + float y; +} LCRScal_typ; + +typedef struct LCRPID +{ + /* VAR_INPUT (analog) */ + unsigned long ident; + float W; + float X; + float Y_max; + float Y_min; + float A; + float Y_man; + float Y_fbk; + unsigned char mode; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float e; + float Y; + float Yp; + float Yi; + float Yd; + /* VAR (analog) */ + float Yi_set; + float Yi_min; + float Yi_max; + float Yi_minInternal; + float Yi_maxInternal; + float Tv_Tf_old; + float e_old; + unsigned short deadband_state; + struct SysInfo sysinfo_inst; + struct LCRScal scal_inst; + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + unsigned short musecs_old; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit hold_I; + /* VAR (digital) */ + plcbit Set_Yi; + plcbit force_Yi; + plcbit joltFreeDoneLowerLim; + plcbit joltFreeDoneUpperLim; + plcbit enable_old; +} LCRPID_typ; + +typedef struct LCRCurveByPoints +{ + /* VAR_INPUT (analog) */ + float x; + unsigned short NoOfPoints; + struct lcrCurveByPoints_TabEntry_type* ptr_table; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + signed short i_tab; + unsigned short iterations; + struct LCRScal scal1; +} LCRCurveByPoints_typ; + +typedef struct LCRPIDpara +{ + /* VAR_INPUT (analog) */ + float WX_max; + float WX_min; + float deadband; + unsigned char deadband_mode; + float dY_max; + float Kp; + float Tn; + float Tv; + float Tf; + float Kw; + float Kfbk; + unsigned char fbk_mode; + unsigned char d_mode; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned long ident; + /* VAR (analog) */ + struct lcrpid_internal_typ internal_data; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit enter; + plcbit invert; +} LCRPIDpara_typ; + +typedef struct LCRContinServo +{ + /* VAR_INPUT (analog) */ + float x; + float max_value; + float min_value; + float t_impulse; + float t_change_up; + float t_change_down; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float hysteresis_up; + float hysteresis_down; + /* VAR (analog) */ + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + signed long t_cnt_1; + signed long t_cnt_2; + signed long y_dbl_1; + signed long y_dbl_2; + struct SysInfo sysInfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit ref; + /* VAR_OUTPUT (digital) */ + plcbit up; + plcbit down; + plcbit refOk; + /* VAR (digital) */ + plcbit enable_old; + plcbit ref_old; +} LCRContinServo_typ; + +typedef struct LCRPT1 +{ + /* VAR_INPUT (analog) */ + float x; + float t; + float y_set; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + signed long y_dbl_1; + signed long y_dbl_2; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit set; +} LCRPT1_typ; + +typedef struct LCRRamp +{ + /* VAR_INPUT (analog) */ + float x; + float dy_up; + float dy_down; + float y_max; + float y_min; + float y_set; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + signed long y_dbl_1; + signed long y_dbl_2; + unsigned long timestore1; + unsigned long timestore2; + unsigned long getDtForceOff; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit set; + /* VAR_OUTPUT (digital) */ + plcbit x_reached; + plcbit max_limit; + plcbit min_limit; +} LCRRamp_typ; + +typedef struct LCRIntegrate +{ + /* VAR_INPUT (analog) */ + float x; + float tn; + float y_max; + float y_min; + float y_set; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + signed long y_dbl_1; + signed long y_dbl_2; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit set; + /* VAR_OUTPUT (digital) */ + plcbit max_limit; + plcbit min_limit; +} LCRIntegrate_typ; + +typedef struct LCRLimit +{ + /* VAR_INPUT (analog) */ + float in; + signed long max_value; + signed long min_value; + /* VAR_OUTPUT (analog) */ + unsigned short status; + signed long out; + /* VAR_OUTPUT (digital) */ + plcbit max_limit; + plcbit min_limit; +} LCRLimit_typ; + +typedef struct LCRLimScal +{ + /* VAR_INPUT (analog) */ + float x; + float x1; + float y1; + float x2; + float y2; + /* VAR_OUTPUT (analog) */ + float y; +} LCRLimScal_typ; + +typedef struct LCRMovAvgFlt +{ + /* VAR_INPUT (analog) */ + float x; + unsigned short base; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + signed long sum_old_dbl_1; + signed long sum_old_dbl_2; + unsigned long p_xold; + unsigned short i_xold; + unsigned short base_old; + unsigned long bootkey_old; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR (digital) */ + plcbit enable_old; +} LCRMovAvgFlt_typ; + +typedef struct LCRTimeBasedOnOff +{ + /* VAR_INPUT (analog) */ + float x; + float max_value; + float min_value; + float timpulse; + float tchange_up; + float tchange_down; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float hysteresis_up; + float hysteresis_down; + /* VAR (analog) */ + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + signed long t_cnt_1; + signed long t_cnt_2; + signed long y_dbl_1; + signed long y_dbl_2; + struct SysInfo sysInfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit ref; + /* VAR_OUTPUT (digital) */ + plcbit up; + plcbit down; + plcbit refOk; + /* VAR (digital) */ + plcbit enable_old; + plcbit ref_old; +} LCRTimeBasedOnOff_typ; + +typedef struct LCRDifferentiate +{ + /* VAR_INPUT (analog) */ + float x; + float tv; + float tf; + /* VAR_OUTPUT (analog) */ + unsigned short status; + float y; + /* VAR (analog) */ + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + struct SysInfo sysinfo_inst; + signed long a11; + signed long a12; + signed long a21; + signed long a22; + /* VAR_INPUT (digital) */ + plcbit enable; +} LCRDifferentiate_typ; + +typedef struct LCRPIDTune +{ + /* VAR_INPUT (analog) */ + float Y_min; + float Y_max; + float Y0; + float Y1; + float X0; + float X_min; + float X_max; + signed short P_manualAdjust; + signed short I_manualAdjust; + signed short D_manualAdjust; + unsigned long request; + struct lcrpid_tune_addpar_typ* pAddPar; + struct lcrpid_tune_osc_options_typ* pOptions_osc; + struct lcrpid_tune_step_options_typ* pOptions_step; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned short addInfo; + unsigned long ident; + unsigned short state; + /* VAR (analog) */ + float t_autotune; + unsigned short status_tmp; + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + float e; + float e_minAmp; + float e_old_up; + float e_old_down; + float e_old; + struct SysInfo sysinfo_inst; + struct LCRMovAvgFlt MovAvgFlt_inst; + struct lcrpid_old_typ old; + struct lcrpid_procPar_typ processPar; + struct lcrpid_internal_typ internal_data; + struct lcrpid_tune_addpar_typ addPar; + struct lcrpid_tune_osc_typ oscillation; + struct lcrpid_tune_step_typ stepresponse; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit okToStep; + /* VAR_OUTPUT (digital) */ + plcbit rdyToStep; + /* VAR (digital) */ + plcbit curveDown; + plcbit curveUp; +} LCRPIDTune_typ; + +typedef struct LCRSlimPID +{ + /* VAR_INPUT (analog) */ + float W; + float X; + unsigned long request; + struct lcrslimpid_par_typ* pPar; + /* VAR_OUTPUT (analog) */ + float e; + float Y; + unsigned short status; + unsigned short addInfo; + /* VAR (analog) */ + struct LCRMovAvgFlt MovAvgFlt_inst; + struct LCRPIDTune PIDTune_inst; + struct LCRPID PID_inst; + unsigned long requ_old; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR (digital) */ + plcbit enable_old; +} LCRSlimPID_typ; + +typedef struct LCRPFM +{ + /* VAR_INPUT (analog) */ + float x; + float max_value; + float min_value; + float t_pulse; + float t_pause; + /* VAR_OUTPUT (analog) */ + unsigned short status; + /* VAR (analog) */ + float area; + float area_c; + float range; + float last; + float tpls; + unsigned short counter_state; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + struct SysInfo sysinfo_inst; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR_OUTPUT (digital) */ + plcbit pulse; + /* VAR (digital) */ + plcbit enable_old; +} LCRPFM_typ; + +typedef struct LCRTt +{ + /* VAR_INPUT (analog) */ + signed long Tt; + float x; + float y_set; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + signed long Ts; + signed long Tt_Max; + float* pRingBuf; + float* pBuf_OutIn; + unsigned char set_old; + unsigned char Set_y; + unsigned long Bootkey; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit set; + /* VAR (digital) */ + plcbit enable_old; +} LCRTt_typ; + +typedef struct LCRPT2 +{ + /* VAR_INPUT (analog) */ + float V; + float T1; + float T2; + float x; + float y_set; + unsigned char set; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + unsigned long x1_dbl_1; + unsigned long x1_dbl_2; + unsigned long x2_dbl_1; + unsigned long x2_dbl_2; + signed long Ts; + unsigned long Ts_dbl_1; + unsigned long Ts_dbl_2; + unsigned char set_old; + unsigned char Set_y; + unsigned long Bootkey; + /* VAR_INPUT (digital) */ + plcbit enable; +} LCRPT2_typ; + +typedef struct LCRSimModExt +{ + /* VAR_INPUT (analog) */ + signed long Tt_h; + signed long Tt_c; + float k_h; + float k_c; + float PT2_T1; + float PT2_T2; + float Temp_amb; + float Temp_c; + float Alpha_h; + float Alpha_c; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + struct LCRTt Tt_heat; + struct LCRTt Tt_cool; + float k_h_intern; + float k_c_intern; + struct LCRPT2 PT2; + float y_c; + float y_end; + float y_h; + unsigned long Bootkey; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR (digital) */ + plcbit enable_old; +} LCRSimModExt_typ; + +typedef struct LCRPT1e +{ + /* VAR_INPUT (analog) */ + float V; + float T1; + float x; + float y_set; + unsigned char set; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + unsigned long x1_dbl_1; + unsigned long x1_dbl_2; + signed long Ts; + unsigned long Ts_dbl_1; + unsigned long Ts_dbl_2; + unsigned char set_old; + unsigned char Set_y; + unsigned long Bootkey; + /* VAR_INPUT (digital) */ + plcbit enable; +} LCRPT1e_typ; + +typedef struct LCRDblActPID +{ + /* VAR_INPUT (analog) */ + float W; + float X; + float Y_man; + unsigned char mode; + struct lcrdblpid_par_typ* pPar1; + struct lcrdblpid_par_typ* pPar2; + struct lcrpid_tune_addpar_typ* pAddPar; + struct lcrdblpid_tune_typ* pOpt; + /* VAR_OUTPUT (analog) */ + float e; + float Y1; + float Y2; + unsigned short status; + unsigned char tuneState; + /* VAR (analog) */ + struct LCRPID pid; + struct LCRPIDTune tune; + struct SysInfo sysinfo_inst; + float gradient; + float Y_avg; + unsigned long tcnt_1; + unsigned long tcnt_2; + float Tmeas; + float y_lim_old; + float p_fact; + unsigned long bootkey_old; + unsigned long systicks_old; + unsigned short musecs_old; + unsigned char use_par; + unsigned char meas; + unsigned char mode_old; + unsigned char tune_step; + unsigned char tune_grad; + unsigned char tune_2nd; + unsigned char invert; + unsigned char counter_state; + unsigned char mode_int; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit hold_I; + plcbit okToStep; + /* VAR_OUTPUT (digital) */ + plcbit rdyToStep; + /* VAR (digital) */ + plcbit enable_old; +} LCRDblActPID_typ; + +typedef struct LCRMinMax +{ + /* VAR_INPUT (analog) */ + float in; + /* VAR_OUTPUT (analog) */ + float out_min; + float out_max; + /* VAR_INPUT (digital) */ + plcbit reset; +} LCRMinMax_typ; + +typedef struct LCRTempPID +{ + /* VAR_INPUT (analog) */ + float Temp_set; + float Temp; + float Y_man; + unsigned long mode; + struct lcrtemp_set_typ* pSettings; + /* VAR_OUTPUT (analog) */ + float y_heat; + float y_cool; + unsigned short status; + /* VAR (analog) */ + struct LCRPID pid; + struct LCRPIDpara pid_para; + float Temp_set_delay; + float Temp_set_int; + float TempSetOld; + float delayCnt; + signed char stateOld; + signed char state; + float a; + struct SysInfo sysinfo_inst; + unsigned char para_check_done; + struct lcrtemp_pid_internal_typ internal_para; + float dbl_dt; + float tAlt; + float altTime; + float tKnick; + float fAlt; + float a_alt; + float a_e; + float a_internal; + float Temp_set_int_old1; + float Temp_set_int_old2; + float Temp_set_int_old3; + unsigned long mode_old; + unsigned long timestore1; + unsigned long timestore2; + float yManInternal; + unsigned long timeCnt; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit update; + /* VAR (digital) */ + plcbit delayFlag; + plcbit enable_old; + plcbit altActive; + plcbit err_flag; +} LCRTempPID_typ; + +typedef struct LCRPT2o +{ + /* VAR_INPUT (analog) */ + float V; + float D; + float Tf; + float u; + unsigned char Set_y; + float y_set; + /* VAR_OUTPUT (analog) */ + float y; + unsigned short status; + /* VAR (analog) */ + struct lcrpt2o_Internal_typ Internal; + /* VAR_INPUT (digital) */ + plcbit enable; +} LCRPT2o_typ; + +typedef struct LCRTempTune +{ + /* VAR_INPUT (analog) */ + float Temp_set; + float Temp; + struct lcrtemp_set_typ* pSettings; + /* VAR_OUTPUT (analog) */ + float y_heat; + float y_cool; + unsigned short status; + /* VAR (analog) */ + struct LCRPID pid; + struct LCRPIDpara pid_para; + struct LCRDifferentiate DT2; + struct LCRPT2o pt2; + float Temp_flt; + unsigned short step; + float t; + float Temp_start; + float mem00; + float cnt02; + float cnt33; + float cnt20; + float pem01; + float pem33; + float pem10; + float pem02; + float pem44; + float pem20; + float tol01; + float tol10; + float tol02; + float tol20; + float tol22; + float Temp_old; + float delta_Temp; + unsigned long tcnt_1; + unsigned long tcnt_2; + unsigned long tcnt_dT_1; + unsigned long tcnt_dT_2; + struct SysInfo sysinfo_inst; + float Temp_set_internal; + float timecounter; + struct lcrtemp_tune_internal_typ internal_para; + float dbl_dt; + unsigned long call_counter; + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + float timer2; + unsigned short waitCounter; + float Y_heat_tune_intern; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit start; + plcbit okToHeat; + plcbit okToFree; + plcbit okToFreeEnd; + plcbit okToCool; + plcbit okToCoolEnd; + /* VAR_OUTPUT (digital) */ + plcbit rdyToHeat; + plcbit rdyToFree; + plcbit rdyToFreeEnd; + plcbit rdyToCool; + plcbit rdyToCoolEnd; + plcbit done; + plcbit busy; + /* VAR (digital) */ + plcbit enable_old; +} LCRTempTune_typ; + +typedef struct LCRSchedulePWM +{ + /* VAR_INPUT (analog) */ + float Pmax; + unsigned short n; + unsigned long pPar; + float min_value; + float max_value; + float t_min_pulse; + float t_period; + /* VAR_OUTPUT (analog) */ + unsigned short status; + /* VAR (analog) */ + struct SysInfo sysinfo_inst; + unsigned long store1; + unsigned long store2; + unsigned long timeCnt; + unsigned short numberUnits; + unsigned short limFact; + float Pact; + float Pman; + float intern0[6]; + struct lcrschedule_par_typ* in; + /* VAR_INPUT (digital) */ + plcbit enable; + /* VAR (digital) */ + plcbit enable_old; + plcbit cmd_delay; + plcbit err_flag; + plcbit limAll; +} LCRSchedulePWM_typ; + + + +/* Prototyping of functions and function blocks */ +_BUR_PUBLIC void LCRPID(struct LCRPID* inst); +_BUR_PUBLIC void LCRScal(struct LCRScal* inst); +_BUR_PUBLIC void LCRCurveByPoints(struct LCRCurveByPoints* inst); +_BUR_PUBLIC void LCRPIDpara(struct LCRPIDpara* inst); +_BUR_PUBLIC void LCRContinServo(struct LCRContinServo* inst); +_BUR_PUBLIC void LCRPT1(struct LCRPT1* inst); +_BUR_PUBLIC void LCRRamp(struct LCRRamp* inst); +_BUR_PUBLIC void LCRIntegrate(struct LCRIntegrate* inst); +_BUR_PUBLIC void LCRLimit(struct LCRLimit* inst); +_BUR_PUBLIC void LCRLimScal(struct LCRLimScal* inst); +_BUR_PUBLIC void LCRPWM(struct LCRPWM* inst); +_BUR_PUBLIC void LCRMovAvgFlt(struct LCRMovAvgFlt* inst); +_BUR_PUBLIC void LCRTimeBasedOnOff(struct LCRTimeBasedOnOff* inst); +_BUR_PUBLIC void LCRDifferentiate(struct LCRDifferentiate* inst); +_BUR_PUBLIC void LCRSlimPID(struct LCRSlimPID* inst); +_BUR_PUBLIC void LCRPIDTune(struct LCRPIDTune* inst); +_BUR_PUBLIC void LCRPFM(struct LCRPFM* inst); +_BUR_PUBLIC void LCRSimModExt(struct LCRSimModExt* inst); +_BUR_PUBLIC void LCRTt(struct LCRTt* inst); +_BUR_PUBLIC void LCRPT2(struct LCRPT2* inst); +_BUR_PUBLIC void LCRPT1e(struct LCRPT1e* inst); +_BUR_PUBLIC void LCRDblActPID(struct LCRDblActPID* inst); +_BUR_PUBLIC void LCRMinMax(struct LCRMinMax* inst); +_BUR_PUBLIC void LCRTempPID(struct LCRTempPID* inst); +_BUR_PUBLIC void LCRTempTune(struct LCRTempTune* inst); +_BUR_PUBLIC void LCRPT2o(struct LCRPT2o* inst); +_BUR_PUBLIC void LCRSchedulePWM(struct LCRSchedulePWM* inst); + + +#ifdef __cplusplus +}; +#endif +#endif /* _LOOPCONR_ */ + diff --git a/Logical/Libraries/Package.pkg b/Logical/Libraries/Package.pkg index 00a1531..b09ee00 100644 --- a/Logical/Libraries/Package.pkg +++ b/Logical/Libraries/Package.pkg @@ -18,5 +18,8 @@ AsBrMath AsHttp AsOpcUac + LoopConR + sys_lib + brsystem \ No newline at end of file diff --git a/Logical/Libraries/brsystem/SG3/brsystem.h b/Logical/Libraries/brsystem/SG3/brsystem.h new file mode 100644 index 0000000..06254eb --- /dev/null +++ b/Logical/Libraries/brsystem/SG3/brsystem.h @@ -0,0 +1,271 @@ +/* Automation Studio generated header file */ +/* Do not edit ! */ + +#ifndef _BRSYSTEM_ +#define _BRSYSTEM_ +#ifdef __cplusplus +extern "C" +{ +#endif + +#include + +#include + +#ifndef _IEC_CONST +#define _IEC_CONST _WEAK const +#endif + +/* Constants */ +#ifdef _REPLACE_CONST + #define brX2X 10U + #define brPP 255U + #define brCPU 1U + #define brKEY 8U + #define brDRAM 0U + #define br2003 2U + #define br2005 1U + #define br2010 0U + #define brC200 9U + #define brC300 8U + #define brADDON 7U + #define brPANEL 6U + #define brGLOBAL_REMANENT_PV 5U + #define brLOCAL_REMANENT_PV 4U + #define brUSRROM 3U + #define brSYSROM 2U + #define brUSRRAM 1U + #define brACOPOS 7U + #define brCAN_IO 5U + #define brBASE_IO 3U + #define brPRODUCT 0U + #define brETHER_IO 6U + #define brNO_FAMILY 255U + #define brREMOTE_IO 4U + #define brBATTERY_OK 1U + #define brPOWERPANEL 5U + #define brBATTERY_LOW 0U + #define brLOGICSCANNER 3U + #define brPLUGIN_MODULE 10U + #define brSYSTEM_MODULE 2U + #define brBATTERY_NOTEST 2U + #define TARGET_BIG_ENDIAN 2U + #define brBATTERY_MISSING 3U + #define INIT_REASON_UNKNOWN (-1) + #define INIT_REASON_DOWNLOAD 3 + #define TARGET_LITTLE_ENDIAN 1U + #define brAUTOMATION_RUNTIME 4U + #define brERR_INVALID_DEVICE 27250U + #define INIT_REASON_COLDSTART 2 + #define INIT_REASON_WARMSTART 1 + #define brSYSCONF_SET_VOLATILE 0 + #define brERR_INVALID_PARAMETER 27251U + #define brSYSCONF_SET_NON_VOLATILE 1 +#else + _IEC_CONST unsigned char brX2X = 10U; + _IEC_CONST unsigned char brPP = 255U; + _IEC_CONST unsigned char brCPU = 1U; + _IEC_CONST unsigned char brKEY = 8U; + _IEC_CONST unsigned long brDRAM = 0U; + _IEC_CONST unsigned char br2003 = 2U; + _IEC_CONST unsigned char br2005 = 1U; + _IEC_CONST unsigned char br2010 = 0U; + _IEC_CONST unsigned char brC200 = 9U; + _IEC_CONST unsigned char brC300 = 8U; + _IEC_CONST unsigned char brADDON = 7U; + _IEC_CONST unsigned char brPANEL = 6U; + _IEC_CONST unsigned long brGLOBAL_REMANENT_PV = 5U; + _IEC_CONST unsigned long brLOCAL_REMANENT_PV = 4U; + _IEC_CONST unsigned long brUSRROM = 3U; + _IEC_CONST unsigned long brSYSROM = 2U; + _IEC_CONST unsigned long brUSRRAM = 1U; + _IEC_CONST unsigned char brACOPOS = 7U; + _IEC_CONST unsigned char brCAN_IO = 5U; + _IEC_CONST unsigned char brBASE_IO = 3U; + _IEC_CONST unsigned char brPRODUCT = 0U; + _IEC_CONST unsigned char brETHER_IO = 6U; + _IEC_CONST unsigned char brNO_FAMILY = 255U; + _IEC_CONST unsigned char brREMOTE_IO = 4U; + _IEC_CONST unsigned char brBATTERY_OK = 1U; + _IEC_CONST unsigned char brPOWERPANEL = 5U; + _IEC_CONST unsigned char brBATTERY_LOW = 0U; + _IEC_CONST unsigned char brLOGICSCANNER = 3U; + _IEC_CONST unsigned char brPLUGIN_MODULE = 10U; + _IEC_CONST unsigned char brSYSTEM_MODULE = 2U; + _IEC_CONST unsigned char brBATTERY_NOTEST = 2U; + _IEC_CONST unsigned char TARGET_BIG_ENDIAN = 2U; + _IEC_CONST unsigned char brBATTERY_MISSING = 3U; + _IEC_CONST signed char INIT_REASON_UNKNOWN = -1; + _IEC_CONST signed char INIT_REASON_DOWNLOAD = 3; + _IEC_CONST unsigned char TARGET_LITTLE_ENDIAN = 1U; + _IEC_CONST unsigned char brAUTOMATION_RUNTIME = 4U; + _IEC_CONST unsigned short brERR_INVALID_DEVICE = 27250U; + _IEC_CONST signed char INIT_REASON_COLDSTART = 2; + _IEC_CONST signed char INIT_REASON_WARMSTART = 1; + _IEC_CONST plcbit brSYSCONF_SET_VOLATILE = 0; + _IEC_CONST unsigned short brERR_INVALID_PARAMETER = 27251U; + _IEC_CONST plcbit brSYSCONF_SET_NON_VOLATILE = 1; +#endif + + + + +/* Datatypes and datatypes of function blocks */ +typedef struct MEMInfo +{ + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned long FreeUSR_Ram; + unsigned long FreeSYSTEM; + unsigned long FreeUSR_Prom; + unsigned long FreeSYS_Prom; + unsigned long FreeFIX_Ram; + unsigned long FreeTMP_Ram; + unsigned long FreeMEMCARD; + /* VAR_INPUT (digital) */ + plcbit enable; +} MEMInfo_typ; + +typedef struct SysInfo +{ + /* VAR_OUTPUT (analog) */ + unsigned char init_reason; + unsigned char init_count; + unsigned long tick_count; + unsigned long version; + /* VAR_INPUT (digital) */ + plcbit enable; +} SysInfo_typ; + +typedef struct RTInfo +{ + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned long cycle_time; + signed char init_reason; + signed char task_class; + /* VAR_INPUT (digital) */ + plcbit enable; +} RTInfo_typ; + +typedef struct TARGETInfo +{ + /* VAR_INPUT (analog) */ + unsigned long pOSVersion; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned char DataFormat; + /* VAR_INPUT (digital) */ + plcbit enable; +} TARGETInfo_typ; + +typedef struct HWInfo +{ + /* VAR_INPUT (analog) */ + unsigned long pName; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned char family; + unsigned char usetype; + unsigned long module_typ; + unsigned char master_no; + unsigned char slave_no; + unsigned char module_adr; + unsigned char slot_no; + /* VAR (analog) */ + unsigned long next_vw_p; + unsigned long last_modul_p; + unsigned long next_entry_p; + unsigned char next_entry_ix; + unsigned char next_slot_ix; + unsigned char last_rio_master; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit first; +} HWInfo_typ; + +typedef struct BatteryInfo +{ + /* VAR_INPUT (analog) */ + unsigned long pDevice; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned char state; + /* VAR_INPUT (digital) */ + plcbit enable; +} BatteryInfo_typ; + +typedef struct EXCInfo +{ + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned long task_class; + unsigned long task_ident; + /* VAR_INPUT (digital) */ + plcbit enable; +} EXCInfo_typ; + +typedef struct ZYKVLenable +{ + /* VAR_OUTPUT (analog) */ + unsigned short status; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit mode; +} ZYKVLenable_typ; + +typedef struct PMemGet +{ + /* VAR_INPUT (analog) */ + unsigned long offset; + unsigned long len; + unsigned long adress; + /* VAR_OUTPUT (analog) */ + unsigned short status; + /* VAR_INPUT (digital) */ + plcbit enable; +} PMemGet_typ; + +typedef struct PMemPut +{ + /* VAR_INPUT (analog) */ + unsigned long offset; + unsigned long len; + unsigned long adress; + /* VAR_OUTPUT (analog) */ + unsigned short status; + /* VAR_INPUT (digital) */ + plcbit enable; +} PMemPut_typ; + +typedef struct PMemSize +{ + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned long size; + /* VAR_INPUT (digital) */ + plcbit enable; +} PMemSize_typ; + + + +/* Prototyping of functions and function blocks */ +void MEMInfo(struct MEMInfo* inst); +void SysInfo(struct SysInfo* inst); +void RTInfo(struct RTInfo* inst); +void TARGETInfo(struct TARGETInfo* inst); +void HWInfo(struct HWInfo* inst); +void BatteryInfo(struct BatteryInfo* inst); +void EXCInfo(struct EXCInfo* inst); +void ZYKVLenable(struct ZYKVLenable* inst); +void PMemGet(struct PMemGet* inst); +void PMemPut(struct PMemPut* inst); +void PMemSize(struct PMemSize* inst); + + +#ifdef __cplusplus +}; +#endif +#endif /* _BRSYSTEM_ */ + + diff --git a/Logical/Libraries/brsystem/SG4/brsystem.h b/Logical/Libraries/brsystem/SG4/brsystem.h new file mode 100644 index 0000000..2d87e5f --- /dev/null +++ b/Logical/Libraries/brsystem/SG4/brsystem.h @@ -0,0 +1,347 @@ +/* Automation Studio generated header file */ +/* Do not edit ! */ + +#ifndef _BRSYSTEM_ +#define _BRSYSTEM_ +#ifdef __cplusplus +extern "C" +{ +#endif + +#include + +#include + +#ifndef _BUR_PUBLIC +#define _BUR_PUBLIC +#endif +/* Constants */ +#ifdef _REPLACE_CONST + #define brWINDOWS_BLUESCREEN 1U + #define brWINDOWS_OK 0U + #define brX2X 10U + #define brPP 255U + #define brCPU 1U + #define brKEY 8U + #define brDRAM 0U + #define br2003 2U + #define br2005 1U + #define br2010 0U + #define brC200 9U + #define brC300 8U + #define brADDON 7U + #define brPANEL 6U + #define brGLOBAL_REMANENT_PV 5U + #define brLOCAL_REMANENT_PV 4U + #define brUSRROM 3U + #define brSYSROM 2U + #define brUSRRAM 1U + #define brACOPOS 7U + #define brCAN_IO 5U + #define brBASE_IO 3U + #define brPRODUCT 0U + #define brETHER_IO 6U + #define brNO_FAMILY 255U + #define brREMOTE_IO 4U + #define brBATTERY_OK 1U + #define brPOWERPANEL 5U + #define brBATTERY_LOW 0U + #define brLOGICSCANNER 3U + #define brPLUGIN_MODULE 10U + #define brSYSTEM_MODULE 2U + #define brBATTERY_NOTEST 2U + #define TARGET_BIG_ENDIAN 2U + #define brBATTERY_MISSING 3U + #define INIT_REASON_UNKNOWN (-1) + #define INIT_REASON_DOWNLOAD 3 + #define TARGET_LITTLE_ENDIAN 1U + #define brAUTOMATION_RUNTIME 4U + #define brERR_INVALID_DEVICE 27250U + #define INIT_REASON_COLDSTART 2 + #define INIT_REASON_WARMSTART 1 + #define brSYSCONF_SET_VOLATILE 0 + #define brERR_INVALID_PARAMETER 27251U + #define brERR_NON_CYCLIC_CONTEXT 27252U + #define brSYSCONF_SET_NON_VOLATILE 1 +#else + #ifndef _GLOBAL_CONST + #define _GLOBAL_CONST _WEAK const + #endif + _GLOBAL_CONST unsigned long brWINDOWS_BLUESCREEN; + _GLOBAL_CONST unsigned long brWINDOWS_OK; + _GLOBAL_CONST unsigned char brX2X; + _GLOBAL_CONST unsigned char brPP; + _GLOBAL_CONST unsigned char brCPU; + _GLOBAL_CONST unsigned char brKEY; + _GLOBAL_CONST unsigned long brDRAM; + _GLOBAL_CONST unsigned char br2003; + _GLOBAL_CONST unsigned char br2005; + _GLOBAL_CONST unsigned char br2010; + _GLOBAL_CONST unsigned char brC200; + _GLOBAL_CONST unsigned char brC300; + _GLOBAL_CONST unsigned char brADDON; + _GLOBAL_CONST unsigned char brPANEL; + _GLOBAL_CONST unsigned long brGLOBAL_REMANENT_PV; + _GLOBAL_CONST unsigned long brLOCAL_REMANENT_PV; + _GLOBAL_CONST unsigned long brUSRROM; + _GLOBAL_CONST unsigned long brSYSROM; + _GLOBAL_CONST unsigned long brUSRRAM; + _GLOBAL_CONST unsigned char brACOPOS; + _GLOBAL_CONST unsigned char brCAN_IO; + _GLOBAL_CONST unsigned char brBASE_IO; + _GLOBAL_CONST unsigned char brPRODUCT; + _GLOBAL_CONST unsigned char brETHER_IO; + _GLOBAL_CONST unsigned char brNO_FAMILY; + _GLOBAL_CONST unsigned char brREMOTE_IO; + _GLOBAL_CONST unsigned char brBATTERY_OK; + _GLOBAL_CONST unsigned char brPOWERPANEL; + _GLOBAL_CONST unsigned char brBATTERY_LOW; + _GLOBAL_CONST unsigned char brLOGICSCANNER; + _GLOBAL_CONST unsigned char brPLUGIN_MODULE; + _GLOBAL_CONST unsigned char brSYSTEM_MODULE; + _GLOBAL_CONST unsigned char brBATTERY_NOTEST; + _GLOBAL_CONST unsigned char TARGET_BIG_ENDIAN; + _GLOBAL_CONST unsigned char brBATTERY_MISSING; + _GLOBAL_CONST signed char INIT_REASON_UNKNOWN; + _GLOBAL_CONST signed char INIT_REASON_DOWNLOAD; + _GLOBAL_CONST unsigned char TARGET_LITTLE_ENDIAN; + _GLOBAL_CONST unsigned char brAUTOMATION_RUNTIME; + _GLOBAL_CONST unsigned short brERR_INVALID_DEVICE; + _GLOBAL_CONST signed char INIT_REASON_COLDSTART; + _GLOBAL_CONST signed char INIT_REASON_WARMSTART; + _GLOBAL_CONST plcbit brSYSCONF_SET_VOLATILE; + _GLOBAL_CONST unsigned short brERR_INVALID_PARAMETER; + _GLOBAL_CONST unsigned short brERR_NON_CYCLIC_CONTEXT; + _GLOBAL_CONST plcbit brSYSCONF_SET_NON_VOLATILE; +#endif + + + + +/* Datatypes and datatypes of function blocks */ +typedef struct MEMInfo +{ + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned long FreeUSR_Ram; + unsigned long FreeSYSTEM; + unsigned long FreeUSR_Prom; + unsigned long FreeSYS_Prom; + unsigned long FreeFIX_Ram; + unsigned long FreeTMP_Ram; + unsigned long FreeMEMCARD; + /* VAR_INPUT (digital) */ + plcbit enable; +} MEMInfo_typ; + +typedef struct MEMxInfo +{ + /* VAR_INPUT (analog) */ + unsigned long mem_typ; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned long MemSize; + unsigned long FreeMemSize; + unsigned long BiggestFreeBlockSize; + /* VAR (analog) */ + unsigned short i_state; + unsigned short i_result; + unsigned long i_tmp; + /* VAR_INPUT (digital) */ + plcbit enable; +} MEMxInfo_typ; + +typedef struct SysInfo +{ + /* VAR_OUTPUT (analog) */ + unsigned char init_reason; + unsigned char init_count; + unsigned long tick_count; + unsigned long version; + /* VAR_INPUT (digital) */ + plcbit enable; +} SysInfo_typ; + +typedef struct RTInfo +{ + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned long cycle_time; + signed char init_reason; + signed char task_class; + /* VAR_INPUT (digital) */ + plcbit enable; +} RTInfo_typ; + +typedef struct TARGETInfo +{ + /* VAR_INPUT (analog) */ + unsigned long pOSVersion; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned char DataFormat; + /* VAR_INPUT (digital) */ + plcbit enable; +} TARGETInfo_typ; + +typedef struct HWInfo +{ + /* VAR_INPUT (analog) */ + unsigned long pName; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned char family; + unsigned char usetype; + unsigned long module_typ; + unsigned char master_no; + unsigned char slave_no; + unsigned char module_adr; + unsigned char slot_no; + /* VAR (analog) */ + unsigned long next_vw_p; + unsigned long last_modul_p; + unsigned long next_entry_p; + unsigned char next_entry_ix; + unsigned char next_slot_ix; + unsigned char last_rio_master; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit first; +} HWInfo_typ; + +typedef struct SysconfInfo +{ + /* VAR_INPUT (analog) */ + unsigned long pEntry; + unsigned long pValue; + unsigned long value_len; + /* VAR_OUTPUT (analog) */ + unsigned short status; + /* VAR_INPUT (digital) */ + plcbit enable; +} SysconfInfo_typ; + +typedef struct SysconfSet +{ + /* VAR_INPUT (analog) */ + unsigned long pEntry; + unsigned long pNewValue; + unsigned char option; + /* VAR_OUTPUT (analog) */ + unsigned short status; + /* VAR_INPUT (digital) */ + plcbit enable; +} SysconfSet_typ; + +typedef struct BatteryInfo +{ + /* VAR_INPUT (analog) */ + unsigned long pDevice; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned char state; + /* VAR_INPUT (digital) */ + plcbit enable; +} BatteryInfo_typ; + +typedef struct EXCInfo +{ + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned long task_class; + unsigned long task_ident; + /* VAR_INPUT (digital) */ + plcbit enable; +} EXCInfo_typ; + +typedef struct ZYKVLenable +{ + /* VAR_OUTPUT (analog) */ + unsigned short status; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit mode; +} ZYKVLenable_typ; + +typedef struct PMemGet +{ + /* VAR_INPUT (analog) */ + unsigned long offset; + unsigned long len; + unsigned long adress; + /* VAR_OUTPUT (analog) */ + unsigned short status; + /* VAR_INPUT (digital) */ + plcbit enable; +} PMemGet_typ; + +typedef struct PMemPut +{ + /* VAR_INPUT (analog) */ + unsigned long offset; + unsigned long len; + unsigned long adress; + /* VAR_OUTPUT (analog) */ + unsigned short status; + /* VAR_INPUT (digital) */ + plcbit enable; +} PMemPut_typ; + +typedef struct PMemSize +{ + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned long size; + /* VAR_INPUT (digital) */ + plcbit enable; +} PMemSize_typ; + +typedef struct ARwinWindowsInfo +{ + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned long windowsStatus; + /* VAR_INPUT (digital) */ + plcbit enable; +} ARwinWindowsInfo_typ; + +typedef struct ARwinEthWinInfo +{ + /* VAR_OUTPUT (analog) */ + unsigned short status; + plcstring IPAddr[16]; + plcstring SubnetMask[16]; + plcbyte MacAddr[6]; + /* VAR_INPUT (digital) */ + plcbit enable; +} ARwinEthWinInfo_typ; + + + +/* Prototyping of functions and function blocks */ +_BUR_PUBLIC void MEMInfo(struct MEMInfo* inst); +_BUR_PUBLIC void MEMxInfo(struct MEMxInfo* inst); +_BUR_PUBLIC void SysInfo(struct SysInfo* inst); +_BUR_PUBLIC void RTInfo(struct RTInfo* inst); +_BUR_PUBLIC void TARGETInfo(struct TARGETInfo* inst); +_BUR_PUBLIC void HWInfo(struct HWInfo* inst); +_BUR_PUBLIC void SysconfInfo(struct SysconfInfo* inst); +_BUR_PUBLIC void SysconfSet(struct SysconfSet* inst); +_BUR_PUBLIC void BatteryInfo(struct BatteryInfo* inst); +_BUR_PUBLIC void EXCInfo(struct EXCInfo* inst); +_BUR_PUBLIC void ZYKVLenable(struct ZYKVLenable* inst); +_BUR_PUBLIC void PMemGet(struct PMemGet* inst); +_BUR_PUBLIC void PMemPut(struct PMemPut* inst); +_BUR_PUBLIC void PMemSize(struct PMemSize* inst); +_BUR_PUBLIC void ARwinWindowsInfo(struct ARwinWindowsInfo* inst); +_BUR_PUBLIC void ARwinEthWinInfo(struct ARwinEthWinInfo* inst); +_BUR_PUBLIC plcbit RTCyclic(void); +_BUR_PUBLIC plcbit RTInit(void); +_BUR_PUBLIC plcbit RTExit(void); + + +#ifdef __cplusplus +}; +#endif +#endif /* _BRSYSTEM_ */ + diff --git a/Logical/Libraries/brsystem/binary.lby b/Logical/Libraries/brsystem/binary.lby new file mode 100644 index 0000000..c174b3d --- /dev/null +++ b/Logical/Libraries/brsystem/binary.lby @@ -0,0 +1,12 @@ + + + + + brsystem.fun + brsystem.typ + brsystem.var + + + + + \ No newline at end of file diff --git a/Logical/Libraries/brsystem/brsystem.fun b/Logical/Libraries/brsystem/brsystem.fun new file mode 100644 index 0000000..dc3386a --- /dev/null +++ b/Logical/Libraries/brsystem/brsystem.fun @@ -0,0 +1,216 @@ + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION_BLOCK MEMInfo (*returns information about the memory areas available on the system*) + VAR_INPUT + enable :BOOL; (*enables execution*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, 0xXXXX = see help*) + FreeUSR_Ram :UDINT; (*SG3: free memory in USER RAM SG4: free memory in SRAM (Userram)*) + FreeSYSTEM :UDINT; (*SG3: free system memory SG4: not used, always 0*) + FreeUSR_Prom :UDINT; (*SG3: free memory in USER PROM SG4: free memory of HD where RPSHD is located*) + FreeSYS_Prom :UDINT; (*SG3: free memory in system PROM SG4: free memory of HD where RPSHD is located*) + FreeFIX_Ram :UDINT; (*SG3: free memory in FIX RAM SG4: not used, always 0*) + FreeTMP_Ram :UDINT; (*SG3: free temporary memory in RAM SG4: free memory in DRAM*) + FreeMEMCARD :UDINT; (*SG3: free memory on MEMCARD SG4: not used, always 0*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION_BLOCK MEMxInfo (*returns information about the memory areas available in the system; asynchronous execution*) + VAR_INPUT + enable :BOOL; (*enables execution*) + mem_typ :UDINT; (*memory type: brDRAM, brUSRRAM, brSYSROM, brUSRROM*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, ERR_FUB_BUSY, 0xXXXX = see help*) + MemSize :UDINT; (*total memory size in bytes*) + FreeMemSize :UDINT; (*size of available memory in bytes*) + BiggestFreeBlockSize :UDINT; (*size of the largest available block in memory in bytes*) + END_VAR + VAR + i_state :UINT; (*internal variable*) + i_result :UINT; (*internal variable*) + i_tmp :UDINT; (*internal variable*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION_BLOCK SysInfo (*returns information about the target system*) + VAR_INPUT + enable :BOOL; (*enables execution*) + END_VAR + VAR_OUTPUT + init_reason :USINT; (*reason for initialization*) + init_count :USINT; (*SG3: the value is increased by every INIT (warm restart) SG4: not used, always 0*) + tick_count :UDINT; (*tick count*) + version :UDINT; (*operating system version of the target system*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION_BLOCK RTInfo (*returns runtime information about the program*) + VAR_INPUT + enable :BOOL; (*enables execution*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, 0xXXXX = see help*) + cycle_time :UDINT; (*cycle time in microsec*) + init_reason :SINT; (*reason for initialization*) + task_class :SINT; (*task class (SG3: #1 - #4 SG4: #1 - #8)*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION_BLOCK TARGETInfo (*returns information about the target system used*) + VAR_INPUT + enable :BOOL; (*enables execution*) + pOSVersion :UDINT; (*string given as a pointer (min. 7 char), where the os version is written*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, 0xXXXX = see help*) + DataFormat :USINT; (*wether "big endian" or "little endian" ("TARGET_BIG_ENDIAN"/"TARGET_LITTLE_ENDIAN")*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_ERROR} FUNCTION_BLOCK HWInfo (*returns information about the hardware configuration*) + VAR_INPUT + enable :BOOL; (*enables execution*) + first :BOOL; (*determines the hardware module on which the FUB is used 0/1 next/first*) + pName :UDINT; (*string given as a pointer, where the name of the module is written*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, 0xXXXX = see help*) + family :USINT; (*family designation*) + usetype :USINT; (*hardware type*) + module_typ :UDINT; (*module type*) + master_no :USINT; (*logical number of the IO master, RIO master, CAN bus with CANIO*) + slave_no :USINT; (*slave number*) + module_adr :USINT; (*hardware module address (decimal)*) + slot_no :USINT; (*slot of the first submodule found (decimal)*) + END_VAR + VAR + next_vw_p :UDINT; (*internal variable*) + last_modul_p :UDINT; (*internal variable*) + next_entry_p :UDINT; (*internal variable*) + next_entry_ix :USINT; (*internal variable*) + next_slot_ix :USINT; (*internal variable*) + last_rio_master :USINT; (*internal variable*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION_BLOCK SysconfInfo (*returns the parameters for a sysconf entry*) + VAR_INPUT + enable :BOOL; (*enables execution*) + pEntry :UDINT; (*string given as a pointer, where the name of the entry is written*) + pValue :UDINT; (*string given as a pointer, where the value of the entry is copied*) + value_len :UDINT; (*length of the "value-string"*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, 0xXXXX = see help*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_ERROR} FUNCTION_BLOCK SysconfSet (*sets the parameters for a sysconf entry*) + VAR_INPUT + enable :BOOL; (*enables execution*) + pEntry :UDINT; (*string given as a pointer, where the name of the entry is written*) + pNewValue :UDINT; (*string given as a pointer, where the new value of the entry is written*) + option :USINT; (*sets the parameter volatile/permanent ("brSYSCONF_SET_VOLATILE"/"brSYSCONF_SET_NON_VOLATILE")*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, 0xXXXX = see help*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION_BLOCK BatteryInfo (*returns the state of the battery*) + VAR_INPUT + enable :BOOL; (*enables execution*) + pDevice :UDINT; (*device name given as a pointer*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, 0xXXXX = see help*) + state :USINT; (*state of the battery*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_ERROR} FUNCTION_BLOCK EXCInfo (*returns information about the program that triggered the exception*) + VAR_INPUT + enable :BOOL; (*enables execution*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, 0xXXXX = see help*) + task_class :UDINT; (*task class in which the exception was triggered*) + task_ident :UDINT; (*ID number of the program that triggered the exception*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_ERROR} FUNCTION_BLOCK ZYKVLenable (*enables/disables the cycle time monitoring of programs*) + VAR_INPUT + enable :BOOL; (*enables execution*) + mode :BOOL; (*0/1 monitoring off/on*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, 0xXXXX = see help*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_ERROR} FUNCTION_BLOCK PMemGet (*reads data of len byte from the permanent memeory area beginning at offset*) + VAR_INPUT + enable :BOOL; (*enables execution*) + offset :UDINT; (*offset within the permanent memory area*) + len :UDINT; (*length of data area to be read*) + adress :UDINT; (*address where the read data is copied*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, 0xXXXX = see help*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_ERROR} FUNCTION_BLOCK PMemPut (*writes len bytes to the permanent memory area beginning at offset*) + VAR_INPUT + enable :BOOL; (*enables execution*) + offset :UDINT; (*offset within the permanent memory area*) + len :UDINT; (*length of data area to be written*) + adress :UDINT; (*address of the data to be written to the permanent memory area*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, 0xXXXX = see help*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_ERROR} FUNCTION_BLOCK PMemSize (*determines the size of permanent memory area in its existing configuration*) + VAR_INPUT + enable :BOOL; (*enables execution*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, 0xXXXX = see help*) + size :UDINT; (*size of permanent memory area*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_ERROR} FUNCTION_BLOCK ARwinWindowsInfo (*get status of windows system*) + VAR_INPUT + enable :BOOL; (*enables execution*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, 0xXXXX = see help*) + windowsStatus :UDINT; (*windows system status: brWINDOWS_BLUESCREEN, brWINDOWS_OK*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_ERROR} FUNCTION_BLOCK ARwinEthWinInfo (*get ETH info windows interface*) + VAR_INPUT + enable :BOOL; (*enables execution*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, 0xXXXX = see help*) + IPAddr :STRING[15]; (*IP-address of virtual windows IF*) + SubnetMask :STRING[15]; (*netmask of virtual windows IF*) + MacAddr :ARRAY[0..5] OF BYTE; (*MAC-address of virtual windows IF*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_OK} FUNCTION RTCyclic : BOOL (*returns true, if function is called in the cyclic part of the program, false otherwise*) +END_FUNCTION + +{REDUND_OK} FUNCTION RTInit : BOOL (*returns true, if function is called in the init part of the program, false otherwise*) +END_FUNCTION + +{REDUND_OK} FUNCTION RTExit : BOOL (*returns true, if function is called in the exit part of the program, false otherwise*) +END_FUNCTION \ No newline at end of file diff --git a/Logical/Libraries/brsystem/brsystem.typ b/Logical/Libraries/brsystem/brsystem.typ new file mode 100644 index 0000000..22bfc94 --- /dev/null +++ b/Logical/Libraries/brsystem/brsystem.typ @@ -0,0 +1,4 @@ + +TYPE + +END_TYPE diff --git a/Logical/Libraries/brsystem/brsystem.var b/Logical/Libraries/brsystem/brsystem.var new file mode 100644 index 0000000..d8b2db1 --- /dev/null +++ b/Logical/Libraries/brsystem/brsystem.var @@ -0,0 +1,49 @@ + +VAR CONSTANT + brSYSCONF_SET_NON_VOLATILE : BOOL := TRUE; (*set permanent value*) + brERR_NON_CYCLIC_CONTEXT : UINT := 27252; (*non-cyclic context call*) + brERR_INVALID_PARAMETER : UINT := 27251; (*invalid parameter transferred*) + brSYSCONF_SET_VOLATILE : BOOL := FALSE; (*set non-permanent value*) + INIT_REASON_WARMSTART : SINT := 1; (*warm restart boot information*) + INIT_REASON_COLDSTART : SINT := 2; (*cold restart boot information*) + brERR_INVALID_DEVICE : UINT := 27250; (*battery monitoring*) + brAUTOMATION_RUNTIME : USINT := 4; (*series recognition*) + TARGET_LITTLE_ENDIAN : USINT := 1; (*formatSpec*) + INIT_REASON_DOWNLOAD : SINT := 3; (*download boot information*) + INIT_REASON_UNKNOWN : SINT := -1; (*unknown boot information*) + brBATTERY_MISSING : USINT := 3; (*battery monitoring*) + TARGET_BIG_ENDIAN : USINT := 2; (*formatSpec*) + brBATTERY_NOTEST : USINT := 2; (*battery monitoring*) + brSYSTEM_MODULE : USINT := 2; (*usage recognition*) + brPLUGIN_MODULE : USINT := 10; (*usage recognition*) + brLOGICSCANNER : USINT := 3; (*series recognition*) + brBATTERY_LOW : USINT := 0; (*battery monitoring*) + brPOWERPANEL : USINT := 5; (*series recognition*) + brBATTERY_OK : USINT := 1; (*battery monitoring*) + brREMOTE_IO : USINT := 4; (*usage recognition*) + brNO_FAMILY : USINT := 255; (*series recognition*) + brETHER_IO : USINT := 6; (*usage recognition*) + brPRODUCT : USINT := 0; (*usage recognition*) + brBASE_IO : USINT := 3; (*usage recognition*) + brCAN_IO : USINT := 5; (*usage recognition*) + brACOPOS : USINT := 7; (*usage recognition*) + brUSRRAM : UDINT := 1; (*USRRAM memory type*) + brSYSROM : UDINT := 2; (*SYSROM memory type*) + brUSRROM : UDINT := 3; (*USRROM memory type*) + brLOCAL_REMANENT_PV : UDINT := 4; (*local REMMEM memory type*) + brGLOBAL_REMANENT_PV : UDINT := 5; (*global REMMEM memory type*) + brPANEL : USINT := 6; (*series recognition*) + brADDON : USINT := 7; (*series recognition*) + brC300 : USINT := 8; (*series recognition*) + brC200 : USINT := 9; (*series recognition*) + br2010 : USINT := 0; (*series recognition*) + br2005 : USINT := 1; (*series recognition*) + br2003 : USINT := 2; (*series recognition*) + brDRAM : UDINT := 0; (*DRAM memory type*) + brKEY : USINT := 8; (*usage recognition*) + brCPU : USINT := 1; (*usage recognition*) + brPP : USINT := 255; (*usage recognition*) + brX2X : USINT := 10; (*series recognition*) + brWINDOWS_OK : UDINT := 0; (*Windows OK*) + brWINDOWS_BLUESCREEN : UDINT := 1; (*Windows in bluescreen*) +END_VAR diff --git a/Logical/Libraries/sys_lib/SG3/sys_lib.h b/Logical/Libraries/sys_lib/SG3/sys_lib.h new file mode 100644 index 0000000..039504c --- /dev/null +++ b/Logical/Libraries/sys_lib/SG3/sys_lib.h @@ -0,0 +1,684 @@ +/****************************************************************************/ +/* */ +/* sys_lib.h */ +/* Declarations and Prototypes for libsys_lib.a */ +/* */ +/* Automation Studio */ +/* Copyright Bernecker&Rainer 1998 */ +/* */ +/****************************************************************************/ + +#ifndef _SYS_LIB_H_ +#define _SYS_LIB_H_ +#ifdef __cplusplus +extern "C" +{ +#endif + +#include + +#include + +#define TMP_MODE 0x8000 /* temporary suspend/resume for */ + /* PLC and user task */ + +/* Error codes of the BURTRAP/SYS_LIB services */ + +#define ERR_BUR_WRROW 2061 /* illegal row */ +#define ERR_BUR_WRCOL 2062 /* illegal column */ +#define ERR_BUR_WR_CHAR 2063 /* invalid ASCII character */ +#define ERR_BUR_NORTC 2073 /* RTC not existing or uninitialized */ + +#define ERR_BUR_MO_NOTFOUND 3019 /* module not found */ +#define ERR_BUR_NOMEM 3030 /* out of memory */ +#define ERR_BUR_MEMVWBUSY 3035 /* memory management busy */ +#define ERR_BUR_ILLPTR 3104 /* illegal data pointer in MEM_free */ + +#define ERR_BUR_PSOS_BASE 3300 /* base number of pSOS errors */ + +#define ERR_BUR_ILLTKNR 3300 /* illegal task-class number */ +#define ERR_BUR_WROFFSET 3301 /* illegal offset */ +#define ERR_BUR_ILLSTATE 3302 /* illegal state of object */ +#define ERR_BUR_NOMSG 3303 /* no message sent/received */ +#define ERR_BUR_DUPOBJ 3305 /* object exists */ +#define ERR_BUR_TIMEOUT 3304 /* timeout error */ +#define ERR_BUR_EXISTS 3306 /* entry exists */ +#define ERR_BUR_LCOUNT 3307 /* Linkcnt <> 0 in AVT_cancel () */ +#define ERR_BUR_BURNING 3308 /* error burning module */ +#define ERR_BUR_INVALIDMBX 3309 /* invalid mailbox */ + +#define ERR_BUR_ILLBPTR 3310 /* invalid base pointer */ +#define ERR_BUR_ILLTYP 3311 /* invalid I/O type */ +#define ERR_BUR_ILLEXT 3312 /* invalid ext. bit */ +#define ERR_BUR_ILLVER 3313 /* invalid version */ + /* e.g. BURTRAP V1.10 to SPSSW V1.05 */ +#define ERR_BUR_ILLLEN 3314 /* invalid data length */ +#define ERR_BUR_MAX_LCOUNT 3315 /* AVT_attach: LCOUNT > 127 */ +#define ERR_BUR_AVT_FREE 3316 /* AVT_release:LCOUNT = 0 */ +#define ERR_BUR_ILLPAR 3317 /* illegal parameter */ +#define ERR_BUR_INSTALL 3318 /* error install datamodule */ +#define ERR_BUR_WRONG_MODTYP 3319 /* wrong Moduletype */ + + +#define ERR_BUR_OBJDEL 3320 /* object already deleted */ +#define ERR_BUR_ILLOBJ 3324 /* object does not exist */ +#define ERR_BUR_ILLOBJTYP 3328 /* invalid object type */ +#define ERR_BUR_NOENTRY 3332 /* no entry */ +#define ERR_BUR_TOOLONG_PVNAME 3333 /* too long PV name */ +#define ERR_BUR_ILLIDENT 3336 /* illegal ident */ +#define ERR_BUR_NOSMBUF 3560 /* no more semaphore buffers */ +#define ERR_BUR_NOSM 3564 /* semaphore not available */ +#define ERR_BUR_SMDEL 3568 /* semaphore deleted */ +#define ERR_BUR_NOTIME 3584 /* time not available */ +#define ERR_BUR_ILLDATE 3588 /* date : out of range */ +#define ERR_BUR_ILLTIME 3592 /* time : out of range */ +#define ERR_BUR_ILLTICKS 3596 /* ticks : out of range */ + +#define ERR_BUR_MEM_ALLOC 3600 /* not enough continuous memory */ +#define ERR_BUR_TMP_ALLOC 3601 /* not enough continuous memory */ +#define ERR_BUR_MEM_FREE 3700 /* invalid pointer/length */ +#define ERR_BUR_TMP_FREE 3701 /* invalid pointer/length */ + +/* State for object PLC task */ +#define Z_ST_created 1 +#define Z_ST_running 2 +#define Z_ST_blocked 3 +#define Z_ST_exist 0x00 +#define Z_ST_installed 0x82 +#define Z_ST_PVinstalled 0x83 +#define Z_ST_IOinstalled 0x84 +#define Z_ST_IOdeinstalled 0x85 +#define Z_ST_PVdeinstalled 0x86 +#define Z_ST_delete 0x87 +#define Z_ST_stdebug 0x88 +#define Z_ST_tmp_suspended 0x90 + +/* PV data types */ +#define PB_DT_STRUCT 0 /* structure */ +#define PB_DT_BOOL 1 /* boolean */ +#define PB_DT_INT8 2 /* integer8 */ +#define PB_DT_INT16 3 /* integer16 */ +#define PB_DT_INT32 4 /* integer32 */ +#define PB_DT_BYTE 5 /* unsigned integer8 */ +#define PB_DT_WORD 6 /* unsigned integer16 */ +#define PB_DT_LONG 7 /* unsigned integer32 */ +#define PB_DT_FLOAT 8 /* floating point */ +#define PB_DT_VIS 9 /* visible string*/ +#define PB_DT_OCTET 10 /* octet string */ +#define PB_DT_DATE 11 /* date */ +#define PB_DT_TIME 12 /* time of day */ +#define PB_DT_DIFF 13 /* time difference */ +#define PB_DT_BIT 14 /* bit string */ +#define PB_DT_ARRAY 15 /* array */ + +/* memory types */ +#define SYS_RAM 1 /* RAM */ +#define USER_ROM1 2 /* EPROM */ +#define FIX_RAM 5 /* fixed RAM */ + +typedef struct RTCtime_typ { + /* 1. UDINT */ + UINT year; /* year, starting with zero */ + USINT month; /* month: 1 - 12 */ + USINT day; /* day: 1 - 31 */ + /* 2. UDINT */ + USINT reserve; + USINT hour; /* hour: 0 - 23 */ + USINT minute; /* minute: 0 - 59 */ + USINT second; /* second: 0 - 59 */ + /* 3. UDINT */ + UINT millisec; /* millisecond: 0 - 999 */ + UINT microsec; /* microsecond: 0 - 999 */ + } RTCtime_typ; + +/* structure for SYSxinfo */ +typedef struct SYSxinfo_typ { + char aws_name[6]; + char aws_type[2]; + UDINT cpu_info; + UINT ma_globl_len; + UINT md_globl_len; + UDINT os_len; + UDINT user_len; + UDINT tmp_len; + UDINT eprom_len; + UDINT fix_ram_len; + } SYSxinfo_typ; + +/* structure for MO_list */ +typedef struct MO_List_typ { + char name[14]; /* name of the module (ASCII) */ + USINT grp; /* groups */ + USINT type; /* module type */ + USINT state; /* state of the module */ + USINT reserve; + UDINT adress; /* physical address of the module */ + UDINT memtype; /* memory type (0=OTP,1=RAM,2=EPROM,3=FLASH */ + } MO_List_typ; /* 5=FIXRAM) */ + +/* structure for MO_info */ +typedef struct MO_info +{ + /* VAR_INPUT (analog) */ + unsigned long pName; + unsigned char grp; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned char type; + unsigned char state; + unsigned long memType; + unsigned long address; + unsigned long size; + unsigned char version[10]; + struct RTCtime_typ date; + /* VAR_INPUT (digital) */ + plcbit enable; +} MO_info_typ; + +/* structure for PV_list */ +typedef struct PV_List_typ { + char name[14]; /* name of the PV (ASCII) */ + USINT tcnr; /* PV task class */ + USINT grp; /* PV group */ + UDINT ident; /* PV identifier */ + UDINT adress; /* physical address of the PV */ + } PV_List_typ; + +/* structue for PV_xlist */ +typedef struct PV_xList_typ { + + char name[33]; /* name of PV (ASCII) */ + USINT data_typ; /* data type of PV */ + UDINT data_len; /* data length of PV */ + UDINT dimension; /* dimension of PV */ + UDINT adress; /* physical address of PV */ + }PV_xList_typ; + +/* structure for ERR_read */ +typedef struct ERR_typ { + UINT err_nr; /* error number */ + UDINT err_info; /* additional information */ + char t_name[5]; /* name of the running task */ + USINT err_type; /* error type (1=fatal, 2=warning, 3=info) */ + UINT err_year; /* time of the error in RTC format */ + USINT err_month; + USINT err_day; + USINT err_reserve; + USINT err_hour; + USINT err_minute; + USINT err_second; + UINT err_millisec; + UINT err_microsec; + } ERR_typ; + +/* structure for ERR_xread */ +typedef struct ERR_xtyp { + UINT err_nr; /* error number */ + UDINT err_info; /* additional information */ + char t_name[5]; /* name of the running task */ + USINT err_type; /* error type (1=Fatal, 2=Warning, 3=Info) */ + UINT err_year; /* time of the error in RTC format */ + USINT err_month; + USINT err_day; + USINT err_reserve; + USINT err_hour; + USINT err_minute; + USINT err_second; + UINT err_millisec; + UINT err_microsec; + USINT err_string[34]; /* 32 byte string with 0 termination */ + } ERR_xtyp; + +/* structure for MO_ver */ +typedef struct MoVerStruc_typ { + USINT version[10]; /* Version of the BR Module */ + UINT year; + USINT month; + USINT day; + USINT reserve; + USINT hour; + USINT minute; + USINT second; + } MoVerStruc_typ; + +/* structure for the FUB Bit2Byte */ +typedef struct Bit2Byte { + /* non boolean input parameter */ + UDINT bitadr; + UINT length; + /* non boolean output parameter*/ + UDINT byteadr; + /* non boolean static local */ + USINT byte_00; + USINT byte_01; + USINT byte_02; + USINT byte_03; + USINT byte_04; + USINT byte_05; + USINT byte_06; + USINT byte_07; + USINT byte_08; + USINT byte_09; + USINT byte_10; + USINT byte_11; + USINT byte_12; + USINT byte_13; + USINT byte_14; + USINT byte_15; + /* boolean input parameter */ + /* boolean output parameter */ + /* boolean static local */ + BOOL bmem000; + BOOL bmem001; + BOOL bmem002; + BOOL bmem003; + BOOL bmem004; + BOOL bmem005; + BOOL bmem006; + BOOL bmem007; + BOOL bmem008; + BOOL bmem009; + BOOL bmem010; + BOOL bmem011; + BOOL bmem012; + BOOL bmem013; + BOOL bmem014; + BOOL bmem015; + BOOL bmem016; + BOOL bmem017; + BOOL bmem018; + BOOL bmem019; + BOOL bmem020; + BOOL bmem021; + BOOL bmem022; + BOOL bmem023; + BOOL bmem024; + BOOL bmem025; + BOOL bmem026; + BOOL bmem027; + BOOL bmem028; + BOOL bmem029; + BOOL bmem030; + BOOL bmem031; + BOOL bmem032; + BOOL bmem033; + BOOL bmem034; + BOOL bmem035; + BOOL bmem036; + BOOL bmem037; + BOOL bmem038; + BOOL bmem039; + BOOL bmem040; + BOOL bmem041; + BOOL bmem042; + BOOL bmem043; + BOOL bmem044; + BOOL bmem045; + BOOL bmem046; + BOOL bmem047; + BOOL bmem048; + BOOL bmem049; + BOOL bmem050; + BOOL bmem051; + BOOL bmem052; + BOOL bmem053; + BOOL bmem054; + BOOL bmem055; + BOOL bmem056; + BOOL bmem057; + BOOL bmem058; + BOOL bmem059; + BOOL bmem060; + BOOL bmem061; + BOOL bmem062; + BOOL bmem063; + BOOL bmem064; + BOOL bmem065; + BOOL bmem066; + BOOL bmem067; + BOOL bmem068; + BOOL bmem069; + BOOL bmem070; + BOOL bmem071; + BOOL bmem072; + BOOL bmem073; + BOOL bmem074; + BOOL bmem075; + BOOL bmem076; + BOOL bmem077; + BOOL bmem078; + BOOL bmem079; + BOOL bmem080; + BOOL bmem081; + BOOL bmem082; + BOOL bmem083; + BOOL bmem084; + BOOL bmem085; + BOOL bmem086; + BOOL bmem087; + BOOL bmem088; + BOOL bmem089; + BOOL bmem090; + BOOL bmem091; + BOOL bmem092; + BOOL bmem093; + BOOL bmem094; + BOOL bmem095; + BOOL bmem096; + BOOL bmem097; + BOOL bmem098; + BOOL bmem099; + BOOL bmem100; + BOOL bmem101; + BOOL bmem102; + BOOL bmem103; + BOOL bmem104; + BOOL bmem105; + BOOL bmem106; + BOOL bmem107; + BOOL bmem108; + BOOL bmem109; + BOOL bmem110; + BOOL bmem111; + BOOL bmem112; + BOOL bmem113; + BOOL bmem114; + BOOL bmem115; + BOOL bmem116; + BOOL bmem117; + BOOL bmem118; + BOOL bmem119; + BOOL bmem120; + BOOL bmem121; + BOOL bmem122; + BOOL bmem123; + BOOL bmem124; + BOOL bmem125; + BOOL bmem126; + BOOL bmem127; + BOOL bmem128; + BOOL bmem129; + BOOL bmem130; + BOOL bmem131; + BOOL bmem132; + BOOL bmem133; + BOOL bmem134; + BOOL bmem135; + BOOL bmem136; + BOOL bmem137; + BOOL bmem138; + BOOL bmem139; + } Bit2Byte_typ; + +/* structure for the FUB Byte2Bit */ +typedef struct Byte2Bit { + /* non boolean input parameter */ + UDINT byteadr; + UINT length; + /* non boolean output parameter*/ + UDINT bitadr; + /* non boolean static local */ + /* boolean input parameter */ + /* boolean output parameter */ + /* boolean static local */ + BOOL bmem000; + BOOL bmem001; + BOOL bmem002; + BOOL bmem003; + BOOL bmem004; + BOOL bmem005; + BOOL bmem006; + BOOL bmem007; + BOOL bmem008; + BOOL bmem009; + BOOL bmem010; + BOOL bmem011; + BOOL bmem012; + BOOL bmem013; + BOOL bmem014; + BOOL bmem015; + BOOL bmem016; + BOOL bmem017; + BOOL bmem018; + BOOL bmem019; + BOOL bmem020; + BOOL bmem021; + BOOL bmem022; + BOOL bmem023; + BOOL bmem024; + BOOL bmem025; + BOOL bmem026; + BOOL bmem027; + BOOL bmem028; + BOOL bmem029; + BOOL bmem030; + BOOL bmem031; + BOOL bmem032; + BOOL bmem033; + BOOL bmem034; + BOOL bmem035; + BOOL bmem036; + BOOL bmem037; + BOOL bmem038; + BOOL bmem039; + BOOL bmem040; + BOOL bmem041; + BOOL bmem042; + BOOL bmem043; + BOOL bmem044; + BOOL bmem045; + BOOL bmem046; + BOOL bmem047; + BOOL bmem048; + BOOL bmem049; + BOOL bmem050; + BOOL bmem051; + BOOL bmem052; + BOOL bmem053; + BOOL bmem054; + BOOL bmem055; + BOOL bmem056; + BOOL bmem057; + BOOL bmem058; + BOOL bmem059; + BOOL bmem060; + BOOL bmem061; + BOOL bmem062; + BOOL bmem063; + BOOL bmem064; + BOOL bmem065; + BOOL bmem066; + BOOL bmem067; + BOOL bmem068; + BOOL bmem069; + BOOL bmem070; + BOOL bmem071; + BOOL bmem072; + BOOL bmem073; + BOOL bmem074; + BOOL bmem075; + BOOL bmem076; + BOOL bmem077; + BOOL bmem078; + BOOL bmem079; + BOOL bmem080; + BOOL bmem081; + BOOL bmem082; + BOOL bmem083; + BOOL bmem084; + BOOL bmem085; + BOOL bmem086; + BOOL bmem087; + BOOL bmem088; + BOOL bmem089; + BOOL bmem090; + BOOL bmem091; + BOOL bmem092; + BOOL bmem093; + BOOL bmem094; + BOOL bmem095; + BOOL bmem096; + BOOL bmem097; + BOOL bmem098; + BOOL bmem099; + BOOL bmem100; + BOOL bmem101; + BOOL bmem102; + BOOL bmem103; + BOOL bmem104; + BOOL bmem105; + BOOL bmem106; + BOOL bmem107; + BOOL bmem108; + BOOL bmem109; + BOOL bmem110; + BOOL bmem111; + BOOL bmem112; + BOOL bmem113; + BOOL bmem114; + BOOL bmem115; + BOOL bmem116; + BOOL bmem117; + BOOL bmem118; + BOOL bmem119; + BOOL bmem120; + BOOL bmem121; + BOOL bmem122; + BOOL bmem123; + BOOL bmem124; + BOOL bmem125; + BOOL bmem126; + BOOL bmem127; + BOOL bmem128; + BOOL bmem129; + BOOL bmem130; + BOOL bmem131; + BOOL bmem132; + BOOL bmem133; + BOOL bmem134; + BOOL bmem135; + BOOL bmem136; + BOOL bmem137; + BOOL bmem138; + BOOL bmem139; + } Byte2Bit_typ; + +/***************/ +/* Prototyping */ +/***************/ + +UINT PV_ident (char *pv_name_p, USINT pv_tcnr, USINT pv_grpnr, + UDINT *pv_ident); +UINT PV_setval (UDINT pv_ident, UDINT value); +UINT PV_getval (UDINT pv_ident, UDINT *value); +UINT PV_getadr (char *pv_name_p, USINT pv_tcnr, USINT pv_grpnr, + UDINT *pv_adresse); +UINT PV_xgetadr (char *pv_name, UDINT *pv_adresse, UDINT *data_len); +UINT PV_xsetval (UDINT pv_ident, UINT subindex, void *data_p, + USINT data_len); +UINT PV_xgetval (UDINT pv_ident, UINT subindex, void *data_p, + USINT data_len); +UINT PV_info (UDINT pv_ident, UDINT *data_type, UDINT *data_len, + UINT *dimension); +UINT PV_list (UINT prev_index, UINT *index, PV_List_typ *pvl_p); +UINT PV_xlist (UINT prev_index, UINT *index, PV_xList_typ *pvl_p); +UINT PV_item (char *pv_name, UINT index, char *itemname); +UINT PV_ninfo (char *pv_name, UDINT *data_typ_p, UDINT *data_len_p, + UINT *dimension_p); + + + +UINT SYS_info (UDINT *sg_init_cnt, UDINT *sg_initdescr, UDINT *sg_tickcnt, + UDINT *sg_version, UDINT *sg_ov_version); +UINT SYSxinfo (SYSxinfo_typ *sx_p); +UINT SYSreset (BOOL enable, USINT mode); +USINT SYS_battery (void); + +UINT MO_list (UINT prev_index, UINT *index, MO_List_typ *mol_p); +void MO_info (struct MO_info* pInst); +UINT KEY_enadis (BOOL mode); +UINT KEY_read (USINT keys[4]); + +UINT FORCE_info (USINT tcnr, BOOL *force); + +UINT ST_ident (char *st_name_p, USINT st_grp, UDINT *st_ident); +UINT ST_suspend (UDINT st_ident); +UINT ST_resume (UDINT st_ident); +UINT ST_tmp_suspend (UDINT st_ident); +UINT ST_tmp_resume (UDINT st_ident); +UINT ST_allsuspend (void); +UINT ST_info (UDINT st_ident, USINT *state, SINT *tcnr); +UINT ST_name (UDINT st_ident, char *st_name_p, USINT *st_grp); + +UINT UT_ident (char *ut_name_p, USINT ut_grp, USINT ut_proc, char *ut_sps_p,UDINT *ut_ident); +UINT UT_suspend (UDINT ut_ident); +UINT UT_resume (UDINT ut_ident); +UINT UT_sleep (UDINT tickcount); +UINT UT_sendmsg (UDINT ut_ident, void *msg, UDINT msglng, UDINT flags); +UINT UT_recmsg (UDINT *ut_ident, void **msg, UDINT *msglng, UDINT flags); +UINT UT_freemsg (UDINT msglng, void *msg); +UINT UT_exit (UDINT exitinfo); + + +UINT AVT_create (char *name_p, USINT grupid, UDINT av_info, UDINT *av_ident); +UINT AVT_cancel (UDINT av_ident); +UINT AVT_ident (char *name_p, USINT grupid, UDINT *av_ident); +UINT AVT_attach (UDINT av_ident, UDINT *av_info); +UINT AVT_release (UDINT av_ident); +UINT AVT_info (UDINT av_ident, USINT *av_linkcount); + +UINT MEM_alloc (UDINT memlng, void **memptr); +UINT MEM_free (UDINT memlng, void *memptr); +UINT TMP_alloc (UDINT memlng, void **memptr); +UINT TMP_free (UDINT memlng, void *memptr); + +UINT RTC_gettime (RTCtime_typ *rtctime); +UINT RTC_settime (RTCtime_typ *rtctime); +UINT SW_gettime (RTCtime_typ *rtctime); +UINT SW_settime (RTCtime_typ *rtctime); +UINT TIM_musec (void); +UINT TIM_ticks (void); + +UINT SM_create (char *sm_name, USINT sm_count, UDINT *sm_ident); +UINT SM_ident (char *sm_name, UDINT *sm_ident); +UINT SM_delete (UDINT sm_ident); +UINT SM_attach (UDINT sm_ident, UDINT timeout, UDINT flags); +UINT SM_release (UDINT sm_ident); + +UINT ERR_warning (UINT errornr, UDINT errorinfo); +UINT ERR_fatal (UINT errornr, UDINT errorinfo); +UINT ERR_read (UINT entry_nr, ERR_typ *err_p); +UINT ERRxwarning (UINT errornr, UDINT errorinfo, char* errorstring); +UINT ERRxread (UINT entry_nr, ERR_xtyp *err_p); +UINT ERRxfatal (UINT errornr, UDINT errorinfo, char* errorstring); + +UINT DIS_str (UDINT row, UDINT col, char *string); +UINT DIS_chr (UDINT row, UDINT col, char character); +UINT DIS_clr (void); + +UINT DA_create (char *name_p, USINT grp, UINT spooladr, UDINT data_len, + void *data_p, void **mo_data_p, UDINT *mo_ident); +UINT DA_write (UDINT mo_ident, void *data_p,UDINT data_len, + UDINT mo_data_offset); +UINT DA_read (UDINT mo_ident, void *data_p,UDINT data_len, + UDINT mo_data_offset); +UINT DA_ident (char *name_p, USINT grp, UDINT *mo_ident); +UINT DA_delete (UDINT mo_ident); +UINT DA_burn (UDINT mo_ident); +UINT DA_fix (UDINT mo_ident); +UINT DA_info (UDINT mo_ident, void **moduldata_adr, UDINT *moduldata_lng, + USINT *memorytype); +UINT DA_copy (UDINT mo_ident, char *new_name, USINT mem_typ, UDINT *da_ident, + UDINT *daten_p, UDINT *daten_len); +UINT DA_store (UDINT mo_ident, USINT mem_typ, UDINT* daten_p, UDINT* daten_len); + +UINT MO_ver (STRING *pName, USINT grp, MoVerStruc_typ* pMoVerStruc); + +void Bit2Byte (Bit2Byte_typ* Bit2Byte_ptr); +void Byte2Bit (Byte2Bit_typ* Byte2Bit_ptr); + +#ifdef __cplusplus +}; +#endif +#endif /* _SYS_LIB_H_ */ + diff --git a/Logical/Libraries/sys_lib/SG4/sys_lib.h b/Logical/Libraries/sys_lib/SG4/sys_lib.h new file mode 100644 index 0000000..da46f3b --- /dev/null +++ b/Logical/Libraries/sys_lib/SG4/sys_lib.h @@ -0,0 +1,730 @@ +/* Automation Studio generated header file */ +/* Do not edit ! */ + +#ifndef _SYS_LIB_H_ +#define _SYS_LIB_H_ +#ifdef __cplusplus +extern "C" +{ +#endif + +#include +#include + +#ifndef _BUR_PUBLIC +#define _BUR_PUBLIC +#endif + +#define TMP_MODE 0x8000 /* temporary suspend/resume for */ + /* PLC and user task */ + +/* Error codes of the BURTRAP/SYS_LIB services */ + +#define ERR_BUR_WRROW 2061 /* illegal row */ +#define ERR_BUR_WRCOL 2062 /* illegal column */ +#define ERR_BUR_WR_CHAR 2063 /* invalid ASCII character */ +#define ERR_BUR_NORTC 2073 /* RTC not existing or uninitialized */ + +#define ERR_BUR_MO_NOTFOUND 3019 /* module not found */ +#define ERR_BUR_NOMEM 3030 /* out of memory */ +#define ERR_BUR_MEMVWBUSY 3035 /* memory management busy */ +#define ERR_BUR_ILLPTR 3104 /* illegal data pointer in MEM_free */ + +#define ERR_BUR_PSOS_BASE 3300 /* base number of pSOS errors */ + +#define ERR_BUR_ILLTKNR 3300 /* illegal task-class number */ +#define ERR_BUR_WROFFSET 3301 /* illegal offset */ +#define ERR_BUR_ILLSTATE 3302 /* illegal state of object */ +#define ERR_BUR_NOMSG 3303 /* no message sent/received */ +#define ERR_BUR_DUPOBJ 3305 /* object exists */ +#define ERR_BUR_TIMEOUT 3304 /* timeout error */ +#define ERR_BUR_EXISTS 3306 /* entry exists */ +#define ERR_BUR_LCOUNT 3307 /* Linkcnt <> 0 in AVT_cancel () */ +#define ERR_BUR_BURNING 3308 /* error burning module */ +#define ERR_BUR_INVALIDMBX 3309 /* invalid mailbox */ + +#define ERR_BUR_ILLBPTR 3310 /* invalid base pointer */ +#define ERR_BUR_ILLTYP 3311 /* invalid I/O type */ +#define ERR_BUR_ILLEXT 3312 /* invalid ext. bit */ +#define ERR_BUR_ILLVER 3313 /* invalid version */ + /* e.g. BURTRAP V1.10 to SPSSW V1.05 */ +#define ERR_BUR_ILLLEN 3314 /* invalid data length */ +#define ERR_BUR_MAX_LCOUNT 3315 /* AVT_attach: LCOUNT > 127 */ +#define ERR_BUR_AVT_FREE 3316 /* AVT_release:LCOUNT = 0 */ +#define ERR_BUR_ILLPAR 3317 /* illegal parameter */ +#define ERR_BUR_INSTALL 3318 /* error install datamodule */ +#define ERR_BUR_WRONG_MODTYP 3319 /* wrong Moduletype */ + +#define ERR_BUR_OBJDEL 3320 /* object already deleted */ +#define ERR_BUR_ILLOBJ 3324 /* object does not exist */ +#define ERR_BUR_ILLOBJTYP 3328 /* invalid object type */ +#define ERR_BUR_NOENTRY 3332 /* no entry */ +#define ERR_BUR_TOOLONG_PVNAME 3333 /* too long PV name */ +#define ERR_BUR_ILLIDENT 3336 /* illegal ident */ +#define ERR_BUR_NOSMBUF 3560 /* no more semaphore buffers */ +#define ERR_BUR_NOSM 3564 /* semaphore not available */ +#define ERR_BUR_SMDEL 3568 /* semaphore deleted */ +#define ERR_BUR_NOTIME 3584 /* time not available */ +#define ERR_BUR_ILLDATE 3588 /* date : out of range */ +#define ERR_BUR_ILLTIME 3592 /* time : out of range */ +#define ERR_BUR_ILLTICKS 3596 /* ticks : out of range */ + +#define ERR_BUR_MEM_ALLOC 3600 /* not enough continuous memory */ +#define ERR_BUR_TMP_ALLOC 3601 /* not enough continuous memory */ +#define ERR_BUR_MEM_FREE 3700 /* invalid pointer/length */ +#define ERR_BUR_TMP_FREE 3701 /* invalid pointer/length */ + +/* State for object PLC task */ +#define Z_ST_created 1 +#define Z_ST_running 2 +#define Z_ST_blocked 3 +#define Z_ST_exist 0x00 +#define Z_ST_installed 0x82 +#define Z_ST_PVinstalled 0x83 +#define Z_ST_IOinstalled 0x84 +#define Z_ST_IOdeinstalled 0x85 +#define Z_ST_PVdeinstalled 0x86 +#define Z_ST_delete 0x87 +#define Z_ST_stdebug 0x88 +#define Z_ST_tmp_suspended 0x90 + +/* PV data types - obsolete */ +#define PB_DT_STRUCT 0 /* structure */ +#define PB_DT_BOOL 1 /* boolean */ +#define PB_DT_INT8 2 /* integer8 */ +#define PB_DT_INT16 3 /* integer16 */ +#define PB_DT_INT32 4 /* integer32 */ +#define PB_DT_BYTE 5 /* unsigned integer8 */ +#define PB_DT_WORD 6 /* unsigned integer16 */ +#define PB_DT_LONG 7 /* unsigned integer32 */ +#define PB_DT_FLOAT 8 /* floating point */ +#define PB_DT_VIS 9 /* visible string */ +#define PB_DT_OCTET 10 /* octet string */ +#define PB_DT_DATE 11 /* date */ +#define PB_DT_TIME 12 /* time of day */ +#define PB_DT_DIFF 13 /* time difference */ +#define PB_DT_BIT 14 /* bit string */ +#define PB_DT_ARRAY 15 /* array */ + +/* elementary data types */ +#define SYSLIB_IEC_TYPE_USER_DEFINED 0 /* User-defined data type */ +#define SYSLIB_IEC_TYPE_USER_DEFINED_2 15 /* User-defined data type (legacy: array of structs) */ +#define SYSLIB_IEC_TYPE_BOOL 1 /* 8 Bit containing a boolean value FALSE=0 or TRUE=1 */ +#define SYSLIB_IEC_TYPE_SINT 2 /* 8 Bit signed integer */ +#define SYSLIB_IEC_TYPE_INT 3 /* 16 Bit signed integer */ +#define SYSLIB_IEC_TYPE_DINT 4 /* 32 Bit signed integer */ +#define SYSLIB_IEC_TYPE_USINT 5 /* 8 Bit unsigned integer */ +#define SYSLIB_IEC_TYPE_UINT 6 /* 16 Bit unsigned integer */ +#define SYSLIB_IEC_TYPE_UDINT 7 /* 32 Bit unsigned integer */ +#define SYSLIB_IEC_TYPE_REAL 8 /* 32 Bit floating point number */ +#define SYSLIB_IEC_TYPE_STRING 9 /* Variable-length single-byte character string */ +#define SYSLIB_IEC_TYPE_DATE_AND_TIME 11 /* 32 Bit of Date in Seconds since 01.01.1970 00:00:00 */ +#define SYSLIB_IEC_TYPE_TIME 12 /* 32 Bit of Time in ms */ +#define SYSLIB_IEC_TYPE_DATE 13 /* 32 Bit of Date (only) */ +#define SYSLIB_IEC_TYPE_LREAL 14 /* 64 Bit floating point number */ +#define SYSLIB_IEC_TYPE_TIME_OF_DAY 16 /* 32 Bit Time of day (only) */ +#define SYSLIB_IEC_TYPE_BYTE 17 /* Bit string of length 8 */ +#define SYSLIB_IEC_TYPE_WORD 18 /* Bit string of length 16 */ +#define SYSLIB_IEC_TYPE_DWORD 19 /* Bit string of length 32 */ +#define SYSLIB_IEC_TYPE_WSTRING 21 /* Variable-length double-byte character string */ + +/* memory types */ +#define SYS_RAM 1 /* RAM */ +#define USER_ROM1 2 /* EPROM */ +#define FIX_RAM 5 /* fixed RAM */ + +/* shutdown / reboot types */ +#define SYSLIB_WARMSTART 0x01 /*WARMSTART(with restart)*/ +#define SYSLIB_COLDSTART 0x02 /*COLDSTART(with restart)*/ +#define SYSLIB_WARMSTART_NO_REBOOT 0x11 /*WARMSTART(no restart, only shutdown)*/ +#define SYSLIB_COLDSTART_NO_REBOOT 0x12 /*COLDSTART(no restart, only shutdown)*/ +#define SYSLIB_DIAGNOSTICS 0x20 /*DIAGNOSTICS(with restart)*/ +#define SYSLIB_SERVICE 0x40 /*SERVICE(with restart) */ + +typedef struct RTCtime_typ { + /* 1. UDINT */ + UINT year; /* year, starting with zero */ + USINT month; /* month: 1 - 12 */ + USINT day; /* day: 1 - 31 */ + /* 2. UDINT */ + USINT reserve; + USINT hour; /* hour: 0 - 23 */ + USINT minute; /* minute: 0 - 59 */ + USINT second; /* second: 0 - 59 */ + /* 3. UDINT */ + UINT millisec; /* millisecond: 0 - 999 */ + UINT microsec; /* microsecond: 0 - 999 */ + } RTCtime_typ; + +/* structure for SYSxinfo */ +typedef struct SYSxinfo_typ { + char aws_name[6]; + char aws_type[2]; + UDINT cpu_info; + UINT ma_globl_len; + UINT md_globl_len; + UDINT os_len; + UDINT user_len; + UDINT tmp_len; + UDINT eprom_len; + UDINT fix_ram_len; + } SYSxinfo_typ; + +/* structure for MO_list */ +typedef struct MO_List_typ { + char name[14]; /* name of the module (ASCII) */ + USINT grp; /* groups */ + USINT type; /* module type */ + USINT state; /* state of the module */ + USINT reserve; + UDINT adress; /* physical address of the module */ + UDINT memtype; /* memory type (0=OTP,1=RAM,2=EPROM,3=FLASH */ + } MO_List_typ; /* 5=FIXRAM) */ + +/* structure for slMoList */ +typedef struct slMoList { + /* VAR_INPUT (analog) */ + unsigned long pMoName; + unsigned long sizeMoName; + unsigned long pAppMoName; + unsigned long sizeAppMoName; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned long moSize; + unsigned char moType; + unsigned char memType; + /* VAR (analog) */ + unsigned long i_hMo; + /* VAR_INPUT (digital) */ + plcbit enable; + plcbit first; + plcbit filter; +} slMoList_typ; + +/* structure for MO_info */ +typedef struct MO_info +{ + /* VAR_INPUT (analog) */ + unsigned long pName; + unsigned char grp; + /* VAR_OUTPUT (analog) */ + unsigned short status; + unsigned char type; + unsigned char state; + unsigned long memType; + unsigned long address; + unsigned long size; + unsigned char version[10]; + struct RTCtime_typ date; + /* VAR_INPUT (digital) */ + plcbit enable; +} MO_info_typ; + +/* structure for PV_list */ +typedef struct PV_List_typ { + char name[14]; /* name of the PV (ASCII) */ + USINT tcnr; /* PV task class */ + USINT grp; /* PV group */ + UDINT ident; /* PV identifier */ + UDINT adress; /* physical address of the PV */ + } PV_List_typ; + +/* structue for PV_xlist */ +typedef struct PV_xList_typ { + + char name[33]; /* name of PV (ASCII) */ + USINT data_typ; /* data type of PV */ + UDINT data_len; /* data length of PV */ + UDINT dimension; /* dimension of PV */ + UDINT adress; /* physical address of PV */ + }PV_xList_typ; + +/* structure for ERR_read */ +typedef struct ERR_typ { + UINT err_nr; /* error number */ + UDINT err_info; /* additional information */ + char t_name[5]; /* name of the running task */ + USINT err_type; /* error type (1=fatal, 2=warning, 3=info) */ + UINT err_year; /* time of the error in RTC format */ + USINT err_month; + USINT err_day; + USINT err_reserve; + USINT err_hour; + USINT err_minute; + USINT err_second; + UINT err_millisec; + UINT err_microsec; + } ERR_typ; + +/* structure for ERR_xread */ +typedef struct ERR_xtyp { + UINT err_nr; /* error number */ + UDINT err_info; /* additional information */ + char t_name[5]; /* name of the running task */ + USINT err_type; /* error type (1=Fatal, 2=Warning, 3=Info) */ + UINT err_year; /* time of the error in RTC format */ + USINT err_month; + USINT err_day; + USINT err_reserve; + USINT err_hour; + USINT err_minute; + USINT err_second; + UINT err_millisec; + UINT err_microsec; + USINT err_string[34]; /* 32 byte string with 0 termination */ + } ERR_xtyp; + +/* structure for MO_ver */ +typedef struct MoVerStruc_typ { + USINT version[10]; /* Version of the BR Module */ + UINT year; + USINT month; + USINT day; + USINT reserve; + USINT hour; + USINT minute; + USINT second; + } MoVerStruc_typ; + +/* structure for the FUB Bit2Byte */ +typedef struct Bit2Byte { + /* non boolean input parameter */ + UDINT bitadr; + UINT length; + /* non boolean output parameter*/ + UDINT byteadr; + /* non boolean static local */ + USINT byte_00; + USINT byte_01; + USINT byte_02; + USINT byte_03; + USINT byte_04; + USINT byte_05; + USINT byte_06; + USINT byte_07; + USINT byte_08; + USINT byte_09; + USINT byte_10; + USINT byte_11; + USINT byte_12; + USINT byte_13; + USINT byte_14; + USINT byte_15; + /* boolean input parameter */ + /* boolean output parameter */ + /* boolean static local */ + BOOL bmem000; + BOOL bmem001; + BOOL bmem002; + BOOL bmem003; + BOOL bmem004; + BOOL bmem005; + BOOL bmem006; + BOOL bmem007; + BOOL bmem008; + BOOL bmem009; + BOOL bmem010; + BOOL bmem011; + BOOL bmem012; + BOOL bmem013; + BOOL bmem014; + BOOL bmem015; + BOOL bmem016; + BOOL bmem017; + BOOL bmem018; + BOOL bmem019; + BOOL bmem020; + BOOL bmem021; + BOOL bmem022; + BOOL bmem023; + BOOL bmem024; + BOOL bmem025; + BOOL bmem026; + BOOL bmem027; + BOOL bmem028; + BOOL bmem029; + BOOL bmem030; + BOOL bmem031; + BOOL bmem032; + BOOL bmem033; + BOOL bmem034; + BOOL bmem035; + BOOL bmem036; + BOOL bmem037; + BOOL bmem038; + BOOL bmem039; + BOOL bmem040; + BOOL bmem041; + BOOL bmem042; + BOOL bmem043; + BOOL bmem044; + BOOL bmem045; + BOOL bmem046; + BOOL bmem047; + BOOL bmem048; + BOOL bmem049; + BOOL bmem050; + BOOL bmem051; + BOOL bmem052; + BOOL bmem053; + BOOL bmem054; + BOOL bmem055; + BOOL bmem056; + BOOL bmem057; + BOOL bmem058; + BOOL bmem059; + BOOL bmem060; + BOOL bmem061; + BOOL bmem062; + BOOL bmem063; + BOOL bmem064; + BOOL bmem065; + BOOL bmem066; + BOOL bmem067; + BOOL bmem068; + BOOL bmem069; + BOOL bmem070; + BOOL bmem071; + BOOL bmem072; + BOOL bmem073; + BOOL bmem074; + BOOL bmem075; + BOOL bmem076; + BOOL bmem077; + BOOL bmem078; + BOOL bmem079; + BOOL bmem080; + BOOL bmem081; + BOOL bmem082; + BOOL bmem083; + BOOL bmem084; + BOOL bmem085; + BOOL bmem086; + BOOL bmem087; + BOOL bmem088; + BOOL bmem089; + BOOL bmem090; + BOOL bmem091; + BOOL bmem092; + BOOL bmem093; + BOOL bmem094; + BOOL bmem095; + BOOL bmem096; + BOOL bmem097; + BOOL bmem098; + BOOL bmem099; + BOOL bmem100; + BOOL bmem101; + BOOL bmem102; + BOOL bmem103; + BOOL bmem104; + BOOL bmem105; + BOOL bmem106; + BOOL bmem107; + BOOL bmem108; + BOOL bmem109; + BOOL bmem110; + BOOL bmem111; + BOOL bmem112; + BOOL bmem113; + BOOL bmem114; + BOOL bmem115; + BOOL bmem116; + BOOL bmem117; + BOOL bmem118; + BOOL bmem119; + BOOL bmem120; + BOOL bmem121; + BOOL bmem122; + BOOL bmem123; + BOOL bmem124; + BOOL bmem125; + BOOL bmem126; + BOOL bmem127; + BOOL bmem128; + BOOL bmem129; + BOOL bmem130; + BOOL bmem131; + BOOL bmem132; + BOOL bmem133; + BOOL bmem134; + BOOL bmem135; + BOOL bmem136; + BOOL bmem137; + BOOL bmem138; + BOOL bmem139; + } Bit2Byte_typ; + +/* structure for the FUB Byte2Bit */ +typedef struct Byte2Bit { + /* non boolean input parameter */ + UDINT byteadr; + UINT length; + /* non boolean output parameter*/ + UDINT bitadr; + /* non boolean static local */ + /* boolean input parameter */ + /* boolean output parameter */ + /* boolean static local */ + BOOL bmem000; + BOOL bmem001; + BOOL bmem002; + BOOL bmem003; + BOOL bmem004; + BOOL bmem005; + BOOL bmem006; + BOOL bmem007; + BOOL bmem008; + BOOL bmem009; + BOOL bmem010; + BOOL bmem011; + BOOL bmem012; + BOOL bmem013; + BOOL bmem014; + BOOL bmem015; + BOOL bmem016; + BOOL bmem017; + BOOL bmem018; + BOOL bmem019; + BOOL bmem020; + BOOL bmem021; + BOOL bmem022; + BOOL bmem023; + BOOL bmem024; + BOOL bmem025; + BOOL bmem026; + BOOL bmem027; + BOOL bmem028; + BOOL bmem029; + BOOL bmem030; + BOOL bmem031; + BOOL bmem032; + BOOL bmem033; + BOOL bmem034; + BOOL bmem035; + BOOL bmem036; + BOOL bmem037; + BOOL bmem038; + BOOL bmem039; + BOOL bmem040; + BOOL bmem041; + BOOL bmem042; + BOOL bmem043; + BOOL bmem044; + BOOL bmem045; + BOOL bmem046; + BOOL bmem047; + BOOL bmem048; + BOOL bmem049; + BOOL bmem050; + BOOL bmem051; + BOOL bmem052; + BOOL bmem053; + BOOL bmem054; + BOOL bmem055; + BOOL bmem056; + BOOL bmem057; + BOOL bmem058; + BOOL bmem059; + BOOL bmem060; + BOOL bmem061; + BOOL bmem062; + BOOL bmem063; + BOOL bmem064; + BOOL bmem065; + BOOL bmem066; + BOOL bmem067; + BOOL bmem068; + BOOL bmem069; + BOOL bmem070; + BOOL bmem071; + BOOL bmem072; + BOOL bmem073; + BOOL bmem074; + BOOL bmem075; + BOOL bmem076; + BOOL bmem077; + BOOL bmem078; + BOOL bmem079; + BOOL bmem080; + BOOL bmem081; + BOOL bmem082; + BOOL bmem083; + BOOL bmem084; + BOOL bmem085; + BOOL bmem086; + BOOL bmem087; + BOOL bmem088; + BOOL bmem089; + BOOL bmem090; + BOOL bmem091; + BOOL bmem092; + BOOL bmem093; + BOOL bmem094; + BOOL bmem095; + BOOL bmem096; + BOOL bmem097; + BOOL bmem098; + BOOL bmem099; + BOOL bmem100; + BOOL bmem101; + BOOL bmem102; + BOOL bmem103; + BOOL bmem104; + BOOL bmem105; + BOOL bmem106; + BOOL bmem107; + BOOL bmem108; + BOOL bmem109; + BOOL bmem110; + BOOL bmem111; + BOOL bmem112; + BOOL bmem113; + BOOL bmem114; + BOOL bmem115; + BOOL bmem116; + BOOL bmem117; + BOOL bmem118; + BOOL bmem119; + BOOL bmem120; + BOOL bmem121; + BOOL bmem122; + BOOL bmem123; + BOOL bmem124; + BOOL bmem125; + BOOL bmem126; + BOOL bmem127; + BOOL bmem128; + BOOL bmem129; + BOOL bmem130; + BOOL bmem131; + BOOL bmem132; + BOOL bmem133; + BOOL bmem134; + BOOL bmem135; + BOOL bmem136; + BOOL bmem137; + BOOL bmem138; + BOOL bmem139; + } Byte2Bit_typ; + +/***************/ +/* Prototyping of functions and function blocks */ +_BUR_PUBLIC UINT PV_ident (char *pv_name_p, USINT pv_tcnr, USINT pv_grpnr, + UDINT *pv_ident); +_BUR_PUBLIC UINT PV_setval (UDINT pv_ident, UDINT value); +_BUR_PUBLIC UINT PV_getval (UDINT pv_ident, UDINT *value); +_BUR_PUBLIC UINT PV_getadr (char *pv_name_p, USINT pv_tcnr, USINT pv_grpnr, + UDINT *pv_adresse); +_BUR_PUBLIC UINT PV_xgetadr (char *pv_name, UDINT *pv_adresse, UDINT *data_len); +_BUR_PUBLIC UINT PV_xsetval (UDINT pv_ident, UINT subindex, void *data_p, + USINT data_len); +_BUR_PUBLIC UINT PV_xgetval (UDINT pv_ident, UINT subindex, void *data_p, + USINT data_len); +_BUR_PUBLIC UINT PV_info (UDINT pv_ident, UDINT *data_type, UDINT *data_len, + UINT *dimension); +_BUR_PUBLIC UINT PV_list (UINT prev_index, UINT *index, PV_List_typ *pvl_p); +_BUR_PUBLIC UINT PV_xlist (UINT prev_index, UINT *index, PV_xList_typ *pvl_p); +_BUR_PUBLIC UINT PV_item (char *pv_name, UINT index, char *itemname); +_BUR_PUBLIC UINT PV_ninfo (char *pv_name, UDINT *data_typ_p, UDINT *data_len_p, + UINT *dimension_p); + + + +_BUR_PUBLIC UINT SYS_info (UDINT *sg_init_cnt, UDINT *sg_initdescr, UDINT *sg_tickcnt, + UDINT *sg_version, UDINT *sg_ov_version); +_BUR_PUBLIC UINT SYSxinfo (SYSxinfo_typ *sx_p); +_BUR_PUBLIC UINT SYSreset (BOOL enable, USINT mode); +_BUR_PUBLIC USINT SYS_battery (void); + +_BUR_PUBLIC UINT MO_list (UINT prev_index, UINT *index, MO_List_typ *mol_p); +_BUR_PUBLIC void MO_info (struct MO_info* pInst); +_BUR_PUBLIC void slMoList (slMoList_typ * pInst); + +_BUR_PUBLIC UINT KEY_enadis (BOOL mode); +_BUR_PUBLIC UINT KEY_read (USINT keys[4]); + +_BUR_PUBLIC UINT FORCE_info (USINT tcnr, BOOL *force); + +_BUR_PUBLIC UINT ST_ident (char *st_name_p, USINT st_grp, UDINT *st_ident); +_BUR_PUBLIC UINT ST_suspend (UDINT st_ident); +_BUR_PUBLIC UINT ST_resume (UDINT st_ident); +_BUR_PUBLIC UINT ST_tmp_suspend (UDINT st_ident); +_BUR_PUBLIC UINT ST_tmp_resume (UDINT st_ident); +_BUR_PUBLIC UINT ST_allsuspend (void); +_BUR_PUBLIC UINT ST_info (UDINT st_ident, USINT *state, SINT *tcnr); +_BUR_PUBLIC UINT ST_name (UDINT st_ident, char *st_name_p, USINT *st_grp); + +_BUR_PUBLIC UINT UT_ident (char *ut_name_p, USINT ut_grp, USINT ut_proc, char *ut_sps_p,UDINT *ut_ident); +_BUR_PUBLIC UINT UT_suspend (UDINT ut_ident); +_BUR_PUBLIC UINT UT_resume (UDINT ut_ident); +_BUR_PUBLIC UINT UT_sleep (UDINT tickcount); +_BUR_PUBLIC UINT UT_sendmsg (UDINT ut_ident, void *msg, UDINT msglng, UDINT flags); +_BUR_PUBLIC UINT UT_recmsg (UDINT *ut_ident, void **msg, UDINT *msglng, UDINT flags); +_BUR_PUBLIC UINT UT_freemsg (UDINT msglng, void *msg); +_BUR_PUBLIC UINT UT_exit (UDINT exitinfo); + + +_BUR_PUBLIC UINT AVT_create (char *name_p, USINT grupid, UDINT av_info, UDINT *av_ident); +_BUR_PUBLIC UINT AVT_cancel (UDINT av_ident); +_BUR_PUBLIC UINT AVT_ident (char *name_p, USINT grupid, UDINT *av_ident); +_BUR_PUBLIC UINT AVT_attach (UDINT av_ident, UDINT *av_info); +_BUR_PUBLIC UINT AVT_release (UDINT av_ident); +_BUR_PUBLIC UINT AVT_info (UDINT av_ident, USINT *av_linkcount); + +_BUR_PUBLIC UINT MEM_alloc (UDINT memlng, void **memptr); +_BUR_PUBLIC UINT MEM_free (UDINT memlng, void *memptr); +_BUR_PUBLIC UINT TMP_alloc (UDINT memlng, void **memptr); +_BUR_PUBLIC UINT TMP_free (UDINT memlng, void *memptr); + +_BUR_PUBLIC UINT RTC_gettime (RTCtime_typ *rtctime); +_BUR_PUBLIC UINT RTC_settime (RTCtime_typ *rtctime); +_BUR_PUBLIC UINT SW_gettime (RTCtime_typ *rtctime); +_BUR_PUBLIC UINT SW_settime (RTCtime_typ *rtctime); +_BUR_PUBLIC UINT TIM_musec (void); +_BUR_PUBLIC UINT TIM_ticks (void); + +_BUR_PUBLIC UINT SM_create (char *sm_name, USINT sm_count, UDINT *sm_ident); +_BUR_PUBLIC UINT SM_ident (char *sm_name, UDINT *sm_ident); +_BUR_PUBLIC UINT SM_delete (UDINT sm_ident); +_BUR_PUBLIC UINT SM_attach (UDINT sm_ident, UDINT timeout, UDINT flags); +_BUR_PUBLIC UINT SM_release (UDINT sm_ident); + +_BUR_PUBLIC UINT ERR_warning (UINT errornr, UDINT errorinfo); +_BUR_PUBLIC UINT ERR_fatal (UINT errornr, UDINT errorinfo); +_BUR_PUBLIC UINT ERR_read (UINT entry_nr, ERR_typ *err_p); +_BUR_PUBLIC UINT ERRxwarning (UINT errornr, UDINT errorinfo, char* errorstring); +_BUR_PUBLIC UINT ERRxread (UINT entry_nr, ERR_xtyp *err_p); +_BUR_PUBLIC UINT ERRxfatal (UINT errornr, UDINT errorinfo, char* errorstring); + +_BUR_PUBLIC UINT DIS_str (UDINT row, UDINT col, char *string); +_BUR_PUBLIC UINT DIS_chr (UDINT row, UDINT col, char character); +_BUR_PUBLIC UINT DIS_clr (void); + +_BUR_PUBLIC UINT DA_create (char *name_p, USINT grp, UINT spooladr, UDINT data_len, + void *data_p, void **mo_data_p, UDINT *mo_ident); +_BUR_PUBLIC UINT DA_write (UDINT mo_ident, void *data_p,UDINT data_len, + UDINT mo_data_offset); +_BUR_PUBLIC UINT DA_read (UDINT mo_ident, void *data_p,UDINT data_len, + UDINT mo_data_offset); +_BUR_PUBLIC UINT DA_ident (char *name_p, USINT grp, UDINT *mo_ident); +_BUR_PUBLIC UINT DA_delete (UDINT mo_ident); +_BUR_PUBLIC UINT DA_burn (UDINT mo_ident); +_BUR_PUBLIC UINT DA_fix (UDINT mo_ident); +_BUR_PUBLIC UINT DA_info (UDINT mo_ident, void **moduldata_adr, UDINT *moduldata_lng, + USINT *memorytype); +_BUR_PUBLIC UINT DA_copy (UDINT mo_ident, char *new_name, USINT mem_typ, UDINT *da_ident, + UDINT *daten_p, UDINT *daten_len); +_BUR_PUBLIC UINT DA_store (UDINT mo_ident, USINT mem_typ, UDINT* daten_p, UDINT* daten_len); + +_BUR_PUBLIC UINT MO_ver (STRING *pName, USINT grp, MoVerStruc_typ* pMoVerStruc); + +_BUR_PUBLIC void Bit2Byte (Bit2Byte_typ* Bit2Byte_ptr); +_BUR_PUBLIC void Byte2Bit (Byte2Bit_typ* Byte2Bit_ptr); + +#ifdef __cplusplus +}; +#endif +#endif /* _SYS_LIB_H_ */ + + diff --git a/Logical/Libraries/sys_lib/binary.lby b/Logical/Libraries/sys_lib/binary.lby new file mode 100644 index 0000000..8360c7b --- /dev/null +++ b/Logical/Libraries/sys_lib/binary.lby @@ -0,0 +1,12 @@ + + + + + sys_lib.fun + sys_lib.typ + sys_lib.var + + + + + \ No newline at end of file diff --git a/Logical/Libraries/sys_lib/sys_lib.fun b/Logical/Libraries/sys_lib/sys_lib.fun new file mode 100644 index 0000000..4111403 --- /dev/null +++ b/Logical/Libraries/sys_lib/sys_lib.fun @@ -0,0 +1,655 @@ + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION_BLOCK Byte2Bit (*converts a byte array into a bit array*) + VAR_INPUT + byteadr :UDINT; (*byte array address*) + length :UINT; (*byte array length (1 through 16)*) + END_VAR + VAR_OUTPUT + bitadr :UDINT; (*bit array address*) + END_VAR + VAR + bmem000 :BOOL; (*internal variable*) + static_val :ARRAY[0..138] OF USINT; (*internal variable*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION_BLOCK Bit2Byte (*converts a bit array into a byte array where every bit of data corresponds to an element in the bit array*) + VAR_INPUT + bitadr :UDINT; (*BIT array address*) + length :UINT; (*BIT array length (1 through 128)*) + END_VAR + VAR_OUTPUT + byteadr :UDINT; (*BYTE array address*) + END_VAR + VAR + byte_00 :USINT; (*internal variable*) + byte_01 :USINT; (*internal variable*) + byte_02 :USINT; (*internal variable*) + byte_03 :USINT; (*internal variable*) + byte_04 :USINT; (*internal variable*) + byte_05 :USINT; (*internal variable*) + byte_06 :USINT; (*internal variable*) + byte_07 :USINT; (*internal variable*) + byte_08 :USINT; (*internal variable*) + byte_09 :USINT; (*internal variable*) + byte_10 :USINT; (*internal variable*) + byte_11 :USINT; (*internal variable*) + byte_12 :USINT; (*internal variable*) + byte_13 :USINT; (*internal variable*) + byte_14 :USINT; (*internal variable*) + byte_15 :USINT; (*internal variable*) + bmem000 :BOOL; (*internal variable*) + static_val :ARRAY[0..138] OF USINT; (*internal variable*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_ERROR} FUNCTION KEY_read : UINT (*reads the status of the keys on the CPU*) + VAR_INPUT + keys :UDINT; (*array variable for storing key states*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION KEY_enadis : UINT (*disables key handling by the operating system (operating mode 0)*) + VAR_INPUT + mode :BOOL; (*operating mode: 0 ... key handling by the operating system, 1 ... key handling by an application program*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION DA_fix : UINT (*transfers a data object to the FIXRAM*) + VAR_INPUT + mo_ident :UDINT; (*ID number from DA_create() or DA_ident()*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION DA_info : UINT (*provides information about the data object*) + VAR_INPUT + mo_ident :UDINT; (*ID number from DA_create() or DA_ident()*) + moduldata_adr :UDINT; (*data address in the data object*) + moduldata_len :UDINT; (*pointer to length of the data (in bytes)*) + memorytype :UDINT; (*pointer to memory type*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION DA_copy : UINT (*copies a data object into the specified memory (RAM, User ROM, MEMCARD or FIXRAM) under the name new_name*) + VAR_INPUT + mo_ident :UDINT; (*ID number from DA_create() or DA_ident()*) + new_name :UDINT; (*pointer to name of the new data object*) + mem_typ :USINT; (*memory type, e.g. 1...RAM, 2...User ROM, ..*) + da_ident :UDINT; (*pointer to ID number of the copied data object*) + daten_p :UDINT; (*data address in the new data object*) + daten_len :UDINT; (*pointer to data length in the new data object (in bytes)*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION DA_store : UINT (*saves a data object in the specified memory (RAM, UserROM, MEMCARD or FIXRAM)*) + VAR_INPUT + mo_ident :UDINT; (*ID number from DA_create() or DA_ident()*) + mem_typ :USINT; (*memory type, e.g. 1...RAM, 2...User ROM, ..*) + daten_p :UDINT; (*data address in the new data object*) + daten_len :UDINT; (*pointer to data length in the new data object (in bytes)*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION DA_burn : UINT (*transfers a data object to UserROM*) + VAR_INPUT + mo_ident :UDINT; (*ID number from DA_create() or DA_ident()*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION DA_delete : UINT (*deletes a data object from the memory (RAM, User ROM, MEMCARD or FIXRAM)*) + VAR_INPUT + mo_ident :UDINT; (*ID number from DA_create() or DA_ident()*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION DA_ident : UINT (*provides the ID number of an existing data object*) + VAR_INPUT + name_p :UDINT; (*pointer to name of the data object*) + grp :USINT; (*group number (standard = 0)*) + mo_ident :UDINT; (*pointer to ID number of the data object*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION DA_read : UINT (*reads data from a module in the RAM or FIXRAM*) + VAR_INPUT + mo_ident :UDINT; (*ID number from DA_create() or DA_ident()*) + data_p :UDINT; (*pointer to data range*) + data_len :UDINT; (*length of the data (in bytes)*) + mo_data_offset :UDINT; (*offset in the data area of the module*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION DA_write : UINT (*writes data to a data object in RAM or FIXRAM*) + VAR_INPUT + mo_ident :UDINT; (*ID number from DA_create() or DA_ident()*) + data_p :UDINT; (*pointer to data range*) + data_len :UDINT; (*length of the data (in bytes)*) + mo_data_offset :UDINT; (*offset in the data area of the module*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION DA_create : UINT (*generates a data object with corresponding parameter in the RAM*) + VAR_INPUT + name_p :UDINT; (*pointer to name of the data object*) + grp :USINT; (*group Number (standard = 0)*) + spooladr :UINT; (*spool address (standard = 0)*) + data_len :UDINT; (*length of the data (in bytes)*) + data_p :UDINT; (*pointer to data which is written in the data object*) + mo_data_p :UDINT; (*data address in the data object*) + mo_ident :UDINT; (*pointer to ID number of the data object*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION DIS_clr : UINT (*clears the CPU status display (B&R 2010 system only)*) + VAR_INPUT + dummy_input :USINT; (*required for operation in ladder diagram*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION DIS_chr : UINT (*writes a ASCII character to the CPU status display*) + VAR_INPUT + row :UDINT; (*row number (0 or 1) where the ASCII character is to be output*) + col :UDINT; (*column number (0 through 7) where the ASCII character is to be output*) + character :SINT; (*ASCII character that is to be output on the status display*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION DIS_str : UINT (*writes a character string to the CPU status display*) + VAR_INPUT + row :UDINT; (*row number (0 or 1) where the string is to be output*) + col :UDINT; (*column number (0 through 7) from where the string is to be output*) + string :UDINT; (*pointer to string (ending in zero) that is to be output on the status display*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION ERRxfatal : UINT (*makes an log book entry in the error log book*) + VAR_INPUT + errornr :UINT; (*error number, which is entered in the error log book*) + errorinfo :UDINT; (*optional additional information (error details)*) + errorstring :UDINT; (*pointer to string, ending in zero (32 characters maximum)*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION ERR_read : UINT (*reads an entry from the error log book and writes the information in a structure (ERR_typ_struct)*) + VAR_INPUT + entry_nr :UINT; (*number of the log book entry that is to be read*) + ERR_typ_struct :UDINT; (*pointer to structure in which information about the log book entry is written*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION ERRxread : UINT (*reads an entry from the error log book and writes the information in a structure (ERR_typ_struct)*) + VAR_INPUT + entry_nr :UINT; (*number of the log book entry that is to be read*) + ERR_xtyp_struct :UDINT; (*pointer to structure in which information about the log book entry is written*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION ERR_fatal : UINT (*makes an entry (log book entry) in the error log book*) + VAR_INPUT + errornr :UINT; (*error number, which is entered in the error log book*) + errorinfo :UDINT; (*optional additional information (error details)*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION ERR_warning : UINT (*makes an entry (log book entry) in the error log book*) + VAR_INPUT + errornr :UINT; (*error number, which is entered in the error log book*) + errorinfo :UDINT; (*optional additional information (error details)*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION ERRxwarning : UINT (*makes an entry (log book entry) in the error log book*) + VAR_INPUT + errornr :UINT; (*error number, which is entered in the error log book*) + errorinfo :UDINT; (*optional additional information (error details)*) + errorstring :UDINT; (*string ending in zero (32 characters maximum)*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION SM_release : UINT (*releases the semaphore with the specified ID number*) + VAR_INPUT + sm_ident :UDINT; (*semaphore ID number from SM_create() or SM_ident()*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION SM_attach : UINT (*requests the use of a semaphore*) + VAR_INPUT + sm_ident :UDINT; (*semaphore ID number from SM_create() or SM_ident()*) + timeout :UDINT; (*timeout time in units of 10 ms (0 = unlimited timeout time)*) + flags :UDINT; (*0 ... wait for timeout time to elapse, 1 ... do not wait for timeout time to elapse*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION SM_delete : UINT (*deletes the semaphore with the specified ID number*) + VAR_INPUT + sm_ident :UDINT; (*semaphore ID number from SM_create() or SM_ident()*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION SM_ident : UINT (*provides the ID number of an existing semaphore*) + VAR_INPUT + sm_name :UDINT; (*pointer to semaphore name*) + sm_ident :UDINT; (*pointer to ID number of the semaphore*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION SM_create : UINT (*generates a semaphore using the specified parameter and provides the ID number of the semaphore*) + VAR_INPUT + sm_name :UDINT; (*semaphore name, given as a string*) + sm_count :USINT; (*number of permitted instances of simultaneous access using the semaphore*) + sm_ident :UDINT; (*ID number of the semaphore*) + END_VAR +END_FUNCTION + +{REDUND_OK} {REDUND_UNREPLICABLE} FUNCTION TIM_ticks : UINT (*provides the number of ticks (1 tick = 10 ms) in the current second*) +(* The dummy_input parameter is obsolete. + VAR_INPUT + dummy_input :USINT; required for operation in ladder diagram + END_VAR *) +END_FUNCTION + +{REDUND_OK} {REDUND_UNREPLICABLE} FUNCTION TIM_musec : UINT (*provides the (approximate) number of microseconds in the current tick (1 tick = 10 ms)*) +(* The dummy_input parameter is obsolete. + VAR_INPUT + dummy_input :USINT; required for operation in ladder diagram + END_VAR *) +END_FUNCTION + +{REDUND_ERROR} FUNCTION SW_settime : UINT (*sets the software clock to the desired time (RTCtime_struct structure)*) + VAR_INPUT + RTCtime_struct :UDINT; (*pointer to the structure which contains the time and date*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION SW_gettime : UINT (*reads the time and date from the software clock and writes this information in a RTCtime_struct structure*) + VAR_INPUT + RTCtime_struct :UDINT; (*pointer to the structure where the time and date are stored*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION RTC_settime : UINT (*sets the real-time clock to the desired time (RTCtime_struct structure)*) + VAR_INPUT + RTCtime_struct :UDINT; (*pointer to the structure which contains the time and date*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION RTC_gettime : UINT (*reads time and date from the real-time clock and writes this information in a RTCtime_struct structure*) + VAR_INPUT + RTCtime_struct :UDINT; (*pointer to the structure where the time and date are stored*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION TMP_free : UINT (*releases a memory area, which has been allocated using TMP_alloc()*) + VAR_INPUT + memlng :UDINT; (*size of the memory area to be released in bytes*) + memptr :UDINT; (*address for the memory area to be released*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION TMP_alloc : UINT (*allocates memory in the temporary memory area (system RAM only)*) + VAR_INPUT + memlng :UDINT; (*size of the allocated memory area in bytes*) + memptr :UDINT; (*pointer to requested memory area*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION MEM_free : UINT (*releases a memory area, which has been allocated using MEM_alloc()*) + VAR_INPUT + memlng :UDINT; (*size of the memory area to be released in bytes*) + memptr :UDINT; (*address for the memory area to be released*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION MEM_alloc : UINT (*allocates memory in the user memory area (user RAM only)*) + VAR_INPUT + memlng :UDINT; (*size of the allocated memory area in bytes*) + memptr :UDINT; (*pointer to requested memory area*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION AVT_info : UINT (*determines how many links there are to the AVT entry with the specified AVT ID number*) + VAR_INPUT + av_ident :UDINT; (*AVT ID number from AVT_create() or AVT_ident()*) + av_linkcount :UDINT; (*link count (number of access to this AVT entry)*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION AVT_release : UINT (*releases the AVT entry with the specified AVT ID number*) + VAR_INPUT + av_ident :UDINT; (*AVT ID number from AVT_create() or AVT_ident()*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION AVT_attach : UINT (*attachs information to an AVT entry*) + VAR_INPUT + av_ident :UDINT; (*AVT ID number from AVT_create() or AVT_ident()*) + av_info :UDINT; (*pointer to AVT info (e.g.: data address)*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION AVT_ident : UINT (*provides the AVT ID number for an existing AVT entry*) + VAR_INPUT + av_name :UDINT; (*pointer to name of AVT entry*) + av_grp :USINT; (*group number (standard = 0)*) + av_ident :UDINT; (*pointer to AVT ident number*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION AVT_cancel : UINT (*deletes the entry with the specified AVT ID number from the AVT*) + VAR_INPUT + av_ident :UDINT; (*AVT ID number from AVT_create() or AVT_ident()*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION AVT_create : UINT (*generates an AVT entry with the specified name and provides an ID number*) + VAR_INPUT + av_name :UDINT; (*pointer to name of AVT entry*) + av_grp :USINT; (*group number (standard = 0)*) + av_info :UDINT; (*AVT info (e.g.: data address)*) + av_ident :UDINT; (*pointer to AVT ident number*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION UT_sleep : UINT (*stops the idle time object for a set period of time*) + VAR_INPUT + tickcount :UDINT; (*number of ticks (1 tick = 10 ms) for which an idle time object is stopped*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION UT_exit : UINT (*exits an idle time object*) + VAR_INPUT + exitinfo :UDINT; (*exit information (standard = 0)*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION UT_freemsg : UINT (*releases the memory which was taken up by a received message*) + VAR_INPUT + msglng :UDINT; (*size of the memory to be released (in bytes)*) + msg :UDINT; (*pointer to memory to be released*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION UT_recmsg : UINT (*receives a message sent using the UT_sendmsg() function*) + VAR_INPUT + ut_ident :UDINT; (*pointer to ID number of the object to which the message was sent*) + msg :UDINT; (*address at which the received message should be saved*) + msglng :UDINT; (*pointer to length of the received data in bytes*) + flags :UDINT; (*Bit 1 = 1: do not wait for UT_sendmsg()*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION UT_sendmsg : UINT (*sends a message to another object (including cyclic objects)*) + VAR_INPUT + ut_ident :UDINT; (*ID number of the object to which the message is to be sent (from UT_ident())*) + msg :UDINT; (*pointer to message to be sent*) + msglng :UDINT; (*length of the message to be sent (in bytes)*) + flags :UDINT; (*Bit 1 = 1: do not wait for UT_recmsg()*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION UT_resume : UINT (*restarts a stopped idle time object*) + VAR_INPUT + ut_ident :UDINT; (*ID number from UT_ident()*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION UT_suspend : UINT (*stops the idle time object with the specified ID number*) + VAR_INPUT + ut_ident :UDINT; (*ID number from UT_ident()*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION UT_ident : UINT (*provides the ID number of an idle time object*) + VAR_INPUT + ut_name :UDINT; (*pointer to name of the idle time object*) + ut_grp :USINT; (*group number (standard = 0)*) + ut_proc :USINT; (*processor number (standard: 0 = current processor)*) + ut_sps_p :UDINT; (*pointer to name of the target system*) + ut_ident :UDINT; (*pointer to ID number of the idle time object*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION ST_name : UINT (*provides the name and group number for the object with the relevant ID number*) + VAR_INPUT + st_ident :UDINT; (*ID number for the object from ST_ident() (0 = the object itself)*) + st_name_p :UDINT; (*pointer to name of the object*) + st_grp :UDINT; (*pointer to group number for the object (standard = 0)*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION ST_info : UINT (*provides information about the object with the relevant ID number*) + VAR_INPUT + st_ident :UDINT; (*ID number for the object from ST_ident() (0 = the object itself)*) + state :UDINT; (*pointer to status of the object: 1 ... Object installed, 2 ... Object running, ..*) + tknr :UDINT; (*pointer to resource information: 1 through 8 ... Cyclic resource, -8 ... Exception resource, ..*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION ST_allsuspend : UINT (*suspends all cyclic software objects*) + VAR_INPUT + dummy_input :USINT; (*required for operation in ladder diagram*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION ST_tmp_resume : UINT (*activates a previously stopped (cyclic) software object*) + VAR_INPUT + st_ident :UDINT; (*ID number for the software object from ST_ident()*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION ST_tmp_suspend : UINT (*suspends a cyclic object temporarily*) + VAR_INPUT + st_ident :UDINT; (*ID number for the object from ST_ident() (0 = object suspends itself)*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION ST_resume : UINT (*activates a previously stopped (cyclic) software object*) + VAR_INPUT + st_ident :UDINT; (*ID number for the software object from ST_ident()*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION ST_suspend : UINT (*suspends a cyclic object permanently*) + VAR_INPUT + st_ident :UDINT; (*ID number for the object from ST_ident()(0 = object suspends itself)*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION ST_ident : UINT (*provides the ID number for a software object*) + VAR_INPUT + st_name :UDINT; (*pointer to name of the software object*) + st_grp :USINT; (*group number for the object (standard = 0)*) + st_ident :UDINT; (*pointer to ID number of the object*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION FORCE_info : UINT (*determines whether or not a variable is forced in the objects of the specified resource (tk_nr)*) + VAR_INPUT + tknr :USINT; (*resource that is to be checked: 1 through 4 ... cyclic resource, -9 ... Interrupt resource, ..*) + force :UDINT; (*given as a pointer: 1 ... force function is active, 0 ... force function is inactive*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION MO_ver : UINT (*reads the version and the date of a B&R module*) + VAR_INPUT + pName :UDINT; (*pointer to name of the B&R module*) + grp :USINT; (*group number for the object (standard = 0)*) + pMoVerStruc :UDINT; (*pointer to the structure where the module version of the located B&R module is stored*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION MO_list : UINT (*browses all the B&R modules on the target system*) + VAR_INPUT + prev_index :UINT; (*index of the B&R module where the search is being started*) + index :UDINT; (*pointer to index of the found B&R module*) + MO_List_struct :UDINT; (*pointer to structure where the module information is stored*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION_BLOCK MO_info (*reads information of a B&R module on the target system*) + VAR_INPUT + enable :BOOL; (*enables execution*) + pName :UDINT; (*pointer to name of the B&R module*) + grp :USINT; (*group number for the object (standard = 0)*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, 0xXXXX = see help*) + type :USINT; (*B&R module type*) + state :USINT; (*B&R module status*) + memType :UDINT; (*memory of the B&R module*) + address :UDINT; (*physical address of the B&R module*) + size :UDINT; (*size of the B&R module*) + version :ARRAY[0..9] OF USINT; (*B&R module version*) + date :RTCtime_typ; (*B&R module date*) + END_VAR +END_FUNCTION_BLOCK + +{REDUND_ERROR} FUNCTION SYS_battery : USINT (*indicates the status of the standard/rechargeable battery in the CPU and the battery in the APM*) + VAR_INPUT + dummy_input :USINT; (*required for operation in ladder diagram*) + END_VAR +END_FUNCTION + +{REDUND_OK} {REDUND_UNREPLICABLE} FUNCTION SYSreset : UINT (*initiates a boot procedure on the target system in the specified mode (WARM or COLD START)*) + VAR_INPUT + enable :BOOL; (*enables execution*) + mode :USINT; (*boot mode: 0x01 .. WARM START (with Restart), 0x02 .. COLD START (with Restart), ..*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION SYSxinfo : UINT (*reads the additional system information and writes this information into a SYSxinfo_struct structure*) + VAR_INPUT + SYSxinfo_struct :UDINT; (*pointer to structure where the additional system information is stored, given as a pointer*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION SYS_info : UINT (*provides information about the system*) + VAR_INPUT + init_count :UDINT; (*pointer to number of previously executed warm restarts*) + init_descr :UDINT; (*pointer to mode of last start-up: 1 ... WARM RESTART, 2 ... COLD RESTART, ..*) + tick_count :UDINT; (*pointer to tick counter*) + version :UDINT; (*pointer to operating system version number*) + ov_version :UDINT; (*pointer to object directory version number*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION PV_xlist : UINT (*browse all the variables*) + VAR_INPUT + prev_index :UINT; (*index of the PV where the search is being started*) + index :UDINT; (*pointer to index of the located PV*) + PV_xList_struct :UDINT; (*pointer to structure which contains PV information about the located PV*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION PV_ninfo : UINT (*reads data from a process variable of a complex data type (array or structure variable)*) + VAR_INPUT + pv_name :UDINT; (*pointer to name of the process variable*) + data_typ_p :UDINT; (*pointer to data type of the PV*) + data_len_p :UDINT; (*pointer to length of the PV in bytes*) + dimension_p :UDINT; (*pointer to number of array or structure elements*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION PV_item : UINT (*determines the names of structure elements*) + VAR_INPUT + pv_name :UDINT; (*pointer to name of the process variable*) + index :UINT; (*structure element index*) + itemname :UDINT; (*pointer to name of the structure element*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION PV_ident : UINT (*provides the ID number of a process variable (PV)*) + VAR_INPUT + pv_name :UDINT; (*pointer to name of the process variable*) + pv_tknr :USINT; (*process variable resource*) + pv_grp :USINT; (*group number *) + pv_ident :UDINT; (*pointer to PV ID number*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION PV_list : UINT (*browses all variables*) + VAR_INPUT + prev_index :UINT; (*index of the PV where the search is being started*) + index :UDINT; (*pointer to index of the located PV*) + PVList_struct :UDINT; (*pointer to structure which contains PV information about the located PV*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION PV_info : UINT (*reads data from a process variable of a complex data type (array or structure variable)*) + VAR_INPUT + pv_ident :UDINT; (*ID number of the process variable from PV_ident()*) + data_typ :UDINT; (*pointer to data type of the PV*) + data_len :UDINT; (*pointer to length of the PV in bytes*) + dimension :UDINT; (*pointer to number of array or structure elements*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION PV_xgetval : UINT (*reads data from a process variable of a complex data type (array or structure variable)*) + VAR_INPUT + pv_ident :UDINT; (*ID number of the process variable from PV_ident()*) + subindex :UINT; (*element index: 0 ... Entire array/structure, 1 ... 1st element of the array/structure, ..*) + data_p :UDINT; (*pointer to data read*) + data_len :USINT; (*length of the data to be read in bytes*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION PV_xsetval : UINT (*sets a particular value for a process variable of a complex data type (array variable or structure variable)*) + VAR_INPUT + pv_ident :UDINT; (*ID number of the process variable from PV_ident()*) + subindex :UINT; (*element index: 0 ... Entire array/structure, 1 ... 1st element of the array/structure, ..*) + data_p :UDINT; (*pointer to data assigned to the PV*) + data_len :USINT; (*length of the data in bytes*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION PV_xgetadr : UINT (*provides the address and length of a variable*) + VAR_INPUT + pv_name_p :UDINT; (*pointer to name of the process variable*) + pv_adresse :UDINT; (*PV address for dynamic access*) + data_len :UDINT; (*pointer to length of the process variable in bytes*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION PV_getadr : UINT (*provides the address of a process variable*) + VAR_INPUT + pv_name_p :UDINT; (*pointer to name of the process variable*) + pv_tknr :USINT; (*process variable resource: 1 ... Cyclic #1, timer #1-4, 2 ... Cyclic resource cyclic #2, ..*) + pv_grpnr :USINT; (*group number (standard = 0)*) + pv_adresse :UDINT; (*PV address for dynamic access*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION PV_getval : UINT (*reads the value of a process variable*) + VAR_INPUT + pv_ident :UDINT; (*ID number of the process variable from PV_ident()*) + value :UDINT; (*pointer to determined value of the PV*) + END_VAR +END_FUNCTION + +{REDUND_ERROR} FUNCTION PV_setval : UINT (*sets a particular value for a process variable*) + VAR_INPUT + pv_ident :UDINT; (*ID number of the process variable from PV_ident()*) + value :UDINT; (*value assigned to the PV*) + END_VAR +END_FUNCTION + +{REDUND_CONTEXT} {REDUND_UNREPLICABLE} FUNCTION_BLOCK slMoList (*browses the B&R modules on the target system*) + VAR_INPUT + enable :BOOL; (*enables execution*) + first :BOOL; (*starting point for browsing*) + filter :BOOL; (*filter for browsing in own application module*) + pMoName :UDINT; (*name of the B&R module given as a pointer*) + sizeMoName :UDINT; (*length of the string (pMoName) -> ideally, sizeMoName = 11*) + pAppMoName :UDINT; (*name of the application module given as a pointer*) + sizeAppMoName :UDINT; (*length of the string (pAppMoName) -> ideally, sizeAppMoName = 21*) + END_VAR + VAR_OUTPUT + status :UINT; (*execution status: ERR_OK, ERR_FUB_ENABLE_FALSE, 0xXXXX = see help*) + moSize :UDINT; (*size of the B&R module*) + moType :USINT; (*type of the B&R module*) + memType :USINT; (*memory type of the B&R module*) + END_VAR + VAR + i_hMo :UDINT; (*internal variable*) + END_VAR +END_FUNCTION_BLOCK diff --git a/Logical/Libraries/sys_lib/sys_lib.typ b/Logical/Libraries/sys_lib/sys_lib.typ new file mode 100644 index 0000000..7dc0ff1 --- /dev/null +++ b/Logical/Libraries/sys_lib/sys_lib.typ @@ -0,0 +1,90 @@ + +TYPE + MoVerStruc_typ : STRUCT + version : ARRAY[0..9] OF USINT ; + year : UINT ; + month : USINT ; + day : USINT ; + reserve : USINT ; + hour : USINT ; + minute : USINT ; + second : USINT ; + END_STRUCT; + ERR_xtyp : STRUCT + err_nr : UINT ; + err_info : UDINT ; + t_name : ARRAY[0..4] OF SINT ; + err_type : USINT ; + err_year : UINT ; + err_month : USINT ; + err_day : USINT ; + err_reserve : USINT ; + err_hour : USINT ; + err_minute : USINT ; + err_second : USINT ; + err_millisec : UINT ; + err_microsec : UINT ; + err_string : ARRAY[0..33] OF USINT ; + END_STRUCT; + ERR_typ : STRUCT + err_nr : UINT ; + err_info : UDINT ; + t_name : ARRAY[0..4] OF SINT ; + err_type : USINT ; + err_year : UINT ; + err_month : USINT ; + err_day : USINT ; + err_reserve : USINT ; + err_hour : USINT ; + err_minute : USINT ; + err_second : USINT ; + err_millisec : UINT ; + err_microsec : UINT ; + END_STRUCT; + PV_xList_typ : STRUCT + name : ARRAY[0..32] OF SINT ; (*name of the process variable*) + data_typ : USINT ; (*PV data type (see PV_info())*) + data_len : UDINT ; (*length of the PV in bytes*) + dimension : UDINT ; (*number of array elements*) + adress : UDINT ; (*physical address of the PV (for dynamic access)*) + END_STRUCT; + PV_List_typ : STRUCT + name : ARRAY[0..13] OF SINT ; (*name of the PV*) + tcnr : USINT ; (*PV resource*) + grp : USINT ; (*group number of the PV (standard = 0)*) + ident : UDINT ; (*PV ID number*) + adress : UDINT ; (*physical address of the PV (for dynamic access)*) + END_STRUCT; + MO_List_typ : STRUCT + name : ARRAY[0..13] OF SINT ; + grp : USINT ; + type : USINT ; + state : USINT ; + reserve : USINT ; + adress : UDINT ; + memtype : UDINT ; + END_STRUCT; + SYSxinfo_typ : STRUCT + aws_name : ARRAY[0..5] OF SINT ; + aws_type : ARRAY[0..1] OF SINT ; + cpu_info : UDINT ; + ma_globl_len : UINT ; + md_globl_len : UINT ; + os_len : UDINT ; + user_len : UDINT ; + tmp_len : UDINT ; + eprom_len : UDINT ; + fix_ram_len : UDINT ; + END_STRUCT; + RTCtime_typ : STRUCT + year : UINT ; + month : USINT ; + day : USINT ; + reserve : USINT ; + hour : USINT ; + minute : USINT ; + second : USINT ; + millisec : UINT ; + microsec : UINT ; + END_STRUCT; +END_TYPE diff --git a/Logical/Libraries/sys_lib/sys_lib.var b/Logical/Libraries/sys_lib/sys_lib.var new file mode 100644 index 0000000..625d11b --- /dev/null +++ b/Logical/Libraries/sys_lib/sys_lib.var @@ -0,0 +1,131 @@ + +(*error codes of the SYS_LIB services*) +VAR CONSTANT + ERR_BUR_WRROW : UINT := 2061; (*illegal row*) + ERR_BUR_WRCOL : UINT := 2062; (*illegal column*) + ERR_BUR_WR_CHAR : UINT := 2063; (*invalid ASCII character*) + ERR_BUR_NORTC : UINT := 2073; (*RTC not existing or uninitialized*) + + ERR_BUR_MO_NOTFOUND : UINT := 3019; (*module not found*) + ERR_BUR_NOMEM : UINT := 3030; (*out of memory*) + ERR_BUR_MEMVWBUSY : UINT := 3035; (*memory management busy*) + ERR_BUR_ILLPTR : UINT := 3104; (*illegal data pointer in MEM_free*) + + ERR_BUR_ILLTKNR : UINT := 3300; (*illegal task-class number*) + ERR_BUR_WROFFSET : UINT := 3301; (*illegal offset*) + ERR_BUR_ILLSTATE : UINT := 3302; (*illegal state of object*) + ERR_BUR_NOMSG : UINT := 3303; (*no message sent/received*) + ERR_BUR_DUPOBJ : UINT := 3305; (*object exists*) + ERR_BUR_TIMEOUT : UINT := 3304; (*timeout error*) + ERR_BUR_EXISTS : UINT := 3306; (*entry exists*) + ERR_BUR_LCOUNT : UINT := 3307; (*Linkcnt <> 0 in AVT_cancel ()*) + ERR_BUR_BURNING : UINT := 3308; (*error burning module*) + ERR_BUR_INVALIDMBX : UINT := 3309; (*invalid mailbox*) + + ERR_BUR_ILLBPTR : UINT := 3310; (*invalid base pointer*) + ERR_BUR_ILLTYP : UINT := 3311; (*invalid I/O type*) + ERR_BUR_ILLEXT : UINT := 3312; (*invalid ext. bit*) + ERR_BUR_ILLVER : UINT := 3313; (*invalid version, e.g. BURTRAP V1.10 to SPSSW V1.05*) + ERR_BUR_ILLLEN : UINT := 3314; (*invalid data length*) + ERR_BUR_MAX_LCOUNT : UINT := 3315; (*AVT_attach: LCOUNT > 127*) + ERR_BUR_AVT_FREE : UINT := 3316; (*AVT_release:LCOUNT = 0*) + ERR_BUR_ILLPAR : UINT := 3317; (*illegal parameter*) + ERR_BUR_INSTALL : UINT := 3318; (*error install datamodule*) + ERR_BUR_WRONG_MODTYP : UINT := 3319; (*wrong module type*) + + ERR_BUR_OBJDEL : UINT := 3320; (*object already deleted*) + ERR_BUR_ILLOBJ : UINT := 3324; (*object does not exist*) + ERR_BUR_ILLOBJTYP : UINT := 3328; (*invalid object type*) + ERR_BUR_NOENTRY : UINT := 3332; (*no entry*) + ERR_BUR_TOOLONG_PVNAME : UINT := 3333; (*too long PV name*) + ERR_BUR_ILLIDENT : UINT := 3336; (*illegal ident*) + ERR_BUR_NOSMBUF : UINT := 3560; (*no more semaphore buffers*) + ERR_BUR_NOSM : UINT := 3564; (*semaphore not available*) + ERR_BUR_SMDEL : UINT := 3568; (*semaphore deleted*) + ERR_BUR_NOTIME : UINT := 3584; (*time not available*) + ERR_BUR_ILLDATE : UINT := 3588; (*date : out of range*) + ERR_BUR_ILLTIME : UINT := 3592; (*time : out of range*) + ERR_BUR_ILLTICKS : UINT := 3596; (*ticks : out of range*) + + ERR_BUR_MEM_ALLOC : UINT := 3600; (*not enough continuous memory*) + ERR_BUR_TMP_ALLOC : UINT := 3601; (*not enough continuous memory*) + ERR_BUR_MEM_FREE : UINT := 3700; (*invalid pointer/length*) + ERR_BUR_TMP_FREE : UINT := 3701; (*invalid pointer/length*) + END_VAR + +(*state for object PLC task*) +VAR CONSTANT + Z_ST_created : UINT := 1; (*object installed*) + Z_ST_running : UINT := 2; (*object running*) + Z_ST_blocked : UINT := 3; (*object stopped*) + Z_ST_exist : UINT := 16#00; (*object exists*) + Z_ST_installed : UINT := 16#82; (*temporary status during installation*) + Z_ST_PVinstalled : UINT := 16#83; (*temporary status during installation*) + Z_ST_IOinstalled : UINT := 16#84; (*temporary status during installation*) + Z_ST_IOdeinstalled : UINT := 16#85; (*temporary status during installation*) + Z_ST_PVdeinstalled : UINT := 16#86; (*temporary status during installation*) + Z_ST_delete : UINT := 16#87; (*temporary status during installation*) + Z_ST_stdebug : UINT := 16#88; (*temporary status during installation*) + Z_ST_tmp_suspended : UINT := 16#90; (*object temporarily stopped*) +END_VAR + +(*OBSOLETE PV data types*) +VAR CONSTANT + PB_DT_STRUCT : UINT := 0; (*OBSOLETE*) + PB_DT_BOOL : UINT := 1; (*OBSOLETE*) + PB_DT_INT8 : UINT := 2; (*OBSOLETE*) + PB_DT_INT16 : UINT := 3; (*OBSOLETE*) + PB_DT_INT32 : UINT := 4; (*OBSOLETE*) + PB_DT_BYTE : UINT := 5; (*OBSOLETE*) + PB_DT_WORD : UINT := 6; (*OBSOLETE*) + PB_DT_LONG : UINT := 7; (*OBSOLETE*) + PB_DT_FLOAT : UINT := 8; (*OBSOLETE*) + PB_DT_VIS : UINT := 9; (*OBSOLETE*) + PB_DT_OCTET : UINT := 10; (*OBSOLETE*) + PB_DT_DATE : UINT := 11; (*OBSOLETE*) + PB_DT_TIME : UINT := 12; (*OBSOLETE*) + PB_DT_DIFF : UINT := 13; (*OBSOLETE*) + PB_DT_BIT : UINT := 14; (*OBSOLETE*) + PB_DT_ARRAY : UINT := 15; (*OBSOLETE*) +END_VAR + +(*elementary data types*) +VAR CONSTANT + SYSLIB_IEC_TYPE_USER_DEFINED : USINT := 0; (*User-defined data type*) + SYSLIB_IEC_TYPE_USER_DEFINED_2 : USINT := 15; (*User-defined data type (legacy: array of structs)*) + SYSLIB_IEC_TYPE_BOOL : USINT := 1; (*8 Bit containing a boolean value FALSE=0 or TRUE=1*) + SYSLIB_IEC_TYPE_SINT : USINT := 2; (*8 Bit signed integer*) + SYSLIB_IEC_TYPE_INT : USINT := 3; (*16 Bit signed integer*) + SYSLIB_IEC_TYPE_DINT : USINT := 4; (*32 Bit signed integer*) + SYSLIB_IEC_TYPE_USINT : USINT := 5; (*8 Bit unsigned integer*) + SYSLIB_IEC_TYPE_UINT : USINT := 6; (*16 Bit unsigned integer*) + SYSLIB_IEC_TYPE_UDINT : USINT := 7; (*32 Bit unsigned integer*) + SYSLIB_IEC_TYPE_REAL : USINT := 8; (*32 Bit floating point number*) + SYSLIB_IEC_TYPE_STRING : USINT := 9; (*Variable-length single-byte character string*) + SYSLIB_IEC_TYPE_DATE_AND_TIME : USINT := 11; (*32 Bit of Date in Seconds since 01.01.1970 00:00:00*) + SYSLIB_IEC_TYPE_TIME : USINT := 12; (*32 Bit of Time in ms*) + SYSLIB_IEC_TYPE_DATE : USINT := 13; (*32 Bit of Date (only)*) + SYSLIB_IEC_TYPE_LREAL : USINT := 14; (*64 Bit floating point number*) + SYSLIB_IEC_TYPE_TIME_OF_DAY : USINT := 16; (*32 Bit Time of day (only)*) + SYSLIB_IEC_TYPE_BYTE : USINT := 17; (*Bit string of length 8*) + SYSLIB_IEC_TYPE_WORD : USINT := 18; (*Bit string of length 16*) + SYSLIB_IEC_TYPE_DWORD : USINT := 19; (*Bit string of length 32*) + SYSLIB_IEC_TYPE_WSTRING : USINT := 21; (*Variable-length double-byte character string*) +END_VAR + +(*memory types*) +VAR CONSTANT + SYS_RAM : UINT := 1; (*RAM*) + USER_ROM1 : UINT := 2; (*EPROM*) + FIX_RAM : UINT := 5; (*fixed RAM*) +END_VAR + +(*shutdown/reboot types*) +VAR CONSTANT + SYSLIB_WARMSTART : USINT := 16#01; (*WARMSTART (with restart)*) + SYSLIB_COLDSTART : USINT := 16#02; (*COLDSTART (with restart)*) + SYSLIB_WARMSTART_NO_REBOOT : USINT := 16#11; (*WARMSTART (no restart, only shutdown)*) + SYSLIB_COLDSTART_NO_REBOOT : USINT := 16#12; (*COLDSTART (no restart, only shutdown)*) + SYSLIB_DIAGNOSTICS : USINT := 16#20; (*DIAGNOSTICS (with restart)*) + SYSLIB_SERVICE : USINT := 16#40; (*SERVICE (with restart) *) +END_VAR \ No newline at end of file diff --git a/Logical/Machine/ConMon/Main.st b/Logical/Machine/ConMon/Main.st index 77a522a..8857ae0 100644 --- a/Logical/Machine/ConMon/Main.st +++ b/Logical/Machine/ConMon/Main.st @@ -10,6 +10,9 @@ PROGRAM _INIT Status.enAirCom := enAIR_INIT; + + FUBs.LCRMovAvgFlt_pDiff.enable := TRUE; + FUBs.LCRMovAvgFlt_pDiff.base := 3000; END_PROGRAM @@ -58,10 +61,16 @@ PROGRAM _CYCLIC Environment.rHumidity1 := INT_TO_REAL (AirValues.iHumidity1) * 0.1; Environment.rHumidity2 := INT_TO_REAL (AirValues.iHumidity2) * 0.1; Environment.rAirPreasure := INT_TO_REAL (AirValues.iBaroPreassure); //Barometrischen Luftdruck verwenden - Environment.rDiffPreassure := - INT_TO_REAL (AirValues.iDiffPreassure) * 0.1; + rDiffpressureRaw := - INT_TO_REAL (AirValues.iDiffPreassure) * 0.3; // Wert * 3 + Environment.rDiffPreassure := rDiffpressureFlitered; gLogValue := Environment; END_IF END_CASE; + FUBs.LCRMovAvgFlt_pDiff.x := rDiffpressureRaw; + FUBs.LCRMovAvgFlt_pDiff (); + IF (FUBs.LCRMovAvgFlt_pDiff.status = ERR_OK) THEN + rDiffpressureFlitered := FUBs.LCRMovAvgFlt_pDiff.y; + END_IF //=================================== diff --git a/Logical/Machine/ConMon/Types.typ b/Logical/Machine/ConMon/Types.typ index 98307b2..6cdef52 100644 --- a/Logical/Machine/ConMon/Types.typ +++ b/Logical/Machine/ConMon/Types.typ @@ -18,6 +18,7 @@ TYPE TONParticleOK : TON; TOFParticleOk : TOF; TOFShowHidenMenu : TOF; + LCRMovAvgFlt_pDiff : LCRMovAvgFlt; END_STRUCT; typ_enAirComm : ( (*Schrittkette*) diff --git a/Logical/Machine/ConMon/Variables.var b/Logical/Machine/ConMon/Variables.var index 589c02c..ead56aa 100644 --- a/Logical/Machine/ConMon/Variables.var +++ b/Logical/Machine/ConMon/Variables.var @@ -1,6 +1,8 @@ VAR blTempOk : BOOL; blTempNOk : BOOL; + rDiffpressureRaw : REAL; + rDiffpressureFlitered : REAL; Status : typ_Status; (*Status*) Environment : gtyp_Environment; (*Umgebungsvariablen*) AirValues : typ_AirValues; (*Werte von Klimaanlage*) diff --git a/Physical/Config2/X20CP0483/Cpu.sw b/Physical/Config2/X20CP0483/Cpu.sw index f32763b..fde35c5 100644 --- a/Physical/Config2/X20CP0483/Cpu.sw +++ b/Physical/Config2/X20CP0483/Cpu.sw @@ -79,5 +79,8 @@ + + + \ No newline at end of file diff --git a/admin.set b/admin.set new file mode 100644 index 0000000..4be53a5 --- /dev/null +++ b/admin.set @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file