Was ist ein virtuelles Gerät?

Ein Widget, dessen Zustand ohne physische Protokollverbindung auf dem Server liegt. Es kann einen Merker, eine Gruppe, einen berechneten Wert oder einen Node-RED-Datenpunkt darstellen.

Wie bleibt ein virtueller Wert nach einem Neustart erhalten?

Aktivieren Sie Persist State am Kommunikationsobjekt. Ein virtuelles Objekt hat keine Standardwerteinstellung.

Wo öffne ich Node-RED?

Aktivieren Sie den optionalen Node-RED-Dienst auf der Seite Services und starten Sie den Server neu. Sobald der Dienst läuft, erscheint sein Eintrag unter APPS in der Admin-Seitenleiste und öffnet den Flow-Editor in einem neuen Tab.

Wann sollte ich Node-RED statt der Logik-Engine verwenden?

Verwenden Sie die Logik-Engine für übliche Gebäudelogik mit Validierung und Überwachung. Node-RED eignet sich für eigene Integrationen und Flows, die nicht in diese Bausteine passen.

Warum ignoriert ein HyperVisu-Node meine Nachricht?

Der Zielname in msg.inputTarget fehlt, ist falsch geschrieben oder hat die falsche Groß- und Kleinschreibung — etwa Switch ON/OFF statt Switch On/OFF. Setzen Sie ihn mit einem Input Target-Node. Prüfen Sie auch die Gerätezuordnung: Ein importiertes Beispiel zeigt „(set device)“, bis Sie ein Gerät auswählen.

Benötigen Flows die Alarm-PIN?

Nein. Ein Flow führt die Scharfschaltung und Unscharfschaltung eines Alarms ohne PIN aus, auch bei geschütztem Alarm, ebenso wie Szenarien und Automatisierungen.

Virtuelle Geräte und Node-RED

Virtuelle Geräte

Ein virtuelles Gerät hat keinerlei physische Verbindung — der Server selbst speichert seinen Zustand. Virtuelle Geräte verbinden die Funktionen anspruchsvoller Installationen. Typische Anwendungen:

Datenpunkte, die von Node-RED-Flows angesteuert werden (siehe unten).
Gerätegruppen — eine Gruppe ist ein virtuelles Widget, das seine Mitglieder ansteuert (siehe „Gerätegruppen“).
Materialisierte Logikausgänge — der Ausgang einer Funktion wird zu einem echten Widget (siehe „Funktionseinrichtung und Ausgänge“).
Merker und Sollwerte für Automatisierungen („Urlaubsmodus“, „Solltemperaturverschiebung“).

Erstellen Sie diese im Arbeitsbereich Geräte wie jedes andere Widget, mit Protocol auf VIRTUAL. Pro Objekt stellen Sie Folgendes ein:

Einstellung	Bedeutung
Range - Min / Range - Max	Die vom Objekt akzeptierten Werte. Ein von außen geschriebener Wert (aus einem Flow oder dem Webhook) außerhalb des Bereichs wird abgelehnt; ein neues Objekt beginnt mit 0 bis 100.
Persist State	Ob der aktuelle Wert einen Serverneustart übersteht. Für Merker und Sollwerte aktivieren; für kurzzeitige Signale deaktiviert lassen.

Ein virtuelles Objekt hat keine Standardwerteinstellung. Aktivieren Sie Persist State, wenn der letzte Wert nach einem Neustart wiederhergestellt werden muss. Die Object ID unter dem Titel des Objektdialogs dient Flows und dem Webhook zur Adressierung des Objekts.

Objekteinstellungen eines virtuellen Widgets.

Node-RED

Node-RED ist ein optionaler Dienst auf dem Server (unter „Dienste und Protokolle“ aktivieren) zum Erstellen eigener Flows — MQTT-Brücken, spezielle Cloud-APIs, individuelle Logik außerhalb der Möglichkeiten der Logik-Engine oder ein Treiber für ein von HyperVisu nicht unterstütztes Gerät.

Aktivieren: Schalten Sie unter Services den Dienst Node-RED ein. Die Zeile zeigt Changes need a restart; klicken Sie im Banner Pending Changes auf Restart Server und warten Sie, bis der Server wieder verfügbar ist.
Öffnen: Sobald der Dienst läuft, erscheint Node-Red in der Gruppe APPS der Admin-Seitenleiste. Klicken Sie darauf, um den Flow-Editor in einem neuen Tab zu öffnen.
Verbindung: Melden Sie sich mit Ihrem HyperVisu-Konto an.
Geräte ansteuern: Die Hypervisu-Nodes der Palette lesen und schreiben HyperVisu-Geräte direkt (siehe „Die HyperVisu-Nodes“ unten). Virtuelle Geräte bilden den natürlichen Verbindungspunkt: Der Flow berechnet, das virtuelle Gerät zeigt das Ergebnis an und nimmt wie jedes andere Gerät an Szenarien, Automatisierungen und Ansichten teil.
Webhook-API: Flows und Drittsysteme können auch die Geräte-Webhook-API verwenden, die durch Prüfung der Seriennummer geschützt ist (siehe „Webhooks und Drittanbieter-APIs“). Dafür muss Webhooks auf der Seite Services eingeschaltet sein (siehe „Dienste und Protokolle“). Behandeln Sie die Seriennummer vertraulich: Jeder, der sie kennt, kann über den Webhook schreiben.

💡 Tipp: Bevorzugen Sie für übliche Gebäudelogik die Logik-Engine (siehe „Logik-Engine — Konzepte und Arbeitsfläche“) — sie wird überwacht, validiert und ist für Bewohner sichtbar. Verwenden Sie Node-RED für Aufgaben, die Code erfordern.

Die HyperVisu-Nodes

Node-RED auf dem Server enthält die Palettenkategorie Hypervisu: einen Node pro Gerätetyp, einen Input Target-Node, zwei Nodes für globale Befehle und einen Scenario-Node. Ein Geräte-Node steht für ein HyperVisu-Gerät. Senden Sie ihm eine Nachricht, wird das Gerät angesteuert; bei einer Geräteänderung gibt der Node den neuen Wert über einen seiner Ausgänge aus.

Die zur Kategorie Hypervisu gescrollte Palette.

Node	Gerätetyp (siehe „Übersicht der Widget-Typen“)	Eingänge → Ausgänge
Pushbutton	Taster	Beliebige Nachricht → 1 Ausgang
Light Switch, Switch	Lichtschalter, Schalter	2 Ziele → 2 Ausgänge
Analog Output	Analogausgang	Eine Zahl → 1 Ausgang
Shutter / Blind	Rollladen / Jalousie	8 Ziele → 8 Ausgänge
Temperature Controller	Temperatur / Thermostat	5 Ziele → 5 Ausgänge
Dimmer	Dimmer	4 Ziele → 4 Ausgänge
RGB Dimmer	RGB-Dimmer	4 Ziele → 4 Ausgänge
Tunable White Dimmer	Tunable-White-Dimmer	6 Ziele → 6 Ausgänge
Analog Input	Analogeingang	Eine Zahl → 1 Ausgang
Digital Input	Digitaleingang	true / false → 1 Ausgang
Text Input	Texteingang	Ein Text → 1 Ausgang
Alarm	Alarm	7 Ziele → 7 Ausgänge
Audio	Audio	13 Ziele → 13 Ausgänge
Ventilation	Lüftung	10 Ziele → 10 Ausgänge
Air Conditioning	Klimaanlage	11 Ziele → 11 Ausgänge
Door Lock	Türschloss	2 Ziele → 2 Ausgänge
Meter	Zähler	4 Ziele → 4 Ausgänge
Charger	Ladestation für Elektrofahrzeuge	8 Ziele → 8 Ausgänge
Global Lights, Global Shutters	Alle Leuchten oder Rollläden eines Raums oder einer Kategorie	Ein / Aus, Auf / Ab — kein Ausgang
Scenario	Ein Szenario	Jede Nachricht führt es aus — kein Ausgang
Input Target	—	Fügt einer Nachricht den Zielnamen hinzu (siehe „Der Input Target-Node“)

Wie die Nodes den Server erreichen. Node-RED auf dem Server enthält einen Hypervisu-Subflow, der bereits in einem Flow-Tab platziert ist, neben den Nodes zur Weiterleitung von Nachrichten zu und von den Geräte-Nodes (einem Link-Node, einem Widget out-Node und einem Weiterleitungs-Node). Der Subflow meldet sich mit einem eigenen Dienstkonto am Server an, lädt Räume, Kategorien, Geräte und Szenarien und hält die Live-Verbindung offen. Lassen Sie diese Nodes an ihrem Platz: Ohne sie haben die Geräte-Nodes leere Listen und bleiben stumm. Die Palette enthält auch einen Msg Forwarder-Node: Er gehört zu dieser Weiterleitung und ist bereits platziert — fügen Sie Ihren Flows keinen weiteren hinzu.

⚠️ Warnung: Flows arbeiten mit vollen Rechten. Ein Global Lights- oder Global Shutters-Node wirkt auf alle passenden Geräte des Raums oder der Kategorie, auch auf physische Geräte.

Einen Geräte-Node hinzufügen

Voraussetzungen: aktivierter Node-RED-Dienst (siehe „Node-RED“ oben), aktivierter Server und im Arbeitsbereich Geräte angelegtes Gerät.

Ziehen Sie im Node-RED-Editor den Node des Gerätetyps aus der Palettenkategorie Hypervisu auf den Flow.
Doppelklicken Sie auf den Node. Der Dialog zeigt Räume, Kategorien und Geräte der Installation.
Wählen Sie Room, dann Category, dann Widget (das Gerät). Jede Liste grenzt die nächste ein. Das Gerät muss dem Node-Typ entsprechen: Ein Dimmer-Node zeigt nur Dimmer.
Prüfen Sie Description und die Objektliste darunter: Sie zeigen die Geräteobjekte mit ihren Object IDs, damit Sie das gewählte Gerät überprüfen können.
Name to display wird automatisch mit „Room - Device“ gefüllt. Ändern Sie den Namen für eine andere Beschriftung auf der Arbeitsfläche.
Klicken Sie auf Done.
Verbinden Sie einen inject-Node (oder einen anderen Node, der einen Wert erzeugt) mit dem Eingang und einen debug-Node mit jedem zu beobachtenden Ausgang.
Klicken Sie auf Deploy.

Der geöffnete Dialog des Light Switch-Nodes.

Fehlt ein gerade erstelltes Gerät in den Listen, starten Sie die Flows neu (Menü Deploy → Restart Flows), laden Sie die Editorseite neu und öffnen Sie den Dialog erneut.

Ein- und ausgehende Nachrichten

Eine Nachricht an einen Geräte-Node enthält zwei Eigenschaften:

Eigenschaft	Inhalt
`msg.inputTarget`	Für welches Geräteobjekt der Wert bestimmt ist, angegeben durch dessen Namen — etwa `Switch On/OFF` oder `Dimming setpoint`. Die Namen pro Node stehen unten in „Node-Referenz“. Verwenden Sie einen Input Target-Node zur Auswahl (siehe „Der Input Target-Node“).
`msg.payload`	Der Wert: `true` / `false`, eine Zahl, ein Text oder ein RGB-Objekt `{"red": 255, "green": 120, "blue": 0}`.

Eine ausgehende Nachricht enthält den Wert in msg.payload und die Object ID des Objekts in msg.topic. Ausgang n gehört zu Ziel n der Node-Liste, in derselben Reihenfolge.

Die Ziele eines Nodes sind in zwei Arten unterteilt:

Befehle (Switch On/OFF, Dimming setpoint, Up/Down output…) — das Senden steuert das Gerät an, genau wie ein Tippen in der App.
Rückmeldungen (Feedback, Status feedback, Actual setpoint, Temperature…) — der vom Gerät gemeldete Zustand. Schreiben aus einem Flow aktualisiert den in HyperVisu angezeigten Wert; an das Gerät wird nichts gesendet.

Wann Ausgänge auslösen:

Ausgang eines…	Löst aus, wenn
Befehlsziels	der Flow dieses Ziel sendet (der Wert wird sofort ausgegeben); die App, ein Szenario, eine Automatisierung oder ein anderer Flow das Gerät ansteuert — nur bei Wertänderung.
Rückmeldungsziels	das Gerät einen Wert meldet — jedes Mal, auch bei gleichem Wert.

ℹ️ Hinweis: Groß- und Kleinschreibung wird beachtet. Eine Nachricht mit unbekanntem Namen oder ohne msg.inputTarget bei einem Node, der dieses benötigt, wird ohne Fehler ignoriert — etwa Switch ON/OFF statt Switch On/OFF.

Node-RED als Gerätetreiber

Node-RED kann ein Gerät anbinden, für das HyperVisu kein Protokoll besitzt:

Erstellen Sie ein virtuelles Gerät des richtigen Typs (siehe „Virtuelle Geräte“ oben).
Fügen Sie dessen Node einem Flow hinzu. Verbinden Sie die Befehlsausgänge mit den Nodes, die mit dem realen Gerät kommunizieren (HTTP, MQTT, seriell…).
Führen Sie die Antworten des realen Geräts über einen Input Target-Node mit dem passenden Rückmeldungsziel in den Node zurück.

Bewohner bedienen das Gerät wie gewohnt in den Apps; der Flow überträgt die Befehle und führt den Zustand zurück.

Die Debug-Seitenleiste nach einer Injektion „ON“ in den Light Switch-Node.

Der Input Target-Node

Der Input Target-Node setzt msg.inputTarget anhand einer Liste, sodass Sie die Namen nicht eingeben müssen.

Ziehen Sie einen Input Target-Node zwischen die Wertquelle und den Geräte-Node.
Doppelklicken Sie darauf.
Wählen Sie unter Widget den Gerätetyp (Dimmer, Shutter/Blind, Audio…).
Wählen Sie unter Input das Ziel. Die Liste zeigt die Ziele dieses Typs in der Reihenfolge der Ausgänge des Geräte-Nodes.
Füllen Sie optional Name aus. Ohne Namen zeigt der Node den Zielnamen auf der Arbeitsfläche.
Klicken Sie auf Done, dann auf Deploy.

Der geöffnete Dialog des Input Target-Nodes.

Der Node leitet jede Nachricht mit hinzugefügtem msg.inputTarget weiter und zeigt darunter den letzten Wert an: einen grünen Punkt mit Value: … oder einen roten Ring mit No input target selected, wenn Input leer ist. Vor einem Geräte-Node stehen üblicherweise mehrere Input Target-Nodes, einer pro verwendetem Ziel.

💡 Tipp: Setzen Sie in einem function-Node dieselbe Eigenschaft selbst — msg.inputTarget = "Dimming setpoint"; msg.payload = 40; return msg;. Eine Funktion kann dann mehrere Ziele nacheinander mit node.send() senden.

Node-Referenz

Jeder Eintrag listet die Ziele in Ausgangsreihenfolge. C = Befehl, F = Rückmeldung. Die Beispiele stammen aus einem Testflow mit virtuellen Geräten: inject-Nodes links, Input Target-Nodes in der Mitte, der Geräte-Node und rechts ein debug-Node pro Ausgang.

Ein Beispiel importieren

Jedes folgende Beispiel ist als Datei zum Import in Ihr eigenes Node-RED verfügbar. Die Geräte-Nodes dieser Dateien sind keinem Gerät zugeordnet: Ihr Name enthält „(set device)“.

Laden Sie die Beispieldatei herunter.
Öffnen Sie im Node-RED-Editor das Hauptmenü (☰) und wählen Sie Import.
Klicken Sie auf select a file to import und wählen Sie die Datei, oder fügen Sie deren Inhalt in den Dialog ein.
Wählen Sie current flow oder new flow, klicken Sie auf Import und dann auf die Arbeitsfläche, um die Gruppe zu platzieren.
Doppelklicken Sie auf den Geräte-Node und wählen Sie Room, Category und Widget Ihrer Installation (siehe „Einen Geräte-Node hinzufügen“). Wählen Sie bei Global Lights und Global Shutters einen Raum oder eine Kategorie; bei Scenario ein Szenario. Klicken Sie auf Done.
Klicken Sie auf Deploy.

⚠️ Warnung: Die inject-Nodes eines Beispiels steuern das Gerät sofort beim Anklicken an. Ordnen Sie die Beispiele zuerst einem Testgerät oder virtuellen Gerät zu und wählen Sie das Gerät vor dem Bereitstellen — ein Geräte-Node ohne Gerät protokolliert nur Fehler.

Taster

Eingang	Ausgang
Beliebige Nachricht — `msg.inputTarget` und `msg.payload` werden nicht benötigt	1 · der gesendete Wert, bei jeder Betätigung des Tasters (App, Szenario oder Flow), sobald der Server ihn hat

Der Geräte-Untertyp bestimmt den Wert: ON sendet true, OFF sendet false, Toggle sendet das Gegenteil des letzten Werts.

Pushbutton.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Lichtschalter und Schalter

#	Ziel	Art	Wert
1	`Switch On/OFF`	C	`true` / `false`
2	`Feedback`	F	`true` / `false`

Light-Switch.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Switch.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Analogausgang

Eingang	Ausgang
Eine Zahl in `msg.payload` innerhalb des Gerätebereichs; `msg.inputTarget` ist optional (`Analog Output`)	1 · Befehl — der Wert bei jeder Ansteuerung des Geräts (App, Szenario, Automatisierung oder Flow)

Analog-Output.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Rollladen / Jalousie

#	Ziel	Art	Wert
1	`Up/Down output`	C	`false` = auf, `true` = ab
2	`Stop output`	C	`true` = Stopp
3	`Blind Position input`	F	Position 0–100 %
4	`Blind Position output`	C	Position 0–100 %
5	`Moving Up input`	F	`true` während der Aufwärtsfahrt
6	`Moving Down input`	F	`true` während der Abwärtsfahrt
7	`Slat Position input`	F	Lamellenwinkel 0–100 %
8	`Slat Position output`	C	Lamellenwinkel 0–100 %

Positionen folgen der HyperVisu-Regel: 100 % ist vollständig geschlossen. Lamellenziele gibt es nur bei Rollläden mit Lamellen. Die Ausgänge 1 und 2 lösen bei jedem Befehl aus, auch bei gleichem Wert.

Shutter-Blind.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Temperaturregler

#	Ziel	Art	Wert
1	`Setpoint`	C	°C
2	`Temperature`	F	gemessene Temperatur, °C
3	`Actual setpoint`	F	°C
4	`Mode Selection`	C	Modusnummer: `1` Komfort, `2` Bereitschaft, `3` Nacht
5	`Actual mode`	F	Modusnummer

Temperature-Controller.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Dimmer

#	Ziel	Art	Wert
1	`Switch On/OFF`	C	`true` / `false`
2	`Status feedback`	F	`true` / `false`
3	`Dimming setpoint`	C	0–100 %
4	`Dimming feedback`	F	0–100 %

Dimmer.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

RGB-Dimmer

#	Ziel	Art	Wert
1	`Switch On/OFF`	C	`true` / `false`
2	`Status feedback`	F	`true` / `false`
3	`RGB setpoint`	C	`{"red": 0–255, "green": 0–255, "blue": 0–255}`
4	`RGB feedback`	F	gleiches Format

RGB-Dimmer.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Tunable-White-Dimmer

#	Ziel	Art	Wert
1	`Switch On/OFF`	C	`true` / `false`
2	`Status feedback`	F	`true` / `false`
3	`Dimming setpoint`	C	Helligkeit 0–100 %
4	`Dimming feedback`	F	Helligkeit
5	`Temperature setpoint`	C	Farbtemperatur im Bereich des Geräteobjekts
6	`Temperature feedback`	F	Farbtemperatur

Tunable-White-Dimmer.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Analogeingang und Digitaleingang

Node	Eingang	Ausgang
Analog Input	Eine Zahl in `msg.payload` innerhalb des Gerätebereichs; `msg.inputTarget` optional (`Analog Input`)	1 · der Wert bei jeder Meldung des Geräts
Digital Input	`true` / `false`; `msg.inputTarget` optional (`Digital Input`)	1 · der Zustand bei jeder Meldung des Geräts

Dies sind Messwerte: Ein von einem Flow geschriebener Wert wird erst ausgegeben, nachdem der Server ihn gespeichert hat, nicht zum Zeitpunkt des Sendens durch den Flow.

Analog-Input.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Digital-Input.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Texteingang

Eingang	Ausgang
Ein Text in `msg.payload`; `msg.inputTarget` optional (`Text`)	1 · der Text bei jeder Änderung auf dem Server

Der Node akzeptiert Texte aus einem Flow nur für ein VIRTUAL-Textgerät. Auf KNX enthält ein Text (DPT 16) höchstens 14 Zeichen.

Text-Input.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Alarm

#	Ziel	Art	Wert
1	`Arm Command`	C	sendet immer `true`, unabhängig von der Nutzlast
2	`Partial Arm Command`	C	sendet immer `true`
3	`Disarm Command`	C	sendet immer `true`
4	`Armed Status`	F	`true` / `false`
5	`Partial Armed Status`	F	`true` / `false`
6	`Disarmed Status`	F	`true` / `false`
7	`Alarm Status`	F	`true`, wenn der Alarm ausgelöst wird

Es wird keine PIN abgefragt, auch wenn der Alarm durch eine PIN geschützt ist.

Alarm.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Audio

#	Ziel	Art	Wert
1	`Volume setpoint`	C	0–100
2	`Volume feedback`	F	0–100
3	`Zone On/Off`	C	`true` / `false`
4	`Zone feedback`	F	`true` / `false`
5	`Mute On/Off`	C	`true` / `false`
6	`Mute feedback`	F	`true` / `false`
7	`Play/Stop`	C	`true` = Wiedergabe, `false` = Stopp
8	`Play/Stop feedback`	F	`true` / `false`
9	`Source selection`	C	Quellennummer
10	`Source feedback`	F	Quellennummer
11	`Previous/Next`	C	`false` = vorheriger, `true` = nächster
12	`Track Title`	F	Text
13	`Track Artist`	F	Text

Ausgang 11 löst bei jeder Betätigung aus, auch bei gleichem Wert.

Audio.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Lüftung

#	Ziel	Art	Wert
1	`Auto On/Off`	C	`true` / `false`
2	`Auto feedback`	F	`true` / `false`
3	`Slow On/Off`	C	`true` / `false`
4	`Slow feedback`	F	`true` / `false`
5	`Medium On/Off`	C	`true` / `false`
6	`Medium feedback`	F	`true` / `false`
7	`High On/Off`	C	`true` / `false`
8	`High feedback`	F	`true` / `false`
9	`Boost`	C	`true` / `false`
10	`Boost feedback`	F	`true` / `false`

Ventilation.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Klimaanlage

#	Ziel	Art	Wert
1	`On/Off`	C	`true` / `false`
2	`On/Off feedback`	F	`true` / `false`
3	`Heating Mode`	C	`true`
4	`Heating feedback`	F	`true` / `false`
5	`Cooling Mode`	C	`true`
6	`Cooling feedback`	F	`true` / `false`
7	`Auto Mode`	C	`true`
8	`Auto feedback`	F	`true` / `false`
9	`Setpoint`	C	°C
10	`Actual setpoint`	F	°C
11	`Temperature`	F	gemessene Temperatur, °C

Air-Conditioning.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Ein zweites Air Conditioning-Beispiel am selben Gerät mit Input Target-Nodes.

Air-Conditioning-Input-Targets.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Türschloss

#	Ziel	Art	Wert
1	`Lock/Unlock`	C	`true` = verriegeln, `false` = entriegeln
2	`Feedback`	F	`true` / `false`

Door-Lock.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Zähler

#	Ziel	Art	Wert
1	`Power/Flow`	F	Zahl (W oder Durchfluss für Wasser und Gas)
2	`Energy/Volume`	F	Zahl (kWh oder Volumen)
3	`Exported Energy`	F	Zahl (kWh)
4	`State Of Charge`	F	Zahl (%)

Ohne msg.inputTarget geht der Wert an Power/Flow. Ein Zähler besitzt nur die Objekte seiner Rolle (siehe „Übersicht der Widget-Typen“): Ein Netzzähler hat keinen Ladezustand. Ein von einem Flow geschriebener Wert wird ausgegeben, sobald der Server ihn gespeichert hat.

Meter.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Ladestation

#	Ziel	Art	Wert
1	`Start/Stop`	C	`true` = starten, `false` = stoppen
2	`Charging`	F	`true` / `false`
3	`Charging Current`	C	A
4	`Connected`	F	`true`, wenn ein Fahrzeug angeschlossen ist
5	`Error`	F	`true` / `false`
6	`Actual Power`	F	W
7	`Last Energy`	F	kWh der letzten Sitzung
8	`Last duration`	F	Dauer der letzten Sitzung

Charger.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf den Geräte-Node, wählen Sie Ihr Gerät und klicken Sie auf Deploy.

Global Lights, Global Shutters und Scenario

Node	Im Dialog	Eingang	Ausgang
Global Lights	Room oder Category (die Auswahl einer Option leert die andere)	`msg.inputTarget` = `On` oder `Off`; die Nutzlast wird ignoriert	—
Global Shutters	Room oder Category	`msg.inputTarget` = `Up` oder `Down`	—
Scenario	Scenario	Jede Nachricht führt das Szenario aus	—

Die globalen Nodes senden denselben Befehl wie die globalen Schaltflächen der App: alle Leuchten oder alle Rollläden des Raums oder der Kategorie.

Global-Commands-and-Scenario.json — importieren Sie die Datei in Node-RED, doppelklicken Sie dann auf jeden Node, um Raum oder Kategorie (globale Nodes) oder das Szenario auszuwählen, und klicken Sie auf Deploy.

ℹ️ Hinweis: Beim erneuten Öffnen eines Global Lights- oder Global Shutters-Nodes zeigen beide Listen einen Wert — die Category-Liste zeigt lediglich ihren ersten Eintrag. Der Node wirkt auf die zuletzt geänderte Liste: hier den Raum, wie sein Name angibt. Zum Wechsel auf eine Kategorie wählen Sie diese unter Category aus (der Raum wird dann geleert).