Zum Inhalt

Alle Artikel# Blog

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.

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:

  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:

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.

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.

Stromverbrauch mit dem Shelly 3EM und Home Assistant messen

Von unserem Stromversorger kam im Oktober eine Mitteilung zur Strompreisanpassung. Von derzeit 28,6 ct./kWh sollte es ab dem 01.12.21 aufsage und schreibe 42,52 ct./kWh gehen. Die Strommärkte spielen gerade verrückt und manch Anbieter hatte sich wohl etwas verkalkuliert. Der erste Schritt ist natürlich, sein Sonderkündigungsrecht zu nutzen und einen günstigeren Anbieter zu finden.

Der zweite Schritt besteht darin, Einsparpotenzial zu finden. Mit einem normalen Ferraris-Zähler ist es mühsam bis unmöglich, Verbraucher gezielt aufzuspüren – wer will schon die drehende Scheibe beobachten und die Zeit für 2-3 Umdrehungen stoppen? Auch DIY-Lösungen, wie ich sie hier vorgestellt habe, sind nicht genau genug, da sie auch nur die Zählerscheibe beobachten. Smartmeter sind zwar immer häufiger anzutreffen, allerdings ist der Zugriff darauf, um exakte Verbrauchsdaten auszulesen, oft nicht möglich.

Stromwandler auf den Zuleitungen im Verteiler. Der Pfeil muss in Richtung Versorger zeigen.

Mit dem Shelly 3EM bekommt man hingegen eine recht preiswerte Lösung, die mit wenig Aufwand sehr genaue Einblicke in die Verbräuche ermöglicht. Der Shelly 3EM besteht aus einem kleinen Modul, das auf die Hutschiene im Verteilerschrank gesteckt wird und nur eine Teilungseinheit Platz beansprucht. Der 3EM kann den Strom von 3 Phasen messen und nutzt dazu kontaktlose Stromwandler, die über die 3 Hauptzuleitungen geklappt werden. Die Anschlusskabel werden einfach am 3EM angesteckt, sind mit etwa 40 cm aber nicht sonderlich lang, sodass man hier vorher testen sollte, wo man das 3EM Modul montieren kann.

WICHTIGER HINWEIS: Arbeiten an Netzspannung sind lebensgefährlich und dürfen nur von Elektrofachkräften durchgeführt werden, weshalb es hier keine Hinweise, Hilfe und Anleitung zum Einbau gibt. Ihr gefährdet damit nicht nur euer Leben, sondern unter Umständen auch euren Versicherungsschutz. Wendet euch an einen Fachmann und lasst euch das Gerät fachmännisch in Betrieb nehmen!

Shelly 3EM Modul im Verteiler neben den LCN-Modulen

Zur Erfassung der Spannung der 3 Phasen, werden diese samt Neutralleiter entsprechenden am Shelly 3EM angeschlossen, der damit auch gleich mit Strom versorgt wird. Die Installation ist in weniger als 15 Minuten erledigt. Eine grüne LED zeigt die Betriebsbereitschaft und der 3EM öffnet einen WLAN-Access-Point. Mit der kostenlosen Shelly APP kann man den 3EM einrichten und ins heimische WLAN-Netz bringen.

Shelly Android App

Ist das geschehen, wird in der App schon der 3EM sowie aktuelle Verbrauchsdaten angezeigt. Jede Phase wird mit Spannung, aktuellem Strom und Leistungsfaktor dargestellt. Daraus wird auch die aktuelle Leistung in Watt und die Leistungsaufnahme aller 3 Phasen summiert dargestellt. Erstellt man ein Shelly-Konto, werden die Verbrauchsdaten auch in der Shelly-Cloud aufgezeichnet und können über lange Zeiträume dargestellt und ausgewertet werden. Über den Webbrowser und die IP-Adresse des 3EM kann man ebenfalls auf die Daten und Einstellungen des Shelly 3EM zugreifen.

Shelly 3EM in der Browseransicht

Der Shelly 3EM hat auch ein Relais eingebaut, mit dem sich Verbraucher bis 10 A Stromaufnahme oder ein Schütz schalten lassen. Die App sieht dazu auch programmierbare Schaltzeiten vor. Wer eine Photovoltaik-Anlage oder ähnliche Stromerzeuger betreibt, kann sich mit dem 3EM auch den erzeugten Strom messen und anzeigen lassen.

AngebotBrennenstuhl Primera-Line Energiemessgerät PM 231 E (Strommessgerät/Stromzähler Steckdose mit erhöhtem Berührungsschutz, Energiekostengerät mit 2 individuell einstellbaren Stromtarifen)Brennenstuhl Primera-Line Energiemessgerät PM 231 E (Strommessgerät/Stromzähler Steckdose mit erhöhtem Berührungsschutz, Energiekostengerät mit 2 individuell einstellbaren Stromtarifen)

  • Energiekostenmessgerät zur Messung von Spannung, Frequenz, Strom, Leistungsfaktor und Leistung
  • Stromzähler mit erhöhtem Berührungsschutz zur Berechnung des gesamten Energieverbrauchs und der Energiekosten – ideal zur Reduzierung Ihrer Stromkosten
  • Energiemessgerät mit 2 individuell einstellbaren Stromtarifen (Tag + Nacht)
  • Das Strommessgerät zeigt die Messzeit in Stunden und Minuten an
  • Primera-Line Energiemessgerät inkl. 3 Batterien LR44 zur Datenspeicherung bei Stromausfall 11,24 EUR −11% 9,98 EUR Amazon PrimeJetzt bei Amazon kaufenEve Energy (HomeKit) - Smarte Steckdose, misst Stromverbrauch, schaltet Geräte EIN/aus, Siri-Sprachsteuerung, Zeitschaltuhr, Fernzugriff, Keine Bridge nötig, TÜV-Zertifiziert, Thread, AppleEve Energy (HomeKit) – Smarte Steckdose, misst Stromverbrauch, schaltet Geräte EIN/aus, Siri-Sprachsteuerung, Zeitschaltuhr, Fernzugriff, Keine Bridge nötig, TÜV-Zertifiziert, Thread, Apple

  • Schalten Sie Lichter und Elektrogeräte über die App (iPhone, iPad, Mac), Siri oder die eingebaute Taste ein und aus

  • Richten Sie mühelos Programme ein, um Geräte automatisch ein- oder auszuschalten — unabhängig von Ihrem iPhone und Heimnetzwerk
  • Steuern Sie Ihre Geräte remote oder basierend auf Ihrer Präsenz über einen Hub (HomePod, HomePod mini oder Apple TV)
  • Energieeinsparung: Stromverbrauch beobachten, Kostenprognose auf Basis des persönlichen Strompreises erhalten und Geräte im unnötigen Standby-Modus ausschalten
  • Blitzschnell einsatzbereit dank schneller und einfacher Einrichtung ohne Gateway oder andere Zwischenbox; unterstützt Bluetooth und Thread; TÜV-zertifiziert Jetzt bei Amazon kaufenAngebotFRITZ!DECT 200 - Intelligente Steckdose für das Heimnetz, steuerbar zum Energie sparen, deutschsprachige VersionFRITZ!DECT 200 – Intelligente Steckdose für das Heimnetz, steuerbar zum Energie sparen, deutschsprachige Version

  • Intelligente Steckdose für Smart Home, schaltet automatisch oder manuell die Stromzufuhr angeschlossener Geräte (bis 2.300 Watt)

  • Energie sparen durch individuelles Schalten: einmalig, täglich, wochentäglich, rhythmisch, zufällig, je nach Zeitpunkt von Sonnenauf- und -untergang oder per Google-Kalender
  • Steuerbar per FRITZ!Fon via DECT, per PC, Smartphone oder Tablet über die Benutzeroberfläche der FRITZ!Box oder MyFRITZ!App
  • Misst den Energieverbrauch und zeigt Details zu Leistung, Verbrauch, Stromkosten sowie zur CO2-Bilanz und versendet diese auf Wunsch per Push-Mail
  • Aus FRITZ!DECT 200 wird FRITZ!Smart Energy 200: Hierbei handelt es sich nur um eine Produktumbenennung. Technisch sind die Produkte identisch, lediglich Name und Produktgehäuse können variieren. 42,77 EUR −6% 40,00 EURJetzt bei Amazon kaufenShelly 3EM TI Messgerät, 3 x 120 AShelly 3EM TI Messgerät, 3 x 120 A

  • Drei unabhängige Messkanäle bis zu 120 A, jeweils eine Schützkontrolle (oder Last bis zu 10 A).

  • 365 Tage interner Speicher, falls kein WLAN verfügbar ist.
  • Spannungsmessung und Alarmberichte konfigurierbar.
  • Inklusive 3 Spannungswandler, 120 A. Jetzt bei Amazon kaufen

Shelly 3EM mit Home Assistant nutzen

Hat man ohnehin Homeassistant im Einsatz, kann man den Verbrauch auch ganz praktisch darin anzeigen lassen und auswerten. Dazu ist dann keine Shelly-Cloud notwendig. Homeassistant besitzt bereits eine Integration für Shelly-Geräte. Hat man diese aktiviert, wird der 3EM automatisch gefunden und kann aktiviert werden.

Einbindung der Shelly-3EM-Entitäten im Energie-Dashboard

Homeassistant besitzt seit der Version 2021.8 ein Energie-Dashboard, das Auskunft über verbrauchte, als auch erzeugte Energie gibt. Die notwendigen Entitäten dazu legt die Shelly Integration automatisch an und man muss nur die Energy-Entitäten der 3 Phasen des Shelly auswählen.

Die Entitäten des Shelly 3EM in einer Homeassistant Karte

Hat man einen Stromerzeuger wie eine PV-Anlage (oder ein einfaches Balkonkraftwerk) im Einsatz, kann man die Energy-Return-Entitäten nutzen und bekommt damit auch die gewonnene Energie angezeigt und ausgewertet.

Auswertung der Shelly-Daten im Homeassistant Energie-Dashboard

Natürlich liegen auch Spannung, Strom, Leistungsfaktor und aktuelle Leistung pro Phase als Entitäten bereit und können angezeigt und ausgewertet werden. So sieht man hier schön, wenn Verbraucher ein- und ausschalten. Im Beispiel kann man die kurzen Aufheizungen unseres Quooker-Heißwasserhahns deutlich erkennen – und wie er über Nacht ausgeschaltet wird.

In der Verlaufsansicht von Homeassistant kann man dann auch längere Zeiträume detailliert anzeigen lassen. Im Screenshot erkennt man z. B. die kleinen Treppen, die auf die Kühlgefrierkombi zurückzuführen sind, welche an Phase 2 angeschlossen ist.

Der Kühlschrank ist eindeutig in dieser Auswertung der Phase 2 über 3 Tage zu erkennen

Die Shelly-Integration stellt keine Entität für den gesamten aktuellen Verbrauch zur Verfügung. Einen Sensor dafür kann man aber ganz einfach selbst erstellen. Dazu legt man eine neue Sensor-Entität, welche die aktuelle Leistung aller 3 Phasen summiert:

1
2
3
4
5
6
7
  - platform: template
    sensors:
      verbrauch_total:
        friendly_name: 'Verbrauch total'
        unit_of_measurement: "W"
        value_template: >-
          {{ (states('sensor.shellyem3_xyz_channel_a_power')|float + states('sensor.shellyem3_xyz_channel_b_power')|float + states('sensor.shellyem3_xyz_channel_c_power')|float)|round(0) }}

Die neue Entität verbrauch_total wird mit round(0) ohne Nachkommastellen in Watt ausgegeben.

Strategien zur Optimierung des Stromverbrauchs

Der Shelly 3EM misst den Verbrauch sehr detailliert und auch sehr kurze Ereignisse und Veränderungen im Verbrauch werden erfasst. Um nun aber herauszufinden, welche Veränderung welcher Verbraucher ist, muss man zunächst erst einmal wissen, auf welcher Phase welche Verbraucher laufen. Wenn die Verteilung gut dokumentiert ist, kann man sehen, welche Leitungsschutzschalter wofür zuständig ist und auf welcher Phase er liegt. Damit kann man die möglichen Verbraucher pro Phase schon einmal einkreisen.

Viele Verbraucher wie Fernsehgerät, Kühlschrank, Backofen, Geschirrspüler, Waschmaschine etc. lassen sich sehr einfach lokalisieren, da sie sehr charakteristische Muster und hohe Ströme und damit Spitzen im Verbrauch haben. Sparen kann man allerdings vor allem bei der Verringerung der Grundlast, also all der Verbraucher, die zwar alle recht wenig verbrauchen, das dafür über lange Zeiträume. Standby-Verbraucher wie AV-Receiver, Sat-Receiver, PCs aber auch Smarthome-Geräte wie Alexa oder Philips Hue Leuchten, können in der Masse nicht unerhebliche Verbräuche verursachen.

lelit-siebtraeger-maschine-home-assistant

Smarte Steckdose schalte die Siebträgermaschine automatisch an und wieder aus

Hier sollte man in einer Zeit (früh am Morgen oder in der Nacht) nach und nach alle Geräte vom Netz nehmen, nacheinander wieder aktivieren und den Verbrauch beobachten. Schnell findet man dann heraus, dass sich TV, Sat- und AV-Receiver zusammen mit einem Apple TV-Gerät zusammen 40 Watt im Standby-Betrieb gönnen und rund um die Uhr aus der Steckdose nuckeln. Der Laptop am Ladegerät nimmt sich ständig 10 Watt, weil er den Akku auf Trab hält und der Laserdrucker mit Netzwerkanschluss im Arbeitszimmer mag auch ausgeschaltet 10 Watt. Diese 60 Watt alleine, kosten bei 32 ct. Stromkosten pro Kilowattstunde im Jahr gut 168 Euro. Mit einer Hausautomation oder smarten Steckdosen, kann man diese Geräte bei Nichtgebrauch vom Netz nehmen und die Kosten für diese Steckdosen amortisieren sich schon nach wenigen Monaten.

Mein neuer ESPHome Multisensor mit Display für Home Assistant

Mein eigentliches Ziel war ein Gerät auf Basis eines Wemos Mini D1 und ESPHome, um mehrere 1-Wire Temperatursensoren auslesen zu können, die ich an den Vor- und Rückläufen unserer Heizungsanlage, sowie oben, in der Mitte und unten in unserem Pufferspeicher montiert habe. Die 1-Wire Sensoren vom Typ DS18B20 sind nicht nur preiswert und für diese Aufgabe hinreichend genau, sondern können auch gut verlängert werden und es lassen sich etwa 100 Sensoren an einer einzigen Datenleitung betreiben.

Bei mir geht es hingegen nur um 9 Sensoren: Fußbodenheizung Vorlauf/Rücklauf, Wandheizkörper Vorlauf/Rücklauf, wassergeführter Kamin Vorlauf/Rücklauf und eben die 3 Sensoren im Pufferspeicher.

Der fertig aufgebaute ESPHome Multisensor mit Display

Der fertig aufgebaute ESPHome Multisensor mit Display

Nun finde ich es aber immer schade, wenn man einen ESP für nur eine Aufgabe verbrät und die anderen Pins ungenutzt lässt. Also warum nicht gleich noch einen BME280 Sensor nutzen, um die Luftfeuchtigkeit und Temperatur im Technikraum zu messen? Dank des eingebauten Luftdrucksensors kann man dann auch gleich noch die absolute Luftfeuchtigkeit und den Taupunkt ausrechnen lassen.

Und wenn man schon die Daten hat, wäre doch ein Display ganz nett? Dazu hatte ich noch einige Nokia 5110 Displays vom PCD 8544 herumliegen. Mit seinen 84×48 Pixeln ist es für diese Aufgabe optimal geeignet. Mit der passenden Schriftart kann man 6 Zeilen zu 14 Zeichen gut lesbar darstellen. Man bekommt hier einfach mehr unter als bei einem zweizeiligen HD44780 Display und kann auch Grafiken einsetzen.

Zudem unterstützt die ESPHome Plattform bei diesem Display auch “Pages”, sodass man sehr einfach zwischen mehreren Seiten und Anzeigen durchblättern und somit jede Menge Informationen übersichtlich darstellen kann. Zum Blättern braucht es aber auch ein Bedienelement und hier habe ich mich für einen einfachen Taster entschieden, denn für einen Endlos-Encoder waren nicht mehr genug Pins vorhanden. Dafür kann das Display über Home Assistant in der Helligkeit gesteuert werden und ein WS2812 LED-Streifen mit 8 RGB-LEDs gibt Auskunft über verschiedene Betriebszustände.

Der Aufbau

Es ist immer eine gute Idee, solche umfangreicheren Projekte zunächst auf einem Breadboard aufzubauen und zu testen, bevor man sich an den Lötkolben wagt. Funktioniert der fliegende Aufbau wie gewünscht, kann man sich an die Umsetzung auf einer Platine machen.

Testaufbau auf einem Breadboard

Testaufbau auf einem Breadboard

Ich bin von jeher ein Fan von Streifenrasterplatinen. Damit habe ich schon mit 9 Jahren gebastelt, in meiner Ausbildung damit gearbeitet und ich mag die Streifenraster-Philosophie lieber als diese Lötzinnbäche auf Punktraster-Boards. Dabei verfolge auch noch die “reine Lehre”, nämlich dass Drahtbrücken nur in einer Richtung verlaufen. Wemos Mini, Display und BME280 Sensor werden gesteckt, sodass man sie auch schnell mal tauschen könnte.

Der grundlegende Aufbau und Schaltplan meines Multisensors mit Display

Für die Anbindung der 9 1-Wire Sensoren habe ich mich für 9-polige Federklemmblöcke entschieden. 3 Stück davon passen nebeneinander auf eine Europlatinenbreite und sind für die dünnen Adern der DS18B20 Sensoren ideal geeignet. Die Datenleitung der Sensoren muss mit einem 4,7 kOhm Widerstand auf High (3,3 Volt Betriebsspannung) gelegt werden und ein 10 uF Elko direkt an der Spannungsversorgung der Sensoren sorgt für einen stabileren Betrieb. Die 1-Wire Sensoren werden immer in der Reihenfolge DATA (Gelb), VCC (Rot), GND (Schwarz) von links nach rechts angeschlossen.

Der komplette Aufbau passte auf weniger als eine halbe Eurokarte und sieht meiner Meinung nach ganz ordentlich aus.

Natürlich könnte man auch eine richtige Platine gestalten und herstellen (lassen). Allerdings werde ich diesen Aufbau nur ein einziges Mal benötigen, sodass der Aufwand hier nicht gerechtfertigt ist und eine sauber aufgebaute Streifenrasterplatine ist ebenso zuverlässig.

Die Programmierung mit ESPHome

ESPHome ist eine grandiose Lösung für eigene Sensoren und Aktoren. Es basiert auf Arduino Bibliotheken, wird aber in der Hauptsache mit YAML eher konfiguriert, als programmiert. Trotzdem lassen sich auch komplexe Funktionen und Berechnungen damit umsetzen, in dem man mit sogenannten Lambdas auch C-Code innerhalb der YAML Konfiguration einsetzen kann. Was die Programmierung jedoch noch vereinfacht, ist die Integration der ESPHome Plattform direkt in Home Assistant. Hat man die ESPHome Integration in HA, kann man auf Flash-Tools etc. verzichten.

Dazu benötigt man nur den Chrome-Browser oder Edge (vermutlich gehen auch andere Browser, die auf Chromium basieren), denn diese bieten die Web Serial Schnittstelle. Damit verbindet man den ESP per USB mit dem Rechner, an dem man gerade sitzt und kann, öffnet die ESPHome Integration in HA im Browser und kann damit den ESP direkt flashen. Wichtig dabei ist nur, dass die Verbindung zu Home Assistant per SSL erfolgt.

ESPHome direkt aus Home Assistant über den Browser flashen

Hat man das erledigt, wird der neu angelegte und geflashte ESP in der ESPHome Oberfläche als “online” angezeigt und kann von da an direkt über die Weboberfläche programmiert werden. Auch die Logs des ESP werden darüber ausgegeben und ESPs können von dort aus auch upgedatet werden. Ich habe früher Tasmota und ESPeasy eingesetzt, aber ESPHome ist so viel einfacher, eleganter und flexibler in der Nutzung – besonders wenn man mehrere solcher Geräte im Einsatz hat. Die ESPHome Geräte können praktisch von überall aus programmiert werden, wo man Zugriff auf seinen Home Assistant Server hat.

Der Code für den Multisensor mit Display

Hier zunächst einmal der komplette Programmcode meines ESPHome Multisensors:

esphome:
  name: technik
  platform: ESP8266
  board: d1_mini

# Logging an RX/TX ausschalten, da diese Pins als GPIOs verwendet werden
logger:
  baud_rate: 0

#  Home Assistant API aktivieren
api:

ota:
  password: "Dein-OTA-Passwort"

wifi:
  ssid: "DEINE-SSID"
  password: "DEIN-WLAN-PASSWORT"

  # Fallback hotspot (captive portal) aktivieren, falls WLAN fehlt
  ap:
    ssid: "Technik Fallback Hotspot"
    password: "DEIN_PASSWORT"

captive_portal:

# GPIO Übersicht und Verbindungen
# D0 = RST Display
# D1 = I2C SCL BME280
# D2 = I2C SDA BME280
# D3 = DC Display
# D4 = 1Wire Data für DS18B20 Sensoren
# D5 = SPI CLK Display
# D6 = WS2812 LED Data
# D7 = CS/CE Display
# D8 = SPI MOSI Display Din
# RX = Backlight Display = GPIO3
# TX = Switch = GPIO1
# A1 = noch nicht im Einsatz


light:
    # WS2812 LED Infostrip
  - platform: fastled_clockless
    chipset: WS2812B
    id: light_fastled
    pin: D6
    num_leds: 8
    rgb_order: GRB
    name: "Infostrip"
    effects:
      - pulse:
  # LEDs definieren   
  - platform: partition
    name: "PL0"
    segments:
      - id: light_fastled
        from: 0
        to: 0
    effects:
      - pulse:
  - platform: partition
    name: "PL1"
    segments:
      - id: light_fastled
        from: 1
        to: 1
    effects:
      - pulse:
  - platform: partition
    name: "PL2"
    segments:
      - id: light_fastled
        from: 2
        to: 2
    effects:
      - pulse:
  - platform: partition
    name: "PL3"
    segments:
      - id: light_fastled
        from: 3
        to: 3
    effects:
      - pulse:
  - platform: partition
    name: "PL4"
    segments:
      - id: light_fastled
        from: 4
        to: 4
    effects:
      - pulse:
  - platform: partition
    name: "PL5"
    segments:
      - id: light_fastled
        from: 5
        to: 5
    effects:
      - pulse: 
  - platform: partition
    name: "PL6"
    segments:
      - id: light_fastled
        from: 6
        to: 6
    effects:
      - pulse: 
  - platform: partition
    name: "PL7"
    segments:
      - id: light_fastled
        from: 7
        to: 7
    effects:
      - pulse:      

# Displaybeleuchtung
  - platform: monochromatic
    name: "Technik Display"
    output: technik_display

output:
  - platform: esp8266_pwm
    id: technik_display
    pin: GPIO03
    inverted: true

# 1-Wire Sensoren 
dallas:
  - pin: D4

# I2C-Bus für BME280 
i2c:
  sda: D2
  scl: D1
  scan: true
  id: bus_a

# SPI-Bus für Display  
spi:
  clk_pin: D5
  mosi_pin: D8

# Statusdaten für den ESP holen
text_sensor:
  - platform: template
    name: Uptime Human Readable
    id: uptime_human
    icon: mdi:clock-start

  - platform: wifi_info
    ip_address:
      name: ESP IP Address
      id: my_ip
    ssid:
      name: ESP Connected SSID
      id: my_SSID
    bssid:
      name: ESP Connected BSSID
    mac_address:
      name: ESP Mac Wifi Address
      id: my_mac

# 1-Wire Sensoren einbinden
sensor:
  - platform: dallas
    address: 0x42030297792CC028
    resolution: 12
    name: "Vorlauf FBH"
    id: fbh_vl

  - platform: dallas
    address: 0x16030297794F1A28
    resolution: 12
    name: "Rücklauf FBH"
    id: fbh_rl

# BME280 Sensor     
  - platform: bme280
    temperature:
      name: "ESP1 Technik Temperatur"
      id: bme280_temperature
      oversampling: 16x
    pressure:
      name: "ESP1 Technik Luftdruck"
      id: bme280_pressure
    humidity:
      name: "ESP1 Technik Feuchte"
      id: bme280_humidity
    address: 0x76
    update_interval: 120s #längere Updateintervalle verhindern Erwärmung des Sensors
    iir_filter: 4x # Messwerte glätten

# WLAN-Signalstärke holen
  - platform: wifi_signal
    name: "Technik ESP Wifi Signal"
    update_interval: 30s
    id: wlan_signal

# Uptime des ESP auslesen und menschenlesbar formatieren
  - platform: uptime
    name: Uptime ESP Technik
    id: uptime_sensor
    update_interval: 60s
    on_raw_value:
      then:
        - text_sensor.template.publish:
            id: uptime_human
            state: !lambda |-
              int seconds = round(id(uptime_sensor).raw_state);
              int days = seconds / (24 * 3600);
              seconds = seconds % (24 * 3600);
              int hours = seconds / 3600;
              seconds = seconds % 3600;
              int minutes = seconds /  60;
              seconds = seconds % 60;
              return (
                (days ? String(days) + "d " : "") +
                (hours ? String(hours) + "h " : "") +
                (minutes ? String(minutes) + "m " : "") +
                (String(seconds) + "s")
              ).c_str();

# LCN-WIH Außentemperatursensor von HA holen
  - platform: homeassistant
    id: temp_aussen
    entity_id: sensor.wih_temp_aussen


# Luftdruck mit Höhenkorrektur auf 516 Meter berechnen

  - platform: template
    name: "Technik Luftdruck"
    update_interval: 60s
    lambda: |-
      const float STANDARD_ALTITUDE = 516; // in Meter
      return id(bme280_pressure).state / powf(1 - ((0.0065 * STANDARD_ALTITUDE) /
        (id(bme280_temperature).state + (0.0065 * STANDARD_ALTITUDE) + 273.15)), 5.257); // in hPa
    unit_of_measurement: 'hPa'

# Absolute Luftfeuchtigkeit in g/m3 berechnen    
  - platform: template
    name: "Technik Absolute Luftfeuchtigkeit"
    lambda: |-
      const float mw = 18.01528;    // molare Masse von Wasser g/mol
      const float r = 8.31447215;   // universelle Gas-Konstante J/mol/K
      return (6.112 * powf(2.718281828, (17.67 * id(bme280_temperature).state) /
        (id(bme280_temperature).state + 243.5)) * id(bme280_humidity).state * mw) /
        ((273.15 + id(bme280_temperature).state) * r); // in Gramm/m^3
    accuracy_decimals: 2
    update_interval: 60s
    icon: 'mdi:water'
    unit_of_measurement: 'g/m³'
    id: wsabs

# Taupunkt berechnen    
  - platform: template
    name: "Technik Taupunkt"
    lambda: 
      return (243.5*(log(id(bme280_humidity).state/100)+((17.67*id(bme280_temperature).state)/
      (243.5+id(bme280_temperature).state)))/(17.67-log(id(bme280_humidity).state/100)-
      ((17.67*id(bme280_temperature).state)/(243.5+id(bme280_temperature).state))));
    unit_of_measurement: °C
    icon: 'mdi:thermometer-alert'

# Uhrzeit von Home Assistant holen (für Uptime-Berechnung)
time:
  - platform: homeassistant
    id: homeassistant_time      

# Display-Fonts definieren
font:
  - file: "fonts/hd44780.ttf"
    id: font_a
    size: 8
  - file: "fonts/VCR_OSD_MONO.ttf"
    id: font_b
    size: 20

# Icons definieren
image:
  - file: "icons/water-percent.gif"
    id: water_percent
  - file: "icons/thermometer.gif"
    id: thermometer
  - file: "icons/sm_sad.gif"
    id: sad
    resize: 22x24
  - file: "icons/sm_neutral.gif"
    id: neutral 
    resize: 22x24
  - file: "icons/sm_happy.gif"
    id: happy
    resize: 22x24

# Nokia 5110 Display    
display:
  - platform: pcd8544
    id: my_display
    reset_pin: D0   
    cs_pin: D7
    dc_pin: D3                       
    contrast: 0x3f # Wichtig: zu hohe Werte zeigen schwarzes Display!

    # Mehrere Display-Seiten 
    pages:
      - id: page1
        lambda: |-
          it.image(0, 0, id(thermometer));
          it.printf(14, 0, id(font_b), "%.1f°C", id(bme280_temperature).state);
          it.image(0, 20, id(water_percent));
          it.printf(14, 20, id(font_b), "%.0f", id(bme280_humidity).state);
          it.printf(38, 22, id(font_a), "%.1f", id(wsabs).state);
          it.print(38, 30, id(font_a), "g/m3");
          if ((id(bme280_humidity).state <= 55)) {
            it.image(63, 18, id(happy));
          }

          if ((id(bme280_humidity).state >= 56) and (id(bme280_humidity).state <= 68))    {
            it.image(63, 18, id(neutral));
          }    
          if ((id(bme280_humidity).state >= 69))    {
            it.image(63, 18, id(sad));
          }      

          it.strftime(0, 40, id(font_a), "%H:%M-%d.%m.%y", id(homeassistant_time).now());



      - id: page2
        lambda: |-
          it.print(0, 0, id(font_a), "   HK1 - FBH"); 
          it.print(0, 6, id(font_a), "______________"); 
          it.printf(0, 18, id(font_a), "FBH VL:%.1f C", id(fbh_vl).state);
          it.printf(0, 28, id(font_a), "FBH RL:%.1f C", id(fbh_rl).state);
          it.printf(0, 38, id(font_a), "Aussen:%.1f C", id(temp_aussen).state);

      - id: page3
        lambda: |-
          it.print(0, 0, id(font_a), "  HK2 - Wand"); 
          it.print(0, 6, id(font_a), "______________"); 
          it.printf(0, 18, id(font_a), "HK VL:%.1f C", id(fbh_vl).state);
          it.printf(0, 28, id(font_a), "HK RL:%.1f C", id(fbh_rl).state);
          it.printf(0, 38, id(font_a), "Aussen:%.1f C", id(temp_aussen).state);
      - id: page4
        lambda: |-
          it.print(0, 0, id(font_a), " HK3 - Kamin"); 
          it.print(0, 6, id(font_a), "______________"); 
          it.printf(0, 18, id(font_a), "KAM VL:%.1f C", id(fbh_vl).state);
          it.printf(0, 28, id(font_a), "KAM RL:%.1f C", id(fbh_rl).state);
          it.printf(0, 38, id(font_a), "Aussen:%.1f C", id(temp_aussen).state);
      - id: page5
        lambda: |-
          it.print(0, 0, id(font_a), "    Puffer"); 
          it.print(0, 6, id(font_a), "______________"); 
          it.printf(0, 18, id(font_a), "Oben:  %.1f C", id(fbh_vl).state);
          it.printf(0, 28, id(font_a), "Mitte: %.1f C", id(fbh_rl).state);
          it.printf(0, 38, id(font_a), "Unten: %.1f C", id(fbh_rl).state);

      - id: page6
        lambda: |-
          it.print(0, 0, id(font_a), "Name: Technik"); 
          it.print(0, 6, id(font_a), "______________"); 
          it.printf(0, 16, id(font_a), "Up:%s", id(uptime_human).state.c_str()); 
          it.printf(0, 24, id(font_a), "%s", id(my_ip).state.c_str()); 
          it.printf(0, 32, id(font_a), "%s", id(my_mac).state.c_str());
          it.printf(0, 40, id(font_a), "WLAN: %.0f dBm", id(wlan_signal).state);

# Taster zum wechseln der Display-Pages          
binary_sensor:
  - platform: gpio
    pin: 
      number: GPIO01
      mode: INPUT_PULLUP # internen Pullup einschalten - spart einen Widerstand :-)
      inverted: True
    name: "Technik Taster"
    on_press:
      then: 
        - display.page.show_next: my_display
        - component.update: my_display

# Status des ESP an HA mitteilen (verbunden oder nicht)
  - platform: status
    name: "ESP Technik"

Da ich die serielle Schnittstelle des ESP nicht benötige, schalte ich das Loggen dafür in Zeile 8 aus. Damit kann ich die beiden Pins als normale GPIOs nutzen.

Die wichtigsten Konfigurationen und Funktionen im Detail

Viel im Code sind Standardfunktionen, die man ganz einfach nachlesen kann. Ich möchte hier die interessanteren Teile kurz einzeln erklären.

light:
    # WS2812 LED Infostrip
  - platform: fastled_clockless
    chipset: WS2812B
    id: light_fastled
    pin: D6
    num_leds: 8
    rgb_order: GRB
    name: "Infostrip"
    effects:
      - pulse:
  # LEDs definieren   
  - platform: partition
    name: "PL0"
    segments:
      - id: light_fastled
        from: 0
        to: 0
    effects:
      - pulse:

...

Hier wird der WS2812 LED-Stripe mit 8 RGB-LEDs eingerichtet. Für jedes LED wird die Platform: partition angelegt. Damit kann jedes LED später individuell angesprochen werden. Aktuell ist dafür noch kein weiterer Code enthalten und die Nutzung dieser Funktion, wird erst später hinzukommen. So könnte man darüber etwa anzeigen, wenn man Lüften sollte oder wenn der Brenner der Heizung aktiv ist.

# Displaybeleuchtung
  - platform: monochromatic
    name: "Technik Display"
    output: technik_display

output:
  - platform: esp8266_pwm
    id: technik_display
    pin: GPIO03
    inverted: true

Die Displaybeleuchtung ist an dem früheren RX-Pin angeschlossen, der nun auf GPIO03 hört. Damit kann das Display von HA aus gesteuert und gedimmt werden.

dallas:
  - pin: D4

# 1-Wire Sensoren einbinden
sensor:
  - platform: dallas
    address: 0x42030297792CC028
    resolution: 12
    name: "Vorlauf FBH"
    id: fbh_vl

  - platform: dallas
    address: 0x16030297794F1A28
    resolution: 12
    name: "Rücklauf FBH"
    id: fbh_rl

...

Die DS18D20 1-Wire Temperatursensoren werden hier definiert. Dazu benötigt man die eindeutige ID des jeweiligen Sensors. Entweder schließt man dazu jeden Sensor einmal einzeln an, notiert sich die ID und markiert sie am Sensor oder man schließt alle Sensoren gleichzeitig an, erwärmt jeden Sensor kurz und sieht im Log nach, welche ID gerade eine höhere Temperatur anzeigt.

# Uptime des ESP auslesen und menschenlesbar formatieren
  - platform: uptime
    name: Uptime ESP Technik
    id: uptime_sensor
    update_interval: 60s
    on_raw_value:
      then:
        - text_sensor.template.publish:
            id: uptime_human
            state: !lambda |-
              int seconds = round(id(uptime_sensor).raw_state);
              int days = seconds / (24 * 3600);
              seconds = seconds % (24 * 3600);
              int hours = seconds / 3600;
              seconds = seconds % 3600;
              int minutes = seconds /  60;
              seconds = seconds % 60;
              return (
                (days ? String(days) + "d " : "") +
                (hours ? String(hours) + "h " : "") +
                (minutes ? String(minutes) + "m " : "") +
                (String(seconds) + "s")
              ).c_str();

Hier wird die Zeit, die der ESP online ist, in ein menschenlesbares Format umgewandelt, sodass man es später schön im Display und in der HA Oberfläche anzeigen lassen kann.

1
2
3
4
# LCN-WIH Außentemperatursensor von HA holen
  - platform: homeassistant
    id: temp_aussen
    entity_id: sensor.wih_temp_aussen

Natürlich kann man auch Sensoren aus HA holen. Hier lese ich den Außentemperatursensor meiner LCN-WIH Wetterstation aus, um die Werte im Display anzeigen zu lassen.

# Luftdruck mit Höhenkorrektur auf 516 Meter berechnen

  - platform: template
    name: "Technik Luftdruck"
    update_interval: 60s
    lambda: |-
      const float STANDARD_ALTITUDE = 516; // Höhe über Null am Einsatzort in Meter
      return id(bme280_pressure).state / powf(1 - ((0.0065 * STANDARD_ALTITUDE) /
        (id(bme280_temperature).state + (0.0065 * STANDARD_ALTITUDE) + 273.15)), 5.257); // in hPa
    unit_of_measurement: 'hPa'

# Absolute Luftfeuchtigkeit in g/m3 berechnen    
  - platform: template
    name: "Technik Absolute Luftfeuchtigkeit"
    lambda: |-
      const float mw = 18.01528;    // molare Masse von Wasser g/mol
      const float r = 8.31447215;   // universelle Gas-Konstante J/mol/K
      return (6.112 * powf(2.718281828, (17.67 * id(bme280_temperature).state) /
        (id(bme280_temperature).state + 243.5)) * id(bme280_humidity).state * mw) /
        ((273.15 + id(bme280_temperature).state) * r); // in Gramm/m^3
    accuracy_decimals: 2
    update_interval: 60s
    icon: 'mdi:water'
    unit_of_measurement: 'g/m³'
    id: wsabs

# Taupunkt berechnen    
  - platform: template
    name: "Technik Taupunkt"
    lambda: 
      return (243.5*(log(id(bme280_humidity).state/100)+((17.67*id(bme280_temperature).state)/
      (243.5+id(bme280_temperature).state)))/(17.67-log(id(bme280_humidity).state/100)-
      ((17.67*id(bme280_temperature).state)/(243.5+id(bme280_temperature).state))));
    unit_of_measurement: °C
    icon: 'mdi:thermometer-alert'

Hier wieder ein Einsatz für die Lambdas und etwas C-Code zur Berechnung der absoluten Luftfeuchtigkeit etc. Mit lambda: |- teilt man mit, dass alles, was danach kommt und eingerückt ist, als C-Code interpretiert wird. Die Formeln dafür stammen aus dem Internet. Beim Luftdruck ist darauf zu achten, dass man die richtige Höhenangabe einträgt. Der Luftdruck, den der BME280 direkt ausgibt, ist nicht höhenkompensiert.

Das Nokia 5110 Display – Fonts, Icons und Darstellung

1
2
3
4
5
6
7
8
# Display-Fonts definieren
font:
  - file: "fonts/hd44780.ttf"
    id: font_a
    size: 8
  - file: "fonts/VCR_OSD_MONO.ttf"
    id: font_b
    size: 20

Für das Nokia 5110 PCD8544 Display müssen Schriftarten definiert werden. Grundsätzlich kann man jeden TrueType-Font (.ttf) dafür nutzen. Allerdings klappt das nur für große Texte und auch hier sieht nicht jeder Font gut aus. Für die kleinstmögliche leserliche Darstellung sind 7×5 (Pixel) Fonts ideal. So findet man z. B. bei wfonts.com die hd44780.ttf Schriftart, welche klar lesbar ist und 6 Zeilen zu 14 Zeichen erlaubt. Für großen Text habe ich mich für VCR_OSD_MONO.ttf bei dafont.com entschieden.

Fonts-Verzeichnis unter esphome im VScode Editor

Die Fonts lädt man in ein Verzeichnis unterhalb des esphome Verzeichnisses. Das geht ganz einfach per VSCode Integration in HA. Einfach einen Ordner fonts (der Name ist egal) anlegen, rechten Mausklick darauf und Upload auswählen.

# Icons definieren
image:
  - file: "icons/water-percent.gif"
    id: water_percent
  - file: "icons/thermometer.gif"
    id: thermometer
  - file: "icons/sm_sad.gif"
    id: sad
    resize: 22x24
  - file: "icons/sm_neutral.gif"
    id: neutral 
    resize: 22x24
  - file: "icons/sm_happy.gif"
    id: happy
    resize: 22x24

Ich habe für den Haupt-Screen meines ESP einige Icons eingebaut. Ein Thermometer, Wassertropfen und 3 Smilies, die Auskunft über die Luftfeuchtigkeit geben. Auch hier legt man sich wieder ein Verzeichnis unterhalb von esphome an – in meinem Fall icons – und lädt die entsprechenden Grafiken hoch. Ich hatte allerdings nur mit GIF-Dateien Erfolg. PNGs, egal ob mit oder ohne Alphakanal, zeigten immer nur einen schwarzen Block an.

Das Hauptmenü meines Multisensors

# Nokia 5110 Display    
display:
  - platform: pcd8544
    id: my_display
    reset_pin: D0   
    cs_pin: D7
    dc_pin: D3                       
    contrast: 0x3f # Wichtig: zu hohe Werte zeigen schwarzes Display!

    # Mehrere Display-Seiten 
    pages:
      - id: page1
        lambda: |-
          it.image(0, 0, id(thermometer));
          it.printf(14, 0, id(font_b), "%.1f°C", id(bme280_temperature).state);
          it.image(0, 20, id(water_percent));
          it.printf(14, 20, id(font_b), "%.0f", id(bme280_humidity).state);
          it.printf(38, 22, id(font_a), "%.1f", id(wsabs).state);
          it.print(38, 30, id(font_a), "g/m3");
          if ((id(bme280_humidity).state <= 55)) {
            it.image(63, 18, id(happy));
          }

          if ((id(bme280_humidity).state >= 56) and (id(bme280_humidity).state <= 68))    {
            it.image(63, 18, id(neutral));
          }    
          if ((id(bme280_humidity).state >= 69))    {
            it.image(63, 18, id(sad));
          }      

          it.strftime(0, 40, id(font_a), "%H:%M-%d.%m.%y", id(homeassistant_time).now());

Nun wird das Display konfiguriert. Wichtig ist die contrast Einstellung. In der offiziellen Dokumentation wird hier der Wert contrast: 0x7f angegeben. Damit erhält man aber nur ein komplett schwarz gefülltes Display und glaubt erst einmal an einen Verkabelungsfehler. Tatsächlich handelt es sich aber nur um einen viel zu hohen Kontrast. Mit contrast: 0x3f wird die Schrift meiner Ansicht nach ideal dargestellt.

Bei den print– und image-Anweisungen bedeutet printf(14,20 … ), dass die Schrift 14 Pixel nach rechts und 20 Pixel nach unten, ausgehend von der linken oberen Ecke der Anzeige dargestellt werden soll.

Vor- und Rücklauf der Fußbodenheitung sowie Außentemperatur

Mit pages: und id: page1 nutze ich die Möglichkeit, Inhalte auf mehrere Displayseiten zu verteilen. Page1 ist mein Hauptscreen, der beim Start erscheint und Raumtemperatur sowie Luftfeuchtigkeit groß mit einem Icon davor darstellt. Neben der Luftfeuchtigkeit zeige ich noch kleiner die absolute Luftfeuchtigkeit an. Daneben, je nach Luftfeuchte, einen passenden Smilie und darunter die aktuelle Uhrzeit und das Datum.

Mit it.printf(14, 0, id(font_b), “%.1f°C”, id(bme280_temperature).state); wird die Temperatur im C-Stil auf eine Nachkommastelle formatiert (%.1f).

Mit den if-Anweisungen werden die Smilies nach einem Schwellwert geändert und zu guter Letzt die Uhrzeit angezeigt.

# Taster zum wechseln der Display-Pages          
binary_sensor:
  - platform: gpio
    pin: 
      number: GPIO01
      mode: INPUT_PULLUP # internen Pullup einschalten - spart einen Widerstand :-)
      inverted: True
    name: "Technik Taster"
    on_press:
      then: 
        - display.page.show_next: my_display
        - component.update: my_display

Hier wird der Taster am GPIO01 abgefragt. Mit INPUT_PULLUP kann man den internen Pullup aktivieren und man spart sich damit die externe Beschaltung mit einem Widerstand, der für einen definierten Logikpegel sorgt. Wenn der Taster gedrückt wird, sorgen die beiden letzten Zeilen dafür, dass die Seiten (Pages) nacheinander durchgeschaltet und anzeigt werden.

Eine Seite mit Systeminformationen

Tipps

Zum BME280 Sensor gibt es im Netz viele Diskussionen. Ursprünglich wurde der Sensor von Bosch entwickelt. Geht man nach dem Datenblatt der Firma Bosch, müssen die Sensoren in einem speziellen Prozess verlötet und dann bei definierten Bedingungen getrocknet und eingebrannt werden.

Bei den günstigen China-Sensoren kann man nicht wirklich sicher sagen, ob es sich um Bosch-Typen oder Kopien handelt und der Verarbeitungsprozess wird ganz sicher nicht eingehalten. Daher wird immer davon gesprochen, dass diese China-Varianten ungenau wären. Achtet man jedoch darauf, dass der Sensor möglichst weit von Wärmequellen wie dem ESP8266 entfernt montiert wird und die Zuleitungen möglichst lang (und dünn) sind, liefert der BME280 nach meinen Erfahrungen und auch Vergleichsmessungen mit gesättigten Salzlösungen (siehe auch: https://nachbelichtet.com/guenstige-xiaomi-mijia-ble-sensoren-mit-home-assistant-nutzen/) sehr genaue Werte.

Häufig ist auch die Erwartung an einen Messwert schlichtweg Unsinn. Es geht nicht darum, den besten und genausten Messwert zu erhalten, sondern den Messwert, der zur Anwendung passt. Die Lufttemperatur unterscheidet sich selbst in kleinen Räumen und je nach Messhöhe und Position im Raum nicht selten um 2 °C. Gleiches gilt für die Luftfeuchtigkeit. Sind also 22,7 °C richtiger als 23,4 °C? Nein! Denn verzichtet man auf die Nachkommastelle, kämen für diesen Einsatz vollkommen ausreichende 23 Grad als Messwert heraus.

Aqara Multisensoren für Temperatur, Luftfeuchtigkeit und Luftdruck

Aqara Multisensoren für Temperatur, Luftfeuchtigkeit und Luftdruck

Doch selbst hier sagt der Messwert noch nichts darüber aus, ob man sich bei dieser Temperatur auch wohlfühlt. Das Wohlfühlklima wird über die Temperatur, die Luftfeuchtigkeit und die Luftbewegung definiert. So nimmt die gefühlte Temperatur bei steigender Luftfeuchtigkeit zu und umgekehrt. 21 °C Lufttemperatur fühlen sich bei 55 % rel. Luftfeuchte schon wie 23 °C und bei 75 % wie 26 °C an. Daher fühlt sich auch recht warme, aber trockene Heizungsluft im Winter gar nicht so muggelich an, wie man oft erwarten würde. Kommt dann auch noch eine leichte Luftbewegung hinzu, können sich 23 °C wie 20 °C anfühlen.

Die DS18B20 Sensoren sollte man alle in einen Eimer Wasser mit hängen, dessen Temperatur mit einem vertrauenswürdigen Thermometer gemessen hat. So kann man die Sensoren nach Genauigkeit und Abweichung selektieren. Bei der Messung von Vor- und Rücklauf einer Niedrigtemperaturheizungen, macht 1 °C Abweichung schon etwas aus. Wenn dann die Rücklauftemperatur höher ist als der Vorlauf, kann man keine vernünftige Steuerung darauf aufbauen. Daher sollten beide Sensoren die gleichen relativen Messwerte liefern. Abweichungen vom tatsächlichen Messwert kann man dann ggf. auch noch per Software kompensieren.

Bauteile und Kosten

Das gesamte Projekt kostet weniger als 10 Euro. Die 5110 Displays bekommt man für weniger als 2 Euro bei diversen China-Versendern (auf die neuen Regelungen beim Versand aus China achten – siehe HIER !). Ein ESP Wemos Mini kostet auch nur 2 Euro. Bestellt man ihn aus Deutschland, muss man etwa 4,50 Euro rechnen. BME280 Sensor, Platine und die Klemmen sind für weitere 3-4 Euro zu haben.

Nicht in den Kosten enthalten sind die DS18B20 1-Wire Sensoren. Hier bekommt man 10 Stück für unter 20 Euro. Auf Basis dieses Grund-Codes kann man viele universelle Smarthome-Sensoren mit Display günstig herstellen. Da man sowohl einen I2C- als auch einen SPI-Bus zur Verfügung hat, kann man problemlos noch weitere Sensoren einbinden und damit den Funktionsumfang nach den eigenen Wünschen und Anforderungen erweitern.

Automationen mit mehreren Schaltzeiten in Home Assistant erstellen

Ich kann es nicht oft genug wiederholen: Eine App auf dem Smartphone, die eine Lampe oder was auch immer schalten kann, macht noch lange kein Smarthome, denn das ist nur ein verlagerter Schalter. Da jeder Hersteller seine eigene App hat, ist das sogar noch viel umständlicher. Smarthome-Hubs wie Home Assistant verbinden die unterschiedlichsten Systeme und Anwendungen unter einer Oberfläche und sorgen für wirklich smarte Funktionen.

Baustelle vor dem Bürofenster – die große Terrasse wird neu gepflastert

Wir haben seit über 6 Wochen eine Baustelle rund ums Haus, da wir unsere Terrasse, Einfahrten etc. erneuern lassen. Dabei kam auch heraus, dass die Fallrohre unserer Dachrinnen nicht mehr okay sind und ausgetauscht werden müssen. Unser Haus sieht zwar wie ein moderner Neubau aus, steht aber seit 1965.

Die Regenwasserzisterne

Und das 2,5 Meter tiefe Loch dafür.

Da gab es noch Rohre aus Ton und die sind irgendwann einmal kaputt. Da sowieso alles aufgerissen und der Bagger schon da war, war der Aufwand dafür überschaubar, daher haben wir uns auch gleich noch eine Regenwasserzisterne einbuddeln lassen, die das gesamte Regenwasser der großen Dach-Südseite auffangen kann. Durch die starken Regenfälle der letzten Tage ist die auch schon bis oben hin voll – immerhin 5.000 Liter. Zwei weitere Behälter (auf dem Bild oben rechts) waren schon von den Vorbesitzern hier und wurden versetzt. Auch diese fassen noch einmal gut 3.000 Liter und werden vom Garagendach gespeist.

Diese neue angelegte Fläche muss bewässert werden

Da dieses Regenwasser natürlich auch genutzt werden muss, installieren wir gerade eine automatische Bewässerung mit Versenkregnern und Wasserentnahmedosen von Gardena rund ums Haus. Dieses Jahr werden wir das zwar nicht mehr komplett umsetzen, aber es entstanden ein paar zusätzliche Flächen, die wir gerade frisch angesät haben und feucht gehalten werden wollen. Eine Tauchdruckpumpe war schon vorhanden und ein einfacher Regner sorgt mit einer ZigBee-Steckdose von Osram und einer Home Assistant Automation gerade dafür, dass der Grassamen die besten Voraussetzungen erhält.

Lohnt sich eine Regenwasserzisterne?

Eine Regenwasserzisterne ist eine tolle Sache, da man das Regenwasser in Trockenzeiten nicht nur für die Gartenbewässerung, sondern auch auf Reinigungsarbeiten etc. nutzen kann. Zwar war der Sommer dieses Jahr sehr nass, die letzten beiden Jahre aber extrem trocken, sodass eine Bewässerung notwendig wird, wenn man einen grünen Garten möchte. Eine Brunnenbohrung ist bei uns aus geografischen Gründen nicht wirtschaftlich möglich.

Die Kosten für eine Regenwasserzisterne sind allerdings erheblich. Eine Flachzisterne mit 5.000 Litern Kapazität und Vorfilter kostet in guter Qualität (unsere kauften wir bei der BayWa) 2.500 Euro. Für Aushubarbeiten, Kies und Sand, Einbau, Anschluss bzw. Erweiterung der Rohre, Tauchdruckpumpe usw. kommt mindestens noch einmal der gleiche Betrag hinzu.

Regenwasser vom Dach im Vorfilter der Zisterne

In unserer Region muss man mit 15 Liter pro Quadratmeter und Woche rechnen. Die zu bewässernde Fläche beträgt bei uns ca. 500 qm und muss im Schnitt 16 Wochen bewässert werden. 15 l * 500 qm *16 Wochen = 120.000 Liter = 120 qm Wasser pro Saison. Bei uns gibt es keinen gesonderten Tarif für Gartenwasser, daher würden wir hier 580 Euro pro Jahr nur für die Gartenbewässerung ausgeben, wenn wir diese optimal machen möchten. Die Zisterne würde sich damit nach gut 10 Jahren rechnen. Da bei uns Bagger etc. ohnehin schon da waren, fällt die Rechnung deutlich besser aus.

Betrachtet man die Entwicklung der Temperaturen durch den Klimawandel, dürfte der Wasserbedarf in den nächsten Jahren jedoch deutlich steigen und dann wird man froh sein, wenn man auf günstiges Regenwasser zurückgreifen kann. Sicher steigen dann nämlich auch die Kosten für Leitungswasser.

Mehrere Schaltzeiten in Home Assistant einstellen

Damit Rasen gut anwachsen kann, soll man ihn besser öfter, dafür kürzer bewässern. Tagsüber jede Stunde für 2-3 Minuten ist nach meinen Recherchen wohl optimal. Außerdem soll die Bewässerung ausgesetzt werden, wenn es regnet oder an diesem Tag schon mehr als 3 mm Niederschlag gegeben hat. Da wir mit unserer LCN-WIH bereits einen Regensensor auf dem Dach haben, kann man diesen auch gleich dafür einsetzen. Über die FineOffset Wetterstation (die unter zig Markennamen wie Bresser, Saintlogic oder dnt angeboten wird), ihren Niederschlagsmesser und WeeWX bekomme ich außerdem die stündliche und tägliche Regenmenge berichtet.

Fine Offset WH1080 Wetterstation

Die Wetterstation auf unserem Dach

Der geplante Ablauf ist also:

  • Schalte die Pumpe über die ZigBee Steckdose jede volle Stunde für 2 Minuten ein
  • aber nur wenn es aktuell nicht regnet
  • oder es heute schon mehr als 3 mm Niederschlag (= 3 Liter pro Quadratmeter) gab

Meine Osram ZigBee Steckdose heißt bei mir übrigens “Springer”, da sie immer dann zum Einsatz kommt, wenn ich vorübergehend eine bestimmte Funktion benötige.

Eine Automation mit einer einzigen Schaltzeit und den genannten Bedingungen lässt sich im visuellen Editor für Automationen zusammenklicken.

Home Assistant Automation mit mehreren Schaltzeiten

Automation anlegen und Namen geben

Home Assistant Automation mit mehreren Schaltzeiten

Mehrere Schaltzeiten als Auslöser der Automation als Liste in YAML

Home Assistant Automation mit mehreren Schaltzeiten

Erste Bedingung: Es darf gerade nicht regnen (vom LCN-Regensensor auf dem Dach)

Home Assistant Automation mit mehreren Schaltzeiten

Zweite Bedingung: Es darf nicht mehr als 0,3 cm Niederschlag gehabt haben – vom Regenmesser der FineOffset Wetterstation und WeeWX

Wenn alles zutrifft, wird der Dienst “switch.turn_on” gestartet und die ZigBee-Steckdose “Springer” aktiviert. Nach einer Verzögerung von 2 Minuten …

… wird der Dienst “switch.turn_off” aufgerufen, der die Steckdose und damit die Pumpe wieder ausschaltet

Möchte man jedoch mehrere Schaltzeiten, muss man etwas YAML-Code einfügen. Praktischerweise gibt es in HA für den “Time” Auslöser die Möglichkeit mehrere Zeiten als Liste anzugeben. Für die Aufgabe der Gartenbewässerung ist das ideal, da man hier selten andere Einstellungen benötigen wird.

alias: Bewässerung
description: ''
trigger:
  - platform: time
    at:
      - '7:00'
      - '8:00'
      - '9:00'
      - '10:00'
      - '11:00'
      - '12:00'
      - '13:00'
      - '14:00'
      - '15:00'
      - '16:00'
      - '17:00'
      - '18:00'
      - '19:00'
      - '20:00'
condition:
  - condition: state
    entity_id: binary_sensor.wih_regen
    state: 'off'
  - condition: numeric_state
    entity_id: sensor.weewx_niederschlag_heute_cm
    below: '0.3'
action:
  - service: switch.turn_on
    target:
      entity_id: switch.springer
  - delay:
      hours: 0
      minutes: 2
      seconds: 0
      milliseconds: 0
  - service: switch.turn_off
    target:
      entity_id: switch.springer
mode: single

Ihr könnt die grundsätzliche Automation erst einmal über den visuellen Editor anlegen, da diese sehr komfortabel bei der Auswahl der Entitäten wie Schalter und Sensoren ist. Danach klickt ihr oben rechts in der Automation auf die drei Pünktchen und wählt “Als YAML bearbeiten” aus. Damit lassen sich die Schaltzeiten wie oben dargestellt erweitern. Nachdem die Automatisierung gespeichert wurde, muss man unter Einstellungen -> Serversteuerung die Automationen neu laden, damit diese auch aktiv werden.

Frontend und Einstellung der Bewässerungsdauer über Helfer

Im Lovelace Frontend kann man einen Schalter für die Automation einbauen, mit dem man sie bei Bedarf auch deaktivieren kann. Ich habe auch einen Schalter für meine “Springer” Steckdose, damit ich diese auch manuell schalten kann.

Ein Schalter, um die Automation deaktivieren zu können.

Damit könnte man auch eine automatische Deaktivierung der Bewässerung realisieren, wenn die Kamera Personen vor dem Hochbeet erkennt, damit diese nicht nass werden – mit Frigate und einer eigenen Zone für das Hochbeet wäre das kein Problem.

Außerdem wäre es praktisch, wenn man die Bewässerungsdauer im Frontend einstellen könnte. Dazu legt man sich unter Einstellungen -> Helfer einen Schieberegler an, mit dem man die Bewässerungsdauer in Minuten bestimmen kann.

Ein Helfer, um die Bewässerungsdauer individuell anpassen zu können. Minimal kann 1 Minute eingestellt werden, maximal 30 Minuten.

Um den Helfer mit der Zeiteinstellung in die Automation einbinden kann, bedarf es wieder etwas YAML, das die fest-codierte Verzögerungseinstellung ersetzt:

delay:
  minutes: '{{ states(''input_number.bewasserungsdauer'') | int  }}'

Damit erfolgt die Einstellung der Bewässerungsdauer über den Helfer und kann im Frontend verändert werden

Den Helfer für die Bewässerungsdauer könnte man nun auch über den Dienst input_number manipulieren. So wäre eine weitere Automation denkbar, welche die Bewässerungsdauer in Abhängigkeit der Außentemperatur verlängert oder je nach Bodenfeuchte verkürzt – oder oder oder …

Welche Sensoren und Bedingungen ihr einfügt, bleibt euch natürlich selbst überlassen. Vielleicht habt ihr einen Bodenfeuchte-Sensor über ESPHome eingebunden (eine kleine Bauanleitung dazu folgt demnächst) oder wertet die Daten eines Wetterdienstes aus? Mit einem Füllstandssensor für die Zisterne könnte man die Bewässerungszeit verringern oder ganz abschalten etc. Es gibt jede Menge Möglichkeiten und natürlich beschränkt sich die Anwendung mehrerer Schaltzeiten nicht nur auf die Gartenbewässerung 😉

NAS- und Netzwerklaufwerke mit Home Assistant einbinden

Viele von euch haben große Mediensammlungen auf NAS-Laufwerken. Leider gibt es in Home Assistant bislang noch keinen einfachen und direkten Weg, Windows-/Samba-Netzlaufwerke zu verbinden und die Daten daraus in Home Assistant verfügbar zu machen. Mit ein paar kleinen Einstellungen geht es aber relativ einfach und schnell.

Zunächst solltet ihr die gewünschten Freigaben auf eurem NAS oder File-Server einrichten und sicherstellen, dass diese von anderen Geräten aus erreichbar sind. Das hängt natürlich von euren Systemen ab und weil es so viele Möglichkeiten gibt, kann das nicht Teil der Anleitung sein.

Die eigentliche Anbindung des Netzwerk-Shares an Home Assistant geht über den Umweg eines Shell-Commands. Damit kann man Linux-Befehle aus Home Assistant heraus ausführen. In diesem Fall ist der mount Befehl, mit dem wir das Netzlaufwerk verbinden.

In eurer configuration.yaml tragt ihr Folgendes ein:

shell_command:
  mount_music_folder: mkdir -p /media/musik;mount -v -t cifs -o vers=1.0,noserverino,user=media,password=media123,domain=WORKGROUP,sec=ntlm //192.168.178.2/media/musik /media/musik

Zerlegen wir mal den gesamten Befehl:

shell_command: sagt Home Assistant einfach, dass diesen Linux-Befehl als Service zur Verfügung stehen soll. Services kann man dann in Automationen und Skripts verwenden. Dazu später noch mehr.

mount_music_folder – ist ein beliebiger Name für den neuen Service. Man könnte es auch musiklaufwerk_verbinden nennen oder Ähnliches.

mkdir -p – legt zunächst ein Verzeichnis in Home Assistant an, das bei erfolgreichem mount-Befehl den Inhalt des Netzlaufwerks wiederspiegelt. Das -p sagt, dass der Befehl keinen Fehler ausgeben soll, wenn das Verzeichnis schon vorhanden ist.

/media/musik: Damit Home Assistant die Daten auch in seinem Medien-Verzeichnis erkennt, müssen wir das Netzlaufwerk in diesem mounten. Ich möchte, dass meine Musik im Unterverzeichnis /media/musik verbunden wird

mount – v -t cifs -o vers=1.0, noserverino – der eigentliche Mountbefehl, der Samba/Windows-Shares mit der Samba-Version 1.0 verbindet. Die Version 1.0 (vers=1.0) ist meist am unproblematischsten, aber auch am langsamsten. Andere Werte wären vers=2.0 oder vers=3.0. Siehe auch: mount.cifs › Wiki › ubuntuusers.de

user=media,password=media123,domain=WORKGROUP,sec=ntlm – beim user wird ein Username angegeben, der Zugriffserlaubnis auf euer Netzlaufwerk hat und mit password=media123 das zugehörige Passwort. sec=ntlm definiert die Hashing-Methode des Passworts.

//192.168.178.2/media/musik – ist der UNC-Pfad zu eurem NAS oder Server, in dem die gewünschten Daten liegen und dieser wird im anfangs erwähnten und angelegten Verzeichnis /media/musik in Home Assistant gemountet

Ihr solltet auf jeden Fall vorher probieren, ob ihr mit dem Netzwerk- oder UNC-Pfad und dem zugehörigen User/Passwort Zugriff auf euer Netzlaufwerk bekommt. Man kann das auch von der Home Assistant Shell mit dem kompletten Befehl testen. Verläuft das positiv, steht dem Einsatz nichts mehr im Wege.

Damit wird das Verzeichnis aber noch nicht gemountet. Damit das überhaupt geschieht, muss der Service mount_musik_folder – oder wie ihr ihn auch immer genannt habt, ausgeführt werden, und zwar am besten immer dann, wenn Home Assistant neu startet.

Home Assistant Entwickler Werkzeuge

Den neuen Service in den Entwickler-Tools testen

Zunächst könnt ihr den Service in den Entwickler-Tools -> Dienste testen, indem ihr nach dem Dienst, in meinem Fall mount_music_folder sucht und dann Dienst ausführen auswählt. Nun sollte der Inhalt eures Netzlaufwerks in Home Assistant im Medien Browser zu finden sein.

Home Assistant Medien-Browser

Die Verzeichnisse des NAS-Laufwerks im Media-Browser von Home Assistant

Nun müssen wir Home Assistant nur noch beibringen, diesen Dienst auch beim Neustart auszuführen. Dazu legen wir eine Automatisierung an:

Zunächst vergeben wir einen Namen für die Automatisierung. Bei mir heißt sie Mount Unraid NAS

Home Assistant Automatisierung anlegen

Der Auslöser für die Automatisierung ist der Start von Home Assistant. Und als Aktionstyp soll unser Service mount_music_folder ausgeführt werden.

Home Assistant Aktionen - Services ausführen

Ich habe mehrere Laufwerke, die beim Start eingebunden werden sollen. Diese kann man einfach nacheinander angeben, muss sie aber vorher in der configuration.yaml genau so definieren, wie in unserem Beispiel, also in der Form:

1
2
3
4
shell_command:
  mount_music_folder: ...
  mount_video_folder: ...
  mount_photos_folder: ...

Nun noch die Automatisierung speichern und ab jetzt werden bei jedem Start von Home Assistant eure Netzlaufwerke in Home Assistant verfügbar gemacht.

KI-gesteuerte Überwachungskameras mit Home Assistant, Frigate und Google Coral

Wir haben ums Haus herum 4 Kameras im Einsatz. Ich habe im Lauf der Zeit unterschiedliche Systeme ausprobiert, darunter Motion Eye, iSpy, Zoneminder und Shinobi. Keine der Lösungen überzeugte mich so richtig, zumal alle mit den gleichen “dummen” Überwachungsfunktionen arbeiteten und damit jede Menge unwichtiger Bewegungen erkannten. Zudem waren sie ziemlich CPU-Hungrig. Das ist bei meinem System zwar kein Problem, da meine ganzen NAS- und Smarthome-Funktionen auf einem HP Microserver mit Intel XEON E3 1230 CPU laufen und der hat genügend Leistungsreserven, aber für die gebotene Funktionalität war es einfach zu viel. Die Bewegungserkennung kam auch kaum über die meiner HIKVision Kameras hinaus.

HIKVision IP-Kameras für den Außenbereich (Modell DS-2CD2342WD)

Frigate Überwachungssoftware mit KI-Funktion

Mit Frigate gibt es seit einiger Zeit eine Überwachungssoftware für Kameras, die tief in Home Assistant integriert ist und per KI (über Tensor Flow) den Bildinhalt analysiert. Dabei kann Frigate z. B. zwischen Personen, Katzen, Autos, LKWs und vielen anderen Objekten unterscheiden. Gleichzeitig können die Ereignisse als Sensoren in Home Assistant genutzt werden und damit entsprechend Funktionen wie z. B. Außenlicht etc. steuern. Frigate kann ganz einfach über den Supervisor installiert werden und wird damit nahtlos in Home Assistant integriert.

Da hat Frigate mich erwischt …

Die Einrichtung erfolgt per YAML-Konfigurationsdatei, in der die Kameras und deren Funktionen konfiguriert werden. Idealerweise passen dabei die zu erkennenden Objekte in ein Quadrat von 300×300 Pixeln Größe. Eine sehr hohe Kamera-Auflösung ist daher nicht unbedingt besser. Für die exakte Bilderkennung genügt auch eine Bildwiederholrate von 5 fps.

Eine beispielhafte Konfiguration sieht z. B. so aus:

  einfahrt:
    ffmpeg:
      inputs:
        - path: rtsp://user:passwort@MEINEKAMERAIP/Streaming/Channels/101
          roles: 
            - detect
            - clips
            - rtmp

    width: 1280
    height: 720
    fps: 5
    objects:
      track:
        - person
        - cat
        - dog
      filters:
        person:
          min_score: 0.6
          threshold: 0.5
        cat:
          min_score: 0.4
          threshold: 0.5
    motion:
      mask:
        - 0,679,167,543,467,205,751,158,1280,308,1280,0,0,0      
      contour_area: 80 

    clips:
      enabled: true
      pre_capture: 5

Im “Input” Bereich legt man die Adresse der Überwachungskamera und die gewünschten Funktionen fest. In diesem Fall sollen Objekte detektiert und bei Ereignissen Video-Clips davon aufgezeichnet werden. Gleichzeitig soll das Kamera-Bild als RTMP-Stream weitergereicht werden. Damit ist der Kamera-Stream über die standardisierte Adresse rtmp://HA-IP/live/kameraname erreich- und einbindbar.

Bei “Objects” legt man fest, welche Objekte erkannt werden sollen und mit “Filters” wird die Erkennungsschwelle eingestellt. Mit der “Mask” können Bereiche aus der Erkennung ausgeschlossen werden und mit “pre_capture” wird festgelegt, wie viele Sekunden vor dem Ereignis in der Aufzeichnung enthalten sein sollen. Für jede Kamera und für jeden Objekt-Typen lassen sich Aufbewahrungszeiten festlegen, nach denen die Clips und Bilder automatisch gelöscht werden. So kann man z. B. Clips von Personen 10 Tage aufheben, von Fahrzeugen aber nur 3 Tage.

Frigate mi meinen Kameras in Home Assistant

Auf die Ereignisse und Einstellungen von Frigate kann per MQTT zugegriffen werden. Es gibt jedoch auch eine Erweiterung frigate-hass-integration, die man einfach über HACS installieren kann und die komfortable Sensor-Entities, Switches und Binary-Sensoren (“Bewegung erkannt”) bereitstellt. Über die Switch-Entities kann man z. B. die Objekterkennung deaktivieren, wenn die Terrassentür geöffnet ist (einen entsprechenden Türsensor vorausgesetzt), damit man nicht ständig selbst erkannt und unnötig aufgezeichnet wird. Oder man pappt sich ein NFC-Tag an die Hauswand, welches man mit dem Smartphone scannt und das dann die Erkennung für diesen Bereich über eine entsprechende Automation für z. B. 1 Stunde deaktiviert.

Frigate Entities in Home Assistant

Frigate Sensoren und Switch-Entities in Home Assistant

Apropos Bereiche: In der Frigate Konfiguration kann man auch “Zones” definieren. Hat man z. B. einen Kamerabereich, in dem sich die Garageneinfahrt, der Hauseingang und der Briefkasten befinden, kann man für jeden dieser Bereiche Zonen definieren. Diese melden dann selektiv, wenn in dieser Zone eine Bewegung erkannt wurde.

Man kann auch Kameras einbinden, die statt einem RSTP-Stream einen MPEG-Stream liefern, was bei meiner WANTEC Monolith C IP/VoIP Türsprechanlage der Fall ist. Dazu muss der MPEG-Stream per FFMPG umgewandelt werden. Das sieht in meiner frigate.yml so aus:

  eingang:

    ffmpeg:

      inputs:

        - path: http://user:password@IP-WANTEC-KAMERA:8080/?action=stream
            roles:
            - detect
            - clips



      input_args:
              - -avoid_negative_ts
              - make_zero
              - -fflags
              - nobuffer
              - -flags
              - low_delay
              - -strict
              - experimental
              - -fflags
              - +genpts+discardcorrupt
              - -r
              - "5" # <---- adjust depending on your desired frame rate from the mjpeg image
              - -use_wallclock_as_timestamps
              - "1"

      output_args:
        detect: -f rawvideo -pix_fmt yuv420p
        clips: -f segment -segment_time 10 -segment_format mp4 -reset_timestamps 1 -strftime 1 -c:v libx264 -an


    width: 1280
    height: 720
    fps: 15
    clips:
      enabled: true


    objects:
      track:
        - person
        - cat
        - dog
      filters:
        person:
          min_score: 0.6
          threshold: 0.6


    motion:
      mask:
        - 0,406,0,380,0,306,0,0,545,0,544,277
      contour_area: 80

Damit wurde auch die Kamera der Türsprechanlage zur vollwertigen Überwachungskamera samt Objekterkennung und das ganz ohne irgendwelchen Cloud-Dienste.

Weniger CPU-Last und bessere Erkennung mit Google Coral

Das Besondere an Frigate ist auch, dass man neben GPUs (bei unterstützten Grafikkarten/Chips) auch den Google Coral USB-Accelerator einbinden kann. Das ist ein TPU (Tensor Processing Unit) in Form eines kleinen USB3 Dongles. Damit wird die CPU enorm entlastet und der kleine Google Coral analysiert über 100 Frames pro Sekunde, was gerade bei mehreren Kameras oder bei der Nutzung eines Raspberry Pi sehr hilfreich ist.

Google Coral TPU

Den Google Coral gibt es z. B. beim Elektronik-Versender Pollin für 69,99 € zzgl. Versand. Wenn ihr euch für den Pollin-Newsletter anmeldet, bekommt ihr einen 5 Euro Gutschein und spart damit die Versandkosten!

Eingebunden wird der Google Coral in der frigate.yml mit diesen Parametern:

1
2
3
4
detectors:
  coral:
    type: edgetpu
    device: usb

In der Praxis

Für die Einrichtung von Frigate muss man ein wenig die Dokumentation studieren, die in manchen Bereich auch noch einige Lücken hat. Weiter hilft hier wie immer das HA-Forum und das HA-Sub-Reddit. Meine 4 Kameras waren dann aber schnell eingebunden und funktionierten tadellos. Überhaupt ist die echte Objekterkennung (und Unterscheidung) ein Segen! Bewegte Äste oder Vögel führen so nicht mehr zu unerwünschten Aufzeichnungen und Benachrichtigungen. Die Erkennungsleistung ist sehr gut, auch wenn manche Katze als Hund erkannt wird 🙂

Einmal erkennt Frigate die Katze richtig …

und einmal wird sie zum Hund 🙂

Die Latenz bei der Objekterkennung liegt bei mir unter 1 Sekunde (was allerdings vermutlich auch am Google Coral liegt) und damit eignet sich Frigate und der entsprechende Switch auch dazu, einen dummen Bewegungsmelder zu ersetzen und nicht bei jeder Katze die Außenbeleuchtung anzuschalten. Die Erkennung funktioniert bei meinen HikVision Kameras mit deren IR-Beleuchtung und guten Bildqualität auch nachts, wenn es regnet.

Fazit

Frigate ist meiner Ansicht nach die derzeit beste kostenlose Software für Überwachungskameras. Noch wird fleißig entwickelt und manches muss man sich recht mühsam erarbeiten, aber das Ergebnis überzeugt schon jetzt vollends. Ich würde auf jeden Fall den Google Coral empfehlen, da man damit auch auf dem Raspi Frigate problemlos laufen lassen kann.

Zwar werden viele Objekte von Haus aus von Frigate unterstützt, darunter Giraffe, Zebra, Bananen und Zahnbürsten, aber richtig interessant wird Frigate dann, wenn es auch Personen unterscheiden kann. Ich sammle gerade Bilder von uns, um eigene Custom Models für Tensor Flow und Gesichtserkennung zu trainieren. Allerdings muss ich mit damit erst noch ausführlich beschäftigen, da das Thema momentan noch nicht auf der Feature-Liste von Frigate steht.

CO2 Ampel mit ESPHome und Home Assistant

Das Corona-Virus wird uns wohl noch lange begleiten. Gerade in Räumen mit vielen Personen aus unterschiedlichen Haushalten ist die Ansteckungsgefahr hoch. Gleiches gilt aber schon lange für Grippeviren. Die US-Wissenschaftler Rudnick und Milton steckten dazu 30 Personen, darunter eine mit Grippe-Infektion 4 Stunden in einen Raum. Bei einem CO2-Gehalt in der Luft von 1000 ppm infizierten sich fünf Personen, bei 2000 ppm waren es schon 12 und bei 3000 ppm 15 Personen.

Ein niedriger CO2 Wert hat aber auch abseits von Infektionskrankheiten eine wichtige Bedeutung. Bei zu hohen CO2-Werten in der Raumluft sinkt die Aufmerksamkeit und Konzentration merklich und kann Kopfschmerzen und Müdigkeit verursachen, was gerade an Schulen beachtet werden sollte – auch ganz ohne Corona-Problematik.

Welche CO2 Werte sind für eine Ampel geeignet

Das war genau die Frage, die sich nach meinen Recherchen sehr schwer beantworten lässt. Gerne wird die Pettenkofer-Zahl, nach dem deutschen Hygieniker Prof. Max von Pettenkofer (1818-1901) genannt. Dieser fand heraus, dass 1.000 ppm CO2 der Grenzwert für eine gute Luftqualität sind. Allerdings gab es 1858 noch keine hochdichten Gebäudehüllen oder Isolierglasfenster. Zudem war der natürliche CO2 Gehalt in der Außenluft mit 350 ppm noch deutlich niedriger als heute mit durchschnittlich 400 ppm (in Städten oft 450 – 500 ppm). So fand die Pettenkofer-Zahl auch keinen Einzug mehr in die entsprechende DIN-Normen.

In der DIN 1946-2 ging man von 1.500 ppm als Grenzwert für den CO2-Gehalt in der Luft von Innenräumen aus, ohne aber wissenschaftliche Grundlagen dafür zu nennen. Diese DIN-Norm wurde durch die DIN 13779 ersetzt und hier wurden 4 IDA-Kategorien (In Door Air) definiert, die eine CO2 Konzentration über der Außenluft definieren:

Kategorie Beschreibung Erhöhung gegenüber Außenluft in ppm Absoluter CO2 Gehalt bei 400 ppm CO2 in Außenluft
IDA 1 Hohe Raumluftqualität <= 400 <= 800
IDA 2 Mittlere Raumluftqualität > 400 – 600 > 800 – 1000
IDA 3 Mäßige Raumluftqualität > 600 – 1000 > 1000 – 1400
IDA 4 Niedrige Raumluftqualität > 1000 > 1400

Einteilung der Raumluftqualität in IDA-Kategorien

Wohnt man in einer belebten Innenstadt, kann man für die Außenluft schon Werte um 500 ppm annehmen und die absoluten Werten erhöhen sich entsprechend.

Lüftungs-Ampel mit ESPHome und MH-Z19B Sensor

Um die CO2-Belastung in der Luft messen zu können, benötigt man einen entsprechenden Sensor. Sehr gut verfügbar und relativ preiswert sind die CO2-Sensoren vom Typ MH-Z19B, die 25 Euro kosten. Diese Sensoren arbeiten nach dem NDIR-Prinzip. Eine kleine Glühlampe wird als breitbandige Infrarotquelle genutzt, damit eine Probenkammer durchleuchtet und dann über einen Filter auf einen Infrarotsensor geleitet. Der Filter ist dabei so schmalbandig ausgelegt, dass die CO2-Moleküle das Infrarotlicht absorbieren und somit weniger Licht auf den Sensor fällt. Je höher die CO2-Konzentration in der Messkammer, desto weniger Infrarotstrahlung fällt auf den Sensor.

Ausgelesen wir der MH-Z19 per seriellem UART-Interface mit 9600 Baud, kann also ganz einfach angebunden werden. Wichtig ist, dass er mit 5 Volt versorgt wird. Er funktioniert zwar grundsätzlich auch mit 3,3 Volt, allerdings weichen die gemessenen Werte dann stark ab. Das Datenblatt nennt einen Spannungsbereich von 3,6 bis 5,2 Volt. Schön ist hingegen, dass man die seriellen RX/TX-Anschlüsse ohne Pegelkonverter an 3,3 Volt-GPIOs wie etwa am ESP8266 oder Raspberry Pi nutzen kann.

Prototyp mit MH-Z19 Sensor

Da ich den Sensor ohnehin mit Home Assistant (HA) nutzen wollte, musste das Rad dazu nicht neu erfunden werden und man muss das auch nicht von ganz vorne programmieren.

Home Assistant bringt mit ESPHome seine eigene Plattform für ESP-Microcontroller mit, die sich über Home Assistant flashen, programmieren und aktualisieren lässt. Außerdem werden sie über eine native API an HA angebunden und nicht per MQTT, was die ganze Sache noch schneller und komfortabler macht.

ESPHome-Verwaltung in Home Assistant

ESPHome-Verwaltung in Home Assistant

Wenn man einen jungfräulichen ESP, Wemos oder auch Sonoff vor sich hat, kann man die passende Firmware direkt in HA erstellen und kompilieren lassen. Entweder steckt man dann den Mikrocontroller an einem USB-Anschluss des HA-Rechners an und kann damit die Firmware direkt flashen oder man speichert sich die Binary-Datei und flasht sie z. B. mit einem Tool wie dem NodeMCU-Flasher oder dem ESPHome-Flasher auf einem anderen Rechner. Hatte man schon einmal eine Firmware wie Tasmota, ESPEasy (mein Favorit vor ESPHome) oder Espurna drauf, kann man die von HA erzeugte Firmware direkt über deren Firmware-Update aufspielen.

Wichtig zu wissen ist dabei, dass ESPHome im Gegensatz zu etwa Tasmota kein eigenes Webinterface hat. Sämtliche Konfiguration geht von Home Assistant aus.

Anschluss und Programmierung

Ich habe für meinen Prototyp einen einfachen ESP8266 mit Adapterplatine eingesetzt. An welche GPIOs der MH-Z19 und die anderen Bauteile angeschlossen werden müssen, hängt von eurem Board ab. Nach den Einstellungen für das WLAN und ggf. einen Fallback-Hotspot für den ESPHome, werden ab Zeile 34 die UART-Pins definiert. In meinem Fall ist das GPIO 4 für den RX-Pin und GPIO5 für den TX-Pin des Sensors. Die Baudrate wird auf 9600 bps eingestellt.

Die Bibliotheken für den MH-Z19 Sensor kennt Home Assistant schon und sie stehen ohne weitere Installation zur Verfügung. Die Sensor-Plattform wird ab Zeile 39 gesetzt. Mit on_value_range ab Zeile 44, können nun die LEDs angesteuert werden. Diese sind über 150 Ohm Widerstände an den GPIOs 16 (grün), 14 (gelb) und 12 (rot) angeschlossen und können mit den YAML-Anweisungen below, above und then entsprechend auf HIGH oder LOW gesetzt werden. Innerhalb Home Assistant werden die LEDs als switch-Plattform behandelt (ab Zeile 68).

esphome:
  name: co2
  platform: ESP8266
  board: esp01_1m

wifi:
  ssid: "MEINE-SSID"
  password: "MEIN-WLAN-PASSWORT"

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Co2 Fallback Hotspot"
    password: "MEIN-PASSWORT"

captive_portal:

# Enable logging
logger:

# Enable Home Assistant API
api:
  password: "MEIN-API-PASSWORT"

#Service fuer HA definieren um Kalibrierung aus HA steuern zu koennen
  services:
    - service: mhz19_calibrate_zero
      then:
        - mhz19.calibrate_zero: sens1

ota:
  password: "MEIN-OTA-PASSWORT"


# Serielle Schnittstelle definieren
uart:
  rx_pin: GPIO4
  tx_pin: GPIO5
  baud_rate: 9600

# Sensor konfigurieren
sensor:
  - platform: mhz19
    co2:
      name: "MH-Z19 CO2 Value" #Entity-ID in HA
      id: co2val
      on_value_range: # Schwellwerte für die Ampel
        - below: 1200
          then:
            - switch.turn_on: green_pin
            - switch.turn_off: yellow_pin
            - switch.turn_off: red_pin
        - above: 1200
          then:
            - switch.turn_off: green_pin
            - switch.turn_off: red_pin
            - switch.turn_on: yellow_pin
        - above: 1800
          then:
            - switch.turn_off: green_pin
            - switch.turn_off: yellow_pin
            - switch.turn_on: red_pin
    temperature:
      name: "MH-Z19 Temperature"
    update_interval: 60s
    automatic_baseline_calibration: false
    id: sens1


# Switch Plattform und GPIOs fuer LEDs definieren
switch:        
  - platform: gpio
    pin: GPIO12
    id: red_pin
    name: "CO2 rot"
  - platform: gpio
    pin: GPIO14
    id: yellow_pin
    name: "CO2 gelb"
  - platform: gpio
    pin: GPIO16
    id: green_pin
    name: "CO2 grün"

Mit dieser Konfiguration kann der ESPHome auch ohne Home Assistant als CO2-Ampel arbeiten, denn die LEDs werden direkt von der Logik auf dem ESPHome geschaltet.

Interessant ist die Zeile 63: Wird diese auf TRUE gesetzt, kann der MH-Z19 kalibriert werden. Dazu lässt man ihn 24 Stunden bei einer definierten CO2-Konzentration, also am besten in einem gut gelüfteten Raum ruhen. Bei guter Lüftung beträgt der CO2 Gehalt etwa 400 ppm. Der Sensor misst über den Kalibrierzeitraum die aktuelle Konzentration und schreibt den niedrigsten Wert als Baseline in sein EPROM, welcher dann als Referenz genommen wird. Danach stellt man die automatic_baseline_calibration wieder auf false.

Noch komfortabler geht es, wenn man einen Service für Home Assistant definiert, mit dem man die Kalibrierung aus HA aktivieren kann. Das geschieht in der ESPHome Konfiguration in Zeile 24.

Kalibrierung über einen Service in HA starten

In HA muss dann nur noch in den Developer Tools der Service ausgewählt und mit Call Service gestartet werden. Dabei sollte sich der Sensor wieder in einer Umgebung mit 400 ppm Kohlendioxid befinden. Nach einigen Stunden Kalibrierung startet man den ESP einfach neu. Damit beendet sich auch der Service und der Sensor arbeitet wieder im Normalbetrieb mit neuer Kalibrierung.

Der Sensor wird alle 60 Sekunden ausgelesen und die Werte zu Home Assistant übertragen. Über die Konsole von HA kann man sehen, was der neue ESPHome gerade macht:

Konsolen-Ausgabe des neuen ESPHome mit CO2 Ampel

Apropos Kalibrierung: nachts sind die CO2 Werte außen tatsächlich höher als am Tag. Der Grund dafür ist die geringere Photosynthese der Pflanzen. Gleiches gilt für die kalte Jahreszeit. Das ist selbst mit dem MH-Z19 messbar, hat aber wenig Einfluss auf die Kalibrierung, da es sich im 2-stelligen Bereich bewegt. Dieses Dokument zu “15 Jahre CO2 Messung in Hessen” erklärt das sehr interessant.

Messwerte und Erfahrungen

Ich habe die Messwerte mit meinem Airthings Wave Plus verglichen und die Messwerte korrelieren sehr gut. Die CO2-Ampel springt nun beim Überschreiten von 1200 ppm CO2 gelb und ab 1800 ppm rot. Lüftet man mehrere Minuten, wird die CO2-Ampel wieder grün.

Ein dauerhafter Wert von unter 1000 ist selbst in einem Raum mit 25 qm nur zwei Personen dauerhaft nicht möglich. Spätestens nach 2 Stunden überschreitet der Wert die 1000er Marke, bewegt sich aber dann bei Werten bis maximal 1500 ppm. 5 Minuten Stoßlüften mit offener Terrassentür senkt den Wert dann wieder an die 400er Grenze.

Schöne Diagramme Influx und Grafana

24 Stunden CO2-Messung im Homeoffice mit 2 Personen

Diese Messwerte erfasse ich mit der InfluxDB und dem Visualisierungs-Tool Grafana, das in Home Assistant einfach nachinstalliert werden kann. Die Auswertung für den Verlauf sieht in Grafana so aus:

Grafana Einstellungen und Query für die Verlaufsanzeige

Die “Gauge” Anzeige so:

In Grafana kann man auch Schwellwerte konfigurieren, die nicht nur der optischen Anzeige dienen, sondern auch aktiv für Benachrichtigungen eingesetzt werden können. Grafana unterstützt hier neben E-Mail auch Telegram, Slack, Microsoft Teams oder Google Hangouts. Eine Übersicht dazu gibt es HIER. Ich ziehe es jedoch vor, die Benachrichtigungen direkt aus Home Assistant heraus zu machen, dann habe ich nicht unterschiedliche Systeme.

Da die Werte nun auch in Home Assistant zur Verfügung stehen können sie hier z. B. genutzt werden, um ebenfalls Benachrichtigungen per Telegram zu versenden oder als Alexa Sprachnachricht mit freundlicher Aufforderung zu Lüften. Das kann Grafana nicht.

Die CO2-Ampel in Home Assistant

Die LEDs zeigen ihren Status als Schalter an. Ebenso könnte man Home Assistant und die Switches der Ampel dazu nutzen einen automatischen Fensterantrieb und ein Lüftungssystem zu steuern.

Was kommt noch?

Der Sensor läuft nun seit dem 30. Oktober ohne Probleme und animiert uns dazu öfter zu lüften, als wie es sonst getan hätten. Nicht weil wir uns vor Corona schützen wollen, sondern weil die Luft angenehmer ist und man sich so im Homeoffice besser und länger konzentrieren kann.

Nun muss ich noch eine Platine dafür entwerfen. Ein BME280 Sensor für Luftfeuchtigkeit und genaue Temperaturmessung kommt auch noch drauf und ein kleiner Lautsprecher erinnert mit dezentem Piepsen dran, wieder mal das Fenster aufzumachen – oder auch zu schließen, wenn die Temperatur zu stark abfällt. Noch ein schönes Gehäuse gedruckt und fertig ist die CO2 Ampel für weniger als 40 Euro.

Darum ist Home Assistant die beste Smarthome Software!

Der Hauptgrund für die Auswahl von Symcon war bei mir die gute Unterstützung unseres LCN Issendorf Gebäudeautomationssystems. Bei OpenHAB wird das Thema nur sehr stiefmütterlich behandelt, weil die Verbreitung auch nicht sehr hoch ist – zumindest im privaten Bereich. Die anderen Systeme habe ich mir damals aus reinem Interesse angesehen und getestet.

Vom gesamten Konzept ist Symcon sehr schlüssig, unterstützt alle wichtigen Komponenten, Systeme und Protokolle und war für mich als PHPler schön, da mir damit das Schreiben von eigenen Skripten und Funktionen sehr leicht gefallen ist.

Was mich daran stört, sind die Dashboards, die nicht so richtig sexy und teilweise ziemlich unhandlich sind. Auch die Darstellung von Diagrammen ist nicht besonders praktisch und schön gelöst und gerade die sind für mich sehr wichtig, konnte ich mit diesen Auswertungen doch unsere komplette Heizung um 30 % optimieren.

Da schon einiges an Konfigurationsaufwand und Gehirnschmalz in Symcon geflossen ist und ich grundsätzlich damit zufrieden war, Stand ein Wechsel bislang nicht im Raum. Bislang …

Home Assistant und Unraid

Begonnen hat alles mit meinem Umstieg auf Unraid bei meinem Smarthome-Server/NAS (Details dazu HIER). Mit der Docker-Integration von Unraid konnte ich schnell einen Blick auf Home Assistant werfen, ohne einen Raspi startklar machen zu müssen, da Home Assistant Core als fertige Anwendung in den Unraid Community Apps zu finden ist.

Home Assistant (kurz: HA) hatte ich mir 2016 schon einmal genauer angesehen, als wir uns für den Kauf unseres Hauses entschieden hatten. Da das Projekt damals aber erst 3 Jahre jung war, keine LCN-Unterstützung bot und auch sonst noch keinen vollständigen Eindruck machte, habe ich es als Smarthome-Lösung für unser Haus wieder verworfen.

Per Autodiscover gefundene Sensoren und Eingänge

2020 war mein Eindruck von Home Assistant ein völlig anderer: Schicke, sehr detailliert konfigurierbare Dashboards, tolle Anzeigen und Elemente und flotte Bedienung. Noch interessanter war aber, dass Home Assistant beim Start automatisch per Autodiscover nach bekannten Geräten und Systemen suchte und ZigBee (über den Conbee-Stick), TV-Geräte, Fritzbox und vieles mehr bereits fix und fertig integriert und nutzbar waren.

Mit der Smartphone-App von Home Assistant war sogar mein Samsung mit Akkustand, Standort (Geofencing out of the Box), Speicherplatz, Bluetooth-Verbindungen etc. sofort Teil des Smarthome Systems. Eine Visualisierung ist bereits im Grundsystem möglich.

Home Assistant und Hass.io

Das Docker-Image von Home Assistant für Unraid besteht aus dem Home Assistant Core, mit dem ich die ersten Versuche gemacht habe. Es gibt jedoch auch Hass.io. Das ist ein komplettes Betriebssystem mit allen notwendigen Voraussetzungen für Home Assistant. Zusätzlich bringt es aber Updates per Mausklick, Backup, einen Community-Store für Erweiterungen und jede Menge anderer Vorzüge mit.

Mit Home Assistant starten- welche Plattform wählen?

Hass.io kann als fertiges Image auf einem Raspberry Pi innerhalb von Minuten betriebsbereit sein, wobei aktuell noch kein Raspbery Pi 4 unterstützt wird. Hass.io läuft aber auch auf einem PC, QNAP und Synology NAS-Systemen, einem Intel NUC oder – wie in meinem Fall – als virtuelle Maschine in Unraid.

Für Hass.io gibt es ein Abo für $5 pro Monat, das den Fernzugriff und die Nutzung von Amazon Alexa extrem vereinfacht. Zudem unterstützt man damit die Weiterentwicklung von Home Assistant. Grundsätzlich braucht man es aber nicht, muss jedoch etwas mehr Aufwand in die Konfiguration von Alexa stecken.

Konfiguration, YAML, VS Code und Node-Red

Die Konfiguration von HA erfolgt mittels YAML, einer Auszeichnungssprache zu der auch JSON gehört. In der configuration.yaml legt man alle Sensoren, Schalter, Lichter, Anbindungen etc. an, die in HA zur Verfügung stehen sollen.

Das ist anfänglich ein bisschen ungewohnt und die Syntax mit ihren Einrückungen muss man verstehen. In Hass.io kann jedoch Microsofts VS Code direkt in HA integriert und genutzt werden. Durch die Home Assistant Erweiterung für VS Code können die Konfigurationsdateien komfortabel mit entsprechenden Fehlerhinweisen etc. bearbeitet werden.

Tatsächlich lassen sich dann aber auch ziemlich komplexe Automationen über recht einfache YAML-Konstrukte realisieren. Entitäten, also ein Messwert eines Sensors, ein Schalter oder eine Lampe können einfach zu Gruppen zusammengefasst werden, die sich dann gemeinsam schalten und steuern lassen. Mit den aktuellen Versionen von Hass.io kann aber auch immer mehr ohne YAML über die Bedienoberfläche konfiguriert werden.

Node-Red Integration in Home Assistant

Vollständig baff war ich, als ich die Integration von Node-Red in Home Assistant gesehen habe. Durch die speziellen Home Assistant Nodes, bilden Home Assistant und Node-Red eine Einheit und man kann auch Node-Red für Automationen etc. nutzen. Viele HA-Nutzer setzen bei ihren Konfigurationen vollständig auf Node-Red, da man hier eine visuelle Darstellung einer Automation hat.

Wem das noch nicht genügt, kann über die Erweiterung AppDaemon Python Programme zur Automation einsetzen und damit auch die komplexesten Aufgaben bewältigen.

Lovelace – das Home Assistant Frontend

Das Frontend von HA wurde Anfang 2019 auf Lovelace umgestellt. Vorher organisierte sich das Frontend nach einem Algorithmus von selbst und konnte nur durch YAML angepasst werden. Mit Lovelace kann man sich nun seine Frontends beliebig gestalten.

Mit 24 Cards können die unterschiedlichsten Funktionen und Sensoren übersichtlich und attraktiv dargestellt werden. So lassen sich z. B. auch einzelne Schalter zu einer Gruppe kombinieren, die dann auch gleich einen zentralen Schalter hat, die auf alle Elemente in der Gruppe wirkt. Die Cards lassen sich individuell in Look and Feel konfigurieren. Über den Community-Store kann man zig weitere Cards und Themes installieren. Die Anzahl der Frontends ist beliebig und zukünftig sollen diese auch automatisierbar sein. Man könnte dann etwa je nach Tageszeit oder anwesenden Personen ein angepasstest Dashboard einblenden.

Gerade bei Integration neuer Geräte und Sensoren ist die Minimal-Ansicht sehr hilfreich, in der automatisch alle neuen Entitäten aufgelistet und bedienbar sind.

Optisch macht das HA Frontend einen sehr sauberen, modernen und attraktiven Eindruck. Dazu zählen auch die schicken Mediaplayer.

Eine Visualisierung des Smarthomes ist Grundbestandteil des Frontends und lässt sich sehr flexibel umsetzen.

Home Assistant Smartphone App

Die Smartphone-App für Android und iOS hat es ebenfalls in sich und wird ebenso schnell weiterentwickelt, wie HA selbst. Geofencing, Personenerkennung und Daten zum Smartphone wie Standort, Akkustand oder Alarmeinstellungen sind schon mit dabei und die App kann Push-Nachrichten von HA empfangen.

Sehr neu ist die Integration von NFC-Tags. Diese kleinen Aufkleber können mit einem NFC-fähigen Smartphone gelesen und in HA sehr komfortabel entsprechenden Funktionen zugeordnet werden. So könnte man das Smartphone im Auto auf ein entsprechendes Tag legen und damit das Garagentor öffnen oder schließen lassen – natürlich nur, wenn man sich auch im Geofencing-Bereich befindet.

Home Assistang App

Ein NFC-Tag an der Wand kann zusammen mit dem Smartphone auch ein Lichtschalter oder eine Zugangskontrolle sein. Man braucht also keinen NFC-Leser am Eingang, sondern nur das robuste und billige NFC-Tag – und das Smartphone. Die Home Assistant App dient dabei auch als Schreiber für NFC-Tags. Allein diese Funktion bietet unendlich viele Möglichkeiten.

Home Assistant und LCN

Ein Großteil meiner Steuerung setzt auf LCN. Die Einrichtung meiner vielen LCN-Module, Relais und Variablen bedeutete etwas Tipparbeit. Nachdem alle Ausgänge, Bewegungsmelder und Sensoren angelegt sind, funktioniert LCN mit Home Assistant tadellos. Tastenbefehle können ganz offiziell genutzt werden und HA lässt auch den Zugriff auf Regler, Schwellwerte, LEDs und Logik zu. Natürlich kann man auch die Texte der LCN-GT4 und LCN-GT12 Displays von HA aus ansteuern.

VS Code in Home Assistant und die LCN Configuration

In der Konfiguration der Ausgänge können Rampenzeiten für dimmbare Ausgänge vorkonfiguriert werden. Damit geht die Beleuchtung sanft an und aus, ohne das dafür zusätzlicher Konfigurationsaufwand anfällt.

Home Assistant Add-On Store

Hat man Hass.io installiert, hat man auch den Add-On Store zur Verfügung. Darin findet man bekannte Anwendungen wie Grafana, InfluxDB, AdGuard, NGINX Reverse Proxy, Let’s Encrypt, Mosquitto MQTT Broker und vieles mehr. Diese Anwendungen können per Mausklick installiert und konfiguriert werden. Auch Updates werden von Hass.io aus gesteuert. Noch mehr: Die Anwendungen sind perfekt in Home Assistant integriert und von der konfigurierbaren Menüleiste links erreichbar.

Home Assistant Add-on Store

Gerade die Integration von InfluxDB und Grafana ist kinderleicht und man hat damit eine mächtige und sehr attraktive Lösung für Diagramme, Statusmeldungen und andere Darstellungen zur Verfügung. HA kann alle Ereignisse in die InfluxDB schreiben, es lassen sich aber auch bestimmte Sensoren oder Gruppen definieren, die eingeschlossen oder ausgelassen werden sollen.

Zum Add-On Store gesellt sich zusätzlich HACS – der Home Assistant Community Store. Hier findet man noch einmal hunderte von Integrationen z. B. für Plex, OpenSprinkler, Bosch Indego Rasenroboter aber auch zusätzliche Cards (Anzeigeelemente) für das Frontend oder fertige Automationen als Vorlage. Insgesamt kann man damit auf über 1600 Integrationen und Add-Ons zurückgreifen.

ESPHome – perfekte Integration für Sonoff, ESP8266 etc.

Ich stehe ja auf DIY-Sensoren auf Basis von ESP8266 oder ESP32. Bislang habe ich dazu auf ESPeasy gesetzt, um auch die Sonoff-Geräte in Symcon einzubinden. Home Assistant bring hier eine eigene Plattform mit, ESPHome, die perfekt in HA integriert ist. ESPHome unterstützt praktisch alle bekannten Sensoren und Aktoren und kann aus der HA Oberfläche heraus programmiert und auf den neuesten Stand gebracht werden. So kann man alle ESPHome Geräte per Mausklick über das WLAN aktualisieren. Neue Konfigurationen werden in HA kompiliert und per OTA (Over the Air) zum ESP-Gerät übertragen.

Sonoff Geräte über WLAN-Konfigurieren und flashen

Programmiert werden die ESPs auch wieder mit YAML, was aber sehr viel einfacher ist, als es klingt. Ein Vorteil dabei: Man kann eine Konfiguration ganz schnell auf mehreren Geräten verteilen.

Was mir an ESPHome besonders gut gefällt, ist die Möglichkeit auch umfangreiche Berechnungen oder Automationen direkt im Modul zu erledigen. Damit kann ein Modul wichtige Steuerungsaufgaben auch unabhängig von Home Assistant erledigen. Mein ESP8266 Wemos Modul mit BME280 Sensor (Temperatur, Luftfeuchtigkeit, Luftdruck), liefert so auch gleich die absolute Luftfeuchtigkeit, Taupunkt und den höhenkorrigierten Luftdruck.

Sonoff Konfiguration mit Berechnungen im Modul

Wer bislang auf die alternative Firmware Tasmota gesetzt hat, findet bei Home Assistant mit TasmoAdmin ebenfalls ein Werkzeug, um alle Tasmota/Sonoff Geräte zentral bearbeiten und aktualisieren zu können – oder man steigt gleich auf ESPHome um.

Home Assistant Grundlagen mit Kaffeemaschine und Alexa

Die Home Assistant Community

Home Assistant gehört zu den 10 größten Open-Source-Projekten auf Github. 1900 Core-Entwickler sorgen für eine rasante Weiterentwicklung des Systems, bei dem es praktisch wöchentlich ein neues Release gibt. Weitere 63.000 Entwickler sorgen für Erweiterungen und Anpassungen anderer Systeme.

Die Home Assistant Community ist riesig, sehr aktiv und hilfsbereit. Neben dem eigenen Forum gibt es ein Sub-Reddit für HA und einen Discord-Channel mit 53.000 Mitgliedern.

Der einzige Nachteil könnte für manchen Anwender sein, dass bei HA englisch gesprochen wird und auch die hervorragende Dokumentation englisch ist.

Wenn Englisch (mit einem leichten australischem Einschlag) kein Problem ist, kann ich den Home Assistant Podcast wärmsten empfehlen. Hier erfährt man nicht nur in sehr unterhaltsamer Weise Neuigkeiten zu Home Assistant, sondern auch, was andere HA Anwender umgesetzt haben, denn in jeder Episode gibt es einen Gast aus der Community. Der Podcast läuft seit Tagen in meinem Tesla.

Fazit

Home Assistant hat mich mehr als überzeugt. Home Assistant und Hass.io bieten einen bislang unerreichten Funktionsumfang, bei gleichzeitiger Stabilität und durchdachter Konfiguration und Bedienung. Die riesige Community und die viele freiwilligen Entwickler sorgen für ein enormes Tempo bei der Weiterentwicklung.

Gerade die direkte Integration von zusätzlichen Diensten und Anwendungen wie InfluxDB, MariaSQL, MotionEye (Überwachungskameras), Grafana, Deconz (Conbee Stick) usw. machen Home Assistant zur besten Lösung für anspruchsvolle Smarthome-Besitzer. Integriertes Backup mit Snapshots, Versionierung der eigenen Einstellungen mit Github und Hass.io als zugrundeliegendes Betriebssystem schützen vor Konfigurationsfehlern und sichern den problemlosen Betrieb.

Manuelle und automatische Snapshots und Backups

Natürlich muss man sich erst einmal einarbeiten, Begrifflichkeiten und Architektur verstehen. Dabei hilft die Community ungemein, wo viele Anwender auch ihre Konfiguration auf Github zur Verfügung stellen. Viele Automationen kann man sich dort einfach abschauen, kopieren und an die eigenen Anforderungen anpassen. Das führt dazu, dass man anhand dieser vielen Praxisbeispiele sehr schnell einen Einstieg in Home Assistant schafft.

Ich bin gerade dabei meine bisherige Symcon-Konfiguration zu Home Assistant zu übertragen. Eigene PHP-Skripte habe ich bereits umgeschrieben oder konnte auf fix und fertige Lösungen von HA zurückgreifen. Symcon ist eine tolle Smarthome-Zentrale. In größeren Ausbaustufen allerdings auch nicht so ganz günstig und hat als Closed-Source Anwendung mit Fokus auf deutschsprachige Anwender auch nicht die Möglichkeiten, welche die große Home Assistant-Gemeinde hat. Letztendlich war es das Gesamtpaket aus tollem Frontend, umfassender Integration von anderen Systemen wie Node-Red oder DeConz und schneller Weiterentwicklung die mich dazu bewegten Symcon abzulösen.

Um nun noch einmal die Überschrift aufzugreifen: Ja, Home Assistant ist für mich die beste Smart Home Software und wenn die Entwicklung so schnell weitergeht wie bisher, werden es andere Lösungen zukünftig schwer haben. Home Assistant hat das Zeug, den Standard in diesem Bereich zu definieren.

Mehr Infos: https://www.home-assistant.io/

ESP32-Cam Probleme beheben

Die ESP-Familie von Espressif ist durch den ESP8266 bekannt geworden, der sich in vielen WLAN-Steckdosen, Lampen und anderen Geräten findet. Eine günstige Variante kommt mit einer Kamera und lässt sich zur Überwachungskamera umbauen. Es ist sogar eine Gesichtserkennung möglich. Die Kamera liefert einen Live-Stream und bietet jede Menge Einstellungsmöglichkeiten per Web-Interface:

Das Web-Interface des ESP32-CAM Beispiels

Das Web-Interface des ESP32-CAM Beispiels

ESP32-Cam mit der Arduino-IDE flashen

Die ESP-Mikrocontroller lassen sich mit der Arduino-IDE flashen und programmieren. Hier in aller Kürze die wichtigsten Einstellungen.

In der Arduino-IDE wird zunächst die Quelle für die Board-Informationen eingebunden:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

Zusätzliche Board-Verwalter URLs in der Arduino IDE eintragen

Die URL wird unter “Zusätzliche Boardverwalter-URLs” eingetragen

Mehrere Einträge werden mit einem Komma getrennt. Damit kann man im Anschluss unter Werkzeuge->Board->Boardverwalter die Definitionen für die ESP32 Boards installieren. Einfach ESP32 in der Suche eingeben und das Board installieren.

ESP32 Board installieren

ESP32 Board installieren

Nach der erfolgreichen Installation wählt man das Board ESP32 Wrover Module aus. Die Board-Einstellungen erfolgen normalerweise automatisch und sollten wie im Screenshot aussehen:

ESP32 Wrover Module auswählen

ESP32 Wrover Module auswählen

Zur Programmierung der günstigen ESP32-Cam Boards braucht man einen FTDI-Adapter. Der 3,3 Volt und GND-Anschluss des FTDI-Adapters kommt auf den 3,3 V und GND auf dem Board, dabei nicht vergessen, den Jumper für die Spannung auf dem FTDI-Adapter auch auf 3,3 Volt zu stecken, sonst killt ihr euren ESP32! Der RX-Anschluss des Adapters kommt auf den UOT-Anschluss am ESP32 und der TX-Anschluss auf den UOR-Anschluss des ESP. Wenn ihr den FTDI-Adapter an eurem Rechner anschließt, zeigt er sich als neuer COM-Port (PC). Diesen COM-Port stellt ihr in den Board-Einstellungen (letzter Screenshot) unter Port ein. Um den ESP32 flashen zu können, braucht ihr eine Brücke zwischen GND und IO0, nur dann kann der ESP32 programmiert werden.

Unter Datei->Beispiele->ES32->Camera könnt ihr nun das CameraWebServer Script laden. Hier müssen folgende Zeilen angepasst werden:

#include "esp_camera.h"
#include <WiFi.h>

//
// WARNING!!! Make sure that you have either selected ESP32 Wrover Module,
//            or another board which has PSRAM enabled
//

// Select camera model
//#define CAMERA_MODEL_WROVER_KIT
//#define CAMERA_MODEL_ESP_EYE
//#define CAMERA_MODEL_M5STACK_PSRAM
//#define CAMERA_MODEL_M5STACK_WIDE
#define CAMERA_MODEL_AI_THINKER

#include "camera_pins.h"

const char* ssid = "DEINE-SSID";
const char* password = "DEIN-WLAN-PASSWORT";

void startCameraServer();

void setup() {
  Serial.begin(115200);
  Serial.setDebugOutput(true);
  Serial.println();

Hat man das Script wie oben geändert und abgespeichert, kann der ESP32 geflasht werden. Dazu klickt ihr auf den Pfeil oben links in der Arduino-IDE und gleich danach die Reset-Taste auf dem ESP32. Nun sollte das Programm zum ESP32 hochgeladen werden. Die IDE bestätigt euch den erfolgreichen Upload. Das sollte in etwa so aussehen:

Erfolgreicher ESP32-Cam Flash-Vorgang

Erfolgreicher ESP32-Cam Flash-Vorgang

Nun entfernt ihr die Brücke zwischen GND und IO0 wieder, da sonst das Programm nicht gestartet wird (der ESP32 bleibt dann im Programmiermodus). Danach öffnet ihr die serielle Konsole in der IDE und drückt erneut die Reset-Taste. Wenn ihr nun nach einigen Zeilen

1
2
3
4
WiFi connected
Starting web server on port: '80'
Starting stream server on port: '81'
Camera Ready! Use 'http://192.168.1.34' to connect

seht, lief alles super und ihr könnt über die angegebene IP-Adresse das Setup-Interface aufrufen und über http://192.168.1.34:81/stream (natürlich mit eurer IP-Adresse) das Live-Bild der Kamera betrachten.

Probleme mit dem ESP32-Cam Modul beheben

Eines der größten Probleme des Moduls ist der “Brownout”. Als Brownout wird ein kurzzeitiges Absinken der Spannung bezeichnet und genau das passiert bei vielen ESP32-Cam Clones, sobald das WLAN starten möchte. Viele FTDI-Programmer und die dazu angeschlossenen USB-Kabel können die kurzzeitig hohen Ströme beim Start der WLAN-Verbindung nicht liefern und in der seriellen Konsole der Arduino IDE wird dann “Brownout detector was triggered rst:0xc …” angezeigt.

Erste Abhilfe schaffen bessere USB-Kabel. Zudem sollte man im Echtbetrieb den ESP32 über den 5 Volt-Anschluss mit Strom versorgen. Ebenso ist ein 220 µF Elko am 5V- und GND-Pin hilfreich.

Elko am ES32

Ein weiteres Problem ist aber die Stromversorgung selbst. Viele USB-Ports und Powerbanks liefern gerade mal so 5 Volt. Bei dem kurzzeitigen Strombedarf des ESP32 brechen diese aber schnell auf 4,8 Volt und weniger ein. Auf dem ESP32 befindet sich jedoch ein Spannungsregler vom Typ AMS1117, der nicht zu den allerbesten seiner Art gehört. Zwar kann er die gewünschte Ausgangsspannung von 3,3 Volt noch bis zu einer Eingangsspannung von 4,35 Volt (laut Datenblatt) stabil erzeugen. In der Praxis klappt das jedoch nicht wirklich und der Brownout wird provoziert.

In einem Test an meinem Rigol DP832 Labornetzteil habe ich festgestellt, dass der ESP32 erst ab 5,4 Volt am Eingang stabil arbeitet. Einige billige China-USB-Netzteile liefern genau diese überhöhten Spannungen und damit funktioniert der ESP32-Cam einwandfrei.

Da der AMS1117 Spannungsregler Eingangsspannungen bis 15 Volt verträgt, kann man den ESP32 mit 6 oder 7 Volt betreiben und vermeidet damit die genannten Probleme. Höhere Spannungen führen bei dem Linear-Regler natürlich auch zu mehr Verlusten und Abwärme.

Streifen im Bild

Ebenfalls mit einer zu niedrigen Versorgungsspannung hängen die horizontalen Streifen im Bild zusammen, die häufig bemängelt werden. Auch hier hilft eine einfache Anhebung der Versorgungsspannung am 5 Volt Eingang des ESP32 auf 5,5 Volt oder mehr.

Mangelnde WLAN-Reichweite

Die EPS32 Clones sind keine Reichweiten-Monster, wenn es um die WLAN-Verbindung geht. Allerdings befindet sich auf dem Board eine Mini-Coax-Buchse (MHF IV, I-PEX, HSC MXHP32). Das Problem daran ist, dass sie nicht einfach so genutzt werden kann. Um eine externe Antenne am ESP32 anschließen zu können, muss ein Bauteil umgelötet werden, das die Coax-Buchse statt der eingebauten Antenne verbindet.

Dabei handelt es sich um eine einfache SMD-Brücke im 0402 (01005) Format. Wir reden hier also von einem Bauelement, das weniger als einen halben Millimeter lang ist. So ein Teil von Hand aus- und wieder einzulöten ist selbst mit der besten Ausstattung praktisch unmöglich. Da es sich nur um eine Brücke handelt, kann man das Teil aber einfach auslöten und mit viel Fingerspitzengefühl gegen ein Stückchen Draht aus einer Ader einer Litze ersetzen. Ein Mikroskop macht diese Arbeit deutlich leichter.

Einfacherer Umbau für eine externe Antenne

Wer es einfacher möchte, trennt die interne Antenne an der Speiseleitung auf und lötet da die externe Antenne an. Ich habe übrigens die Antenne samt Coax-Kabel einer alten Fritzbox recycelt.

Fazit

Abgesehen von kleineren Quirks, ist die ESP32-Cam ein wirklich hilfreiches und preiswertes Teil, für die es jede Menge Anwendungen gibt.