MESHLE Geräte über lokales MQTT an Node-RED anbinden

MESHLE Geräte sind drahtlos über MESHLE Bluetooth Mesh verbunden — ein proprietäres, offline-fähiges Mesh, das Beleuchtung, Sensoren und Aktoren ohne Cloud betreibt. Das MESHLE Gateway öffnet dieses Mesh über eine lokale MQTT-Schnittstelle für Ihr eigenes Netzwerk: Sobald ein Gerät seinen Zustand meldet — eine Leuchte wechselt die Farbe, ein Sensor erkennt Anwesenheit, eine Jalousie fährt — veröffentlicht das Gateway eine JSON-Nachricht auf Ihrem lokalen Broker.

Die Schnittstelle funktioniert in beide Richtungen. Um ein Gerät zu steuern, senden Sie ein JSON-Payload an ein einziges Befehls-Topic, und das Gateway übersetzt es in den passenden Mesh-Frame. Kein Umweg über die Cloud, kein Polling — nur ereignisgesteuerte Telemetrie und Befehle auf einem Broker, den Sie selbst betreiben.

Diese Anleitung führt das komplette Setup von Anfang bis Ende durch: das Gateway in der MESHLE App auf lokales MQTT umstellen, einen Mosquitto-Broker betreiben, Node-RED anbinden, Live-Telemetrie empfangen und Steuerbefehle senden. Sie richtet sich an Entwickler, Gebäudeautomations- und GLT-Integratoren sowie OEM-Ingenieure, die MESHLE Beleuchtung in einen lokalen Automatisierungs-Flow einbinden möchten.

Was Sie brauchen

Stellen Sie Folgendes bereit, bevor Sie beginnen.

• MESHLE Gateway eingeschaltet und im selben Netzwerk wie Ihr Broker
• Ein Rechner für Mosquitto und Node-RED (Mac, Linux oder Windows mit Docker)
• Die MESHLE App (iOS, Android oder Desktop) zum Einrichten des Gateways

Unterstützte Gerätetypen

Jede Telemetrie-Nachricht enthält eine Ganzzahl device_type, die angibt, welche Felder zu erwarten sind. Sensoren sind reine Lesegeräte; alle übrigen Typen nehmen zusätzlich Befehle entgegen.

Teil 1: Gateway in der MESHLE App einrichten (einmalig)

Dieser Schritt ist nur einmal nötig. Sie richten das Gateway in der MESHLE App ein und verweisen es auf Ihren lokalen Broker statt auf den MESHLE Cloud-Broker.

1. Tippen Sie auf dem Startbildschirm unten rechts auf die Schaltfläche +.
2. Tippen Sie im Add-Menü (Timer, Group, Device, Peripheral) auf Device.
3. Warten Sie den BLE-Scan ab. Sobald MESHLE Matter Gateway erscheint, tippen Sie darauf.
4. Tippen Sie auf dem Setup-Bildschirm ("Gateway Setup in MESHLE Cloud") oben rechts auf das Drei-Punkte-Menü, bevor Sie Next antippen.
5. Tippen Sie im Bereich Select MQTT Broker auf Setup Locally und anschließend auf Next.
6. Geben Sie die IP-Adresse des Rechners ein, auf dem Ihr Mosquitto-Broker läuft — derselbe Rechner, auf dem auch Node-RED läuft.
7. Wählen Sie den Netzwerktyp — LAN (Ethernet) oder Wi-Fi. Bei Wi-Fi geben Sie SSID und Passwort ein; bei LAN sind keine Zugangsdaten nötig.
8. Warten Sie, bis die Provisionierung abgeschlossen ist, und tippen Sie dann auf Finish.

Schritt 1 von 8

Das Hinzufügen-Menü öffnen

Tippen Sie auf dem Startbildschirm unten rechts auf die Schaltfläche +.

Zurück

Weiter

Prüfen: Führen Sie diesen Befehl aus. Sobald sich ein Gerät ändert, sollten innerhalb weniger Sekunden JSON-Nachrichten erscheinen.

mosquitto_sub -h 127.0.0.1 -p 1883 -t 'v1/gateway/telemetry/json' -v

Teil 2: MQTT-Broker einrichten (Mosquitto)

Installieren Sie Mosquitto unter macOS mit Homebrew, unter Debian/Ubuntu mit apt oder über Docker.

macOS:

brew install mosquitto

Linux (Debian/Ubuntu):

sudo apt-get install mosquitto

Docker:

docker run -d --name mosquitto \
  -p 1883:1883 \
  eclipse-mosquitto:latest \
  mosquitto -c /mosquitto/config/mosquitto.conf

Standardmäßig lauscht Mosquitto nur auf 127.0.0.1, sodass weder das Gateway noch Node-RED im Docker-Container darauf zugreifen können. Lassen Sie es auf allen Schnittstellen lauschen:

# mosquitto-local.conf
listener 1883 0.0.0.0
allow_anonymous true

Starten Sie Mosquitto mit dieser Konfiguration:

mosquitto -c /path/to/mosquitto-local.conf -v

Hinweis: allow_anonymous true ist in einem geschlossenen lokalen Netzwerk unproblematisch. Für nicht vertrauenswürdige Clients verwenden Sie stattdessen ein password_file.

Prüfen Sie den Broker mit zwei Terminals — hello sollte im ersten Terminal erscheinen:

# Terminal 1 -- subscribe
mosquitto_sub -h 127.0.0.1 -p 1883 -t 'test' -v

# Terminal 2 -- publish
mosquitto_pub -h 127.0.0.1 -p 1883 -t 'test' -m 'hello'

Teil 3: Node-RED einrichten

Betreiben Sie Node-RED in Docker auf Port 1880 und öffnen Sie http://127.0.0.1:1880.

docker run -it --name nodered \
  -p 1880:1880 \
  -v node_red_data:/data \
  --restart unless-stopped \
  nodered/node-red:latest

Tragen Sie im Konfigurationsknoten für den MQTT-Broker als Hostnamen host.docker.internal ein — Docker löst diesen Namen zum Host-Rechner auf, während 127.0.0.1 wieder in den Container zurückzeigen würde. Läuft Node-RED nativ (nicht in Docker), verwenden Sie 127.0.0.1. Installieren Sie anschließend über Manage palette die Palette @flowfuse/node-red-dashboard.

Hinweis: Rufen Sie das Dashboard unter http://127.0.0.1:1880/dashboard auf. Schalten Sie ein Gerät in der MESHLE App um, aktualisieren sich die Anzeigen innerhalb einer Sekunde.

Teil 4: Telemetrie empfangen

Abonnieren Sie v1/gateway/telemetry/json. Die Nachrichten sind ereignisgesteuert — es gibt kein Polling. Fügen Sie einen mqtt in Node hinzu und stellen Sie dessen Ausgabe auf ein geparstes JSON-Objekt.

Jedes Payload ist ein flaches JSON-Objekt: device_type und device_id sind immer vorhanden, die übrigen Felder hängen vom Typ ab.

{
  "device_type": 1,
  "device_id": 1,
  "power_on": true,
  "error_flag": false,
  "hue_deg": 180,
  "saturation_pct": 100,
  "brightness_pct": 55
}

Payload-Beispiele nach Gerätetyp

HSV-Farbleuchte (device_type: 1):

{
  "device_type": 1, "device_id": 1,
  "power_on": true, "error_flag": false,
  "hue_deg": 180, "saturation_pct": 100, "brightness_pct": 55
}

HCL-Leuchte (Tunable White) (device_type: 3):

{
  "device_type": 3, "device_id": 2,
  "power_on": true, "error_flag": false,
  "kelvin": 3500, "brightness_pct": 70
}

Dimmbare Leuchte (device_type: 4):

{
  "device_type": 4, "device_id": 3,
  "power_on": true, "error_flag": false,
  "brightness_pct": 40
}

Behang (device_type: 6): state 0 = gestoppt, 1 = fährt herunter/schließt, 2 = fährt hoch/öffnet.

{
  "device_type": 6, "device_id": 5,
  "power_on": false, "error_flag": false,
  "position_pct": 60, "tilt_deg": 30, "state": 0
}

OUT32 Mehrkanal-Dimmer (device_type: 32): channel_mask ist eine Bitmaske — Wert 3 (binär 0011) bedeutet, dass die Kanäle 0 und 1 aktiv sind.

{
  "device_type": 32, "device_id": 4,
  "power_on": true, "error_flag": false,
  "channel_mask": 3, "ch0_pct": 80, "ch1_pct": 60, "ch2_pct": 0, "ch3_pct": 0
}

Präsenz- und Helligkeitssensor (device_type: 69):

{
  "device_type": 69, "device_id": 6,
  "power_on": false, "error_flag": false,
  "occupancy": true, "illuminance_lux": 340
}

Kontakt- und Feuchtesensor (device_type: 83):

{
  "device_type": 83, "device_id": 7,
  "power_on": false, "error_flag": false,
  "contact_closed": true, "temperature_c": 22.5, "humidity_pct": 48.5
}

Payload in einem function Node auswerten

Fügen Sie nach dem mqtt in Node einen function Node hinzu. Dieses Muster behandelt alle Gerätetypen sicher: eine Hilfsfunktion für Zahlen, ein Filter nach Gerät, Booleans als ON/OFF-Strings und die Verteilung der Werte auf getrennte Ausgänge.

var p = msg.payload || {};

// Safe number helper -- returns fallback when field is absent or null
function num(v, fallback) {
    return (v == null || isNaN(v)) ? fallback : Number(v);
}

// Filter to a specific device if needed
if (p.device_type !== 1 || p.device_id !== 1) return null;

// Power -- convert boolean to string for dashboard display
var powerOn = p.power_on === true ? 'ON' : (p.power_on === false ? 'OFF' : '-');

// HSV fields
var hue        = num(p.hue_deg,        0);   // 0-360 degrees
var saturation = num(p.saturation_pct, 0);   // 0-100 percent
var brightness = num(p.brightness_pct, 0);   // 0-100 percent

// Route each value to its own output
return [
    { payload: powerOn },
    { payload: hue },
    { payload: saturation },
    { payload: brightness }
];

Stellen Sie den function Node auf 4 Ausgänge und verdrahten Sie jeden Ausgang mit seinem Dashboard-Widget. Anzeigeinstrumente eignen sich für hue_deg, saturation_pct, brightness_pct, kelvin, position_pct, die Kanäle, temperature_c und humidity_pct; Textanzeigen für power_on (ON/OFF) und occupancy (PRESENT/CLEAR).

Hinweis zu FlowFuse Dashboard 2.0: Das Feld format wertet keine JavaScript-Ausdrücke aus. Wandeln Sie Booleans und Zahlen zuerst im function Node in Anzeige-Strings um und verweisen Sie dann auf {{msg.payload}}.

Teil 5: Geräte steuern

Senden Sie an v1/gateway/command/json. Das Gateway übersetzt jedes JSON-Payload in den passenden BLE-Mesh-Frame. Verwenden Sie QoS 0 und kein Retain.

Befehl: power

Wird von allen steuerbaren Gerätetypen unterstützt (value: true = an, false = aus).

{
  "device_type": 1,
  "device_id": 1,
  "command": "power",
  "value": true
}

Befehl: color

Nur HSV-Leuchten (device_type: 1). Setzt Farbton, Sättigung und Helligkeit in einem Befehl.

{
  "device_type": 1,
  "device_id": 1,
  "command": "color",
  "hue": 180,
  "saturation": 100,
  "brightness": 55
}

Befehl: brightness

Passt die Helligkeit an, ohne die Farbe zu ändern. Unterstützt für HSV (1), HCL (3) und Dimmer (4) — Farbton und Sättigung bleiben unverändert.

{
  "device_type": 1,
  "device_id": 1,
  "command": "brightness",
  "value": 75
}

Befehle aus Node-RED senden

Ein function Node setzt msg.topic = 'v1/gateway/command/json' und baut das Objekt msg.payload; verdrahtet wird er mit einem mqtt out Node (das Topic am out Node leer lassen).

msg.topic   = 'v1/gateway/command/json';
msg.payload = {
    device_type: 1,
    device_id:   1,
    command: 'power',
    value:   msg.payload   // boolean from switch widget
};
return msg;

Bei drei HSV-Reglern führen Sie deren Werte vor dem Senden über den Flow-Kontext zusammen — jeder Regler löst eigenständig aus und würde sonst die anderen überschreiben.

// Wire all three sliders to this single function node
// Set each slider's msg.topic to: 'hue' | 'saturation' | 'brightness'

var ctrl = flow.get('hsvCtrl') || { hue: 0, sat: 100, bri: 55 };

if      (msg.topic === 'hue')        ctrl.hue = Number(msg.payload);
else if (msg.topic === 'saturation') ctrl.sat = Number(msg.payload);
else if (msg.topic === 'brightness') ctrl.bri = Number(msg.payload);

flow.set('hsvCtrl', ctrl);

msg.topic   = 'v1/gateway/command/json';
msg.payload = {
    device_type: 1,
    device_id:   1,
    command:     'color',
    hue:         ctrl.hue,
    saturation:  ctrl.sat,
    brightness:  ctrl.bri
};
return msg;

Hinweis: Stellen Sie den Auslöser jedes Reglers auf "on release", um den Broker nicht zu überfluten, während gezogen wird.

Häufig gestellte Fragen

Nach dem Einrichten des Gateways kommt keine Telemetrie an. Woran liegt das?

Prüfen Sie zuerst, ob Mosquitto läuft und auf 0.0.0.0 lauscht, nicht nur auf 127.0.0.1. Abonnieren Sie dann #, um den gesamten Broker-Verkehr zu sehen, und stellen Sie sicher, dass das Gateway die Provisionierung in der MESHLE App wirklich abgeschlossen hat.

Der MQTT-Node in Node-RED zeigt "disconnected".

Tragen Sie in Docker als Hostnamen host.docker.internal ein, nicht 127.0.0.1; nativ verwenden Sie 127.0.0.1. Achten Sie darauf, dass Port 1883 im Broker-Konfigurationsknoten und in Ihrer Mosquitto-Konfiguration übereinstimmt.

Power wird als true/false statt als ON/OFF angezeigt.

FlowFuse Dashboard 2.0 wertet im Widget-Feld format kein JavaScript aus. Wandeln Sie den Boolean zuerst im function Node in einen String um und zeigen Sie dann {{msg.payload}} an.

Meine Befehle werden gesendet, aber das Gerät reagiert nicht.

Stellen Sie sicher, dass device_type und device_id exakt mit der Telemetrie übereinstimmen. Der Befehl color gilt nur für device_type 1 — für HCL (3) und Dimmer (4) verwenden Sie brightness — und prüfen Sie, ob das Gerät im Mesh aktiv ist.

HSV- oder Sensorfelder fehlen oder zeigen 0.

Diese Felder erscheinen nur beim passenden device_type. Prüfen Sie den device_type im Debug-Panel und lesen Sie nur die für diesen Typ dokumentierten Felder.

Sie planen eine lokale MQTT- oder GLT-Integration rund um MESHLE Beleuchtung? Sprechen Sie mit uns über Ihr Projekt — wir begleiten Entwickler, Integratoren und OEMs durch die Anbindung.

MESHLE Gateway M602

M602

Weiterlesen

• MESHLE Gateway: ein Mesh, offene APIs (REST, MQTT, Modbus, BACnet™)
• MESHLE Geräte über BACnet™ von einer WAGO SPS steuern (CODESYS-Anleitung)
• Warum MESHLE Smart Lighting offline-first funktioniert
• Was ist Bluetooth Mesh? Eine verständliche Einführung
• MESHLE für eine lokale MQTT- oder GLT-Integration kontaktieren

BACnet™ ist eine Marke der ASHRAE.