UPGRADE IP 9 verfügbar!
Timberwolf VISU jetzt mit NEUEM Layout Editor
Freie Anordnung, Reihenfolge und Größe der Widgets - viele weitere Verbesserungen
Infos im Wiki: https://elabnet.atlassian.net/l/cp/06SeuHRJ

NEU! Insider & Leistungsmerkmale FÜR ALLE freigeschaltet
Damit kann nun jeder das Upgrade vornehmen und VISU & IFTTT testen. Alle Info hier: viewtopic.php?f=8&t=5074

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

Hier stellen Foristen und Kunden Ihre EIGENEN Logikbausteine vor. Diese Logikbausteine stehen jedem im Rahmen der vom Autor eingeräumten / genannten Lizenz zur Verfügung.
Forumsregeln
  • Denke bitte an aussagekräftige Titel und gebe dort auch die [Firmware] an. Wenn ETS oder CometVisu beteiligt sind, dann auch deren Version
  • Bitte mache vollständige Angaben zu Deinem Server, dessen ID und dem Online-Status in Deiner Signatur. Hilfreich ist oft auch die Beschreibung der angeschlossener Hardware sowie die verwendeten Protokolle
  • Beschreibe Dein Projekt und Dein Problem bitte vollständig. Achte bitte darauf, dass auf Screenshots die Statusleiste sichtbar ist
  • Bitte sei stets freundlich und wohlwollend, bleibe beim Thema und unterschreibe mit deinem Vornamen. Bitte lese alle Regeln, die Du hier findest: https://wiki.timberwolf.io/Forenregeln

Ersteller
Robert_Mini
Reactions:
Beiträge: 3741
Registriert: So Aug 12, 2018 8:44 am
Hat sich bedankt: 1164 Mal
Danksagung erhalten: 2058 Mal

#11

Beitrag von Robert_Mini »

maggyver hat geschrieben: Mo Feb 27, 2023 8:19 pm da hast du ganz ordentlich etwas sehr ausführlich und auf einfachste Weise dargestellt.
Der Benchmark ist deine Freundin :laughing-rolling: :dance:

Es geht heute (hoffentlich) noch weiter.

Danke und Lg
Robert
Timberwolf Server 2500 / #117 (VPN offen + reboot nach Rückfrage) / zusätzlich: 3500M/#935, 3500L/#1297

Ersteller
Robert_Mini
Reactions:
Beiträge: 3741
Registriert: So Aug 12, 2018 8:44 am
Hat sich bedankt: 1164 Mal
Danksagung erhalten: 2058 Mal

#12

Beitrag von Robert_Mini »

Kurze Zwischenbilanz:

aus Schritt 3 (viewtopic.php?f=65&t=4128&sid=77be421a8 ... fcf#p45910) sind nun die Punkte 1-5 und 7 erreicht. Die Begrenzung durch Min/Max-Dimmwert ist noch offen und folgt in diesem Schritt.

Schritt 7:

Eigentlich hätte ich dafür einfach einen Limiter nachgeschaltet, der den Dimmwert nach oben und unten beschränkt. Damit würde aber beim Dimmen aus dem ausgeschalteten Zustand, der Sollwert sofort auf Min. Dimmwert springen.

Deshalb habe ich nun die Grenzwerte mittels Comparator umgesetzt, wobei nur jener Wert verglichen wird, der "in Dimmrichtung" liegt (max. Dimmwert für Hochdimmen und min. Dimmwert für Zurückdimmen).

Code: Alles auswählen

// Dimmgrenzen prüfen
    ["Comparator", "-$DimmwertNeu", "-$DimmwertMax_CResult", "-$I_DimmwertMax"],   // >= daher alles invertiert!
    ["Comparator", "$DimmwertNeu", "-$DimmwertMin_CResult", "$I_DimmwertMin"],       // <= daher nur Ausgang invertiert

// Min/Max. Dimmwert auf Ausgang übernehmen, wenn neuer Wert außerhalb der Grenzen liegt und Dimmenvorgang aktiv
    ["And" , ["$DimmwertMax_CResult","$Bit3b","$StatusDimmen"], "$LimitMax"],
    ["Latch","$I_DimmwertMax","$O_Dimmwert","$LimitMax",0],
    ["And" , ["$DimmwertMin_CResult","-$Bit3b","$StatusDimmen"], "$LimitMin"],
    ["Latch","$I_DimmwertMin","$O_Dimmwert","$LimitMin",0],
Zusätzlich muss sichergestellt sein, das der zyklische Trigger beendet (oder nicht gestartet) wird, wenn der neue Dimmwert bereits außerhalb der Dimmgrenzen liegt ==> $StatusDimmen = false

Code: Alles auswählen

// Wenn obere oder untere Grenze erreicht, Dimmvorgang abbrechen (IMMER, daher Latch Triggeroption=0)
    ["Or" , ["$LimitMin","$LimitMax"], "$DimmenStop"],
    ["Latch","$KonstFalse","$StatusDimmen","$DimmenStop",0],
In Grafana kann man sehr schön das Verhalten studieren. Es wird sozusagen in die Dimmgrenzen hineingedimmt.
Nach dem Erreichen des Grenzwertes wird das zyklische Triggern korrekt beendet.

HINWEIS: Im Test muss (ohne Aktor) aktuell die Rückmeldung nach Ende des Dimmvorganges im Dokmode manuell gesetzt werden.

Schritt7_Grafana_WithLimits.png

Hier der aktuelle Gesamtcode (inkl. der zusätzlichen Variablendefinitionen:

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],

	["$DimmwertMax_CResult","bool",false],
	["$DimmwertMin_CResult","bool",false],
	["$LimitMax","bool",false],
	["$LimitMin","bool",false],
	["$DimmenStop","bool",false],
		
	["$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"]],
  	
    // Dimmgrenzen prüfen
    ["Comparator", "-$DimmwertNeu", "-$DimmwertMax_CResult", "-$I_DimmwertMax"],   // >= daher alles invertiert!
    ["Comparator", "$DimmwertNeu", "-$DimmwertMin_CResult", "$I_DimmwertMin"],       // <= daher nur Ausgang invertiert

    // Min/Max. Dimmwert auf Ausgang übernehmen, wenn neuer Wert außerhalb der Grenzen liegt und Dimmenvorgang aktiv
    ["And" , ["$DimmwertMax_CResult","$Bit3b","$StatusDimmen"], "$LimitMax"],
    ["Latch","$I_DimmwertMax","$O_Dimmwert","$LimitMax",0],
    ["And" , ["$DimmwertMin_CResult","-$Bit3b","$StatusDimmen"], "$LimitMin"],
    ["Latch","$I_DimmwertMin","$O_Dimmwert","$LimitMin",0],
    
    // Wenn obere oder untere Grenze erreicht, Dimmvorgang abbrechen (IMMER, daher Latch Triggeroption=0)
    ["Or" , ["$LimitMin","$LimitMax"], "$DimmenStop"],
    ["Latch","$KonstFalse","$StatusDimmen","$DimmenStop",0],
  	
  	// 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"]
    ]
}
Du hast keine ausreichende Berechtigung, um die Dateianhänge dieses Beitrags anzusehen.
Zuletzt geändert von Robert_Mini am Mo Feb 27, 2023 11:27 pm, insgesamt 1-mal geändert.
Timberwolf Server 2500 / #117 (VPN offen + reboot nach Rückfrage) / zusätzlich: 3500M/#935, 3500L/#1297
Benutzeravatar

Parsley
Reactions:
Beiträge: 525
Registriert: Di Okt 09, 2018 7:27 am
Wohnort: 490..
Hat sich bedankt: 587 Mal
Danksagung erhalten: 351 Mal

#13

Beitrag von Parsley »

Hi Robert,

ein ganz großes Dankeschön von mir! Tolle Anleitung!

LG Lukas
Gruß Parsley


Timberwolf Server 3500L #657 (VPN offen, reboot nach Absprache)

Ersteller
Robert_Mini
Reactions:
Beiträge: 3741
Registriert: So Aug 12, 2018 8:44 am
Hat sich bedankt: 1164 Mal
Danksagung erhalten: 2058 Mal

#14

Beitrag von Robert_Mini »

Schritt 8:

Im nächsten Schritt wird noch die Schrittweite aus dem DPT3 übersetzt (Danke an Maggyver für viewtopic.php?f=24&t=3944&start=10#p45788).
Wenn Schrittweite 100%, dann wird die Schrittweite aus dem Eingang "Schrittweite" verwendet, ansonsten die % die im DPT3 festgelegt sind. Ich hoffe das passt so.

BIN 000 = Schrittweite 0 = Stopp
BIN 001 = Schrittweite 1 = 100%
BIN 010 = Schrittweite 2 = 50%
BIN 011 = Schrittweite 3 = 25%
BIN 100 = Schrittweite 4 = 12,5%
BIN 101 = Schrittweite 5 = 6%
BIN 110 = Schrittweite 6 = 3%
BIN 111 = Schrittweite 7 = 1%

Dies lässt sich perfekt mit dem Multiplexer umsetzen. Eine Zeile reicht :-)

Man muss dazu noch verstehen, dass der Integerwert des DPT3 auch das Bit4 für die Richtung berücksichtigt. D.g. der zulässige Wert liegt zwischen 0 und 15, d.h. die Schrittweite wiederholt sich von 9-15. Der Wert 8 ist ein Stopp-Telegramm, unabhängig von den ersten 3 Bits.

Code: Alles auswählen

  	// Schrittweite aus DPT3 umrechnen:
  	["Multiplexer",["$Konst0","$I_Schrittweite","$Konst50","$Konst25","$Konst12_5","$Konst6","$Konst3","$Konst1","$Konst0","$I_Schrittweite","$Konst50","$Konst25","$Konst12_5","$Konst6","$Konst3","$Konst1"],"$Schrittweite","$I_DimmbefehlRelativ"],
Zusätzlich muss die Variable im Polynom von $I_Schrittweite auf $Schrittweite angepasst werden.

Code: Alles auswählen

  	["Polynomial", "$DimmRichtung", "$DimmwertNeu",["$DimmwertLast", "$Schrittweite"]],
In folgendem Screenshot sieht man das Dimmverhalten, mit variablen Schrittweiten, die auch dynamisch auf den Eingang reagieren (auch wenn KNX kein geändertes DPT3 ohne Stoppdiagramm schicken kann) - aber schadet ja nicht. Dabei ist mir auch ein Fehler aufgefallen: Der Dimmwert kann unter gewissen Umständen doch außerhalb der Dimmgrenzen liegen.

Schritt8_Grafana_Dimmoutput.png

Im DokMode findet man:
- $LimitMin=true ist korrekt und der Ausgang wird dem min. Dimmwert überschrieben
- $StatusDimmen=false ebenfalls korrekt
- $ClockTriggered ist aber ebenfalls true! Damit gewinnt am Ende der Logik doch noch der neu berechnete Dimmwert!

Ein zusätzlicher UND-Baustein löst dieses Problem:

Code: Alles auswählen

  	// Wert nur übernehmen, wenn Dimmvorgang aktiv und Taktsignal getriggert hat
  	["And" , ["$ClockTriggered","$StatusDimmen"], "$NewValue"],
  	["Latch","$DimmwertNeu","$O_Dimmwert","$NewValue",0] 
Hier wieder der gesamte Code:

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],
	
	// Interne Variablen
	["$StatusDimmen","bool",false],
		
	["$DimmRelTouched","bool",false],
	["$DimmenRelativStart","bool",false],
	["$DimmenRelativStopp","bool",false],
	
	["$DimmwertLast","float",0.0],
  	["$DimmwertNeu","float",0.0],
	["$DimmRichtung","float",0.0],
	["$Schrittweite","float",0.0],

	["$DimmwertMax_CResult","bool",false],
	["$DimmwertMin_CResult","bool",false],
	["$LimitMax","bool",false],
	["$LimitMin","bool",false],
	["$DimmenStop","bool",false],
		
	["$Bit0b","bool",false],
	["$Bit1b","bool",false],
	["$Bit2b","bool",false],
	["$Bit3b","bool",false],
	
	["$KonstTrue","bool",true],
	["$KonstFalse","bool",false],
	
	["$Konst50","float",50.0],
	["$Konst25","float",25.0],
	["$Konst12_5","float",12.5],
	["$Konst6","float",6.0],
	["$Konst3","float",3.0],
	["$Konst1","float",1.0],
	["$Konst0","float",0.0],
	
	["$Takt","bool",false],
	["$TaktLast","bool",false],
	["$ClockTriggered","bool",false],
	["$NewValue","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],
	
	// Schrittweite aus DPT3 umrechnen:
  	["Multiplexer",["$Konst0","$I_Schrittweite","$Konst50","$Konst25","$Konst12_5","$Konst6","$Konst3","$Konst1","$Konst0","$I_Schrittweite","$Konst50","$Konst25","$Konst12_5","$Konst6","$Konst3","$Konst1"],"$Schrittweite","$I_DimmbefehlRelativ"],
	
	// 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", "$Schrittweite"]],
  	
	// Dimmgrenzen prüfen
	["Comparator", "-$DimmwertNeu", "-$DimmwertMax_CResult", "-$I_DimmwertMax"],   // >= daher alles invertiert!
	["Comparator", "$DimmwertNeu", "-$DimmwertMin_CResult", "$I_DimmwertMin"],       // <= daher nur Ausgang invertiert

	// Min/Max. Dimmwert auf Ausgang übernehmen, wenn neuer Wert außerhalb der Grenzen liegt und Dimmenvorgang aktiv
	["And" , ["$DimmwertMax_CResult","$Bit3b","$StatusDimmen"], "$LimitMax"],
	["Latch","$I_DimmwertMax","$O_Dimmwert","$LimitMax",0],
	["And" , ["$DimmwertMin_CResult","-$Bit3b","$StatusDimmen"], "$LimitMin"],
	["Latch","$I_DimmwertMin","$O_Dimmwert","$LimitMin",0],
    
	// Wenn obere oder untere Grenze erreicht, Dimmvorgang abbrechen (IMMER, daher Latch Triggeroption=0)
	["Or" , ["$LimitMin","$LimitMax"], "$DimmenStop"],
	["Latch","$KonstFalse","$StatusDimmen","$DimmenStop",0],
  	
  	// Taktgeber starten
  	["Clocksignal","$StatusDimmen","$Takt","$I_DauerDimmen"],
	// Taktsignal mit letztem Wert vergleichen: wenn ungleich => Taktgeber hat getriggert 
  	["Limiter","$Takt",0,"-$ClockTriggered",["$TaktLast", "$TaktLast"]],
	// Wert nur übernehmen, wenn Dimmvorgang aktiv und Taktsignal getriggert hat
  	["And" , ["$ClockTriggered","$StatusDimmen"], "$NewValue"],
  	["Latch","$DimmwertNeu","$O_Dimmwert","$NewValue",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 StatusDimmen","aktiver Dimmvorgang?","$StatusDimmen","c"]
    ]
}
Du hast keine ausreichende Berechtigung, um die Dateianhänge dieses Beitrags anzusehen.
Timberwolf Server 2500 / #117 (VPN offen + reboot nach Rückfrage) / zusätzlich: 3500M/#935, 3500L/#1297

Ersteller
Robert_Mini
Reactions:
Beiträge: 3741
Registriert: So Aug 12, 2018 8:44 am
Hat sich bedankt: 1164 Mal
Danksagung erhalten: 2058 Mal

#15

Beitrag von Robert_Mini »

Hallo zusammen!

Auch wenn es etwas ruhig in den letzten Tagen um diesen Thread war, möchte ich dieses Tutorial und die Logik gerne zum Abschluss bringen. Ich hoffe, dass nach Fertigstellung mehr Fragen kommen als bisher. Ich kann nur jedem Logik-Interessierten empfehlen, das mal Schritt für Schritt durchzuarbeiten. Da ist viel dabei, ich hab selbst wieder einiges dazu gelernt.

Schritt 9:

In diesem Schritt wird die Logik um die Funktion Absolutes Dimmen erweitert. Dies ist leider deutlich aufwendiger als gedacht, da einerseits weite Teile für relatives und absolutes Dimmen ident sind, aber in den Feinheiten ist es dann doch anders.

Ich fasse die wichtigsten Änderungen im einzelnen zusammen:

1) Die Schrittweite aus DPT3 wird auf die neue Variable $SchrittweiteRel zwischengespeichert.
Mit den Status-Variablen $StatusDimmenRel und $StatusDimmenAbs wird mittels Latch geweils die richtige Schrittweite übernommen.
Damit wird erreicht, dass die Schrittweite sowohl beim relativen als auch absoluten Dimmen auch dynamisch im laufenden Dimmvorgang verändert werden kann.

Code: Alles auswählen

	// Schrittweite aus DPT3 umrechnen:
  	["Multiplexer",["$Konst0","$I_Schrittweite","$Konst50","$Konst25","$Konst12_5","$Konst6","$Konst3","$Konst1","$Konst0","$I_Schrittweite","$Konst50","$Konst25","$Konst12_5","$Konst6","$Konst3","$Konst1"],"$SchrittweiteRel","$I_DimmbefehlRelativ"],
	// Nur übernehmen, wenn Rel. Dimmen aktiv
	["Latch","$SchrittweiteRel","$Schrittweite","$StatusDimmenRel",0],
	
	["Latch","$I_Schrittweite","$Schrittweite","$StatusDimmenAbs",0],
2) Absoluten Dimmvorgang und die Richtung erkennen:
Mit den folgenden Zeilen wird ein neuer Eingangswert für absolutes Dimmen erkannt (Modul Triggered) und mittels Comparator die Dimmrichtung durch Vergleich mit dem letzten Rückmeldewert bestimmt (Abs>Rückmeldung und Abs<Rückmeldung, daher sind die Attribute im 2. Comparator vertauscht).
Mit den nachfolgenden "And/And/Or" wird ausgewertet, ob ein neuer Dimmvorgang gestartet wurde => $DimmenAbsolutStart=true.
In diesem Fall wird der interne Status $StatusDimmenAbs auf true gesetzt und die Schrittweite vom Eingang übernommen.

Beim genauen Hinsehen sieht man beim Latch zuerst TriggerOption 1, dann TriggerOption 0. Das ist kein Zufall, sondern bedeutet:
- nur bei pos. Flanke von $DimmenAbsolutStart wird der Status gesetzt
- damit erfolgt kein Rücksetzen des Status beim nächsten Aufruf, da die And Bedingungen dann nicht mehr erfüllt sind!
- das 2. Latch hat bewusst TriggerOption 0, damit auch beim laufenden Dimmvorgang die Schrittweite angepasst werden kann :dance: :dance: !

Am Ende dieses Code-Ausschnittes wird dann aus $StatusDimmenRel und $StatusDimmenAbs ein gemeinsames $StatusDimmen errechnet.
Immer wenn sich der Dimmstatus ändert (egal ob rel. oder abs.), wird der Rückmeldewert vom Eingang übernommen.

Code: Alles auswählen

// Auswerten, ob Eingang Abs. Dimmen getriggert wurde
	["Triggered", "$I_DimmbefehlAbsolut", "$DimmAbsTouched" ],
	["Comparator", "$I_DimmbefehlAbsolut", "$DimmwertGroesser_CResult", "$I_RueckmeldungDimmen"],
	["Comparator", "$I_RueckmeldungDimmen", "$DimmwertKleiner_CResult", "$I_DimmbefehlAbsolut"],
	
	["And" , ["$DimmAbsTouched","$DimmwertGroesser_CResult","-$StatusDimmenAbs","-$StatusDimmenRel"], "$DimmenAbsStartGroesser"],
	["And" , ["$DimmAbsTouched","$DimmwertKleiner_CResult","-$StatusDimmenAbs","-$StatusDimmenRel"], "$DimmenAbsStartKleiner"],
	["Or" , ["$DimmenAbsStartGroesser","$DimmenAbsStartKleiner"],"$DimmenAbsolutStart"], 
	["Latch","$KonstTrue","$StatusDimmenAbs","$DimmenAbsolutStart",1],
	["Latch","$I_Schrittweite","$Schrittweite","$StatusDimmenAbs",0],
	
	["Or" , ["$StatusDimmenAbs","$StatusDimmenRel"],"$StatusDimmen"], 
	["Latch","$I_RueckmeldungDimmen","$DimmwertLast","$StatusDimmen",1],
3) Gesamtdimmrichtung auswerten:
Hier war leider der alte Ansatz nicht mehr brauchbar.
Im folgenden Abschnitt wird aus dem jeweiligen $StatusDimmen und der zugehörigen Dimmrichtung ausgewertet, ob nach heller oder dunkler gedimmt wird und dafür ein gemeinsamer Bool-Wert gespeichert ($DimmRichtungHeller und $DimmRichtungDunkler).
Diese beiden Stati werden später noch benötigt, im Latch direkt darunter wird damit erst mal -1 oder +1 auf den Faktor $Dimmrichtung geschrieben, damit im Polynom die Schrittweite entsprechend addiert/subtrahiert wird.

Code: Alles auswählen

	// Dimmrichtung gesamt ermitteln
	["And" , ["$StatusDimmenRel","$Bit3b"], "$DimmRichtungRelHeller"],
	["And" , ["$StatusDimmenRel","-$Bit3b"], "$DimmRichtungRelDunkler"],
	["And" , ["$StatusDimmenAbs","$DimmwertGroesser_CResult"], "$DimmRichtungAbsHeller"],
	["And" , ["$StatusDimmenAbs","$DimmwertKleiner_CResult"], "$DimmRichtungAbsDunkler"],
	["Or" , ["$DimmRichtungRelHeller","$DimmRichtungAbsHeller"], "$DimmRichtungHeller"],
	["Or" , ["$DimmRichtungRelDunkler","$DimmRichtungAbsDunkler"], "$DimmRichtungDunkler"],
    
	["Latch","$Konst1","$DimmRichtung","$DimmRichtungHeller",0],
	["Latch","-$Konst1","$DimmRichtung","$DimmRichtungDunkler",0],
4) Sollwert übernehmen, wenn dieser erreicht wird:
Analog zum weiter oben beschriebenen Auswerten, ob Dimmgrenzen erreicht werden, erfolgt der Vergleich des neuen Dimm-Soll-Werts mit dem Zielwert. Ist der Soll-Wert größer dem Zielwert (beim Dimmen nach heller) oder kleiner dem Zielwert (beim Dimmen nach dunkler) und absolutes Dimmen aktiv, dann wird SollReached1/2 true und der Sollwert wird auf den Zielwert gesetzt.

Code: Alles auswählen

	// Mit Abs. Sollwert verleichen prüfen
	["Comparator", "-$DimmwertNeu", "-$DimmwertAbsGr_CResult", "-$I_DimmbefehlAbsolut"],   // >= daher alles invertiert!
	["Comparator", "$DimmwertNeu", "-$DimmwertAbsKl_CResult", "$I_DimmbefehlAbsolut"],       // <= daher nur Ausgang invertiert
    
	// Sollwert auf Ausgang übernehmen, wenn neuer Wert Sollwert über(unter)schreitet	
	["And" , ["$DimmwertAbsGr_CResult","$DimmRichtungHeller","$StatusDimmenAbs"], "$SollReached1"],
	["And" , ["$DimmwertAbsKl_CResult","$DimmRichtungDunkler","$StatusDimmenAbs"], "$SollReached2"],
	["Or" , ["$SollReached1","$SollReached2"], "$SollReached"],
	["Latch","$I_DimmbefehlAbsolut","$O_Dimmwert","$SollReached",0],
5) Abbruchbedingung anpassen:
Im "letzten Schritt" wird die Variable "$SollReached" noch in den Oder-Logik aufgenommen, damit auch in diesem Fall $DimmenStop=true gesetzt wird. Damit werden alle 3 $StatusDimmen Variablen zurückgesetzt. Damit endet auch der zyklische Trigger und für den nächsten Aufruf wird gespeichert, dass kein Dimmvorgang mehr aktiv ist.

Code: Alles auswählen

// Wenn obere oder untere Grenze erreicht, Dimmvorgang abbrechen (IMMER, daher Latch Triggeroption=0)
	["Or" , ["$LimitMin","$LimitMax","$SollReached"], "$DimmenStop"],
	["Latch","$KonstFalse","$StatusDimmen","$DimmenStop",0],
	// Auch beide Status-Variablen zurücksetzen
	["Latch","$KonstFalse","$StatusDimmenAbs","$DimmenStop",0],
	["Latch","$KonstFalse","$StatusDimmenRel","$DimmenStop",0],
6) Zusammenfassung:
Damit ist im Prinzip die Funktionalität mit zahlreichen Zusatzanforderungen (zB dynamisches Anpassen der Schrittweite und Grenzen, etc.) umgesetzt. Ein paar Spezialfälle müssen im abschließenden Test+Finetuning-Schritt noch eingebaut werden => in Kürze.

Getestet kann aber schon werden :handgestures-thumbupright: !

Vollständiger Code inkl. aller Variablendefinitionen etc.:

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",2.0],
	["$I_DimmwertMax","float",100.0],
	["$I_DimmwertMin","float",0.0],
        
    // Ausgänge
	["$O_Dimmwert","float",0.0],
	["$O_StatusSchalten","bool",false],
	
	// Interne Variablen
	["$StatusDimmen","bool",false],
	["$StatusDimmenAbs","bool",false],
	["$StatusDimmenRel","bool",false],
		
	["$DimmRelTouched","bool",false],
	["$DimmenRelativStart","bool",false],
	["$DimmenRelativStopp","bool",false],
	
	["$DimmAbsTouched","bool",false],
	["$DimmwertGroesser_CResult","bool",false],
	["$DimmwertKleiner_CResult","bool",false],	
	["$DimmenAbsStartGroesser","bool",false],	
	["$DimmenAbsStartKleiner","bool",false],	
	["$DimmenAbsolutStart","bool",false],	
	
	
	
	["$DimmwertLast","float",0.0],
  	["$DimmwertNeu","float",0.0],
	["$DimmenAbsNeu","bool",false],
	
	["$DimmRichtungAbsHeller","bool",false],
	["$DimmRichtungAbsDunkler","bool",false],
//	["$DimmRichtungRel","float",0.0],
	["$DimmRichtungRelHeller","bool",false],
	["$DimmRichtungRelDunkler","bool",false],
	["$DimmRichtung","float",0.0],
	["$DimmRichtungHeller","bool",false],
	["$DimmRichtungDunkler","bool",false],
	
	["$Schrittweite","float",0.0],
	["$SchrittweiteRel","float",0.0],

	["$DimmwertMax_CResult","bool",false],
	["$DimmwertMin_CResult","bool",false],
	["$LimitMax","bool",false],
	["$LimitMin","bool",false],

	["$DimmwertAbsGr_CResult","bool",false],
	["$DimmwertAbsKl_CResult","bool",false],
	["$SollReached1","bool",false],
	["$SollReached2","bool",false],
	["$SollReached","bool",false],
	
	["$DimmenStop","bool",false],
		
	["$Bit0b","bool",false],
	["$Bit1b","bool",false],
	["$Bit2b","bool",false],
	["$Bit3b","bool",false],
	
	["$KonstTrue","bool",true],
	["$KonstFalse","bool",false],
	
	["$Konst50","float",50.0],
	["$Konst25","float",25.0],
	["$Konst12_5","float",12.5],
	["$Konst6","float",6.0],
	["$Konst3","float",3.0],
	["$Konst1","float",1.0],
	["$Konst0","float",0.0],
	
	["$Takt","bool",false],
	["$TaktLast","bool",false],
	["$ClockTriggered","bool",false],
	["$NewValue","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","-$StatusDimmenRel","-$StatusDimmenAbs"], "$DimmenRelativStart"],
	["Latch","$KonstTrue","$StatusDimmenRel","$DimmenRelativStart",0],
	
	// Stopp Telegramm auswerten und Dimmen stoppen
	["And" , ["$DimmRelTouched","-$I_DimmbefehlRelativ","$StatusDimmenRel","-$StatusDimmenAbs"], "$DimmenRelativStopp"],
	["Latch","$KonstFalse","$StatusDimmenRel","$DimmenRelativStopp",0],
	// Bei negativer Flanke auch Takt zurücksetzen, damit nächster Dimmvorgang korrekt erkannt wird
	["Latch","$KonstFalse","$TaktLast","$StatusDimmenRel",2],
	
	// Schrittweite aus DPT3 umrechnen:
  	["Multiplexer",["$Konst0","$I_Schrittweite","$Konst50","$Konst25","$Konst12_5","$Konst6","$Konst3","$Konst1","$Konst0","$I_Schrittweite","$Konst50","$Konst25","$Konst12_5","$Konst6","$Konst3","$Konst1"],"$SchrittweiteRel","$I_DimmbefehlRelativ"],
    // Nur übernehmen, wenn Rel. Dimmen aktiv
	["Latch","$SchrittweiteRel","$Schrittweite","$StatusDimmenRel",0],
	
	// Wenn $I_DimmbefehlAbsolut während laufendem Dimmvorgang überschrieben wird => letzten gesendeten Wert als Rückmeldung übernehmen
	["And" , ["$DimmAbsTouched","$StatusDimmenAbs","-$StatusDimmenRel"], "$DimmenAbsNeu"],
	["Latch","$DimmwertLast","$I_RueckmeldungDimmen","$DimmenAbsNeu",1],
	
	// Auswerten, ob Eingang Abs. Dimmen getriggert wurde
	["Triggered", "$I_DimmbefehlAbsolut", "$DimmAbsTouched" ],
	["Comparator", "$I_DimmbefehlAbsolut", "$DimmwertGroesser_CResult", "$I_RueckmeldungDimmen"],
	["Comparator", "$I_RueckmeldungDimmen", "$DimmwertKleiner_CResult", "$I_DimmbefehlAbsolut"],
	
	["And" , ["$DimmAbsTouched","$DimmwertGroesser_CResult","-$StatusDimmenAbs","-$StatusDimmenRel"], "$DimmenAbsStartGroesser"],
	["And" , ["$DimmAbsTouched","$DimmwertKleiner_CResult","-$StatusDimmenAbs","-$StatusDimmenRel"], "$DimmenAbsStartKleiner"],
	["Or" , ["$DimmenAbsStartGroesser","$DimmenAbsStartKleiner"],"$DimmenAbsolutStart"], 
	["Latch","$KonstTrue","$StatusDimmenAbs","$DimmenAbsolutStart",1],
	["Latch","$I_Schrittweite","$Schrittweite","$StatusDimmenAbs",0],
	
	["Or" , ["$StatusDimmenAbs","$StatusDimmenRel"],"$StatusDimmen"], 
	["Latch","$I_RueckmeldungDimmen","$DimmwertLast","$StatusDimmen",1],

	// Dimmrichtung aus DPT3 ermitteln
	["BinaryDemultiplexer","$I_DimmbefehlRelativ",["$Bit0b","$Bit1b","$Bit2b","$Bit3b"]],
	
	
	// Dimmrichtung gesamt ermitteln
	["And" , ["$StatusDimmenRel","$Bit3b"], "$DimmRichtungRelHeller"],
	["And" , ["$StatusDimmenRel","-$Bit3b"], "$DimmRichtungRelDunkler"],
	["And" , ["$StatusDimmenAbs","$DimmwertGroesser_CResult"], "$DimmRichtungAbsHeller"],
	["And" , ["$StatusDimmenAbs","$DimmwertKleiner_CResult"], "$DimmRichtungAbsDunkler"],
	["Or" , ["$DimmRichtungRelHeller","$DimmRichtungAbsHeller"], "$DimmRichtungHeller"],
	["Or" , ["$DimmRichtungRelDunkler","$DimmRichtungAbsDunkler"], "$DimmRichtungDunkler"],
	// Dimmrichtung auf -1/+1 setzen
	["Latch","$Konst1","$DimmRichtung","$DimmRichtungHeller",0],
	["Latch","-$Konst1","$DimmRichtung","$DimmRichtungDunkler",0],
	
	//  Neuen Dimmwert berechnen
  	["Polynomial", "$DimmRichtung", "$DimmwertNeu",["$DimmwertLast", "$Schrittweite"]],
  	
    // Dimmgrenzen prüfen
    ["Comparator", "-$DimmwertNeu", "-$DimmwertMax_CResult", "-$I_DimmwertMax"],   // >= daher alles invertiert!
    ["Comparator", "$DimmwertNeu", "-$DimmwertMin_CResult", "$I_DimmwertMin"],       // <= daher nur Ausgang invertiert

    // Mit Abs. Sollwert verleichen prüfen
    ["Comparator", "-$DimmwertNeu", "-$DimmwertAbsGr_CResult", "-$I_DimmbefehlAbsolut"],   // >= daher alles invertiert!
    ["Comparator", "$DimmwertNeu", "-$DimmwertAbsKl_CResult", "$I_DimmbefehlAbsolut"],       // <= daher nur Ausgang invertiert

    // Min/Max. Dimmwert auf Ausgang übernehmen, wenn neuer Wert außerhalb der Grenzen liegt und Dimmenvorgang aktiv
    ["And" , ["$DimmwertMax_CResult","$DimmRichtungHeller","$StatusDimmen"], "$LimitMax"],
    ["Latch","$I_DimmwertMax","$O_Dimmwert","$LimitMax",0],
    ["And" , ["$DimmwertMin_CResult","$DimmRichtungDunkler","$StatusDimmen"], "$LimitMin"],
    ["Latch","$I_DimmwertMin","$O_Dimmwert","$LimitMin",0],
    
    // Sollwert auf Ausgang übernehmen, wenn neuer Wert Sollwert über(unter)schreitet
    ["And" , ["$DimmwertAbsGr_CResult","$DimmRichtungHeller","$StatusDimmenAbs"], "$SollReached1"],    // ,"-$DimmAbsTouched"
    ["And" , ["$DimmwertAbsKl_CResult","$DimmRichtungDunkler","$StatusDimmenAbs"], "$SollReached2"],    // ,"-$DimmAbsTouched"
    ["Or" , ["$SollReached1","$SollReached2"], "$SollReached"],
    ["Latch","$I_DimmbefehlAbsolut","$O_Dimmwert","$SollReached",0],
    
    // Wenn obere oder untere Grenze erreicht, Dimmvorgang abbrechen (IMMER, daher Latch Triggeroption=0)
    ["Or" , ["$LimitMin","$LimitMax","$SollReached"], "$DimmenStop"],
    ["Latch","$KonstFalse","$StatusDimmen","$DimmenStop",0],
    // Auch beide Status-Variablen zurücksetzen
    ["Latch","$KonstFalse","$StatusDimmenAbs","$DimmenStop",0],
    ["Latch","$KonstFalse","$StatusDimmenRel","$DimmenStop",0],
  	
  	// Taktgeber starten
  	["Clocksignal","$StatusDimmen","$Takt","$I_DauerDimmen"],
    // Taktsignal mit letztem Wert vergleichen: wenn ungleich => Taktgeber hat getriggert 
  	["Limiter","$Takt",0,"-$ClockTriggered",["$TaktLast", "$TaktLast"]],
    // Wert nur übernehmen, wenn Dimmvorgang aktiv und Taktsignal getriggert hat
  	["And" , ["$ClockTriggered","$StatusDimmen"], "$NewValue"],
  	["Latch","$DimmwertNeu","$O_Dimmwert","$NewValue",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"]
    ]
}
Timberwolf Server 2500 / #117 (VPN offen + reboot nach Rückfrage) / zusätzlich: 3500M/#935, 3500L/#1297
Antworten

Zurück zu „Zusätzliche Logikbausteine“