ElabNET Technik Forum

Referenz-Code für AI-Hilfe bei Timberwolf Custom Logic (JSON)


Hallo zusammen,

viele nutzen vielleicht AI-Assistenten (wie ChatGPT, Claude etc.) für Unterstützung bei der Erstellung von Timberwolf Server "Custom Logic"-Blöcken im JSON-Format. Da diese KIs oft keinen direkten Zugriff auf die aktuelle TWS-Dokumentation oder die exakte Syntax der verfügbaren Module haben, benötigen sie eine funktionierende Basis als Kontext.

Basierend auf Tests und Erkenntnissen aus der Zusammenarbeit mit dem Forenmitglied eib-eg (vielen Dank dafür!) haben wir hier einen kompakten Referenz-Codeblock erstellt. Dieser Code wurde erfolgreich im TWS gespeichert und demonstriert die Syntax sowie die Verwendung wichtiger Module wie Latch (für Persistenz), PID_awu und einen nachgebauten FlipFlop.

Anleitung:

Wenn ihr eine AI um Hilfe bei eurer "Custom Logic" bittet, könnt ihr diesen Codeblock zu Beginn eures Chats an die AI übergeben. Das gibt ihr den notwendigen Kontext über die Struktur, Syntax und Kernmodule, was zu schnelleren und genaueren Antworten führen sollte.





Wichtiger Hinweis & Aufruf zur Mithilfe:

Dieser Referenzcode enthält die wichtigsten stateful Module, die wir identifizieren konnten (Latch, PID_awu, nachgebauter FlipFlop). Sollte jemand bei seiner Problemstellung feststellen, dass ein wichtiges, hier fehlendes Modul oder Konzept für die AI als Referenz hilfreich wäre, bitten wir darum:

Der AI das Problem und ggf. einen Beispielcode für das fehlende Modul zu geben.

Die AI zu bitten, eine aktualisierte Version dieses Referenzcodes zu erstellen, die das neue Element enthält.

Diese aktualisierte Referenz idealerweise wieder hier im Forum zu teilen, damit die Wissensbasis für alle (und die AI) wächst.

Ziel ist es, eine möglichst umfassende, aber dennoch kompakte Referenz zu pflegen.

Nochmal vielen Dank an eib-eg für die Hilfe beim Testen und Validieren!



und von mir auch danke

So, die Informationen des Wikis und der Code der Logik-Funktionen ist jetzt in einem LLM-verträglichen ZIP-File TWS_Wiki-Logik-Data_For_LLM.zip enthalten. Ich habe lediglich die großen für unseren Anwendungsfall irrelevanten Wikipages gelöscht, wie z.B. die Versionschangelogs. Somit müsste die LLM nun so ziemlich alles über den TWS wissen, was auch im Wiki veröffentlicht ist.

Gruß

Franky

@eib-eg hmm, ich glaube, wir könnten uns koordinieren

hast du jetzt fast das gleiche gemacht und gedacht wie ich

ich habe eine komplexe solarsteuerung erstellen lassen die sich speichern lies.
darauf hin kam mir so der gedanke ob nicht die ki den forumsbeitrag selber erstellen kann

Ist doch super, lass uns das synchronisieren.

Verschiedene Ansätze und Gedanken sind genau das, was wir brauchen, um zu guten Lösungen zu gelangen.

Ob mein "Monster-Prompt" der Weißheit letzter Schluss ist, muss sich auch erst beweisen. Hast Du die fachlichen Anforderungen zur Solarsteuerung mal zusammengeschrieben? Dann könnte ich endlich meinen "2-Way-Etwicklungsprompt" testen, und überhaupt, wie er mit einer größeren neuen Anforderung umgeht...

Zur Doku: ich habe einen scraper schreiben lassen, der das Wiki downloaded und den Code der manuellen Logikfunktionen aufnimmt, den man sich aus der GUI im TWS kopieren kann (siehe Beträge ab gestern Mittag in diesem Thread ).

Die Datei TWS_Wiki-Logik-Data_For_LLM.zip kann man somit auf Knopfdruck aktualisieren, wenn die Doku aktualisiert wird. Ergänzungen zu dieser Doku (also zum Wiki) sind im großen Prompt zur Custom-Logik Entwicklung enthalten (Download in vorheriger Nachricht in diesem Tread), damit die LLM auf dem neuesten Stand ist.

Gruß

Frank

jo
ich lasse noch eine anleitung von der ki über den code schreiben

ab jatzt nur ki geschrieben







Wow, das ist ja großartig, dass die Community schon Interesse zeigt! Das bestätigt, dass unsere Arbeit hier relevant ist.

Absolut, hier ist ein Entwurf für einen Forenbeitrag, der den Code enthält und erklärt, wie man ihn verwendet und anpasst. Ich habe versucht, ihn informativ, aber auch mit den nötigen Warnhinweisen zu versehen.

Titel: Fortgeschrittene Solarsteuerung (3 Ziele, PID-Pumpe) als Custom Logic Block [Beta]

Hallo zusammen,

in Zusammenarbeit mit dem Forenmitglied eib-eg (vielen Dank an dieser Stelle!) und durch die Analyse vieler bestehender Custom Logic Beispiele haben wir einen einzelnen Custom Logic Block im JSON-Format entwickelt, der eine relativ komplexe Solarthermie-Steuerung abbildet.

Funktionen:

Ansteuerung von bis zu 3 Zielen (Warmwasser, Pufferspeicher, Eisspeicher).

Feste Priorisierung der Ziele: Warmwasser > Puffer > Eisspeicher.

Drehzahlregelung der Solarpumpe über PID-Regler (PID awu) mit einstellbarer Solldifferenz (dT).

Ansteuerung von 2 Umschaltventilen gemäß der Logik:

Ventil 1 AUS: Warmwasser

Ventil 1 EIN, Ventil 2 AUS: Puffer

Ventil 1 EIN, Ventil 2 EIN: Eisspeicher

Nutzung des Latch-Moduls zur persistenten Speicherung von Zuständen (Pumpenstatus, aktives Ziel).

Berücksichtigung von Ein-/Ausschalthysteresen und Maximaltemperaturen der Speicher.

Zweck:

Dieser Code dient als fortgeschrittene Vorlage und Diskussionsgrundlage. Er wurde erfolgreich im Timberwolf Server gespeichert, die Logik ist jedoch in einem realen System noch nicht ausführlich getestet!

Der Code (Version 1.1):


{
"Level": [
// --- INPUTS (Sensoren & Parameter) ---
// Sensoren (Initialwerte nur für Offline-Simulation)
[ "$I_T_Koll", "float", 45.0 ],
[ "$I_T_WW_U", "float", 30.0 ],
[ "$I_T_WW_O", "float", 55.0 ],
[ "$I_T_Puffer_U", "float", 35.0 ],
[ "$I_T_Puffer_O", "float", 60.0 ],
[ "$I_T_Eis", "float", 10.0 ],
// Parameter (Anpassen!)
[ "$P_EIN_HYS", "float", 6.0 ],
[ "$P_AUS_HYS", "float", 3.0 ],
[ "$P_T_WW_MAX", "float", 60.0 ],
[ "$P_T_PUFFER_MAX", "float", 80.0 ],
[ "$P_T_EIS_MAX", "float", 25.0 ],
[ "$P_Prio_WW", "integer", 1 ], // Info: In dieser Version NICHT ausgewertet!
[ "$P_Prio_Puffer", "integer", 2 ], // Info: In dieser Version NICHT ausgewertet!
[ "$P_Prio_Eis", "integer", 3 ], // Info: In dieser Version NICHT ausgewertet!
[ "$P_dT_Soll", "float", 8.0 ],
[ "$P_Kp", "float", 10.0 ],
[ "$P_Ki", "float", 0.5 ],
[ "$P_Kd", "float", 0.1 ],
[ "$P_Pump_Min_Speed", "float", 20.0 ], // %
[ "$P_Pump_Max_Speed", "float", 100.0 ], // %
[ "$P_PID_LL", "float", 0.0 ], // PID Output Lower Limit (%)
[ "$P_PID_UL", "float", 100.0 ], // PID Output Upper Limit (%)

// --- PERSISTENT STATES (Werden über Module oder Latch aktualisiert) ---
[ "$FF_Out_Alt", "bool", false ], // Pumpenstatus vom letzten Zyklus (aus FF-Nachbau)
[ "$State_ActiveTargetID_Alt", "integer", 0 ], // Aktives Ziel vom letzten Zyklus (0=Kein, 1=WW, 2=Puffer, 3=Eis)
[ "$State_T_Unten_Alt", "float", 0.0 ], // T_Unten des letzten aktiven Ziels
[ "$State_T_Oben_Alt", "float", 0.0 ], // T_Oben des letzten aktiven Ziels
[ "$State_T_Max_Alt", "float", 0.0 ], // T_Max des letzten aktiven Ziels

// --- INTERMEDIATE CALCULATIONS (Variablen für Zwischenschritte) ---
// dTs
[ "$Calc_dT_WW", "float", 0.0 ],
[ "$Calc_dT_Puffer", "float", 0.0 ],
[ "$Calc_dT_Eis", "float", 0.0 ],
// Conditions per Target
[ "$Cond_WW_Ready", "bool", false ],
[ "$Cond_WW_NotFull", "bool", false ],
[ "$Cond_WW_CanLoad", "bool", false ],
[ "$Cond_Puffer_Ready", "bool", false ],
[ "$Cond_Puffer_NotFull", "bool", false ],
[ "$Cond_Puffer_CanLoad", "bool", false ],
[ "$Cond_Eis_Ready", "bool", false ],
[ "$Cond_Eis_NotFull", "bool", false ],
[ "$Cond_Eis_CanLoad", "bool", false ],
// Priority Logic Result
[ "$Calc_NextTargetID", "integer", 0 ],
[ "$Target_Temp1", "integer", 0 ],
[ "$Target_Temp2", "integer", 0 ],
// Pump Control FlipFlop (Nachbau)
[ "$Cond_FF_Set", "bool", false ],
[ "$Cond_FF_Reset", "bool", false ],
[ "$FF_InStat", "integer", 0 ],
[ "$FF_Out_Neu", "bool", false ],
// Reset Condition Logic
[ "$dT_Alt_Ziel", "float", 0.0 ],
[ "$Reset_Cond1", "bool", false ],
[ "$Reset_Cond2", "bool", false ],
[ "$Cond_FF_Reset_Raw", "bool", false ],
[ "$OldTargetExists", "bool", false ],
// PID Control
[ "$Calc_dT_Ist_Selected", "float", 0.0 ],
[ "$Calc_PID_Manipulate", "float", 0.0 ],
[ "$Calc_PID_Limited", "float", 0.0 ],
[ "$Limiter_Val_Ok", "bool", false ],
[ "$Calc_PumpSpeedPerc_Volt", "float", 0.0 ],
// Valve Control
[ "$Calc_Ventil1_On", "bool", false ],
[ "$Calc_Ventil2_On", "bool", false ],
[ "$Ventil1_Cond1", "bool", false ],
[ "$Ventil2_Cond1", "bool", false ],
// State Saving Temps
[ "$Temp_T_Unten_Neu", "float", 0.0 ],
[ "$Temp_T_Oben_Neu", "float", 0.0 ],
[ "$Temp_T_Max_Neu", "float", 0.0 ],
// Formulas
[ "$Formula_dT", "string", "X1 - X2" ],
[ "$Formula_ScaleVolt", "string", "(X1 / 100.0) * 10.0" ],

// --- OUTPUTS (Variablen, die nach außen gehen) ---
[ "$O_PumpSpeedVolt", "float", 0.0 ],
[ "$O_Ventil1_On", "bool", false ],
[ "$O_Ventil2_On", "bool", false ],
[ "$O_PumpState", "bool", false ], // Debug Output
[ "$O_ActiveTargetID", "integer", 0 ], // Debug Output

// --- CONSTANTS ---
[ "$KonstTrue", "bool", true ],
[ "$KonstFalse", "bool", false ],
[ "$Konst0_float", "float", 0.0 ],
[ "$Konst0_int", "integer", 0 ],
[ "$Konst1_int", "integer", 1 ], // Ziel-ID für WW
[ "$Konst2_int", "integer", 2 ], // Ziel-ID für Puffer
[ "$Konst3_int", "integer", 3 ], // Ziel-ID für Eis

// --- INHIBIT ---
// [ "$VAR<Inhibit?>", "bool", false ] // Bei Bedarf einkommentieren
],
"Module": [
// 0. Optional Break
// [ "Break", [ "$VAR<Inhibit?>" ] ], // Bei Bedarf einkommentieren (Komma danach!)

// --- 1. Calculate dTs ---
[ "CalcFormula", [ "$I_T_Koll", "$I_T_WW_U" ], "$Calc_dT_WW", "$Formula_dT" ],
[ "CalcFormula", [ "$I_T_Koll", "$I_T_Puffer_U" ], "$Calc_dT_Puffer", "$Formula_dT" ],
[ "CalcFormula", [ "$I_T_Koll", "$I_T_Eis" ], "$Calc_dT_Eis", "$Formula_dT" ],

// --- 2. Check Conditions per Target ---
[ "Comparator", "$Calc_dT_WW", "$Cond_WW_Ready", "$P_EIN_HYS" ],
[ "Comparator", "$P_T_WW_MAX", "$Cond_WW_NotFull", "$I_T_WW_O" ],
[ "And", [ "$Cond_WW_Ready", "$Cond_WW_NotFull" ], "$Cond_WW_CanLoad" ],
[ "Comparator", "$Calc_dT_Puffer", "$Cond_Puffer_Ready", "$P_EIN_HYS" ],
[ "Comparator", "$P_T_PUFFER_MAX","$Cond_Puffer_NotFull", "$I_T_Puffer_O" ],
[ "And", [ "$Cond_Puffer_Ready", "$Cond_Puffer_NotFull" ], "$Cond_Puffer_CanLoad" ],
[ "Comparator", "$Calc_dT_Eis", "$Cond_Eis_Ready", "$P_EIN_HYS" ],
[ "Comparator", "$P_T_EIS_MAX", "$Cond_Eis_NotFull", "$I_T_Eis" ],
[ "And", [ "$Cond_Eis_Ready", "$Cond_Eis_NotFull" ], "$Cond_Eis_CanLoad" ],

// --- 3. Priority Logic (Feste Prio: WW > Puffer > Eis) ---
[ "Multiplexer", [ "$Konst0_int", "$Konst3_int" ], "$Target_Temp1", "$Cond_Eis_CanLoad" ],
[ "Multiplexer", [ "$Target_Temp1", "$Konst2_int" ], "$Target_Temp2", "$Cond_Puffer_CanLoad" ],
[ "Multiplexer", [ "$Target_Temp2", "$Konst1_int" ], "$Calc_NextTargetID", "$Cond_WW_CanLoad" ],

// --- 4. Pump Control FlipFlop (Nachbau) ---
[ "Comparator", "$Calc_NextTargetID", "$Cond_FF_Set", "$Konst1_int" ], // Set wenn ID >= 1
[ "Comparator", "$State_ActiveTargetID_Alt", "$OldTargetExists", "$Konst1_int" ], // Altes Ziel vorhanden?
[ "CalcFormula", [ "$I_T_Koll", "$State_T_Unten_Alt" ], "$dT_Alt_Ziel", "$Formula_dT" ],
[ "Comparator", "$P_AUS_HYS", "$Reset_Cond1", "$dT_Alt_Ziel" ], // Reset wenn dT < AUS_HYS
[ "Comparator", "$State_T_Oben_Alt", "$Reset_Cond2", "$State_T_Max_Alt" ], // Reset wenn T_Oben >= T_Max
[ "Or", [ "$Reset_Cond1", "$Reset_Cond2" ], "$Cond_FF_Reset_Raw" ],
[ "And", [ "$OldTargetExists", "$Cond_FF_Reset_Raw" ], "$Cond_FF_Reset" ],
[ "BinaryMultiplexer", [ "$Cond_FF_Set", "$Cond_FF_Reset" ], "$FF_InStat" ],
[ "Multiplexer", [ "$FF_Out_Alt", "$KonstFalse", "$KonstTrue", "$KonstTrue" ], "$FF_Out_Neu", "$FF_InStat" ],

// --- 5. PID Control ---
[ "Multiplexer", [ "$Konst0_float", "$Calc_dT_WW", "$Calc_dT_Puffer", "$Calc_dT_Eis" ], "$Calc_dT_Ist_Selected", "$Calc_NextTargetID" ],
[ "PID_awu", "$P_dT_Soll", "$Calc_dT_Ist_Selected", "$Calc_PID_Manipulate", "$P_Kp", "$P_Ki", "$P_Kd", "$P_PID_LL", "$P_PID_UL" ],

// --- 6. Pump Output Calculation ---
[ "Limiter", "$Calc_PID_Manipulate", "$Calc_PID_Limited", "$Limiter_Val_Ok", [ "$P_Pump_Min_Speed", "$P_Pump_Max_Speed" ] ],
[ "CalcFormula", [ "$Calc_PID_Limited" ], "$Calc_PumpSpeedPerc_Volt", "$Formula_ScaleVolt" ],
[ "Multiplexer", [ "$Konst0_float", "$Calc_PumpSpeedPerc_Volt" ], "$O_PumpSpeedVolt", "$FF_Out_Neu" ],

// --- 7. Valve Control ---
[ "Comparator", "$Calc_NextTargetID", "$Ventil1_Cond1", "$Konst2_int" ], // V1=EIN wenn ID >= 2
[ "Multiplexer", [ "$KonstFalse", "$KonstTrue" ], "$Calc_Ventil1_On", "$Ventil1_Cond1" ],
[ "Comparator", "$Calc_NextTargetID", "$Ventil2_Cond1", "$Konst3_int" ], // V2=EIN wenn ID >= 3
[ "Multiplexer", [ "$KonstFalse", "$KonstTrue" ], "$Calc_Ventil2_On", "$Ventil2_Cond1" ],

// --- 8. Persist State for Next Cycle using Latch ---
[ "Latch", "$FF_Out_Neu", "$FF_Out_Alt", "$KonstTrue", 0 ],
[ "Latch", "$Calc_NextTargetID", "$State_ActiveTargetID_Alt", "$KonstTrue", 0 ],
[ "Multiplexer", [ "$Konst0_float", "$I_T_WW_U", "$I_T_Puffer_U", "$I_T_Eis" ], "$Temp_T_Unten_Neu", "$Calc_NextTargetID" ],
[ "Latch", "$Temp_T_Unten_Neu", "$State_T_Unten_Alt", "$KonstTrue", 0 ],
[ "Multiplexer", [ "$Konst0_float", "$I_T_WW_O", "$I_T_Puffer_O", "$I_T_Eis" ], "$Temp_T_Oben_Neu", "$Calc_NextTargetID" ],
[ "Latch", "$Temp_T_Oben_Neu", "$State_T_Oben_Alt", "$KonstTrue", 0 ],
[ "Multiplexer", [ "$Konst0_float", "$P_T_WW_MAX", "$P_T_PUFFER_MAX", "$P_T_EIS_MAX" ], "$Temp_T_Max_Neu", "$Calc_NextTargetID" ],
[ "Latch", "$Temp_T_Max_Neu", "$State_T_Max_Alt", "$KonstTrue", 0 ],

// --- 9. Assign Outputs ---
[ "Multiplexer", [ "$Calc_Ventil1_On", "$Calc_Ventil1_On" ], "$O_Ventil1_On", "$KonstTrue" ],
[ "Multiplexer", [ "$Calc_Ventil2_On", "$Calc_Ventil2_On" ], "$O_Ventil2_On", "$KonstTrue" ],
[ "Multiplexer", [ "$FF_Out_Neu", "$FF_Out_Neu" ], "$O_PumpState", "$KonstTrue" ],
[ "Multiplexer", [ "$Calc_NextTargetID", "$Calc_NextTargetID" ], "$O_ActiveTargetID", "$KonstTrue" ]
],
"Input": [
// Sensoren
[ "T Kollektor", "Temperatur Kollektor [C]", "$I_T_Koll", "c" ],
[ "T WW Unten", "Temperatur WW Speicher Unten [C]", "$I_T_WW_U", "c" ],
[ "T WW Oben", "Temperatur WW Speicher Oben [C]", "$I_T_WW_O", "c" ],
[ "T Puffer Unten", "Temperatur Pufferspeicher Unten [C]", "$I_T_Puffer_U", "c" ],
[ "T Puffer Oben", "Temperatur Pufferspeicher Oben [C]", "$I_T_Puffer_O", "c" ],
[ "T Eisspeicher", "Temperatur Eisspeicher [C]", "$I_T_Eis", "c" ],
// Parameter
[ "Ein Hysterese", "Einschaltdifferenz Kollektor > Speicher [K]", "$P_EIN_HYS", "c" ],
[ "Aus Hysterese", "Ausschaltdifferenz Kollektor > Speicher [K]", "$P_AUS_HYS", "c" ],
[ "T WW Max", "Maximale WW Temperatur [C]", "$P_T_WW_MAX", "c" ],
[ "T Puffer Max", "Maximale Puffer Temperatur [C]", "$P_T_PUFFER_MAX", "c" ],
[ "T Eis Max", "Maximale Eisspeicher Temperatur [C]", "$P_T_EIS_MAX", "c" ],
[ "dT Soll", "Solldifferenz für PID Regelung [K]", "$P_dT_Soll", "c" ],
[ "PID Kp", "Proportionalbeiwert", "$P_Kp", "c" ],
[ "PID Ki", "Integralbeiwert", "$P_Ki", "c" ],
[ "PID Kd", "Differentialbeiwert", "$P_Kd", "c" ],
[ "Pump Min Speed", "Minimale Pumpendrehzahl [%]", "$P_Pump_Min_Speed", "c" ],
[ "Pump Max Speed", "Maximale Pumpendrehzahl [%]", "$P_Pump_Max_Speed", "c" ]
],
"Output": [
[ "Pumpe Spannung", "Ausgangsspannung für Pumpe [0-10V]", "$O_PumpSpeedVolt", "c" ],
[ "Ventil 1 (Puffer/Eis)", "Schaltet auf Puffer/Eis (true=EIN)", "$O_Ventil1_On", "c" ],
[ "Ventil 2 (Eis)", "Schaltet auf Eisspeicher (true=EIN)", "$O_Ventil2_On", "c" ],
[ "DEBUG Pumpe Status", "Zeigt aktuellen Pumpenstatus (true=AN)", "$O_PumpState", "c" ],
[ "DEBUG Aktives Ziel", "Zeigt aktuell angefordertes Ziel (0=Aus,1=WW,2=Puffer,3=Eis)", "$O_ActiveTargetID", "c" ]
]
}




Wichtige Hinweise für den Forum-Post:

Status: Kläre, dass dieser Code syntaktisch korrekt ist (lässt sich speichern), aber die Logik intensiv getestet und an die eigene Anlage angepasst werden muss. Es ist eine Beta-Version / Vorlage.

Parameter: Hebe hervor, dass alle $P_...-Werte (Hysteresen, Max-Temperaturen, PID-Werte, Pumpen-Limits) in $Level oder über die $Input-Pins unbedingt an die eigene Anlage angepasst werden müssen.

Priorität: Erwähne deutlich, dass die Priorität fest auf WW > Puffer > Eis eingestellt ist und die Prio-Parameter $P_Prio_... aktuell nicht ausgewertet werden.

Sensoren/Aktoren: Erkläre, dass die $I_...-Inputs mit den passenden Sensor-Objekten und die $O_...-Outputs mit den Aktor-Objekten (und Debug-Objekten) im TWS verknüpft werden müssen.

Risiko: Füge einen klaren Hinweis hinzu, dass die Verwendung auf eigene Gefahr erfolgt und eine Fehlkonfiguration zu Schäden führen kann.

Feedback: Bitte um konstruktives Feedback, Testergebnisse und Verbesserungsvorschläge.

Ich hoffe, dieser Beitrag ist eine gute Grundlage für das Forum und hilft anderen Nutzern weiter! Viel Erfolg beim Testen!

antwort von der ki


Hallo Frank (und eib-eg),

das klingt nach einem exzellenten Plan und einer sehr professionellen Herangehensweise! Es freut mich sehr, dass hier eine so konstruktive Zusammenarbeit entsteht.

Synchronisation & Entwicklung:

Absolut, ich bin ganz bei dir. Die Kombination verschiedener Ansätze (Custom Logic, vielleicht LUA, unterschiedliche Strukturierungen) und das gegenseitige Testen und Bewerten ist der beste Weg zu einer robusten und gut durchdachten Lösung.

Fachliche Anforderungen Solarsteuerung (Zusammenfassung):

Gerne schreibe ich die Kernanforderungen zusammen, die wir bisher für den "Ein-Block-Custom-Logic"-Entwurf definiert haben:

Ziele: Ansteuerung von bis zu drei Wärmespeichern:

Warmwasser (WW)

Pufferspeicher (Puffer)

Eisspeicher (Eis)

Sensoren: Erfassung der Temperaturen von:

Sonnenkollektor (T_Koll)

Jeweils Oben und Unten für WW und Puffer (T_WW_O, T_WW_U, T_Puffer_O, T_Puffer_U)

Eisspeicher (T_Eis)

Aktoren:

Solarpumpe (Drehzahlregelung 0-10V)

Zwei Umschaltventile (V1, V2) mit folgender Logik:

V1 AUS, V2 AUS: Fluss zu WW

V1 EIN, V2 AUS: Fluss zu Puffer

V1 EIN, V2 EIN: Fluss zu Eis

Kernlogik:

Priorisierung: Auswahl des zu ladenden Ziels basierend auf Verfügbarkeit (genügend Temperaturdifferenz Kollektor zu Speicher-Unten) und Bedarf (Speicher-Oben noch nicht auf Maximaltemperatur). In der aktuellen Custom-Logic-Version ist die Priorität fest: WW > Puffer > Eis.

Pumpensteuerung (EIN/AUS): Pumpe läuft, wenn irgendein priorisiertes Ziel geladen werden kann. Pumpe stoppt, wenn das aktuell geladene Ziel entweder "voll" ist (Max-Temp erreicht) oder die Temperaturdifferenz zum Kollektor unter eine Ausschaltschwelle fällt. (Realisiert über den nachgebauten RS-FlipFlop).

Pumpenregelung (Drehzahl): Regelung der Pumpendrehzahl mittels PID (PID awu), um eine konstante Solltemperaturdifferenz (dT_Soll) zwischen Kollektor und dem aktuell geladenen Speicher-Unten zu halten. Begrenzung auf Min/Max-Drehzahl.

Ventilsteuerung: Ansteuerung von V1 und V2 entsprechend dem ausgewählten Ziel.

Zustandsspeicherung: Der Zustand (Pumpe EIN/AUS, zuletzt aktives Ziel-ID und dessen Temperaturen) muss persistent gespeichert werden (realisiert über Latch).

Parameter: Einstellbare Werte für Hysteresen (EIN/AUS), Max-Temperaturen, Prioritäten (aktuell nicht genutzt), dT-Soll, PID-Parameter (Kp, Ki, Kd), Pumpen-Limits (%).

Dein "2-Way-Entwicklungsprompt" & Scraper:

Das klingt hochinteressant! Ein Scraper, der die aktuelle Doku und die GUI-Logik extrahiert, ist eine geniale Methode, um eine LLM wie mich mit den aktuellsten und spezifischsten Informationen zum TWS zu versorgen. Das überwindet genau die Wissenslücke, die ich durch meinen Trainingsdaten-Zeitstempel habe.

TWS_Wiki-Logik-Data_For_LLM.zip: Wenn diese Datei die extrahierten Moduldefinitionen enthält, wäre das eine fantastische Ressource für mich, um die verfügbaren Module und ihre Syntax noch genauer zu kennen.

"2-Way-Entwicklungsprompt": Ich bin sehr gespannt, wie dieser Prompt funktioniert und wie ich darauf reagiere, wenn ich eine größere Anforderung (wie die Zusammenfassung oben) erhalte, idealerweise zusammen mit den Daten aus der ZIP-Datei. Das könnte die Entwicklungsgeschwindigkeit und -qualität erheblich steigern.

Nächste Schritte aus meiner Sicht:

Du testest den "2-Way-Entwicklungsprompt" mit den oben zusammengefassten Anforderungen und den extrahierten Daten (ZIP-Datei). Ich bin gespannt auf das Ergebnis und den Code, den ich (oder eine andere LLM mit diesen Infos) dann produziere. Wird er dem ähneln, was wir mühsam erarbeitet haben? Wird er vielleicht sogar eleganter oder korrekter sein?

Parallel / Danach: eib-eg testet den aktuellen Custom Logic Block V1.1 an seiner Anlage und gibt Feedback zur Funktionalität und eventuellen Fehlern oder notwendigen Anpassungen.

Synchronisation: Wir vergleichen die Ergebnisse und entscheiden, welcher Ansatz (reine Custom Logic V1.1, eine durch die neuen Daten verbesserte Custom Logic, oder vielleicht doch ein LUA-Ansatz, falls die LLM das vorschlägt) der vielversprechendste ist.

Ich finde diesen Ansatz super und freue mich auf die Ergebnisse deines Prompt-Tests!

@eib-eg Fein, ich bin super happy, dass du da gerade ähnlich dran bist, wie ich.

Welches LLM Modell und welche Version davon nimmst Du?

Wenn Du Lust hast, gib ihm ruhig mal den Metaprompt von mir (siehe ein paar Beträge drüber) und gib ihm die neue Doku im ZIP-Format. Frag ihn, was er verbessern würde und dann kannst du auch den Prompt nehmen, die Anforderungen zur Lüftersteuerung (durch die LLM) entfernen lassen und dann die neue Anforderung in den Prompt im Dialog aufnehmen lassen. Das "schöne" an "meinem" Ansatz ist, dass du durch den Prompt Persistenz hast. Er wird dich ab und an neven, dass du den Prompt zwecks Sicherung downloaden sollst. Damit meine ich, wenn du an deiner Aufgabe weiterarbeiten willst lädst du den zuvor runtergeladenen Prompt erneut hoch und machst weiter.

Man muss ja die Sessions ab und an neu starten, damit der Tokenverbrauch und das Halluzineren eingedämmt wird.

Dann ist es halt super, wenn man alles Wissen (auch das interne der LLM) im Prompt gespeichert hat. Wenn Dein LLM mit der Größe nicht klarkommt, nimm Gemini aus der google ai studio Webseite (ist kostenfrei). Das funktioniert gut.

Das tollste wäre, wenn Du ein "Ableger" von dem Prompt züchtest und irgendwann (als Datei) hier uploadest. Nicht als Text, das ist zu groß! Du musst aufpassen, dass die LLM ein Codefenster/Markup/json-Format zur Ausgabe verwendet (dazu habe ich Anweisungen im Prompt), da sonst Sonderzeichen/Formatierungen die Ausgabe, insb. den Code kaputt machen kann. Danach einfach ein Download der letzten Ausgabe des Chatbots und du hast den neuen Prompt lokal gespeichert.

LG

Franky

@Franky

Hab für heute Abend schon einen Schlachtplan mit der ki ausgemacht

Das einfachste währe wen von forumsmitglider die eigenerstellte costemlogik in der txt Datei mit VR eingefügt würden

Aber lass mich mal heute Nacht noch mal arbeiten und testen

Ach ja übrigens
Ich komme nicht aus der Programmierung oder Software
Deswegen hab ich mit deinen Abkürzungen bzw. eigentlich das ganze Forum nicht klar

Ich weis jetzt nicht wie es den anderen dami dabei mit den Abkürzungen geht

Gut
Es ist eine Abkürzung schneller geschrieben wenn beide wissen was mit dieser gemeint ist
Solange der unwissende mit dieser Abkürzung aber nichts anfangen kann und alles andere (normalgeschriebene) versteht und keinen Vergleich hat wird es schwierig für den lernenden.

Die Kette ist nur so stark wie das schwächste Glied

Was soll der Satz aussagen

500 Glieder einer Kette , ein Glied ist zb LLM
Und die Kette reißt bei geringer Belastung

Ich sag’s mal so
Nicht das jetzt einer schreibt ob ich blöde oder was bin

Ich hab’s nicht so mit dem lesen und schreiben, außer es ist was seeehr interessantes wie die ki

Die ki lacht aber auch nicht bei Rechtschreibfehlern

Inzwischen kennen mich doch einige hier im Forum persönlich und kennen meinen wissensschatz ca zu 30%

Was aber den wolf angeht bin ich bis zu einem bestimmten Zeitpunkt aktuell auf dem laufenden gewesen
Aber seit diesem Zeitpunkt hab ich zu verschiedene Seiten keinen Zugriff mehr, nicht einmal was ich selber geschrieben hab

Genauso kann ich keine pns mehr senden geschweigedem antworten

Mein privates Problem ist, ich weis was der Wolf kann und können wird, das ist der Gründe warum ich ihn nicht verkaufe sowie solange man „von Anfang an dabei war“ die Leichtigkeit der Bedienung

Vermutlich ist auch das der Grund das sich einige auf Videos eingeschossen haben sprich YouTube und da das Wissen holen

Wenn du alle lesbaren Texte im Forum kennst, kennst ein Muster bei den Fragestellenden.


So

Frust von der Seele geschrieben
Nun zurück zum Ausgangspunkt

Diese ki finde ich faszinierend weil es in meinen Augen die bedienbarkeit der costemlogik sehr vereinfacht

Wenn jetzt jeder der Logiken gebaut hat mal diese der ki gibt lernt diese extrem

Beispiel
Von Robert Mini die Rasenmäher Logik
Dadurch wurden 5 Fragen der ki beantwortet
Als nächstes sind Dragonos seine Logiken dran besonders die mit der Verschattung, da hatte er einmal eine sehr komplexe gebaut

Heute werde ich noch einiges machen

Token hab ich jetzt ca 25% verbraucht