[TOP TIPP] Tutorial zu Custom Logiken: Dimm-Aktor

[Robert_Mini]

Hallo zusammen!

Nachfolgend möchte ich Schritt für Schritt einen Dimm-Aktor entwickeln, wie hier diskutiert: viewtopic.php?f=24&t=3944&start=20#p45814

Funktion zu Beginn:
1) Logik empfängt relativen Dimmbefehl als DPT3
2) Logik sendet sofort und dann zyklisch Dimmwerte (ausgehend vom letzten Rückmeldewert) als Absolutwert
3) Stopp-Telegramm des DPT3 oder Erreichen von Min/Max. beendet den Dimmvorgang. Ausgang bleibt am letzten Wert.
4) Schrittweite wird vom DPT3 übernommen, wenn Schrittweite 100% dann vom Eingang "Schrittweite"
5) Bool Einschalteingang sendet direkt 100% mit eigener Rampe - entfällt im Schritt 1
6) Rückmeldung zum Beginn des Dimmvorganges ausgewertet (als Startpunkt der Rampe).

Auf geht's!
Bei Fragen einfach melden.

LG
Robert

[Robert_Mini]

Schritt 1:

Es hat sich für mich bewährt, alle erforderlichen (und zu Beginn bekannten) Ein-/Ausgänge anzulegen. Damit hat man gleich ein "sichtbares Ergebnis" und kann mit den Eingängen in den nächsten Schritten sofort testen.

In rot der Name des Eingangs und gelb der Variablenname:

1) Eingang Dimmbefehlt DPT3 (Rel. Dimmwert / $Dimmbefehl)
2) Eingang Rückmeldeobjekt (Rückmeldung Dimmwert / $RueckmeldungDimmen)
3) Schrittweite (Schrittweite / $Schrittweite)
4) Dauer Dimmvorgang 0-100% (Dauer Dimmvorgang / $DauerDimmen)
5) Begrenzung für oberen/unteren Dimmwert (max. Dimmwert & min. Dimmwert / $DimmwertMax & $DimmwertMin)
6) Statusausgang (Schaltstatus / $StatusSchalten)

Unter der Code dazu. Darin ist auch eine Vorlage vorhanden, die ich standardmäßig als Startpunkt verwende (mit Beispielmodul-Konfigurationen). Damit kann ich Schritt für Schritt einzelne Module ergänzen, speichern und testen...

Unter Input/Output werden die Ein und Ausgänge festgelegt (Sichtbarer Text / Mouseover-Text / Variablenname und Trigger bzw. Sendeoption). Alle Variablen müssen unter Levels definiert werden (mit korrektem Typ und Default-Wert). Detailerklärungen am besten im Wiki nachlesen: https://elabnet.atlassian.net/wiki/spac ... om+Logiken

Danach auf "Logik aktualisieren" drücken und speichern. Damit sollte folgender Baustein vorliegen:

Schritt1_EinAusgaenge_Definieren.png

Code: Alles auswählen

{
    "Level":[
    // Eingänge
	["$I_DimmbefehlRelativ","integer",0],
 	["$I_DimmbefehlAbsolut","integer",0],
	["$I_RueckmeldungDimmen","float",0.0],
	["$I_Schrittweite","float",1.0],
	["$I_DauerDimmen","float",1.0],
	["$I_DimmwertMax","float",1.0],
	["$I_DimmwertMin","float",1.0],
        
    // Ausgänge
	["$O_Dimmwert","float",0.0],
	["$O_StatusSchalten","bool",false]	
    ],
    "Module":[
	
	
	// VORLAGE
	  //["Polynomial", "$Var_x", "$OutputFloat",["$A0", "$A1"]],	
	  //["Ratio","$Zaehler","$OutputFloat","$Nenner"],
	  //["Limiter","$Input1","$OutputFloat","$InputInnerhalb",["$Untergrenze", "$Obergrenze"]],
	  //["Comparator", "$Input1", "$OutputBool", "$Vergleichswert"],
	  //["Multiplexer",["$Input1","$Input2"],"$OutputFloat","$SelectInput"],			
	  //["Or" , ["$Input1","$Input2"], "$OutputBool"],
	  //["And" , ["$Input1","$Input2"], "$OutputBool"],
	  //["Monoflop","$Trigger","$Reset","$TimerStatus","$Dauer",1],  
	  //["Latch","$Input1","$Output","$Trigger",0],     // Übernimmt den Wert von $Input1 auf $Output, wenn Trigger = 0, Option 0/1/2/3 = wenn true/pos. Flanke/neg. Flanke/jede Flanke
	  //["Clocksignal","$Enable","$Takt","$Periode"],   // Zyklischer Trigger, $Takt wechselt jeweils nach Ablauf von $Periode zwischen TRUE/FALSE
	  //["HobbsMeter","$Status","$Time","$Reset"],      // Zaehlt bei $Status = TRUE die Zeit in [h]
	  //["Stopwatch","$Status", "$Time"],               // Stoppt die Zeit in [s] ab $Status = TRUE, bei $Status = FALSE wird auf 0 zurückgesetzt
	  //["CalcFormula",["$Day1Case","$Day2Case","$Day3Case","$Day4Case","$DayEquals"], "$Case", "$Formula3"],
	  //["Cron","$KonstTrue","$Reset",0,"$CronString"],
	  //["Wakeup","$Utime_start","$Status"],
	  //["BinaryMultiplexer",["$In_D","$In_E","$In_F"],"$Output"],
	  //["Triggered", "$InputVar", "$Touched" ],        // Touched = TRUE, wenn der Eingang $InputVar die Logik getriggert hat
	  //["SendExplicit","$Send","$OutputVar",0],        // Sendet Ausgang $OutputVar, abhängig von $Send 0/1/2/3 (Paramter analog Latch), ACHTUNG "x" am Output setzen!
	  //["Interpolation","$In", "$Out", [ [x1,y1] , [x2,y2] , ... , [xn,yn ] ] ]  **/
    ],
    "Input":[
        ["Relativer Dimmwert","Eingang Dimmbefehlt DPT3","$I_DimmbefehlRelativ","c"],
        ["Absoluter Dimmwert","Eingang Dimmbefehlt 0-100%","$I_DimmbefehlAbsolut","c"],
        ["Rückmeldung Dimmwert","Eingang Rückmeldeobjekt Dimmen","$I_RueckmeldungDimmen","c"],
        ["Schrittweite","Schrittweite","$I_Schrittweite","c"],
        ["Dauer Dimmvorgang","Dauer Dimmvorgang 0-100%","$I_DauerDimmen","c"],
        ["max. Dimmwert","max. Dimmwert","$I_DimmwertMax","c"],
        ["min. Dimmwert","min. Dimmwert","$I_DimmwertMin","c"]
    ],
    "Output":[
        ["Absolut Dimmwert","Output absoluter Dimmwert 0-100%","$O_Dimmwert","c"],
        ["Schaltstatus","Status Schalten","$O_StatusSchalten","c"]
    ]
}

[Robert_Mini]

Schritt 2:

Die Funktion grob skizzieren:

1) Logik empfängt Dimmbefehl ==>
2) Richtung auswerten ==>
3) Zykluszeit berechnen ==>
4) Startwert vom Rückmeldeeingang übernehmen ==>
5) Dimmwert_Neu berechnen (Dimmwert_alt +/- Schrittweite ==>
6) Neuen Dimmwert mit Grenzen vergleichen ==>
7) Wenn Grenze nicht erreicht ==> zyklischen Trigger aktivieren ==>
8) Dimmwert vor Ausgabe auf Min/Max begrenzen

[Robert_Mini]

Schritt 3:

Funktion in Module "übersetzen" und weiter detaillieren:

1) Logik empfängt Dimmbefehl ==> Modul Triggered am Eingang Dimmbefehl auswerten
2) Richtung auswerten ==> Modul Binär-Demultiplexer
3) Zykluszeit berechnen ==> später
4) Startwert vom Rückmeldeeingang übernehmen (wenn per Dimmbefehl getriggert wurde und Dimmvorgang noch inaktiv) ==> Modul Latch
5) Dimmwert_Neu berechnen (Dimmwert_alt +/- Schrittweite ==> Modul Polynom: y = a + bx mit x +1/-1 je nach Dimmrichtung
6) Neuen Dimmwert mit Grenzen vergleichen ==> Modul Comparator oder Modul Limiter (Eingangswert innerhalb Grenzen ja/nein)
7) Wenn Grenze nicht erreicht ==> zyklischen Trigger aktivieren ==> Modul Clocksignal
8) Dimmwert vor Ausgabe auf Min/Max begrenzen => Modul Limiter, kann mit 6) kombiniert werden

[Robert_Mini]

Schritt 4:

Im nächsten Schritt werden die ersten Module hinzugefügt:
- Trigger auswerten
- DPT3 zerlegen
- Letzten Dimmwert merken

Dazu sind auch ein paar neue Variablen erforderlich: $bit0b bis $bit3b, $DimmRelTouched, "$DimmwertLast.

Weiters sind 2 temporäre Ausgänge hinzugekommen, damit man gleich testen kann (Zwischenstand des Codes unter dem Screenshot).

Zum Testen den DokMode aktivieren (Das Stethoskop-Symbol) und dann in folgender Reihenfolgen
1) 30 am Eingang "Rückmeldung Dimmwert" eingeben => 30 wird übernommen, nichts weiter passiert.
2) am Eingang "Relativer Dimmwert" den Wert 1 eingeben => 30 wird auf den Ausgang "Debug_Out DimmwertLast" übernommen (Modul "Triggered" erkennt die Eingabe und löst damit "Latch" aus, wodurch der Wert auf "$DimmwertLast" übernommen wird)
3) 15 als re. Dimmwert eingeben eingeben => "Debug_Out Bit4" wird true. Damit wird die positive Dimmrichtung erkannt (Werte >=8).

Das sollte dann so aussehen:

Schritt4_ErsteModule_DokMode.png

Code: Alles auswählen

/**===========================================================
Kommentar 
============================================================*/
{
    "Level":[
        // Eingänge
        ["$I_DimmbefehlRelativ","integer",0],
        ["$I_DimmbefehlAbsolut","integer",0],
	["$I_RueckmeldungDimmen","float",0.0],
	["$I_Schrittweite","float",1.0],
	["$I_DauerDimmen","float",1.0],
	["$I_DimmwertMax","float",1.0],
	["$I_DimmwertMin","float",1.0],
        
        // Ausgänge
        ["$O_Dimmwert","float",0.0],
	["$O_StatusSchalten","bool",false],
		
	["$DimmRelTouched","bool",false],
	["$DimmwertLast","float",0.0],
		
	["$Bit0b","bool",false],
	["$Bit1b","bool",false],
	["$Bit2b","bool",false],
	["$Bit3b","bool",false]
		
    ],
    "Module":[
	["Triggered", "$I_DimmbefehlRelativ", "$DimmRelTouched" ],
	["BinaryDemultiplexer","$I_DimmbefehlRelativ",["$Bit0b","$Bit1b","$Bit2b","$Bit3b"]],
	["Latch","$I_RueckmeldungDimmen","$DimmwertLast","$DimmRelTouched",1]
	
	// VORLAGE
	  //["Polynomial", "$Var_x", "$OutputFloat",["$A0", "$A1"]],	
      	  //["Ratio","$Zaehler","$OutputFloat","$Nenner"],
	  //["Limiter","$Input1","$OutputFloat","$InputInnerhalb",["$Untergrenze", "$Obergrenze"]],
	  //["Comparator", "$Input1", "$OutputBool", "$Vergleichswert"],
    	  //["Multiplexer",["$Input1","$Input2"],"$OutputFloat","$SelectInput"],			
	  //["Or" , ["$Input1","$Input2"], "$OutputBool"],
	  //["And" , ["$Input1","$Input2"], "$OutputBool"],
	  //["Monoflop","$Trigger","$Reset","$TimerStatus","$Dauer",1],  
	  //["Latch","$Input1","$Output","$Trigger",0],     // Übernimmt den Wert von $Input1 auf $Output, wenn Trigger = 0, Option 0/1/2/3 = wenn true/pos. Flanke/neg. Flanke/jede Flanke
	  //["Clocksignal","$Enable","$Takt","$Periode"],   // Zyklischer Trigger, $Takt wechselt jeweils nach Ablauf von $Periode zwischen TRUE/FALSE
	  //["HobbsMeter","$Status","$Time","$Reset"],      // Zaehlt bei $Status = TRUE die Zeit in [h]
	  //["Stopwatch","$Status", "$Time"],               // Stoppt die Zeit in [s] ab $Status = TRUE, bei $Status = FALSE wird auf 0 zurückgesetzt
     	  //["CalcFormula",["$Day1Case","$Day2Case","$Day3Case","$Day4Case","$DayEquals"], "$Case", "$Formula3"],
	  //["Cron","$KonstTrue","$Reset",0,"$CronString"],
	  //["Wakeup","$Utime_start","$Status"],
	  //["BinaryMultiplexer",["$In_D","$In_E","$In_F"],"$Output"],
	  //["Triggered", "$InputVar", "$Touched" ],        // Touched = TRUE, wenn der Eingang $InputVar die Logik getriggert hat
	  //["SendExplicit","$Send","$OutputVar",0],        // Sendet Ausgang $OutputVar, abhängig von $Send 0/1/2/3 (Paramter analog Latch), ACHTUNG "x" am Output setzen!
	  //["Interpolation","$In", "$Out", [ [x1,y1] , [x2,y2] , ... , [xn,yn ] ] ]  **/
    ],
    "Input":[
        ["Relativer Dimmwert","Eingang Dimmbefehlt DPT3","$I_DimmbefehlRelativ","c"],
        ["Absoluter Dimmwert","Eingang Dimmbefehlt 0-100%","$I_DimmbefehlAbsolut","c"],
        ["Rückmeldung Dimmwert","Eingang Rückmeldeobjekt Dimmen","$I_RueckmeldungDimmen","c"],
        ["Schrittweite","Schrittweite","$I_Schrittweite","c"],
        ["Dauer Dimmvorgang","Dauer Dimmvorgang 0-100%","$I_DauerDimmen","c"],
        ["max. Dimmwert","max. Dimmwert","$I_DimmwertMax","c"],
        ["min. Dimmwert","min. Dimmwert","$I_DimmwertMin","c"]
    ],
    "Output":[
        ["Absolut Dimmwert","Output absoluter Dimmwert 0-100%","$O_Dimmwert","c"],
        ["Schaltstatus","Status Schalten","$O_StatusSchalten","c"],
        ["Debug_Out Bit4","Dimmrichtung","$Bit3b","c"],
        ["Debug_Out DimmwertLast","Startwert","$DimmwertLast","c"]
    ]
}

[alexbeer]

Hey Robert, danke dass du deine Best Practice bzgl Herangehensweise an eine neue Logik- Anforderung so wunderbar und verständlich nachvollziehbar aufbereitet hast.

[Robert_Mini]

Schritt 5:

Im nächsten Schritt wird je nach Dimmrichtung ($bit3b) der Multiplikator +1 oder -1 ausgewählt und auf $DimmRichtung gespeichert.

Mittels Polynom wird der neue Dimmwert berechnet: $DimmwertLast+$Dimmrichtung * $I_Schrittweite. Das Ergebnis wird auf die zusätzliche Variable $DimmwertNeu gespeichert.

Später muss die Schrittweite noch weiter aufgesplittet werden (abhängig von DPT3 oder externer Vorgabe).

Wieder mit ein paar Werten 7 / 15 testen. In Grafana kann man statt weiterer "Debug-Ausgänge" sofort das Verhalten prüfen.
Man sieht, dass $DimmRichtung zwischen -1 und +1 wechselt und DimmwertNeu von 30 auf 35 bzw. 25 wechselt.
Auf 25 deshalb, weil im Moment immer vom Rückmeldewert 30 weggerechnet wird (manuell eingegeben). Dieses Verhalten wird mit dem nächsten Schritt angegangen (Berechnung im Bezug auf den letzten Dimmwert).

Schritt5_Test_Grafana.png

Code: Alles auswählen

/**===========================================================
Kommentar 
============================================================*/
{
    "Level":[
    // Eingänge
	["$I_DimmbefehlRelativ","integer",0],
	["$I_DimmbefehlAbsolut","integer",0],
	["$I_RueckmeldungDimmen","float",0.0],
	["$I_Schrittweite","float",5.0],
	["$I_DauerDimmen","float",10.0],
	["$I_DimmwertMax","float",100.0],
	["$I_DimmwertMin","float",0.0],
        
    // Ausgänge
	["$O_Dimmwert","float",0.0],
	["$O_StatusSchalten","bool",false],
		
	["$DimmRelTouched","bool",false],
	["$DimmwertLast","float",0.0],
	["$DimmwertNeu","float",0.0],
	["$DimmRichtung","float",0.0],
		
	["$Bit0b","bool",false],
	["$Bit1b","bool",false],
	["$Bit2b","bool",false],
	["$Bit3b","bool",false],
	["$Konst1","float",1.0],
	["$KonstTrue","bool",true]
	
    ],
    "Module":[
	["Triggered", "$I_DimmbefehlRelativ", "$DimmRelTouched" ],
	["BinaryDemultiplexer","$I_DimmbefehlRelativ",["$Bit0b","$Bit1b","$Bit2b","$Bit3b"]],
	["Latch","$I_RueckmeldungDimmen","$DimmwertLast","$DimmRelTouched",1],
	["Multiplexer",["-$Konst1","$Konst1"],"$DimmRichtung","$Bit3b"],
	["Polynomial", "$DimmRichtung", "$DimmwertNeu",["$DimmwertLast", "$I_Schrittweite"]]
	
	// VORLAGE
	  //["Polynomial", "$Var_x", "$OutputFloat",["$A0", "$A1"]],	
	  //["Ratio","$Zaehler","$OutputFloat","$Nenner"],
	  //["Limiter","$Input1","$OutputFloat","$InputInnerhalb",["$Untergrenze", "$Obergrenze"]],
	  //["Comparator", "$Input1", "$OutputBool", "$Vergleichswert"],
	  //["Multiplexer",["$Input1","$Input2"],"$OutputFloat","$SelectInput"],			
	  //["Or" , ["$Input1","$Input2"], "$OutputBool"],
	  //["And" , ["$Input1","$Input2"], "$OutputBool"],
	  //["Monoflop","$Trigger","$Reset","$TimerStatus","$Dauer",1],  
	  //["Latch","$Input1","$Output","$Trigger",0],     // Übernimmt den Wert von $Input1 auf $Output, wenn Trigger = 0, Option 0/1/2/3 = wenn true/pos. Flanke/neg. Flanke/jede Flanke
	  //["Clocksignal","$Enable","$Takt","$Periode"],   // Zyklischer Trigger, $Takt wechselt jeweils nach Ablauf von $Periode zwischen TRUE/FALSE
	  //["HobbsMeter","$Status","$Time","$Reset"],      // Zaehlt bei $Status = TRUE die Zeit in [h]
	  //["Stopwatch","$Status", "$Time"],               // Stoppt die Zeit in [s] ab $Status = TRUE, bei $Status = FALSE wird auf 0 zurückgesetzt
	  //["CalcFormula",["$Day1Case","$Day2Case","$Day3Case","$Day4Case","$DayEquals"], "$Case", "$Formula3"],
	  //["Cron","$KonstTrue","$Reset",0,"$CronString"],
	  //["Wakeup","$Utime_start","$Status"],
	  //["BinaryMultiplexer",["$In_D","$In_E","$In_F"],"$Output"],
	  //["Triggered", "$InputVar", "$Touched" ],        // Touched = TRUE, wenn der Eingang $InputVar die Logik getriggert hat
	  //["SendExplicit","$Send","$OutputVar",0],        // Sendet Ausgang $OutputVar, abhängig von $Send 0/1/2/3 (Paramter analog Latch), ACHTUNG "x" am Output setzen!
	  //["Interpolation","$In", "$Out", [ [x1,y1] , [x2,y2] , ... , [xn,yn ] ] ]  **/
    ],
    "Input":[
        ["Relativer Dimmwert","Eingang Dimmbefehlt DPT3","$I_DimmbefehlRelativ","c"],
        ["Absoluter Dimmwert","Eingang Dimmbefehlt 0-100%","$I_DimmbefehlAbsolut","c"],
        ["Rückmeldung Dimmwert","Eingang Rückmeldeobjekt Dimmen","$I_RueckmeldungDimmen","c"],
        ["Schrittweite","Schrittweite","$I_Schrittweite","c"],
        ["Dauer Dimmvorgang","Dauer Dimmvorgang 0-100%","$I_DauerDimmen","c"],
        ["max. Dimmwert","max. Dimmwert","$I_DimmwertMax","c"],
        ["min. Dimmwert","min. Dimmwert","$I_DimmwertMin","c"]
    ],
    "Output":[
        ["Absolut Dimmwert","Output absoluter Dimmwert 0-100%","$O_Dimmwert","c"],
        ["Schaltstatus","Status Schalten","$O_StatusSchalten","c"],
        ["Debug_Out Bit4","Dimmrichtung","$Bit3b","c"],
        ["Debug_Out DimmwertLast","Startwert","$DimmwertLast","c"],
        ["Debug_Out DimmwertNeu","Startwert","$DimmwertNeu","c"]
    ]
}

[Robert_Mini]

Schritt 6:

Der nächste Schritt ist etwas umfangreicher, war aber nicht sinnvoll trennbar.
Es war nun auch höchste Zeit, im Code sauber zu kommentieren!

Im einzelnen:
1) Die wesentliche Ergänzung ist das Modul Clocksignal. Damit wird die Logik zyklisch im Intervall $DauerDimmen aufgerufen). Sollte ggf. später auf $DauerDimmIntervall umbenannt werden.
2) Um zu erkennen, ob Clocksignal die Logik aufgerufen hat, wird zu Beginn immer der letzte $Takt gespeichert (Latch Zeile 2)
3) $DimmwertNeu wird nur dann auf den Ausgang übernommen, wenn $Takt <> $TaktLast

4) In Zeile 1 wird nun der letzte Ausgangswert $O_Dimmwert auf $DimmwertLast gespeichert.

5) UND Verknüpfung: Getriggert & DPT3>0 & StatusDimmen==False => $DimmenRelativStart = True
6) Zusätzliche Variable $StatusDimmen wird True, wenn $DimmenRelativStart == True
7) Die Übernahme des Rückmeldewertes wird ebenfalls auf diese Bedingung $DimmenRelativStart == True geändert. Damit wird verhindert, dass ein Rückmeldeobjektes während eines Dimmvorganges übernommen wird.

8) Stopp-Telegramm erkennen (UND Getriggert & DPT3==0 & $StatusDimmen==True => $DimmenRelativStopp = True)
9) $DimmenRelativStopp = True ==> $StatusDimmen wieder auf False setzen.

10) Sehr speziell (aber hier kommt Erfahrung ins Spiel): $TaktLast muss beim Ende des Dimmvorganges ebenfalls auf false gesetzt werden, da der Takt des Clocksignal immer mit True startet. Ansonsten würde je nach Zustand des Clocksignals beim Dimmende manchmal der nächste Dimmvorgang erst beim 2. Takt gestartet.
HINWEIS: Latch TriggerType = 2 für fallende Flanke


In Grafana habe ich folgendes getestet:
1) Start Dimmvorgang => Dimmwert zählt periodisch hoch
2) Änderung Rückmeldeobjekt => Dimmwert wird nicht verändert, da Clocksignal nicht abgelaufen ist (22:51:35). ClockTriggered wird kurzzeitig false!
3) Stopp-Telegramm => Dimmwert bleibt erhalten, Dimmvorgang endet, kein weiterer Trigger durch Clocksignal, da nun inaktiv.

Schritt6_Grafana_NotSent.png

Schritt6_Grafana_ClocksignalTrigger.png

Code: Alles auswählen

/**===========================================================
Kommentar 
============================================================*/
{
    "Level":[
    // Eingänge
	["$I_DimmbefehlRelativ","integer",0],
	["$I_DimmbefehlAbsolut","integer",0],
	["$I_RueckmeldungDimmen","float",0.0],
	["$I_Schrittweite","float",5.0],
	["$I_DauerDimmen","float",10.0],
	["$I_DimmwertMax","float",100.0],
	["$I_DimmwertMin","float",0.0],
        
    // Ausgänge
	["$O_Dimmwert","float",0.0],
	["$O_StatusSchalten","bool",false],
	
	["$StatusDimmen","bool",false],
		
	["$DimmRelTouched","bool",false],
	["$DimmenRelativStart","bool",false],
	["$DimmenRelativStopp","bool",false],
	
	["$DimmwertLast","float",0.0],
  	["$DimmwertNeu","float",0.0],
	["$DimmRichtung","float",0.0],
		
	["$Bit0b","bool",false],
	["$Bit1b","bool",false],
	["$Bit2b","bool",false],
	["$Bit3b","bool",false],
	["$Konst1","float",1.0],
	["$KonstTrue","bool",true],
	["$KonstFalse","bool",false],
	
	["$Takt","bool",false],
	["$TaktLast","bool",false],
	["$ClockTriggered","bool",false]
	
    ],
    "Module":[
	// Werte des letzten Aufrufs abspeichern
	["Latch","$O_Dimmwert","$DimmwertLast","$KonstTrue",0],
	["Latch","$Takt","$TaktLast","$KonstTrue",0],
	
	// Auswerten, ob Eingang Rel. Dimmen getriggert wurde
	["Triggered", "$I_DimmbefehlRelativ", "$DimmRelTouched" ],
	// Nur wenn Wert >0 und Dimmen noch nicht aktiv, StatusDimmmen auf True setzen
	["And" , ["$DimmRelTouched","$I_DimmbefehlRelativ","-$StatusDimmen"], "$DimmenRelativStart"],
	["Latch","$KonstTrue","$StatusDimmen","$DimmenRelativStart",1],
	["Latch","$I_RueckmeldungDimmen","$DimmwertLast","$DimmenRelativStart",1],
	
	// Stopp Telegramm auswerten und Dimmen stoppen
	["And" , ["$DimmRelTouched","-$I_DimmbefehlRelativ","$StatusDimmen"], "$DimmenRelativStopp"],
	["Latch","$KonstFalse","$StatusDimmen","$DimmenRelativStopp",1],
	// Bei negativer Flanke auch Takt zurücksetzen, damit nächster Dimmvorgang korrekt erkannt wird
	["Latch","$KonstFalse","$TaktLast","$StatusDimmen",2],
	
	// Dimmrichtung aus DPT3 ermitteln
	["BinaryDemultiplexer","$I_DimmbefehlRelativ",["$Bit0b","$Bit1b","$Bit2b","$Bit3b"]],
	// Dimmrichtung auf -1/+1 setzen und neuen Dimmwert berechnen
	["Multiplexer",["-$Konst1","$Konst1"],"$DimmRichtung","$Bit3b"],
  	["Polynomial", "$DimmRichtung", "$DimmwertNeu",["$DimmwertLast", "$I_Schrittweite"]],
  	
  	// Taktgeber starten
  	["Clocksignal","$StatusDimmen","$Takt","$I_DauerDimmen"],
	// Taktsignal mit letztem Wert vergleichen: wenn ungleich => Taktgeber hat getriggert => Wert auf Ausgang übernehmen
  	["Limiter","$Takt",0,"-$ClockTriggered",["$TaktLast", "$TaktLast"]],
  	["Latch","$DimmwertNeu","$O_Dimmwert","$ClockTriggered",0]
	
	// VORLAGE
	  //["Polynomial", "$Var_x", "$OutputFloat",["$A0", "$A1"]],	
	  //["Ratio","$Zaehler","$OutputFloat","$Nenner"],
	  //["Limiter","$Input1","$OutputFloat","$InputInnerhalb",["$Untergrenze", "$Obergrenze"]],
	  //["Comparator", "$Input1", "$OutputBool", "$Vergleichswert"],
	  //["Multiplexer",["$Input1","$Input2"],"$OutputFloat","$SelectInput"],			
	  //["Or" , ["$Input1","$Input2"], "$OutputBool"],
	  //["And" , ["$Input1","$Input2"], "$OutputBool"],
	  //["Monoflop","$Trigger","$Reset","$TimerStatus","$Dauer",1],  
	  //["Latch","$Input1","$Output","$Trigger",0],     // Übernimmt den Wert von $Input1 auf $Output, wenn Trigger = 0, Option 0/1/2/3 = wenn true/pos. Flanke/neg. Flanke/jede Flanke
	  //["Clocksignal","$Enable","$Takt","$Periode"],   // Zyklischer Trigger, $Takt wechselt jeweils nach Ablauf von $Periode zwischen TRUE/FALSE
	  //["HobbsMeter","$Status","$Time","$Reset"],      // Zaehlt bei $Status = TRUE die Zeit in [h]
	  //["Stopwatch","$Status", "$Time"],               // Stoppt die Zeit in [s] ab $Status = TRUE, bei $Status = FALSE wird auf 0 zurückgesetzt
	  //["CalcFormula",["$Day1Case","$Day2Case","$Day3Case","$Day4Case","$DayEquals"], "$Case", "$Formula3"],	  
	  //["Cron","$KonstTrue","$Reset",0,"$CronString"],
	  //["Wakeup","$Utime_start","$Status"],
	  //["BinaryMultiplexer",["$In_D","$In_E","$In_F"],"$Output"],
	  //["Triggered", "$InputVar", "$Touched" ],        // Touched = TRUE, wenn der Eingang $InputVar die Logik getriggert hat
	  //["SendExplicit","$Send","$OutputVar",0],        // Sendet Ausgang $OutputVar, abhängig von $Send 0/1/2/3 (Paramter analog Latch), ACHTUNG "x" am Output setzen!
	  //["Interpolation","$In", "$Out", [ [x1,y1] , [x2,y2] , ... , [xn,yn ] ] ]  **/
    ],
    "Input":[
        ["Relativer Dimmwert","Eingang Dimmbefehlt DPT3","$I_DimmbefehlRelativ","c"],
        ["Absoluter Dimmwert","Eingang Dimmbefehlt 0-100%","$I_DimmbefehlAbsolut","c"],
        ["Rückmeldung Dimmwert","Eingang Rückmeldeobjekt Dimmen","$I_RueckmeldungDimmen","c"],
        ["Schrittweite","Schrittweite","$I_Schrittweite","c"],
        ["Dauer Dimmvorgang","Dauer Dimmvorgang 0-100%","$I_DauerDimmen","c"],
        ["max. Dimmwert","max. Dimmwert","$I_DimmwertMax","c"],
        ["min. Dimmwert","min. Dimmwert","$I_DimmwertMin","c"]
    ],
    "Output":[
        ["Absolut Dimmwert","Output absoluter Dimmwert 0-100%","$O_Dimmwert","c"],
        ["Schaltstatus","Status Schalten","$O_StatusSchalten","c"],
        ["Debug_Out Bit4","Dimmrichtung","$Bit3b","c"],
        ["Debug_Out DimmwertLast","Startwert","$DimmwertLast","c"],
        ["Debug_Out DimmwertNeu","Startwert","$DimmwertNeu","c"],
        ["Debug_Out StatusDimmen","aktiver Dimmvorgang?","$StatusDimmen","c"]
    ]
}

[Mibr85]

Hallo Robert
Vielen Dank für diese super ausführliche gut verständlich Ausführung
Die muss definitiv als Beispiel ins Wiki übernommen werden.
Echt starke Leistung

[maggyver]

Hallo Robert,

da hast du ganz ordentlich etwas sehr ausführlich und auf einfachste Weise dargestellt.

Das gefällt mir sehr gut.