4.6.6 Verwendung von Standard Logikbausteinen in Custom Logik

Beschreibung: Verwendung von Standard Logikbausteinen in Custom-Logiken

Kategorie: Logiken

Link zu diesem Beitrag: Alles auswählen

[url=https://forum.timberwolf.io/app.php/kb/viewarticle?a=115&sid=eb94fc910fce0633a2456a3debccbfd7]Knowledge Base - 4.6.6 Verwendung von Standard Logikbausteinen in Custom Logik[/url]

Alphabetische Auflistung der verfügbaren Module:
  • And: Binäre UND-Verknüpfung
  • Astro: Astrofunktionen, wie Sonnenauf- und untergang
  • BinaryDemultiplexer: Bildet Binärwerte aus einer Integerzahl (Umkehrfunktion vom BinaryMultiplexer)
  • BinaryMultiplexer: Bildet einen Zahlenwert aus mehreren Binäreingängen (Umkehrfunktion vom BinaryDemultiplexer)
  • BinaryStatistic: Binäre Statistiken
  • Break: Abbruch-Modul
  • CalcFormula: Freie Formel (neu ab TWS v2.0 IP4)
  • Clocksignal: zyklischer Trigger
  • Comparator: Schwellwertschalter (optional mit Hysterese)
  • Cron: Timer
  • Error: Fehlerhandling in Custom-Logiken
  • HobbsMeter: Betriebsstundenzaehler
  • If-Then-Else: Wenn Dann Sonst Bedingungen
  • Interpolation: Interpoliert Werte zwischen Stützpunkten
  • Latch: Wertzuweisung
  • Limiter: Modul zum Begrenzen von Zahlenwerten (WICHTIG: Mit optionalem binärem Rückmeldewert)
  • Localtime: Unix-Zeit und Komponenten
  • Monoflop: Verzögerungsmodul oder Timer
  • Multiplexer: Selektiert einen von mehreren Werten
  • Or: Binäre Oder-Verknüfung
  • Polynomial: Löst Additionen, Multiplikationen und Exponenten-Aufgaben
  • Ramp(neu ab TWS V1.6): Rampenfunktion / Softdimming
  • Ratio: Division
  • SendExplicit(neu ab TWS V1.6): gesteuertes Senden
  • Statemachine(neu ab TWS V1.6): Zustandsautomat
  • Statistic: Statistik für Integer und Float (Durchschnitt, Max, Min,...)
  • Step: Vereinfacht Zahlenänderungen auf vorgegebe Schrittweiten
  • Stopwatch: Stoppuhr
  • Tiefpass / Lowpass: Tiefpass zur Glättung von Zeitsignalen
  • Triggered (neu ab TWS V1.6) : Erkennt, welcher Eingang die Logik getriggert hat
  • Wake-up : Triggert zu einem bestimmten Zeitpunkt
Am Ende der Seite findet Ihr eine Kopiervorlage als Grundlage für neue Custom-Logiken.

Erklärung der oben aufgeführten Module:
  • And
    Gibt am Ausgang 1 aus, wenn alle Eingänge ungleich 0 sind.
    ["And" , ["$Variable1" , "$Variable2",... ,"$Variable_n"], "$Output"]

  • Astro
    tbd.
    [["Astro",0,0],"$Altitude","$Azimute","$Transit","$Sunrise","$Sunset","$Civil_dawn","$Civil_dusk","$Naut_dawn","$Naut_dusk","$Astro_dawn","$Astro_dusk","$Alt_moon",$Azi_moon"]],

  • BinaryDemultiplexer
    Aus n binären Eingängen wird ein Integer-Wert mit 2n möglichen Zuständen berechnet.
    ["BinaryDemultiplexer","$Eingang",["$bit0","$bit1","$bit2",...]]

    Eine Ganzzahlwert (Integer) am Eingang wird durch diesen Baustein in Binärcode und dabei in einzelne bit's/Boolwerte gewandelt.

    Eine Dezimalzahl "9" wird dabei beispielsweise zu einer "1001":
    bit0 = Wertigkeit 2^0 = 1 -> in diesem Beispiel true
    bit1 = Wertigkeit 2^1 = 2 -> in diesem Beispiel false
    bit2 = Wertigkeit 2^2 = 4 -> in diesem Beispiel false
    bit3 = Wertigkeit 2^3 = 8 -> in diesem Beispiel true

  • BinaryMultiplexer
    Aus n binären Eingängen wird ein Integer-Wert mit 2n möglichen Zuständen berechnet.
    ["BinaryMultiplexer",["$In_D","$In_E","$In_F"],"$Output"]

    Der Ausgang $Output kann im obigen Beispiel Werte zwischen 0 und 7, also gesamt 8 unterschiedliche Werte annehmen.
    Die Anzahl der Eingänge kann natürlich auch höher als 3 sein.

    Der BinaryMultiplexer wird sehr oft zur Fallunterscheidung verwendet und in einem nachgeschalteten Multiplexer als Selektor verwendet.

  • BinaryStatistic
    tbd.
    ["BinaryStatistic",["$VAR<Input!>"],"$MoreTrue","$FalseCount","$TrueCount"],

  • Break
    Dies ist ein spezielles Modul, das die weitere Ausführung einer (Custom-) Logikzelle abbricht, sobald ein "True" auf einem der Break-Eingänge eintrifft (von einem Eingang der Logikzelle oder einer Variablen, die innerhalb der Logik berechnet wird). Beim Abbruch werden keine nachfolgenden Module mehr berechnet/ausgeführt. Kein Ausgang wird gesendet, auch nicht die Ausgänge, deren Variable vor dem Erreichen des Breaks gesetzt wurden.

    Syntax mit einem Eingang:
    ["Break", ["$Eingang"]]

    Mehrer Eingänge sind ODER-verknüpft, zB:
    ["Break", ["$Eingang1","$Eingang2"]]

    Wird Break wie folgt verwendet, können in der GUI beliebig viele Eingänge hinzugefügt werden, die einen Abbruch triggern:
    ["Break", ["$VAR<Inhibit?>"]]

  • CalcFormula
    Dieser Baustein ermöglicht mathematische Rechnungen mit freier Eingabe der Rechenformel.
    ["CalcFormula",["$Eingang_Eins","$Eingang_Zwo,"...","$Eingang_n"], "$Result", "$Formula"]
    Eine Hilfreiche, ausführliche Diskussion dazu findet sich hier: viewtopic.php?f=93&t=2815&start=10

    Zusammenfassung:
    • Eingangsvariablen-Array: $Eingang_n sind hier Platzthalter für beliebige Variablen-Namen, wobei diese automatisch der Reihenfolge nach und völlig unabhängig von Ihrem Namen den Formelvariabeln X1, X2,X3,... zugeordnet werden. Im Namen der Eingangs-Variabeln muss das X1 usw. nicht vorkommen.
    • Ergebnis: $Result führt das Ergebnis der Rechnung und ist vom Typ float
    • Formel: $Formula ist vom Typ string und beinhaltet die Formel, in die Variablen (X1, X2, X3,...) eingebettet werden, z.B. :"sin(X1+5*X4-X2)*X3". Die Formel muss genauso wie auch sonste sämtliche Werte im Abschnitt Level deklariert werden und kann nicht direkt im Modul als string eingetragen werden!
    Dieses Modul nutzt die MuParser Bibliothek. Dadurch können die meisten der hier beschriebenen Funktionen genutzt werden.

    Ein paar goldene Regeln zum Umgang mit diesem Baustein:
    • WICHTIG: Dezimalzahlen werden mit .(Punkt) und nicht mit ,(Komma) getrennt. (3.14 / 3,14). Ein Komma in der Formel separiert zwei Berechnungen. Und im Ergebnis des Logikmoduls wird dann nur das Ergebnis der letzten Berechnung ausgegeben. Beispiel: 3,14*2,5*X1 mit X1 = 2 liefert das Ergebnis 10 (5 * X1). Dieses Verhalten zu kennen ist wichtig, denn bei echten Fehlern ist das Ergebnis 0. Verwendet ein Nutzer irrtümlich, oder weil er es nicht besser weiß, ein Komma und sind die getrennten Formeln ansonsten korrekt, liefert das Modul ein valides Ergebnis, welches lediglich nicht das Gewünschte ist.
    • Da das Komma in einer Formel die Formel zu trennen scheint, funktionieren aktuell die muparser-Funktionen if(,,) und pow(,) nicht. Wer das Gegenteil herausfindet, bitte über das Forum melden und beschreiben wie.
    • pow(,) lässt sich sehr gut mit einem Polynomial-Baustein ersetzen.
    • Für if(,,) gibt es viele Wege, die nach Rom führen, z.B. die Kombinationen aus (COMPERATOR und MULTIPLEXER), (LIMITER und MULTIPLEXER), (LATCH und LATCH) oder weitere. Siehe If-Then-Else
    • Die Schreibeweise der Variabeln in der Formel ist case sensitiv (X1/ x1)
    • Ein Fehler in der Formel führt zu dem Ergebnis = 0 und dem Abbruch der gesamten weiteren Custom-Logik (siehe auch Error)
    • Einige Konstanten wie z.B. PI werden unterstützt, Die Schreibweise _pi siehe hier. Zum Zeitpunkt des Verfassen dieses Artikels werden die erweiterten Konstanten wie z.b. _rad nicht unterstützt
    • Ein vorhandener Eingangsparameter muss nicht in der Formel genutzt werden (das ist beim Debugging von Formelfehlern hilfreich)
    • Mathematische Zeichen müssen gesetzt werden (2*X1 / 2X1)
    • Zahlen zwischen 0 und 1 dürfen ohne die vorangehende 0 geschrieben werden (0.2 = .2), aber das ist eine sehr unschöne Schreibweise und sollte unterlassen werden)
    • Leerzeichen in Formeln sind erlaubt und haben keine Auswirkung

  • Clocksignal
    Damit kann ein zyklischer Trigger innerhalb einer Custom Logik erstellt werden, der in Kombination mit den Sendenoptionen die Ausführung der Logikzelle und das Senden auslöst.
    ["Clocksignal","$ConstTRUE","$Clk","$Period"]

    Bild

    Die Variable $Clk liefert dabei im Takt abwechselnd true/false, wird dieser Wert nicht weiter benötigt, kann er durch 0 ersetzt werden:
    ["Clocksignal","$ConstTRUE",0,"$Period"]

  • Comparator
    Der Schwellwertschalter erlaubt 2 Varianten:
    Ein Schwellwert: Der Eingangswert wird mit dem Schwellwert verglichen und die Logikzelle gibt 1 aus, wenn $Input_Wert > $Schwellwert erfüllt ist.
    ["Comparator" , "$Input_wert" , "$Output" , "$Schwellwert"]
    Oberer und unterer Schwellwert: Der Ausgang der Logik liefert 0, wenn der untere Schwellwert unterschritten ist, eine 1, wenn der obere Schwellwert überschritten ist. Liegt der Input_Wert zwische oberer und unterer Schwelle, wird der unveränderte Ausgangswert ausgegeben.
    ["Comparator" , "$Input_Wert" , "$Output" , ["$UntereSchwelle","$ObereSchwelle"]]

  • Cron
    Triggert eine Logik zu definierten Zeitpunkten, die mittels Cron-String definiert werden.

    ["Cron","$Start","$Alarm","$NextTrigger","$CronExpr"]
    • $Start: Boolscher Eingang. True schaltet den Timer aktiv (triggert bei nächsten Cron-Zeitpunkt).Falseschaltet den Timer inaktiv (nichts passiert).
    • $Alarm: Boolscher Ausgang. Wird zum Cron-Zeitpunkt true ansonsten false
    • $NextTrigger: Integer Ausgang: Gibt den Cron-Zeitpunkt aus (in Unix-Zeit), wann der Timer das nächste mal triggert. Oder den Wert 0, falls der Timer inaktiv ist.
    • $CronExpr: Der Cron-String (um Sekunden erweitert) der die Trigger-Zeitpunkte festlegt.
    Wird $NextTrigger nicht benötigt, einfach per 0 ersetzen:
    ["Cron","$Start","$Alarm",0,"$CronExpr"]

    Hinweis: es wird eine um Sekunden erweiterte Beschreibung verwendet, siehe unten!

    ┌───────────── Sekunde (0 - 59)
    │ ┌───────────── Minute (0 - 59)
    │ │ ┌───────────── Stunde (0 - 23)
    │ │ │ ┌───────────── Tag des Monats (1 - 31)
    │ │ │ │ ┌───────────── Monat (1 - 12)
    │ │ │ │ │ ┌───────────── Wochentag (0 - 6)
    │ │ │ │ │ │
    * * * * * *


    Beispiele für Cron-Expressions:
    • ["$CronExpr","string","1 2 3 * * *"] ... triggert täglich um 3:02:01
    • ["$CronExpr","string","1 2 3-6 * * *"] ... triggert täglich um 3:02:01, 4:02:01, 5:02:01 und 6:02:01
    • ["$CronExpr","string","1 2 3 4 * *"] ... triggert am 4. des Monats um 3:02:01
    • ["$CronExpr","string","1 2 3 4 5 *"] ... triggert am 4. des 5. Monats (Mai) um 3:02:01
    • ["$CronExpr","string","1 2 3 * * 1"] ... triggert jeden Montag um 3:02:01 (Achtung Sonntag = 0!)
    • ["$CronExpr","string","0/10 * * * * *"] ... triggert alle 10sec beginnend bei 0 sec (0, 10, 20, 30, 40, 50 sec) unabhängig von Minuten, Stunden, Wochentag etc.
    • ["$CronExpr","string","5/10 * * * * *"] ... triggert alle 10sec beginnend bei 5 sec (5, 15, 25, 35, 45, 55 sec) unabhängig von Minuten, Stunden, Wochentag etc.

  • Error
    Die Errorhandling-Funktion ist kein eigenständiges Modul wie die meisten anderen, hier beschriebenen Module. Es ermöglicht das Ausgeben eines boolschen Wertes in Abhängigkeit davon, ob die Logik aufgrund eines Errors abgebrochen wurde oder nicht. Dies ergibt vor allem im Zusammenhang mit freien Formeln (CalcFormula), aber auch mit dem Baustein Ratio, Sinn (Division durch 0 = Fehler).

    Es wird kein Eintrag im Abschnitt MODULE benötigt, dafür aber ein Eintrag im Abschnitt LEVEL und ein Eintrag im Abschnitt OUTPUT.

    Code: Alles auswählen

        "Level": [
        		...
    		[ "$Error?", "bool", false ]
        ],
        ...
        "Output":[
        		...
    		["Err","Fehler","$Error?","ce"]
        ]
    
    Der Fehlerausgang ist derjenige Ausgang, der in seiner Sendeoption die Buchstabenkombination "ce" aufweist.
    Das "c" steht, wie üblich für "sende bei Änderung". Das "e" weist ihn als den Ausgang aus, der den (Fehler-)Zustand der Zelle ausgibt.

    Das Fragezeichen in der Variable ist optional, ohne erscheint der Ausgang sofort und muss nicht erst über das [+] in der Oberfläche aktiviert werden.

    Beachte: Es darf nur einen Fehlerausgang pro Logikzelle geben und die Variable (hier "$Error?") muss vom Typ "bool" sein und darf nicht anderweitig in der Logikzelle verwendet werden.

    Wenn ein Fehler während der Berechnung passiert, wird die weitere Berechnung abgebrochen und lediglich der Fehlerausgang gesetzt.

  • HobbsMeter
    Der Hobbsmeter ist ein Betriebsstundenzähler. Sobald am Eingang $State ein "True" anliegt, wird die Zeit in [h] hochgezählt und am Ausgang "$Time" ausgegeben. Mittels dem Eingang $Reset wird der Zähler zurückgesetzt (Achtung: hier ist ein Impuls erforderlich, d.h. nach dem Reset mit Reset=True, läuft der Zähler erst weiter, wenn $Reset auf 0 zurückgesetzt wurde.)
    "$Time" ist dabei ein Wert vom Typ "float" und Minuten sind aus den Nachkommstellen auslesbar (nach dem Prinzip 0,5 h = 30 Min)

    ["HobbsMeter","$State","$Time","$Reset"],

  • If-Then-Else
    Der Logikeditor des Timberwolf Server orientiert sich stark an elektrischer Schaltungstechnik, in der es einen solchen Baustein so nicht gibt. Es ist aber dennoch möglich - meist viel einfacher - entsprechende Lösungen mit meist nur einem Baustein zu schaffen. Dafür gibt es eine eingene Hinweisseite in der KB: Knowledge Base - 4.6.7.7 CUSTOM: IF-THEN (ELSE) Lösungen

  • Interpolation
    Interpoliert zwischen den nächstgelegenen Stützpunkten den Funktionswert einer punktweise definierten Kennlinie.
    ["Interpolation","$In", "$Out", [ [x1,y1] , [x2,y2] , ... , [xn,yn ] ] ]
    • "Interpolation" (Modulbezeichner)
    • "$In" (Referenz auf Eingangs-Level)
    • "$Out" (Referenz auf Ausgangs-Level)
    • [ [x1,y1] , [x2,y2] , ... , [xn,yn ] ] (Stützpunkte der Interpolatioin, die Stützpunkte werden dabei direkt in der Moduldeklaration als Zahlen eingetragen, also zum Beispiel [[0,0,] , [5.5,11], [20,18]] und es werden hierbei keine internen Variablen verwendet.)
    Die Stützpunkte [xi,yi] müssen folgende Bedingung erfüllen:
    xi < xi+1 , d.h. die Stützpunkte müssen nach ihren x-Werten aufsteigend sortiert sein und x-Werte dürfen nicht doppelt vorkommen

    Die Berechnung des Ausgangswertes erfolgt mit abschnittweiser linearer Interpolation.
    Zusätzlich werden die Ein- und Ausgangswerte auf den Wertebereich der Stützpunkte limitiert:
    Eingangswert (X)Ausgangswert (Y)
    X < x1y1
    X = xiyi
    xi < X < xi+1yi + (yi+1 - yi) / (xi+1 - xi) * (X - xi)
    X > xnyn

  • Latch
    Ein Latch ist dazu da, einen Wert/Zustand der zu einen bestimmten Zeitpunkt anliegt zwischenzuspeichern.
    ["Latch","$Eingang","$Ausgang","$Trigger",TriggerOption]

    Eingang und Ausgang müssen vom gleichen Typ sein, also (float/float),(integer/integer),(bool/bool) oder (string/string).
    Der Trigger ist vom Typ "bool" und bestimmt, ob der Eingangswert am Ausgang übernommen wird.
    Das Verhalten des Triggers kann durch die TriggerOption angepasst werden.
    TriggerOptionDer Eingangswert wird am Ausgang übernommen, wenn ...
    0... Trigger = true ist
    1... der Trigger von false nach true wechselt (steigende Flanke)
    2... der Trigger von true nach false wechselt (fallende Flanke)
    3... der Trigger seinen Wert ändert (steigende oder fallende Flanke)
    ansonsten bleibt der Ausgang unverändert.

  • Limiter
    Begrenzt den Eingangswert mit Minimal- und Maximalwert, dazwischen wird der Eingangswert auf den Ausgang geschrieben. $Val_ok liefert 1, wenn der Wert innerhalb liegt, sonst 0.
    ["Limiter","$In_val","$Out_val","$Val_ok",["$Min", "$Max"]]

    Limiter kann somit auch als SWITCH CASE verwendet werden.
    Es gilt: wenn $Min <= $In_val <= $Max => $Val_ok= True.

    Wenn Unter- und Obergrenze den gleichen Wert haben, wird bei genau diesem Wert am Eingang der Status "Val_ok" true, ansonsten false.
    Dies kann somit zur Abfrage auf Gleichheit zB. $In_val == $Ref verwendet werden.

  • Localtime
    Mit diesem Baustein kann die aktuelle Linux-Zeit ausgelesen werden. Zusätzlich sind die Einzelkomponenten des Zeitpunktes auf einzelnen Variablen verfügbar:
    ["Localtime",0,"$Utime","$Sec","$Min","$Hour","$Mday","$Mon","$Year","$Wday","$Yday","$IsDst"]

    Wird nur der Zeitpunkt benötigt (zB zum Senden auf KNX), können die Einzelkomponenten durch 0 ersetzt werden:
    ["Localtime",0,"$Utime",0,0,0,0,0,0,0,0,0]

  • Multiplexer
    Mit diesem Baustein können mehrere Werte/Eingänge selektiv auf einen Ausgang gelegt werden.
    ["Multiplexer",["$KonstNull","$KonstEins","$KonstZwei","$KonstDrei"],"$Out","$Select"]
    • $KonstNull...$KonstDrei sind die Werte/Eingänge
    • $Select wählt den Wert/Eingang aus, beginnend mit 0 (0...3 in obigem Beispiel)
    • $Out wird mit dem gewählten Wert beschrieben
    Vereinfachungen:
    Wenn der Selektor größer als die Anzahl der Eingänge ist, wird immer der letzte/höchste Eingang selektiert.
    Aus ["Multiplexer",["$Val_A","$Val_B","$DefVal","$DefVal","$Val_C","$Val_D","$DefVal","$DefVal","$DefVal","$DefVal","$DefVal"],"$Out","$Select"]
    mache ["Multiplexer",["$Val_A","$Val_B","$DefVal","$DefVal","$Val_C","$Val_D","$DefVal"],"$Out","$Select"]
    Trotzdem können mehr als die 7 Werte adressiert werden (es wird dann wie schon erwähnt der Wert des letzten/höchsten Eingang ausgegeben).

    Statt der Referenz auf "$Unused" kann man die spezielle Null-Referenz verwenden. Die Null-Referenz (tatsächlich der Wert 0; keine Anführungszeichen) verwendet man bei nicht benutzten Ein-/Ausgängen.

    Aus ["Multiplexer",["$Val_A","$Unused","$DefVal","$Unused","$Unused","$Val_D","$DefVal"],"$Out","$Select"]
    mache ["Multiplexer",["$Val_A",0,"$DefVal",0,0,"$Val_D","$DefVal"],"$Out","$Select"]

    Anmerkung: Eingänge mit Null-Referenz haben einen festen Wert, abhängig vom erwarteten Eingangs-Typ
    Eingangs-TypWert
    boolfalse
    integer0
    float0.0
    string"" (Leerstring)
    Eine Variante, die den Ausgang nicht verändert, falls eine unerwarteter Wert für den Selektor auftaucht (im Bsp. sollten die unterstrichenen Werte durch den Selektor nicht adressierbar sein):
    ["Multiplexer",["$Out","$Out","$Val_A","$Val_B","$Out","$Val_C","$Val_D","$Out"],"$Out","$Select"]

  • Monoflop
    Ist die Triggerbedingung beim ausführen des Moduls erfüllt, wird der Ausgang auf true gesetzt (sonst auf false!), der Timer startet und nach Ablauf der Verzögerungszeit wird der Ausgang false gesetzt.
    ["Monoflop","$Trigger","$Reset","$Ausgang","$Verzögerungszeit",0]

    Die Optionen sind:

    Mit dem letzten Parameter (eine Zahl zwischen 0 und 7) kann das Trigger-Verhalten festgelegt werden.
    "re-triggerbar" bedeutet dabei , dass ein begonnener Monoflop nicht mehr ausgeführt, aber sofort erneut startet wird in dem der erneut true auf den Ausgang gesendet wird und die Verzögerungszeit von neuem startet.
    "nicht re-triggerbar" bedeutet, dass der Monoflop nicht durch einen erneuten Trigger am 1. Parameter neu gestartet wird.
    Über den Paramenter Reset kann der Timer zurückgesetzt werden.
    Ein erneutes Triggern ist erst nach Ablauf der Verzögerungszeit und nach dem Setzen des "false" am 3. Parameter möglich.

    Die Optionen sind:
    0 ... Nicht re-triggerbar, Pegelgesteuert, wenn $trigger = true ist
    1 ... Re-triggerbar, Pegelgesteuert, wenn $trigger = true ist
    2 ... Nicht re-triggerbar, Timer wird nur bei steigender Flanke getriggert
    3 ... Re-triggerbar, Timer wird nur bei steigender Flanke getriggert
    4 ... Nicht re-triggerbar, Timer wird nur bei fallender Flanke getriggert
    5 ... Re-triggerbar, Timer wird nur bei fallender Flanke getriggert
    6 ... Nicht re-triggerbar, Timer wird bei beiden Flanken getriggert
    7 ... Re-triggerbar, Timer wird bei beiden Flanken getriggert

    Mit dem Baustein Monoflop können in z.B. in Verbindung mit einer UND-Logik Ein- und Ausschaltverzögerungen umgesetzt werden.

    Weitere gute Hinweise und Erklärungen findet man hier: viewtopic.php?f=24&t=1911&p=20488&hilit ... set#p20488

  • Or
    Gibt am Ausgang 1 aus, sobald einer der Eingänge ungleich 0 ist.
    ["Or" , ["$Variable1" , "$Variable2",... ,"$Variable_n"], "$Output"]

  • Polynomial
    Berechnet den Funktionswert eines Polynoms der Form:
    f(x)=A0 + A1 * X + A2 * X^2 + ... + An * X^n
    ["Polynomial", "$Variable_X", "$Ergebnis",["$A0", "$A1", "$A2", ..., "$An"]]
  • Ramp(verfügbar ab TWS V1.6)
    Mit der "Ramp"-enfunktion lässt sich ein Wert einem neuen Zielwert langsam und schrittweise annähern.

    Die Syntax für die Rampenfunktion sieht folgendermassen aus:
    ["Ramp","$In","$Out","$Active","$Step","$Period"]
        "Ramp" :   Modulkennung
        "$In":     Referenz auf einen float Level der den angestrebten Ziel-Wert enthält
        "$Out":    Referenz auf einen float Level der den aktuellen Ist-Wert enthält
        "$Active": Referenz auf einen boolschen Level der anzeigt, wenn die Annäherung aktiv ist (Ziel- und Ist-Wert unterschiedlich)
        "$Step":   Referenz auf einen float Level der die Schrittweite der Annäherung enthält
        "$Period": Referenz auf einen float Level der den Takt der Annäherung enthält
    
    Wie funktioniert das Ganze?
    Wenn der Ist-Wert unterschiedlich zum Ziel-Wert ist, wird ein Timer (mit $Period) gestartet.
    Jedesmal wenn der Timer abläuft nähert sich der Ist-Wert dem Ziel-Wert an.
    Wenn Ist- und Ziel-Wert gleich sind wird der Timer wieder gestoppt.

    Mit diesem Modul lässt sich sehr einfach eine langsame Dimmung umsetzen (Lichtwecker)

    Weitere Details und Infos hier: Ankündigung Modul Ramp

  • Ratio
    Berechnet das Verhältnis von 2 Zahlenwerten.
    ["Ratio", "$Input_Zähler", "$Output_Verhältnis", "$Input_Nenner"]

    ACHTUNG: Der Anwender muss aktuell (min. V.1.6 IP1) vermeiden, dass eine "Division durch Null" entstehen kann (kann auch unbeabsichtigt passieren), da ansonsten alle Module ab dem [Ratio] mit Div durch 0 nicht mehr ausgeführt werden.


    Hier ein Vorschlag zum Abfangen des Fehlers:

    Code: Alles auswählen

    {
        "Level": [
        		["$Zaehler", "float", 1.0],
        		["$Nenner", "float", 1.0], 
        		["$Ergebnis", "float", 1.0], 
        		["$dummy", "bool", false],
        		// optional ["$Alternatives_Ergebnis", "float", 12345] siehe letzte Zeile
    		["$AnstelleNull", "float", 0.1] //hier sollte ein für die vorgesehene Rechnung eher niedriger Wert eingegeben werden und damit wird der Division ein Nenner gegen 0 vorgegaukelt, was in der regel zu einem Ergebnis gegen Unendlich führen wird.
    	],
    	"Input": [
    		["Zähler","","$Zaehler","c"],
    		["Nenner","","$Nenner","c"]
        ],
    	"Output": [
    	   	["Ergebnis","","$Ergebnis","c"]
        ],
        "Module": [
    		["Comparator","$Nenner","-$dummy",0],
    		["Latch","$AnstelleNull","$Nenner","$dummy",0],
            	["Ratio" , "$Zaehler" , "$Ergebnis" , "$Nenner"]
            	// optional ["Latch", "$Alternatives_Ergebnis", "$Ergebnis","$dummy",0],
        ]
    }
    
    

  • SendExplicit (verfügbar ab TWS V1.6)
    Mit diesem Modul lässt sich für ein (Ausgangs-)Level explizit festlegen, ob es gesendet werden soll.
    Die Syntax für das Modul sieht folgendermassen aus:
    ["SendExplicit","$SendCond","$Out_val",Option]
    "SendExplicit" : Modulkennung
    "$SendCond": Referenz auf einen boolschen Level der das Sendeverhalten (je nach Option) steuert
    "$Out_val": Referenz auf einen Ausgangs-Level dessen Sendeverhalten gesteuert werden soll.
    Option:
    0:Sende bei True ,
    1: Sende bei positiver Flanke,
    2: Sende bei negativer Flanke,
    3: sende bei positiver und negativer Flanke

    Ist die Sendebedingung erfüllt wird beim (Ausgangs-)Level ein Flag gesetzt, das auf die Sendeoption: X reagiert.
    Die Sendeoption X lässt sich nur in Custom-Logiken setzen und nicht wie bei den bisherigen Sende-Optionen (A,C oder T) über die GUI.

    Weitere Informationen und Diskussionen hier

  • Statemachine (verfügbar ab TWS V1.6)
    Dieses Modul besitzt auch einen optionalen (Timeout-)Timer.
    Wobei der Timeout als zusätzliche Eingangsbedingung verwendet werden kann.

    Die Syntax für den Zustandsautomat sieht folgendermassen aus:
    ["Statemachine", [Zustandsübergangstabelle], "$State"]

    "Statemachine" : Modulkennung
    "$State": Referenz auf einen integer Level der den aktuellen Status enthält

    Die [Zustandsübergangstabelle] ist eine Liste aus mehreren Zustandsübergängen.
    Jeder Zustandsübergang besteht jeweils aus einer Liste mit vier Einträgen:
    [Bedingung , aktueller Zustand, nächster Zustand, Timeout]

    Bedingung: Referenz auf einen boolschen Level
    aktueller Zustand: Integerwert, der den Zustand repräsentiert
    nächster Zustand: Integerwert, der den Zustand repräsentiert
    Timeout: Referenz auf "float"

    Weitere Details und Infos hier: Ankündigung Modul Statemachine

  • Statistic
    Liefert Min./Max./Median/Mittelwert aus mehreren Eingängen:
    [ "Statistic",[ "Input1","Input2","Input3" ],"$Min","$Max","$Mean", "$Median"]

    Auch eine variable Anzahl von Eingängen kann verwendet werden:
    [ "Statistic",[ "$VAR<Input!>" ],"$Min","$Max","$Mean", "$Median"]

  • Step
    Mit dieser Funktion kann ein Signalverlauf in eine Stufenfunktion verändert werden, d.h. der Eingangswert wird erst an den Ausgang übergeben, wenn eine definierte Differenz zur letzten Stufe überschritten wird.
    ["Step","$Input","$Output","$Stepped","$Absolute","$Relative"]

    Der Wert von $Input wird an $Output übernommen, wenn eine der folgenden Bedingungen erfüllt sind:
    • $Input >= ($Output + $Absolute) UND $Absolute >= 0
    • $Input <= ($Output - $Absolute) UND $Absolute >= 0
    • $Input >= ($Output + |$Output * $Relative|) UND $Relative >= 0
    • $Input <= ($Output - |$Output * $Relative|) UND $Relative >= 0
    Der zusätzliche boolsche Ausgang $Stepped zeigt an, ob mit dem letzten Trigger eine der obigen Bedingungen erfüllt war, d.h. der $Output verändert wurde.

    Wenn man die Referenz auf einen Level(Variable), z.B. "$Relative", durch den Zahlenwert 0 ersetzt, wird diese Bedingung nicht ausgewertet.
    ["Step","$LamellePosOut","$LamellePosStpOut",0,"$LamellePosStep",0]
    Im obigen Beispiel ist "$Relative" mit 0 ersetzt, daher werden nur absolute Schritte und keine relativen Schritte ausgewertet.
    Anmerkung: Auch "$Stepped" ist im Beispiel oben durch 0 ersetzt, da dieser Ausgang nicht weiter verwendet wurde.

  • Stopwatch
    Stopwatch erlaubt die Zeitmessung zw. Start ($In = 1) und Stop ($In = 0).
    ["Stopwatch","$In", "$Time"]

    $Time: Liefert die die Zeit, die seit dem Start der Stoppuhr abgelaufen ist (in sec.).

    Hinweis: Die Stoppuhr kann je Customlogik für jede Zeitvariable ($Time) nur einmal aufgrufen werden! D.h. ein Stoppen und neu Starten in einem Aufruf ist nicht möglich.

    In so einem Anwendungsfall müssen 2 Stoppuhren alternierend gestartet werden. Mittels Multiplexer wird die jeweils letzte Stoppuhr auf $Time kopiert. Damit kann immer die Zeit seit dem letzten Aufruf gemessen werden:

    Code: Alles auswählen

    ["Stopwatch","$Start","$Time1"],
    ["Stopwatch","-$Start","$Time2"],
    // Aktuellen Timer umkopieren
    ["Multiplexer",["$Time1","$Time2"],"$Time","-$Start"],
    

  • Tiefpass / Lowpass
    Der Tiefpass erlaubt die Glättung von Zeitsignalen. Die Stärke der Glättung wird mit der Zeitkonstante $Time_const bestimmt.
    ["Lowpass","$In_val","$Out_val","$Time_const"]

  • Triggered(verfügbar ab TWS V1.6)
    Die Syntax für die Trigger-Erkennung sieht folgendermassen aus:
    [ "Triggered", "$Input", "$Touched" ]

    "Triggered" : Modulkennung
    "$Input": Referenz auf einen Level der mit einem Eingang verbunden ist
    "$Touched": Referenz auf einen boolschen Level

    Der Trigger-Erkennung funktioniert folgendermaßen:
    Der Status des "$Input"-Levels wird überprüft, ob er beim aktellen Durchlauf dieser Logik bereits einmal "angefasst" wurde.
    Ist das der Fall wird "$Touched" auf true gesetzt, anderfalls auf false

    Wenn ein Ereignis an einem Eingang die Logik triggert, bekommt der mit dem Eingang verbundene Level vorher das "Touched"-Flag gesetzt.
    Somit lässt sich einfach abfragen, ob dieser Eingang die Logik ausgelöst hat.

    Achtung:
    Wird ein Level intern "angefasst", z.B. durch ein vorheriges Modul beschrieben, wird ebenfalls das "Touched"-Flag gesetzt. Will man sicher nur auf "Eingang triggered" testen, muss dieser Test möglichst vor allen anderen Modulen stehen, die den Level verändern können.
  • Wakeup
    Mittels Wake-up wird ein Trigger (Wecker) zu einem bestimmten Zeitpunkt erzeugt. Der Zeitpunkt (Weckzeit) muss im Unix-Zeitformat definiert werden.
    ["Wakeup","$Utime_start","$Status"],
Kopiervorlage
Folgende Kopiervorlage kann beim Erstellen von neuen Custom-Logiken helfen. die Kopiervorlage beinhaltet alle wichtigen Zeilen als Vorlage zum Kopieren und Verändern.

Code: Alles auswählen

/**
* ACHTUNG Dies ist keine sinnvolle oder funktionierende Logik!
* KOPIERVORLAGE
* Module sind hier alphabetisch sortiert und werden in der KB genauer beschrieben. Link: https://forum.timberwolf.io/app.php/kb/viewarticle?a=87
*
* Nutzungsrechte:
* Der Schöpfer dieser Custom Logik überträgt die Nutzungsrechte gemäß der TOLL ("Timberwolf Open Logikblock License") die unter https://wrgt.news/TOLL zum Download zur Verfügung steht. 
*/

// In dieser Vorlage sind alle Elemente, die es gibt einmal enthalten

{
  "Input":[
    ["Input","BlaBla","$In","a"],
    //Beim letzten Eintrag entfällt das abschließende Komma
  ],
  "Output":[
    ["Output","BlaBla","$Out","a"],
    //Beim letzten Eintrag entfällt das abschließende Komma
  ],
  "Level":[
    ["$In","bool",false],
    ["$Out","bool",false],
    ["$a", "integer",0],
    ["$b", "float",0.0],
    //Beim letzten Eintrag entfällt das abschließende Komma
  ],
  "Module":[ 
    ["And" , ["$Variable1" , "$Variable2",... ,"$Variable_n"], "$Output"],
    ["Astro",[0,0],"$Altitude","$Azimute","$Transit","$Sunrise","$Sunset","$Civil_dawn","$Civil_dusk","$Naut_dawn","$Naut_dusk","$Astro_dawn","$Astro_dusk","$Alt_moon",$Azi_moon"]], 
    ["Break", ["$Eingang"]],
    ["BinaryMultiplexer",["$In_D","$In_E","$In_F"],"$Output"],
    ["BinaryStatistic",["$VAR<Input!>"],"$MoreTrue","$FalseCount","$TrueCount"],
    ["Clocksignal","$ConstTRUE",0,"$Period"],
    ["Comparator" , "$Input_wert" , "$Output" , "$Schwellwert"],
    ["Comparator" , "$Input_Wert" , "$Output" , ["$UntereSchwelle","$ObereSchwelle"]],
    ["Interpolation","$In", "$Out", [ [x1,y1] , [x2,y2] , ... , [xn,yn ] ] ],
    ["Latch","$Eingang","$Ausgang","$Trigger",TriggerOption],
    ["Limiter","$In_val","$Out_val","$Val_ok",["$Min", "$Max"]],
    ["Localtime",0,"$Utime","$Sec","$Min","$Hour","$Mday","$Mon","$Year","$Wday","$Yday","$IsDst"],
    ["Multiplexer",["$KonstNull","$KonstEins","$KonstZwei","$KonstDrei"],"$Out","$Select"],
    ["Monoflop","$Trigger","$Reset","$Ausgang","$Verzögerungszeit",0],
    ["Or" , ["$Variable1" , "$Variable2",... ,"$Variable_n"], "$Output"],
    ["Polynomial", "$Variable_X", "Ergebnis",["$A0", "$A1", "$A2", ..., "$An"]],
    ["Ratio", "$Input_Zähler", "$Output_Verhältnis", "$Input_Nenner"],
    ["Statistic",[ "$VAR<Input!" ],"$Min","$Max","$Mean", "$Median"],
    ["Step","$Input","$Output","$Stepped","$Absolute","$Relative"],
    ["Stopwatch","$In", "$Time"],
    //Beim letzten Eintrag entfällt das abschließende Komma
  ]
}








































































Die vielen Leerzeilen dienen der besseren Bedienung mit den Anchor-Links.