Zum Inhalt

2022

  • 8 Min. Lesezeit

Home Assistant und ZigBee – ZHA, DeConz oder ZigBee2MQTT?

Der Vorteil einer Lösung wie Home Assistant liegt darin, unterschiedlichste Systeme miteinander zu verbinden. Dazu gehören auch Lampen, Steckdosen und Sensoren, die auf den ZigBee-Standard hören. Diese bekommt man mittlerweile mit TINT (Müller Licht) auch bei Aldi oder unter dem Namen Silvercrest bei Lidl.

Philips Hue Iris

ConBee Stick II und DeConz/Phoscon – meine bisherige Lösung

Ich habe 15 Lampen von Philips, Aldi, Osram und Lidl sowie weiter 25 Sensoren von Aqara (Magnetsensoren und Multisensoren), Tradfri und Lidl im Einsatz. Das ist schon ein ziemlich umfangreiches ZigBee-Setup. Bislang lief es mit dem ConBee-Stick mit Phoscon/DeConz in einem externen Docker-Container unter UnRAID.

Der Grund dafür war, dass ich es nie geschafft habe, den ConBee II Stick zuverlässig zu meiner virtuellen Maschine durchzureichen, um DeConz/Phoscon direkt in Home Assistant laufen zu lassen. Einzig nach HA-Updates musste ich den DeConz-Container oft neu starten, damit die Geräte von HA aus wieder erreichbar waren. Das habe ich jedoch über ein Skript lösen können, das nach dem Neustart von HA den Docker-Container ebenfalls neu startete.

Phoscon mit ConBee Stick

Ein Nachteil der DeConz-Lösung des ConBee II Sticks ist, dass neue Geräte oft erst sehr viel später unterstützt werden und das System manchmal auch etwas träge in der Ausführung ist. Darum habe ich mir die beiden anderen Lösungen einmal genauer angesehen. Gleich vorweg: Es war ein heißer Ritt und teilweise wirklich nervenaufreibend, denn man muss natürlich alle Geräte neu koppeln, HA Entitäten und Automationen anpassen etc.

ZHA (ZigBee Home Automation) – geht, geht nicht, geht, geht nicht

ZHA ist die direkte Implementierung für ZigBee in Home Assistant. Einfach die Integration installieren, der Anschluss des ZigBee-Coordinators wird normalerweise automatisch erkannt und nach kurzer Zeit hat man ZigBee in Home Assistant zur Verfügung. Die Integration der gefundenen Geräte ist so, wie man es von Home Assistant kennt und alles wirkt wie aus einem Guss. Das Durchreichen eines Sonoff ZigBee USB 3.0 Dongle Plus Sticks war kein Problem und er wurde auch gleich erkannt.

ZHA Integration eines Geräts in Home Assistant

Die ZigBee Geräte waren relativ schnell angelernt, allerdings musste ich feststellen, dass die Geräte bei der Kopplung oft näher am Coordinator sein mussten, als ich das vom ConBee-Stick kannte. Das Setup war jedoch fast identisch: USB-Verlängerung für den Stick und dieser an fast identischer Position im Haus – daran konnte es also nicht liegen.

Ich war irgendwie begeistert, wie schön das alles integriert und aufgebaut ist und sah das schon als “meine” Lösung, weil mit den HA-Updates auch gleich ZHA upgedatet und neu gestartet wird. Die Darstellung der Netzwerk-Topologie ist gut, wenngleich man die Beschreibungen der einzelnen Knoten erst nach starkem Hineinzoomen angezeigt bekommt.

Visualisierung in ZHA

Nachdem alle Geräte gekoppelt waren, zeigten sich erste Probleme, denn plötzlich waren manche (hauptsächlich) Hue-Lampen nicht mehr erreichbar. Die ganzen Sensoren oder auch TINT-Leuchten funktionierten weiterhin. Nach einem Neustart waren die Lampen wieder erreichbar, bis sie einige Stunden später wieder ausfielen. Dabei war kein Schema zu erkennen. Manche Lampen, die nahe am ZigBee-Stick waren, gingen nicht mehr, wohingegen manch weit entfernte problemlos funktionierten. Durch erneutes Koppeln, konnte man sie wiederbeleben, wobei die vorhergehenden Einstellungen erhalten blieben. Nach unbestimmter Zeit waren sie dann wieder andere Geräte offline.

Sonoff ZigBee 3.0 USB Dongle Plus

Da die Logs von ZHA die Kommunikation mit den funktionierenden Geräten ohne Probleme anzeigten, konnte es auch nicht an meiner virtuellen Maschine und dem Pass-Through des USB-Sticks liegen, zumal auch die Sensoren keinerlei Verbindungsprobleme hatten. Das Verhalten hing wohl auch nicht vom ZigBee-Stick ab, denn der Effekt war sowohl mit dem Sonoff-Stick als auch mit dem ConBee gleichermaßen vorhanden.

Eine Recherche ergab (hier nur EIN Beispiel: https://community.home-assistant.io/t/zha-zigbee-network-hell-since-updates/478368/9), dass ich hier nicht allein war. Seit den letzten HA-Updates funktioniert ZHA wohl immer unzuverlässiger – egal ob auf einem Raspi, nativ auf PC-Hardware, HA als Docker oder VM. Viele berichteten auch, dass DeConz beim gleichen Setup nie Probleme verursacht habe.

Das war natürlich kein Zustand, da über die ZigBee-Sensoren auch einige wichtigere Dinge bei mir gesteuert werden. Darum weiter zu …

ZigBee2MQTT – erwachsen, flexibel und mit breiter Geräteunterstützung

ZigBee2MQTT ist eine Open Source Implementierung des ZigBee Protokolls, das unabhängig von der verwendeten Smarthome-Software läuft. Man benötigt natürlich einen MQTT-Broker wie Mosquitto, der aber in Home Assistant als Add-On zur Verfügung steht. ZigBee2MQTT kann auch unter HA als Add-On installiert werden, ich habe mich jedoch dafür entschieden, es als Docker-Container direkt in UnRaid zu installieren, was reibungslos funktionierte.

ZigBee Geräte in ZigBee2MQTT

ZigBee2MQTT kann mit verschiedenen ZigBee-Lösungen wie dem ConBee-Stick, Sonoff ZigBee 3.0, der Sonoff-Bridge oder anderen betrieben werden. Da ich nach dem Reinfall mit ZHA erst einmal testen wollte, wie sich ZigBee2MQTT verhält, habe ich es parallel zu ZHA (mit ConBee) installiert und dazu den Sonoff-Stick eingesetzt.

Auffällig war zunächst, dass das Koppeln der Geräte mit dem Sonoff Stick sehr viel schneller ging, als unter ZHA und ein direkter Vergleich mit beiden Installationen zeigte, dass ZigBee2MQTT schneller auf Befehle (gerade bei Farbwechseln) reagierte, als ZHA. Sehr viel wichtiger ist jedoch, dass die gekoppelten Geräte auch zuverlässig verbunden bleiben und da zeigten sich bei diesem System bislang keine Probleme.

Netzwerk-Topologie

ZigBee2MQTT bietet die breiteste und schnellste Unterstützung für Endgeräte und erlaubt die Konfiguration bis ins kleinste Detail. Die Darstellung der Netzwerk-Topologie ist schön gelöst und informativ. Man hat ein einfaches Dashboard mit allen verfügbaren Geräten, die man von dort aus direkt steuern kann, was bei einem Test sehr praktisch ist. Gerätenamen können direkt editiert werden und auf Wunsch wird der neue Name gleich in HA für die Entity übernommen.

ZigBee2MQTT Dashboard

Auf zigbee2mqtt.io gibt es zudem eine riesige Datenbank über praktisch alle auf dem Markt verfügbaren ZigBee-Geräte mit Beschreibung, Funktionsumfang und wie man sie in den Kopplungsmodus versetzt. Diese Datenbank ist Gold wert und nicht nur für Nutzer dieses Systems hilfreich.

ZigBee2MQTT abstrahiert die ZigBee-Anbindung auch gut, denn durch die MQTT-Basis kann man mit anderen Systemen direkt und ohne Umweg über Home Assistant auf die verbundenen Geräte zugreifen.

Welche ZigBee Lösung ist für Home Assistant die beste?

ZHA wäre definitiv die schönste Lösung, da sie direkt in Home Assistant integriert ist. Leider scheitert die Nutzung an der genannten Unzuverlässigkeit, die wohl kein Einzelfall ist. Ob diese Ausfälle bei größeren Netzen und/oder vielen unterschiedlichen Geräten häufiger sind, konnte ich nicht herausfinden.

Es wird auch von Installationen berichtet, die nur aus 4 oder 5 Geräten bestehen und trotzdem Probleme zeigen. Auch scheint es nicht an der ZigBee Hardware wie Sonoff, ConBee oder anderen zu liegen. Daher ist diese Lösung momentan mit Vorsicht zu betrachten und ihr solltet erst einmal einen Test machen, bevor ihr euch entscheidet oder alles über den Haufen werft.

ZigBee Bewegungsmelder im Vergleich

ZigBee Bewegungsmelder im Vergleich

ZigBee2MQTT ist eine etablierte Lösung mit vielen Möglichkeiten und der breitesten Hardware-Unterstützung. Updates und neue Hardware gibt es laufend und sehr zeitnah, sollten Probleme auftauchen.

Der Nachteil dieser Lösung ist, dass man einen MQTT-Broker benötigt. Gleichzeitig kann das auch ein Vorteil sein, denn ZigBee2MQTT läuft eigenständig und losgelöst von anderen Anwendungen. Will man von Home Assistant etwa auf OpenHAB wechseln (warum sollte man, aber das ist nur ein Beispiel), verbindet man sich mit dem MQTT Broker und hat sofort Zugriff auf die ZigBee-Geräte.

ZigBee2MQTT arbeitet schnell und stabil und auch die Kopplung funktioniert schnell und zuverlässig.

DeConz/Phoscon bietet die schönste Benutzeroberfläche, gute Hardware-Unterstützung – wenngleich neue Geräte oft erst Monate später unterstützt werden. DeConz ist nicht das schnellste System und wer Home Assistant als VM betreibt, kann Probleme mit dem Durchreichen des ConBee II Sticks bekommen.

ConBee 2 USB Stick

Es ist das System, das bei mir am längsten (über 3 Jahren) im Einsatz war und immer zuverlässig arbeitete. Die Integration in Home Assistant ist gut gelöst und es arbeitet auch direkt als Bridge. Damit kann der ZigBee Stick mit DeConz/Phoscon auch direkt mit Alexa oder einer App wie Hue Essentials verbunden werden. Das geht bei ZHA/ZigBee2MQTT nur über Home Assistant oder eine zusätzliche Anwendung wie diyHUE. Das erfordert aber auch eine zusätzliche Installation als Docker Container oder Home Assistant Add-On und erhöht die Komplexität.

Für welche Lösung habe ich mich entschieden?

Gute Frage! Da bin ich mir noch nicht sicher. Aus jetziger Sicht werde ich ZigBee2MQTT parallel mit einigen Lampen laufen lassen und beobachten. Meine Tendenz geht aber wieder klar in Richtung ConBee/DeConz/Phoscon. Es funktionierte lange zuverlässig. Alle Geräte, die ich momentan im Einsatz habe, werden unterstützt und es arbeitet auch gleichzeitig als Bridge, welche auch ohne Home Assistant funktioniert.

Würde ZHA zuverlässig funktionieren, hätte ich kein Problem damit, sofort darauf umzusteigen. Dazu muss man aber erst einmal die Erfahrungen mit zukünftigen Updates beobachten.

Gleichzeitig werde ich mir aber einmal ansehen, wie sich ZHA auf einer anderen Home Assistant Installation verhält. Hierzu werde ich ein Backup meiner HA-Konfiguration einmal direkt auf eine PC-Hardware installieren und einmal als Proxmox-VM.

Ich habe von meiner Home Assistant Installation ein Backup gemacht und als virtuelle Maschine – wie angekündigt – unter Proxmox installiert. Dafür musste ein alter Dell Mini PC mit 8 GB und i5 CPU (Dell Optiplex 790 SFF mit Intel Core i5 2500, gibt es mit 8 GB und 250 GB SSD für unter 100 Euro) herhalten, den ich noch rumstehen hatte. Auch hier habe ich den Sonoff ZigBee Stick an die VM durchgereicht und was soll ich sagen: ZHA läuft hier absolut problemlos!

Der kleine DELL mit dem Sonoff Stick als Basis für meinen Proxmox Test

Noch interessanter ist, dass dieselbe Home Assistant Installation hier deutlich schneller läuft und flüssiger reagiert. Ich kann sogar Frigate mit 4 Kameras direkt mit dem HA Add-On OHNE Google Coral Beschleuniger bei 50 % CPU-Auslastung laufen lassen. Das erste Diagramm zeigt die Auslastung der Home Assistant VM mit und ohne Frigate.

Anscheinend funktioniert die Virtualisierung auf meine UnRaid Server deutlich schlechter, als Proxmox und verursacht auch die Probleme mit den ZigBee-Sticks.

Da ich schon länger mit Proxmox experimentiere, werde ich meinen UnRaid-Server wohl komplett auf Proxmox umstellen. Die Snapshot-Funktionen für die VM und das eingebaute Backup funktionieren hervorragend, während man bei UnRaid selbst Lösungen finden muss, die nie so richtig stabil sind.

ZHA funktioniert schnell und alle gekoppelten Geräte sind zuverlässig erreichbar. Daher ist meine Empfehlung eindeutig ZHA!

  • 2 Min. Lesezeit

Home Assistant Quickie: Werte in Prozent anzeigen

Bei meiner Zisterne, wird aus der Spannung des Wasserstandsensors der Füllstand in Zentimetern und Litern berechnet. Natürlich weiß ich, dass bei 100,5 cm Füllstand die Zisterne bis zum Überlauf voll ist und damit laut Herstellerangabe 5130 Liter Wasser enthalten sind. Doch wie gibt man den Füllstand in Prozent aus? Das ist auch für Batterieanzeigen interessant, denn 70 % Batterielevel sind intuitiver zu verstehen, als 2,7 Volt.

Mit einem Sensor-Template geht die Umrechnung ganz einfach, denn damit kann man praktisch einen “virtuellen” Sensor bauen, der eine Berechnung aus anderen Quellen ausgibt.

Wir benötigen einen Sensor mit dem aktuellen Wert, also z. B. dem aktuellen Wasserstand in Litern. Bei mir ist das die Entität sensor.zisterne_liter. Außerdem den maximal zu erreichenden Wert, den Grundwert. Bei meiner Zisterne wären das 5130 (Liter).

Nun erstellt man einen neuen Sensor. Entweder unter sensors: in der configuration.yaml oder, wie bei mir, in einer ausgelagerten sensors.yaml in der nur meine Sensoren enthalten sind – das schafft mehr Übersicht.

1
2
3
4
5
6
7
sensors:
  - platform: template
    sensors: 
      zisterne_prozent:
        unit_of_measurement: '%'
        value_template: >-
          {{ (((states('sensor.zisterne_liter'))|float / 5130) *100)|round(1) }}

In value_template teilen wir den gemessenen Wert des Sensors durch den Grundwert, also 5130 und multiplizieren das Ergebnis mit 100. round(1) gibt an, dass auf eine Nachkommstelle gerundet werden soll. Will man keine Nachkommastellen, gibt man round(0) an.

Nach dem Reload hat man eine neue Entität sensor.zisterne_prozent, die man dann im Dashboard einbinden kann.

Für eine Batterie muss man erst einmal wissen, ab wann eine Batterie als leer angesehen werden kann. Bei Knopfzellen, wie man sie in vielen Geräten wie den Aqara ZigBee Sensoren findet, kommen 3 Volt Lithium-Knopfzellen zum Einsatz. Die meisten Hersteller geben an, dass die Zelle bei einer Spannung von 2 Volt leer ist. Daher darf man also nicht die 3 Volt als Grundwert annehmen, sondern nur die Differenz zwischen neuer Batterie mit 3 Volt und leerer Batterie mit 2 Volt, also 1 Volt. Bei 1,5 Volt Batterien geht man von 0,9 Volt für eine leere Batterie aus, also müsste man 0,6 Volt als Grundwert annehmen (1,5 Volt – 0,9 Volt).

1
2
3
4
5
6
7
sensors:
  - platform: template
    sensors: 
      batterie_prozent:
        unit_of_measurement: '%'
        value_template: >-
          {{ (((states('sensor.batteriespannung'))|float / 1) *100)|round(0) }}

Hier nimmt man den Sensor, der die aktuelle Batteriespannung eines Geräts misst, und setzt z. B. bei einer 3 Volt Batterie 1 als Grundwert ein und schon hat man den Batteriezustand in Prozent.

  • 17 Min. Lesezeit

DIY Bewässerungssteuerung mit Home Assistant und ESPHome

Mit unserer Zisterne, die wir im letzten Jahr als Puffer und mit den neuen Rohren für die Regenwasserableitung bekommen haben, gibt es und reichlich kostenloses Wasser vom Dach. Zumindest, wenn es eines Tages mal wieder regnet.

Wir haben daher auf dem Grundstück Rohre für eine automatische Bewässerung verlegt, wozu das Gardena Bewässerungssystem zum Einsatz kam, da diese Komponenten im letzten Jahr günstiger als die Alternativen von Hunter oder Rainbird waren.

Über 5 Ventile steuern wir 5 individuelle Kreise an:

  • Rasenbewässerung Ost
  • Rasenbewässerung West
  • Hochbeet / Beete
  • Vorgarten
  • Wasserauslass in der Einfahrt

Als Material haben wird verbaut:

Gardena Versenkregner

Die Elektronik des Waterking

Die typischen Bewässerungsventile werden mit 24 Volt Wechselstrom angesteuert. Der Einschaltstrom beträgt etwa laut Datenblatt 370 mA, der Haltestrom 210 mA. Die tatsächlichen Werte waren nach meinen Messungen etwas geringer.

Da nie alle Ventile gleichzeitig in Betrieb sind, weil sonst der Wasserdruck zu stark abfallen würde (selbst bei der 4 bar Tauchdruckpumpe), genügt ein 24 Volt Wechselspannungsnetzteil mit 1 Ampere. Das hatte ich noch von einer alten Außenlichterkette. Passende Netzteile bekommt man auch bei Ebay.

Würde man die Ventile mit Gleichspannung betreiben, könnten sich die Kerne der Elektromagnete permanent magnetisieren und die Ventile würden “kleben”. Im schlimmsten Fall wird der Kern gesättigt, was einen höheren Stromfluss und damit die Zerstörung der Spulen bedeuten kann.

Daher kann man keine MOSFETs zur einfachen Ansteuerung nutzen. Am einfachsten wären Relais, doch darauf wollte ich nicht vertrauen. Erstens können die Kontakte korrodieren und die einfachen China-Relais, die es als 4er oder 8er Platinen fix und fertig gibt, sind nicht unbedingt zum Schalten von Niederspannung geeignet. Das klingt paradox, aber die meisten Legierungen, die für Relais-Kontakte eingesetzt werden (bei diesen Relais AgCdO), benötigen einen kurzen Lichtbogen, der nur bei höheren Spannungen und Strömen entsteht (der sog. Frittstrom). Dadurch werden Oxide weggebrannt, was für einen dauerhaft guten Kontakt sorgt. Da im Gerätehaus auch hohe Luftfeuchtigkeit vorkommt, schieden Relais für mich aus.

Die Triacs der 5 Kanäle mit den weißen Optokopplern

Ich habe mich bei meinem DIY-Controller, den ich Waterking getauft habe, für Triacs vom Typ BTA08-600B entschieden, die über einen MOC3041 Optokoppler angesteuert werden, der auch gleich einen Nulldurchgang-Triac-Treiber enthält. Rechnet man noch 5 Widerstände, einen NPN-Transistor und eine LED dazu, kostet ein Kanal nicht einmal einen Euro und man wird nie Kontaktprobleme haben. Die LEDs zeigen Hardware-seitig an, ob ein Ventil offen ist und der Optokoppler angesteuert wird.

Da man ohnehin schon die 24 Volt hat, kann man die auch für die Versorgung des ESP8266 und des Displays nutzen. Gleichgerichtet kommt man auf 35 V Gleichspannung, die ich mit einem LM2596S Step-Down-Konverter sehr effizient auf 5 Volt wandle.

Wie oft bei meinen Projekten kommt ein Wemos D1 Mini Pro zum Einsatz, weil ich vor längerer Zeit einmal preiswert einen größeren Posten eingekauft hatte. Der Wemos wird auch bis auf den (fast) letzten GPIO ausgereizt. Zur Ansteuerung von 5 Ventilen und unserer Tauchdruckpumpe benötige ich 6 Ausgänge. Jetzt könnte man 6 GPIOs verbraten oder man nimmt ein Schieberegister vom Typ SN74HC595. Damit kann man mit 3 Steuer-Pins 8 Ausgänge schalten. Benötigt man mehr, kann man unter ESPHome bis zu 4 SN74HC595 kaskadieren, wozu man dann noch einen Pin mehr benötigt, damit aber 32 Ausgänge erhält.

Die Pumpe wird über ein Solid State Relais (SSR) geschaltet.

TL - 136 Flüssigkeitsstandsender Wasser Ölstandsensor Detektor 24VDC 420mA Signalausgang(0-2m), SenderTL – 136 Flüssigkeitsstandsender Wasser Ölstandsensor Detektor 24VDC 420mA Signalausgang(0-2m), Sender

Ursprünglich sollte mein Controller “dumm” bleiben, also nur die Triac-Ausgänge per Home Assistant schaltbar machen. Wenn man aber schon einen Mikrocontroller hat, kann man ja auch gleich noch ein paar Funktionen extra einbauen. So schalten die Ventile nach einer konfigurierbaren Zeit (10 Minuten) ab. Ist kein Ventil mehr aktiv, wird auch die Pumpe deaktiviert. Sollte die WLAN-Verbindung während der Bewässerung verloren gehen oder Home Assistant einen Bug haben, schalten Ventile und die Pumpe automatisch und autonom ab. Aufgebaut habe ich alles auf einer Streifenrasterplatine. Ich bin “Team Streifenraster” – mir gefällt das Herumgekleckse mit Lötzinn auf den Perfboards einfach nicht.

Bitte habt Verständnis dafür, dass ich keinen Plan für den Aufbau der Platine habe. Ich mache so etwas frei und ohne große Vorplanung direkt vom Schaltplan weg. Kurz die Position der Teile testen und los geht es. Bei Gelegenheit gibt es vielleicht mal ein Platinenlayout mit KiCAD dazu – vielleicht hat ja auch von euch jemand Lust dazu? Den Schaltplan in KiCAD dazu gibt es.

Schaltplan ohne Display und Encoder

Über einen Dreh-Encoder und das LED-Display kann ich nicht nur den Zustand der Ventile (zusätzlich zu den LEDs am Optokoppler) anzeigen lassen, sondern diese auch direkt am Controller ein- und ausschalten. Weitere Menü-Ebenen zeigen den Wasserstand der Zisterne in Zentimetern und Litern, die Stärke des WLAN-Signals, den heutigen Wasserverbrauch und die Uhrzeit an. Wie man den Wasserstandsmesser mit einem TL-136 Sensor baut, habe ich hier beschrieben: https://nachbelichtet.com/wasserstand-in-zisternen-mit-homeassistant-esphome-und-tl-136-drucksensor-messen/

Wasserstand in der Zisterne

Durch einfaches Drehen am Encoder kann man die Ebenen wechseln. Drückt man die Taste, gelangt man ins Setup-Menü für die Ventile. Ein Strich zeigt ein inaktives Ventil an, ein Kästchen ein aktives. Der Dezimalpunkt signalisiert, welches Ventil man gerade ausgewählt hat und ein langer Druck auf die Taste schaltet es ein oder aus. Mit einer kurzen Betätigung kommt man wieder ins Hauptmenü.

Der Waterking im Einsatz

Mich hat es einmal gereizt, mit einer einfachen 8-stelligen LED-Anzeige ein komfortables Menü zu basteln. Es muss nicht immer ein OLED- oder LC-Display sein und die LED-Anzeige ist sehr robust, was bei -20 bis +50 °C im Gerätehaus nicht unwichtig ist.

Die verschiedenen Menüs und Einstellungen im Display

Über die Abfrage des Wasserstands der Zisterne, kann ich die Pumpe deaktivieren, wenn der Wasserstand unter 12 cm sinkt. Eine lange Betätigung der Encoder-Taste schaltet alle Ventile und die Pumpe sofort aus.

Ventilesteuerung in Home Assistant mit Wasserstand der Zisterne

Das Interlocking der Ausgänge verhindert, dass bestimmte Ventile gleichzeitig aktiv sein können. Damit verhindert man nicht nur einen Druckabfall, sondern auch die Überlastung des Netzteils. Es können maximal 3 Ventile (Gardena Micro Trip Tropfer Hochbeet, Vorgarten und Wasserentnahme) aktiv sein und nur einer der beiden Kreise für die Rasenfläche. Auch diese Sicherheitsfunktion stellt der Controller direkt bereit – egal, was ich in Home Assistant sonst konfigurieren würde.

3D-gedrucktes Gehäuse für den Waterking

Damit alles auch ordentlich verpackt ist und auch gut aussieht, habe ich noch ein Gehäuse aus PETG und PLA gedruckt. Das transparente PETG lässt die LEDs und das Display durchscheinen.

Gehäuse mit abstrahiertem Modell der Platine

Beim Displayausschnitt habe ich die Schichtdicke bei der Konstruktion so gewählt, dass kein Infill gedruckt wird. Damit sieht das wie eine transparente Folie aus.

Das ganze Gehäuse ist schraubenlos verschließbar und auch die Platine wird nur von Schnappverschlüssen gehalten. Bei einer handgefertigten Platine ist die Konstruktion eines Gehäuses mit Deckel nicht ganz trivial, klappte aber beim ersten Versuch und Druck.

Konstruktion in Fusion 360

Als Gag ist noch ein Halter für eine Ersatzsicherung dabei. Der Zugang zu den Anschlussklemmen erfolgt von unten. Zur Konstruktion habe ich – wie immer – Autodesk Fusion 360 eingesetzt. Den Druck erledigte mein Creality Ender 3 in etwa 10 Stunden.

Zugang zu den Anschlussklemmen

Wer den Aufwand mit der Ventilansteuerung nicht betreiben möchte, kann statt der Triacs auch eine solche SSR-Platine einsetzen, die man für unter 20 € bekommt. Hier muss man nur noch die Kanäle mit dem ESP ansteuern. Der Code unten kann auch hierfür genutzt werden.

SSR-Modul mit 8 Kanälen.

Die YAML-Konfiguration in ESPHome habe ich mit entsprechenden Anmerkungen versehen:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
esphome:
  name: waterking
  platform: ESP8266
  board: d1_mini
  # Zur Sicherheit alle Ausgänge beim Start ausschalten
  on_boot: 
    then:
      - switch.turn_off: v1
      - switch.turn_off: v2
      - switch.turn_off: v3
      - switch.turn_off: v4
      - switch.turn_off: v5
      - switch.turn_off: pump
      - sensor.rotary_encoder.set_value:
          id: enc
          value: 0

# Seriellen Logger an RX/TX ausschalten, um Pins für andere Aufgaben nutzen zu können
logger: 
  baud_rate: 0

# Home Assistant API aktivieren
api:

ota:
  password: !secret otapass"

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  use_address: waterking.local

  # Fallback Hotspot
  ap:
    ssid: "Bewaesserung Fallback Hotspot"
    password: !secret hotspot

captive_portal:

# Uhrzeit von HA holen
time:
  - platform: homeassistant
    id: homeassistant_time

# Globale Variablen setzen
globals: 
  - id: setpage #Einstellmodus
    type: bool
    restore_value: no
    initial_value: 'false'

  - id: maxtime #maximale Laufzeit Ventile als Schutz
    type: int
    restore_value: yes
    initial_value: '600000' # in ms = 10 min

# Schieberegister einrichten
sn74hc595:
  - id: 'sn74hc595_hub'
    data_pin: D5
    clock_pin: D6
    latch_pin: D7
    oe_pin: D2
    sr_count: 1

# SPI für Display
spi:
  clk_pin: D0
  mosi_pin: D1

# Ventile definieren

switch:
  - platform: gpio
    name: "Ventil Ost"
    id: v1
    pin:
      sn74hc595: sn74hc595_hub
      number: 1
      inverted: false
    interlock: [v2,v4,v5] # Bestimmte Ventile nicht gleichzeitig einschalten -> Druckverlust
    on_turn_on:
      - switch.turn_on: pump
      - delay: !lambda "return id(maxtime);"
      - switch.turn_off: v1

  - platform: gpio
    name: "Ventil West"
    id: v2
    pin:
      sn74hc595: sn74hc595_hub
      number: 2
      inverted: false
    interlock: [v1,v4,v5]
    on_turn_on:
      - switch.turn_on: pump
      - delay: !lambda "return id(maxtime);"
      - switch.turn_off: v2

  - platform: gpio
    name: "Ventil Beet"
    id: v3
    pin:
      sn74hc595: sn74hc595_hub
      number: 3
      inverted: false
    interlock: [v2]
    on_turn_on:
      - switch.turn_on: pump
      - delay: !lambda "return id(maxtime);"
      - switch.turn_off: v3

  - platform: gpio
    name: "Ventil Vorgarten"
    id: v4
    pin:
      sn74hc595: sn74hc595_hub
      number: 4
      inverted: false
    interlock: [v1,v2]
    on_turn_on:
      - switch.turn_on: pump
      - delay: !lambda "return id(maxtime);"
      - switch.turn_off: v4

  - platform: gpio
    name: "Ventil Einfahrt"
    id: v5
    pin:
      sn74hc595: sn74hc595_hub
      number: 5
      inverted: false
    interlock: [v2,v5]
    on_turn_on:
      - switch.turn_on: pump
      - delay: 1h #Ventil 5 darf max. 1 Stunde an sein -> Wasserentnahme
      - switch.turn_off: v5

# Solid State Relais Ausgang für Pumpensteuerung
  - platform: gpio
    name: "SSR Pumpe"
    internal: true # Pumpe nicht in HA anzeigen
    id: pump
    pin:
      sn74hc595: sn74hc595_hub
      number: 0
      inverted: false

# Display einrichten
display:
  - platform: max7219
    cs_pin: D3
    num_chips: 1
    update_interval: 500ms
    lambda: |-
      // Page 5 Uhrzeit anzeigen
      if ((id(enc).state == 5) && (id(setpage) == false)) {
        it.print("        ");
        it.strftime("%H.%M.%S", id(homeassistant_time).now());
      }

      // Page 4 Wifi Level
      if ((id(enc).state == 4) && (id(setpage) == false)) {
        it.print("        ");
        it.printf("Wi %.0fdB", id(wlan_signal).state);
      }

      // Page 1 Wasserstand Höhe
      if ((id(enc).state == 1) && (id(setpage) == false)) {
        it.print("        ");
        it.printf("FH %.1fcn", id(zisterne_cm).state);
          }

      // Page 2 Wasserstand Liter
      if ((id(enc).state == 2) && (id(setpage) == false)) {
        it.print("        ");
        it.printf("FS %.0fL", id(zisterne_liter).state);
          }

      // Page 3 Wasserverbrauch heute
      if ((id(enc).state == 3) && (id(setpage) == false)) {
        it.print("        ");
        it.printf(1,"= %.0f L", id(zisterne_delta_heute).state);

          }      

      // Page 0 Status Ventile anzeigen    
      if ((id(enc).state == 0) && (id(setpage) == false)) {
        it.print("        ");
          if ((id(v1).state)) {
            it.print("o");
            } else {
            it.print("_");
              }

          if ((id(v2).state)) {
            it.print(1,"o");
            } else {
            it.print(1,"_");
              }

          if ((id(v3).state)) {
            it.print(2,"o");
            } else {
            it.print(2,"_");
              }

          if ((id(v4).state)) {
            it.print(3,"o");
            } else {
            it.print(3,"_");
              }

          if ((id(v5).state)) {
            it.print(4,"o");
            } else {
            it.print(4,"_");
              }
          if ((id(pump).state)) {
            it.print(6,"P");
            } else {
            it.print(6,"_");
              }
          }      

      // Erste Seite Setup-Page
      if (id(setpage) == true && id(enc).state == 0) {
        it.print("       S");
        if ((id(v1).state)) {
          it.print("o");
          } else {
          it.print("_");
            }

        if ((id(v2).state)) {
          it.print(1,"o");
          } else {
          it.print(1,"_");
            }

        if ((id(v3).state)) {
          it.print(2,"o");
          } else {
          it.print(2,"_");
            }

        if ((id(v4).state)) {
          it.print(3,"o");
          } else {
          it.print(3,"_");
            }

        if ((id(v5).state)) {
          it.print(4,"o");
          } else {
          it.print(4,"_");
            }
        if ((id(pump).state)) {
          it.print(6,"P");
          } else {
          it.print(6,"_");
            }

      }


      // Ventil 1 einstellen 

      if (id(setpage) == true && id(enc).state == 1) {


        if ((id(v1).state)) {
          it.print("o.");
          } else {
          it.print("_.");
            }

        if ((id(v2).state)) {
          it.print(1,"o");
          } else {
          it.print(1,"_");
            }

        if ((id(v3).state)) {
          it.print(2,"o");
          } else {
          it.print(2,"_");
            }

        if ((id(v4).state)) {
          it.print(3,"o");
          } else {
          it.print(3,"_");
            }

        if ((id(v5).state)) {
          it.print(4,"o");
          } else {
          it.print(4,"_");
            }

          }  // Ende V1  

        // Ventil 2 einstellen 

        if (id(setpage) == true && id(enc).state == 2) {


          if ((id(v1).state)) {
            it.print("o");
            } else {
            it.print("_");
              }

          if ((id(v2).state)) {
            it.print(1,"o.");
            } else {
            it.print(1,"_.");
              }

          if ((id(v3).state)) {
            it.print(2,"o");
            } else {
            it.print(2,"_");
              }

          if ((id(v4).state)) {
            it.print(3,"o");
            } else {
            it.print(3,"_");
              }

          if ((id(v5).state)) {
            it.print(4,"o");
            } else {
            it.print(4,"_");
              }

          }

          if (id(setpage) == true && id(enc).state == 3) {


            if ((id(v1).state)) {
              it.print("o");
              } else {
              it.print("_");
                }

            if ((id(v2).state)) {
              it.print(1,"o");
              } else {
              it.print(1,"_");
                }

            if ((id(v3).state)) {
              it.print(2,"o.");
              } else {
              it.print(2,"_.");
                }

            if ((id(v4).state)) {
              it.print(3,"o");
              } else {
              it.print(3,"_");
                }

            if ((id(v5).state)) {
              it.print(4,"o");
              } else {
              it.print(4,"_");
                }

            }

            if (id(setpage) == true && id(enc).state == 4) {


              if ((id(v1).state)) {
                it.print("o");
                } else {
                it.print("_");
                  }

              if ((id(v2).state)) {
                it.print(1,"o");
                } else {
                it.print(1,"_");
                  }

              if ((id(v3).state)) {
                it.print(2,"o");
                } else {
                it.print(2,"_");
                  }

              if ((id(v4).state)) {
                it.print(3,"o.");
                } else {
                it.print(3,"_.");
                  }

              if ((id(v5).state)) {
                it.print(4,"o");
                } else {
                it.print(4,"_");
                  }

              }
              if (id(setpage) == true && id(enc).state == 5) {


                if ((id(v1).state)) {
                  it.print("o");
                  } else {
                  it.print("_");
                    }

                if ((id(v2).state)) {
                  it.print(1,"o");
                  } else {
                  it.print(1,"_");
                    }

                if ((id(v3).state)) {
                  it.print(2,"o");
                  } else {
                  it.print(2,"_");
                    }

                if ((id(v4).state)) {
                  it.print(3,"o");
                  } else {
                  it.print(3,"_");
                    }

                if ((id(v5).state)) {
                  it.print(4,"o.");
                  } else {
                  it.print(4,"_.");
                    }

                }        

sensor:

  - platform: rotary_encoder # Drehencoder einrichten
    name: "Rotary Encoder"
    id: enc
    publish_initial_value: true
    pin_a: 
      number: TX
      inverted: true
      mode:
        input: true
        pullup: true
    pin_b: 
      number: RX
      inverted: true
      mode:
        input: true
        pullup: true
    max_value: 5
    min_value: 0

# Füllstand in Liter von HA holen
  - platform: homeassistant
    id: zisterne_liter
    entity_id: sensor.zisterne_liter

# Verbrauch heute von HA holen
  - platform: homeassistant
    id: zisterne_delta_heute
    entity_id: sensor.zisterne_delta_heute

# Füllstand in cm von HA holen    
  - platform: homeassistant
    id: zisterne_cm
    entity_id: sensor.wasserstandraw # Notabschaltung Wasserstand < 12 cm -> Pumpenschutz
    on_value_range:
      - below: 12
        then:
          - switch.turn_off: v1
          - switch.turn_off: v2
          - switch.turn_off: v3
          - switch.turn_off: v4
          - switch.turn_off: v5
          - switch.turn_off: pump

# WLAN Signalstärke holen ... weil man es kann
  - platform: wifi_signal
    name: "Bewaesserung ESP Wifi Signal"
    update_interval: 30s
    id: wlan_signal      

binary_sensor:

  - platform: template
    name: "Any Valve On" # Wenn alle Ventile aus, Pumpe ausschalten
    internal: true
    lambda: 'return id(v1).state or id(v2).state or id(v3).state or id(v4).state or id(v5).state ;'
    on_release:
      then:
        - switch.turn_off: pump

  - platform: gpio # Taster am Encoder einrichten
    id: encswitch
    pin: 
      number: GPIO2
      mode: INPUT_PULLUP
      inverted: True 
    on_click:
    - min_length: 50ms  # Kurzer Betätigung, um ins Ventil-Setup zu kommen
      max_length: 250ms
      then: 
        - lambda: |-
            if(id(setpage)) {
              id(setpage) = false; 
            } else {
              id(setpage) = true; 
            } 

    - min_length: 600ms # lange Betätigung, um ausgewähltes Ventil ein/aus zu schalten
      max_length: 1500ms
      then:
        - if:
            condition:
              lambda: 'return (id(setpage) == true && id(enc).state == 1);'
            then:
              switch.toggle: v1

        - if:
            condition:
              lambda: 'return (id(setpage) == true && id(enc).state == 2);'
            then:
              switch.toggle: v2              

        - if:
            condition:
              lambda: 'return (id(setpage) == true && id(enc).state == 3);'
            then:
              switch.toggle: v3    

        - if:
            condition:
              lambda: 'return (id(setpage) == true && id(enc).state == 4);'
            then:
              switch.toggle: v4             

        - if:
            condition:
              lambda: 'return (id(setpage) == true && id(enc).state == 5);'
            then:
              switch.toggle: v5 


    - min_length: 3000ms # gaaanz lange Betätigung, um alle Ventile und die Pumpe auszuschalten
      max_length: 60000ms
      then:
        - switch.turn_off: v1
        - switch.turn_off: v2
        - switch.turn_off: v3
        - switch.turn_off: v4
        - switch.turn_off: v5
        - switch.turn_off: pump

Bewässerungssteuerung mit Home Assistant

Die eigentliche Bewässerungssteuerung wird Home Assistant übernehmen. Da hier bereits diverse Sensoren wie der Regensensor der LCN-WIH Wetterstation, Regenmengensensor sowie die Wettervorhersage als Entitäten in HA vorhanden sind, kann man diese für eine optimale und sparsame Bewässerung nutzen.

Installation im Gerätehaus

Die Füllstandsmessung der Zisterne ist übrigens auch ein hervorragender Sensor, was Niederschlagsmengen angeht, bekommt er doch den Niederschlag von 75 qm Dachfläche. Bei niedrigem Wasserstand in der Zisterne kann man auch die Bewässerungszeiten verkürzen usw.

Bodenfeuchtesensor

Neues Projekt: Der DIY-Bodenfeuchtesensor

Die wichtigsten Werte für die Bewässerung kommen über einen Bodenfeuchtesensor. Kapazitive Sensoren sind zwar relativ robust, messen die Bodenfeuchte jedoch nur in einem engen Bereich von wenigen Quadratzentimetern. Ich habe mir daher einen resistiven Sensor aus zwei 1 Meter langen Edelstahlgewindestangen gebaut, die mit 20 mm Abstand in 10 cm Tiefe vergraben werden.

Der DIY-Bodenfeuchtesensor

Edelstahl ist korrosionsbeständig und robust. Die zwei M5 Stangen kosteten im Sonderpreis Baumarkt 3 Euro. Mit diesem Sensor erfasst man einen repräsentativen Bereich und nicht nur punktuell. Da sich durch den Messstrom und die dadurch verursachte Elektrolyse mit der Zeit Salze und Mineralien an den Elektroden ablagern könnten, aktiviert man die Messung nur sehr kurz und in größeren Intervallen. Hierzu wird es einen separaten Beitrag geben.

  • 12 Min. Lesezeit

Meine Erfahrungen aus 2 Jahren Home Assistant Nutzung – plus 10 Tipps und Tricks

Im Juni 2020 habe ich begonnen, mich mit Home Assistant zu beschäftigen. Damals hatte ich bereits mit IP Symcon einen Smarthome-Hub im produktiven Einsatz. Nach den ersten Versuchen auf einem Testsystem, parallel zu Symcon, war ich schnell überzeugt, dass Home Assistant eine vollkommen andere Welt ist. Die riesige Community, die Auswahl an Integrationen und Add-ons, sowie der moderne technische Unterbau und vor allem: unzählige Entwickler, die sich um einen rasanten Fortschritt kümmerten, waren nur einige Gründe.

Da ich schon vorher eigene Sensoren und Aktoren auf Basis von ESPeasy und Tasmota gebaut und im Einsatz hatte, war auch die ESPhome-Plattform mit ihrer engen Integration in Home Assistant ein starkes Argument für einen Umstieg. Meine Symcon-Installation hatte zu diesem Zeitpunkt eine gewisse Komplexität (1200 Variablen – vergleichbar mit Home Assistant Entitäten) angenommen, die ich natürlich in Home Assistant neu umsetzen musste. Was mich anfänglich noch etwas abschreckte, war aus heutiger Sicht aber erstaunlich einfach lösbar. Anforderungen, Logik der Automationen usw. waren ja bereits bekannt und mussten “nur” auf der neuen Plattform, mit deren Möglichkeiten, aufgesetzt werden.

Home Assistant NAS Laufwerk einbinden

HP Microserver Gen8

Die technische Basis für Home Assistant war bei meinem anfänglichen Testsystem ein Raspberry Pi 4. Im August 2020 bin ich dann bei meinem Homeserver auf UnRaid umgestiegen und habe Home Assistant als virtuelle Maschine in UnRaid aufgesetzt. Das ist auch noch jetzt mein Produktivsystem. Ich habe damit all die Vorteile vom Home Assistant Supervisor, wie automatische Backups, Updates der Add-Ons usw. zur Verfügung. Zudem bietet mir mein HP Microserver Gen 8 mit Intel XEON E3-1240 CPU und 16 GB RAM reichlich Leistung, um auch anspruchsvolle Anwendungen wie die Kameraüberwachung mit Frigate und 6 Kameras zu bewerkstelligen.

Aktuell bin ich bei 42 Integrationen und 20 Add-Ons im Einsatz. In der Summe macht das, Stand heute:

Sensoren: 882
Lampen: 116
Schalter: 201
Binär-Sensoren: 172
Automationen: 79

Zu den Lampen und Schaltern gehören auch “virtuelle” Geräte, z. B. von meiner LCN-Installation, Alexa, PCs, TV- und ESPHome-Geräten.

Home Assistant verarbeitet das ohne nennenswerte Auslastung und das seit 2 Jahren extrem zuverlässig. Ich hatte seitdem noch keinerlei Totalausfälle oder größere Schwierigkeiten. Natürlich lasse ich regelmäßig Backups der Konfiguration und Installation machen. Gelegentlich ziehe ich auch eine Kopie der virtuellen Maschine, die ich – zusammen mit den aktuellen Backups der Konfiguration – jederzeit auch auf einem anderen System starten könnte.

Tipps und Tricks für Home Assistant

Hier möchte ich euch ein paar Tipps geben, die meiner Ansicht und Erfahrung nach hilfreich für den Einstieg und Betrieb von Home Assistant sind.

Zuvor solltet ihr euch aber überlegen – sofern ihr nicht schon ein anderes System betreibt und mit dem Umstieg auf Home Assistant liebäugelt, ob ihr für ein solches System bereit seid. Es bedarf einer nicht zu unterschätzenden Einarbeitung und ihr solltet der englischen Sprache einigermaßen mächtig sein, denn die Community ist englisch. Dafür findet man zu praktisch jedem Thema einen Lösungsansatz und man ist sehr hilfreich und freundlich. Zudem gibt es nicht nur das offizielle Home Assistant Forum, sondern auch ein Sub-Reddit und einen Discord-Server zum Austausch. Oft finde ich bei Reddit die interessantesten Inhalte und Anregungen – und auch die schnellste Hilfe.

Man muss Zeit investieren können und wollen. Viele möchten auch ein System wie meines, sehen aber nicht, wie viel Zeit und Anstrengung dahintersteckt. Außerdem solltet ihr ein solches System nicht für kritische Funktionen einsetzen. Grundlegendes wie die Heizungssteuerung, dass ihr Licht schalten könnten etc. muss auch ohne eine solche Software funktionieren. Zusätzlich solltet ihr bedenken, dass auch andere im Notfall das System bedienen und pflegen können müssen. Ein paar Gedanken dazu hatte ich hier veröffentlicht: 5 Gründe, warum du kein Smarthome haben solltest

1. Die technische Plattform

Für den Einstieg in Home Assistant (HA) genügt ein Raspberry Pi 3 (besser 4). Wenn du bereits einen Homeserver hast, kann man HA auch als Docker-Container laufen lassen. Beides geht einfach und schnell. Für den dauerhaften Betrieb von Home Assistant auf einem Raspi, solltest du über eine SSD statt der Micro-SD-Karte nachdenken, denn eines Tages wird die SD-Karte ausfallen.

Auch einem alten Laptop kann man neues Leben als Home Assistant Server einhauchen. Selbst ältere Laptops verbrauchen vergleichsweise wenig Strom, sind aber trotzdem leistungsfähiger, als ein Raspberry Pi. Zudem hat man – sofern die Batterie noch okay ist – auch gleich eine unterbrechungsfreie Stromversorgung (USV) eingebaut, welche Stromausfälle überbrücken kann.

Mehr Tipps zur besten Plattform für Home Assistant mit Vor- und Nachteilen findest du hier: Mit Home Assistant starten- welche Plattform wählen?

2. Entities, Templates, YAML & Co: Grundlagen verstehen

Immer mehr Integrationen kann man in Home Assistant per Mausklick konfigurieren. Trotzdem wird die Grundkonfiguration mit YAML und damit in einer etwas gewöhnungsbedürftigen Auszeichnungssprache gemacht, die mit Einrückungen arbeitet und gerade für Anfänger oft schwer zu verstehen ist.

Hilfreich ist hier nicht nur der Microsofts VS Code, den man als Standard-Editor für Home Assistant sehen kann. Dieser ist auch als Add-On verfügbar und integriert sich damit tief in Home Assistant. Er bietet Code-Vervollständigung und kann Entitäten automatisch auflisten. Ich würde behaupten, dass fast 90 % der Probleme, die man zu Beginn mit Home Assistant hat, auf Fehler in der YAML-Konfiguration zurückzuführen sind.

Ihr solltet zunächst auch die verschiedenen Begriffe und deren Bedeutung und Nutzung lernen. Dazu habe ich in diesem Beispiel versucht, die wichtigsten Home Assistant Begriffe in einem Beispiel zu demonstrieren:

Home Assistant Grundlagen mit Kaffeemaschine und Alexa

3. Strukturieren und dokumentieren

Zu Beginn ist man euphorisch und konfiguriert und integriert, was das Zeug hält. Nur wenig später kann sich das zu einem unübersichtlichen Moloch entwickeln. Darum solltet ihr eure Konfiguration von Anfang an klar strukturieren und – zumindest mit Kommentaren im Code – dokumentieren. Man muss und sollte nicht alle Konfigurationen in der configuration.yaml anlegen. Ich habe z. B. alle Lampen, Schalter, Automationen, Alexa-Einstellungen und Sensoren in eigenen YAML-Dateien nach Zimmern geordnet angelegt. In der configuration.yaml steht dann

1
2
3
4
5
6
7
light: !include lights.yaml
automation: !include automations.yaml
script: !include scripts.yaml
scene: !include scenes.yaml
switch: !include switch.yaml
sensor: !include sensors.yaml
alexa: !include alexa.yaml

was auf die einzelnen, sauber getrennten Konfigurationen verweist und diese einbindet.

Außerdem benutze ich Nimbus Note als Notizbuch für meine Konfigurationen. Hier kann ich auch Code-Schnippsel und Screenshots einfügen und habe es immer und überall verfügbar.

4. Geräteauswahl und Schnittstellen

Hat man erst einmal mit Home Assistant angefangen, will man alles integrieren, steuern und auslesen können. Darum ist es wichtig, dass man vor der Anschaffung neuer Geräte erst einmal recherchiert, ob schon jemand geschafft hat, dieses in Home Assistant zu integrieren oder es gar eine offizielle Integration dafür gibt.

ZigBee Bewegungsmelder im Vergleich

ZigBee Bewegungsmelder von Philips, Aqara und Lidl

Viele Geräte haben unterschiedliche Hersteller und Namen, arbeiten aber trotzdem auf derselben technischen Grundlage. Das Philips Hue System basiert auf dem ZigBee-Protokoll, das auch von Lidl’s Silvercrest Smarthome-Geräten oder IKEA’s Tradfri eingesetzt wird. Auch die Xiaomi Aqara Sensoren arbeiten damit. Hat man jedoch nur die offizielle Philips Bridge im Einsatz, lassen sich die Fremdhersteller oft nicht nutzen.

ZigBee Netz mit ConBee/DeConz

Abhilfe schafft hier z. B. der Conbee II Stick oder der Weg über die ZHA Integration und einen Sonoff Zigbee 3.0 Dongle Plus. Viele günstige Wifi-Lampen laufen mit dem Tuya-System und können darüber in Home Assistant eingebunden werden.

Saugroboter, E-Autos, Heizungen, Wärmepumpen und Wallboxen oder PV-Wechselrichter, will man doch mit Home Assistant steuern und überwachen. Also besser vor dem Kauf prüfen, ob das entsprechende Gerät auch eine API und Schnittstelle zur Verfügung stellt, die man mit HA nutzen kann.

5. Nabu Casa Cloud oder besser nicht?

Nabu Casa ist ein Unternehmen, das Home Assistant unterstützt. Diese bieten auch eine kostenpflichtige Cloud-Lösung an, welche die Anbindung von Alexa und Google Assistant zur Sprachsteuerung- und Ausgabe sehr vereinfacht und einen geschützten Fernzugriff auf Home Assistant ermöglicht. Das kostet derzeit $ 6,50 pro Monat oder $65,00 pro Jahr, wobei man damit auch die Entwicklung von Home Assistant unterstützt.

Preiserhöhung für Home Assistant Cloud

Home Assistant mit Alexa steuern

Nabu Casu kämpft aber immer wieder mit Problemen hinsichtlich Geschwindigkeit und Verfügbarkeit – gerade bei der Alexa-Anbindung, was natürlich auch an der großen Beliebtheit und steigenden Nutzerbasis von HA liegt. Bei uns macht die Sprachsteuerung einen Großteil unserer Interaktion mit unserem Smarthome aus, sodass dies ein sehr kritischer Teil der Funktionalität ist.

Ich habe mich daher Anfang des Jahres dazu entschieden, auf Nabu Casa zu verzichten und die Alexa-Anbindung selbst in die Hand zu nehmen. Das ist einmalig etwas Aufwand, aber auch für Einsteiger machbar. Belohnt wird man jedoch mit einer sehr viel besseren Reaktionszeit bei Sprachein- und Ausgaben.

Die manuelle Einrichtung von Alexa in Home Assistant habe ich hier beschrieben: Home Assistant und Amazon Alexa ohne Nabu Casa: Schneller und zuverlässiger

Um den Fernzugriff abzusichern, braucht es einen (kostenlosen) Cloudflare-Account, einen NGINX-Reverse-Proxy sowie Netzwerk-Erfahrung. Dazu werde ich demnächst einen Beitrag veröffentlichen.

Wer es einfach haben möchte, geht erst einmal über Nabu Casa. Jedoch sollte man hier die Entitäten und Funktionen manuell definieren, damit nicht jede Entität zu Alexa synchronisiert wird. Hierzu habe ich diesen Beitrag: Home Assistant: Entitäten sauber in Amazon Alexa integrieren (nachbelichtet.com)

6. Vor dem Update Changelog lesen!

Home Assistant gehört zu den 10 größten Open-Source-Projekten auf Github. Über 1900 Entwickler arbeiten am Programmkern und noch einmal 63.000 Entwickler sorgen für Erweiterungen und Add-Ons. Damit legt HA eine unglaubliche Geschwindigkeit an den Tag und veröffentlicht oft 6 Core-Updates pro Monat.

Da Home Assistant aber noch immer ein sehr junges Projekt ist, werden manche Funktionen über Bord geworfen oder umgebaut. Im Change-Log wird von “Braking Changes” gesprochen und genau diese sollte man vor jedem Update lesen, ob nicht eine Funktion dabei ist, die man selbst im Einsatz hat. Andernfalls wundert man sich vielleicht, warum etwas nach dem Update nicht mehr funktioniert. An dieser Stelle hilft dann auch wieder Tipp #3 aus diesem Beitrag.

7. Kann man mit Home Assistant Heizkosten sparen?

Klare Antwort: Jein! An allen Ecken und Enden kann man momentan lesen, dass man mit intelligenter Steuerung Heizkosten sparen kann. Vor wenigen Tage gab es sogar eine Schlagzeile, dass elektronische Thermostate in Mietwohnungen Pflicht werden sollen.

LCN Glastaster mit Verbrauchsdaten

Das Absenken und spätere Anheben der Raumtemperatur sind aber wenig zielführend und kann sogar für einen Mehrverbrauch sorgen. Zudem verbrauchen Sensoren, Aktoren und Steuerung selbst Strom. So ist die Einzelraumregelung (ERR) der Heizung in modernen Häusern überflüssig, wenngleich zunächst verpflichtend (man kann sich davon befreien lassen).

Die typischen Stellantriebe verbrauchen etwa 2 Watt pro Ventil. Wir haben auf 180 qm Fußbodenheizung mit 25 Heizkreisen. Machen alle Ventile auf, werden also alleine dafür 50 Watt Strom verbraucht. Man hat hier die Wahl zwischen NC (Normal closed, stromlos geschlossen) und NO (Normal open, stromlos offen). In unserer Gegend sind hier schon einmal NO-Antriebe sinnvoller, da die Heizungsventile übers Jahr öfter offen als geschlossen sind.

Hinzu kommen die Aktoren, welche die Ventile ansteuern, elektronische Temperatursensoren für jeden Raum samt Elektronik und eben der Smarthome-Server. Für die Aktoren/Elektronik sind das optimistisch 10 Watt. Rechnen wir mit einer Heizperiode von 210 Tagen und 12 Stunden Heizdauer pro Tag, kommen wir auf 126 kWh Strom für die Ventile und 87,6 kWh für die Ansteuerung (diese muss ganzjährig laufen), also rund 214 kWh. Bei 0,35 € pro kWh sind das bereits 74,90 Euro pro Jahr nur für die Steuerung. Den Home Assistant Server rechnen wir nicht mit, denn wir wollen ja auch andere Dinge steuern.

Was man stattdessen tun sollte, ist der perfekte hydraulische Abgleich der Heizung. Dabei hat mir Home Assistant und sehr geholfen, denn ich habe nicht nur die Daten meiner Heizung inkl. Gasverbrauch über 24 Monate, sondern auch Raum- und Außentemperaturen protokolliert. Damit konnte ich nach und nach den Durchfluss meiner Heizkreise so optimieren, dass ohne ERR gleiche Raumtemperaturen herrschen und solare Einträge durch Sonnenschein auf den Fußboden nicht durch Ventile davon abgehalten werden, im kompletten Haus genutzt zu werden. Die Heizung taktet nicht unnötig und seit dem Einzug 2018 und der Einstellung des Heizungsbauers, konnten wir den Verbrauch um über 30 % senken.

Lange Anwort: Ja, Home Assistant kann beim Energiesparen helfen – aber eher indirekt, weil man darüber einen sehr viel tieferen Einblick und eine bessere Übersicht über Temperaturverläufe und die Entwicklung hat. Hier hat sich bei uns dann auch gezeigt, dass eine Absenkung von mehr als 2 Grad zu einem höheren Verbrauch führt.

8. Stromverbrauch mit Home Assistant messen und optimieren

Der Stromverbrauch lässt sich in Home Assistant mittlerweile perfekt nachverfolgen – sowohl beim Netzbezug als auch bei der Einspeisung. Wer kein Smartmeter hat, das sich über eine Schnittstelle auslesen lässt, kann auf den günstigen Shelly 3EM zurückgreifen. Dessen Möglichkeiten habe ich hier beschrieben: Stromverbrauch mit dem Shelly 3EM und Home Assistant messen

Bastellösungen, wie Impulszähler am Ferrariszähler (einen Bauvorschlag hatte ich hier einmal: So funktioniert der TCRT5000 mit ESPeasy als Pulse Counter (nachbelichtet.com)) lohnen sich hier nicht mehr und sind auch zu ungenau. Mit einer schlauen Steuerung von Verbrauchern nach Anwesenheit und Tageszeit lässt sich einiges an Strom sparen, wenn man z. B. die vielen Standby-Verbraucher vom Netz nimmt oder Rechner per Home Assistant schlafen schickt und aufweckt.

9. Bastelt nicht mit Netzspannung!

Home Assistant und die vielen günstigen Geräte verleiten dazu, auch Geräte anzuschließen, die mit Netzspannung betrieben werden. Als Laie ist das lebensgefährlich und ich verliert damit im ungünstigsten Fall auch euren Versicherungsschutz.

Wenn man hier keine Erfahrung und Ausbildung hat, helfen auch Youtube-Tutorials nichts, da man gar nicht bewerten kann, ob der Youtuber selbst Ahnung davon hat. Dort und in divesen Foren sind oft haarsträubende Sachen zu sehen – gerade auch aus den USA. Baut euch keinesfalls Geräte mit einfachen Relais-Platinen und Breadboards für den Betrieb am Stromnetz und werkelt auf gar keinen Fall im Stromverteiler herum!

Holt euch professionelle Hilfe, denn das ist bezahlbar – ein Menschenleben nicht.

10. Machen, was sinnvoll ist und hilft

Überlege dir, was du erreichen willst und was dazu notwendig ist. Solle es der Komfortgewinn sein, dass du alle Lichter und Verbraucher zentral ausschalten und das Garagentor schließen kannst, wenn es ins Bett geht? Oder eine Szene, die den Fernsehabend mit der passenden Lichtstimmung, Programm und geschlossenen Jalousien einleitet?

Home Assistant Grundlagen mit der Kaffeemaschine und Alexa

Oder vielleicht zusätzliche Sicherheit durch Tür- und Fenstersensoren, intelligenter Objekterkennung und elektronischen Schlössern? Machbar ist fast alles. Konzentriere dich zunächst aber auf die Dinge, die das Leben auf einfache Weise erleichtern. Eine meiner meistgenutzten Automatisierungen schaltet bei Bedarf die Lampen im Büro ein, fährt dort die Raffstores je nach Sonnenstand automatisch rauf und runter, damit es nicht blendet und startet Radio und Rechner am Morgen. Auf Zuruf wird die Kaffeemaschine aktiviert und ich erfahre auch, wann ich sie reinigen muss.

Fazit

Home Assistant ist meiner Meinung und nach Ausflügen zu diversen anderen Lösungen wie Symcon, OpenHAB oder ioBroker, konkurrenzlos. Die schiere Anzahl an Entwicklern, Integrationen und unterstützten Geräten, macht die Open-Source-Lösung einzigartig.

In den zwei Jahren, in denen ich nun ein ziemlich komplexes und immer weiter wachsendes System betreibe, hatte ich keine kritischen Ausfälle und Hänger. Home Assistant ist nach einer gewissen Einarbeitungszeit recht einfach und komfortabel zu konfigurieren. Man lernt natürlich ständig dazu und es hat ein gewisses Suchtpotenzial. Gleichzeitig arbeiten die Entwickler an Vereinfachungen und dass man immer mehr auf YAML-Code verzichten kann.

Ventilschacht für die Gardena-Bewässerung

Aktuell arbeite ich an der Integration der Gartenbewässerung, für die ich eine eigene Steuerung für die 24 Volt Ventile entwickelt habe.

Der Bewässerungs-Controller in KiCAD

Hier fehlt nun noch eine Platine und vielleicht werde ich das auch als Bausatz zum Kauf anbieten.

  • 6 Min. Lesezeit

Home Assistant und Amazon Alexa ohne Nabu Casa: Schneller und zuverlässiger

Wir haben in fast jedem Raum einen Amazon Echo stehen, über den wir nicht nur Radio und Musik hören, sondern auch viele Dinge im Haus steuern können. Home Assistant und die kostenpflichtige, jedoch einfach Anbindung des Sprachassistenten über die Nabu Casa Cloud, machen es in kürzester Zeit möglich. Nabu Casa ist eine Firma, die aus den Home Assistant Machern entstanden ist. Für 5 Euro pro Monat erhält man darüber nicht nur eine einfache Möglichkeit, Sprachassistenten wie Alexa oder den Google Assistant anzubinden, sondern auch einen abgesicherten Fernzugang. Zusätzlich unterstützt man damit die Weiterentwicklung von Home Assistant, was eine hervorragende Sache ist.

So sah bislang meine Liste an Geräten für Alexa über die Nabu Casa Cloud aus

Seit einiger Zeit gibt es jedoch Probleme mit der Anbindung der Sprachassistenten über Nabu Casa. Offenbar hat der große Erfolg von HA dafür gesorgt, dass der Dienst, der Home Assistant und die Assistenten ohne großen Konfigurationsaufwand mit den entsprechenden Anbietern verbindet, sehr langsam und unzuverlässig geworden ist. Möchte man einen Befehl ausführen, dauert es oft mehrere Sekunden. Zusätzlich quittiert Alexa den Befehl damit, dass das entsprechende Gerät nicht reagieren würde. Kurze Zeit darauf wird der Befehl trotzdem ausgeführt.

Das ist nicht nur nervig, sondern reduziert den WAF (Womens Acceptance Factor) deutlich. Da wir diese Dienste jedoch regelmäßig nutzen, weil wir auch beide im Homeoffice arbeiten, habe ich meine Alexa-Anbindung umgestellt.

NGINX Proxy Manager für den externen Zugriff auf Home Assistant

Eine vollständige Anleitung dazu gibt es bei Home Assistant und auch dieses Video hilft dabei, die recht komplexe Konfiguration zu meistern.

Man benötigt dazu einen kostenlosen Amazon Developer-Account, um auf die AWS-Dienste zugreifen zu können. Außerdem muss Home Assistant per SSL über den Port 443 und einer festen Adresse erreichbar sein. Wir haben hier eine feste IP-Adresse für unseren DSL-Anschluss, die ich im DNS meines Domain-Providers über eine Subdomain auflöse. Auf meinem Server läuft vor Homeassistant ein Docker-Container mit einem NGINX-Proxy-Server, der die Verwaltung der Zertifikate und auch einiges an Absicherung übernimmt.

Home Assistant selbst bietet im Supervisor ähnliche Funktionen und auch DuckDNS kann hier genutzt werden, falls man eine dynamische IP-Adresse nach außen hat. Die Erreichbarkeit von außen samt gültigen SSL-Zertifikaten muss vor der weiteren Einrichtung funktionieren und getestet sein.

Addons für NGINX, Let’s Encrypt und Duck DNS im Addon Store von Home Assistant

Ich habe für die komplette Einrichtung etwa 45 Minuten benötigt. Man erstellt in diesem Zusammenhang auch einen eigenen Alexa Skill, der die zukünftige Steuerung übernimmt. Das ist insgesamt sehr interessant, weil man damit auch ein bisschen Einblick in die Grundlagen der Skill-Entwicklung für Alexa bekommt.

Hat man alles getestet, fällt die bisherige Konfiguration der Geräte und Entitäten, die zu Alexa synchronisiert und dort erreichbar sein sollen weg und muss durch eine Erweiterung der HA configuration.yaml ersetzt werden. Damit kann man allerdings auch sehr viel granularer und gezielter einstellen, welche Dienste mit welchem Namen und Sprachbefehl mit Alexa genutzt werden können.

Der eigene Alexa Skill zur Steuerung von Home Assistant

Ich habe diese Konfiguration in eine eigene Datei alexa.yaml ausgelagert und diese in meiner configuration.yaml eingebunden. Dabei habe ich zunächst alle Domains, also Lampen, Schalter, Sensoren etc. mit exclude_domains: von Alexa ausgeschlossen, um sie dann gezielt per include_entities einzubinden.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
smart_home:
  locale: de-DE
  client_id: amzn1.application-oa2-client.40cd01
  client_secret: 062e0ca88560015b9ee
  filter:
    exclude_domains:
      - automation
      - alert
      - input_boolean
      - media_player
      - binary_sensor
      - switch
      - camera
      - light
      - automation
      - script
      - sensor
      - device-tracker
      - lock
      - fan
      - remote
      - alarm_control_panel
      - input_select
      - input_number
      - person
      - sun
      - climate 
      - weather
      - zone
      - persistent_notification
      - air_quality

    include_entities:

      - group.schlafzimmerlicht
      - group.wohnzimmerlicht
      - group.kuechenlicht
      - group.buerolicht        
      - group.studiolicht
      - group.badlicht
      - group.werkstattlicht
      - group.aussenlicht

      # Lampen Küche
      - light.kuchenlicht
      - light.kuche_insel
      - light.kuche_haupt
      - light.kuche_fenster
      - light.kuche_theke

Mit der entity_config lässt sich dann auch bestimmen, wie die Entität in Alexa angesprochen werden soll – ganz unabhängig vom Namen der Entität in Home Assistant:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
  entity_config:

    light.burolicht:
      name: Bürolicht
      description: Büro Beleuchtung
      display_categories: LIGHT

    light.buro_markus:
      name: Büro Markus
      description: Büro Beleuchtung Markus
      display_categories: LIGHT

    light.wz_leselicht:
      name: Leselicht
      description: Leselicht Wohnzimmer
      display_categories: LIGHT

    light.wz_spots:
      name: Deckenspots
      description: Spots Wohnzimmerdecke
      display_categories: LIGHT

    light.kuche_theke:
      name: Theke
      description: Licht Küchentheke
      display_categories: LIGHT

Die display_categories sorgen dafür, dass die Entität einer Geräteklasse in Alexa (z. B. LIGHT, COVER, SWITCH, LOCK etc.) zugeordnet wird, was wiederum für die Übersicht gut ist. Dieser Teil der Konfiguration nimmt fast noch mehr Zeit in Anspruch, als die eigentliche Konfiguration – lohnt sich aber!

Da man für die manuelle Anbindung von Alexa ohnehin einen sicheren Zugang von außen auf HA benötigt, erübrigt sich damit auch der von Nabu Casa angebotene Dienst dafür.

Alles so schnell auf einmal!

Tatsächlich war ich überrascht, wie schnell die Befehle nun ausgeführt werden, ohne dass sie den Umweg über einen (derzeit überlasteten) Drittserver gehen müssen. Auch als bei mir noch Symcon im Einsatz war, lief die Kommunikation über den Service von Symcon ab. Ich hatte also noch nie den direkten Vergleich. Aber auch andere Dienste wie Philips Hue etc. waren langsamer als diese Lösung.

Die Befehle werden sofort ausgeführt, ohne dass man dabei eine merkliche Verzögerung beobachten könnte und werden brav mit “PALIM!” quittiert. Seitdem gab es keine Meldungen mehr, dass ein Gerät nicht reagieren würde.

Flash Briefings für Alexa

So euphoriert, habe ich mich auch gleich noch an ein eigenes Flash Briefing für Alexa gemacht, das mir auf die Frage “Alexa, was gibt es Neues?” eine Übersicht über wichtige Werte und Zustände liefert. So etwa welche Außentemperatur gerade herrscht, ob es regnet und wie der Ladestand unseres Tesla Model 3 (unser McFly) ist:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
flash_briefings:
  password: xxxxxxxx
  wetter:
    title: Wie ist das Wetter?
    text: >
      Momentan hat es außen {{ states("sensor.wih_temp_aussen") }} Grad
      {% if is_state('binary_sensor.wih_regen', 'on')  %}
        und es regnet.
      {% else %}
        und es ist trocken. 
      {% endif %}
        Die gefühlte Temperatur beträgt {{ states("sensor.weewx_gefuehlte_temperatur")}} Grad.

      {% if is_state('binary_sensor.garage_geschlossen', 'on')  %}
        Das Garagentor ist geschlossen.
      {% else %}
        Das Garagentor ist offen.
      {% endif %}

      {% if is_state('binary_sensor.werkstattfenster', 'off')  %}
        Das Werkstattfenster ist geschlossen.
      {% else %}
        Das Werkstattfenster ist offen.
      {% endif %}

      {% if is_state('switch.studio_sd_rack', 'on')  %}
        Der Strom im Studio ist an.      
          {% if is_state('switch.nachbelichtet', 'on')  %}
            und der PC im Studio ist noch an.
          {% endif %}
      {% endif %}

      {% if is_state('binary_sensor.haustur', 'off')  %}
        Die Haustüre ist geschlossen.
      {% else %}
        Die Haustüre ist offen.
      {% endif %}

        McFly hat {{states("sensor.mcfly_battery_sensor")}} Kilowatt geladen und seine Reichweite liegt bei {{states("sensor.mcfly_range_sensor")}} Kilometern.
        Der Gasverbrauch lag heute bisher bei {{states("sensor.gasverbrauch_kwh")}} Kilowattstunden und es werden gerade {{states("sensor.strom_stats_w")}} Watt Strom verbraucht.

Für diesen Bereich habe ich noch jede Menge Ideen und ich werde ihn noch so verfeinern, dass bestimmte Zustände nur angesagt werden, wenn eine Handlung erforderlich ist, z. B. “Bitte das Werkstattfenster schließen!”. Auch kommen hier alle Fenster- und Türsensoren dazu.

Fazit

Die direkte Anbindung von Alexa an Home Assistant ist eine nicht ganz triviale Sache und erfordert einiges an Zeit und Muse. Belohnt wird man aber mit einem sehr schnellen System. Die Home Assistant Entwickler bei Nabu Casa sind laut Reddit bereits an einer Lösung für das Problem mit ihrer Cloud dran. Diese wird aber wohl erst Ende Februar 22 fertig. Ich werde jedoch auf jeden Fall bei meiner individuellen Anbindung bleiben. Das hat zwei Gründe:

  • Sie ist schneller, weil ein weiterer Server dazwischen wegfällt
  • und sie ist zuverlässiger, weil ein weiterer Server dazwischen wegfällt.

Es gab bei Nabu Casa auch schon ein paar Ausfälle, die dann eben alle Homeassistant-Anwender betreffen, die auf diese Lösung setzen. Die 5 Euro pro Monat bekommen sie weiterhin, weil ich damit die Weiterentwicklung von Home Assistant unterstützen möchte.

  • 8 Min. Lesezeit

LED-Streifen mit WLED ansteuern und in Home Assistant einbinden

Ich wollte den Tastaturauszug meines ZAOR Miza XL Studiotischs eine Beleuchtung, welche die Geräte gut ausleuchtet und auch ein wenig schick aussieht. Zwar kann man mit ESPHome, das ein Teil von Home Assistant ist und den sehr einfachen Einsatz von ESP-Mikrocontrollern erlaubt, auch LED-Strips ansteuern, aber mit WLED gibt es ungleich mehr Möglichkeiten, Effekte und noch einige andere Funktionen. So können WLED-Geräte auch mit einer Philips Hue Bridge verbunden und angesteuert werden.

Die Teile

Da ich für meine Aufgabe keine “echte” weiße Lichtfarbe benötigte, habe ich mich für die günstigen WS2812 LED-Streifen entschieden, welche ich eigentlich immer vorrätige habe. Einen 5 Meter langen Streifen mit 150 LEDs bekommt ab etwa 22 Euro.

Diese Streifen lassen sich nach jeder LED, also etwa alle 3,3 cm trennen und so auf das gewünschte Maß bringen. Der Studiotisch ist beim Auszug 150 cm breit, also konnte ich den Streifen so zuschneiden, dass 45 LEDs übrig blieben – mehr als genug. Jedes WS2812 LED besteht eigentlich aus 3 kleinen einzelnen LEDs in rot, grün und blau, die mit einer Ansteuerelektronik in einem Gehäuse vereint sind. Werden alle 3 LEDs gleich hell angesteuert, entsteht ein weißes Mischlicht.

Makro-Aufnahme eines WS2812b LEDs

Wie viel Strom benötigen die WS2812 LEDs wirklich?

Zu den LED Strips gibt es jede Menge Berichte und Aussagen zur Stromaufnahme. Meist wird von 60 mA pro LED ausgegangen, was bei weißem Licht und 45 LEDs einen Strom von 2,7 Ampere bedeuten würde. Ich habe verschiedene Messungen gemacht und bei meinem Chinly Strip benötigen die 45 LEDs bei voller Ansteuerung gerade mal 1,1 Ampere.

45 LEDs benötigen 1,1 Ampere inkl. der 30 mA für den Wemos D1 Mini

Damit kommen wir auch zum Netzteil. Hier würde ein 5-Volt Netzteil genügen, das 1,5 Ampere liefern kann. Viel einfacher und sehr preiswert bekommt man hingegen 2 Ampere Netzteile. Vielleicht hat man noch ein altes USB-Netzteil von einem Smartphone übrig? Andernfalls bekommt man entsprechende Netzteile oft für unter 5 Euro.

Als Herzstück habe ich wieder einen Wemos D1 Mini mit ESP8266 Controller eingesetzt. Diese bekommt man schon für unter 5 Euro pro Stück, wenn man gleich ein 3er-Set bestellt. Man benötigt auch einen 470 Ohm (1/4 Watt) Widerstand (können 220 bis 470 Ohm sein, da er nur zur Strombegrenzung und zum Schutz des ESP8266 dient). Die WS2812B LEDs benötigen zur Ansteuerung nur 3,3 Volt, sodass man auf einen Level-Shifter verzichten kann.

CHINLY WS2812B 5m 150leds DC5V einzeln adressierbaren LED-Streifen 5050 RGB SMD 150 Pixel Traumfarbe Wasserdichte IP65 PCB SchwarzCHINLY WS2812B 5m 150leds DC5V einzeln... Jetzt bei Amazon kaufenHJHX Ws2812b LED Streifen, 5m 300LED individuell adressierbare DC5V, SMD5050 RGB Magic Color Programmierbar Led Pixel Streifen Flexible LichterkettHJHX Ws2812b LED Streifen, 5m 300LED individuell... Jetzt bei Amazon kaufenAnpro 50Stk leiterplatte Kit 20Stk PCB Universal Board 5x7 4x6 3x7 2x8CM Double Side Lochrasterplatte Lochrasterplatine Leiterplatte Platine 10 Screw Terminal 20 Kopfleiste, EINWEGAnpro 50Stk leiterplatte Kit 20Stk PCB Universal... Jetzt bei Amazon kaufenERSA RDS80 Digital Lötstation 80W Leistung mit einstellbarer Temperatur 150 – 450 °C inkl. Lötspitze 2,2mm meißelförmig ERSADUR und Standby/SchlaffunktionERSA RDS80 Digital Lötstation 80W Leistung mit... Amazon Prime161,83 EURJetzt bei Amazon kaufenCrimpzange Dupont Stecker Set - Preciva 1550 pcs 2,54 mm Steckverbinder und Crimp Pins, 460 pcs 2,54 mm JST-XH JST Crimpkontakten und Buchsengehäuse, für 0,1-1 mm² (0,1-1 mm² Set)Crimpzange Dupont Stecker Set - Preciva 1550 pcs... Amazon Prime36,99 EURJetzt bei Amazon kaufen

Wichtig ist ein Elektrolytkondensator (Elko), mit 100 bis 1000 µF. Ein 10 Volt Typ genügt. Natürlich geht auch einer mit 35 oder 63 Volt. Damit benötigen sie aber nur unnötig viel Platz. Der Kondensator wird möglichst nahe an der Versorgungsspannung platziert und glättet die Spannung. Das ist gerade bei WLED-Projekten wichtig, da die Lichteffekte enorme Schwankungen bei der Stromaufnahme verursachen können. Die Folge ist, dass die Spannungsversorgung stark schwankt und damit den Mikrocontroller und die LEDs aus dem Tritt bringen kann.

Ein Wort zu solchen Elektronik-Projekten:

Meine Beiträge sind Anregungen zu neuen Projekten und keine Schritt-für-Schritt-Anleitungen, sondern Berichte über meine Projekte. Sie erfordern Grundkenntnisse in den Bereichen Elektrotechnik, Bauteilkunde, Löten, Messtechnik, PC und Programmierung sowie der Fehlersuche. Zudem ist eine Grundausstattung erforderlich, die ein gutes Multimeter, Oszilloskop, Netzteil, Lötkolben, diverses Werkzeug usw. umfasst. Mit diesen Voraussetzungen ausgerüstet, sollten meine Projekte keine Fragen oder Probleme aufwerfen. Scheitert man bereits daran einen Widerstandscode zu lesen, welche Spannungsfestigkeit ein Elko haben sollte usw., rate ich vom Nachbau ab, um Frust zu vermeiden und Geld zu sparen.

Natürlich freue ich mich, wenn meine Leser neue Dinge lernen möchten und auch die Grundlagen der Elektronik kann man lernen. Ich empfehle hier z. B. das Elektronik Kompendium. Startet einfach mit Elektronik Grundlagen.

Eine weitere Möglichkeit sind die vielen Maker Spaces, die es mittlerweile fast überall gibt. Ein Verzeichnis findet ihr hier: Makerspaces, Fablabs und andere Orte der Maker-Community – Maker Faire (maker-faire.de). Hier helfen euch nicht nur kompetente Leute, sondern ihr habt auch Zugriff auf Werkzeug, 3D-Drucker, Messgeräte usw. Damit findet man schnell heraus, ob Elektronikbasteln das geeignete Hobby ist. Ich selbst engagiere mich am StartUplab der Hochschule Hof.

Der Aufbau – Platine, Gehäuse und Anschlüsse

Ich habe die einfache Schaltung auf einem kleinen Perfboard aufgebaut. Der Wemos ist gesockelt, sodass man ihn nicht nur einfach austauschen könnte, sondern auch einen Testlauf ohne Controller machen und erst einmal auf korrekte Verkabelung testen kann.

Die Hohlsteckerbuchse dient der Stromversorgung und gleichzeitig der Befestigung der Platine im 3D-gedrucken Gehäuse. Ich kann hier dieses Hohlstecker-Set empfehlen.

Zur Absicherung des LED-Strips habe ich einen Feinsicherungshalter in die Versorgung des Strips eingebaut und mit einer 800 mA Sicherung abgesichert (mittelträge). Das muss bei so kurzen Strips nicht unbedingt sein, da moderne Netzteile kurzschlussfest sind – aber warum nicht …

Der Strip wird bei mir über einen JST-Stecker angeschlossen. Mit diesem schönen Set samt Crimp-Zange, kann man wunderbar ordentliche Steckverbindungen bauen. Da die Zuleitung zum Strip bei mir sehr kurz ist (10 cm), genügt ein AWG24 Querschnitt (0,25 mm2) vollkommen. Mit etwas Übung im Umgang mit Perfboards ist der Aufbau ist in 15 Minuten geschehen.

Das Gehäuse war in Autodesk Fusion 360 schnell konstruiert. Sehr empfehlenswert ist hier das tolle Tutorial von Mistermaestro auf Youtube. Er erklärt, wie man sehr schnell und einfach zu einem individuellen Gehäuse kommt.

Ich habe das früher auch sehr viel umständlicher gemacht. Mit seinen Tipps braucht man noch nicht einmal Schrauben. Gedruckt habe ich das Gehäuse mit ABS auf meinem Wanhao Duplicator 6.

Die Druckdateien brauche ich euch nicht zur Verfügung stellen, weil das Gehäuse ohnehin nur für meinen speziellen Aufbau passt.

WLED Firmware flashen und Home Assistant

Die WLED-Firmware bekommt ihr bei Github für den jeweils passenden Controller – in meinem Fall den ESP8266. Flashen kann man sie mit dem ESPHome Flasher oder anderen Tools. Eine genaue Anleitung für WLED gibt es auf der offiziellen Homepage des Projekts: Welcome to WLED – WLED Project

Hat man die Firmware erfolgreich geflasht, startet der Controller neu und eröffnet einen WLAN-Access Point. Mit dem Password wled1234 kann man sich mit dem Smartphone oder einem anderen WLAN-fähigen Gerät damit verbinden, den neuen WLED-Controller ins heimische WLAN einbinden und ihm einen Namen geben. Über dessen IP oder seinen Namen kann man auf die Weboberfläche des WLED-Controllers zugreifen:

Wer es noch komfortabler mag, lädt sich die WLED App für Android oder iOS auf Smartphone oder Tablet. Diese durchsucht das WLAN auch automatisch nach neuen Controllern und zeigt diese an.

WLED Android App

Besonders interessant an den WLED-Geräten sind nicht die vielen Effekte, sondern die Möglichkeit, einen LED-Strip in mehrere Segmente aufteilen und diese völlig individuell ansteuern zu können. So kann etwa LED 1-20 hell weiß leuchten, während 21-40 einen Effekt durchlaufen und LED 40-50 nicht leuchten. WLED beinhaltet auch einen Timer sowie eine Nachtlicht-Funktion. Mit den Playlists lassen sich vorher definierte Presets automatisch durchlaufen.

Wer eine Philips Hue Bridge im Einsatz hat, kann WLED-Controller auch damit verbinden. Mit einer alternativen Bridge, wie dem Conbee II Stick, geht das leider nicht, da WLED auf WLAN-Basis und nicht per ZigBee-Protokoll kommuniziert.

WLED-Geräte können auch mit Amazon Alexa verbunden und gesteuert werden – ganz ohne zusätzliche Konfiguration und auch eine IR-Fernbedienung kann integriert werden. Außerdem können zwei Taster mit kurz, lang und Doppelklick-Funktion abgefragt und für Steuerungszwecke genutzt werden und auch ein Ausgang, um etwa ein Relais zu steuern, steht zur Verfügung.

WLED in Home Assistant

In Home Assistant bindet man WLED-Geräte über die offizielle Integration dafür ein. Die gewünschten Lichteffekte und Einstellungen legt man in der WLED-Oberfläche als Presets ab, die sich dann in Home Assistant aufrufen und natürlich auch automatisieren lassen. Auch die Segmente können von Home Assistant aus angesteuert werden.

WLED Beleuchtung mit zwei Segmenten – ein Teil rot, einer weiß

WLED ist eine tolle Möglichkeit nicht nur LED-Streifen einfach und effektvoll anzusteuern. Man kann damit auch eigene Lampen im Stil der Philips Hue Leuchten bauen.