UPDATE 31.10.: Amazon Alexa - ioBroker Skill läuft aus ?

[stefan22]

Moin Gemeinde.

Ich bräuchte mal Hilfe beim verstehen für Node-Red

Ich möchte eine json Datei empfangen und aufteilen. Um mit einem true/false meinen KNX Aktor zu schalten.
Aber irgendwie bekomme ich das nicht hin.
Quasi ich stehe vor Node-Red wie der Sprichwörtliche Ochs vorm Berg.
Quasi null Plan.

Gruss und Danke

[haselchen]

@stefan22

Willkommen im Club :)
Fast das gleiche Problem hier:
https://forum.iobroker.net/topic/35982/ausgelesene-werte-in-datenpunkte-schreiben-node-red

[stefan22]

@haselchen Da bin ich ja Froh das es mir net nur alleine so geht :)

Gruss und Danke

[stefan22]

@haselchen Nur ich habe kein iBroker laufen

[mickym]

@stefan22 Wie kann ich helfen? Wenn Du keinen iobroker hast - dann hast Du sicher ein anderes System oder irgend eine Modul im Node-Red um mit den KNX Geräten zu kommunizieren. Dann poste doch mal einen Screen-Shot wo Du im Node-Red Daten empfängst und in einem Debug-Node ausgibst und dann das Debug Fenster mal hier als ScreenShot postest. Ansonsten auf die Kürze - vom input mit JSON -Node in ein Javascript Objekt umwandeln.

Oder Du liest die Datei ein - aber die Kommunikation mit dem KNX-Aktor musst Du erst mal wissen.

[stefan22]

@mickym Moin . Sorry für die späte Antwort bin gerade auf Montage .

So der Node Red läuft bei mir auf dem RealAirserver von RealKnx. Ipadress:1880
Die sendende App ist Geofencing
Diese sendet ja ne html/json beim Betreten und verlassen von nem vor definierten Bereich .
Wie kann ich die Datei umwandeln und den Wert entry umwandeln oder auslesen um meine Verbraucher im Knx zu schalten ? .
Das mit dem Knx hab ich hinbekommen

Gruß

[mickym]

@stefan22 auf welchem Betriebssystem läuft dein Node-Red?

[mickym]

@stefan22 Ok - hast wohl momentan wenig Zeit.

Ich nutze für das Geofencing owntracks - damit kommuniziere ich zwar über mqtt und nicht über eine Datei.

Ich habe Dir aber nun 2 Flows gebastelt - da ich mal denke, dass der JSON String vielleicht genauso aufgebaut ist:

{
    "t": "c",
    "tst": 123456789,
    "acc": 5,
    "_type": "transition",
    "event": "enter",
    "lon": 11,
    "lat": 49,
    "wtst": 1581954003,
    "tid": "XX",
    "desc": "Location"
}

Diesen hab ich mal in den Inject Node verbannt - damit Du siehst, wie ich auf den event Parameter im switch node direkt zugreife:

[
    {
        "id": "3f6b154f.c11fba",
        "type": "inject",
        "z": "d3cedfe7.726d1",
        "name": "Beispiel JSON",
        "props": [
            {
                "p": "payload"
            },
            {
                "p": "topic",
                "vt": "str"
            }
        ],
        "repeat": "",
        "crontab": "",
        "once": false,
        "onceDelay": 0.1,
        "topic": "",
        "payload": "{\"t\":\"c\",\"tst\":123456789,\"acc\":5,\"_type\":\"transition\",\"event\":\"enter\",\"lon\":11,\"lat\":49,\"wtst\":1581954003,\"tid\":\"XX\",\"desc\":\"Location\"}",
        "payloadType": "json",
        "x": 440,
        "y": 260,
        "wires": [
            [
                "7b88d3e5.f8e79c"
            ]
        ]
    },
    {
        "id": "7b88d3e5.f8e79c",
        "type": "switch",
        "z": "d3cedfe7.726d1",
        "name": "",
        "property": "payload.event",
        "propertyType": "msg",
        "rules": [
            {
                "t": "eq",
                "v": "enter",
                "vt": "str"
            },
            {
                "t": "eq",
                "v": "leave",
                "vt": "str"
            }
        ],
        "checkall": "true",
        "repair": false,
        "outputs": 2,
        "x": 630,
        "y": 260,
        "wires": [
            [
                "7e9f0ec7.6e16a"
            ],
            [
                "fbb14bc9.976718"
            ]
        ]
    },
    {
        "id": "13315852.ed89c8",
        "type": "debug",
        "z": "d3cedfe7.726d1",
        "name": "KNX Gerät",
        "active": true,
        "tosidebar": true,
        "console": false,
        "tostatus": false,
        "complete": "payload",
        "targetType": "msg",
        "statusVal": "",
        "statusType": "auto",
        "x": 1150,
        "y": 240,
        "wires": []
    },
    {
        "id": "7e9f0ec7.6e16a",
        "type": "change",
        "z": "d3cedfe7.726d1",
        "name": "setze true",
        "rules": [
            {
                "t": "set",
                "p": "payload",
                "pt": "msg",
                "to": "true",
                "tot": "bool"
            }
        ],
        "action": "",
        "property": "",
        "from": "",
        "to": "",
        "reg": false,
        "x": 800,
        "y": 200,
        "wires": [
            [
                "13315852.ed89c8"
            ]
        ]
    },
    {
        "id": "fbb14bc9.976718",
        "type": "change",
        "z": "d3cedfe7.726d1",
        "name": "setze false",
        "rules": [
            {
                "t": "set",
                "p": "payload",
                "pt": "msg",
                "to": "false",
                "tot": "bool"
            }
        ],
        "action": "",
        "property": "",
        "from": "",
        "to": "",
        "reg": false,
        "x": 810,
        "y": 300,
        "wires": [
            [
                "13315852.ed89c8"
            ]
        ]
    }
]

Das sieht dann so aus - die letzte Debug Node ist halt dann Deine Node zu Deinem KNX Aktor.

Im Prinzip geht es sogar noch einfacher - in dem Du alles in einen Change Node verpackst:

[
    {
        "id": "3f6b154f.c11fba",
        "type": "inject",
        "z": "d3cedfe7.726d1",
        "name": "Beispiel JSON",
        "props": [
            {
                "p": "payload"
            },
            {
                "p": "topic",
                "vt": "str"
            }
        ],
        "repeat": "",
        "crontab": "",
        "once": false,
        "onceDelay": 0.1,
        "topic": "",
        "payload": "{\"t\":\"c\",\"tst\":123456789,\"acc\":5,\"_type\":\"transition\",\"event\":\"enter\",\"lon\":11,\"lat\":49,\"wtst\":1581954003,\"tid\":\"XX\",\"desc\":\"Location\"}",
        "payloadType": "json",
        "x": 440,
        "y": 260,
        "wires": [
            [
                "e0c2bb47.77fb38"
            ]
        ]
    },
    {
        "id": "13315852.ed89c8",
        "type": "debug",
        "z": "d3cedfe7.726d1",
        "name": "KNX Gerät",
        "active": true,
        "tosidebar": true,
        "console": false,
        "tostatus": false,
        "complete": "payload",
        "targetType": "msg",
        "statusVal": "",
        "statusType": "auto",
        "x": 830,
        "y": 260,
        "wires": []
    },
    {
        "id": "e0c2bb47.77fb38",
        "type": "change",
        "z": "d3cedfe7.726d1",
        "name": "translate event",
        "rules": [
            {
                "t": "change",
                "p": "payload.event",
                "pt": "msg",
                "from": "enter",
                "fromt": "str",
                "to": "true",
                "tot": "bool"
            },
            {
                "t": "change",
                "p": "payload.event",
                "pt": "msg",
                "from": "leave",
                "fromt": "str",
                "to": "false",
                "tot": "bool"
            },
            {
                "t": "set",
                "p": "payload",
                "pt": "msg",
                "to": "payload.event",
                "tot": "msg"
            }
        ],
        "action": "",
        "property": "",
        "from": "",
        "to": "",
        "reg": false,
        "x": 640,
        "y": 260,
        "wires": [
            [
                "13315852.ed89c8"
            ]
        ]
    }
]

Das schaut dann ganz clean ;) aus.

Falls Du über Dateien kommunizierst und nicht über mqtt nimmst Du ("unter Speicher" ) den watch Node und liest mit file-in ein. Dann konvertierst Du den Text in JSON Format und greifst dann analog oben dann darauf zu. Damit müsstest Du das alles in den Griff bekommen.

[
    {
        "id": "4ff32339.2830dc",
        "type": "watch",
        "z": "d3cedfe7.726d1",
        "name": "",
        "files": "/home/pi/package-lock.json",
        "recursive": "",
        "x": 220,
        "y": 380,
        "wires": [
            [
                "7b232dce.c21b04"
            ]
        ]
    },
    {
        "id": "7b232dce.c21b04",
        "type": "file in",
        "z": "d3cedfe7.726d1",
        "name": "",
        "filename": "",
        "format": "utf8",
        "chunk": false,
        "sendError": false,
        "encoding": "none",
        "x": 450,
        "y": 380,
        "wires": [
            [
                "b6f50216.0a6bd"
            ]
        ]
    },
    {
        "id": "2e14a940.8785f6",
        "type": "debug",
        "z": "d3cedfe7.726d1",
        "name": "",
        "active": true,
        "tosidebar": true,
        "console": false,
        "tostatus": false,
        "complete": "false",
        "statusVal": "",
        "statusType": "auto",
        "x": 870,
        "y": 380,
        "wires": []
    },
    {
        "id": "b6f50216.0a6bd",
        "type": "json",
        "z": "d3cedfe7.726d1",
        "name": "",
        "property": "payload",
        "action": "",
        "pretty": false,
        "x": 650,
        "y": 380,
        "wires": [
            [
                "2e14a940.8785f6"
            ]
        ]
    }
]

Das heißt du verkabelst anstelle des Inject Nodes den JSON Node aus dem Datei auslesen.

Warum ich nach dem Betriebssystem gefragt habe? Nun da müssen halt die Dateipfade mit doppeltem Backslash eingetragen werden - siehst Du aber an der Info zu dem watch Node.

[stefan22]

@mickym

[mickym]

@stefan22 Ja dann brauchst ja nur den Pfad zu der Datei in dem Flow ändern

[stefan22]

@mickym ??? Ok ich schau mir das mal in Ruhe heute Nacht an .
Noch ne Frage wie bekommt man nen upd Befehl versendet . Der Output Node Is klar , aber wo schreib ich den Befehl rein .
Mir fehlt da irgendwie das Verständnis noch von
Node Red .

Vielen Dank für deine Hilfe

[mickym]

@stefan22 Ich habe zwar keine Ahnung was das upd für ein Befehl ist. Ich kenne die Output Nodes für KNX nicht. Du schriebst ja, dass Du das mit dem KNX hinbekommen hast?

Falls Du das realKNX da nutzt - musst Du meines Erachtens nur realKNX Knoten (out Node) wie die grüne Debug Node verdrahten.

Was ist upd bzw. was macht das? Wie Du Deine App dazu bringst ein Update zu machen - falls das nicht automatisch vom Handy erfolgt ist mir ehrlich gesagt schleierhaft. Zeitlich zu pollen - das ist ja wohl Technik aus den 90igern. ;)

Und falls das ein Betriebssystem-Befehl ist, den Du auf Deinem Raspi absetzen willst - nimmst halt den exec-Node.

Ansonsten kann ich Dir zum geofencing nur owntracks mit MQTT Server empfehlen - Du brauchst halt einen MQTT Server im eigenen Netz und einen VPN Zugang - aber auf dem Handyschirm scheinst Du ja mit VPN vertraut zu sein.

[stefan22]

@mickym :blush: sollte udp/tcp heißen . Hat nix mit dem knx zu tun. :blush: gibt ja auch udp und tcp Node .

Gruß

[stefan22]

@mickym

[stefan22]

@stefan22 Siehe letzte Node

[mickym]

@stefan22 Ja damit hast Dir die Antwort ja selbst gegeben - bei dem udp Node gibst ip-Zieladresse und port an und der schickt die msg.payload dorthin.

Trotzdem frage ich mich - warum Du auf Netzwerkebene kommunizieren willst ?

[stefan22]

@mickym siehst und da Ist mein Problem. Jetzt weiß ich das ich MessagePayload brauch, aber wie kommt der Code in die Message Den ich senden möchte ????
Ich denk ich hab von Grund auf zu wenig Ahnung von Node Red .
Da war das VPN demand beim bestimmten Port einfacher

[mickym]

@stefan22 das geniale an NodeRed ist, dass es im Prinzip alles transparent macht vom Trigger mit dem Du eine Nachricht erzeugst bis zum Output mit dem die Nachricht verschickt wird.

Die Nodes werden "grafisch" verdrahtet und in diesen Drähten fließt dann Dein Nachrichtenobjekt. Das Nachrichtenobjekt ist ein ganz normales Java-Objekt mit verschiedenen Elementen.

In der Regel hat ein Nachricht immer ein Topic (ist nicht zwingend) um zu zeigen, um was es sich bei der Nachricht handelt und um eine payload - die den Inhalt der Nachricht enthält. Dies kann ein einfacher String sein oder wieder ein Java-Objekt usw.

Du kannst jeder Zeit eine Nachricht mit einem ChangeNode generieren indem Du die msg.payload festlegst.

Willst Du also den Befehl "Hallo" über den upd Node verschicken - generierst Du ein msg- Objekt und legst den String auf "Hallo" fest den Du dann an die UDP-Node schickst.

Ich mach Dir wieder mal ein Beispiel-Flow:

[
    {
        "id": "2584387.06b99c8",
        "type": "udp out",
        "z": "cbd44c7e.fa8fd",
        "name": "",
        "addr": "",
        "iface": "",
        "port": "",
        "ipv": "udp4",
        "outport": "",
        "base64": false,
        "multicast": "false",
        "x": 750,
        "y": 260,
        "wires": []
    },
    {
        "id": "9227533a.0063d",
        "type": "inject",
        "z": "cbd44c7e.fa8fd",
        "name": "",
        "props": [
            {
                "p": "payload"
            },
            {
                "p": "topic",
                "vt": "str"
            }
        ],
        "repeat": "",
        "crontab": "",
        "once": false,
        "onceDelay": 0.1,
        "topic": "",
        "payload": "Hallo",
        "payloadType": "str",
        "x": 430,
        "y": 220,
        "wires": [
            [
                "2584387.06b99c8"
            ]
        ]
    },
    {
        "id": "2b8feae8.11da46",
        "type": "change",
        "z": "cbd44c7e.fa8fd",
        "name": "",
        "rules": [
            {
                "t": "set",
                "p": "payload",
                "pt": "msg",
                "to": "Hallo",
                "tot": "str"
            }
        ],
        "action": "",
        "property": "",
        "from": "",
        "to": "",
        "reg": false,
        "x": 500,
        "y": 300,
        "wires": [
            [
                "2584387.06b99c8"
            ]
        ]
    }
]

Normalerweise hängst Du einen anderen Trigger oder einen Flow vor die Change Node und legst dann ggf. die payload fest (gelbe Node).

Mit der Injekt Node - kannst Du aber zur Laufzeit die Nachricht generieren - als selbst triggern und direkt zum Beispiel über den udp Node rausschicken.

Also einfach den Code in die payload schreiben. Trotzdem bin ich zu Deiner Low-Level Netzwerkkommunikation nicht überzeugt. ;)

... und statt Hallo verschickst Du einfach Deinen Code. ;) - Ist doch easy.

[stefan22]

@mickym Siehst wenn ich mal nen Anfang richtig erklärt bekomm dann Steig ich da langsam hinter . Lach ok was meinst du mit dem low Level ?????

Gruß

[mickym]

@stefan22 Nun ich verstehe immer noch nicht warum DU über UPD oder TCP kommunizierst (das nenn ich Low-Level) - in der Regel machen das Anwendungen oder auf Neudeutsch "Apps" :stuck_out_tongue_winking_eye: