Nachdem ich mir eine hübsche RGB-LED Leiste mit einem ESP32 zusammengebaut habe und diverse Arduino-Sketche mit allen möglichen Lichteffekten zusammen kopiert habe, entstand nach einiger Zeit doch der Wunsch, die LED-Leiste als Hue-Lampe ansprechen zu können.Der Vorteil ist eine einheitliche Bedienung über die Hue-App, sowie die Möglichkeit alle Lichter auf einen Schlag auszuschalten.

Wie funktioniert das?

Um eine LED-Leiste als Hue-Lampe ansprechen zu können, muss zunächst eine virtuelle Hue-bridge auf einem Host (z.B. als Docker Container) installiert werden. Diese emulierte Hue-bridge gibt sich gegenüber dem LAN und somit auch gegenüber der Hue-App als originale Bridge aus. Auf der anderen Seite ist sie aber in der Lage auch andere (nicht-Hue-)Lampen einzubinden. Ich habe ein paar verschiedener solcher Hue-Emulationen gefunden, aber am besten und flexibelsten ist meiner Meinung nach „diyHue“, zu finden auf GitHub (https://github.com/diyhue/diyHue). Man muss aber sagen, dass die Dokumentation ziemlich schlecht ist. Ich habe die Schritte zur Installation und Konfiguration deshalb hier zusammen gestellt: diyHue bridge emulation installieren

Das schöne ist aber, dass man die LED-Leiste in beliebig viele „virtuelle“ Hue-Lampen aufteilen kann, die alle einzeln über die Hue-App wie klassische Hue-Lampen steuerbar sind. Dabei kann man angeben, wie viele „Pixel“ (=Leds) jede Lampe „breit“ sein soll und wie viele Pixel zwischen den Lampen „frei“ bleiben sollen.

LED-Leiste vorbereiten

Hier gehe ich jetzt nicht auf die Hardwareseite ein, das würde zu weit führen. Es gibt viele Tutorials im Netz, wie man eine RGB-Led-Leiste an einen Arduino-kompatiblen Microcontroller anschließt und verkabelt. Ich habe mich für SK9822-Leds entschieden, das sind billige Clone der APA102, die aus einzeln steuerbaren RGB-Leds bestehen. Als Controller verwende ich ein ESP32-Dev-Board von Espressif, weil es leistungsfähig ist (240 MHz, 4 MB Flash) und mit Bluetooth und Wifi alles mitbringen, was man braucht.

Zum Programmieren habe ich die Arduino-IDE verwendet. Ein Beispiel-Sketch ist unter https://github.com/linuzer/Arduino-HueAPI zu finden.

Natürlich müssen ein paar Dinge an die entsprechenden Gegebenheiten angepasst werden:

NUM_LEDS	Gesamtzahl der physikalischen LEDs in der Leiste
DATA_PIN CLOCK_PIN	Arduino-Pins, an denen die LEDs angeschlossen sind
COLOR_ORDER LED_TYPE	Reihenfolder der Farben. In der Doku der LEDs nachsehen
HUE_(…)	Der interessanteste Teil, konfiguriert die Anzahl und Größe der einzelnen virtuellen Hue-Lampen.
useDhcp	selbstredend. Wenn True, dann muss keine IP-Adresse konfiguriert werden.
ConnectMQTT()	Hier müssen IP, Port und Topic, sowie Client-Name angepasst werden.
class HueApi	Hier wird die Kommunikation mit der diyHue gekapselt, sowie Hue-spezifische Routinen abgelegt.
StateGet() StatePut()	Hier passiert die eigentliche Kommunikation mit der diyHue.
Detect()	Diese Methode produziert die richtige Antwort auf die Suchanfrage der diyHue, sodass die LED-Leiste als Hup-Lampe gefunden werden kann.

Am Ende den Sketch einfach per USB-Kabel auf den ESP flashen. Ist das erfolgreich geschehen, sucht man mit dem Handy nach dem unverschlüsseltem WLAN des ESP und verbindet sich. Die SSID sollte die sein, die man mit HUE_Name festgelegt hat.

Sodann kann man unter http://192.168.4.1 auf die Lampe zugreifen und das eigentliche WLAN konfigurieren. Nach einem Neustart, sollte die Lampe im WLAN auftauchen.

Am besten testet man jetzt auch gleich das Arduino OTA-Update (Over-the-air Flashing). Wenn das auch funktioniert, kann man den ESP an seinem endgültigen Bestimmungsort verbauen.

LED-Leiste als Hue-Lampe ansprechen

Wenn bis hierhin alles geklappt hat, öffnet man die Hue-App auf dem Handy und sucht nach einer neuen Bridge. Eventuell muss man die IP-Adresse der diyHue bridge manuell eingeben. Ist die App mit der diyHue verbunden, sucht man nach neuen Lampen. Es kann einen Moment dauern (der sogar länger als der Timeout der App-Suche sein kann) und dann sollte die App eine (oder mehrere) neue Hue-Lampen vermelden. Diese kann man jetzt in gewohnter Art und Weise konfigurieren, sie Räumen, Szenen und Gruppen zuordnen, umbenennen, etc. … und natürlich steuern.

An dieser Stelle ist man dann am Ziel. Jetzt kann man die selbstgebaute LED-Leiste als Hue-Lampe ansprechen. Jede virtuelle Hue-Lampe ist einzeln in der App zu sehen und kann entsprechend gesteuert werden.

Troubleshooting / Debugging

Bei Arduino Compiler-Fehlern genau lesen und alle Fehler beheben. Dabei immer mit dem obersten (!) Fehlern beginnen, der Rest können (verwirrende) Folgefehler sein. Am Anfang ist es wahrscheinlich, dass noch benötigte Bibliotheken nicht installiert sind (z.B. die ArduinoJson v6).

Die Funktionen zum Laden und Wiederherstellen der gespeicherten Settings sind bewußt auskommentiert (in Setup() ), weil sie am Anfang Probleme machen können, wenn es noch keine gespeicherte Konfiguration auf dem ESP gibt.

Wenn das Flashen geklappt hat, die Lampe aber nicht gefunden wird, dann mit dem Arduino Serial-Monitor (nur per USB-Kabel möglich) prüfen, ob es Fehlermeldungen gibt. Allerdings muss man echt Geduld haben, die Lampen tauchen häufig erste nach (viel-)maligem suchen in der App auf. Hintergrund ist, die diyHue sucht alle IP-Adressen im Netz ab und schaut, ob eine Lampe antwortet. Dabei ist das Zeitfenster pro IP-Adresse sehr klein… für einen ESP, der im WLAN hängt u.U. zu klein, sodass er nicht beim ersten Ping gefunden wird.

Sobald das Wifi konfiguriert ist, am Router prüfen, welche IP-Adresse vergeben wurde.

Per Serial-Monitor prüfen, ob die Lampe sich am MQTT-Broker anmelden konnte. Falls ja, ist man einen großen Schritt weiter: Ab jetzt kann man sich die wichtigsten Log-Meldungen auch per MQTT-Client auf dem Topic „iot/ledcontroller/log“ abholen. Damit ist auch ein remote Debugging per WLAN möglich.

Jetzt kann man auch zu Debug-Zwecken weitere Log()-Kommandos in den Arduino-Code einbauen, um sich per MQTT über den Status informieren zu lassen.

Zur weiteren Fehleranalyse empfiehlt es sich den Debug-Modus auf der diyHue einzuschalten und mit tail -f ...log | grep "z.b. IP-Adresse" nach relevanten messages filtern zu lassen. Details hierzu siehe meinen Artikel, oder die offizielle Doku. Mit den MQTT-Messages (was die Led-Leiste abschickt) und mit dem diyHue-Log (was dort ankommt und die Bridge damit macht) sollte es dann möglich sein allen Problemen auf die Schliche zu kommen.

diyHue (GitHub) ist eine virtuelle Hue-bridge, die nicht nur eine originale Philips Hue-bridge mit ihren verbundenen Hue-Lampen ansprechen kann, sondern über eigene APIs eine breite Palette von anderen Lampen einbinden kann. Da sie aber netzwerkseitig das originale Hue-API spricht, kann sich die originale Hue-App (und alle Alternativen) an diyHue anmelden, und alle eingebundenen Lampen genau so steuern, wie die original Hue-Lampen. Wie man diyHue installieren kann, zeige ich in dieser Anleitung.

Das Schaubild auf GitHub gibt einen guten Überblick, was alles eingebunden werden kann.

diyHue installieren

Leider ist die Dokumentation des Projekts ziemlich schlecht, sodass es nicht besonders leicht ist, alles richtig hinzukriegen. Deshalb dokumentiere ich hier die Schritte, mit denen ich Erfolg hatte. Natürlich kann man die virtuell Hue-Bridge diyHue auch anders installieren, meine Lösung erhebt weder den Anspruch, die einzig Richtige, noch die Beste zu sein.

Ich habe mich für eine Installation in Docker entschlossen, da somit alles recht sauber gekapselt ist. Wer Docker noch nicht installiert hat, sollte sich erstmal ein bisschen einlesen, das führt jetzt hier zu weit, aber die Installation ist denkbar einfach.

Netzwerk

Dann muss man sich über das Netzwerk kurz Gedanken machen. Der diyHue container muss ja direkt aus dem Netz erreichbar sein. Ich habe mich entschlossen, meine Docker-container über eine macvlan-bridge direkt ins LAN zu hängen, ohne das sonst bei Docker übliche NAT Subnetz.

Mein LAN hat die Adresse 192.168.3.x mit Subnet 255.255.255.0. Die oberen 32 Adressen, von 192.168.3.224 – 192.168.3.255 möchte ich für meine Container reservieren.

Achtung! Diesen Bereich vom DHCP-Server des LAN ausklammern!

Die entsprechende network bridge erzeugt dann dieser Befehl:

docker network create -d macvlan --subnet=192.168.3.0/24 --ip-range=192.168.3.224/27 --aux-address 'host=192.168.3.224' --gateway=192.168.3.1 -o parent=eth0 pub_net

--aux-address 'host=192.168.3.224' Diese Adresse wird vom Docker-DHCP ausgenommen. Sie dient der Verbindung zwischen Host und Docker-Netzwerk.

-o parent=eth0 Das normale network interface des Hosts, bitte entsprechend anpassen.

pub_net Der Name der Bridge an den persönlichen Geschmack anpassen.

Als nächstes müssen wir eine Eigenheit von Docker, bzw. dem macvlan Treiber umgehen. Docker filtert standardmäßig den Traffic zwischen dem Host und den Containern heraus. Umgehen lässt sich das mit einem 2. Netzwerk-interface, welches wir unter /etc/network/interfaces eintragen. Die Befehle gelten alle für Debian/Ubuntu, auf anderen Distributionen könnte es anders sein.

auto docker-bridge
iface docker-bridge inet static
        address 192.168.3.224
        netmask 255.255.255.224
        pre-up ip link add docker-bridge link eth0 type macvlan mode bridge
        post-down ip link del docker-bridge link eth0 type macvlan mode bridge
        up route add -net 192.168.3.224 netmask 255.255.255.224 gw 192.168.3.1
        down route del -net 192.168.3.224 netmask 255.255.255.224 gw 192.168.3.1

Wir verwenden hierfür die oben ausgeklammerte Adresse 192.168.3.224. Der Name „docker-bridge“ kann beliebig sein. Das Haupt-Interface „eth0“ muss entsprechend angepasst werden. Es wird auch gleich die nötige Route mit angelegt.

Nach dem Speichern einmal service networking restart ausführen (oder analog auf anderen Systemen), um alles zu aktivieren.

Container starten

Damit können wir nun den eigentlichen Container installieren:

docker run --name=diyHue --env="IP=192.168.3.225" --env="DEBUG=true" --env="MAC=dc:fe:07:e1:80:e6" --volume="/mnt/hue-emulator/:/opt/hue-emulator/export/:rw" --network=pub_net -p 1982:1982/udp -p 1900:1900/udp -p 443:443 -p 80:80 -p 2100:2100/udp --restart=always --detach=true diyhue/core:latest

Tipp: Wer sich den Befehl eines bereits laufenden Containers nicht aufgeschrieben hat und wieder anzeigen möchte, findet hier eine Lösung!

--env="IP=192.168.3.225" Sofern man dem Container eine feste IP zuweisen möchte.

--env="DEBUG=true" Aktiviert den Debug-Modus. Details siehe https://diyhue.readthedocs.io/en/latest/AddFuncts/debug.html. Ansehen kann man sich das Logfile mit tail -f /var/lib/docker/containers/(ID)/(ID).log. Die (ID) bekommt man mit docker ps -a. Wenn alles läuft, nicht vergessen den Debug-Mode wieder auszuschalten! …sonst wird das Logfile ziemlich groß…!

--network=pub_net Das oben konfigurierte Netzwerk, ggf. den Namen anpassen.

-p 1982:1982/udp sowie die anderen: Diese Ports müssen freigegeben werden.

diyhue/core:latest Name des Containers, neueste Version.

diyHue konfigurieren

Wenn alles läuft, sollte sich die diyHue unter http://192.168.2.225 (oder die IP, die sie bekommen hat) erreichen lassen.

originale Hue-bridge koppeln

Zunächst wird die Anzeige leer sein, denn als erstes muss die echte Hue-bridge gekoppelt werden. Wie das genau geht, steht unter https://diyhue.readthedocs.io/en/latest/configuration.html

In Kurz: Unter „Import from bridge“ die IP-Adresse der echten Hue-bridge eintragen, den Hardware-Button auf der echten Bridge drücken, dann OK drücken. Wenn alles klappt, bestätigt eine kurze Meldung, wie viele Hue-Lampen importiert wurden.

Hue-App koppeln

Sehr wahrscheinlich werden jedoch immer noch keine Lampen angezeigt, denn es fehlt noch ein Raum, oder eine Gruppe, in die die Lampen zugeordnet werden. Leider bietet diyHue hier keine Möglichkeit das zu erledigen. Aber über die originale Philips-Hue App kann man diesen Schritt ausführen. Zum koppeln, läßt man die Hue-App nach einer neuen Bridge suchen. Wird sie nicht von alleine gefunden, gibt man über „Hilfe“ die IP-Adresse direkt ein. Zum finalen Verbinden, muss man sich auf der diyHue-Seite unter „Link device“ mit Benutzer „Hue“ und Passwort „Hue“ anmelden. Der anschließende Klick auf „Activate“ stellt den Hardware-button dar. Jetzt kann man innerhalb 30 Sekunden die Hue-App koppeln. Wenn auch dies geklappt hat, sollten in der Hue-App alle Lampen wie bisher zu sehen sein. Auch die diyHue-Seite sollte jetzt alle Lampen anzeigen.

Wenn jetzt in der diyHue andere (nicht-Hue-)Lampen importiert werden, werden diese sofort auch in der Hue-App angezeigt und können über diese gesteuert werden.

mögliche Probleme

Die Hue-App findet die diyHue nicht

Über „Hilfe“ die IP-Adresse von Hand eingeben

Die Hue-App kann nicht Verbunden werden

Es kann eine Hilfe sein, die Hue-App komplett zu löschen (mit allen Daten) und neu zu installieren.

Die diyHue-Seite zeigt keine Lampen an

Eine Möglichkeit ist, dass noch keine Lampen von der originalen Hue-Bridge importiert worden sind.

Eine andere Möglichkeit ist, dass die Hue-App noch nicht gekoppelt ist und somit noch kein einziger Raum oder Gruppe angelegt werden konnte.

Ich hatte bereits mehrfach das Problem, dass ich mir den konkreten Befehl zum Starten eines bestimmten Docker-Containers nicht dokumentiert hatte, ihn aber hinterher wieder gebraucht habe. Aber es gibt einen Trick, mit dem man den Docker run command rekonstruieren kann.

Als erstes mit diesem Befehl alle laufenden Container anzeigen lassen:

docker ps -a

Hier die „Container ID“ des gewünschten Containers kopieren.

Dann:

docker run --rm -v /var/run/docker.sock:/var/run/docker.sock assaflavie/runlike e0aced1e4011

Hierbei die Container ID hinten durch die oben kopierte ersetzen.

Der Befehl lädt einen speziellen Docker-Container temporär herunter und führt ihn aus. Als Ausgabe wird der run-Befehl des gefragten Containers angezeigt.