[DISKUSSION] [V4.5] Entwicklung einer Batterie-Steuerung (work-in-progress)

[AndererStefan]

Ahhh Fehler gefunden, es lag nicht direkt an der Logik. Die Lade/Entlademodi heißen in MQTT bei diesem Gerät Input und Output mode. Wennndie Logik charge und discharge schickt kann das natürlich nicht funktionieren. Die Verwirrung wird perfekt wenn man es in der Visu rihtig gemacht hat.

@StefanW : DANKE, dass man Logik, Visu und alles auch mal eben per Handy von unterwegs machen kann!
Es ist zwar fummelig klein und manches geht nur im Quermodus (ihr empfehlt min. ein Tablet, daher alles fein) aber es geht gut.


VG Stefan

[pbm]

1) Kann ich mit dem TWS aus der Leistung die Energie integrieren? Gibt es da eine fertige Logik?

schau dir diese Custom-Logik mal an: viewtopic.php?p=60153&hilit=integral#p60153

[AndererStefan]

Moin,

habt ihr eine Idee, wie ich vernüftig in der Logik ein „Notaus“ umsetze?

Mein Ziel ist bei einem Ausfall des Messwerts vom Stromzähler/Smartmeter, das Laden- und Entladen auf 0 zu setzen und gegen „wiedereinschalten“ zu blockieren.

Der häufigste Eintrittsfall wird vermutlich ein Geräteneustart, Strom- oder Netzwerkausfall sein. Ein Freigabe Button in der Visu wäre daher sinnvoll.

Ich habe derzeit einen Watchdog auf Basis eines Monoflops. Es tickt ein Timer runter der mit jedem Trigger durch den Messwert resettet wird. Läuft der Timer ab, wird eine Variable als false gesetzt. Ist die Variable false wird am Ende des Skriptes Lade- und Entladeleistung mit 0 überschrieben.

Mir fehlt noch die „Sicherung gegen wiedereinschalten.“ Kann ich aus der Logik heraus die Logik anhalten wie mit dem pause-Button?

Ich habe auch schon einen Inhibit-Eingang und einem „Break-Block“ am Anfang des Codes. Der Eingang wird über die Visu gesteuert. Wäre es klug aus dem Skript heraus auf den Inhibit-Eingang zu schreiben (Zirkelbezug)?

VG
Stefan

[AndererStefan]

N'abend,

dann beantworte ich mir die Frage mal selber:
Ich nutze eine Statemachine für die Unterscheidung der Betriebsmodi Standby, Laden und Entladen. Nach etwas Überlegen kam ich dann auch darauf, dass es am übersichtlichsten und nachvolziehbarsten wäre, die Statemachine einfach um einen Zustand "Fehler" zu ergänzen.

Ich halte den aktuellen Stand der Logik nun für Fortgeschritten genug, um den hier zu teilen. Die Logik ist von einem LLM entwickelt, aber ich habe (im Rahmen meiner Möglichkeiten) den gesamten Code geprüft, nachvollzogen und getestet. Ich kann aber trotz aller Sorgfalt nicht ausschließen, dass darin noch Fehler enthalten sind. Der Code ist auch über die Zeit gewachsen und daher von der Struktur/Nomenklatur nicht ganz optimal. Da jede größere Änderung auch wieder potenzielle Fehler einbauen kann, habe ich auf größere "Aufräumaktionen" verzichtet.

Funktionsbeschreibung:
Ziel ist die Steuerung einer AC-gekoppelten Batterie (über MQTT) um diese mit PV-Überschuss zu laden und nachts ohne PV-Produktion zu entladen um den Netzbezug zu reduzieren. Ziel war mit einer möglichst einfachen Logik und wenig Aufwand/Invest einen vernüftigen Effekt zu erzielen. Wenn meine Abschätzungen passen, bekomme ich auf diese Weise ca. 270 Zyklen pro Jahr hin, was zu einer Amortisation in 6-7 Jahren führt und dem guten Gefühl, immer etwas Notfallstrom gespeichert zu haben.

Die Steuerung ist grundsätzlich universell gedacht, aber drei Aspekte waren bei der Konzeption maßgeblich:
1.) Die PV-Anlage hat einen im Verhältnis zur Batterie sehr hohe Produktionsleistung und die Batterie ist auf die nächtliche Grundlast dimensioniert.
2.) Der Messwert am Bilanzpunkt (Zähler) misst nur im Minutentakt. Daraus ergibt sich die Implikation immer auf Einspeiseüberschuss und einen Restbezug zu regeln um auf "der sicheren Seite zu liegen" anstelle auf 0-Einspeisung/Bezug.
3.) Niedrige Lade- und Entladeleistungen haben einen schlechten Wirkungsgrad. Bevor die Batterie in den ineffizienzen Bereichen läuft, lieber einspeisen, bzw. Strom beziehen. Wegen 1.) verliere ich dadurch wenig bis nichts.

Die Regelung erfolgt gedämpft: Um hektische Schwankungen und Übersteuern zu reduzieren, wird die Lade-/Entladeleistung bei jedem Ausführungszyklus schrittweise erhöht. Fällt der Überschuss oder der Bedarf jedoch plötzlich weg, wird die Leistung sofort reduziert, um ungewollte Einspeisung oder Netzbezug zu verhindern.

Es gibt 4 Zustände:

• Laden starten: Nur, wenn genügend PV-Überschuss vorhanden ist, um die minimale Ladeleistung zu erbringen UND gleichzeitig die gewünschte Mindesteinspeisung ins Netz aufrechtzuerhalten.
• Laden stoppen: Wenn der PV-Überschuss dafür nicht mehr ausreicht ODER der Lade-Stopp SOC erreicht ist. (macht die Batterie selber, aber es sah "doof" aus, wenn die Logik laden will, die Batterie aber auf Standby geht.)
• Entladen starten: Nur, wenn keine PV-Produktion UND ein signifikanter Netzbezug besteht (mindestens minimale Entladeleistung + minimaler Netzbezug).
• Entladen stoppen: Wenn der Hausverbrauch zu niedrig wird, die PV-Produktion einsetzt ODER der Entlade-Stopp SOC erreicht ist.
• Fehler: Falls der Messwert eine gewisse Zeit nicht aktualisiert wird, Laden/Entladen auf 0 W und auf Quittierung des Fehlers warten.

Anforderungsbeschreibung der KI

► Text zeigen

--- START: ANFORDERUNGEN ---

**Pkt 00: Zielsetzung**
Steuerung einer PV-Batterie basierend auf dem Messwert eines langsam aktualisierenden Stromzählers (`$in_Leistungsmessung`). Die Steuerung soll stabil, sicher, flexibel parametrierbar und robust gegenüber Lastschwankungen sein. Die Steuerung des Ladevorgang erfolgt durch Vorgabe des Betriebsmodus (`$out_Betriebsmodus`), es gibt Laden ("Input mode") und Entladen ("Output mode"). Der Standby-Modus wird erreicht, indem die jeweilige Soll-Leistung auf 0 W gesetzt wird; der Betriebsmodus behält dabei den zuletzt aktiven Zustand.

**Pkt 01: Grundprinzip & Zustände**
Die Logik operiert als eine Zustandsmaschine mit vier exklusiven Zuständen:
* **0: STANDBY:** Die Batterie ist im Leerlauf. Leistungsausgänge sind 0.
* **1: LADEN:** Die Batterie wird aktiv geladen.
* **2: ENTLADEN:** Die Batterie wird aktiv entladen.
* **3: FEHLER:** Ein Fehler ist aufgetreten. Lade- und Entladeleistung werden auf 0 W gesetzt und die Steuerung wird erst nach dem Quittieren des Fehlers fortgesetzt.

**Pkt 02: Dynamische Zustandsübergänge**
Die Wechsel zwischen den Zuständen werden durch dynamisch berechnete Schwellwerte gesteuert, die auf den Eingangsparametern basieren.

* **Pkt 02.1: Ladevorgang beginnen (STANDBY -> LADEN):**
* Bedingung: `PV-Erzeugung > 0 W` UND `$in_Leistungsmessung >= ($in_minLadeleistung + $in_minEinspeisung)` UND `$in_soc < $in_socLadeStart`.
* **Pkt 02.2: Ladevorgang pausieren (LADEN -> STANDBY):**
* Bedingung: `PV-Erzeugung <= 0 W` ODER `$_Leistungsbilanz < ($in_minLadeleistung + $in_minEinspeisung)` ODER `$in_soc >= $in_socLadeStopp`.
* *Anmerkung: Die Bedingung prüft, ob die berechnete Leistungsbilanz ausreicht, um die Mindestladeleistung zu erbringen UND gleichzeitig die Mindesteinspeisung zu gewährleisten. Zusätzlich wird der Ladevorgang beendet, wenn der Lade-Stopp SOC erreicht ist.*
* **Pkt 02.3: Entladevorgang beginnen (STANDBY -> ENTLADEN):**
* Bedingung: `PV-Erzeugung <= 0 W` UND `$in_Leistungsmessung <= -($in_minEntladeleistung + $in_minBezug)`.
* **Pkt 02.4: Entladevorgang pausieren (ENTLADEN -> STANDBY):**
* Bedingung: `PV-Erzeugung > 0 W` ODER `($_Leistungsbilanz) > -($in_minEntladeleistung + $in_minBezug)` ODER `$in_soc <= $in_socEntladeStopp`.
* *Anmerkung: Diese Bedingung stoppt das Entladen, sobald PV-Strom erzeugt wird, der Gesamt-Strombedarf zu gering wird (Summe aus minimaler Entladeleistung und minimalem Netzbezug), oder der minimale Entlade-SOC erreicht ist.*
* **Pkt 02.5: Wechsel in Fehlerzustand (-> FEHLER):**
* Bedingung: Der Watchdog für `$in_Leistungsmessung` löst aus.
* Anmerkung: Der Wechsel kann aus *jedem* aktiven Zustand (0, 1, 2) erfolgen. Die Bedinungen können später um weitere Auslöser ergänzt werden.
* **Pkt 02.6: Fehler quittieren (FEHLER -> STANDBY):**
* Bedingung: Der Eingang `$in_fehlerQuittieren` wird auf `TRUE` gesetzt.

**Pkt 03: Leistungsregelung im Zustand LADEN**
* **Pkt 03.1: Formel:** `Ziel-Ladeleistung = Überschuss aus Leistungsbilanz - $in_minEinspeisung`.
* **Pkt 03.2: Grenzen:** Die Ziel-Ladeleistung wird auf den Bereich von `$in_minLadeleistung` bis `$in_maxLadeleistung` begrenzt.

**Pkt 04: Leistungsregelung im Zustand ENTLADEN**
* **Pkt 04.1: Formel:** `Ziel-Entladeleistung = Defizit aus Leistungsbilanz - $in_minBezug`.
* **Pkt 04.2: Grenzen:** Die Ziel-Entladeleistung wird auf den Bereich von `$in_minEntladeleistung` bis `$in_maxEntladeleistung` begrenzt.

**Pkt 05: Asymmetrische & lineare Leistungsanpassung (Dämpfung)**
* **Pkt 05.1: Funktionsprinzip:** Bei jeder Aktualisierung von `$in_Leistungsmessung` wird die Leistungsbilanz auf Basis der *aktuellen* Daten berechnet (`$in_Leistungsmessung + $in_IstLeistungLaden - $in_IstLeistungEntladen`) und daraus der neue Leistungs-Zielwert berechnet.
* **Leistungserhöhung:** Erfolgt linear begrenzt um max. `$in_maxSchrittLadeleistung` bzw. `$in_maxSchrittEntladeleistung` pro Zyklus.
* **Leistungsreduktion:** Erfolgt sofort.
* **Pkt 05.2: Finale Begrenzung:** Der resultierende Sollwert wird abschließend immer auf die in Pkt 03.2 und Pkt 04.2 definierten Min/Max-Leistungsgrenzen begrenzt.

**Pkt 06: Ein- und Ausgänge**
* **Eingänge:**
* `$in_Leistungsmessung` (float, W): Leistung am Zähler (+Einspeisung / -Bezug).
* `$in_pvErzeugung` (float, W): Aktuelle PV-Erzeugungsleistung.
* `$in_soc` (float, %): Ladezustand der Batterie (0-100).
* `$in_socLadeStart` (float, %): Ladevorgänge starten nur unterhalb dieses Ladezustands. Default: 95.
* `$in_socLadeStopp` (float, %): Der Ladevorgang wird beendet, wenn dieser SOC-Wert erreicht oder überschritten wird. Default: 100.
* `$in_socEntladeStopp` (float, %): Der Entladevorgang wird beendet, wenn dieser SOC-Wert erreicht oder unterschritten wird. Default: 20.
* `$in_IstLeistungLaden` (float, W): Tatsächliche Ladeleistung der Batterie. Default: 0.
* `$in_IstLeistungEntladen` (float, W): Tatsächliche Entladeleistung der Batterie. Default: 0.
* `$in_minLadeleistung` (float, W): Default: 400.
* `$in_maxLadeleistung` (float, W): Default: 1200.
* `$in_minEinspeisung` (float, W): Default: 200.
* `$in_minEntladeleistung` (float, W): Default: 150.
* `$in_maxEntladeleistung` (float, W): Default: 800.
* `$in_minBezug` (float, W): Default: 50.
* `$in_maxSchrittLadeleistung` (float, W): Default: 200.
* `$in_maxSchrittEntladeleistung` (float, W): Default: 50.
* `$in_watchdogTime` (float, s): Zeitlimit in Sekunden für den Watchdog. Default: 300.
* `$in_inhibit` (bool): Sperrt die Logik-Ausführung (TRUE = gesperrt). Default: false.
* `$in_fehlerQuittieren` (bool): Setzt den Fehlerzustand zurück. Default: false.
* **Ausgänge:**
* `$out_Betriebsmodus` (string): Mögliche Werte sind "Input mode" oder "Output mode". Der Standby-Zustand wird durch Setzen der entsprechenden Soll-Leistung auf 0 W signalisiert, nicht durch einen eigenen Modus-String.
* `$out_SollLeistungLaden` (float, W): Angeforderte Ladeleistung.
* `$out_SollLeistungEntladen` (float, W): Angeforderte Entladeleistung.
* `$out_LogikStatus` (integer): Aktueller Zustand der Logik (0=Standby, 1=Laden, 2=Entladen, 3=Fehler).
* `$out_Fehler` (bool): Es ist ein Fehler aufgetreten, Batterie in Standby.

**Pkt 07: Globale Sperre (Inhibit)**
* Die Logik kann über den Eingang `$in_inhibit` angehalten werden. Wenn dieser `TRUE` ist, wird die Ausführung der Logik für den aktuellen Zyklus sofort abgebrochen, und die Ausgänge behalten ihre vorherigen Werte.

**Pkt 08: Watchdog für ausbleibende Messwerte**
* Wenn der Eingang `$in_Leistungsmessung` für die in `$in_watchdogTime` definierte Zeit nicht aktualisiert wird, wechselt die Logik in den Zustand `FEHLER`. In diesem Zustand werden die Soll-Leistungen auf 0 W gesetzt und der Ausgang `$out_Fehler` auf `TRUE` gesetzt.

--- ENDE: ANFORDERUNGEN ---

TWS Custom Logic für eine Batterie-Steuerung, KI-basiert erstellt (MetaPrompt_v2.2, PROJEKT-VERSION: 1.4.9)

► Text zeigen

Verwendung auf eigene Verantwortung! Die Logik geht davon aus, dass sich das Batteriemanagement um alle Sicherheitsfunktionen kümmert und keine Steuereingaben akzeptiert, die zu Schäden oder gefährlichen Zuständen führen können.

Code: Alles auswählen

{
    "Module": [
        // Version: 1.4.9, Datum: 2025-10-01
        // --- START: Pkt 07 - INHIBIT (SPERRE) ---
        ["Break", ["$in_inhibit"]],
        
        // --- START: Pkt 08 - WATCHDOG ---
        // Prüft, ob der Eingang `$in_Leistungsmessung` diesen Zyklus ausgelöst hat
        ["Triggered", "$in_Leistungsmessung", "$_watchdogResetSignal"],
        // Startet/resettet einen Timer bei jedem Update. $_watchdog_OK ist FALSE, wenn der Timer abläuft.
        ["Monoflop", "$_watchdogResetSignal", "$ConstFalse", "$_watchdogOK", "$in_watchdogTime", 3],

        // --- START: Pkt 02.5 - Fehlerbedingung(en) auswerten ---
        ["Or", ["-$_watchdogOK"], "$_goToFehler"],

        // --- START: Pkt 05.1 - Leistungsbilanz berechnen ---
        ["Polynomial", "$in_IstLeistungLaden", "$_tempLeistungsbilanz", ["$in_Leistungsmessung", "$Const1"]],
        ["Polynomial", "$in_IstLeistungEntladen", "$_Leistungsbilanz", ["$_tempLeistungsbilanz", "$ConstNeg1"]],

        // --- START: Pkt 03 & 04 - Ziel-Leistungen berechnen (roh) ---
        ["Polynomial", "$in_minEinspeisung", "$_zielLadeleistungRoh", ["$_Leistungsbilanz", "$ConstNeg1"]],
        ["Polynomial", "$in_minBezug", "$_zielEntladeleistungRoh", ["-$_Leistungsbilanz", "$ConstNeg1"]],

        // --- START: Pkt 05 - Asymmetrische Leistungsanpassung (Dämpfung) ---
        ["Polynomial", "$in_maxSchrittLadeleistung", "$_maxErlaubteLadeleistung", ["$in_IstLeistungLaden", "$Const1"]],
        ["Comparator", "$_zielLadeleistungRoh", "$_zielUeberschreitetRampeLaden", "$_maxErlaubteLadeleistung"],
        ["Multiplexer", ["$_zielLadeleistungRoh", "$_maxErlaubteLadeleistung"], "$_zielLadeleistungGedaempft", "$_zielUeberschreitetRampeLaden"],
        ["Polynomial", "$in_maxSchrittEntladeleistung", "$_maxErlaubteEntladeleistung", ["$in_IstLeistungEntladen", "$Const1"]],
        ["Comparator", "$_zielEntladeleistungRoh", "$_zielUeberschreitetRampeEntladen", "$_maxErlaubteEntladeleistung"],
        ["Multiplexer", ["$_zielEntladeleistungRoh", "$_maxErlaubteEntladeleistung"], "$_zielEntladeleistungGedaempft", "$_zielUeberschreitetRampeEntladen"],

        // --- START: Pkt 03.2, 04.2, 05.2 - Finale Leistungsbegrenzung ---
        ["Limiter", "$_zielLadeleistungGedaempft", "$_sollLeistungLadenFinal", 0, ["$in_minLadeleistung", "$in_maxLadeleistung"]],
        ["Limiter", "$_zielEntladeleistungGedaempft", "$_sollLeistungEntladenFinal", 0, ["$in_minEntladeleistung", "$in_maxEntladeleistung"]],

        // --- START: Pkt 02 - Bedingungen für Zustandsübergänge berechnen ---
        ["Polynomial", "$in_minEinspeisung", "$_schwelleLadenStart", ["$in_minLadeleistung", "$Const1"]],
        ["Comparator", "$in_Leistungsmessung", "$_ueberSchwelleLadenStart", "$_schwelleLadenStart"],
        ["Comparator", "$in_pvErzeugung", "$_pvErzeugt", "$Const0"],
        ["Comparator", "$in_socLadeStart", "$_socUnterLadeStart", "$in_soc"],
        ["And", ["$_ueberSchwelleLadenStart", "$_pvErzeugt", "$_socUnterLadeStart"], "$_goToLaden"],
        ["Comparator", "$_schwelleLadenStart", "$_LeistungsbilanzUnterSchwelleLaden", "$_Leistungsbilanz"],
        ["Comparator", "$in_socLadeStopp", "$_socUnterLadeStopp", "$in_soc"],
        ["Or", ["$_LeistungsbilanzUnterSchwelleLaden", "-$_pvErzeugt", "-$_socUnterLadeStopp"], "$_goToStandbyFromLaden"],
        ["Polynomial", "$in_minBezug", "$_schwelleEntladenStartRoh", ["$in_minEntladeleistung", "$Const1"]],
        ["Polynomial", "$_schwelleEntladenStartRoh", "$_schwelleEntladenStart", ["$Const0", "$ConstNeg1"]],
        ["Comparator", "$_schwelleEntladenStart", "$_unterSchwelleEntladenStart", "$in_Leistungsmessung"],
        ["And", ["$_unterSchwelleEntladenStart", "-$_pvErzeugt"], "$_goToEntladen"],
        ["Comparator", "$_Leistungsbilanz", "$_LeistungsbilanzUeberSchwelleEntladen", "$_schwelleEntladenStart"],
        ["Comparator", "$in_soc", "$_socUeberEntladeStopp", "$in_socEntladeStopp"],
        ["Or", ["$_LeistungsbilanzUeberSchwelleEntladen", "$_pvErzeugt", "-$_socUeberEntladeStopp"], "$_goToStandbyFromEntladen"],

        // --- START: Pkt 01 - Zustandsmaschine ---
        // 0: Standby, 1: Laden, 2: Entladen, 3: Fehler
        ["Statemachine", [
            ["$_goToFehler", 0, 3, 0],
            ["$_goToFehler", 1, 3, 0],
            ["$_goToFehler", 2, 3, 0],
            ["$in_fehlerQuittieren", 3, 0, 0],
            ["$_goToLaden", 0, 1, 0],
            ["$_goToStandbyFromLaden", 1, 0, 0],
            ["$_goToEntladen", 0, 2, 0],
            ["$_goToStandbyFromEntladen", 2, 0, 0]
        ], "$out_LogikStatus"],

        // --- START: Pkt 06 - Finale Ausgänge setzen ---
        ["Multiplexer", ["$Const0", "$_sollLeistungLadenFinal", "$Const0", "$Const0"], "$out_SollLeistungLaden", "$out_LogikStatus"],
        ["Multiplexer", ["$Const0", "$Const0", "$_sollLeistungEntladenFinal", "$Const0"], "$out_SollLeistungEntladen", "$out_LogikStatus"],
        ["Multiplexer", ["$_letzterBetriebsmodus", "$TextCharge", "$TextDischarge", "$_letzterBetriebsmodus"], "$out_Betriebsmodus", "$out_LogikStatus"],
        ["Multiplexer", ["$ConstFalse", "$ConstFalse", "$ConstFalse", "$ConstTrue"], "$out_Fehler", "$out_LogikStatus"],

        // --- START: Zustand für nächsten Zyklus speichern ---
        ["Latch", "$out_Betriebsmodus", "$_letzterBetriebsmodus", "$ConstTrue", 0]
    ],
    "Level": [
        // --- Konstanten ---
        ["$Const0", "float", 0.0],
        ["$Const1", "float", 1.0],
        ["$ConstNeg1", "float", -1.0],
        ["$ConstTrue", "bool", true],
        ["$ConstFalse", "bool", false],
        ["$TextCharge", "string", "Input mode"],
        ["$TextDischarge", "string", "Output mode"],
        // --- Eingänge (Pkt 06) ---
        ["$in_Leistungsmessung", "float", 0.0],
        ["$in_pvErzeugung", "float", 0.0],
        ["$in_soc", "float", 50.0],
        ["$in_socLadeStart", "float", 95.0],
        ["$in_socLadeStopp", "float", 100.0],
        ["$in_socEntladeStopp", "float", 20.0],
        ["$in_IstLeistungLaden", "float", 0.0],
        ["$in_IstLeistungEntladen", "float", 0.0],
        ["$in_minLadeleistung", "float", 400.0],
        ["$in_maxLadeleistung", "float", 1200.0],
        ["$in_minEinspeisung", "float", 200.0],
        ["$in_minEntladeleistung", "float", 150.0],
        ["$in_maxEntladeleistung", "float", 800.0],
        ["$in_minBezug", "float", 50.0],
        ["$in_maxSchrittLadeleistung", "float", 200.0],
        ["$in_maxSchrittEntladeleistung", "float", 50.0],
        ["$in_watchdogTime", "float", 300.0],
        ["$in_inhibit", "bool", false],
        ["$in_fehlerQuittieren", "bool", false],
        // --- Ausgänge (Pkt 06) ---
        ["$out_Betriebsmodus", "string", "Input mode"],
        ["$out_SollLeistungLaden", "float", 0.0],
        ["$out_SollLeistungEntladen", "float", 0.0],
        ["$out_LogikStatus", "integer", 0],
        ["$out_Fehler", "bool", false],
        // --- Interne Variablen ---
        ["$_Leistungsbilanz", "float", 0.0],
        ["$_tempLeistungsbilanz", "float", 0.0],
        ["$_letzterBetriebsmodus", "string", "Input mode"],
        ["$_zielLadeleistungRoh", "float", 0.0],
        ["$_zielEntladeleistungRoh", "float", 0.0],
        ["$_maxErlaubteLadeleistung", "float", 0.0],
        ["$_zielUeberschreitetRampeLaden", "bool", false],
        ["$_maxErlaubteEntladeleistung", "float", 0.0],
        ["$_zielUeberschreitetRampeEntladen", "bool", false],
        ["$_zielLadeleistungGedaempft", "float", 0.0],
        ["$_zielEntladeleistungGedaempft", "float", 0.0],
        ["$_sollLeistungLadenFinal", "float", 0.0],
        ["$_sollLeistungEntladenFinal", "float", 0.0],
        ["$_schwelleLadenStart", "float", 0.0],
        ["$_ueberSchwelleLadenStart", "bool", false],
        ["$_LeistungsbilanzUnterSchwelleLaden", "bool", false],
        ["$_pvErzeugt", "bool", false],
        ["$_socUnterLadeStart", "bool", false],
        ["$_socUnterLadeStopp", "bool", false],
        ["$_socUeberEntladeStopp", "bool", false],
        ["$_goToFehler", "bool", false],
        ["$_goToLaden", "bool", false],
        ["$_goToStandbyFromLaden", "bool", false],
        ["$_schwelleEntladenStartRoh", "float", 0.0],
        ["$_schwelleEntladenStart", "float", 0.0],
        ["$_unterSchwelleEntladenStart", "bool", false],
        ["$_LeistungsbilanzUeberSchwelleEntladen", "bool", false],
        ["$_goToEntladen", "bool", false],
        ["$_goToStandbyFromEntladen", "bool", false],
        ["$_watchdogResetSignal", "bool", false],
        ["$_watchdogOK", "bool", true]
    ],
    "Input": [
        ["Leistungsmessung (W)", "+Einspeisung / -Bezug", "$in_Leistungsmessung", "a"],
        ["PV Erzeugung (W)", "Aktuelle PV-Leistung", "$in_pvErzeugung", "c"],
        ["SOC (%)", "Ladezustand der Batterie", "$in_soc", "c"],
        ["Lade-Start SOC (%)", "Ladevorgang startet nur unterhalb dieses Ladezustands", "$in_socLadeStart", "c"],
        ["Lade-Stopp SOC (%)", "Ladevorgang stoppt bei Erreichen dieses Werts", "$in_socLadeStopp", "c"],
        ["Entlade-Stopp SOC (%)", "Entladevorgang stoppt bei Erreichen dieses Werts", "$in_socEntladeStopp", "c"],
        ["Ist-Leistung Laden (W)", "Tatsächliche Ladeleistung", "$in_IstLeistungLaden", "u"],
        ["Ist-Leistung Entladen (W)", "Tatsächliche Entladeleistung", "$in_IstLeistungEntladen", "u"],
        ["Min. Ladeleistung (W)", "Untere Grenze für Ladeleistung", "$in_minLadeleistung", "c"],
        ["Max. Ladeleistung (W)", "Obere Grenze für Ladeleistung", "$in_maxLadeleistung", "c"],
        ["Min. Einspeisung (W)", "Mindestüberschuss für Netz", "$in_minEinspeisung", "c"],
        ["Min. Entladeleistung (W)", "Untere Grenze für Entladeleistung", "$in_minEntladeleistung", "c"],
        ["Max. Entladeleistung (W)", "Obere Grenze für Entladeleistung", "$in_maxEntladeleistung", "c"],
        ["Min. Bezug (W)", "Mindestbezug vom Netz", "$in_minBezug", "c"],
        ["Max. Schritt Ladeleistung (W)", "Maximale Erhöhung pro Zyklus", "$in_maxSchrittLadeleistung", "c"],
        ["Max. Schritt Entladeleistung (W)", "Maximale Erhöhung pro Zyklus", "$in_maxSchrittEntladeleistung", "c"],
        ["Watchdog Zeit (s)", "Zeit in Sekunden ohne Messwert-Update, bevor die Logik stoppt", "$in_watchdogTime", "c"],
        ["Inhibit", "Logik-Ausführung anhalten (TRUE = angehalten)", "$in_inhibit", "c"],
        ["Fehler quittieren", "Setzt den Fehlerzustand zurück (TRUE)", "$in_fehlerQuittieren", "c"]
    ],
    "Output": [
        ["Betriebsmodus", "Input mode oder Output mode", "$out_Betriebsmodus", "c"],
        ["Soll-Leistung Laden (W)", "Angeforderte Ladeleistung", "$out_SollLeistungLaden", "c"],
        ["Soll-Leistung Entladen (W)", "Angeforderte Entladeleistung", "$out_SollLeistungEntladen", "c"],
        ["Logik Status", "0:STANDBY, 1:LADEN, 2:ENTLADEN, 3:FEHLER", "$out_LogikStatus", "c"],
        ["Fehler", "Es ist ein Fehler aufgetreten; Batterie im Standby.", "$out_Fehler", "c"]
        // LIZENZ (Prompt & Custom-Logik): Der Schöpfer überträgt die Nutzungsrechte gemäß der TOLL ("Timberwolf Open Logikblock License") die unter https://wrgt.news/TOLL zum Download zur Verfügung steht.
    ]
}

Ich freue mich über Anmerkungen, Ideen und gefundene Fehler

VG
Stefan