2531 lines
99 KiB
C++
2531 lines
99 KiB
C++
#pragma once
|
||
|
||
#ifdef BUILD_TARGET_SOM
|
||
|
||
#if defined(_WIN32)
|
||
#define BINDER_SIMULINK_API_EXPORT __declspec(dllexport)
|
||
#else
|
||
#define BINDER_SIMULINK_API_EXPORT __attribute__((visibility("default")))
|
||
#endif
|
||
#include "algorithm/ControllerBase.hpp"
|
||
#include "asio/SignalConnection.hpp"
|
||
|
||
#endif
|
||
|
||
#include <algorithm>
|
||
#include <array>
|
||
#include <cmath>
|
||
#include <cstdint>
|
||
#include <limits>
|
||
#include <memory>
|
||
#include <vector>
|
||
|
||
const double PI_CONST = 3.14159265358979323846;
|
||
|
||
#define MAX std::max
|
||
#define MIN std::min
|
||
|
||
namespace UTILITY_FUNCTIONS {
|
||
|
||
inline double limit(double x, double lo, double hi) {
|
||
return (x < lo) ? lo : (x > hi) ? hi : x;
|
||
}
|
||
|
||
inline double max3(double a, double b, double c) {
|
||
return std::max(a, std::max(b, c));
|
||
}
|
||
inline double min3(double a, double b, double c) {
|
||
return std::min(a, std::min(b, c));
|
||
}
|
||
|
||
inline bool is_valid(double x) { return std::isfinite(x); }
|
||
|
||
// ST: REAL_TO_INT(x) i.d.R. trunc Richtung 0. Bei Siemens oft ROUND? Du nutzt
|
||
// häufig +0.5.
|
||
inline int real_to_int(double x) { return static_cast<int>(x); }
|
||
|
||
// Platzhalter für GET_VALUE_* (kommt vermutlich aus Parameter-/Recipe-System)
|
||
inline std::int32_t GET_VALUE_DINT(int /*a*/, int /*b*/, int /*c*/, int /*d*/) {
|
||
// TODO: an dein Parameter-System anbinden
|
||
return 0;
|
||
}
|
||
inline double GET_VALUE_REAL(int /*a*/, int /*b*/, int /*c*/, int /*d*/) {
|
||
// TODO: an dein Parameter-System anbinden
|
||
return 0.0;
|
||
}
|
||
|
||
} // namespace UTILITY_FUNCTIONS
|
||
|
||
// -------------------------
|
||
// Regelkern (ST -> C++)
|
||
// -------------------------
|
||
|
||
class PWM {
|
||
public:
|
||
PWM(double zyklus_min, double zyklus_max, double initial_zykluszeit = -1.0) {
|
||
Zykluszeit = 0.0;
|
||
Ausgabe = 0.0;
|
||
Zyklus_MAX = zyklus_max;
|
||
Zyklus_MIN = zyklus_min;
|
||
}
|
||
/*(* Puls Pause Generierung Kühlung *)
|
||
Zyklus_Kuehlventil := Zyklus_Kuehlventil + sampling_time;
|
||
|
||
IF Ausgabe_Kuehlventil > 0.0 THEN
|
||
Kuehlventil := NOT Status_Untertemperatur;
|
||
Ausgabe_Kuehlventil := Ausgabe_Kuehlventil - sampling_time;
|
||
IF Ausgabe_Kuehlventil < 0.0 THEN
|
||
Zykluszeit_Kuehlventil := Zykluszeit_Kuehlventil -
|
||
Ausgabe_Kuehlventil * 100.0 / MAX(Stellgrad_Kuehlventil, sampling_time /
|
||
Zykluszeit_Kuehlventil_MAX * 100.0); Ausgabe_Kuehlventil := 0.0; END_IF; ELSE
|
||
Kuehlventil := FALSE;
|
||
END_IF;
|
||
|
||
IF Stellgrad_Kuehlventil > sampling_time / Zykluszeit_Kuehlventil_MAX * 100.0
|
||
THEN IF Zyklus_Kuehlventil >= Zykluszeit_Kuehlventil OR Zyklus_Kuehlventil >=
|
||
MAX(2.0 * Zykluszeit_Kuehlventil_MIN, sampling_time * 100.0 /
|
||
Stellgrad_Kuehlventil) THEN Ausgabe_Kuehlventil := MIN(Ausgabe_Kuehlventil +
|
||
Stellgrad_Kuehlventil / 100.0 * Zykluszeit_Kuehlventil_MIN,
|
||
Zykluszeit_Kuehlventil); Zykluszeit_Kuehlventil := Zykluszeit_Kuehlventil_MIN;
|
||
Zyklus_Kuehlventil := 0.0;
|
||
END_IF;
|
||
END_IF;*/
|
||
|
||
bool step(double Stellgrad, double samplingTime) {
|
||
Zyklus += samplingTime;
|
||
bool output_bool;
|
||
if (Ausgabe > 0.0) {
|
||
output_bool = true;
|
||
Ausgabe -= samplingTime;
|
||
if (Ausgabe < 0.0) {
|
||
Zykluszeit -=
|
||
Ausgabe * 100 / MAX(Stellgrad, samplingTime / Zyklus_MAX * 100.0);
|
||
Ausgabe = 0.0;
|
||
}
|
||
|
||
} else {
|
||
output_bool = false;
|
||
}
|
||
if (Stellgrad > samplingTime / Zyklus_MAX * 100.0) {
|
||
if (Zyklus >= Zykluszeit ||
|
||
Zyklus >= MAX(2.0 * Zyklus_MIN, samplingTime * 100.0 / Stellgrad)) {
|
||
Ausgabe = MIN(Ausgabe + Stellgrad / 100.0 * Zyklus_MIN, Zyklus);
|
||
Zykluszeit = Zyklus_MIN;
|
||
Zyklus = 0.0;
|
||
}
|
||
}
|
||
return output_bool;
|
||
}
|
||
|
||
private:
|
||
double Zyklus = 0.0;
|
||
double Ausgabe = 0.0;
|
||
double Zykluszeit = 0.0;
|
||
double Zyklus_MAX = 0.0;
|
||
double Zyklus_MIN = 0.0;
|
||
};
|
||
|
||
class ClimateAlgorithm {
|
||
public:
|
||
struct BinInputs {
|
||
// Eingangswerte aus bool_inXX / real_inXX / reset_flag
|
||
bool reset_flag{};
|
||
bool Sammelalarm_quittiert{};
|
||
bool Tuer_offen{};
|
||
bool Sollwert_Feuchte_aktiv{};
|
||
bool Steuerkontakt_Standby{};
|
||
bool Steuerkontakt_Befeuchtung_aus{};
|
||
bool Steuerkontakt_Entfeuchtung_aus{};
|
||
bool Entleerbehaelter_Oben{};
|
||
bool Wasserkanister_leer{};
|
||
bool Entleerbehaelter_Unten{};
|
||
bool Sammelalarm{};
|
||
} binInput;
|
||
|
||
struct AnalogInputs {
|
||
double Istwert_Temperatur{};
|
||
double Sollwert_Temperatur{};
|
||
double Temperaturband{};
|
||
double Istwert_Ueberwachungsregler{};
|
||
double Klasse_Ueberwachungsregler{};
|
||
double Grenzwert_Untertemperatur{};
|
||
double Istwert_Feuchte{};
|
||
double Sollwert_Feuchte{};
|
||
double Feuchteband{};
|
||
double Sollwert_Luefter{};
|
||
double Istwert_Temperatur_Tuer{};
|
||
double Istwert_Temperatur_Verdampferausgang{};
|
||
double Temperatur_Feuchtemodul{};
|
||
double Bandalarm_nach{};
|
||
double Betauungsschutz{};
|
||
double real_in11{}; // du nutzt real_in11 später direkt in alarm_15
|
||
} analogInput;
|
||
|
||
struct BinOutputs {
|
||
// bool_outXX
|
||
bool bool_out01{};
|
||
bool bool_out02{};
|
||
bool bool_out03{};
|
||
bool bool_out07{};
|
||
bool bool_out09{};
|
||
bool bool_out11{};
|
||
bool bool_out12{};
|
||
bool bool_out13{};
|
||
bool bool_out14{};
|
||
bool bool_out16{};
|
||
bool bool_out17{};
|
||
bool bool_out18{};
|
||
bool bool_out19{};
|
||
bool bool_out20{};
|
||
bool bool_out21{};
|
||
bool bool_out23{};
|
||
} binOut;
|
||
|
||
struct AnalogOutputs {
|
||
// real_outXX (nur die, die du im ST setzt)
|
||
double real_out01{};
|
||
double real_out02{};
|
||
double real_out04{};
|
||
double real_out05{};
|
||
double real_out06{};
|
||
double real_out07{};
|
||
double real_out08{};
|
||
double real_out09{};
|
||
double real_out10{};
|
||
double real_out11{};
|
||
double real_out12{};
|
||
double real_out13{};
|
||
double real_out14{};
|
||
double real_out16{};
|
||
double Stellgrad_Feuchtemodul{}; // ...out17
|
||
double real_out18{};
|
||
double real_out19{};
|
||
double real_out20{};
|
||
double real_out21{};
|
||
double real_out25{};
|
||
double real_out26{};
|
||
double Stellgrad_Heizung{};
|
||
double Stellgrad_Kuehlung{};
|
||
double Stellgrad_Befeuchtung{};
|
||
double Stellgrad_Entfeuchtung{};
|
||
double Counter_Tuer{};
|
||
} analogOut;
|
||
|
||
struct Alarm {
|
||
// alarm_01..alarm_15
|
||
bool Startup{};
|
||
bool alarm_01{};
|
||
bool alarm_02{};
|
||
bool alarm_03{};
|
||
bool alarm_04{};
|
||
bool alarm_05{};
|
||
bool alarm_06{};
|
||
bool alarm_07{};
|
||
bool alarm_08{};
|
||
bool alarm_09{};
|
||
bool alarm_10{};
|
||
bool alarm_11{};
|
||
bool alarm_12{};
|
||
bool alarm_13{};
|
||
bool alarm_14{};
|
||
bool alarm_15{};
|
||
} alarmOut;
|
||
|
||
ClimateAlgorithm() = default;
|
||
|
||
void Step(void) {
|
||
using UTILITY_FUNCTIONS::is_valid;
|
||
using UTILITY_FUNCTIONS::limit;
|
||
|
||
// ---------------------------
|
||
// Eingangswerte (ST Zuweisungen)
|
||
// ---------------------------
|
||
Sammelalarm_quittiert = binInput.Sammelalarm_quittiert;
|
||
Tuer_offen = binInput.Tuer_offen;
|
||
Sollwert_Feuchte_aktiv = true;
|
||
Steuerkontakt_Standby = false;
|
||
Steuerkontakt_Befeuchtung_aus = false;
|
||
Steuerkontakt_Entfeuchtung_aus = false;
|
||
Entleerbehaelter_Oben = binInput.Entleerbehaelter_Oben;
|
||
bool Wasserkanister_leer = false;
|
||
Entleerbehaelter_Unten = binInput.Entleerbehaelter_Unten;
|
||
Sammelalarm = false;
|
||
Istwert_Temperatur = analogInput.Istwert_Temperatur;
|
||
Istwert_Ueberwachungsregler = Istwert_Temperatur;
|
||
Sollwert_Temperatur = analogInput.Sollwert_Temperatur;
|
||
Istwert_Feuchte = analogInput.Istwert_Feuchte;
|
||
Sollwert_Feuchte = analogInput.Sollwert_Feuchte;
|
||
// uj - not needed double Sollwert_Luefter = analogInput.Sollwert_Luefter;
|
||
Istwert_Temperatur_Tuer = analogInput.Istwert_Temperatur_Tuer;
|
||
double Istwert_Temperatur_Verdampferausgang = analogInput.Istwert_Temperatur_Verdampferausgang;
|
||
Temperatur_Feuchtemodul = analogInput.Temperatur_Feuchtemodul;
|
||
double Betauungsschutz = 50.0;
|
||
double Feuchteband = 10;
|
||
double Temperaturband = 5;
|
||
bool reset_flag = binInput.reset_flag;
|
||
|
||
// Zähler reset_flag
|
||
// -----------------
|
||
if (reset_flag) {
|
||
Counter_reset_flag = 0;
|
||
} else {
|
||
Counter_reset_flag += 1;
|
||
}
|
||
Startup_finished =
|
||
(Counter_reset_flag > static_cast<std::uint32_t>(10 * 4));
|
||
|
||
// ------------------------------------------
|
||
// Verzögerte Abschaltung Regelung bei Türöffnung
|
||
// ------------------------------------------
|
||
// f_PostDoorOpeningCutOffDelaed(...)
|
||
if (Tuer_offen || Steuerkontakt_Standby) {
|
||
Counter_Regelung_AUS += sampling_time;
|
||
} else {
|
||
Counter_Regelung_AUS = 0.0;
|
||
}
|
||
Regelung_AUS = (Counter_Regelung_AUS > 60.0);
|
||
|
||
// -------------------
|
||
// Nachlauf Türöffnung
|
||
// -------------------
|
||
// f_PostDoorOpening(..)
|
||
if (!Startup_finished) {
|
||
Counter_Tuer_offen = 0.0;
|
||
Counter_Tuer_geschlossen = 600.0;
|
||
} else if (Tuer_offen) {
|
||
Counter_Tuer_offen += sampling_time;
|
||
Counter_Tuer_geschlossen = 0.0;
|
||
} else {
|
||
Counter_Tuer_offen = 0.0;
|
||
Counter_Tuer_geschlossen += sampling_time;
|
||
}
|
||
|
||
Sollwert_Temperatur_MIN = -5.0;
|
||
Sollwert_Temperatur_MAX = 100.0;
|
||
|
||
// ------------------------------------------
|
||
// Sollwert Feuchte (Limit-Kennfeld)
|
||
// ------------------------------------------
|
||
// f_HumiditySetValueByVector(...)
|
||
Index_Sollwert_Feuchte_Limit = 1;
|
||
while (Kennfeld_Sollwert_Feuchte_Limit[0][Index_Sollwert_Feuchte_Limit] <
|
||
Sollwert_Temperatur &&
|
||
Index_Sollwert_Feuchte_Limit < 10) {
|
||
Index_Sollwert_Feuchte_Limit++;
|
||
}
|
||
|
||
Interpolation_Sollwert_Feuchte_Limit = limit(
|
||
(Kennfeld_Sollwert_Feuchte_Limit[0][Index_Sollwert_Feuchte_Limit - 1] -
|
||
Sollwert_Temperatur) /
|
||
(Kennfeld_Sollwert_Feuchte_Limit[0]
|
||
[Index_Sollwert_Feuchte_Limit - 1] -
|
||
Kennfeld_Sollwert_Feuchte_Limit[0][Index_Sollwert_Feuchte_Limit]),
|
||
0.0, 1.0);
|
||
|
||
Sollwert_Feuchte_Max =
|
||
Kennfeld_Sollwert_Feuchte_Limit[1][Index_Sollwert_Feuchte_Limit] *
|
||
Interpolation_Sollwert_Feuchte_Limit +
|
||
Kennfeld_Sollwert_Feuchte_Limit[1][Index_Sollwert_Feuchte_Limit - 1] *
|
||
(1.0 - Interpolation_Sollwert_Feuchte_Limit);
|
||
|
||
Sollwert_Feuchte_Min =
|
||
Kennfeld_Sollwert_Feuchte_Limit[2][Index_Sollwert_Feuchte_Limit] *
|
||
Interpolation_Sollwert_Feuchte_Limit +
|
||
Kennfeld_Sollwert_Feuchte_Limit[2][Index_Sollwert_Feuchte_Limit - 1] *
|
||
(1.0 - Interpolation_Sollwert_Feuchte_Limit);
|
||
|
||
Sollwert_Feuchte =
|
||
limit(Sollwert_Feuchte, Sollwert_Feuchte_Min, Sollwert_Feuchte_Max);
|
||
|
||
|
||
|
||
// Abschaltung Feuchteregelung
|
||
// f_CutOffHumidityControl(...)
|
||
Befeuchtung_aus =
|
||
(!Sollwert_Feuchte_aktiv) || Steuerkontakt_Befeuchtung_aus ||
|
||
(Sollwert_Temperatur > 95.0) || (Sollwert_Temperatur < 5.0);
|
||
Entfeuchtung_aus =
|
||
(!Sollwert_Feuchte_aktiv) || Steuerkontakt_Entfeuchtung_aus ||
|
||
(Sollwert_Temperatur > 95.0) || (Sollwert_Temperatur < 5.0);
|
||
|
||
// (p_H2Omax, Taupunkt etc.)
|
||
p_H2Omax_Sollwert = 6.112 * std::exp(17.62 * Sollwert_Temperatur /
|
||
(243.12 + Sollwert_Temperatur));
|
||
p_H2Omax_Istwert = 6.112 * std::exp(17.62 * Istwert_Temperatur /
|
||
(243.12 + Istwert_Temperatur));
|
||
|
||
Taupunkt_Istwert =
|
||
(241.2 * std::log(std::max(Istwert_Feuchte, 0.001) / 100.0) +
|
||
(4222.03716 * Istwert_Temperatur) / (241.2 + Istwert_Temperatur)) /
|
||
(17.5043 - std::log(std::max(Istwert_Feuchte, 0.001) / 100.0) -
|
||
(17.5043 * Istwert_Temperatur) / (241.2 + Istwert_Temperatur));
|
||
|
||
if (Temperatursprung) {
|
||
Sollwert_Feuchte_Absolut =
|
||
limit(Sollwert_Feuchte * p_H2Omax_Sollwert / p_H2Omax_Istwert, 0.0,
|
||
Sollwert_Feuchte);
|
||
} else {
|
||
Sollwert_Feuchte_Absolut = Sollwert_Feuchte;
|
||
}
|
||
if (!is_valid(Sollwert_Feuchte_Absolut)) {
|
||
Sollwert_Feuchte_Absolut = Sollwert_Feuchte;
|
||
}
|
||
|
||
// ------------------
|
||
// Überwachungsregler
|
||
// ------------------
|
||
// f_SuperVisor
|
||
|
||
/*
|
||
Modus_Ueberwachungsregler =
|
||
static_cast<std::uint32_t>(UTILITY_FUNCTIONS::GET_VALUE_DINT(71,0,3,0));
|
||
Grenzwert_Uebertemperatur = UTILITY_FUNCTIONS::GET_VALUE_REAL(71,0,4,0);
|
||
Offset_Ueberwachungsregler = UTILITY_FUNCTIONS::GET_VALUE_REAL(71,0,5,0);
|
||
|
||
if (Modus_Ueberwachungsregler > 0) {
|
||
Schaltwert_Uebertemperatur = limit(Sollwert_Temperatur +
|
||
Offset_Ueberwachungsregler, -30.0, 110.0); Schaltwert_Untertemperatur =
|
||
limit(Sollwert_Temperatur - Offset_Ueberwachungsregler, -30.0, 110.0); }
|
||
else { Schaltwert_Uebertemperatur = Grenzwert_Uebertemperatur;
|
||
Schaltwert_Untertemperatur = Grenzwert_Untertemperatur;
|
||
}
|
||
|
||
const double maxUeberw = std::max(Istwert_Ueberwachungsregler,
|
||
Istwert_Temperatur); const double minUeberw =
|
||
std::min(Istwert_Ueberwachungsregler, Istwert_Temperatur);
|
||
|
||
if ( (maxUeberw > Schaltwert_Uebertemperatur) ||
|
||
(Status_Uebertemperatur && (maxUeberw > Schaltwert_Uebertemperatur
|
||
- 1.0)) || (StatusQuittierung_Uebertemperatur && (Klasse_Ueberwachungsregler
|
||
< 3.0)) ) { Counter_Status_Uebertemperatur += 1; } else {
|
||
Counter_Status_Uebertemperatur = 0;
|
||
}
|
||
|
||
Status_Uebertemperatur = (Counter_Status_Uebertemperatur >=
|
||
static_cast<std::uint32_t>(10 * 4)); StatusQuittierung_Uebertemperatur =
|
||
(Status_Uebertemperatur && Counter_Status_Uebertemperatur <
|
||
static_cast<std::uint32_t>(11 * 4)) || (StatusQuittierung_Uebertemperatur &&
|
||
Sammelalarm_quittiert);
|
||
|
||
if ( ((minUeberw < Schaltwert_Untertemperatur) ||
|
||
(Status_Untertemperatur && (minUeberw < Schaltwert_Untertemperatur
|
||
+ 1.0))) && (Klasse_Ueberwachungsregler >= 3.0) ) {
|
||
Counter_Status_Untertemperatur += 1;
|
||
} else {
|
||
Counter_Status_Untertemperatur = 0;
|
||
}
|
||
|
||
Status_Untertemperatur = (Counter_Status_Untertemperatur >=
|
||
static_cast<std::uint32_t>(10 * 4)); StatusQuittierung_Untertemperatur =
|
||
(Status_Untertemperatur && Counter_Status_Untertemperatur <
|
||
static_cast<std::uint32_t>(11 * 4)) || (StatusQuittierung_Untertemperatur &&
|
||
Sammelalarm_quittiert);
|
||
|
||
if (Status_Untertemperatur || StatusQuittierung_Untertemperatur) {
|
||
Sollwert_Temperatur = std::max(Sollwert_Temperatur,
|
||
Schaltwert_Untertemperatur);
|
||
}
|
||
if (Status_Uebertemperatur || StatusQuittierung_Uebertemperatur) {
|
||
Sollwert_Temperatur = std::min(Sollwert_Temperatur,
|
||
Schaltwert_Uebertemperatur);
|
||
}*/
|
||
|
||
// ------------------------
|
||
// Parametersatzumschaltung
|
||
// ------------------------
|
||
// f_SwitchParameterSet(...)
|
||
Index_Feuchte = static_cast<std::uint16_t>(
|
||
8 -
|
||
UTILITY_FUNCTIONS::real_to_int(
|
||
limit((Sollwert_Feuchte - 10.0) / (90.0 - 10.0) * 8.0, 0.0, 8.0) +
|
||
0.5));
|
||
Index_Temperatur =
|
||
static_cast<std::uint16_t>(UTILITY_FUNCTIONS::real_to_int(
|
||
limit((Sollwert_Temperatur - 10.0) / (90.0 - 10.0) * 8.0, 0.0,
|
||
8.0) +
|
||
0.5));
|
||
Index_Temperatur_ohne_Feuchte =
|
||
static_cast<std::uint16_t>(UTILITY_FUNCTIONS::real_to_int(
|
||
limit((Sollwert_Temperatur - (-20.0)) / (100.0 - (-20.0)) * 12.0,
|
||
0.0, 12.0) +
|
||
0.5));
|
||
|
||
Regler_Heizung_Xp = F_Xp_Heizung * Kennfeld_Regler_Heizung_Xp[Index_Temperatur_ohne_Feuchte];
|
||
Regler_Kuehlung_Xp = F_Xp_Kuehlung *
|
||
Kennfeld_Regler_Kuehlung_Xp[Index_Temperatur_ohne_Feuchte];
|
||
Regler_Befeuchtung_Xp =
|
||
F_Xp_Befeuchtung_BINDER *
|
||
Kennfeld_Regler_Befeuchtung_Xp[Index_Feuchte][Index_Temperatur];
|
||
Regler_Entfeuchtung_Xp =
|
||
F_Xp_Entfeuchtung *
|
||
Kennfeld_Regler_Entfeuchtung_Xp[Index_Feuchte][Index_Temperatur];
|
||
Regler_Tuer_Xp = F_Xp_Tuer;
|
||
|
||
// ---------------------
|
||
// PID Regler Temperatur
|
||
// ---------------------
|
||
// F_PID PID_Temperature(...)
|
||
Regelabweichung_Temperatur = Sollwert_Temperatur - Istwert_Temperatur;
|
||
|
||
// Zykluszeit Regelabweichung Temperatur
|
||
if (!Startup_finished || !is_valid(Standardregelabweichung_Temperatur) ||
|
||
!is_valid(Standardgradient_Regelabweichung_Temperatur) ||
|
||
Standardgradient_Regelabweichung_Temperatur <= 0.0) {
|
||
Zykluszeit_Regelabweichung_Temperatur = 600.0;
|
||
} else {
|
||
Zykluszeit_Regelabweichung_Temperatur =
|
||
limit(2.0 * 3.1415 * Standardregelabweichung_Temperatur /
|
||
Standardgradient_Regelabweichung_Temperatur * 60.0,
|
||
120.0, 1200.0);
|
||
}
|
||
Zykluszeit_Regelabweichung_Heizung =
|
||
std::min(Zykluszeit_Regelabweichung_Temperatur, 300.0);
|
||
Zykluszeit_Regelabweichung_Kuehlung =
|
||
std::max(Zykluszeit_Regelabweichung_Temperatur, 600.0);
|
||
|
||
Amplitude_Regelabweichung_Temperatur =
|
||
1.4142 * Standardregelabweichung_Temperatur;
|
||
|
||
// Mittelwert Regelabweichung Temperatur
|
||
if (!Startup_finished || !is_valid(Regelabweichung_Temperatur_Mittelwert) ||
|
||
Temperatursprung) {
|
||
Regelabweichung_Temperatur_Mittelwert = 0.0;
|
||
} else if (is_valid(Regelabweichung_Temperatur)) {
|
||
const double alpha =
|
||
(Zykluszeit_Regelabweichung_Temperatur / sampling_time);
|
||
Regelabweichung_Temperatur_Mittelwert = limit(
|
||
Regelabweichung_Temperatur_Mittelwert +
|
||
(Regelabweichung_Temperatur -
|
||
Regelabweichung_Temperatur_Mittelwert) /
|
||
alpha,
|
||
Regelabweichung_Temperatur - 1.0, Regelabweichung_Temperatur + 1.0);
|
||
}
|
||
|
||
// Standardregelabweichung Temperatur
|
||
if (!Startup_finished || !is_valid(Standardregelabweichung_Temperatur) ||
|
||
Temperatursprung) {
|
||
Standardregelabweichung_Temperatur = 0.0;
|
||
} else if (is_valid(Regelabweichung_Temperatur)) {
|
||
const double n = (Zykluszeit_Regelabweichung_Temperatur / sampling_time);
|
||
Standardregelabweichung_Temperatur = std::min(
|
||
std::sqrt(((Regelabweichung_Temperatur -
|
||
Regelabweichung_Temperatur_Mittelwert) *
|
||
(Regelabweichung_Temperatur -
|
||
Regelabweichung_Temperatur_Mittelwert) +
|
||
Standardregelabweichung_Temperatur *
|
||
Standardregelabweichung_Temperatur * (n - 1.0)) /
|
||
n),
|
||
1.0);
|
||
}
|
||
|
||
// Gradient Regelabweichung Temperatur
|
||
// f_PID_Temperaure.GradientDifference(...)
|
||
if (!Startup_finished || !is_valid(Regelabweichung_Temperatur_Gradient)) {
|
||
Regelabweichung_Temperatur_Gradient = 0.0;
|
||
} else if (is_valid(Regelabweichung_Temperatur) &&
|
||
is_valid(Regelabweichung_Temperatur_alt)) {
|
||
Regelabweichung_Temperatur_Gradient = limit(
|
||
Regelabweichung_Temperatur_Gradient +
|
||
((Regelabweichung_Temperatur - Regelabweichung_Temperatur_alt) *
|
||
(60.0 / sampling_time) -
|
||
Regelabweichung_Temperatur_Gradient) /
|
||
(10.0 / sampling_time),
|
||
-4.0, 2.0);
|
||
}
|
||
|
||
// Standardgradient Temperatur
|
||
// f_PID_Temperaure.StandardGradient(...)
|
||
if (!Startup_finished ||
|
||
!is_valid(Standardgradient_Regelabweichung_Temperatur) ||
|
||
Temperatursprung) {
|
||
Standardgradient_Regelabweichung_Temperatur = 0.0;
|
||
} else if (is_valid(Regelabweichung_Temperatur)) {
|
||
const double n = (Zykluszeit_Regelabweichung_Temperatur / sampling_time);
|
||
Standardgradient_Regelabweichung_Temperatur =
|
||
limit(std::sqrt((Regelabweichung_Temperatur_Gradient *
|
||
Regelabweichung_Temperatur_Gradient +
|
||
Standardgradient_Regelabweichung_Temperatur *
|
||
Standardgradient_Regelabweichung_Temperatur *
|
||
(n - 1.0)) /
|
||
n),
|
||
0.01, 1.0);
|
||
}
|
||
|
||
// Temperatursprung
|
||
// f_TemperatureJumpHandler(...)
|
||
if (!Startup_finished) {
|
||
Counter_Temperatursprung = 0.0;
|
||
} else if (((Sollwert_Temperatur != Sollwert_Temperatur_alt) &&
|
||
(std::abs(Regelabweichung_Temperatur) > 1.0)) ||
|
||
Tuer_offen) {
|
||
Counter_Temperatursprung =
|
||
std::max(Counter_Temperatursprung + sampling_time, 0.0);
|
||
} else if (Regelabweichung_Temperatur <
|
||
std::max(0.2, Amplitude_Regelabweichung_Temperatur) &&
|
||
Regelabweichung_Temperatur >
|
||
-std::max(0.2, Amplitude_Regelabweichung_Temperatur)) {
|
||
Counter_Temperatursprung =
|
||
std::min(Counter_Temperatursprung - sampling_time, 0.0);
|
||
} else if (Regelabweichung_Temperatur >
|
||
std::max(0.5, 2.0 * Amplitude_Regelabweichung_Temperatur) ||
|
||
Regelabweichung_Temperatur <
|
||
-std::max(0.5, 2.0 * Amplitude_Regelabweichung_Temperatur)) {
|
||
Counter_Temperatursprung =
|
||
std::max(Counter_Temperatursprung + sampling_time, -120.0);
|
||
}
|
||
Temperatursprung = (Counter_Temperatursprung > 0.0) ||
|
||
(Temperatursprung && Counter_Temperatursprung > -60.0);
|
||
|
||
// Anti-wind-up Heizung (dynamisches Clamping)
|
||
// ------ F_PID_Temperatuer.AntiWindUpHeater(...)
|
||
if ((Counter_Tuer_geschlossen < 180.0) || (Counter_Tuer_offen > 0.0)) {
|
||
Regler_Heizung_MIN = 0.0;
|
||
Regler_Heizung_I_Anteil_MIN = 0.0;
|
||
Regler_Heizung_MAX = 100.0;
|
||
Regler_Heizung_I_Anteil_MAX =
|
||
limit(100.0 - P_Anteil_Heizung, Regler_Heizung_I_Anteil_MIN,
|
||
Stellgrad_Heizung_Mittelwert);
|
||
} else {
|
||
Regler_Heizung_MIN = 0.0;
|
||
Regler_Heizung_I_Anteil_MIN = 0.0;
|
||
Regler_Heizung_MAX = 100.0;
|
||
if (Temperatursprung) {
|
||
Regler_Heizung_I_Anteil_MAX =
|
||
limit(100.0 - P_Anteil_Heizung, Regler_Heizung_I_Anteil_MIN,
|
||
Regler_Heizung_MAX);
|
||
} else {
|
||
Regler_Heizung_I_Anteil_MAX = 100.0;
|
||
}
|
||
}
|
||
//----------------------
|
||
|
||
// Anpassung Xp Heizung
|
||
// // ------------F_PID_Temperatuer.AdaptXp(...)
|
||
if (Regelabweichung_Temperatur > Amplitude_Regelabweichung_Temperatur &&
|
||
Regelabweichung_Temperatur_Mittelwert > 0.05 && !Temperatursprung) {
|
||
Regler_Heizung_Xp /= 2.0;
|
||
}
|
||
// Achtung: du referenzierst hier Zykluszeit_Regelabweichung_Feuchte später
|
||
// – steht unten. Wir setzen default, falls noch uninitialisiert:
|
||
if (!is_valid(Zykluszeit_Regelabweichung_Feuchte) ||
|
||
Zykluszeit_Regelabweichung_Feuchte <= 0.0) {
|
||
Zykluszeit_Regelabweichung_Feuchte = 600.0;
|
||
}
|
||
|
||
Regler_Heizung_Xp =
|
||
Regler_Heizung_Xp *
|
||
limit(Zykluszeit_Regelabweichung_Feuchte / 300.0, 1.0, 2.0) *
|
||
limit(1.0 + Amplitude_Regelabweichung_Temperatur / 0.5 +
|
||
Stellgrad_Kuehlung_Mittelwert / -100.0,
|
||
1.0, 2.0);
|
||
//-----------// ------------F_PID_Temperatuer.AdaptXp(...)---------------------------------------------------
|
||
|
||
// P/I/D Heizung
|
||
//----------------- F_PID_Temperature.step(...)
|
||
if (!Startup_finished || !is_valid(Regelabweichung_Temperatur)) {
|
||
P_Anteil_Heizung = 0.0;
|
||
} else {
|
||
P_Anteil_Heizung = 100.0 / Regler_Heizung_Xp * Regelabweichung_Temperatur;
|
||
}
|
||
|
||
if (!Startup_finished || !is_valid(I_Anteil_Heizung)) {
|
||
I_Anteil_Heizung = 0.0;
|
||
} else if (!Regelung_AUS && is_valid(Regelabweichung_Temperatur) &&
|
||
Counter_Tuer_geschlossen > 60.0) {
|
||
I_Anteil_Heizung = limit(
|
||
I_Anteil_Heizung + 100.0 / Regler_Heizung_Xp /
|
||
(1.0 * Zykluszeit_Regelabweichung_Heizung) *
|
||
sampling_time * Regelabweichung_Temperatur,
|
||
Regler_Heizung_I_Anteil_MIN, Regler_Heizung_I_Anteil_MAX);
|
||
}
|
||
|
||
if (!Startup_finished || !is_valid(D_Anteil_Heizung)) {
|
||
D_Anteil_Heizung = 0.0;
|
||
} else if (is_valid(Regelabweichung_Temperatur) &&
|
||
is_valid(Regelabweichung_Temperatur_alt) &&
|
||
Counter_Tuer_geschlossen > 0.0) {
|
||
D_Anteil_Heizung =
|
||
D_Anteil_Heizung +
|
||
(100.0 / Regler_Heizung_Xp *
|
||
(0.1 * Zykluszeit_Regelabweichung_Heizung) *
|
||
(Regelabweichung_Temperatur - Regelabweichung_Temperatur_alt) /
|
||
sampling_time -
|
||
D_Anteil_Heizung) /
|
||
(Tau_Heizung_Tv / sampling_time);
|
||
}
|
||
|
||
if (Counter_Tuer_offen > 60.0 || Regelung_AUS || !Startup_finished) {
|
||
Stellgrad_Heizung = 0.0;
|
||
} else {
|
||
Stellgrad_Heizung =
|
||
limit(P_Anteil_Heizung + I_Anteil_Heizung + D_Anteil_Heizung,
|
||
Regler_Heizung_MIN, Regler_Heizung_MAX);
|
||
}
|
||
|
||
if (!Startup_finished || !is_valid(Stellgrad_Heizung_Mittelwert)) {
|
||
Stellgrad_Heizung_Mittelwert = 0.0;
|
||
} else if (Temperatursprung) {
|
||
Stellgrad_Heizung_Mittelwert = Stellgrad_Heizung;
|
||
} else if (is_valid(Stellgrad_Heizung)) {
|
||
Stellgrad_Heizung_Mittelwert =
|
||
Stellgrad_Heizung_Mittelwert +
|
||
(Stellgrad_Heizung - Stellgrad_Heizung_Mittelwert) /
|
||
(Zykluszeit_Regelabweichung_Temperatur / sampling_time);
|
||
}
|
||
|
||
|
||
// ------------ F_PID_Temperature.step(...) !!!!! todo uj umbenennen in Heizung !!!!!!!!!!!!!!!!!!!
|
||
|
||
|
||
// ----------------------------------------------------
|
||
// Ab hier: Kühlung + Feuchte-PIDs + Tür-PID + Aktorlogik
|
||
// ----------------------------------------------------
|
||
// => in gleicher Art übersetzen (Muster ist identisch).
|
||
//
|
||
// Für dieses Snippet: wir übernehmen für die Outputs zumindest die Werte,
|
||
// die schon berechnet sind, und lassen Stellgrade der restlichen Aktoren,
|
||
// falls nicht berechnet, auf gültigen Default stehen.
|
||
|
||
// Regelabweichung Kühlung
|
||
// F_ PID PID_Cooling()
|
||
double Regelabweichung_Kuehlung = Regelabweichung_Temperatur;
|
||
|
||
// Gradient Regelabweichgun Kuehlung
|
||
|
||
if (!Startup_finished) {
|
||
Regelabweichung_Kuehlung_Gradient = 0.0;
|
||
|
||
} else {
|
||
Regelabweichung_Kuehlung_Gradient =
|
||
limit((Regelabweichung_Kuehlung - Regelabweichung_Kuehlung_alt) *
|
||
60.0 / sampling_time -
|
||
Regelabweichung_Kuehlung_Gradient,
|
||
-4.0, 2.0);
|
||
}
|
||
|
||
// Faktor Kuehlung
|
||
|
||
if (!Startup_finished || Temperatursprung) {
|
||
Faktor_Kuehlung = 5.0;
|
||
} else if (Regelabweichung_Kuehlung < -0.1) {
|
||
Faktor_Kuehlung = std::min(Faktor_Kuehlung + sampling_time, 5.0);
|
||
} else {
|
||
Faktor_Kuehlung = std::max(Faktor_Kuehlung - sampling_time / 60.0, 0.2);
|
||
}
|
||
|
||
// --------------------------- Gegenheizen Band !!! Überwacher !!!!!
|
||
double Regelabweichung_Entfeuchtung = Regelabweichung_Feuchte;
|
||
if (!Startup_finished || Temperatursprung ||
|
||
(Counter_Temperatursprung > -600.0 &&
|
||
Faktor_Gegenheizen_Band == 10.0)) {
|
||
Faktor_Gegenheizen_Band = 10.0;
|
||
|
||
} else if (Stellgrad_Heizung_Mittelwert - Sollwert_Gegenheizen < -1.0) {
|
||
if (Regelabweichung_Entfeuchtung > 0.5) {
|
||
Faktor_Gegenheizen_Band =
|
||
std::max(Faktor_Gegenheizen_Band - sampling_time / 10.0, 0.0);
|
||
} else {
|
||
Faktor_Gegenheizen_Band =
|
||
std::min(Faktor_Gegenheizen_Band + sampling_time / 60.0, 10.0);
|
||
}
|
||
|
||
} else if (Stellgrad_Heizung_Mittelwert - Sollwert_Gegenheizen > 1.0 &&
|
||
Stellgrad_Kuehlung_Mittelwert < -5.0) {
|
||
if (Regelabweichung_Entfeuchtung < -0.5) {
|
||
Faktor_Gegenheizen_Band =
|
||
std::max(Faktor_Gegenheizen_Band - sampling_time / 10.0, 0.0);
|
||
} else {
|
||
Faktor_Gegenheizen_Band =
|
||
std::min(Faktor_Gegenheizen_Band + sampling_time / 600.0, 5.0);
|
||
}
|
||
}
|
||
else {
|
||
Faktor_Gegenheizen_Band =
|
||
std::max(Faktor_Gegenheizen_Band - sampling_time / 60.0, 0.1);
|
||
}
|
||
// --------------------------- Gegenheizen Band
|
||
|
||
// -----------------------Sollwert Gegenheizen für I-Anteilverschiebung
|
||
|
||
double Faktor_Entfeuchtung_Kuehlung = 0.0;
|
||
double Offset_Kuehlung = Faktor_Entfeuchtung_Kuehlung;
|
||
Offset_Kuehlung =
|
||
Faktor_Entfeuchtung_Kuehlung * Stellgrad_Entfeuchtung_Mittelwert *
|
||
std::max((50.0 - Stellgrad_Heizung_Mittelwert) / (50 - 0.0), 0.0) *
|
||
(8.0 - Stellgrad_Befeuchtung_Standby) / (8.0 - 2.0);
|
||
//------------------------------------------------------------
|
||
|
||
|
||
// P-Anteil Kühlung
|
||
// f_PID_Cooling.SetP
|
||
double P_Anteil_Kuehlung = 0.0;
|
||
if (!Startup_finished) {
|
||
P_Anteil_Kuehlung = 0.0;
|
||
} else {
|
||
P_Anteil_Kuehlung = 100.0 / Regler_Kuehlung_Xp * Faktor_Kuehlung *
|
||
Regelabweichung_Kuehlung;
|
||
}
|
||
|
||
// Begrenzung I-Anteil Kühlung bei Türöffnung
|
||
// f_PID_Cooling.Limit_I_PostDoorOpening(...)
|
||
double Regler_Kuehlung_MAX = 0;
|
||
double Regler_Kuehlung_MIN = 0;
|
||
double Regler_Kuehlung_I_Anteil_MAX = 0;
|
||
double Regler_Kuehlung_I_Anteil_MIN = 0;
|
||
|
||
if ((Counter_Tuer_geschlossen < 180.0) || (Counter_Tuer_offen > 0.0)) {
|
||
Regler_Kuehlung_MAX = I_Anteil_Kuehlung;
|
||
Regler_Kuehlung_MIN = -100.0;
|
||
Regler_Kuehlung_I_Anteil_MAX = I_Anteil_Kuehlung;
|
||
Regler_Kuehlung_I_Anteil_MIN = limit( -100.0 - P_Anteil_Kuehlung, Regler_Kuehlung_MIN, Regler_Kuehlung_MAX);
|
||
} else {
|
||
Regler_Kuehlung_MAX = 0.0;
|
||
Regler_Kuehlung_MIN = -100.0;
|
||
Regler_Kuehlung_I_Anteil_MAX = 0.1 / Regler_Kuehlung_Xp * 100.0;
|
||
Regler_Kuehlung_I_Anteil_MIN = limit( -100.0 - P_Anteil_Kuehlung + Regelabweichung_Kuehlung_Gradient / 0.5 * 100.0,
|
||
Regler_Kuehlung_MIN,
|
||
Regler_Kuehlung_MAX);
|
||
}
|
||
|
||
// f_PID_Cooling.Step(...)
|
||
// I Anteil Kühlung
|
||
if (!Startup_finished) {
|
||
I_Anteil_Kuehlung = 0.0;
|
||
} else if (Counter_Tuer_geschlossen > 60.0) {
|
||
I_Anteil_Kuehlung =
|
||
limit(I_Anteil_Kuehlung +
|
||
100.0 / Regler_Kuehlung_Tn * sampling_time *
|
||
(Regelabweichung_Kuehlung +
|
||
(Stellgrad_Heizung - Sollwert_Gegenheizen) / 100.0 *
|
||
Regler_Heizung_Xp * Theta_I_Kuehlung *
|
||
Faktor_Gegenheizen_Band),
|
||
Regler_Kuehlung_I_Anteil_MIN, Regler_Kuehlung_I_Anteil_MAX);
|
||
}
|
||
|
||
// D-Anteil Kühlung
|
||
|
||
if (!Startup_finished) {
|
||
D_Anteil_Kuehlung = 0.0;
|
||
} else if (Counter_Tuer_geschlossen > 0.0) {
|
||
D_Anteil_Kuehlung +=
|
||
(100.0 / Regler_Kuehlung_Xp * Regler_Kuehlung_Tv *
|
||
(Regelabweichung_Kuehlung - Regelabweichung_Kuehlung_alt) /
|
||
sampling_time -
|
||
D_Anteil_Kuehlung) /
|
||
(Tau_Kuehlung_Tv / sampling_time);
|
||
}
|
||
|
||
// Berechnung Stellgrad Kühlung
|
||
// f_
|
||
if (Counter_Tuer_offen > 60.0 || !Startup_finished) {
|
||
Stellgrad_Kuehlung = 0.0;
|
||
} else {
|
||
Stellgrad_Kuehlung = limit(P_Anteil_Kuehlung + I_Anteil_Kuehlung +
|
||
D_Anteil_Kuehlung + Offset_Kuehlung,
|
||
Regler_Kuehlung_MIN, Regler_Kuehlung_MAX);
|
||
}
|
||
|
||
// Berechnung Stellgrad Mittelwert
|
||
|
||
if (!Startup_finished) {
|
||
Stellgrad_Kuehlung_Mittelwert = 0.0;
|
||
} else {
|
||
Stellgrad_Kuehlung_Mittelwert =
|
||
limit(Stellgrad_Kuehlung_Mittelwert +
|
||
(Stellgrad_Kuehlung - Stellgrad_Kuehlung_Mittelwert) /
|
||
(600.0 / sampling_time),
|
||
Stellgrad_Kuehlung - 0.5 * 100.0 * Regler_Kuehlung_Xp,
|
||
Stellgrad_Kuehlung + 0.5 * 100.0 / Regler_Kuehlung_Xp);
|
||
}
|
||
// ------------------- F_ PID PID_Cooling()
|
||
|
||
|
||
// PID Regler Feuchte
|
||
// f_PID_Humidiy
|
||
Regelabweichung_Feuchte = Sollwert_Feuchte_Absolut - Istwert_Feuchte;
|
||
|
||
// Berechnung Regelabweichung Feuchte Mittelwert
|
||
if (!Startup_finished) {
|
||
Regelabweichung_Feuchte_Mittelwert = 0.0;
|
||
} else {
|
||
Regelabweichung_Feuchte_Mittelwert = limit(
|
||
Regelabweichung_Feuchte_Mittelwert +
|
||
(Regelabweichung_Feuchte - Regelabweichung_Feuchte_Mittelwert) /
|
||
(60.0 / sampling_time),
|
||
Regelabweichung_Feuchte - 10.0, Regelabweichung_Feuchte + 10.0);
|
||
}
|
||
|
||
// Feuchtesprung
|
||
// f_PID_Hunidity.HandleJump(...)
|
||
if (!Startup_finished) {
|
||
Counter_Feuchtesprung = 0.0;
|
||
} else if (Sollwert_Feuchte != Sollwert_Feuchte_alt &&
|
||
std::abs(Regelabweichung_Feuchte) > 2.0) {
|
||
Counter_Feuchtesprung =
|
||
std::max(Counter_Feuchtesprung + sampling_time, 0.0);
|
||
} else if (std::abs(Regelabweichung_Feuchte) < 2.0 ||
|
||
std::abs(Regelabweichung_Feuchte_Mittelwert) < 2.0) {
|
||
Counter_Feuchtesprung =
|
||
std::min(Counter_Feuchtesprung - sampling_time, 0.0);
|
||
} else if (std::abs(Regelabweichung_Feuchte_Mittelwert) > 5.0) {
|
||
Counter_Feuchtesprung =
|
||
std::max(Counter_Feuchtesprung + sampling_time, -120.0);
|
||
}
|
||
|
||
Feuchtesprung = (Counter_Feuchtesprung > 0.0 ||
|
||
(Feuchtesprung && Counter_Feuchtesprung > -120.0));
|
||
|
||
// Regelabweichung Befeuchtung
|
||
|
||
double Regelabweichung_Befeuchtung = Regelabweichung_Feuchte;
|
||
|
||
// Gradient regelabweichung Feuchte
|
||
|
||
if (!Startup_finished) {
|
||
Regelabweichung_Befeuchtung_Gradient = 0.0;
|
||
} else {
|
||
Regelabweichung_Befeuchtung_Gradient = limit(
|
||
Regelabweichung_Befeuchtung_Gradient +
|
||
((Regelabweichung_Befeuchtung - Regelabweichung_Befeuchtung_alt) *
|
||
60.0 / sampling_time -
|
||
Regelabweichung_Befeuchtung_Gradient) /
|
||
60.0 * sampling_time,
|
||
-20.0, 5.0);
|
||
}
|
||
|
||
// Begrenzung I-Anteil bei Türöffnung
|
||
double Regler_Befeuchtung_MIN = 0.0;
|
||
double Regler_Befeuchtung_MAX = 0.0;
|
||
double Regler_Befeuchtung_I_Anteil_MIN = 0.0;
|
||
double Regler_Befeuchtung_I_Anteil_MAX = 0.0;
|
||
|
||
if ((Counter_Tuer_geschlossen < 180.0) || (Counter_Tuer_offen > 0.0)) {
|
||
Regler_Befeuchtung_MIN =
|
||
std::max(Stellgrad_Befeuchtung_Standby - 2.0, Standby_Feuchtemodul);
|
||
Regler_Befeuchtung_MAX = std::min(100.0, Stellgrad_Feuchtemodul_MAX);
|
||
Regler_Befeuchtung_I_Anteil_MIN = 0.0;
|
||
Regler_Befeuchtung_I_Anteil_MAX =
|
||
limit(100.0 - P_Anteil_Befeuchtung, Regler_Befeuchtung_I_Anteil_MIN,
|
||
Stellgrad_Befeuchtung_Mittelwert);
|
||
} else {
|
||
if (Feuchtesprung) {
|
||
Regler_Befeuchtung_MIN =
|
||
std::max(Stellgrad_Befeuchtung_Standby - 2.0, Standby_Feuchtemodul);
|
||
} else {
|
||
Regler_Befeuchtung_MIN =
|
||
std::max(std::min(Stellgrad_Befeuchtung_Standby +
|
||
0.25 * P_Anteil_Befeuchtung +
|
||
D_Anteil_Befeuchtung + Z_Anteil_Befeuchtung,
|
||
Stellgrad_Befeuchtung_Standby + 2.0),
|
||
std::max(Stellgrad_Befeuchtung_Standby - 1.0,
|
||
Standby_Feuchtemodul));
|
||
}
|
||
Regler_Befeuchtung_MAX = std::min(100.0, Stellgrad_Feuchtemodul_MAX);
|
||
Regler_Befeuchtung_I_Anteil_MIN = 0.0;
|
||
Regler_Befeuchtung_I_Anteil_MAX =
|
||
limit(100.0, Regler_Befeuchtung_I_Anteil_MIN,
|
||
Stellgrad_Befeuchtung_Mittelwert);
|
||
}
|
||
|
||
// Anteil P-Anteil Befeuchtung bei Feuchtesprung und Türöffnung
|
||
|
||
if (Counter_Tuer_geschlossen < 180.0 && Feuchtesprung) {
|
||
Regler_Befeuchtung_Xp = Regler_Befeuchtung_Xp * 2.0;
|
||
} else if (Counter_Tuer_geschlossen > 300.0 && Feuchtesprung) {
|
||
Regler_Befeuchtung_Xp = Regler_Befeuchtung_Xp / 2.0;
|
||
} else {
|
||
Regler_Befeuchtung_Xp =
|
||
Regler_Befeuchtung_Xp *
|
||
(1.0 + Stellgrad_Entfeuchtung_Mittelwert / -100.0);
|
||
}
|
||
|
||
// P-Anteil Befeuchtung
|
||
|
||
if (!Startup_finished) {
|
||
P_Anteil_Befeuchtung = 0.0;
|
||
}
|
||
|
||
else {
|
||
P_Anteil_Befeuchtung =
|
||
100.0 / Regler_Befeuchtung_Xp * Regelabweichung_Befeuchtung;
|
||
}
|
||
|
||
// I-Anteil Befeuchtung
|
||
|
||
if (!Startup_finished) {
|
||
I_Anteil_Befeuchtung = 0.0;
|
||
} else if (Counter_Tuer_geschlossen > 60.0) {
|
||
I_Anteil_Befeuchtung = limit(
|
||
I_Anteil_Befeuchtung + 100.0 / Regler_Befeuchtung_Xp /
|
||
Regler_Befeuchtung_Tn * sampling_time *
|
||
Regelabweichung_Befeuchtung,
|
||
Regler_Befeuchtung_I_Anteil_MIN, Regler_Befeuchtung_I_Anteil_MAX);
|
||
}
|
||
|
||
// D-Anteil Befeuchtung
|
||
if (!Startup_finished) {
|
||
D_Anteil_Befeuchtung = 0.0;
|
||
} else if (Counter_Tuer_geschlossen) {
|
||
D_Anteil_Befeuchtung +=
|
||
(100.0 / Regler_Befeuchtung_Xp * Regler_Befeuchtung_Tv *
|
||
(Regelabweichung_Befeuchtung - Regelabweichung_Befeuchtung_alt) /
|
||
sampling_time -
|
||
D_Anteil_Befeuchtung) /
|
||
(Tau_Befeuchtung_Tv / sampling_time);
|
||
}
|
||
|
||
// Z-Anteil Befeuchtung
|
||
|
||
if (!Startup_finished || Feuchtesprung) {
|
||
Z_Anteil_Befeuchtung = 0.0;
|
||
} else if (Counter_Tuer_geschlossen > 0.0) {
|
||
Z_Anteil_Befeuchtung +=
|
||
(100.0 / Regler_Befeuchtung_Xp * Regler_Befeuchtung_Tz *
|
||
((Regelabweichung_Befeuchtung -
|
||
Regelabweichung_Befeuchtung_alt) -
|
||
(Regelabweichung_Befeuchtung_alt -
|
||
Regelabweichung_Befeuchtung_alt_alt)) /
|
||
sampling_time -
|
||
Z_Anteil_Befeuchtung) /
|
||
(Tau_Befeuchtung_Tz / sampling_time);
|
||
}
|
||
// Regler_Befeuchtung_MAX = 10.0;
|
||
// Berechnung Stellgrad Befeuchtung
|
||
if (Counter_Tuer_offen > 60.0 || !Startup_finished) {
|
||
Stellgrad_Befeuchtung = 0.0;
|
||
} else {
|
||
Stellgrad_Befeuchtung =
|
||
limit(P_Anteil_Befeuchtung + I_Anteil_Befeuchtung +
|
||
D_Anteil_Befeuchtung + Z_Anteil_Befeuchtung,
|
||
Regler_Befeuchtung_MIN, Regler_Befeuchtung_MAX);
|
||
}
|
||
|
||
// Berechnung Stellgrad befeuchtung Mittelwert
|
||
|
||
if (!Startup_finished) {
|
||
Stellgrad_Befeuchtung_Mittelwert = 0.0;
|
||
} else {
|
||
Stellgrad_Befeuchtung_Mittelwert =
|
||
limit(Stellgrad_Befeuchtung_Mittelwert +
|
||
(Stellgrad_Befeuchtung - Stellgrad_Befeuchtung_Mittelwert) /
|
||
(600.0 / sampling_time),
|
||
Stellgrad_Befeuchtung - 5.0 * 100.0 / Regler_Befeuchtung_Xp,
|
||
Stellgrad_Befeuchtung + 5.0 * 100.0 / Regler_Befeuchtung_Xp);
|
||
}
|
||
|
||
if (!Startup_finished) {
|
||
Stellgrad_Befeuchtung_Standby = 4.0;
|
||
} else if (!(Feuchtesprung && Counter_Feuchtesprung < 300.0)) {
|
||
Stellgrad_Befeuchtung_Standby =
|
||
limit(Stellgrad_Befeuchtung_Standby +
|
||
(Stellgrad_Befeuchtung - Stellgrad_Befeuchtung_Standby) /
|
||
(600.0 / sampling_time),
|
||
2.0, 8.0);
|
||
}
|
||
|
||
// Regelabweichung Entfeuchtung
|
||
|
||
Regelabweichung_Entfeuchtung = Regelabweichung_Feuchte;
|
||
|
||
// Gradient Regelabweichung Entfeuchtung
|
||
|
||
if (!Startup_finished) {
|
||
Regelabweichung_Entfeuchtung_Gradient = 0.0;
|
||
}
|
||
|
||
else {
|
||
Regelabweichung_Entfeuchtung_Gradient =
|
||
limit(Regelabweichung_Entfeuchtung_Gradient +
|
||
((Regelabweichung_Entfeuchtung -
|
||
Regelabweichung_Entfeuchtung_alt) *
|
||
60.0 / sampling_time -
|
||
Regelabweichung_Entfeuchtung_Gradient) /
|
||
60.0 * sampling_time,
|
||
-20.0, 5.0);
|
||
}
|
||
|
||
// Faktor Entfeuchtung
|
||
|
||
if (!Startup_finished) {
|
||
Faktor_Entfeuchtung = 5.0;
|
||
} else if (Regelabweichung_Entfeuchtung < -0.5) {
|
||
Faktor_Entfeuchtung =
|
||
std::min(Faktor_Entfeuchtung + sampling_time / 60.0, 5.0);
|
||
} else {
|
||
Faktor_Entfeuchtung = std::max(Faktor_Entfeuchtung - sampling_time, 0.2);
|
||
}
|
||
|
||
// Gegenbefeuchten Band
|
||
|
||
if (!Startup_finished || Feuchtesprung ||
|
||
(Counter_Feuchtesprung > -600.0 &&
|
||
Faktor_Gegenbefeuchten_Band == 5.0)) {
|
||
Faktor_Gegenbefeuchten_Band = 5.0;
|
||
} else if (Stellgrad_Befeuchtung_Mittelwert - Sollwert_Gegenbefeuchten <
|
||
-1.0) {
|
||
if (Regelabweichung_Kuehlung > 0.05) {
|
||
Faktor_Gegenbefeuchten_Band =
|
||
std::max(Faktor_Gegenbefeuchten_Band - sampling_time / 10.0, 0.0);
|
||
} else {
|
||
Faktor_Gegenbefeuchten_Band =
|
||
std::min(Faktor_Gegenbefeuchten_Band + sampling_time / 60.0, 5.0);
|
||
}
|
||
|
||
} else if (Stellgrad_Befeuchtung_Mittelwert - Sollwert_Gegenbefeuchten >
|
||
1.0 &&
|
||
Stellgrad_Entfeuchtung_Mittelwert < -10.0) {
|
||
if (Regelabweichung_Kuehlung < -0.05) {
|
||
Faktor_Gegenbefeuchten_Band =
|
||
std::max(Faktor_Gegenbefeuchten_Band - sampling_time / 10.0, 0.0);
|
||
} else {
|
||
Faktor_Gegenbefeuchten_Band =
|
||
std::min(Faktor_Gegenbefeuchten_Band + sampling_time / 600.0, 2.0);
|
||
}
|
||
} else {
|
||
Faktor_Gegenbefeuchten_Band =
|
||
std::max(Faktor_Gegenbefeuchten_Band - sampling_time / 60.0, 0.2);
|
||
}
|
||
|
||
// Sollwert Gegenbefeuchten für I-Anteilverschiebung
|
||
|
||
Sollwert_Gegenbefeuchten =
|
||
6.0 - 4.0 * (-Stellgrad_Entfeuchtung_Mittelwert / 100.0);
|
||
double Offset_Entfeuchtung = 0.0 * Stellgrad_Kuehlung_Mittelwert;
|
||
|
||
//(* P-Anteil Entfeuchtung *)
|
||
|
||
double P_Anteil_Entfeuchtung = 0.0;
|
||
if (!Startup_finished) {
|
||
P_Anteil_Entfeuchtung = 0.0;
|
||
} else {
|
||
P_Anteil_Entfeuchtung = 100.0 / Regler_Entfeuchtung_Xp *
|
||
Faktor_Entfeuchtung *
|
||
Regelabweichung_Entfeuchtung;
|
||
}
|
||
// I-Anteil Entfeuchtung
|
||
if (!Startup_finished) {
|
||
I_Anteil_Entfeuchtung = 0.0;
|
||
} else if (Counter_Tuer_geschlossen > 60.0) {
|
||
I_Anteil_Entfeuchtung = limit(
|
||
I_Anteil_Entfeuchtung +
|
||
100.0 / Regler_Entfeuchtung_Xp / Regler_Entfeuchtung_Tn *
|
||
sampling_time *
|
||
(Regelabweichung_Entfeuchtung +
|
||
(Stellgrad_Befeuchtung - Sollwert_Gegenbefeuchten) / 100.0 *
|
||
Regler_Befeuchtung_Xp * Theta_I_Entfeuchtung *
|
||
Faktor_Gegenbefeuchten_Band),
|
||
Regler_Entfeuchtung_I_Anteil_MIN, Regler_Entfeuchtung_I_Anteil_MAX);
|
||
}
|
||
// D-Anteil Entfeuchtung
|
||
if (!Startup_finished) {
|
||
D_Anteil_Entfeuchtung = 0.0;
|
||
} else if (Counter_Tuer_geschlossen > 0.0) {
|
||
D_Anteil_Entfeuchtung =
|
||
D_Anteil_Entfeuchtung +
|
||
(100.0 / Regler_Entfeuchtung_Xp * Regler_Entfeuchtung_Tv *
|
||
(Regelabweichung_Entfeuchtung -
|
||
Regelabweichung_Entfeuchtung_alt) /
|
||
sampling_time -
|
||
D_Anteil_Entfeuchtung) /
|
||
(Tau_Entfeuchtung_Tv / sampling_time);
|
||
}
|
||
|
||
// Begrenzung Stellgrad und I-Anteil
|
||
|
||
if ((Counter_Tuer_geschlossen < 180.0) || (Counter_Tuer_offen > 0.0)) {
|
||
Regler_Entfeuchtung_MAX = I_Anteil_Entfeuchtung;
|
||
Regler_Entfeuchtung_MIN = -100.0;
|
||
Regler_Entfeuchtung_I_Anteil_MAX = I_Anteil_Entfeuchtung;
|
||
Regler_Entfeuchtung_I_Anteil_MIN =
|
||
limit(-100.0 - P_Anteil_Entfeuchtung, Regler_Entfeuchtung_MIN,
|
||
Regler_Entfeuchtung_I_Anteil_MAX);
|
||
} else {
|
||
Regler_Entfeuchtung_MAX = 0.0;
|
||
Regler_Entfeuchtung_MIN = -100.0;
|
||
Regler_Entfeuchtung_I_Anteil_MAX = 1.5 / Regler_Entfeuchtung_Xp * 100.0;
|
||
Regler_Entfeuchtung_I_Anteil_MIN =
|
||
limit(-100.0 - P_Anteil_Entfeuchtung +
|
||
Regelabweichung_Entfeuchtung_Gradient / 20.0 * 100.0,
|
||
Regler_Entfeuchtung_MIN, Regler_Entfeuchtung_I_Anteil_MAX);
|
||
}
|
||
|
||
// Berechnung Stellgrad Entfeuchtung
|
||
|
||
if (Counter_Tuer_offen > 60.0 || !Startup_finished) {
|
||
Stellgrad_Entfeuchtung = 0.0;
|
||
} else {
|
||
Stellgrad_Entfeuchtung =
|
||
limit(P_Anteil_Entfeuchtung + I_Anteil_Entfeuchtung +
|
||
Offset_Entfeuchtung + D_Anteil_Entfeuchtung,
|
||
Regler_Entfeuchtung_MIN, Regler_Entfeuchtung_MAX);
|
||
}
|
||
|
||
// Berechnung Stellgrad entfeuchtung Mittelwert
|
||
|
||
if (!Startup_finished) {
|
||
Stellgrad_Entfeuchtung_Mittelwert = 0.0;
|
||
} else {
|
||
Stellgrad_Entfeuchtung_Mittelwert = limit(
|
||
Stellgrad_Entfeuchtung_Mittelwert +
|
||
(Stellgrad_Entfeuchtung - Stellgrad_Entfeuchtung_Mittelwert) /
|
||
(600.0 / sampling_time),
|
||
Stellgrad_Entfeuchtung - 5.0 * 100.0 / Regler_Entfeuchtung_Xp,
|
||
Stellgrad_Entfeuchtung + 5.0 * 100.0 / Regler_Entfeuchtung_Xp);
|
||
}
|
||
|
||
// PID Regler Tür
|
||
// f_PID_Door(...)
|
||
double Offset_Temperatur_Tuer;
|
||
if (Feuchtesprung) {
|
||
Offset_Temperatur_Tuer = 0.0;
|
||
} else {
|
||
Offset_Temperatur_Tuer =
|
||
2.0 * Betauungsschutz / 100.0 *
|
||
limit((90.0 + Stellgrad_Kuehlung_Mittelwert) / (90.0 - 80.0), 0.0,
|
||
1.0);
|
||
}
|
||
|
||
// Regelabweichung
|
||
if (!Tuer_offen ||
|
||
std::abs(Regelabweichung_Tuer) >
|
||
std::abs(Sollwert_Temperatur + Offset_Temperatur_Tuer -
|
||
Istwert_Temperatur_Tuer)) {
|
||
Regelabweichung_Tuer = Sollwert_Temperatur + Offset_Temperatur_Tuer -
|
||
Istwert_Temperatur_Tuer;
|
||
}
|
||
|
||
// P-Anteil
|
||
|
||
// Anti-Windup über dynamisches Integrator Clamping
|
||
|
||
double Regler_Tuer_MAX = limit(
|
||
(100.0 + Stellgrad_Kuehlung) / (100.0 - 80.0) * 100.0, 0.0, 100.0);
|
||
double Regler_Tuer_MIN = 0.0;
|
||
double Regler_Tuer_I_Anteil_MAX =
|
||
limit(100.0 - P_Anteil_Tuer, 0.0, Regler_Tuer_MAX);
|
||
double Regler_Tuer_I_Anteil_MIN = 0.0;
|
||
|
||
if (!Startup_finished) {
|
||
P_Anteil_Tuer = 0.0;
|
||
} else {
|
||
P_Anteil_Tuer = 100.0 / Regler_Tuer_Xp * Regelabweichung_Tuer;
|
||
}
|
||
|
||
// I-Anteil
|
||
if (!Startup_finished) {
|
||
I_Anteil_Tuer = 0.0;
|
||
} else if (Temperatursprung && Regelabweichung_Tuer > 0.0) {
|
||
I_Anteil_Tuer = limit(I_Anteil_Tuer, Regler_Tuer_I_Anteil_MIN,
|
||
Regler_Tuer_I_Anteil_MAX);
|
||
} else if (!Tuer_offen) {
|
||
I_Anteil_Tuer =
|
||
limit(I_Anteil_Tuer + 100.0 / Regler_Tuer_Xp / Regler_Tuer_Tn *
|
||
sampling_time * Regelabweichung_Tuer,
|
||
Regler_Tuer_I_Anteil_MIN, Regler_Tuer_I_Anteil_MAX);
|
||
}
|
||
// D-Anteil
|
||
|
||
if (!Startup_finished) {
|
||
D_Anteil_Tuer = 0.0;
|
||
} else {
|
||
D_Anteil_Tuer = D_Anteil_Tuer +
|
||
(100.0 / Regler_Tuer_Xp * Regler_Tuer_Tv *
|
||
(Regelabweichung_Tuer - Regelabweichung_Tuer_alt) /
|
||
sampling_time -
|
||
D_Anteil_Tuer) /
|
||
(Tau_Tuer_Tv / sampling_time);
|
||
}
|
||
|
||
double Stellgrad_Tuer;
|
||
// Berechnung Stellgrad Tür
|
||
if (Tuer_offen || !Startup_finished) {
|
||
Stellgrad_Tuer = limit(P_Anteil_Tuer + I_Anteil_Tuer + D_Anteil_Tuer,
|
||
Regler_Tuer_MIN, Regler_Tuer_MAX);
|
||
}
|
||
|
||
// Kennfelder Kühlung/Entfeuchtung
|
||
|
||
int Index_Ueberhitzung = 1;
|
||
while (Kennfeld_Ueberhitzung[0][Index_Ueberhitzung] < Istwert_Temperatur &&
|
||
Index_Ueberhitzung < 12) {
|
||
Index_Ueberhitzung++;
|
||
}
|
||
double Interpolation_Ueberhitzung = limit((Kennfeld_Ueberhitzung[0][Index_Ueberhitzung - 1] - Istwert_Temperatur) /
|
||
(Kennfeld_Ueberhitzung[0][Index_Ueberhitzung - 1] - Kennfeld_Ueberhitzung[0][Index_Ueberhitzung]),
|
||
0.0, 1.0);
|
||
double Skalierung_Ueberhitzung_Kennfeld_Min = Kennfeld_Ueberhitzung[1][Index_Ueberhitzung] *
|
||
(Interpolation_Ueberhitzung + Kennfeld_Ueberhitzung[1][Index_Ueberhitzung - 1]) *
|
||
(1.0 - Interpolation_Ueberhitzung);
|
||
double Skalierung_Ueberhitzung_Kennfeld_Max = Kennfeld_Ueberhitzung[2][Index_Ueberhitzung] *
|
||
(Interpolation_Ueberhitzung + Kennfeld_Ueberhitzung[2][Index_Ueberhitzung - 1]) *
|
||
(1.0 - Interpolation_Ueberhitzung);
|
||
double Sollwert_Ueberhitzung = Kennfeld_Ueberhitzung[3][Index_Ueberhitzung] *
|
||
(Interpolation_Ueberhitzung + Kennfeld_Ueberhitzung[3][Index_Ueberhitzung - 1]) *
|
||
(1.0 - Interpolation_Ueberhitzung);
|
||
|
||
//(* Entfeuchtung und Abtauung aus Kennfeld *)
|
||
int Index_Entfeuchtung = 1; // todo uj - warum nicht mit 0 starten?
|
||
while ((Kennfeld_Entfeuchtung[0][Index_Entfeuchtung] < Istwert_Temperatur) && (Index_Ueberhitzung < 12)) {
|
||
Index_Entfeuchtung++;
|
||
}
|
||
double Interpolation_Entfeuchtung = limit((Kennfeld_Entfeuchtung[0][Index_Entfeuchtung - 1] -
|
||
(Istwert_Temperatur) / (Kennfeld_Entfeuchtung[0][Index_Entfeuchtung - 1] ) -
|
||
Kennfeld_Entfeuchtung[0][Index_Entfeuchtung]),
|
||
0.0, 1.0);
|
||
double Skalierung_Entfeuchtungsventil = Kennfeld_Entfeuchtung[1][Index_Entfeuchtung] *
|
||
Interpolation_Entfeuchtung +
|
||
Kennfeld_Entfeuchtung[1][Index_Entfeuchtung - 1] *
|
||
(1.0 - Interpolation_Entfeuchtung);
|
||
double Abtauzyklus_Pause =
|
||
Kennfeld_Entfeuchtung[2][Index_Entfeuchtung] *
|
||
Interpolation_Entfeuchtung +
|
||
Kennfeld_Entfeuchtung[2][Index_Entfeuchtung - 1] *
|
||
(1.0 - Interpolation_Entfeuchtung);
|
||
double Abtauzyklus_Dauer =
|
||
Kennfeld_Entfeuchtung[3][Index_Entfeuchtung] *
|
||
Interpolation_Entfeuchtung +
|
||
Kennfeld_Entfeuchtung[3][Index_Entfeuchtung - 1] *
|
||
(1.0 - Interpolation_Entfeuchtung);
|
||
|
||
// Ende - f_PID_Door(...)
|
||
|
||
// Überhitzungsregelung
|
||
|
||
// Temperatur Verdampferausgang PT1
|
||
// f_PT1.Vapourize(...)
|
||
if (!Startup_finished) {
|
||
Istwert_Temperatur_Verdampferausgang_PT1 =
|
||
Istwert_Temperatur_Verdampferausgang;
|
||
} else {
|
||
Istwert_Temperatur_Verdampferausgang_PT1 +=
|
||
(Istwert_Temperatur_Verdampferausgang -
|
||
Istwert_Temperatur_Verdampferausgang_PT1) /
|
||
(60.0 * 4.0);
|
||
}
|
||
|
||
// Skalierung Überhitzung
|
||
if (Istwert_Temperatur_Verdampferausgang <
|
||
(Istwert_Temperatur + Sollwert_Ueberhitzung)) {
|
||
Counter_Durchzug = MIN(Counter_Durchzug + sampling_time, 10.0);
|
||
} else {
|
||
// uj-todo; template for MAX
|
||
// Counter_Durchzug = MAX(MAX(Counter_Durchzug-sampling_time,-10),0);
|
||
}
|
||
if (Counter_Durchzug >= 10.0) {
|
||
Durchzug = true;
|
||
} else if (Counter_Durchzug <= -10.0) {
|
||
Durchzug = false;
|
||
}
|
||
|
||
double Skalierung_Ueberhitzung_PT1 = Skalierung_Ueberhitzung_Kennfeld_Max;
|
||
|
||
// Magnetventil Kühlung
|
||
|
||
// Stellgrad Kühlung
|
||
|
||
if (Counter_Verdichter_aus > 60.0 && Counter_Verdichter_aus < 600.0) {
|
||
Stellgrad_Kuehlventil = 1.0;
|
||
} else if (Istwert_Temperatur > 120.0 || Counter_Kuehlung_Freigabe <= 0.0) {
|
||
Stellgrad_Kuehlventil = 0.0;
|
||
} else {
|
||
Stellgrad_Kuehlventil = MAX(-Stellgrad_Kuehlung, 0.0) *
|
||
Skalierung_Ueberhitzung_PT1 *
|
||
Counter_Kuehlung_Freigabe;
|
||
}
|
||
|
||
// Ende - f_PT1.Vapourize(...)
|
||
|
||
// PWM Generierung Kuehlventil
|
||
// bool step(double Stellgrad,double sampling_time){
|
||
|
||
// f_PWMCoolingValve.Step(...)
|
||
Kuehlventil = PWM_Kuehlventil.step(Stellgrad_Kuehlventil, sampling_time);
|
||
|
||
// Magnetventil Entfeuchtung
|
||
double T_Entfeuchtung;
|
||
if (!Startup_finished) {
|
||
T_Entfeuchtung = Istwert_Temperatur;
|
||
} else if (Entfeuchtungsventil) {
|
||
T_Entfeuchtung =
|
||
limit(T_Entfeuchtung +
|
||
((Istwert_Temperatur - T_Entfeuchtung) * U_Entfeuchtung -
|
||
P_Entfeuchtung) /
|
||
(4.0 * C_Entfeuchtung),
|
||
-30.0, Istwert_Temperatur);
|
||
} else {
|
||
T_Entfeuchtung =
|
||
limit(T_Entfeuchtung +
|
||
((Istwert_Temperatur - T_Entfeuchtung) * U_Entfeuchtung) /
|
||
(4.0 * C_Entfeuchtung),
|
||
-30.0, Istwert_Temperatur);
|
||
}
|
||
// Stellgrad Entfeuchtung
|
||
|
||
if (Istwert_Temperatur > 120.0 || Counter_Entfeuchtung_Freigabe <= 0.0) {
|
||
Stellgrad_Entfeuchtungsventil = 0.0;
|
||
} else {
|
||
Stellgrad_Entfeuchtungsventil = MAX(-Stellgrad_Entfeuchtung, 0.0) *
|
||
Skalierung_Entfeuchtungsventil *
|
||
Counter_Entfeuchtung_Freigabe;
|
||
}
|
||
|
||
// Abtauzyklus
|
||
bool Freigabe_Abtauzyklus =
|
||
Istwert_Feuchte > Sollwert_Feuchte_Absolut + 2.5;
|
||
if (!Freigabe_Abtauzyklus) {
|
||
Counter_Freigabe_Abtauzyklus = 0.0;
|
||
} else {
|
||
Counter_Freigabe_Abtauzyklus += sampling_time;
|
||
}
|
||
double Skalierung_Abtauzyklus_Dauer = 0.0;
|
||
;
|
||
if (Abtauzyklus_Pause > 0.0 && Abtauzyklus_Dauer > 0.0) {
|
||
Skalierung_Abtauzyklus_Dauer =
|
||
limit(Counter_Freigabe_Abtauzyklus /
|
||
(10.0 * (Abtauzyklus_Pause + Abtauzyklus_Dauer) * 60.0),
|
||
1.0, 5.0);
|
||
}
|
||
if (Counter_Abtauzyklus >
|
||
(Abtauzyklus_Pause + Abtauzyklus_Dauer * Skalierung_Abtauzyklus_Dauer) *
|
||
60.0) {
|
||
Counter_Abtauzyklus = 0.0;
|
||
} else if ((T_Entfeuchtung < 0.0 && Freigabe_Abtauzyklus) || Abtauzyklus) {
|
||
Counter_Abtauzyklus += sampling_time;
|
||
}
|
||
|
||
else {
|
||
Counter_Abtauzyklus = MAX(Counter_Abtauzyklus - sampling_time, 0.0);
|
||
}
|
||
Abtauzyklus = Counter_Abtauzyklus > Abtauzyklus_Pause * 60.0 &&
|
||
Abtauzyklus_Pause > 0.0;
|
||
|
||
if (Abtauzyklus) {
|
||
Stellgrad_Entfeuchtungsventil = 0.0;
|
||
}
|
||
// Ende -f_PWMCoolingValve.Step(...)
|
||
|
||
|
||
// PWM Entfeuchtungsventil
|
||
// f_PWMDeHumizeValve.Step(...)
|
||
Entfeuchtungsventil = PWM_Entfeuchtungsventil.step(
|
||
Stellgrad_Entfeuchtungsventil, sampling_time);
|
||
|
||
// Druckausgleich vor Start Verdichter
|
||
if (!Verdichter && Counter_Entfeuchtung_Freigabe > 5.0) {
|
||
Entfeuchtungsventil = true;
|
||
}
|
||
|
||
// Heizung Kessel
|
||
|
||
if (Freigabe_Heizung) {
|
||
Stellgrad_HeizungKessel =
|
||
MAX(Stellgrad_Heizung * Counter_Heizung_Freigabe, 0.0);
|
||
} else {
|
||
Stellgrad_HeizungKessel = 0.0;
|
||
}
|
||
|
||
// PWM Heizung Kessel
|
||
HeizungKessel = PWM_Heizung_Kessel.step(Stellgrad_HeizungKessel, 0.25);
|
||
|
||
// Betauungsschutz
|
||
|
||
double Stellgrad_Betauungsschutz_MAX = limit(
|
||
(90.0 + Stellgrad_Kuehlung_Mittelwert) / (90.0 - 80.0) * 100.0, 0.0,
|
||
limit((Sollwert_Temperatur - 25.0) / (-20.0 - 25.0) * Betauungsschutz,
|
||
0.0, Betauungsschutz));
|
||
|
||
if (!Startup_finished) {
|
||
Stellgrad_Betauungsschutz = 0.0;
|
||
}
|
||
|
||
// Tuerheizung
|
||
Stellgrad_HeizungTuer =
|
||
limit(Stellgrad_Tuer + Stellgrad_Betauungsschutz / 10.0, 0.0, 100.0);
|
||
|
||
HeizungTuer = PWM_Heizung_Tuer.step(Stellgrad_HeizungTuer, 0.25);
|
||
|
||
// Heizung Kesselrand
|
||
|
||
Stellgrad_HeizungKesselrand =
|
||
limit(Stellgrad_Tuer *
|
||
limit(1.0 + Betauungsschutz / 100.0 * 2.0 *
|
||
(90.0 + Stellgrad_Kuehlung_Mittelwert) /
|
||
(90.0 - 80.0),
|
||
1.0, 2.0) +
|
||
Stellgrad_Betauungsschutz,
|
||
0.0, 100.0);
|
||
|
||
// Ende - f_PWMDeHumizeValve.Step(...)
|
||
|
||
|
||
// PWM Kesselrand
|
||
// Ende - f_PWMKesselRand.Step(...)
|
||
HeizungKesselrand = PWM_Heizung_Kesselrand.step(Stellgrad_HeizungKesselrand, 0.25);
|
||
// Ende - f_PWMKesselRand.Step(...)
|
||
|
||
{
|
||
// Binder Feuchtemodul
|
||
|
||
// Sperrsignal Feuchtemodul
|
||
|
||
bool Sperrsignal_Feuchte = false;
|
||
|
||
// Gradient Feuchtemodul
|
||
|
||
if (!Startup_finished) {
|
||
Temperatur_Feuchtemodul_Gradient = 0;
|
||
} else {
|
||
Temperatur_Feuchtemodul_Gradient +=
|
||
((Temperatur_Feuchtemodul - Temperatur_Feuchtemodul_alt) * 60.0 *
|
||
4.0 -
|
||
Temperatur_Feuchtemodul_Gradient) /
|
||
(4.0 * 10.0);
|
||
}
|
||
|
||
Sollwert_Temperatur_Feuchtemodul =
|
||
Sollwert_Temperatur_Feuchtemodul_MIN +
|
||
Stellgrad_Feuchtemodul_Mittelwert / 100.0 *
|
||
(Sollwert_Temperatur_Feuchtemodul_MAX -
|
||
Sollwert_Temperatur_Feuchtemodul_MIN);
|
||
|
||
// Offset Stellgrad Feuchtemodul
|
||
|
||
double Temperatur_Feuchtemodul_Standby =
|
||
Sollwert_Temperatur_Feuchtemodul -
|
||
(Stellgrad_Entfeuchtung_Mittelwert - 0.0) / (-100.0 - 0.0) * 60.0;
|
||
double Standby_Feuchtemodul =
|
||
limit((Temperatur_Feuchtemodul_Standby - Temperatur_Feuchtemodul) /
|
||
10.0 * 5.0,
|
||
0.0, 5.0);
|
||
|
||
// Stellgrad Feuchtemodul
|
||
Stellgrad_Feuchtemodul = limit(
|
||
Stellgrad_Befeuchtung +
|
||
2.0 * limit(Stellgrad_Befeuchtung - Stellgrad_Feuchtemodul_PT1,
|
||
-2.0, 2.0) +
|
||
Stellgrad_Feuchtemodul_Nachfuellen,
|
||
0.0, 100.0);
|
||
|
||
// Begrenzung Temperatur Feuchtemodul über Temperatur
|
||
double Stellgrad_Feuchtemodul_MAX_Temperatur = limit(
|
||
(Temperatur_Feuchtemodul_MAX - Temperatur_Feuchtemodul) / 40.0 * 100.0,
|
||
0.0, 100.0);
|
||
|
||
double Temperatur_Feuchtemodul_Gradient_MAX = 10.0;
|
||
if (Temperatur_Feuchtemodul < 90.0) {
|
||
Temperatur_Feuchtemodul_Gradient_MAX = 10.0;
|
||
} else {
|
||
Temperatur_Feuchtemodul_Gradient_MAX = limit(
|
||
20.0 -
|
||
(Temperatur_Feuchtemodul - (Temperatur_Feuchtemodul_MAX - 60.0)) /
|
||
60.0 * 20.0 -
|
||
Stellgrad_Feuchtemodul_MAX / 100.0 * 10.0,
|
||
5.0, 20.0);
|
||
}
|
||
|
||
double Stellgrad_Feuchtemodul_MAX_adaptiv = 10.0;
|
||
if (!Startup_finished) {
|
||
Stellgrad_Feuchtemodul_MAX_adaptiv = 10.0;
|
||
} else if (Temperatur_Feuchtemodul < 80.0) {
|
||
Stellgrad_Feuchtemodul_MAX_adaptiv = 10.0;
|
||
} else if (Stellgrad_Feuchtemodul + 20.0 >
|
||
Stellgrad_Feuchtemodul_MAX_adaptiv &&
|
||
Stellgrad_Feuchtemodul_MAX_adaptiv <
|
||
Stellgrad_Feuchtemodul_MAX_Temperatur &&
|
||
Temperatur_Feuchtemodul_Gradient <
|
||
2.0 * Temperatur_Feuchtemodul_Gradient_MAX &&
|
||
!Sperrsignal_Feuchte) {
|
||
Stellgrad_Feuchtemodul_MAX_adaptiv =
|
||
limit(Stellgrad_Feuchtemodul_MAX_adaptiv +
|
||
20.0 *
|
||
limit((Temperatur_Feuchtemodul_Gradient_MAX -
|
||
Temperatur_Feuchtemodul_Gradient) /
|
||
Temperatur_Feuchtemodul_Gradient_MAX,
|
||
-2.0, 1.0) /
|
||
(60.0 * 4.0),
|
||
0.0, Stellgrad_Feuchtemodul_MAX_Temperatur);
|
||
} else {
|
||
Stellgrad_Feuchtemodul_MAX_adaptiv =
|
||
limit(Stellgrad_Feuchtemodul_MAX_adaptiv - 5.0 / (60.0 * 4.0), 10.0,
|
||
Stellgrad_Feuchtemodul_MAX_Temperatur);
|
||
}
|
||
|
||
// Begrenzung Stellgrad_Feuchtemodul
|
||
|
||
Stellgrad_Feuchtemodul_MAX =
|
||
MIN(Stellgrad_Feuchtemodul_MAX_Temperatur - 5.0,
|
||
Stellgrad_Feuchtemodul_MAX_adaptiv + Stellgrad_Feuchtemodul_Boost);
|
||
|
||
Stellgrad_Feuchtemodul =
|
||
MIN(Stellgrad_Feuchtemodul, Stellgrad_Feuchtemodul_MAX);
|
||
|
||
// Stellgrad Feuchtemodul Boost
|
||
|
||
if (!Startup_finished || Temperatur_Feuchtemodul < 80.0) {
|
||
Stellgrad_Feuchtemodul_Boost = 0.0;
|
||
} else if (Stellgrad_Feuchtemodul <
|
||
Stellgrad_Feuchtemodul_MAX_adaptiv - 10.0) {
|
||
Stellgrad_Feuchtemodul_Boost =
|
||
MIN(Stellgrad_Feuchtemodul_Boost + 10.0 / 60.0 * sampling_time,
|
||
2.0 * Stellgrad_Feuchtemodul_MAX_Temperatur);
|
||
} else {
|
||
Stellgrad_Feuchtemodul_Boost = MAX(
|
||
Stellgrad_Feuchtemodul_Boost - (Stellgrad_Feuchtemodul + 10.0 -
|
||
Stellgrad_Feuchtemodul_MAX_adaptiv) /
|
||
60.0 * sampling_time,
|
||
0.0);
|
||
}
|
||
if (!Startup_finished) {
|
||
Stellgrad_Feuchtemodul_PT1 = Stellgrad_Feuchtemodul;
|
||
} else if (is_valid(Stellgrad_Feuchtemodul_PT1)) {
|
||
Stellgrad_Feuchtemodul_PT1 = 0.0;
|
||
} else {
|
||
Stellgrad_Feuchtemodul_PT1 =
|
||
Stellgrad_Feuchtemodul_PT1 +
|
||
(Stellgrad_Feuchtemodul - Stellgrad_Feuchtemodul_PT1) / (4.0 * 30.0);
|
||
}
|
||
|
||
// Nachfüllen Befeuchtungsmodul
|
||
|
||
double Stellgrad_Nachfuellen_Temperatur = 0.0;
|
||
double Skalierung_Nachfuellen_Temperatur_P_Anteil = 0.0;
|
||
double Skalierung_Nachfuellen_Temperatur_D_Anteil = 0.0;
|
||
|
||
if (!Startup_finished) {
|
||
Stellgrad_Nachfuellen_Temperatur = 0.0;
|
||
Skalierung_Nachfuellen_Temperatur_D_Anteil = 0.0;
|
||
Skalierung_Nachfuellen_Temperatur_D_Anteil = 0.0;
|
||
Skalierung_Nachfuellen_Temperatur_I_Anteil = 0.0;
|
||
} else {
|
||
Stellgrad_Nachfuellen_Temperatur = limit(
|
||
MAX(Temperatur_Feuchtemodul - Sollwert_Temperatur_Feuchtemodul, 0.0) *
|
||
2.0 +
|
||
MIN(Temperatur_Feuchtemodul - Sollwert_Temperatur_Feuchtemodul,
|
||
0.0) *
|
||
1.0,
|
||
-20.0, 50.0);
|
||
Skalierung_Nachfuellen_Temperatur_P_Anteil = limit(
|
||
MAX(Temperatur_Feuchtemodul - Sollwert_Temperatur_Feuchtemodul, 0.0) /
|
||
20.0 +
|
||
MIN(Temperatur_Feuchtemodul - Sollwert_Temperatur_Feuchtemodul,
|
||
0.0) /
|
||
40.0,
|
||
-0.2, 5.0);
|
||
Skalierung_Nachfuellen_Temperatur_D_Anteil =
|
||
limit(Temperatur_Feuchtemodul_Gradient / 10.0, -5.0, 5.0);
|
||
Skalierung_Nachfuellen_Temperatur_I_Anteil =
|
||
limit(Skalierung_Nachfuellen_Temperatur_I_Anteil +
|
||
limit(Skalierung_Nachfuellen_Temperatur_P_Anteil +
|
||
Skalierung_Nachfuellen_Temperatur_D_Anteil,
|
||
-0.2, 25.0) *
|
||
sampling_time / 1200.0,
|
||
0.0, 5.0);
|
||
}
|
||
double Stellgrad_Nachfuellen = 0.0;
|
||
Stellgrad_Feuchtemodul_Nachfuellen = 0.0;
|
||
|
||
if (Temperatur_Feuchtemodul > Temperatur_Feuchtemodul_MAX &&
|
||
Temperatur_Feuchtemodul_Gradient > 0.0) {
|
||
Stellgrad_Nachfuellen = 20.0;
|
||
Stellgrad_Feuchtemodul_Nachfuellen = 0.0;
|
||
} else {
|
||
Stellgrad_Nachfuellen = limit(
|
||
((Stellgrad_Feuchtemodul_PT1 - Stellgrad_Feuchtemodul_Nachfuellen) *
|
||
(MAX(Skalierung_Nachfuellen_Temperatur_P_Anteil +
|
||
Skalierung_Nachfuellen_Temperatur_D_Anteil,
|
||
0.0) +
|
||
Skalierung_Nachfuellen_Temperatur_I_Anteil) +
|
||
Stellgrad_Nachfuellen_Temperatur) *
|
||
2.0 * 7.9681 / Durchflussmenge_Einlassventil_Feuchtemodul,
|
||
0.0, 100.0);
|
||
Stellgrad_Feuchtemodul_Nachfuellen =
|
||
0.5 * Stellgrad_Nachfuellen *
|
||
Durchflussmenge_Einlassventil_Feuchtemodul / 60.0 * 4.19 * 75.0 /
|
||
600.0;
|
||
}
|
||
//(* Entleeren des Kessels *)
|
||
bool Entleeren_Kessel = false;
|
||
if (Startup_finished && Temperatur_Feuchtemodul < 70.0) {
|
||
Entleeren_Kessel = Counter_Entleeren_Kessel < 60.0;
|
||
Counter_Entleeren_Kessel += sampling_time;
|
||
} else {
|
||
Counter_Entleeren_Kessel = 0.0;
|
||
Entleeren_Kessel = false;
|
||
}
|
||
|
||
//(* Abschlämmen des Kessels *)
|
||
Abschlaemmintegral =
|
||
Abschlaemmintegral + 0.1 * Durchflussmenge_Einlassventil_Feuchtemodul /
|
||
Durchflussmenge_Abschlaemmventil_Feuchtemodul *
|
||
Stellgrad_Nachfuellen / 100.0 * sampling_time;
|
||
|
||
if (Entleeren_Kessel) {
|
||
Abschlaemmventil = true;
|
||
Stellgrad_Abschlaemmventil_zyklisch = 100.0;
|
||
} else {
|
||
Counter_Zyklus_Abschlaemmventil += sampling_time;
|
||
if (Abschlaemmintegral > 0.25 && Temperatur_Feuchtemodul_Gradient < 0.0) {
|
||
Abschlaemmventil = true;
|
||
Stellgrad_Abschlaemmventil_zyklisch = 2.5;
|
||
Counter_Zyklus_Abschlaemmventil = 0.0;
|
||
Abschlaemmintegral -= 0.25;
|
||
} else {
|
||
Abschlaemmventil = false;
|
||
if (Counter_Zyklus_Abschlaemmventil >= 10.0) {
|
||
Stellgrad_Abschlaemmventil_zyklisch = 0.0;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Stellgrad_Feuchtemodul = 2.0;
|
||
|
||
// PWM Befeuchtungsmodul
|
||
HeizungFeuchtemodul =
|
||
PWM_Heizung_Feuchtemodul.step(Stellgrad_Feuchtemodul, 0.25);
|
||
// PWM Nachfüllen
|
||
Nachfuellen = PWM_Nachfuellen.step(Stellgrad_Nachfuellen, 0.25);
|
||
|
||
// Abwassermanagement
|
||
if (!Entleerbehaelter_Unten || !Entleerbehaelter_Oben || Entleeren_Kessel) {
|
||
Counter_Nachlauf_Entleeren = 10.0;
|
||
Counter_Pause_Entleeren += sampling_time;
|
||
if (Counter_Pause_Entleeren > 30.0) {
|
||
Counter_Pause_Entleeren = 0.0;
|
||
}
|
||
|
||
} else {
|
||
Counter_Nachlauf_Entleeren =
|
||
MAX(Counter_Nachlauf_Entleeren - sampling_time, 0.0);
|
||
Counter_Pause_Entleeren = 0.0;
|
||
}
|
||
bool Entleeren_Pause = false;
|
||
Entleeren = Counter_Nachlauf_Entleeren > 0.0;
|
||
Entleeren_Pause = Counter_Pause_Entleeren > 27.0;
|
||
Entleerpumpe = Entleeren && !Entleeren_Pause;
|
||
|
||
if (!Startup_finished) {
|
||
Zyklus_Entleeren_Mittelwert = 600.0;
|
||
} else if (Entleeren && !Entleeren_alt) {
|
||
Zyklus_Entleeren_Mittelwert = limit(
|
||
Zyklus_Entleeren_Mittelwert +
|
||
(Counter_Zyklus_Entleeren - Zyklus_Entleeren_Mittelwert) / 10.0,
|
||
10.0, 3600.0);
|
||
Counter_Zyklus_Entleeren = 0.0;
|
||
} else {
|
||
Counter_Zyklus_Entleeren += sampling_time;
|
||
}
|
||
|
||
if (Steuerkontakt_Standby || Istwert_Temperatur > 110.0) {
|
||
Counter_Kuehlung_Freigabe = 0.0;
|
||
} else {
|
||
if (Stellgrad_Kuehlung < 0.0 || Stellgrad_Heizung < 2.0 ||
|
||
Counter_Tuer_geschlossen < 300.0) {
|
||
Counter_Kuehlung_Freigabe =
|
||
MIN(Counter_Kuehlung_Freigabe + sampling_time / 10.0, 1.0);
|
||
} else {
|
||
Counter_Kuehlung_Freigabe =
|
||
MAX(Counter_Kuehlung_Freigabe - sampling_time / 300.0, 0.0);
|
||
}
|
||
}
|
||
Freigabe_Kuehlung = Counter_Kuehlung_Freigabe >= 1.0 ||
|
||
(Freigabe_Kuehlung && Counter_Kuehlung_Freigabe > 0.0);
|
||
// * Freigabe Kühlung *)
|
||
|
||
// (* Freigabe Entfeuchtung *)
|
||
if (Steuerkontakt_Standby || Istwert_Temperatur > 110.0) {
|
||
Counter_Entfeuchtung_Freigabe = 0.0;
|
||
} else {
|
||
if (Stellgrad_Entfeuchtung < 0.0 || Stellgrad_Befeuchtung < 2.0 ||
|
||
Counter_Tuer_geschlossen < 300.0) {
|
||
Counter_Entfeuchtung_Freigabe =
|
||
MIN(Counter_Entfeuchtung_Freigabe + sampling_time / 10.0, 10.0);
|
||
} else {
|
||
Counter_Entfeuchtung_Freigabe =
|
||
MAX(Counter_Entfeuchtung_Freigabe - sampling_time / 300.0, 0.0);
|
||
}
|
||
}
|
||
Freigabe_Entfeuchtung =
|
||
Counter_Entfeuchtung_Freigabe >= 1.0 ||
|
||
(Freigabe_Entfeuchtung && Counter_Entfeuchtung_Freigabe > 0.0);
|
||
|
||
// (* Freigabe Heizung *)
|
||
if (Steuerkontakt_Standby || Istwert_Temperatur > 110.0) {
|
||
Counter_Heizung_Freigabe = 0.0;
|
||
} else {
|
||
if (Stellgrad_Heizung < 0.0 || Stellgrad_Kuehlung > -2.0 ||
|
||
Counter_Tuer_geschlossen < 300.0) {
|
||
Counter_Heizung_Freigabe =
|
||
MIN(Counter_Heizung_Freigabe + sampling_time / 10.0, 10.0);
|
||
} else {
|
||
Counter_Heizung_Freigabe =
|
||
MAX(Counter_Heizung_Freigabe - sampling_time / 300.0, 0.0);
|
||
}
|
||
}
|
||
Freigabe_Heizung = Counter_Heizung_Freigabe >= 1.0 ||
|
||
(Freigabe_Heizung && Counter_Heizung_Freigabe > 0.0);
|
||
// (* Freigabe Befeuchtung *)
|
||
if (Steuerkontakt_Standby || Istwert_Temperatur > 110.0) {
|
||
Counter_Befeuchtung_Freigabe = 0.0;
|
||
} else {
|
||
if (Stellgrad_Befeuchtung < 0.0 || Stellgrad_Entfeuchtung > -2.0 ||
|
||
Counter_Tuer_geschlossen < 300.0) {
|
||
Counter_Befeuchtung_Freigabe =
|
||
MIN(Counter_Befeuchtung_Freigabe + sampling_time / 10.0, 10.0);
|
||
} else {
|
||
Counter_Befeuchtung_Freigabe =
|
||
MAX(Counter_Befeuchtung_Freigabe - sampling_time / 300.0, 0.0);
|
||
}
|
||
}
|
||
Freigabe_Befeuchtung =
|
||
Counter_Befeuchtung_Freigabe >= 1.0 ||
|
||
(Freigabe_Befeuchtung && Counter_Befeuchtung_Freigabe > 0.0);
|
||
|
||
// Verdichterabscaltung
|
||
|
||
if (!Startup_finished) {
|
||
Drehzahl_Verdichter_adaptiv = Drehzahl_Verdichter_MAX;
|
||
} else if (Temperatursprung) {
|
||
Drehzahl_Verdichter_adaptiv =
|
||
MAX(Drehzahl_Verdichter_Kuehlung, Drehzahl_Verdichter_Entfeuchtung);
|
||
} else if (is_valid(Stellgrad_Kuehlung)) {
|
||
Drehzahl_Verdichter_adaptiv =
|
||
limit(Drehzahl_Verdichter_adaptiv +
|
||
(-Stellgrad_Kuehlung - 25.0) / 100.0 *
|
||
(Drehzahl_Verdichter_MAX - Drehzahl_Verdichter_MIN) /
|
||
(4.0 * 600.0),
|
||
Drehzahl_Verdichter_MIN, Drehzahl_Verdichter_MAX);
|
||
}
|
||
|
||
Drehzahl_Verdichter_Kuehlung =
|
||
Drehzahl_Verdichter_MIN +
|
||
(MAX(-Stellgrad_Kuehlung_Mittelwert, -Stellgrad_Kuehlung) - 30.0) /
|
||
(90.0 - 30.0) * (Drehzahl_Verdichter_MAX - Drehzahl_Verdichter_MIN);
|
||
Drehzahl_Verdichter_Entfeuchtung =
|
||
Drehzahl_Verdichter_MIN +
|
||
0.5 *
|
||
(MAX(-Stellgrad_Entfeuchtung_Mittelwert, -Stellgrad_Entfeuchtung) -
|
||
50.0) /
|
||
(90.0 - 50.0) * (Drehzahl_Verdichter_MAX - Drehzahl_Verdichter_MIN);
|
||
|
||
if (Verdichter) {
|
||
Drehzahl_Verdichter =
|
||
limit(MAX(Drehzahl_Verdichter_Kuehlung,
|
||
MAX(Drehzahl_Verdichter_Entfeuchtung,
|
||
Drehzahl_Verdichter_adaptiv)),
|
||
Drehzahl_Verdichter_MIN, Drehzahl_Verdichter_MAX);
|
||
} else {
|
||
Drehzahl_Verdichter = 1000.0;
|
||
}
|
||
|
||
Stellgrad_Verdichter =
|
||
Drehzahl_Verdichter / Drehzahl_Verdichter_MAX * 100.0 * (160.0 / 200.0);
|
||
/*
|
||
(* -------------------- *)
|
||
(* Verflüssigerregelung *)
|
||
(* -------------------- *) */
|
||
|
||
Verfluessiger = Verfluessiger &&
|
||
((Drehzahl_Verdichter_adaptiv - Drehzahl_Verdichter_MIN) / ((Drehzahl_Verdichter_MAX - Drehzahl_Verdichter_MIN) < 0.30) &&
|
||
(-Stellgrad_Kuehlung_Mittelwert < 30.0) &&
|
||
(-Stellgrad_Entfeuchtung_Mittelwert < 60.0) || ((Drehzahl_Verdichter_adaptiv - Drehzahl_Verdichter_MIN) / (Drehzahl_Verdichter_MAX - Drehzahl_Verdichter_MIN) < 0.20) &&
|
||
(-Stellgrad_Kuehlung_Mittelwert < 20.0) &&
|
||
-Stellgrad_Entfeuchtung_Mittelwert < 50.0);
|
||
|
||
}// Ende Feuchtemodul
|
||
|
||
// ----------------------------------------
|
||
// Werte die auf Veränderung geprüft werden
|
||
// ----------------------------------------
|
||
Sammelalarm_quittiert_alt = Sammelalarm_quittiert;
|
||
Istwert_Temperatur_alt = Istwert_Temperatur;
|
||
Regelabweichung_Temperatur_alt = Regelabweichung_Temperatur;
|
||
Sollwert_Temperatur_alt = Sollwert_Temperatur;
|
||
Istwert_Feuchte_alt = Istwert_Feuchte;
|
||
Regelabweichung_Feuchte_alt_alt = Regelabweichung_Feuchte_alt;
|
||
Regelabweichung_Feuchte_alt = Regelabweichung_Feuchte;
|
||
Sollwert_Feuchte_alt = Sollwert_Feuchte;
|
||
Durchzug_alt = Durchzug;
|
||
Regelabweichung_Tuer_alt = Regelabweichung_Tuer;
|
||
HeizungFeuchtemodul_alt = HeizungFeuchtemodul;
|
||
Regelabweichung_Befeuchtung_alt_alt = Regelabweichung_Befeuchtung_alt;
|
||
Regelabweichung_Entfeuchtung_alt = Regelabweichung_Entfeuchtung;
|
||
|
||
|
||
|
||
// ----------------
|
||
// Rückgabewerte
|
||
// ----------------
|
||
// F_Outputs out{};
|
||
|
||
binOut.bool_out01 = (std::abs((Sollwert_Temperatur - Istwert_Temperatur)) > Temperaturband); // du nutzt Temperaturband-Alarm
|
||
// separat; hier nur Beispiel
|
||
binOut.bool_out02 = (std::abs((Sollwert_Feuchte - Istwert_Feuchte)) > Feuchteband) &&
|
||
(!Befeuchtung_aus) && (!Entfeuchtung_aus);
|
||
binOut.bool_out03 = Befeuchtung_aus || Entfeuchtung_aus;
|
||
binOut.bool_out07 = (!Status_Uebertemperatur) &&
|
||
(!(std::abs(Istwert_Ueberwachungsregler - Istwert_Temperatur) > 20.0));
|
||
alarmOut.Startup = Startup_finished;
|
||
|
||
binOut.bool_out09 = HeizungKessel;
|
||
binOut.bool_out11 = HeizungTuer;
|
||
binOut.bool_out12 = HeizungKesselrand;
|
||
binOut.bool_out13 = Verfluessiger;
|
||
binOut.bool_out14 = Nachfuellen;
|
||
binOut.bool_out16 = Entleerpumpe;
|
||
binOut.bool_out17 = HeizungFeuchtemodul;
|
||
binOut.bool_out20 = Abschlaemmventil;
|
||
binOut.bool_out18 = Kuehlventil;
|
||
binOut.bool_out19 = Entfeuchtungsventil;
|
||
binOut.bool_out21 = Verdichter;
|
||
binOut.bool_out23 = !Sammelalarm_quittiert;
|
||
|
||
analogOut.real_out01 = Istwert_Temperatur;
|
||
analogOut.real_out02 = Istwert_Temperatur;
|
||
analogOut.real_out04 = Istwert_Temperatur;
|
||
analogOut.real_out05 = limit(Istwert_Feuchte, 0.0, 100.0);
|
||
analogOut.real_out06 = limit(Istwert_Feuchte, 0.0, 100.0);
|
||
analogOut.real_out07 = Sollwert_Feuchte;
|
||
analogOut.real_out08 = limit(Istwert_Feuchte, 0.0, 100.0);
|
||
analogOut.real_out09 = Stellgrad_HeizungKessel;
|
||
analogOut.real_out10 = Stellgrad_Pumpe;
|
||
analogOut.real_out11 = Stellgrad_HeizungTuer;
|
||
analogOut.real_out12 = Stellgrad_HeizungKesselrand;
|
||
analogOut.real_out13 = Stellgrad_Feuchtemodul;
|
||
analogOut.real_out14 = Stellgrad_Abschlaemmventil_zyklisch;
|
||
analogOut.real_out16 = Temperatur_Feuchtemodul;
|
||
analogOut.Stellgrad_Feuchtemodul = Stellgrad_Feuchtemodul;
|
||
analogOut.real_out18 = Stellgrad_Kuehlventil;
|
||
analogOut.real_out19 = Stellgrad_Entfeuchtungsventil;
|
||
analogOut.real_out20 = Stellgrad_Luefter;
|
||
analogOut.real_out21 = Stellgrad_Verdichter;
|
||
analogOut.real_out25 = Schaltwert_Uebertemperatur;
|
||
analogOut.real_out26 = Schaltwert_Untertemperatur;
|
||
analogOut.Stellgrad_Heizung = Stellgrad_Heizung;
|
||
analogOut.Stellgrad_Kuehlung = Stellgrad_Kuehlung;
|
||
analogOut.Stellgrad_Befeuchtung = Stellgrad_Befeuchtung;
|
||
analogOut.Stellgrad_Entfeuchtung = Stellgrad_Entfeuchtung;
|
||
analogOut.Counter_Tuer = Counter_Tuer_offen;
|
||
|
||
// alarms (wie ST)
|
||
alarmOut.alarm_01 = Bandalarm_Temperatur;
|
||
alarmOut.alarm_02 = Bandalarm_Feuchte;
|
||
alarmOut.alarm_03 = Tueralarm;
|
||
alarmOut.alarm_04 = false;
|
||
alarmOut.alarm_05 = false;
|
||
alarmOut.alarm_06 = Alarm_Wasser_Befeuchtungsmodul && !Befeuchtung_aus;
|
||
alarmOut.alarm_07 = Alarm_Abwasser_Befeuchtungsmodul;
|
||
alarmOut.alarm_08 = (Alarm_Heizung_Befeuchtungsmodul || Alarm_PT100_Befeuchtungsmodul) &&
|
||
!Befeuchtung_aus;
|
||
|
||
// alarm_09..alarm_15 sind im ST mit Selbsthaltung/Quittierung etc.:
|
||
alarmOut.alarm_09 = (((Istwert_Temperatur_Tuer < -50.0) || (Istwert_Temperatur_Tuer > 120.0)) &&
|
||
Startup_finished) ||(alarm_09 && Sammelalarm_quittiert);
|
||
|
||
alarmOut.alarm_10 = (std::abs(Istwert_Ueberwachungsregler - Istwert_Temperatur) > 20.0) ||
|
||
((((Istwert_Ueberwachungsregler < -50.0) ||
|
||
(Istwert_Ueberwachungsregler > 120.0) && Startup_finished))) ||
|
||
(alarm_10 && Sammelalarm_quittiert);
|
||
|
||
alarmOut.alarm_11 =
|
||
Status_Uebertemperatur || StatusQuittierung_Uebertemperatur;
|
||
alarmOut.alarm_12 =
|
||
Status_Untertemperatur || StatusQuittierung_Untertemperatur;
|
||
|
||
alarmOut.alarm_13 = (((Istwert_Temperatur_Verdampferausgang < -50.0) ||
|
||
(Istwert_Temperatur_Verdampferausgang > 120.0)) &&
|
||
Startup_finished) ||
|
||
(alarm_13 && Sammelalarm_quittiert);
|
||
|
||
alarmOut.alarm_14 =
|
||
(Counter_Wasserkanister_leer > 10.0 && Startup_finished) ||
|
||
(alarm_14 && Sammelalarm_quittiert);
|
||
|
||
alarmOut.alarm_15 =
|
||
((analogInput.real_in11 > Sollwert_Feuchte_Max && !Befeuchtung_aus) ||
|
||
(analogInput.real_in11 < Sollwert_Feuchte_Min && !Entfeuchtung_aus)) ||
|
||
(alarm_15 && Sammelalarm_quittiert);
|
||
|
||
// Selbsthaltung der Alarm-Bits (wie ST-OR alarm_x ...)
|
||
alarm_09 = alarmOut.alarm_09;
|
||
alarm_10 = alarmOut.alarm_10;
|
||
alarm_13 = alarmOut.alarm_13;
|
||
alarm_14 = alarmOut.alarm_14;
|
||
alarm_15 = alarmOut.alarm_15;
|
||
|
||
// return out;
|
||
}
|
||
|
||
private:
|
||
// ===== ST: VAR CONSTANT =====
|
||
static constexpr double sampling_time = 0.25;
|
||
|
||
static constexpr std::array<std::array<double, 13>, 4> Kennfeld_Ueberhitzung{
|
||
{// 0: Temperatur
|
||
std::array<double, 13>{-20.0, -10.0, 0.0, 10.0, 20.0, 30.0, 40.0, 50.0,
|
||
60.0, 70.0, 80.0, 90.0, 100.0},
|
||
// 1: Skalierung Min
|
||
std::array<double, 13>{0.01, 0.02, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7,
|
||
0.8, 0.9, 1.0, 1.0},
|
||
// 2: Skalierung Max
|
||
std::array<double, 13>{0.01, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0,
|
||
1.0, 1.0, 1.0},
|
||
// 3: Sollwert Überhitzung
|
||
std::array<double, 13>{-6.0, -8.0, -10.0, -8.0, -6.0, -8.0, -10.0, -12.0,
|
||
-16.0, -20.0, -24.0, -28.0, -32.0}}};
|
||
static constexpr std::array<std::array<double, 13>, 4> Kennfeld_Entfeuchtung{
|
||
{// 0: Temperatur
|
||
std::array<double, 13>{-20.0, -10.0, 0.0, 10.0, 20.0, 30.0, 40.0, 50.0,
|
||
60.0, 70.0, 80.0, 90.0, 100.0},
|
||
// 1: Skalierung Entfeuchtung
|
||
std::array<double, 13>{0.08, 0.08, 0.08, 0.10, 0.12, 0.14, 0.16, 0.18,
|
||
0.20, 0.22, 0.24, 0.26, 0.28},
|
||
// 2: Abtauzyklus Pause
|
||
std::array<double, 13>{120.0, 120.0, 120.0, 120.0, 120.0, 90.0, 60.0,
|
||
60.0, 60.0, 0.0, 0.0, 0.0, 0.0},
|
||
// 3: Abtauzyklus Dauer
|
||
std::array<double, 13>{60.0, 60.0, 60.0, 30.0, 20.0, 10.0, 8.0, 4.0, 2.0,
|
||
0.0, 0.0, 0.0, 0.0}}};
|
||
|
||
// Kennfelder (nur die, die oben genutzt werden; den Rest kannst du genauso
|
||
// hinzufügen)
|
||
static constexpr std::array<double, 13> Kennfeld_Regler_Heizung_Xp{
|
||
0.2, 0.5, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
|
||
static constexpr std::array<double, 13> Kennfeld_Regler_Kuehlung_Xp{
|
||
0.1, 0.1, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.0};
|
||
static constexpr std::array<std::array<double, 9>, 9>
|
||
Kennfeld_Regler_Befeuchtung_Xp{
|
||
{std::array<double, 9>{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03,
|
||
0.02},
|
||
std::array<double, 9>{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03,
|
||
0.02},
|
||
std::array<double, 9>{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03,
|
||
0.02},
|
||
std::array<double, 9>{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03,
|
||
0.02},
|
||
std::array<double, 9>{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03,
|
||
0.02},
|
||
std::array<double, 9>{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03,
|
||
0.02},
|
||
std::array<double, 9>{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03,
|
||
0.02},
|
||
std::array<double, 9>{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03,
|
||
0.02},
|
||
std::array<double, 9>{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03,
|
||
0.02}}};
|
||
static constexpr std::array<std::array<double, 9>, 9>
|
||
Kennfeld_Regler_Entfeuchtung_Xp{
|
||
{std::array<double, 9>{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25,
|
||
0.20},
|
||
std::array<double, 9>{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25,
|
||
0.20},
|
||
std::array<double, 9>{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25,
|
||
0.20},
|
||
std::array<double, 9>{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25,
|
||
0.20},
|
||
std::array<double, 9>{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25,
|
||
0.20},
|
||
std::array<double, 9>{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25,
|
||
0.20},
|
||
std::array<double, 9>{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25,
|
||
0.20},
|
||
std::array<double, 9>{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25,
|
||
0.20},
|
||
std::array<double, 9>{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25,
|
||
0.20}}};
|
||
|
||
static constexpr std::array<std::array<double, 11>, 3>
|
||
Kennfeld_Sollwert_Feuchte_Limit{
|
||
{std::array<double, 11>{0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100},
|
||
std::array<double, 11>{80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80},
|
||
std::array<double, 11>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}};
|
||
|
||
// Zeitkonstanten etc.
|
||
static constexpr double Tau_Heizung_Tv = 10.0;
|
||
|
||
// Faktoren
|
||
static constexpr double F_Xp_Heizung = 3.8;
|
||
static constexpr double F_Xp_Kuehlung = 33.6;
|
||
static constexpr double F_Xp_Befeuchtung_BINDER = 131.0;
|
||
static constexpr double F_Xp_Entfeuchtung = 100.0;
|
||
static constexpr double F_Xp_Tuer = 10.0;
|
||
|
||
// ===== ST: VAR (Zustände / Merker) =====
|
||
// (ich halte hier nur die, die im übersetzten Teil genutzt werden; den Rest
|
||
// kannst du 1:1 ergänzen)
|
||
double Istwert_Temperatur{};
|
||
double Istwert_Temperatur_alt{};
|
||
double Sollwert_Temperatur{};
|
||
double Sollwert_Temperatur_alt{};
|
||
double Sollwert_Gegenbefeuchten = 0.0;
|
||
double Regelabweichung_Befeuchtung_alt = 0.0;
|
||
double P_Anteil_Befeuchtung = 0.0;
|
||
double Counter_Entfeuchtung_Freigabe = 0.0;
|
||
bool Freigabe_Entfeuchtung = false;
|
||
double Counter_Heizung_Freigabe = 0.0;
|
||
bool Freigabe_Heizung = false;
|
||
double Counter_Befeuchtung_Freigabe = 0.0;
|
||
bool Freigabe_Befeuchtung = false;
|
||
bool Abtauzyklus = false;
|
||
double Counter_Zyklus_Entleeren = 0.0;
|
||
double Drehzahl_Verdichter_Kuehlung = 0.0;
|
||
double Drehzahl_Verdichter_Entfeuchtung = 0.0;
|
||
double Drehzahl_Verdichter = 0.0;
|
||
|
||
/*PWM(double zyklus_min, double zyklus_max, double initial_zykluszeit = -1.0)
|
||
noexcept : Zyklus(0.0), Ausgabe(0.0), Zykluszeit((initial_zykluszeit > 0.0) ?
|
||
initial_zykluszeit : zyklus_max), Zyklus_MIN(zyklus_min),
|
||
Zyklus_MAX(zyklus_max)
|
||
{}
|
||
|
||
bool step(double Stellgrad,double sampling_time,double Zyklus_MIN,double
|
||
Zyklus_MAX){*/
|
||
PWM PWM_Heizung_Kessel = {10.0, 600.0, 0.0};
|
||
PWM PWM_Heizung_Tuer = {10.0, 600.0, 0.0};
|
||
PWM PWM_Nachfuellen = {10.0, 600.0, 0.0};
|
||
PWM PWM_Heizung_Kesselrand = {10.0, 600.0, 0.0};
|
||
PWM PWM_Heizung_Feuchtemodul = {10.0, 600.0, 0.0};
|
||
PWM PWM_Kuehlventil = {10.0, 600.0, 0.0};
|
||
PWM PWM_Entfeuchtungsventil = {10.0, 600.0, 0.0};
|
||
|
||
double Istwert_Ueberwachungsregler{};
|
||
std::uint32_t Modus_Ueberwachungsregler{};
|
||
double Offset_Ueberwachungsregler{};
|
||
double Klasse_Ueberwachungsregler{};
|
||
bool Wasserkanister_leer{};
|
||
double Regler_Tuer_Tn = 700.0;
|
||
double Regler_Tuer_Tv = 60.0;
|
||
double Tau_Tuer_Tv = 60.0;
|
||
double Regler_Entfeuchtung_MAX = 0.0;
|
||
double Regler_Entfeuchtung_MIN = 0.0;
|
||
double Regler_Entfeuchtung_I_Anteil_MAX = 0.0;
|
||
double Regler_Entfeuchtung_I_Anteil_MIN = 0.0;
|
||
bool Freigabe_Kuehlung = false;
|
||
double Sollwert_Temperatur_Feuchtemodul_MIN = 110.0;
|
||
double Sollwert_Temperatur_Feuchtemodul_MAX = 130.0;
|
||
double Zyklus_Entleeren_Mittelwert = 600.0;
|
||
|
||
double Grenzwert_Uebertemperatur{};
|
||
double Schaltwert_Uebertemperatur{};
|
||
bool Status_Uebertemperatur{};
|
||
std::uint32_t Counter_Status_Uebertemperatur{};
|
||
bool StatusQuittierung_Uebertemperatur{};
|
||
|
||
double Grenzwert_Untertemperatur{};
|
||
double Schaltwert_Untertemperatur{};
|
||
bool Status_Untertemperatur{};
|
||
std::uint32_t Counter_Status_Untertemperatur{};
|
||
bool StatusQuittierung_Untertemperatur{};
|
||
|
||
double Istwert_Feuchte{};
|
||
double Istwert_Feuchte_alt{};
|
||
double Sollwert_Feuchte{};
|
||
double Sollwert_Feuchte_alt{};
|
||
double Counter_Entleeren_Kessel{};
|
||
|
||
bool Regelung_AUS{};
|
||
double Counter_Regelung_AUS{};
|
||
bool Steuerkontakt_Standby{};
|
||
bool Sammelalarm{};
|
||
bool Sammelalarm_quittiert{};
|
||
bool Sammelalarm_quittiert_alt{};
|
||
double Regler_Kuehlung_Tv = 5.0;
|
||
double Tau_Kuehlung_Tv = 30.0;
|
||
double Theta_I_Kuehlung = 1.0;
|
||
|
||
// Feuchte absolut
|
||
double p_H2Omax_Sollwert{};
|
||
double p_H2Omax_Istwert{};
|
||
double Taupunkt_Istwert{};
|
||
double Sollwert_Feuchte_Absolut{};
|
||
double Sollwert_Temperatur_Feuchtemodul{};
|
||
double Counter_Kuehlung_Freigabe = 0.0;
|
||
|
||
// Tür
|
||
bool Tuer_offen{};
|
||
double Counter_Tuer_offen{};
|
||
double Counter_Tuer_geschlossen{};
|
||
double Istwert_Temperatur_Tuer{};
|
||
double Regelabweichung_Tuer{};
|
||
double Regelabweichung_Tuer_alt{};
|
||
double Abschlaemmintegral = 0.0;
|
||
double Standby_Feuchtemodul = 0.0;
|
||
double Regelabweichung_Befeuchtung_alt_alt = 0.0;
|
||
double Regelabweichung_Entfeuchtung_alt = 0.0;
|
||
double Durchflussmenge_Einlassventil_Feuchtemodul = 400.0;
|
||
double Durchflussmenge_Abschlaemmventil_Feuchtemodul = 1500.0;
|
||
|
||
// Startup / reset
|
||
std::uint32_t Counter_reset_flag{};
|
||
bool Startup_finished{};
|
||
|
||
// Feuchte limit
|
||
std::uint16_t Index_Sollwert_Feuchte_Limit{};
|
||
double Interpolation_Sollwert_Feuchte_Limit{};
|
||
double Sollwert_Feuchte_Min{};
|
||
double Sollwert_Feuchte_Max{};
|
||
|
||
// Abschaltung Feuchte-Regler
|
||
bool Sollwert_Feuchte_aktiv{};
|
||
bool Steuerkontakt_Befeuchtung_aus{};
|
||
bool Steuerkontakt_Entfeuchtung_aus{};
|
||
bool Befeuchtung_aus{};
|
||
bool Entfeuchtung_aus{};
|
||
double Sollwert_Gegenheizen = 2.0;
|
||
// Parameter Indizes
|
||
std::uint16_t Index_Feuchte{};
|
||
std::uint16_t Index_Temperatur{};
|
||
std::uint16_t Index_Temperatur_ohne_Feuchte{};
|
||
|
||
// Reglerparameter
|
||
double Regler_Heizung_Xp{};
|
||
double Regler_Kuehlung_Xp{};
|
||
double Regler_Befeuchtung_Xp{};
|
||
double Regler_Entfeuchtung_Xp{};
|
||
double Regler_Tuer_Xp{};
|
||
double Regler_Befeuchtung_Tv = 30.0;
|
||
double Regler_Befeuchtung_Tn = 100.0;
|
||
double Regler_Befeuchtung_Tz = 1200.0;
|
||
double Tau_Befeuchtung_Tv = 10.0;
|
||
double Tau_Befeuchtung_Tz = 5.0;
|
||
|
||
// Regelkern Temperatur
|
||
double Sollwert_Temperatur_MIN{};
|
||
double Sollwert_Temperatur_MAX{};
|
||
|
||
double Regelabweichung_Temperatur{};
|
||
double Regelabweichung_Temperatur_alt{};
|
||
double Regelabweichung_Temperatur_Mittelwert{};
|
||
double Standardregelabweichung_Temperatur{};
|
||
double Regelabweichung_Temperatur_Gradient{};
|
||
double Standardgradient_Regelabweichung_Temperatur{};
|
||
double Zykluszeit_Regelabweichung_Temperatur{};
|
||
double Amplitude_Regelabweichung_Temperatur{};
|
||
double Zykluszeit_Regelabweichung_Heizung{};
|
||
double Zykluszeit_Regelabweichung_Kuehlung{};
|
||
double Regelabweichung_Kuehlung_Gradient{};
|
||
double Regelabweichung_Kuehlung_alt{};
|
||
double Faktor_Kuehlung{};
|
||
double Faktor_Gegenheizen_Band{};
|
||
double I_Anteil_Kuehlung{};
|
||
double D_Anteil_Kuehlung{};
|
||
double Regelabweichung_Befeuchtung_Gradient{};
|
||
double I_Anteil_Befeuchtung{};
|
||
double Istwert_Temperatur_Verdampferausgang_PT1 = 0.0;
|
||
double D_Anteil_Befeuchtung{};
|
||
bool Temperatursprung{};
|
||
double Counter_Temperatursprung{};
|
||
double Faktor_Entfeuchtung{};
|
||
double Faktor_Gegenbefeuchten_Band = 5.0;
|
||
double I_Anteil_Entfeuchtung = 0.0;
|
||
double D_Anteil_Entfeuchtung = 0.0;
|
||
double I_Anteil_Tuer = 0.0;
|
||
double P_Anteil_Tuer;
|
||
double Regler_Heizung_MIN{};
|
||
double Regler_Heizung_MAX{};
|
||
double Regler_Heizung_I_Anteil_MIN{};
|
||
double Regler_Heizung_I_Anteil_MAX{};
|
||
double P_Anteil_Heizung{};
|
||
double I_Anteil_Heizung{};
|
||
double D_Anteil_Heizung{};
|
||
double Stellgrad_Heizung{};
|
||
double Stellgrad_Heizung_Mittelwert{};
|
||
double Regelabweichung_Entfeuchtung_Gradient = 0.0;
|
||
double D_Anteil_Tuer = 0.0;
|
||
double Counter_Verdichter_aus = 0.0;
|
||
double Counter_Freigabe_Abtauzyklus = 0.0;
|
||
double Counter_Abtauzyklus;
|
||
double Stellgrad_Feuchtemodul_MAX{};
|
||
double Skalierung_Nachfuellen_Temperatur_I_Anteil{};
|
||
double Counter_Zyklus_Abschlaemmventil = 0.0;
|
||
const double Regler_Kuehlung_Tn = 200.0;
|
||
|
||
double Stellgrad_Feuchtemodul_Boost{};
|
||
const double Temperatur_Feuchtemodul_MAX = 200.0;
|
||
|
||
// Feuchte - nur Platzhalter (weil spätere Ausdrücke referenzieren)
|
||
double Regelabweichung_Feuchte{};
|
||
double Regelabweichung_Feuchte_alt{};
|
||
double Regelabweichung_Feuchte_alt_alt{};
|
||
double Regelabweichung_Feuchte_Mittelwert{};
|
||
double Standardregelabweichung_Feuchte{};
|
||
double Regelabweichung_Feuchte_Gradient{};
|
||
double Standardgradient_Regelabweichung_Feuchte{};
|
||
double Zykluszeit_Regelabweichung_Feuchte{};
|
||
double Amplitude_Regelabweichung_Feuchte{};
|
||
bool Feuchtesprung{};
|
||
double Counter_Feuchtesprung = 0.0;
|
||
double Offset_Regelabweichung_Befeuchtung{};
|
||
double Offset_Regelabweichung_Entfeuchtung{};
|
||
double Stellgrad_Kuehlung{};
|
||
double Stellgrad_Kuehlung_Mittelwert{};
|
||
double Stellgrad_Befeuchtung{};
|
||
double Stellgrad_Befeuchtung_Mittelwert{};
|
||
double Stellgrad_Befeuchtung_Standby{};
|
||
double Stellgrad_Entfeuchtung{};
|
||
double Stellgrad_Entfeuchtung_Mittelwert{};
|
||
double Z_Anteil_Befeuchtung{};
|
||
|
||
// Aktoren/Signale (Defaults, bis restliche Logik ergänzt ist)
|
||
bool HeizungKessel{};
|
||
double Stellgrad_HeizungKessel{};
|
||
bool HeizungTuer{};
|
||
double Stellgrad_HeizungTuer{};
|
||
bool HeizungKesselrand{};
|
||
double Stellgrad_HeizungKesselrand{};
|
||
bool Verfluessiger{};
|
||
bool Nachfuellen{};
|
||
bool Entleerpumpe{};
|
||
bool HeizungFeuchtemodul{};
|
||
bool HeizungFeuchtemodul_alt{};
|
||
bool Abschlaemmventil{};
|
||
double Stellgrad_Abschlaemmventil_zyklisch{};
|
||
bool Kuehlventil{};
|
||
double Stellgrad_Kuehlventil{};
|
||
bool Entfeuchtungsventil{};
|
||
double Stellgrad_Entfeuchtungsventil{};
|
||
bool Verdichter{};
|
||
double Stellgrad_Verdichter{};
|
||
double Stellgrad_Pumpe{};
|
||
double Stellgrad_Luefter{};
|
||
double Stellgrad_Betauungsschutz{};
|
||
double Temperatur_Feuchtemodul_Gradient = 0.0;
|
||
double Stellgrad_Feuchtemodul_MAX_adaptiv = 0.0;
|
||
double Counter_Nachlauf_Entleeren = 0.0;
|
||
double Counter_Pause_Entleeren = 0.0;
|
||
|
||
// “Durchzug” (wird später in Überhitzungslogik gesetzt)
|
||
bool Durchzug{};
|
||
bool Durchzug_alt{};
|
||
double Counter_Durchzug{};
|
||
|
||
// Befeuchtungsmodul Zustände (Platzhalter, damit “Werte die auf Veränderung
|
||
// geprüft werden” passt)
|
||
double Temperatur_Feuchtemodul{};
|
||
double Temperatur_Feuchtemodul_alt{};
|
||
double Stellgrad_Feuchtemodul{};
|
||
double Stellgrad_Feuchtemodul_Mittelwert{};
|
||
double Stellgrad_Feuchtemodul_PT1{};
|
||
double Stellgrad_Feuchtemodul_Nachfuellen{};
|
||
bool Entleeren{};
|
||
bool Entleeren_alt{};
|
||
bool Entleerbehaelter_Oben{};
|
||
bool Entleerbehaelter_Unten{};
|
||
double Counter_Wasserkanister_leer{};
|
||
double Regler_Entfeuchtung_Tv = 5.0;
|
||
double Regler_Entfeuchtung_Tn = 200.0;
|
||
double Tau_Entfeuchtung_Tv = 60.0;
|
||
double Theta_I_Entfeuchtung = 0.1;
|
||
double C_Entfeuchtung = 200.0;
|
||
double U_Entfeuchtung = 0.4;
|
||
double P_Entfeuchtung = 500.0;
|
||
double Regler_Entfeuchten_I_Anteil_MIN = 0.0;
|
||
double Drehzahl_Verdichter_MIN = 1800.0;
|
||
double Drehzahl_Verdichter_MAX = 4500.0;
|
||
double Drehzahl_Verdichter_adaptiv = 0.0;
|
||
|
||
// Alarmbits mit Selbsthaltung
|
||
bool alarm_09{};
|
||
bool alarm_10{};
|
||
bool alarm_13{};
|
||
bool alarm_14{};
|
||
bool alarm_15{};
|
||
bool Alarm_Wasser_Befeuchtungsmodul{};
|
||
bool Alarm_Abwasser_Befeuchtungsmodul{};
|
||
bool Alarm_PT100_Befeuchtungsmodul{};
|
||
bool Alarm_Heizung_Befeuchtungsmodul{};
|
||
bool Bandalarm_Temperatur{};
|
||
bool Bandalarm_Feuchte{};
|
||
bool Tueralarm{};
|
||
};
|
||
|
||
// namespace UTILITY_FUNCTIONS
|
||
|
||
// double PT100_ResistanceToTemperature_Linear(double R)
|
||
// {
|
||
// constexpr double R0 = 100.0;
|
||
// constexpr double alpha = 0.00385; // IEC-Näherung
|
||
|
||
// return (R - R0) / (R0 * alpha);
|
||
// }
|
||
|
||
class PT1 {
|
||
public:
|
||
PT1() = default;
|
||
void initialize(double fs, double t_cutoff) {
|
||
fs_ = fs;
|
||
ts_ = 1 / fs_;
|
||
double f_cutoff = 1. / t_cutoff;
|
||
tau_ = 1 / (2 * PI_CONST * f_cutoff);
|
||
lambda_ = 2 * tau_ / ts_;
|
||
b0_ = k_ / (1. + lambda_);
|
||
b1_ = k_ / (1. + lambda_);
|
||
a0_ = (1. - lambda_) / (1. + lambda_);
|
||
};
|
||
|
||
double step(double x) {
|
||
|
||
double y = b0_ * x + s1_;
|
||
// s1 = b1*x - a1*y
|
||
s1_ = b1_ * x - a0_ * y;
|
||
return y;
|
||
};
|
||
|
||
private:
|
||
double s1_ = 0.;
|
||
double fs_ = 1.;
|
||
double ts_ = 1.;
|
||
double tau_ = 1.;
|
||
double a0_ = 0.;
|
||
double b0_ = 0.;
|
||
double b1_ = 0.;
|
||
double k_ = 1.;
|
||
double lambda_ = 1.;
|
||
};
|
||
|
||
#ifdef BUILD_TARGET_SOM
|
||
namespace appengine::state {
|
||
class IStateVariable;
|
||
}
|
||
#endif
|
||
|
||
#ifdef BUILD_TARGET_SOM
|
||
class Controller : public ControllerBase {
|
||
public:
|
||
bool initialize(const char *configFilePath,
|
||
appengine::IAppLogic *appLogic) override;
|
||
void step() override;
|
||
void terminate() override;
|
||
|
||
private:
|
||
appengine::IAppLogic *appLogic_{nullptr};
|
||
|
||
// Beispiel: du wirst für diese ST-Logik sehr viele StateVars mappen;
|
||
// hier nur exemplarisch:
|
||
std::shared_ptr<appengine::state::IStateVariable> tempVariable_;
|
||
std::shared_ptr<appengine::state::IStateVariable> tempSetPointVariable_;
|
||
|
||
// TODO: bool_inXX / real_inXX / bool_outXX / real_outXX / alarm_XX als
|
||
// StateVariables holen (oder je nach AppEngine: arrays/IO mapping)
|
||
|
||
ClimateAlgorithm algo_{};
|
||
PT1 FILTERED_TEMP{};
|
||
PT1 FILTER_TUER{};
|
||
// Eingänge
|
||
std::shared_ptr<appengine::state::IStateVariable> const_duty_cycle_;
|
||
std::shared_ptr<appengine::state::IStateVariable> const_freq_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Wasserstand_Oben_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Wasserstand_Unten_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Fuellstand_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Tuer_Variable_;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Verdampferausgang_;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Befeuchtungsmodul_;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Verdichter_on_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Startup_;
|
||
std::shared_ptr<appengine::state::IStateVariable> CounterTuer_;
|
||
|
||
// ausgänge
|
||
std::vector<appengine::asio::SignalConnectionPtr> subscriptions_{};
|
||
std::shared_ptr<appengine::state::IStateVariable> Heizung_Bef_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> MV_Kuehlung_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Abschlaemmen_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Entleerpumpe_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Heizung_Kesselrand_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable>
|
||
Freigabe_Verfluessigerluefter_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Heizung_Innenraum_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Heizung_Tuer_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Uebertemperatur_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> MV_Entfeuchtung_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> MV_Druckluft_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable>
|
||
Ansteuerung_Wassereinlass_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable>
|
||
Ansteuerung_Verdichter_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Verdichter_Duty_Config;
|
||
std::shared_ptr<appengine::state::IStateVariable> Luefter_Innenraum_Config_;
|
||
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Stellgrad_Heizung;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Stellgrad_Kuehlung;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Stellgrad_Befeuchtung;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Stellgrad_Entfeuchtung;
|
||
// Regelgrößen
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Sollwert_Temperatur_;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Temperatur_Variable_;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Sollwert_Feuchte_;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Feuchte_Variable_;
|
||
|
||
// std::vector<appengine::asio::SignalConnectionPtr> subscriptions_{};
|
||
};
|
||
|
||
extern "C" BINDER_SIMULINK_API_EXPORT ControllerBase *create();
|
||
|
||
#else
|
||
class Controller {
|
||
|
||
public:
|
||
bool initialize(const char *configFilePath);
|
||
void step();
|
||
void terminate();
|
||
|
||
private:
|
||
#if 0
|
||
appengine::IAppLogic *appLogic_{nullptr};
|
||
|
||
// Beispiel: du wirst für diese ST-Logik sehr viele StateVars mappen;
|
||
// hier nur exemplarisch:
|
||
std::shared_ptr<appengine::state::IStateVariable> tempVariable_;
|
||
std::shared_ptr<appengine::state::IStateVariable> tempSetPointVariable_;
|
||
|
||
// TODO: bool_inXX / real_inXX / bool_outXX / real_outXX / alarm_XX als StateVariables holen
|
||
// (oder je nach AppEngine: arrays/IO mapping)
|
||
|
||
ClimateAlgorithm algo_{};
|
||
PT1 FILTERED_TEMP{} ;
|
||
PT1 FILTER_TUER{};
|
||
// Eingänge
|
||
std::shared_ptr<appengine::state::IStateVariable> const_duty_cycle_;
|
||
std::shared_ptr<appengine::state::IStateVariable> const_freq_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Wasserstand_Oben_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Wasserstand_Unten_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Fuellstand_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Tuer_Variable_;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Verdampferausgang_;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Befeuchtungsmodul_;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Verdichter_on_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Startup_;
|
||
std::shared_ptr<appengine::state::IStateVariable> CounterTuer_;
|
||
|
||
// ausgänge
|
||
std::vector<appengine::asio::SignalConnectionPtr> subscriptions_{};
|
||
std::shared_ptr<appengine::state::IStateVariable> Heizung_Bef_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> MV_Kuehlung_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Abschlaemmen_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Entleerpumpe_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Heizung_Kesselrand_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Freigabe_Verfluessigerluefter_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Heizung_Innenraum_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Heizung_Tuer_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Uebertemperatur_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> MV_Entfeuchtung_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> MV_Druckluft_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Ansteuerung_Wassereinlass_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Ansteuerung_Verdichter_Config_;
|
||
std::shared_ptr<appengine::state::IStateVariable> Verdichter_Duty_Config;
|
||
std::shared_ptr<appengine::state::IStateVariable> Luefter_Innenraum_Config_;
|
||
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Stellgrad_Heizung;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Stellgrad_Kuehlung;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Stellgrad_Befeuchtung;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Stellgrad_Entfeuchtung;
|
||
// Regelgrößen
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Sollwert_Temperatur_;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Temperatur_Variable_;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Sollwert_Feuchte_;
|
||
std::shared_ptr<appengine::state::IStateVariable> SV_Feuchte_Variable_;
|
||
|
||
//std::vector<appengine::asio::SignalConnectionPtr> subscriptions_{};
|
||
#endif
|
||
};
|
||
|
||
#endif
|