[Gelöst] [V4.5] Regex-Ausdrücke nur als Parameter, nicht im Level?

[speckenbuettel]

Hallo,

mir ist an mehreren Stellen aufgefallen, dass sich Custom-Logiken nicht speichern lassen (ohne konkrete Fehlermeldung im Editor) oder nicht fehlerfrei ausgeführt werden, wenn ich Regex-Ausdrücke im Level definieren.
Als Input (Parameter) funktioniert es dann einwandfrei.

Liegt das vielleicht an den Sonderzeichen, die in Regex-Ausdrücken oft enthalten sind?

Ein Beispiel ist diese Logik:

Code: Alles auswählen

{
    "Level": [
        [
            "$InResponse",
            "string,64",
            ""
        ],
        [
            "$Pre_Logeintrag",
            "string",
            "Heizung: Anlagenzeit synchronisiert ("
        ],
        [
            "$Post_Logeintrag",
            "string",
            ")"
        ],
        [
            "$OutLogeintrag",
            "string,128",
            "Heizung: Anlagenzeit synchronisiert"
        ],
        [
            "$ReturnCode",
            "string",
            ""
        ],
        [
            "$Address",
            "string",
            ""
        ],
        [
            "$Value",
            "string,32",
            ""
        ],
        [
            "$RegexExpression",
            "string,32",
            ""
        ],
		[
		    "$RegexHasMatch",
		    "bool",
		    false
	    ],
        [
            "$VAR<Inhibit?>",
            "bool",
            false
        ]
    ],

    "Module": [
        [
            "Break", [
                "$VAR<Inhibit?>"
                ]
        ],
        [
            "Regex",
                "$InResponse",
                "$RegexExpression",
                "$RegexHasMatch",
                0,
                "$ReturnCode",
                "$Address",
                "$Value",
                0,
                0
        ],
        [
            "Concat", [
                "$Pre_Logeintrag",
                "$Value",
                "$Post_Logeintrag"
                ],
                "$OutLogeintrag"
        ],
        [
            "SendExplicit",
                "$RegexHasMatch",
                "$OutLogeintrag",
                0
        ]
    ],

    "Input": [
        [
            "Rückmeldung",
            "Rückmeldung vom Optolink-Splitter",
            "$InResponse",
            "a"
        ],
        [
            "Regex",
            "Regulärer Ausdruck",
            "$RegexExpression",
            "u"
        ],
        [
            "Inhibitor",
            "Ausführung der Logik sperren",
            "$VAR<Inhibit?>",
            "u"
        ]
    ],

    "Output": [
        [
            "Logeintrag",
            "Logeintrag",
            "$OutLogeintrag",
            "x"
        ]
    ]

}

Die habe ich erst zum Laufen gebracht, nachdem ich den Text von $RegexExpression aus dem Level herausgenommen habe und als Parameter übergebe.

Der Fehler lauten:



Dabei fehlt hier keine Klammer, den Ausdruck habe ich auf der Seite regex101.com getestet.

Wenn der gleiche Regex-Ausdruck als Parameter übergeben wird, dann erscheint die Fehlermeldung nicht.

Vielen Dank und viele Grüße
Falk

[ms20de]

Hallo Falk,

kannst du bitte auch deine Regex noch Posten damit wir das untersuchen können.

Viele Grüße,
Matthias

[speckenbuettel]

Hallo Matthias,

sorry, hätte ich schon gleich oben schreiben sollen.

In dieser Logik lautet der Regex-Ausdruck:

Code: Alles auswählen

^(1);(0x088E);((Mo|Di|Mi|Do|Fr|Sa|So) .+)$

In einer ähnlichen Logik (für die Heizung):

Code: Alles auswählen

^(\d+);(0x[0-9a-fA-F]+);(.+)$

Beide funktionieren einwandfrei auf der Seite regex101, die im Wiki zum Testen von Regex-Ausdrücken genannt wird. Und beide funktionieren einwandfrei als Parameter über den Input, aber nicht, wenn ich sie im Level deklariere.

Vielen Dank und viele Grüße
Falk

[Robert_Mini]

Kannst du die nicht funktionierende Logik auch posten?
Ich nehme an du hast den Regex-String zwischen 2 “ “ gesetzt?

Lg
Robert

[ms20de]

Hallo Falk,

nach unseren Tests ist das Problem die Angabe des String Levels auf 32 Zeichen im Custom Logik Code.
Dadurch wird der angegebene Initalwert abgeschnitten. Die Regex ist dann nur noch ^(1);(0x088E);((Mo|Di|Mi|Do|Fr|S.
Das ist die Ursache, warum der Regex Baustein einen Fehler meldet mit fehlender Klammer.

Fehlerhafte Version:

Code: Alles auswählen

[
    "$RegexExpression",
     "string,32",
      "^(1);(0x088E);((Mo|Di|Mi|Do|Fr|Sa|So) .+)$"
],

Gute Version:

Code: Alles auswählen

[
    "$RegexExpression",
     "string",
      "^(1);(0x088E);((Mo|Di|Mi|Do|Fr|Sa|So) .+)$"
],

Wenn die Länge des Initalwerts bekannt ist und sich auch nicht ändert, muss keine Länge angeben werden. Diese wird dann automatisch ermittelt. Alternativ könnte man auch string,64 angeben und es würde auch funktionieren.

Wir prüfen ob es einfach machbar ist diese Art vom Fehler direkt im Logik-Editor abzufangen.

Viele Grüße,
Matthias

[speckenbuettel]

Hallo Matthias,

vielen Dank für deine Prüfung und deine Rückmeldung.

Bei dieser Logik scheint die Länge des Strings tatsächlich die Ursache zu sein. Obwohl die Logik trotzdem funktioniert hat, solange ich den Regex-Ausdruck als Parameter übergeben habe.

Hier ist eine andere Logik, die ich gar nicht erst speicher kann, wenn ich den Regex-Ausdruck im Level definiere:

Code: Alles auswählen

{

    "Level": [
        [
            "$InResponse",
            "string,32",
            ""
        ],
        [
            "$OutBetriebsart",
            "integer",
            0
        ],
        [
            "$OutRTSollnormal",
            "float",
            0
        ],
        [
            "$OutRTSollreduziert",
            "float",
            0
        ],
        [
            "$OutWWTSoll",
            "float",
            0
        ],
        [
            "$OutSparbetrieb",
            "bool",
            false
        ],
        [
            "$OutFehler",
            "bool",
            false
        ],
        [
            "$OutMeldung?",
            "string",
            "Heizung: Fehler bei der Ausführung eines Optolink-Befehls"
        ],
        [
            "$ReturnCodeStr",
            "string",
            ""
        ],
        [
            "$ReturnCode",
            "integer",
            0
        ],
        [
            "$AddressStr",
            "string",
            ""
        ],
        [
            "$Address",
            "integer",
            0
        ],
        [
            "$ValueStr",
            "string,32",
            ""
        ],
        [
            "$Value",
            "float",
            0
        ],
        [
            "$Fehler",
            "bool",
            false
        ],

        ["$Adr_Betriebsart", "string", "0x2323"],
        ["$Adr_RTSollnormal", "string", "0x2306"],
        ["$Adr_RTSollreduziert", "string", "0x2307"],
        ["$Adr_WWSoll", "string", "0x6300"],
        ["$Adr_Sparbetrieb", "string", "0x2302" ],

        ["$Adr_IsBetriebsart", "bool", false],
        ["$Adr_IsRTSollnormal", "bool", false],
        ["$Adr_IsRTSollreduziert", "bool", false],
        ["$Adr_IsWWSoll", "bool", false],
        ["$Adr_IsSparbetrieb", "bool", false],
        
        [
            "$RegexExpression",
            "string",
            "^(\d+);(0x[0-9a-fA-F]+);(.+)$"
        ],
		[
		    "$RegexHasMatch",
		    "bool",
		    false
	    ],
		[
		    "$RegexMatch",
		    "string,32",
		    ""
		],
        [
            "$SuccessStr",
            "string",
            "1"
        ],
        [
            "$CompareMode",
            "string",
            "e"
        ],
        [
            "$VAR<Inhibit?>",
            "bool",
            false
        ]
    ],

    "Module": [
        [
            "Break", [
                "$VAR<Inhibit?>"
                ]
        ],
        [
            "Regex",
                "$InResponse",
                "$RegexExpression",
                "$RegexHasMatch",
                "$RegexMatch",
                "$ReturnCodeStr",
                "$AddressStr",
                "$ValueStr",
                0,
                0
        ],
        [
            "Stringcompare",
                "$ReturnCodeStr",
                "-$Fehler",
                "$SuccessStr",
                "$CompareMode"
        ],
        [
            "Stringcompare",
                "$AddressStr",
                "$Adr_IsBetriebsart",
                "$Adr_Betriebsart",
                "$CompareMode"
        ],
        [
            "Stringcompare",
                "$AddressStr",
                "$Adr_IsRTSollnormal",
                "$Adr_RTSollnormal",
                "$CompareMode"
        ],
        [
            "Stringcompare",
                "$AddressStr",
                "$Adr_IsRTSollreduziert",
                "$Adr_RTSollreduziert",
                "$CompareMode"
        ],
        [
            "Stringcompare",
                "$AddressStr",
                "$Adr_IsWWSoll",
                "$Adr_WWSoll",
                "$CompareMode"
        ],
        [
            "Stringcompare",
                "$AddressStr",
                "$Adr_IsSparbetrieb",
                "$Adr_Sparbetrieb",
                "$CompareMode"
        ],
        [
            "STR->FLOAT",
                "$ValueStr",
                "$Value"
        ],
        [
            "Latch",
                "$Value",
                "$OutBetriebsart",
                "$Adr_IsBetriebsart",
                0
        ],
        [
            "Latch",
                "$Value",
                "$OutRTSollnormal",
                "$Adr_IsRTSollnormal",
                0
        ],
        [
            "Latch",
                "$Value",
                "$OutRTSollreduziert",
                "$Adr_IsRTSollreduziert",
                0
        ],
        [
            "Latch",
                "$Value",
                "$OutWWTSoll",
                "$Adr_IsWWSoll",
                0
        ],
        [
            "Latch",
                "$Value",
                "$OutSparbetrieb",
                "$Adr_IsSparbetrieb",
                0
        ],
        [
            "Or", [
                "-$RegexHasMatch",
                "$Fehler"
                ],
                "$OutFehler"
        ],
        [
            "SendExplicit",
                "$OutFehler",
                "$OutMeldung?",
                0
        ]
    ],

    "Input": [
        [
            "Rückmeldung",
            "Rückmeldung vom Optolink-Splitter",
            "$InResponse",
            "a"
        ],
//        [
//            "Regex",
//            "Regulärer Ausdruck",
//            "$RegexExpression",
//            "u"
//        ],
        [
            "Inhibitor",
            "Inhibitor",
            "$VAR<Inhibit?>",
            "u"
        ]
    ],

    "Output": [
        [
            "Betriebsart",
            "Betriebsart [0, 1, 2, 3, 4]",
            "$OutBetriebsart",
            "c"
        ],
        [
            "RT-Soll normal",
            "Raumtemperatur-Soll normal [°C]",
            "$OutRTSollnormal",
            "c"
        ],
        [
            "RT-Soll reduziert",
            "Raumtemperatur-Soll reduziert [°C]",
            "$OutRTSollreduziert",
            "c"
        ],
        [
            "WW-Soll",
            "Warmwassertemperatur-Soll [°C]",
            "$OutWWTSoll",
            "c"
        ],
        [
            "Standby-Betrieb",
            "Standby-Betrieb [Aus, Ein]",
            "$OutSparbetrieb",
            "c"
        ],
        [
            "Fehler",
            "Return_Code <> SUCCESS",
            "$OutFehler",
            "a"
        ],
        [
            "Fehlermeldung",
            "Return_Code <> SUCCESS",
            "$OutMeldung?",
            "x"
        ]
  ]

}

Laut regex101 ist der Regex-Ausdruck fehlerfrei.

Vielen Dank und viele Grüße
Falk

[bondt]

Hallo Falk (@speckenbuettel),

Danke für die Meldung! Da gibt es zwei Themen:

1. Die RegEx-Expression muss escaped eingegeben werden. Hier \d durch \\d ersetzen:

Code: Alles auswählen

"^(\\d+);(0x[0-9a-fA-F]+);(.+)$"

2. Die Levels bei SendExplicit dürfen nicht optional sein. Hier:
Das Level $OutMeldung? sollte in den Blöcke Level und Module als nicht optional definiert und genutzt werden, wie $OutMeldung. Nur in Output kann es als optional angegeben werden, wie $OutMeldung?.

Wir haben es im Wiki aktualisiert.

[speckenbuettel]

Hallo Michaël,

vielen Dank für deine Antwort.

1. Am Escapen hat es gelegen, vielen Dank für den Hinweis. Das Wiki ist jetzt auch klar.

2. Das war mir vorher auch nicht so klar, aus dem Wiki ging es leider nicht so klar hervor. Allerdings war das Fragezeichen im Level und im Module bisher kein Problem, die Logik ließ sich trotzdem speichern und lief auch einwandfrei.

Problem/Frage gelöst!

Nochmals vielen Dank und viele Grüße
Falk