… Funktionen, die für verschiedene Varianten der Luftzuführung benutzt werden können!

🔧 Funktionale Anforderungen – Übersicht
1. Zuluftbegrenzte Raumregelung
Regelgröße: Rückluft-Temperatur und -Feuchte.

Bei zu kalter Zuluft:

Temperatur-Sollwert wird angehoben:
S_neu = S_alt + Steigung × (T_start - T_zuluft)

Bei zu feuchter Zuluft:

Feuchte-Sollwert wird abgesenkt:
S_neu = S_alt + Steigung × (H_start - H_zuluft)

2. Raumbegrenzte Zuluftregelung
Regelgröße: Zulufttemperatur und -feuchte.

- Bei zu warmer Raumluft (T > T_start1):

- Zuluft-Sollwert wird abgesenkt

- Bei zu kalter Raumluft (T < T_start2):

- Zuluft-Sollwert wird angehoben

- Bei zu trockener Raumluft:

- Zuluft-Feuchte-Sollwert wird angehoben

3. Grenzwertverhalten
Sollwertverschiebungen werden durch definierte Min-/Max-Werte begrenzt.

4. Laststart-Funktion
Wenn (T_ist - T_soll) > Laststart, dann → Stand-By-Gerät starten

5. I-Anteil für variable Sollwerte (Svar)
Integrationsintervall: 5 Minuten

- Svar_n+1 = Svar_n + dS

- dS = (S_fix - Istwert) × Integrationsfaktor
------------------------------------------------------------------
📦 C-Strukturen (Headerdatei regler.h):
------------------------------------------------------------------
#ifndef REGLER_H
#define REGLER_H

typedef struct {
    float sollwert_fix;         // Fester Sollwert
    float sollwert_var;         // Variabler Sollwert (Svar)
    float startwert;            // Starttemperatur oder -feuchte
    float istwert;              // Aktueller Messwert
    float steigung;             // Faktor für Sollwertanpassung
    float min_sollwert;         // Untere Grenze
    float max_sollwert;         // Obere Grenze
    float integrationsfaktor;   // 0.0 - 0.1 (z.B. 0.02 = 2%)
    uint32_t laststart_timer;   // Zeitgeber für I-Anteil
    float laststart_diff;       // Startdifferenz für Stand-By
    bool standby_aktiv;         // Stand-By-Gerät aktiv
} ReglerZustand;

#endif
------------------------------------------------------------------
⚙️ Pseudocode / Algorithmusbeispiel (z. B. in regelung.c):
------------------------------------------------------------------
#include "regler.h"

float berechneSollwertMitBegrenzung(ReglerZustand *r) {
    float delta = r->startwert - r->istwert;
    float s_neu = r->sollwert_fix + r->steigung * delta;

    if (s_neu > r->max_sollwert) s_neu = r->max_sollwert;
    if (s_neu < r->min_sollwert) s_neu = r->min_sollwert;

    return s_neu;
}

void berechneSvar(ReglerZustand *r, uint32_t aktuelleZeit) {
    if (aktuelleZeit - r->laststart_timer >= 300000) { // 5 min
        float dS = (r->sollwert_fix - r->istwert) * r->integrationsfaktor;
        r->sollwert_var += dS;
        if (r->sollwert_var > r->max_sollwert) r->sollwert_var = r->max_sollwert;
        if (r->sollwert_var < r->min_sollwert) r->sollwert_var = r->min_sollwert;
        r->laststart_timer = aktuelleZeit;
    }
}

bool pruefeLaststart(ReglerZustand *r) {
    return (r->laststart_diff > 0.0f && (r->istwert - r->sollwert_fix) > r->laststart_diff);
}
------------------------------------------------------------------
🧪 Beispielaufruf in Task (FreeRTOS):
------------------------------------------------------------------
void RegelTask(void *argument) {
    ReglerZustand regler = {
        .sollwert_fix = 22.0f,
        .steigung = 0.5f,
        .startwert = 18.0f,
        .min_sollwert = 20.0f,
        .max_sollwert = 24.0f,
        .integrationsfaktor = 0.02f,
        .laststart_diff = 1.5f,
        .laststart_timer = HAL_GetTick()
    };

    for (;;) {
        regler.istwert = sensor_get_rueckluft_temp(); // z. B. 17.5 °C
        float s_neu = berechneSollwertMitBegrenzung(&regler);
        berechneSvar(&regler, HAL_GetTick());

        if (pruefeLaststart(&regler)) {
            standby_geraet_starten();
        }

        regelventil_steuern(s_neu); // oder regler.sollwert_var

        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}
------------------------------------------------------------------
So könnte die Regelung dafür aussehen:
------------------------------------------------------------------
/* raumregelung_controller.h */
#------------------------------------------------------------------
ifndef RAUMREGELUNG_CONTROLLER_H
#define RAUMREGELUNG_CONTROLLER_H

#include <stdbool.h>
#include <stdint.h>

typedef struct {
    float sollwert_fix;         // Fester Sollwert
    float sollwert_var;         // Variabler Sollwert (Svar)
    float startwert1;           // Erster Startwert (z.B. für Raum > T1)
    float startwert2;           // Zweiter Startwert (z.B. für Raum < T2)
    float istwert;              // Aktueller Messwert (z. B. Raumtemperatur)
    float steigung;             // Faktor für Sollwertanpassung
    float min_sollwert;         // Untere Grenze
    float max_sollwert;         // Obere Grenze
    float integrationsfaktor;   // 0.0 - 0.1 (z.B. 0.02 = 2%)
    uint32_t laststart_timer;   // Zeitgeber für I-Anteil
    float laststart_diff;       // Startdifferenz für Stand-By
    bool standby_aktiv;         // Stand-By-Gerät aktiv
} ReglerZustand;

float berechneSollwertMitBegrenzung(ReglerZustand *r);
float berechneSollwert_Raumbegrenzung(ReglerZustand *r);
void berechneSvar(ReglerZustand *r, uint32_t aktuelleZeit);
bool pruefeLaststart(ReglerZustand *r);

#endif // RAUMREGELUNG_CONTROLLER_H
------------------------------------------------------------------
/* raumregelung_controller.c */
------------------------------------------------------------------
#include "raumregelung_controller.h"

float berechneSollwertMitBegrenzung(ReglerZustand *r) {
    float delta = r->startwert1 - r->istwert;
    float s_neu = r->sollwert_fix + r->steigung * delta;

    if (s_neu > r->max_sollwert) s_neu = r->max_sollwert;
    if (s_neu < r->min_sollwert) s_neu = r->min_sollwert;

    return s_neu;
}

float berechneSollwert_Raumbegrenzung(ReglerZustand *r) {
    float s_neu = r->sollwert_fix;

    if (r->istwert > r->startwert1) {
        float delta = r->istwert - r->startwert1;
        s_neu -= r->steigung * delta; // Sollwert absenken
    } else if (r->istwert < r->startwert2) {
        float delta = r->startwert2 - r->istwert;
        s_neu += r->steigung * delta; // Sollwert anheben
    }

    if (s_neu > r->max_sollwert) s_neu = r->max_sollwert;
    if (s_neu < r->min_sollwert) s_neu = r->min_sollwert;

    return s_neu;
}

void berechneSvar(ReglerZustand *r, uint32_t aktuelleZeit) {
    if ((aktuelleZeit - r->laststart_timer) >= 300000) { // 5 Minuten in ms
        float dS = (r->sollwert_fix - r->istwert) * r->integrationsfaktor;
        r->sollwert_var += dS;
        if (r->sollwert_var > r->max_sollwert) r->sollwert_var = r->max_sollwert;
        if (r->sollwert_var < r->min_sollwert) r->sollwert_var = r->min_sollwert;
        r->laststart_timer = aktuelleZeit;
    }
}

bool pruefeLaststart(ReglerZustand *r) {
    return (r->laststart_diff > 0.0f && (r->istwert - r->sollwert_fix) > r->laststart_diff);
}
------------------------------------------------------------------
/* regel_task.h */
------------------------------------------------------------------
#ifndef REGEL_TASK_H
#define REGEL_TASK_H

void RegelTask(void *argument);

#endif // REGEL_TASK_H
------------------------------------------------------------------
/* Beispiel in regel_task.c */
------------------------------------------------------------------
#include "raumregelung_controller.h"
#include "cmsis_os.h"
#include "main.h"

extern float sensor_get_rueckluft_temp(void);
extern float sensor_get_raum_temp(void);
extern void regelventil_steuern(float sollwert);
extern void standby_geraet_starten(void);

void RegelTask(void *argument) {
    ReglerZustand regler = {
        .sollwert_fix = 22.0f,
        .sollwert_var = 22.0f,
        .steigung = 0.5f,
        .startwert1 = 26.0f, // obere Raumgrenze
        .startwert2 = 20.0f, // untere Raumgrenze
        .min_sollwert = 18.0f,
        .max_sollwert = 24.0f,
        .integrationsfaktor = 0.02f,
        .laststart_diff = 1.5f,
        .laststart_timer = HAL_GetTick(),
        .standby_aktiv = false
    };

    for (;;) {
        regler.istwert = sensor_get_raum_temp();
        float s_neu = berechneSollwert_Raumbegrenzung(&regler);
        berechneSvar(&regler, HAL_GetTick());

        if (pruefeLaststart(&regler)) {
            standby_geraet_starten();
        }

        regelventil_steuern(s_neu); // Oder regler.sollwert_var
        osDelay(1000);
    }
}
------------------------------------------------------------------