ElabNET Technik Forum

Verfasst: **Sa Okt 19, 2024 10:46 am**

Hallo,

ich habe eine Logik, die über REST-API Pushover-Nachrichten verschickt. Diese Logik hat ziemlich viele Eingangsverknüpfungen (derzeit 22).

Das sieht dann so aus:

Bild

Leider kann man nicht nach unten scrollen um die Verknüpfungen anzusehen oder zu bearbeiten. Außerdem kann man in dieser Ansicht nicht auf "Speichern und anwenden" oder "Abbrechen" klicken. Nur durch einen Klick außerhalb des Fensters wird dieses geschlossen.

Gibt es einen Trick, wie man dennoch scrollen kann? Oder ist vorgesehen, die Darstellung anzupassen, um z. B. mittels Bildlaufleiste scrollen zu können?

Vielen Dank und viele Grüße
Falk

Verfasst: **Sa Okt 19, 2024 11:10 am**

HI Falk,

da es in fast keinem Szenario sinnhaft ist (mit dieser Ausnahme vielleicht), dass soviele Objekte mit einem Eingang verbunden werden, ist auf eine Unterstützung sovieler Objekte im Verknüpfungsassistenten kein Wert gelegt worden.

Ich schlage vor, diese Logik umzubauen für mehr Eingänge oder die Logik mehrmals anzulegen und die Objekte darauf aufzuteilen.

lg

Stefan

Verfasst: **Sa Okt 19, 2024 11:30 am**

Hallo Stefan,

vielen Dank für den Tipp! Mehrere Logiken wäre in diesem Fall die naheliegende Lösung.
Hat es einen Einfluss auf die Performance der Logik-Engine oder des Timberwolf Servers, wenn man extrem viele Logiken hat?
Das Problem hätte ich nämlich an mehreren Stellen, sodass ich bei Aufteilung auf jeweils einzelne Logiken auf 150 bis 200 zusätzliche Logiken komme.

Vielen Dank und viele Grüße
Falk

Verfasst: **Sa Okt 19, 2024 12:27 pm**

Hi Falk,

es sind uns keine Performanceprobleme mit der Logik bekannt. Wir haben im Labor damals mit 10.000 Objektänderungen pro Sekunde getestet und hunderten Logiken und das war machbar - auf der alten Hardware noch.

Mit dem GIS kannst Dir diese vielen Logiken nun auch gut ordnen, zumal man jetzt zusätzlich eigene Verbindungstypen anlegen kann.

Alle Kernsysteme der Timberwolf Software sind in purem C kodiert, sind zum Teil so klein, dass sie in den Cache passen und können auf mehrere Kerne parallelisiert werden. Das ist technisch was GANZ ANDERES, als die JavaScipt- oder .net-"Engines" der Mitbewerber, die technologisch schnell an Limits stoßen.

lg

Stefan

Verfasst: **Sa Okt 19, 2024 12:33 pm**

Hallo Falk!

Kannst du mal die Logik dazu teilen? Denke das aufteilen auf mehrere Eingänge sollte da einfach gehen.

Zur Performance sehe ich da gar kein Thema, da du ja nicht mehr Abläufe triggerst sondern nur auf mehrere Zellen verteilt (vorausgesetzt die Logik wird nur beim Event getriggert).

Lg
Robert

Verfasst: **Sa Okt 19, 2024 12:54 pm**

Hallo Robert,

es ist eine Custom-Logik:

Bild

Code: Alles auswählen


{

    "Level": [
        [
            "$Category",
            "string,32",
            ""
        ],
        [
            "$Text",
            "string,1024",
            ""
        ],
        [
            "$Alarm",
            "bool",
            false
        ],
        [
            "$Geraete",
            "string,64",
            ""
        ],
        [
            "$Token",
            "string",
            "xxxxx"
        ],
        [
            "$User",
            "string",
            "xxxxx"
        ],
        [
            "$Device",
            "string",
            ""
        ],
        [
            "$Priority",
            "integer",
            0
        ],
        [
            "$Title",
            "string",
            "System"
        ],
        [
            "$Message",
            "string,1024",
            ""
        ],
        [
            "$Ttl",
            "string",
            ""
        ],
        [
            "$VAR<Inhibit?>",
            "bool",
            false
        ]
    ],

    "Module": [
        [
            "Break",
            [
                "$VAR<Inhibit?>"
            ]
        ],
        [
            "Multiplexer",
            [
                "$Category"
            ],
            "$Title",
            0
        ],
        [
            "Multiplexer",
            [
                "$Text"
            ],
            "$Message",
            0
        ],
        [
            "BinaryMultiplexer",
            [
                "$Alarm"
            ],
            "$Priority"
        ],
        [
            "Multiplexer",
            [
                "$Geraete"
            ],
            "$Device",
            0
        ]
    ],

    "Input": [
        [
            "Titel",
            "Titel der Pushover-Nachricht",
            "$Category",
            "u"
        ],
        [
            "Nachricht",
            "Text der Pushover-Nachricht",
            "$Text",
            "c"
        ],
        [
            "Alarm",
            "Als Alarm senden?",
            "$Alarm",
            "u"
        ],
        [
            "Geräte",
            "Geräte, an die die Nachricht gesendet werden soll",
            "$Geraete",
            "u"
        ],
        [
            "Inhibitor",
            "Inhibitor",
            "$VAR<Inhibit?>",
            "u"
        ]
    ],

    "Output": [
        [
            "Token",
            "Token",
            "$Token",
            "a"
        ],
        [
            "User",
            "User",
            "$User",
            "a"
        ],
        [
            "Device",
            "Device",
            "$Device",
            "c"
        ],
        [
            "Priority",
            "Priority",
            "$Priority",
            "c"
        ],
        [
            "Title",
            "Title",
            "$Title",
            "a"
        ],
        [
            "Message",
            "Message",
            "$Message",
            "a"
        ],
        [
            "TTL",
            "TTL",
            "$Ttl",
            "c"
        ]
    ]

}

Geht das eventuell, indem man die Nachricht als Mehrfachvariable deklariert? Daran habe ich noch gar nicht gedacht und es daher nicht ausprobiert.

Vielen Dank und viele Grüße
Falk

Verfasst: **Do Nov 14, 2024 2:54 am**

Hallo Robert @Robert_Mini

ich habe nun mal versucht, den Eingang mittels Mehrfachvariable auf mehrere Eingänge aufzuteilen:

Bild

Code: Alles auswählen


{

    "Level": [
        [
            "$Category",
            "string,32",
            ""
        ],
        [
            "$VAR<Text>!",
            "string,1024",
            ""
        ],
        [
            "$Alarm",
            "bool",
            false
        ],
        [
            "$Geraete",
            "string,64",
            ""
        ],
        [
            "$Token",
            "string",
            "ad1cjyoos81yfoevk5i6dqfcq5mcay"
        ],
        [
            "$User",
            "string",
            "udrt6qqircmkr748qegvbctextr99h"
        ],
        [
            "$Device",
            "string",
            ""
        ],
        [
            "$Priority",
            "integer",
            0
        ],
        [
            "$Title",
            "string",
            "System"
        ],
        [
            "$Message",
            "string,1024",
            ""
        ],
        [
            "$Ttl",
            "string",
            ""
        ],
        [
            "$VAR<Inhibit?>",
            "bool",
            false
        ]
    ],

    "Module": [
        [
            "Break",
            [
                "$VAR<Inhibit?>"
            ]
        ],
        [
            "Multiplexer",
            [
                "$Category"
            ],
            "$Title",
            0
        ],
        [
            "Multiplexer",
            [
                "$VAR<Text>!"
            ],
            "$Message",
            0
        ],
        [
            "BinaryMultiplexer",
            [
                "$Alarm"
            ],
            "$Priority"
        ],
        [
            "Multiplexer",
            [
                "$Geraete"
            ],
            "$Device",
            0
        ]
    ],

    "Input": [
        [
            "Titel",
            "Titel der Pushover-Nachricht",
            "$Category",
            "u"
        ],
        [
            "Nachricht",
            "Text der Pushover-Nachricht",
            "$VAR<Text>!",
            "c"
        ],
        [
            "Alarm",
            "Als Alarm senden?",
            "$Alarm",
            "u"
        ],
        [
            "Geräte",
            "Geräte, an die die Nachricht gesendet werden soll",
            "$Geraete",
            "u"
        ],
        [
            "Inhibitor",
            "Inhibitor",
            "$VAR<Inhibit?>",
            "u"
        ]
    ],

    "Output": [
        [
            "Token",
            "Token",
            "$Token",
            "a"
        ],
        [
            "User",
            "User",
            "$User",
            "a"
        ],
        [
            "Device",
            "Device",
            "$Device",
            "c"
        ],
        [
            "Priority",
            "Priority",
            "$Priority",
            "c"
        ],
        [
            "Title",
            "Title",
            "$Title",
            "a"
        ],
        [
            "Message",
            "Message",
            "$Message",
            "a"
        ],
        [
            "TTL",
            "TTL",
            "$Ttl",
            "c"
        ]
    ]

}

Das funktioniert leider nicht: beim EIntreffen einer Nachricht auf einen beliebiegen Eingang wird die Logik getriggert, aber der Wert des letzten Eingangs (in diesem Fall ein leerer String) wird auf den Ausgang weitergereicht.

Ich könnten natürlich alle Text-Eingänge auf "U" stellen und für jede Nachricht einen Trigger hinzufügen, aber dann habe ich 23 Eingänge und 23 Trigger (es werden bestimmt noch ein paar Eingänge mehr wenn ich weitere Nachrichten per Pushover verschicken möchte). Das wird dann total unübersichtlich.

Hast du eine Idee?

Vielen Dank und viele Grüße
Falk

Verfasst: **Do Nov 14, 2024 3:10 pm**

Hallo Falk!

Hab mir das gerade nochmal angesehen.
Der Absatz mit Mehrfachvariablen klappt hier nicht, da du beim entsprechenden Multiplexer angeben müsstest, welcher Eingang ausgelöst hat.
Meines Wissens ist aber die Verwendung des Moduls „Triggered“ nicht vorbereitet, Mehrfacheingänge zu verarbeiten.
Ich würde das genau so, wie von Stefan erwähnt lösen und die ursprüngliche Logik auf 3x10 o.ä. Nachrichten aufteilen.
Eventuell sorgt es ja sogar für zusätzlichen Überblick, wenn du das nach Alarm, Haus, Technik,… sortierst.

Einen Gedanken hätte ich noch:
Das Array manuell anlegen mit $In1, $In2… und dann per Triggered auswerten, welcher Eingang ausgelöst hat und dieses $In für das Telegramm verwenden.

Du kannst dann an jeden Eingang trotzdem 10 Verbindungen anhängen. Das wäre dann weiter nur 1 Baustein.

Lg
Robert

Verfasst: **Sa Nov 16, 2024 11:08 am**

Hallo Robert,

vielen Dank für deine Rückmeldung.

Dann mache ich es so: Aufteilung auf mehrere Logiken mit jeweils 10 Objekten auf einen Eingang.

Viele Grüße
Falk

Verfasst: **Sa Nov 16, 2024 12:01 pm**

Ist aus meiner Sicht der richtige Grad der Modularisierung.
Je Nachricht eine Logik wäre das eine Extrem, eine Logik für alle Nachrichten das andere.

Ich habe eine Ähnliches Thema bei meinen Persistenten Werten. Da könnte ich auch 40 Werte gemischt bool/int/float und Beschattung, Heizung etc. reinpacken.
Am Ende hab ich das nach Gewerken (Beschattung, Heizung, …) aufgeteilt und dafür aber je Logik die Datentypen gemischt.

Lg
Robert

ElabNET Technik Forum

[V4.1 IP3] Darstellung vieler Quellen im Logikeditor

[V4.1 IP3] Darstellung vieler Quellen im Logikeditor

Re: [V4.1 IP3] Darstellung vieler Quellen im Logikeditor

Re: [V4.1 IP3] Darstellung vieler Quellen im Logikeditor

Re: [V4.1 IP3] Darstellung vieler Quellen im Logikeditor

Re: [V4.1 IP3] Darstellung vieler Quellen im Logikeditor

Re: [V4.1 IP3] Darstellung vieler Quellen im Logikeditor

Re: [V4.1 IP3] Darstellung vieler Quellen im Logikeditor

Re: [V4.1 IP3] Darstellung vieler Quellen im Logikeditor

Re: [V4.1 IP3] Darstellung vieler Quellen im Logikeditor

Re: [V4.1 IP3] Darstellung vieler Quellen im Logikeditor