Node-RED und KNX: eigene Logik mit KNX Ultimate, am Beispiel Sommer- und Wintermodus

Manche Automatik ist für ein Logikmodul zu aufwendig und für den Alltag zu wichtig, um sie von Hand zu erledigen. Ein Beispiel ist die Umschaltung zwischen Sommer und Winter: Wann soll die Heizung in den Sommerbetrieb, wann die Beschattung in den Hitzeschutz? Mit Node-RED und dem Baustein KNX Ultimate entscheidet das Haus selbst, anhand des Mittelwerts der Außentemperatur der letzten drei Tage. Hier erfahren Sie, wie Node-RED mit KNX zusammenarbeitet, was KNX Ultimate kann und wie das Beispiel Schritt für Schritt funktioniert.

Von der KnowNX-Redaktion, aktualisiert am 17. Oktober 2026

Was ist Node-RED?

Node-RED ist ein kostenloses Open-Source-Werkzeug für Automatisierungen. Ursprünglich bei IBM entstanden, wird es heute als Projekt der OpenJS Foundation weiterentwickelt. Sie bedienen es im Browser: Bausteine, sogenannte Nodes, werden auf eine Fläche gezogen und mit Linien verbunden. Jede Linie transportiert eine Nachricht, deren Inhalt meist in msg.payload steckt, etwa eine Temperatur oder ein Ein-Aus-Befehl. So ein Ablauf heißt Flow.

Für viele Aufgaben gibt es fertige Nodes: Zeitsteuerung, Vergleiche, Verzögerungen, Diagramme, E-Mail, MQTT und Tausende Erweiterungen aus der Community. Wo kein fertiger Baustein passt, schreiben Sie in einem Function-Node ein paar Zeilen JavaScript. Genau das macht Node-RED für KNX interessant: Rechnungen, die ein Logikmodul nicht kann, etwa Mittelwerte über mehrere Tage, sind hier schnell gebaut.

Node-RED läuft auf einem kleinen Rechner im Haus: auf einem Raspberry Pi oder Mini-PC, als Docker-Container auf einem NAS oder als Erweiterung in Home Assistant. Eine Cloud ist nicht nötig, alles bleibt im eigenen Netz. Download, Installationsanleitungen und Dokumentation finden Sie auf der offiziellen Website nodered.org (öffnet in einem neuen Fenster).

So kommt Node-RED an den KNX-Bus

Node-RED ist nicht direkt an die grüne Busleitung angeschlossen. Die Brücke ist ein Systemgerät im Verteiler, das den Bus mit dem Heimnetz verbindet. Mehr dazu im Artikel über die KNX-Systemgeräte.

• KNX-IP-Schnittstelle (Tunneling): Node-RED baut eine feste Verbindung zur Schnittstelle auf und belegt dort einen Tunnel. Moderne Schnittstellen bieten mehrere Tunnel, sodass ETS, Visualisierung und Node-RED gleichzeitig verbunden sein können. Das ist der übliche Weg im Einfamilienhaus.
• KNX-IP-Router (Routing): Der Router verteilt die Telegramme per Multicast ins Netz. Mehrere Programme können mithören, ohne einen Tunnel zu belegen. Das Netzwerk muss Multicast dafür sauber weiterleiten.
• KNX Secure: Ist die Anlage verschlüsselt, braucht Node-RED die Schlüssel aus dem ETS-Projekt. Wie das zusammenhängt, erklärt der Artikel KNX Secure.

Für Node-RED brauchen Sie außerdem die Gruppenadressen und ihre Datenpunkttypen. Beides steht im Projekt der ETS, das Ihnen der Fachbetrieb übergeben sollte.

KNX Ultimate: die Brücke zwischen Node-RED und KNX

KNX Ultimate ist eine Erweiterung für Node-RED, die das Paket node-red-contrib-knx-ultimate installiert. Entwickelt wird sie von dem Italiener Massimo Saccani, in der Community als Supergiovane bekannt. Sie steht unter der freien MIT-Lizenz, wird laufend gepflegt und gehört zu den meistgenutzten KNX-Erweiterungen für Node-RED. Die Dokumentation gibt es auch auf Deutsch. Dieser Artikel beschreibt Version 8.

Installation und Grundeinstellung

1. Installieren: Im Menü von Node-RED „Palette verwalten“ öffnen, nach node-red-contrib-knx-ultimate suchen und installieren.
2. Gateway einrichten: In der gemeinsamen Konfiguration „KNX Gateway“ tragen Sie die IP-Adresse der Schnittstelle oder des Routers ein und wählen Tunneling oder Routing. Diese Verbindung nutzen alle KNX-Knoten im Flow gemeinsam; das Gateway ist selbst kein Knoten im Flow.
3. KNX Secure: Für eine verschlüsselte Anlage hinterlegen Sie die Schlüsseldatei aus der ETS und ihr Passwort. KNX Ultimate beherrscht IP Secure beim Tunneling und Routing sowie Data Secure für die Gruppenadressen, deren Schlüssel in dieser Datei stehen.
4. Gruppenadressen importieren: Die Gruppenadressen exportieren Sie in der ETS als CSV- oder ESF-Datei und übernehmen sie in die Gateway-Einstellungen. Danach kennt KNX Ultimate zu jeder Adresse den Namen und den Datenpunkttyp. In den Knoten wählen Sie Adressen einfach aus einer Liste, und die Werte werden automatisch richtig umgerechnet.

Wie ein KNX-Ultimate-Knoten arbeitet

Der wichtigste Baustein ist der Knoten KNX Device, im Flow als grüner Knoten mit KNX-Symbol zu sehen. Er gehört zu einer Gruppenadresse und arbeitet in beide Richtungen:

• Vom Bus: Kommt ein Telegramm auf seiner Gruppenadresse an, gibt der Knoten den Wert als Nachricht weiter, bei einer Temperatur zum Beispiel die Zahl 9,8.
• Auf den Bus: Erhält der Knoten eine Nachricht, sendet er deren Wert auf seine Gruppenadresse, bei einem Schaltbefehl etwa true oder false.
• Lesen und Antworten: Der Knoten kann Werte beim Start vom Bus abfragen und auf Leseanfragen antworten. Damit lassen sich auch virtuelle Geräte bauen, die für die KNX-Anlage wie echte Teilnehmer aussehen.

Unter jedem Knoten steht ein Status mit der letzten Gruppenadresse, dem Wert und der Uhrzeit. Das macht die Fehlersuche einfach.

Die Knoten von KNX Ultimate 8

Mit Version 8 hat KNX Ultimate seine Knoten neu geordnet. Zum Paket gehören sechs Knoten und die gemeinsame Gateway-Konfiguration:

Philips Hue und Matter sind seit Version 8 eigene Pakete: node-red-contrib-hue-ultimate und node-red-contrib-matter-ultimate. Sie lassen sich bei Bedarf zusätzlich installieren und nutzen dann das vorhandene KNX-Gateway.

Umstieg von Version 7: Wer KNX Ultimate schon länger nutzt, wandelt die alten Knoten zuerst um und übernimmt sie per Deploy, bevor Version 8 installiert wird. Wie das geht, beschreibt die Anleitung zum Upgrade von Version 7 (öffnet in einem neuen Fenster). Sichern Sie vorher die Flows.

Beispiel: Sommer- und Wintermodus automatisch umschalten

Viele Funktionen im Haus hängen von der Jahreszeit ab. Im Winter soll die Heizung arbeiten und die Sonne das Haus wärmen dürfen. Im Sommer soll die Heizung ruhen, die Beschattung die Hitze draußen halten und eine Wärmepumpe unter Umständen kühlen. Nach dem Kalender umzuschalten, passt selten: Ein warmer April oder ein kühler September halten sich nicht daran.

Besser ist die Außentemperatur, aber nicht die momentane. Ein warmer Nachmittag im Februar oder eine kühle Nacht im Juli dürfen nicht umschalten. Deshalb rechnet das Beispiel mit dem Mittelwert der letzten drei Tage. Er reagiert auf einen echten Wetterwechsel, aber nicht auf einzelne Ausreißer.

Heizgrenztemperatur und Hysterese

Die Heizgrenztemperatur ist die mittlere Außentemperatur, ab der ein Gebäude nicht mehr geheizt werden muss. Sonne, Bewohner und Geräte liefern dann genug Wärme. Sie hängt vor allem von der Dämmung ab. Übliche Richtwerte sind etwa 15 °C für einen unsanierten Altbau, etwa 12 °C für einen gut gedämmten Neubau und etwa 10 °C für ein Passivhaus.

Eine einzige Schaltschwelle würde im Frühjahr und Herbst ständig hin- und herschalten, sobald das Mittel um diesen Wert pendelt. Das Beispiel arbeitet deshalb mit zwei Grenzen, einer sogenannten Hysterese:

• Winter, sobald das 3-Tage-Mittel unter 12 °C fällt,
• Sommer, sobald es über 15 °C steigt,
• dazwischen bleibt der bisherige Modus.

Als Faustregel legen Sie die Wintergrenze auf die Heizgrenztemperatur Ihres Hauses und die Sommergrenze etwa 3 Grad darüber.

Der Flow

Der Flow kommt mit vier Knoten aus:

1. Wetterstation – absolute Temperatur: ein KNX-Ultimate-Knoten auf der Gruppenadresse der Außentemperatur (im Beispiel 5/3/50, Datenpunkttyp 9.001). Er gibt jeden Messwert als Zahl weiter.
2. Sommer-Winter-Umschaltung v4: ein Function-Node mit zwei Ausgängen. Er speichert die Messwerte, bildet das 3-Tage-Mittel und entscheidet über den Modus.
3. Wintermodus: ein KNX-Ultimate-Knoten auf einer eigenen Gruppenadresse mit Datenpunkttyp 1.001. Er sendet 1 für Winter und 0 für Sommer auf den Bus.
4. Debug: zeigt im Editor die Messwerte des Function-Nodes, zur Kontrolle.

Was der Function-Node rechnet

• Zeitgewichtet: Jeder Messwert gilt bis zum nächsten. Der Node rechnet also mit der Zeit, die ein Wert anlag, und nicht mit der Zahl der Telegramme. Sendet die Wetterstation bei schnell wechselnden Temperaturen öfter, verzerrt das den Mittelwert nicht.
• Stundenweise gespeichert: Die Werte landen in Stundenfächern. Für 72 Stunden sind das nur 73 kleine Einträge, ältere werden gelöscht.
• Lücken zählen nicht: Kommt länger als 60 Minuten kein Telegramm, etwa weil Node-RED neu gestartet wurde, zählt die Zeit danach nicht als Messzeit.
• Erst entscheiden, wenn genug Daten da sind: Umgeschaltet wird nur, wenn mindestens 80 Prozent der letzten 72 Stunden erfasst sind. Nach der ersten Inbetriebnahme dauert das knapp zweieinhalb Tage. Bis dahin steht der Modus auf „unbekannt“, und der Node sendet nichts.
• Nur bei einem Wechsel senden: Auf den Bus geht nur ein Telegramm, wenn sich der Modus ändert. Nach einem Neustart von Node-RED sendet der Node den aktuellen Modus einmal, damit KNX sicher auf dem richtigen Stand ist.
• Unplausible Werte verwerfen: Alles, was keine Zahl zwischen −40 und +60 °C ist, wird mit einer Warnung im Protokoll ignoriert.
• Neustartfest: Messwerte und Modus liegen im dateibasierten Kontextspeicher von Node-RED und überstehen so einen Neustart.

Der Status unter dem Node zeigt alles auf einen Blick, zum Beispiel Winter | Mittel 9.6 °C | aktuell 7.2 °C | heute 54 %. „Heute“ ist der Anteil des laufenden Tages, für den schon Messwerte vorliegen. Bei lückenlosem Empfang entspricht er der Uhrzeit, um 9 Uhr also gut 38 Prozent.

Der Code

Kopieren Sie den folgenden Code in den Function-Node, oder laden Sie ihn als Datei herunter. Die Grenzwerte und Einstellungen stehen ganz oben (102 Zeilen, keine Zusatzmodule nötig).

// Sommer-Winter-Umschaltung v4 (Beispiel aus dem KNX-Kompendium von KnowNX)
// Eingang:   Außentemperatur in °C (DPT 9.001) aus einem KNX-Ultimate-Knoten
// Ausgang 1: Wintermodus an KNX Ultimate (DPT 1.001): true = Winter, false = Sommer
// Ausgang 2: Messwerte zur Kontrolle, z. B. für einen Debug-Knoten

const GRENZE_WINTER = 12;   // °C: Mittel darunter -> Winter
const GRENZE_SOMMER = 15;   // °C: Mittel darüber -> Sommer
const FENSTER_STD = 72;     // Stunden für den gleitenden Mittelwert (3 Tage)
const MIN_ABDECKUNG = 0.8;  // mindestens 80 % des Zeitfensters mit Messwerten
const MAX_LUECKE_MIN = 60;  // längere Lücken zählen nicht als Messzeit
const SPEICHER = "file";    // Kontextspeicher aus settings.js, überlebt Neustarts

const STUNDE = 3600000;
const jetzt = Date.now();
const wert = msg.payload;

// 1. Nur plausible Zahlen annehmen
if (typeof wert !== "number" || !Number.isFinite(wert) || wert < -40 || wert > 60) {
    node.warn("Unplausibler Messwert verworfen: " + String(wert).slice(0, 40));
    return null;
}

// 2. Gespeicherten Zustand laden und prüfen
let d = context.get("sommerWinter", SPEICHER);
if (!d || typeof d !== "object" || !d.stunden || typeof d.stunden !== "object") {
    d = { stunden: {}, letzter: null, modus: "unbekannt" };
}
if (!["Winter", "Sommer", "unbekannt"].includes(d.modus)) d.modus = "unbekannt";

// 3. Den vorigen Messwert für die Zeit bis jetzt verbuchen, aufgeteilt auf Stunden
function buchen(von, bis, temperatur) {
    let t = von;
    while (t < bis) {
        const beginn = Math.floor(t / STUNDE) * STUNDE;
        const ende = Math.min(bis, beginn + STUNDE);
        const s = d.stunden[beginn] || { summe: 0, dauer: 0 };
        s.summe += temperatur * (ende - t);
        s.dauer += ende - t;
        d.stunden[beginn] = s;
        t = ende;
    }
}
const l = d.letzter;
if (l && Number.isFinite(l.t) && Number.isFinite(l.wert) && l.t < jetzt) {
    buchen(l.t, Math.min(jetzt, l.t + MAX_LUECKE_MIN * 60000), l.wert);
}
d.letzter = { t: jetzt, wert: wert };

// 4. Zeitgewichteten Mittelwert der letzten 72 Stunden berechnen, alte Stunden löschen
const aktuelleStunde = Math.floor(jetzt / STUNDE) * STUNDE;
const fensterBeginn = aktuelleStunde - FENSTER_STD * STUNDE;
const mitternacht = new Date(jetzt);
mitternacht.setHours(0, 0, 0, 0);
let summe = 0, dauer = 0, heute = 0;
for (const k of Object.keys(d.stunden)) {
    const beginn = Number(k);
    const s = d.stunden[k];
    if (!Number.isFinite(beginn) || beginn < fensterBeginn || beginn > aktuelleStunde ||
        !s || !Number.isFinite(s.summe) || !Number.isFinite(s.dauer) || s.dauer <= 0) {
        delete d.stunden[k];
        continue;
    }
    summe += s.summe;
    dauer += s.dauer;
    if (beginn >= mitternacht.getTime()) heute += s.dauer;
}
const mittel = dauer > 0 ? summe / dauer : null;
const abdeckung = dauer / (jetzt - fensterBeginn);
const heuteProzent = Math.round(heute / (24 * STUNDE) * 100);

// 5. Entscheiden, mit Hysterese: zwischen den Grenzen bleibt der bisherige Modus
let modus = d.modus;
if (mittel !== null && abdeckung >= MIN_ABDECKUNG) {
    if (mittel < GRENZE_WINTER) modus = "Winter";
    else if (mittel > GRENZE_SOMMER) modus = "Sommer";
}
d.modus = modus;
context.set("sommerWinter", d, SPEICHER);

// 6. Nur bei einem Wechsel senden, nach einem Neustart einmal den aktuellen Modus
let knx = null;
if (modus !== "unbekannt" && context.get("gesendet") !== modus) {
    knx = { payload: modus === "Winter" };
    context.set("gesendet", modus); // flüchtig: nach einem Neustart wird erneut gesendet
}

const zahl = (x) => (x === null ? "–" : x.toFixed(1));
node.status({
    fill: modus === "Winter" ? "blue" : modus === "Sommer" ? "yellow" : "grey",
    shape: "dot",
    text: `${modus} | Mittel ${zahl(mittel)} °C | aktuell ${zahl(wert)} °C | heute ${heuteProzent} %`
});

return [knx, {
    payload: {
        modus: modus,
        mittel: mittel === null ? null : Math.round(mittel * 10) / 10,
        aktuell: wert,
        abdeckung: Math.round(abdeckung * 100),
        heute: heuteProzent
    }
}];

Einrichtung Schritt für Schritt

1. Gruppenadresse anlegen: In der ETS eine Gruppenadresse „Wintermodus“ mit Datenpunkttyp 1.001 anlegen, etwa in der Hauptgruppe für zentrale Funktionen. Mit ihr verbinden Sie die Objekte der Geräte, die auf die Jahreszeit reagieren sollen.
2. Wetterstation zyklisch senden lassen: Die Außentemperatur sollte nicht nur bei Änderung, sondern auch regelmäßig gesendet werden, etwa alle 10 bis 15 Minuten. Das stellen Sie in den Parametern der Wetterstation in der ETS ein.
3. Kontextspeicher einrichten: Damit die Messwerte einen Neustart überstehen, bekommt die Datei settings.js von Node-RED einen Speicher mit dem Namen file:

   contextStorage: {
       default: { module: "memory" },
       file: { module: "localfilesystem" }
   },

   Danach Node-RED neu starten. Fehlt dieser Eintrag, schreibt Node-RED eine Warnung ins Protokoll und hält die Werte nur im Arbeitsspeicher. Nach jedem Neustart beginnt die Messung dann von vorn.
4. Flow bauen: Zwei KNX-Ultimate-Knoten für Außentemperatur und Wintermodus, dazwischen einen Function-Node. Im Function-Node auf der Registerkarte „Setup“ zwei Ausgänge einstellen und den Code auf der Registerkarte „On Message“ einfügen. Den ersten Ausgang mit dem Knoten „Wintermodus“ verbinden, den zweiten mit einem Debug-Knoten.
5. Grenzen anpassen: GRENZE_WINTER und GRENZE_SOMMER auf Ihr Haus abstimmen, siehe Heizgrenztemperatur oben.
6. Startphase überbrücken: Bis genug Messwerte vorliegen, bleibt der Modus „unbekannt“. Das gilt auch, solange das Mittel zwischen den Grenzen liegt. Stellen Sie den Wintermodus bis dahin einmal von Hand, etwa über die Visualisierung. Danach übernimmt Node-RED.

Was der Wintermodus im Haus schaltet

Viele Heizungsaktoren und Raumtemperaturregler haben dafür ein eigenes Kommunikationsobjekt, etwa für den Sommerbetrieb oder die Umschaltung zwischen Heizen und Kühlen. Ob 1 dort Winter oder Sommer bedeutet, steht in der Produktdokumentation. Bei Bedarf lässt sich der Wert im Parameter des Geräts umkehren. Die Wärmeerzeuger erreichen Sie über das KNX-Gateway des Herstellers, siehe Heizungssteuerung.

Weitere Ideen: Ein Taster für den Handbetrieb, der die Automatik für einige Tage übersteuert, eine Benachrichtigung bei jedem Wechsel oder ein zweiter Ausgang für eine eigene Übergangszeit.

Was gehört in Node-RED, was in KNX?

Node-RED ergänzt die KNX-Anlage, es ersetzt sie nicht. Bewährt hat sich diese Aufteilung:

Im Beispiel trifft Node-RED nur die Entscheidung Sommer oder Winter. Geregelt wird weiter in KNX. Fällt Node-RED aus, behalten die Geräte den zuletzt gesendeten Modus, und das Haus funktioniert normal weiter.

Node-RED, Logikmodul oder Home Assistant?

Die Lösungen schließen sich nicht aus. Viele Häuser nutzen Node-RED zusammen mit Home Assistant, in dem es sich als Erweiterung installieren lässt. Einfache Zeitpläne und Verknüpfungen bleiben im Logikmodul oder Server, siehe Zeitschaltuhr und Logik.

Betrieb und Sicherheit

• Editor schützen: Der Editor von Node-RED darf nicht ohne Anmeldung erreichbar sein. Richten Sie in settings.js einen Zugang mit Passwort ein (adminAuth) und machen Sie den Editor nie per Portfreigabe aus dem Internet erreichbar. Für den Zugriff von unterwegs gehört ein VPN dazu.
• KNX Secure nutzen: Die Schlüsseldatei aus der ETS ist so schutzwürdig wie ein Passwort. Sie gehört nur auf den Rechner mit Node-RED und in eine verschlüsselte Sicherung.
• Eigener Tunnel: Node-RED belegt einen Tunnel der IP-Schnittstelle. Nutzen Home Assistant und Node-RED beide KNX, belegen sie je einen eigenen Tunnel, auch wenn sie auf demselben Rechner laufen. Planen Sie eine Schnittstelle mit genug Tunneln für ETS, Visualisierung, Home Assistant und Node-RED ein.
• Sichern: Flows, settings.js und der Ordner mit dem Kontextspeicher gehören regelmäßig in die Datensicherung. Nach einem Hardwaretausch läuft dann alles weiter.
• Aktuell halten: Node-RED und die installierten Erweiterungen regelmäßig aktualisieren und vorher die Flows sichern. Läuft Node-RED in Home Assistant, übernimmt Home Assistant die Updates von Node-RED selbst; die Erweiterungen in der Palette aktualisieren Sie weiter in Node-RED.
• Nur nötige Rechte: Der Function-Node im Beispiel braucht keine Zusatzmodule und keinen Zugriff auf Dateien oder das Netz. Je weniger ein Flow darf, desto weniger kann schiefgehen.