Diversifizierung von ETF im Portfolio checken mit Portfolio Performance 7 Sep 11:21 AM (last month)

Spätestens seitdem Neobroker mit hohem Werbebudget den Markt auffrischen, ist für viele Menschen das Thema Geldanlage präsent geworden. Noch vor ein paar Jahren war der Erwerb von Wertpapieren mit solchen großen Hürden verbunden, dass sich viele Menschen nicht auf den Kapitalmarkt trauten. Inzwischen ist es auch für nicht-Finanzgurus wie mich möglich, sich unkompliziert Aktien und andere Anlageformen zuzulegen. Die Apps der Banken und Broker sind inzwischen recht benutzerfreundlich, was die Hürde weiter senkt. Wenn man sich der Sache wieder etwas ernster annähern möchte, kommt man mit den Apps aber schnell an seine Grenzen. Um besser den Überblick über meine Finanzen zu behalten, habe ich mich auf die Suche nach einer Software gemacht, die mich dabei unterstützt. Und ich bin in der Open Source Community fündig geworden.

Meine Fragestellung war folgende: Wie diversifiziert ist mein Portfolio eigentlich? In welchen Regionen und Branchen bin ich wie stark präsent? Welches sind meine Top-Firmen? Wie teilt sich mein Vermögen auf Aktien, ETFs und Cash auf? Wie stark bin ich in Small-Caps investiert? Wann und bei welchen Kurswerten habe ich gekauft und verkauft? Wie viele Dividenden habe ich inzwischen erhalten, usw.? Bisher habe ich das mit Excel lösen können. Die Fact-Sheets der ETF sind im Netz zu finden, dort sind die Verteilungen auf Regionen, Branchen usw. nachzulesen. Mit viel Tipparbeit holt man sich die aktuellen Verteilungen in die Datei, gewichtet sie nach aktuellem Wert im Portfolio und lässt es sich als Diagramm anzeigen. Aber: Das ist sehr aufwendig.

Portfolio Performance: Das mächtige Open Source Finanztool

Portfolio Performance ist hier einfacher. Nach der Installation kann man die PDF-Dateien seiner Bank und Broker importieren. Einfach den Kontoauszug und die Kauf- bzw. Verkaufsnachweise, Dividendenausschüttungen usw. in das Programm laden, und schon hat man den perfekten Überblick. Das Programm läuft lokal, was die Frage nach Datensicherheit vollkommen entschärft. Niemand hat Zugriff darauf, niemand kann sich die Daten ansehen. Meine Daten bleiben bei mir.

Neben dem PDF-Import der Bankdaten gibt es noch etliche weitere Importmöglichkeiten. Am gängigsten ist vermutlich das CSV-Format, das sich über einen tollen Assistenten gut importieren lässt.

Historische Kursdaten sind erstmal nicht vorhanden. Man kann sie sich über mehrere Wege ins Programm holen. Für mich am einfachsten ist der Weg über die Datenbank von Portfolio Performance selbst. Dort muss man ein kostenloses Benutzerkonto anlegen, dann kann man auf die historischen Daten dort zugreifen. Etliche andere Finanzportale sind ebenfalls kompatibel. Am Ende geht hier auch wieder CSV.

ETF- und Portfolio-Diversifikation anzeigen lassen

Über die Diagramme „Berichte → Vermögensaufstellung“ kann man sich anzeigen lassen, über welche Anlageklassen man zu welchen Teilen verfügt. Eine der Hauptfragen meinerseits war jedoch: Wie sieht es mit meiner ETF-Diversifikation aus?. Das geht derzeit noch nicht nativ in Portfolio Performance. Hierfür braucht man einen Drittanbieter.

Glücklicherweise gibt es findige Leute in der sehr aktiven Community, die sich die gleichen Fragen gestellt haben und eine Lösung zur Verfügung stellen. Über ein Skript des Users Alfonso1Qto12 kann man sich beispielsweise die Zusammensetzung der ETF über die Morningstar-API direkt in sein Portfolio Performance schreiben lassen.

Hinweis: Dieses Skript ist nach Aussage des Entwicklers experimentell und sollte nur mit einer Kopie der echten Daten benutzt werden! Stand September 2025 muss man den alternativen Branch wechseln, weil main noch auf eine alte API zugreift.

git clone https://github.com/Alfons1Qto12/pp-portfolio-classifier.git
git checkout new-api-branch
python3 portfolio-classifier.py -top_holdings 50 ./portfolio.xml ./portfolio-classified.xml

Über die Flag top_holdings 50 lasse ich mir aus den ETF die 50 wertvollsten Firmen ausgeben. Empfohlen wird, auf weniger als 100 Firmen zu gehen, um die Performance des Programms nicht zu gefährden.

Mit diesem Skript werden die Wertpapiere ihren Ländern, Regionen, Holdings usw. anteilsweise zugeordnet. Diese Daten werden direkt in die XML-Datei geschrieben und lassen sich anschließend in Portfolio Performance unter den „Klassifizierungen“ betrachten. Es gibt verschiedene Visualisierungsarten, am übersichtlichsten finde ich die Tabelle, das Kreis- und das Flächendiagramm.

Weitere Schritte und Lehren aus den Daten

Mit Portfolio Performance erhält man eine tolle Übersicht über seine Finanzen. Wie der Name schon verrät, kann man sich hier tolle Dashboards bauen, um die Performance im eigenen Portfolio zu überwachen. Alle gängigen Kriterien sind vorhanden und können in Dashboards oder vielfältige Diagramme eingebaut und visualisiert werden.

Die Daten lassen ein Rebalancing zu, dafür gibt es eigens eingebaute Funktionen. Über eine Smartphone-App lassen sich die Daten sogar auf dem Handy anzeigen. Die Synchronisation muss hier über Cloudanbieter durchgeführt werden, also zum Beispiel über die Nextcloud oder Dropbox. Daten einpflegen lassen sich übers Smartphone allerdings nicht.

Zusammengefasst: Wer eine sehr mächtige Open Source Software sucht, mit der man

sein Portfolio im Blick behalten kann,
das Daten aus vielen Quellen (inkl. PDFs von Banken und Brokern) verarbeiten kann,
Hilfestellung beim Rebalancing bietet,
auf einer aktiven Community aufbaut,
die sensiblen Daten lokal auf dem PC hält,
eine Datenaufbereitung fürs Smartphone bietet und
viele Hilfestellungen im Netz bereithält,

der ist bei Portfolio Performance gut aufgehoben.

The post Diversifizierung von ETF im Portfolio checken mit Portfolio Performance first appeared on bejonet - Linux | Smart Home | Technik.

Smarte Außenbeleuchtung mit Zigbee-Schnittstelle 23 May 9:16 AM (5 months ago)

Anzeige – Ich habe für diesen Artikel Produkte der Firma Paulmann zur Verfügung gestellt bekommen.
Wie man sein Smart Home mithilfe von Home Assistant und vielen kleinen Helferlein aufbaut, beschreibe ich nun schon seit geraumer Zeit hier im Blog. Dabei genieße ich es, dass die meisten Smart Home Anwendungen über den ein oder anderen Standard verfügen, mit dem sich Komponenten verbinden lassen. Bei Zigbee ist das generell zwar auch so, aber im Speziellen ist die Sache dann doch etwas komplizierter. Viele Anbieter von smarter Hardware haben auch eine Bridge, Gateway oder ähnliches im Portfolio, mit dem die Zigbee-Anbindung bewerkstelligt werden kann. So ist es auch bei meinen ersten Zigbee Produkten gewesen. Im Folgenden beschreibe ich, wie man die Zigbee Leuchten der Firma Paulmann aus der Serie „Plug & Shine“ einrichtet. Hierfür verwende ich deren Gateway namens Smik.

Bei der Sanierung unseres Außenbereichs haben wir viel Energie in die Auswahl der Materialien gelegt. Sowohl die Terrassenplatten, als auch die Mauersteine haben uns viel Kopfzerbrechen bereitet. Bei der Außenbeleuchtung war es glücklicherweise nicht ganz so schwierig, da die Auswahl an smarten Außenleuchten deutlich kleiner ist. So sind wir auf die Firma Paulmann aufmerksam geworden, die Zigbee-fähige Außenleuchten anbietet und noch dazu einen sehr einfachen Weg zu deren Einbindung bereithält.

Außenleuchten, welche Produkte habe ich verwendet?

Die Gartenmauer lassen wir uns mit der Leuchte „Plug & Shine Floor“ bescheinen. Sie leuchtet in weiß, die Farbtemperatur kann man hier einstellen. Außerdem hat sie alle RBG-Farben. Das ist ein tolles Feature, das man bei Gartenpartys verwenden kann. Über die Farbtemperatur vom weiß kann man die Lichtstimmung auf der Terrasse maßgeblich beeinflussen.

Den Treppenaufgang beleuchten wir mit der Pollerleuchte Ito. Diese ist von Haus aus leider nicht smart, lässt sich über den „Plug & Shine Controller“ aber smart machen. Mit diesem Controller kann man den gesamten Kabelstrang ein- bzw. ausschalten. Hier lassen sich weitere Paulmann-Produkte, die nicht von Haus aus smart sind, in die Steuerung einbinden und danach über das Smart Home steuern.

Die Einfassung der Terrasse beleuchten wir mit dem LED-Streifen „Plug & Shine Smooth Strip RGBW„, der Zigbee-fähig ist. Wie man dem Namen schon entnimmt, kann dieser in allen RGB-Farben leuchten. Für die Farbe weiß ist die Farbtemperatur wählbar.

Bäume und Sträucher setzen wir mit der smarten Leuchte „Plug & Shine Pike“ in Szene. Die Farben sind, ihr ahnt es schon, wieder in allen RBG-Farben möglich. Die Farbtemperatur von weiß ist wieder wählbar.

Elektrisch verkabelt werden die Leuchten mit Kabeln namens „Plug & Shine Connector„, die man in verschiedenen Längen und Anzahl von Abgängen erwerben kann. Das System ist einfach, aber genial: Eine 24 VDC-Spannungsquelle stellt die Spannung zur Verfügung. Die Kabel verfügen über Schraubverbinder, an die man wiederum die Leuchten verbinden kann. Auch Kabelabgänge als Verlängerungsleitung sind hiermit möglich. Die Kabel und die Verbinder sind dabei IP68 wasserfest – sogar für Pools geeignet. Die Anbindung der Leuchten ist somit werkzeuglos, verpolungssicher und sehr einfach möglich. Die Intelligenz der Leuchten steckt bereits in den Leuchten drin, sodass hier keine Bastel- oder Verkabelungsarbeit anfällt. Somit lässt sich das Projekt auch nach und nach erweitern.

Als Spannungsquelle verwende ich die „Plug & Shine Einspeisung 230/24V DC„. Diese sind mit IP67 ebenfalls für den Außenbereich geeignet. Ihre Größe kann man an der Gesamtleistung aller Leuchten berechnen. Es stehen mehrere Größen zur Verfügung. Durch die Kunststoff-Abdeckung „Plug and Shine Trafoabdeckung“ lässt sich das Netzteil sogar unauffällig verkleiden.

Zur Steuerung verwende ich die Fernbedienung „Plug & Shine Gent 2„. Mit ihr kann man die Leuchten gruppenweise an- bzw. ausschalten sowie die Farben vorgeben. Das ist sehr nett gelöst, da man über ein Farbfeld intuitiv die Farben auswählen kann. Großer Pluspunkt für die Fernbedienung! Dafür ist für die Einrichtung bzw. das Anlernen der Leuchten etwas Übung notwendig. Die Anleitung dazu liegt der Fernbedienung bei. Mit etwas Konzentration versteht man aber die Logik dahinter.

Einrichtung des Zigbee Gateways und der Leuchten

Dreh- und Angelpunkt für die Steuerung der Außenbeleuchtung ist das Gateway. Hier ist die Schnittstelle zwischen der Smartphone App und den Leuchten. Die Einrichtung ist denkbar einfach. Man schließt das Gateway mittels Ethernet-Kabel an das Netzwerk an (z.B. an eine Fritzbox) und stellt die Spannungsversorgung her. Die Schwierigkeit besteht in der sehr geringen Reichweite des Signals. Sie wird mit 100 m angegeben, berücksichtigt aber weder Wände noch Fensterscheiben. Folglich muss das Gerät sehr nahe an den Garten gebracht werden.

Auf dem Smartphone installiert man sich die App „Paulmann Smik“ und folgt den Anweisungen auf dem Bildschirm. Man muss im Laufe der Einrichtung den QR-Code auf der Rückseite des Gateways scannen. Hierdurch gelingt die Einrichtung sehr schnell und einfach.

Neue Leuchten fügt man hinzu, indem man sie auf Werkseinstellungen zurückstellt. Das ist etwas herausfordernd, da man die Leuchten hier schnell an- und ausschalten muss, insgesamt 5 mal hintereinander. Die Leuchte darf dabei nicht länger als 2 Sekunden an und nicht länger als 5 Sekunden aus sein. Ich habe das geschafft, indem ich die Spannungsversorgung an eine schaltbare Steckdose angeschlossen habe. Mit ihr kann ich über einen Schalter die Ein- und Ausschaltdauer sehr gut timen. Sobald sie zurückgesetzt wurden, können sie über die App gefunden werden.

Best Practises und Tipps

Gruppiert eure Leuchten am besten thematisch, um zusammengehörige Leuchten gemeinsam zu schalten. Ich habe beispielsweise die Mauerspots gruppiert. Sie liegen in der Fernbedienung auf der Schnellwahltaste 1. Ist die Gruppe gewählt, steuere ich alle Mauerspots gemeinsam. Die Fernbedienung erlaubt auch das Steuern von mehreren Gruppen gleichzeitig. Dadurch kann man die Farben von allen Leuchten gemeinsam verändern. Sehr nice!

Macht die Steckdose schaltbar. Wenn die Spannungsversorgung an einer schaltbaren Steckdose angeschlossen ist, könnt ihr die Leuchten sehr viel komfortabler zurücksetzen und für die Einrichtung vorbereiten.

Setzt das Gateway möglichst nahe an den Außenbereich. Die geringe Reichweite ist relativ nervig, daher muss das Gateway recht nahe an den ersten Teilnehmer. Das Signal wird vom ersten Teilnehmer verstärkt, sodass alle weiteren Leuchten dann gutes Signal haben sollten. In der Praxis muss man das ein bisschen ausprobieren, was gut funktioniert.

Ausblick: Einbindung in Home Assistant

Die Einbindung der Außenbeleuchtung in Home Assistant ist möglich. Hat man einen Zigbee-Stick, zum Beispiel den von Nabu Casa selbst, kann man die Lampen damit einbinden. Hierfür muss man eine Instanz von Zigbee2MQTT installiert haben. Bei vielen Home Assistant Anwendern geht das über den Addon Store oder über einen Docker Container, wie es bei mir der Fall ist. Aus zwei Gründen habe ich das bei mir allerdings nicht getan.

1) Die Steuerung über die Paulmann App bzw. über die Gent 2 Fernbedienung ist sehr komfortabel. Es sind viele Funktionen voreingestellt, die Wahl der Farbtemperatur zum Beispiel oder die sehr einfache Auswahl der Farbe über das Farbfeld ist sehr cool. In Home Assistant müsste man sich diese Funktionen erst selbst konfigurieren. Ich bin mir sicher, dass viele Leute das schaffen würden. Für mich steht der Aufwand in keinem Verhältnis.

2) Während er Zeit auf der Terrasse möchte ich weitestgehend auf das Smartphone verzichten. Für die Lichtsteuerung möchte ich deshalb nicht aufs Smartphone angewiesen sein. Im Gegenteil: ich möchte auch unseren Gästen die einfache Möglichkeit geben, unsere Beleuchtung zu kontrollieren. Die Fernbedienung ist hierfür ideal geeignet.

Für die Einbindung in Home Assistant gibt es jedoch ebenfalls gute Argumente

1) Das ganze Haus lässt sich über eine zentrale Steuereinheit kontrollieren. Hier wäre es nur konsequent, die Außenbeleuchtung mit einzubinden.

2) Logging und Kontrolle von den Lampen: Von unterwegs aus sehen, ob die Lampen noch an sind? Kann man mit Home Assistant.

3) Kombination mit anderen Systemen. Die Sensoren und Aktoren könnten auch von anderen Herstellern kommen. Dämmerungs- und Bewegungsmelder von Paulmann könnten dann auch andere smarte Aktoren schalten.

The post Smarte Außenbeleuchtung mit Zigbee-Schnittstelle first appeared on bejonet - Linux | Smart Home | Technik.

Timelapse aufnehmen und mit imagemagick und ffmpeg zu einem Video umwandeln 12 Apr 12:29 AM (6 months ago)

Dieser Beitrag stammt ursprünglich aus dem Jahr 2014, wurde 2025 aber nochmal grundsätzlich überarbeitet, vor allem der Imagemagick- und ffmpeg-Abschnitt.

Ich finde, dass es kaum schönere Videos von Landschaften oder Städten gibt als Zeitrafferaufnahmen. Diese haben meistens eine Dynamik, die das gewisse Extra ausmachen.

Jetzt habe ich bei eine recht gute Kamera herumliegen (Canon EOS 550D), die sehr gute Fotos macht. Jetzt hat sich mir die Frage gestellt: Kann man die Kamera in einstellbaren Intervallen auslösen lassen, sodass sie für mich die Zeitraffer-Fotos erstellt? Man kann!

Die Kamera zeitgesteuert auslösen

Leider gibt es für die Canon EOS 550D keine interne Funktion, mit der man massenhaft Bildern in voreingestellten Intervallen machen kann.

Möglicher Aufbau für Zeitrafferaufnahmen mit einer DSLR und Laptop

Externe Hardware

Es gibt aber kommerzielle Systeme, mit denen das geht. Diese kosten etwa 25 Euro. Irgendwann versuche ich mal, mir selbst so ein Teil zu basteln, aber das wird dann ein eigener Artikel hier im Blog

Gphoto2

Die Mühen und das Geld kann man sich aber sparen, wenn man einen Laptop zur Verfügung hat, auf dem z.B. Ubuntu läuft. Denn mit einem kleinen Helferlein kann man diese Aufgabe auch über den PC steuern!

Das Paket nennt sich Gphoto2 und lässt sich in den meisten Distributionen sehr leicht installieren.

sudo apt-get install gphoto2

Nach der Installation kann man seine Kamera über USB anschließen. Vermutlich wird sie automatisch eingehängt, das umgeht man, indem man die Kamera auf PTP stellt oder sie einfach wieder aushängt. Das geht zum Beispiel in Nautilus, indem ihr den Escape-Button anklickt.

Jetzt kann man überprüfen, ob gphoto2 mit der Kamera zusammenarbeitet. Das macht man mit dem folgenden Befehl, der die Typenbezeichnung der angeschlossenen Kamera ausgeben sollte (siehe meine Ausgabe).

$ gphoto2 --auto-detect
Modell                         Port                                            
----------------------------------------------------------
Canon EOS 550D                 usb:002,003

Jetzt kann es losgehen. Die Kamera hatte ich im M-Modus (manuell) und habe folgendes manuell eingestellt:

ISO,
Blende,
Verschlusszeit,
Weißabgleich und
Fokus

Ist man im Halbautomatik-Modus (Av oder Tv) können sich die Bilder in der Helligkeit unterscheiden. Den Autofokus kann man am Anfang verwenden, sollte ihn dann aber abschalten. Das sieht auf dem Video sonst nicht schön aus!

Mit dem folgenden Befehl werden die Bilder für das Zeitraffer aufgenommen.

gphoto2 --capture-image-and-download -I 5 -F 600

Die Einstellungen:

–capture-image-and-download → Die Bilder werden geschossen und sofort auf den Computer geladen. Auf der Speicherkarte sind die Bilder nicht mehr!
Alternative: –capture-image → Die Bilder werden auf der Speicherkarte abgelegt.
-I 5 → Das Intervall der Aufnahmen beträgt 5 Sekunden
-F 600 → Es werden 600 Aufnahmen gemacht.

Wer noch mehr einstellen möchte, kann sich über den folgenden Befehl all seine Einstellmöglichkeiten auflisten lassen:

gphoto2 --list-config

Aus einer Bilderserie ein Timelapse-Video machen

Der schwierigste Schritt ist gemacht. Den Rest übernimmt für uns mal wieder Imagemagick, das Bildverarbeitungsprogramm aus der Konsole. Das Herrliche daran: mit wenigen Zeilen kann man mit einem Rutsch alle seine Bilder bearbeiten lassen.

Bilder auf Full-HD Auflösung bringen

Da die Kamera die Bilder in einer sehr hohen Auflösung aufnimmt, muss man diese auf Videogröße skalieren.

Wenn man sich mit dem Terminal im Ordner der Bilder befindet, verkleinert man sie mit dem folgenden Einzeiler auf die Auflösung 1920×1280 (das Bildverhältnis zwingt uns zunächst dazu).

x=1; for i in *.jpg; do convert $i -resize 1920x1280 -shave 0x100 `printf "%05d.jpg" $x`; x=$(($x+1)); done

mit -shave schneiden wir oben und unten jeweils 100 Pixel ab, um auf die finale Auflösung von 1920×1080 Pixel (Full-HD) zu gelangen.

Weiteres Beispiel: Bilder zurechtschneiden und drehen (crop und rotate)

Die Bilderserie wurde mit einer Gopro aufgezeichnet. Der Bildausschnitt muss noch zurechtgeschnitten werden und um 90 ° gedreht werden. Das kann man mit folgendem Befehl durchführen.

$ x=1; for i in *.jpg; do convert $i -crop 3380x1900+300+730 +repage -rotate 90 `printf "%05d.jpg" $x`; x=$(($x+1)); done

Die Geometrie-Angaben für imagemagick Breite x Höhe geben die Größe des fertigen Bildes an. Der Offset x und y wird von der oberen linken Ecke gemessen. Ich habe sie mittels Bildbearbeitungssoftware herausgemessen. Mit +repage stellt man sicher, dass Leinwand und Bild richtig zueinander ausgerichtet sind. Am Ende rotiert die Flagge -rotate das Bild um 90° im Uhrzeigersinn.

Einzelbilder zu Video konvertieren

Mit diesem letzten Befehl verbindet man nun alle Einzelbilder zu einem Video. Ich habe hier eine Framerate von 25 fps (Frames per second) gewählt. Man kann auch weniger nehmen, dann dauert das Video etwas länger, ruckelt allerdings.

ffmpeg -r 25 -f image2 -i 0%04d.jpg -c:v libx264 -profile:v high -level 4.0 -pix_fmt yuv420p -movflags +faststart zeitraffer.mp4

Zu beachten ist der Punkt -i 0%04d.jpg . Die Dateien müssen z.B. 00001.jpg genannt sein, das haben wir oben mit imagemagick sichergestellt. Mit der genannten Flagge teile ich das ffmpeg mit, dass eine vierstellige Dezimalzahl in den Dateinamen vorkommt, nach der es die Bilder aneinandersetzen soll.

-profile:v high -level 4.0: das stellt die Kompatibilität zu Handys (z.B. mit Android) sicher
-movflags +faststart: Stellt den Metatag „moov“ an den Beginn der Datei, sodass das Video schon starten kann, bevor es vollständig geladen ist. Das ist wichtig für Handykompatibilität
-pix_fmt yuv420p: Das ist das am weitesten verbreitete Pixelformat.
optional: -vf scale=1280:720 für eine niedrigere Auflösung
optional: -b:v 2M für eine niedrigere Bitrate

Einstellungen für 4K-Videos

4K-Videos haben eine Auflösung von 3840×2160 Pixeln und sind nur auf wenigen Geräten in voller Größe abspielbar.

Tipps und Tricks

Zeitraffer planen

Bevor ihr ein Zeitraffer aufnehmt, solltet ihr es planen. Es ist wichtig zu wissen, wie lange das fertige Video dauern wird und wie schnell sich die Objekte darauf bewegen sollen.

Für ein 30-Sekunden-Video sind 30×25= 750 Fotos notwendig. Wenn in diesen 30 Sekunden ein Zeitraum von 60 Minuten abgebildet werden soll, muss man das Intervall auf 4,8 ~ 5 Sekunden stellen.

Spiegelreflex-Kameras vermeiden

Wer professionell oder zumindest häufiger Zeitraffer aufnehmen möchte, sollte sich eine Alternative zu einer Spiegelreflex-Kamera überlegen. Meine Kamera ist laut (dubioser) Foren im Internet auf 50.000 Bilder ausgelegt, danach beginnen die Probleme. Die Kamera hat also starken Wertverlust durch die Zeitraffer, da hier in kurzer Zeit viele Bilder gemacht werden.

Anzahl der Auslösungen der Kamera anzeigen

Die Anzahl der Auslösungen der Kamera kann man ebenfalls mit gphoto2 auslesen. Man startet es im Terminal in einer ncurses-Umgebung und navigiert durch das Menü: Statusinformationen → Auslösezahl

gphoto2 --config

Weiterführende Links

The post Timelapse aufnehmen und mit imagemagick und ffmpeg zu einem Video umwandeln first appeared on bejonet - Linux | Smart Home | Technik.

Digitalen Stromzähler auslesen mit SML und ESPHome 20 Mar 11:08 AM (7 months ago)

Die digitalen Stromzähler (offizielle Bezeichnung: Moderne Messeinrichtung) sind inzwischen weit verbreitet. Viele können in zwei Richtungen zählen, was bei der Benutzung eines Balkonkraftwerks von großer Bedeutung sein kann. Ich habe vor einiger Zeit beschrieben, wie ich mit dem Impulsausgang auf der Vorderseite des Stromzählers den aktuellen Verbrauch ablese. Diese Methode klappt sehr gut, ist sehr einfach und braucht keine weitere Freischaltung des Netzbetreibers. Man kann einfach loslegen. Leider bringt der Impulszähler zwei Nachteile mit sich.

Über den Impulsausgang sieht man ausschließlich den aktuellen Stromverbrauch, nichts Weiteres. Man erfährt nicht den aktuellen Zählerstand oder die Flussrichtung. Außerdem gibt es keine Kontrolle, ob alle Impulse richtig gezählt werden. Summiert man die Leistung auf, erhält man zwar einen Jahresverbrauch, kann sich aber nicht sicher sein, ob er stimmt.
An sonnigen Tagen kommt es vor, dass man mit seinem Balkonkraftwerk mehr Strom erzeugt, als man im Haushalt verbraucht. In diesem Fall wird Strom ins Netz eingespeist. Der Impulszähler kann aber nicht unterscheiden, ob der Strom vom Netz kommt, oder ob er ins Netz geht. Folglich steigt scheinbar der Stromverbrauch im Haus, obwohl in Wirklichkeit ein Stromüberschuss erzeugt wird.

In diesem Artikel möchte ich eine alternative Auslesevariante vorstellen, die robuster und zuverlässiger arbeitet. Aussetzer in der Datenerfassung lassen sich durch späteres Zählerablesen wieder kompensieren, die Bilanz passt immer. Es können nicht nur der aktuelle Verbrauch, sondern auch die Zählerstände „in beide Richtungen“ erfasst werden. Das geschieht über das Auslesen von mehreren OBIS-Kennzahlen über die SML-Schnittstelle.

Die „Moderne Messeinrichtung“ verfügt über zwei optische Schnittstellen. Der Impulsausgang (oben Mitte) gibt den Momentanverbrauch via Impulsen aus. Diese Einbindung dieser Schnittstelle wurde in einem anderen Artikel bereits behandelt. Die SML-Schnittstelle (rechts) gibt mehrere Werte aus, unter anderem den Momentanverbrauch und den Zählerstand.

Die SML Schnittstelle des digitalen Stromzählers

Die digitalen Stromzähler haben eine zweite, wertvolle Schnittstelle: Die SML-Schnittstelle (Smart Meter Language). Über sie kommuniziert der Stromzähler mit einem genormten Protokoll (IEC 62056-6-1) mit uns Anwendern. In ihr werden die Zählerstände, der Momentanverbrauch und gelegentlich noch weitere Informationen bereitgestellt. Die Informationen sind als OBIS-Kennzahlen verfügbar und können leicht zugeordnet werden. Für mich sind die beiden OBIS-Kennzahlen 1.8.0 (Zählerstand, bezogen aus dem Netz) sowie 2.8.0 (Zählerstand, eingespeiste Energie ins Netz) relevant. Der OBIS-Kennwert 16.7.0 gibt mir die momentan bezogene Leistung aus.

Stromzähler vorbereiten: SML Schnittstelle freischalten

Standardmäßig ist diese optische Schnittstelle deaktiviert und mit einer PIN geschützt. Diese PIN erhält man meist kostenlos von seinem Netzbetreiber. Der Netzbetreiber (nicht verwechseln mit dem Stromanbieter!) ist auf dem Stromzähler und der Stromrechnung genannt. In meinem Fall sind es die Stadtwerke. Eine freundliche E-Mail mit der Bitte um Bekanntgabe der PIN unter Nennung meiner Zählernummer hat bereits gereicht.

Diese PIN muss nun mit einer Taschenlampe in die optische Schnittstelle eingeblinkt werden. Schaut euch das kurze Video von Extra 3 dazu an, darin wird der ganze Frust damit gut zusammengefasst.

Bei erfolgreicher Eingabe der PIN muss die Funktion „Inf off“ auf „Inf on“ gestellt werden. Das gelingt, indem man sich durch das Menü des Stromzählers „blinkt“ und beim entsprechenden Eintrag mind. 4 Sekunden mit der Taschenlampe leuchtet. Diese Funktion schaltet die erweiterte Funktion des Stromzählers frei. Man erkennt das später daran, dass nicht nur der Zählerstand im Display angezeigt wird, sondern auch der Momentanverbrauch.

Ist die PIN eingegeben und die erweiterte Informationsvergabe freigeschaltet, kann es endlich losgehen!

DIY Komponenten und Controller ESP8266 vorbereiten

Ich verwende für die optische Schnittstelle einen ESP8266 und das Bauteil TCRT5000. Beides erhält man für weniger als 5 Euro bei Ebay oder anderen Händlern. Der TCRT5000 ist ein optischer LED-Sensor für Infrarot, die sowohl eine LED als auch eine IR-Diode verwendet.

Die LED stört uns in diesem Fall, man muss sie vorher entfernen. Entweder zwickt man sie einfach ab, oder man lötet den Vorwiderstand von ihr weg. Ich habe mich für zweiteres entschieden. Der TCRT hat mehrere Vorteile gegenüber anderen Varianten. Manche Leute löten direkt eine IR-Diode an den ESP. Kann man natürlich machen, ich möchte nur auf die Vorteile meiner Variante hinweisen:

die elektrischen Bauteile sind aufgeräumt auf einer Leiterplatte, keine Bauteile fliegen einzeln herum. Außerdem gibt er genügend „Angriffsfläche“, um ihn – zumindest übergangsweise – per Klebeband zu fixieren.
die Schaltung enthält zwei kleine Status-LEDs: eine zeigt die Spannungsversorgung an, die zweite zeigt das Signal an der IR-Diode an. Vor allem die zweite Status-LED ist sehr, sehr hilfreich, wenn man die Bauteile installiert. Man erhält sofort eine Rückmeldung, ob die Diode ein Signal sieht oder nicht. Das ist besonders beim Ausrichten der Diode hilfreich, oder beim dritten Vorteil:
über das eingebaute Potentiometer kann man die Empfindlichkeit der Diode einstellen. Das ist manchmal notwendig, wenn das Signal der Stromzähler-LED zu stark oder zu schwach ist. Dann dreht man am Poti so lange, bis man über die Status-LED ein sinnvolles Signal sieht. Weiter unten im Artikel zeige ich nochmal genauer, was ich damit meine.

Jetzt verkabelt man die Baugruppe mit dem ESP8266. Ich habe die Variante Wemos D1 mini. Dieses hat bereits die UART-Schnittstelle vorbereitet, die wir verwenden wollen. Dadurch ergibt sich folgendes Verkabelungsschema. Ob ihr das nun verlötet oder mit Jumper-Kabeln verdrahtet, bleibt euch überlassen.

ESPHome konfigurieren und aufspielen

Die Installation von ESPHome im Windows Service for Linux habe ich bereits in einem anderen Artikel beschrieben. Wir erzeugen uns eine Textdatei mit dem Dateinamen stromzaehler-sml.yaml und füllen sie mit folgendem Inhalt.

touch stromzaehler-sml.yaml 
nano stromzaehler-sml.yaml

esphome:
  name: stromzaehlersml

esp8266:
  board: d1_mini

# Enable logging
logger:
  level: VERY_VERBOSE # kann spaeter auf DEBUG verringert werden
  logs:
    sml: DEBUG
    text_sensor: DEBUG
# Enable Home Assistant API
api:
  password: "<password>"

ota:
  password: "<password>"

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  manual_ip:
    static_ip: <statische IP eintragen>
    gateway: <gateway>
    subnet: <subnet>
  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Stromzaehler Sml"
    password: "<password>"

captive_portal:

uart:
  id: uart_bus
  tx_pin: GPIO1
  rx_pin: GPIO3 # dieser GPIO ist wichtig, hier ist das Signalkabel angeschlossen
  baud_rate: 9600
  data_bits: 8
  parity: NONE
  stop_bits: 1

sml:
  id: mysml
  uart_id: uart_bus

sensor:
  - platform: sml
    name: "Total energy SML 180"
    sml_id: mysml
    server_id: "0123456789abcdef"
    obis_code: "1-0:1.8.0"
    unit_of_measurement: kWh
    accuracy_decimals: 3
    device_class: energy
    state_class: total_increasing
    filters:
      - multiply: 0.0001
  - platform: sml
    name: "Total energy SML 280"
    sml_id: mysml
    server_id: "0123456789abcdef"
    obis_code: "1-0:2.8.0"
    unit_of_measurement: kWh
    accuracy_decimals: 3
    device_class: energy
    state_class: total_increasing
    filters:
      - multiply: 0.0001
  - platform: sml
    name: "Stromverbrauch SML 1670"
    sml_id: mysml
    server_id: "0123456789abcdef"
    obis_code: "1-0:16.7.0"
    unit_of_measurement: W
    accuracy_decimals: 0
    device_class: energy
    filters:
      - multiply: 1.0
text_sensor:
  - platform: sml
    name: "Total energy text"
    sml_id: mysml
    server_id: "0123456789abcdef"
    obis_code: "1-0:1.8.0"

Es müssen folgende Zeilen angepasst werden:

Wifi Zugangsdaten
Feste IP-Adresse (kann auch erst im zweiten Schritt erfolgen)
die server_id passen wir an, sobald wir sie kennen. Sie ist ggf. auf den Stromzähler aufgedruckt. Weiter unten im Artikel finden wir sie aber auch über die SML-Schnittstelle heraus.

Zur Erklärung: Die Kommunikation zwischen unserer IR-Diode und dem ESP erfolgt über ein Protokoll namens UART. Diese Schnittstelle wird in den Zeilen nach uart: konfiguriert. Der GPIO-Pin 3 ist dabei derjenige, der auf dem Wemos D1 Mini mit RX gekennzeichnet ist. Falls ihr einen anderen verwendet, müsst ihr diese Zeile anpassen. Die SML Schnittstelle wird ab Zeile sml: konfiguriert. Die meisten Einstellungen könnt ihr so lassen, wie es oben beschrieben ist. Die wichtigen Zeilen sind die mit server_id. Dort wird die Server-Adresse eingestellt. Vermutlich kennt ihr sie nicht von Anfang an, lasst also erstmal die Voreinstellung. Wir ändern sie später, sobald wir sie erfahren haben.

Speichert die Datei nun und kompiliert sie über den Befehl

esphome run stromzaehler-sml.yaml

Nach ein paar Augenblicken ist der Vorgang abgeschlossen und irgendwo wird eine Datei namens firmware.bin abgelegt. Der Pfad ist in der Textausgabe angegeben, bei mir war es

.esphome/build/stromzaehlersml/.pioenvs/stromzaehlersml/firmware.bin

Nun flashen wir die Datei auf den ESP8266. Dazu benutzen wir den Google Chrome (oder einen anderen kompatiblen Browser) und gehen auf die Webseite https://web.esphome.io Schließt den ESP mit einem USB-Kabel an den PC an. Auf der Webseite sollte ein Popup erscheinen.

ESP8266 ESPHome Chrome Browser Gerät erkannt

Sollte dieser Schritt nicht funktionieren, liegt das sehr wahrscheinlich am USB-Kabel. Tauscht das Kabel gegen ein anderes, nicht alle Kabel sind dafür geeignet! Folgt den Anweisungen auf der Webseite, um die Datei firmware.bin auf den ESP zu flashen.

Kontrolliert nach dem Flashen, ob ihr den ESP in eurem WLAN findet. Falls ja, großartig! Wir binden ihn gleich in Home Assistant ein. Gehe in Home Assistant auf Einstellungen → Geräte und Dienste → Integration hinzufügen → ESPHome

Baut jetzt den ESP in der Nähe eures Stromzählers auf. Versorgt ihn mit Spannung (z.B. über ein Handy-Netzteil) und richtet die IR-Diode richtig aus. Jetzt hilft euch die Status-LED vom TCRT5000. Sollte sie regelmäßig blinken, habt ihr schon viel geschafft. Ich habe mit einem kleinen Schraubendreher das Poti noch so verstellt, bis ein wirklich sauberes Signal angekommen ist.

Sollte die Status-LED gar nicht leuchten, ist vermutlich die Diode noch nicht richtig ausgerichtet oder das Signal ist zu schwach. Ändert mit einem kleinen Schraubendreher die Empfindlichkeit am Poti.
Kommen nur kurze Dauersignale, ist die Empfindlichkeit zu hoch. Dreht am Poti so lange, bis in der AN-Phase ein dezentes Flackern zu sehen ist (unteres Diagramm). Dann wird via UART auf diesem Kanal kommuniziert. Die Ausgabe in den Logs müsste nun mit Leben gefüllt sein.

Auslesen der Daten und Einbindung in Home Assistant

Ruft die Logs des Controllers auf. Über Home Assistant gibt es die entsprechende Schnittstelle, über WSL geht das mit dem Befehl

esphome logs stromzaehler-sml.yaml

Wenn alles bis hierher geklappt hat, müsste die Ausgabe sich stetig erweitern. Darin müssten auch Einträge nach dem folgenden Format auftauchen:

Hier findet ihr auch die Server-ID, die wir anfangs noch nicht kannten. Sie steht in runden Klammern und ist im Screenshot rot eingerahmt. Kopiert sie euch und fügt sie in der YAML-Datei in Zeilen, wo die server_id eingetragen werden muss (insgesamt vier mal).

Zur Kontrolle der Validität der Daten, könnt ihr den HEX-Wert mal umrechnen und checken, ob der Stromzählerwert korrekt übertragen wird. Im Beispiel oben:

0x056f8b25 entspricht 91196197. Multipliziert mit 0,0001 ergibt 9119,6 kWh

Ändert nun die YAML-Datei auf die für euch wichtigen Werte (Server-ID und ggf. andere OBIS-Codes) und flasht sie kabellos („Over the air“) auf den ESP

esphome run stromzaehler-sml.yaml

Seht im Home Assistant, ob die Werte dort ankommen. In aller Regel kommen die Werte dort an und können weiter verarbeitet werden. Ich habe mir noch einen Helfer gebaut, der den aktuellen Verbrauch in Kilowatt umrechnet. Das lässt sich mit anderen Energiequellen schöner in Diagrammen darstellen.

Fertig, ihr habt es geschafft! Kommentiert gerne, ob ihr diese Werte für andere Zwecke weiterverwendet. Realisiert ihr damit eine Nulleinspeisung oder beobachtet den Strompreis in Echtzeit?

Weiterführende Quellen: https://esphome.io/components/sml.html

The post Digitalen Stromzähler auslesen mit SML und ESPHome first appeared on bejonet - Linux | Smart Home | Technik.

Raspberry Pi: Umzug von SD-Karte auf SSD in wenigen Schritten 12 Apr 2024 12:34 PM (last year)

Der Raspberry Pi hat sich in den letzten Jahren von einem kleinen Minicomputer für Bastler und Nerds zu einem vollwertigen und verhältnismäßig leistungsfähigem Rechner entwickelt. Nicht wenige Anwender freuen sich darüber, für wenig Geld einen vollwertigen Miniserver zu bekommen.

Beim Einsatz des Raspberry Pi für den produktiven Einsatz als Server ist zu beachten, dass auch die angeschlossene Hardware hierfür geeignet sein sollte. Ein Gehäuse, bei dem er Pi überhitzt, ist genau so schädlich wie eine SD-Karte als Festplatte, da diese nicht für den Dauerbetrieb geeignet ist.

Durch den Einsatz rund um die Uhr gibt es sehr viele Schreib- und Lesevorgänge auf der SD-Karte. Hierfür sind diese Karten aber nur bedingt geeignet. Bei den ersten Raspberry Pi Generationen hatte ich sehr häufig Datenverlust, weil die SD-Karte den Geist aufgegeben hat.

Inzwischen läuft auf dem Pi bei mir eine Instanz von Home Assistant. Hier werden rund um die Uhr Daten aufgezeichnet und Automationen ausgeführt. Auch andere Dienste laufen hier, von denen ich keinen Ausfall erleiden möchte.

Außerdem sind die Lese- und Schreibgeschwindigkeiten einer SD-Karte sehr limitiert. Eine moderne SSD ist um ein Vielfaches schneller. Das wird vor allem dann deutlich, wenn man in Home Assistant Datenmengen abfragt, z.B. Diagramme anzeigt. Ladezeiten von mehreren Sekunden sind dann keine Seltenheit.

Die Konsequenz daraus ist, dass ich den Raspberry von einer SD-Karte auf eine SSD-Karte umziehen möchte. Dadurch, dass hier ein Produktivsystem läuft, möchte ich alle Installationen, Daten und Einstellungen möglichst verlustfrei auf das neue Medium umziehen. Wie ich das gemacht habe, erfahrt hier in folgendem Tutorial.

Schritt 0: Geschwindigkeit testen (optional)

Um einen Geschwindigkeitsvorteil in messbare Größen zu fassen, kann man als Referenz einen Geschwindigkeitstest der SD-Karte machen. Mit dem folgenden Befehl werden Beispieldateien geschrieben. Der Befehl gibt aus, wie schnell die Geschwindigkeit dabei war.

$ dd if=/dev/zero of=/tmp/speedtest1.img bs=20MB count=5
5+0 records in
5+0 records out
100000000 bytes (100MB, 95 MiB) copied, 11.9403 s, 8.4 MB/s

Wenn der Umzug fertig ist, kann man diesen Test wiederholen. Bei mir kam ich von ca. 8,4 MB/s Schreibgeschwindigkeit auf 168 MB/s. Das hat sich mal gelohnt!

Schritt 1: SSD erstmals anschließen

In meinem Fall handelt es sich um eine externe SSD, die über USB 3.0 angeschlossen wird. Nachdem ich sie angesteckt habe, prüfe ich ob sie rechtmäßig erkannt wird, indem ich den folgenden Befehl eingebe und in der Ausgabe nach der SSD suche.

$ lsblk

Schritt 2: Installation von RPi-clone

Auf Github gibt es ein kleines Projekt, das viele Funktionen beinhaltet. Das Programm kopiert den Inhalt der SD-Karte auf die SSD, sodass von ihr gebootet werden kann und alle Einstellungen vorhanden sind.

$ git clone https://github.com/billw2/rpi-clone.git
$ cd rpi-clone
$ sudo cp rpi-clone /usr/local/sbin/sys-clone
$ sudo cp rpi-clone-setup /usr/local/sbin/sys-clone-setup

Schritt 3: Services stoppen und Kopiervorgang starten

Am besten ist es, wenn kein Service mehr läuft und der Kopiervorgang ungestört durchlaufen kann. Daher erst prüfen, was alles läuft, danach einzeln beenden

$ sudo systemctl stop cron
$ sudo systemctl stop nginx
$ sudo systemctl stop docker usw.

Schritt 4: Kopiervorgang starten

Aus dem Check von Schritt 1 kennen wir bereits die Bezeichnung der Festplatte. Auf diese müssen wir nun verweisen mit dem Befehl:

$ rpi-clone sda

Der Wizard hält zunächst an und berichtet uns über den Zustand des Systems. Wenn alles korrekt ist, kann der Vorgang mit der Eingabe von „yes“ gestartet werden.

Schritt 5: Raspberry Pi herunterfahren und von SSD booten

Nach Ende des Kopiervorgangs fährt man den Raspberry Pi herunter.

$ sudo shutdown now

Anschließend von der Stromversorgung trennen, die SD-Karte entfernen, und die Spannungsversorgung wieder herstellen. Jetzt bootet der Raspberry von SSD und ist sehr viel schneller.

The post Raspberry Pi: Umzug von SD-Karte auf SSD in wenigen Schritten first appeared on bejonet - Linux | Smart Home | Technik.

MQTT-Broker Mosquitto als Docker Container installieren 26 Jan 2024 11:48 AM (last year)

Ein MQTT-Broker ist die Schnittstelle zwischen vielen IoT-Sensoren und Geräten, die Sensordaten auswerten oder Aktoren steuern. Das MQTT-Protokoll ist offen und sehr weit verbreitet. Es findet in der Industrie Anwendungen, ist aber auch in Smart Homes ist MQTT weit verbreitet.
MQTT ist ein sehr schlankes und schnelles Protokoll. Es wird in Anwendungen mit niedriger Bandbreite gerne angewendet.

MQTT funktioniert, grob gesagt, folgendermaßen: IoT-Geräte können Nachrichten versenden, die von anderen IoT-Geräten empfangen werden. Die Vermittlungsstelle ist ein sogenannter MQTT-Broker. Dieser empfängt die Nachrichten von den Clients. Gleichzeitig können diese Nachrichten von anderen Clients abonniert werden. Die Nachrichten werden in sog. Topics eingestuft, die hierarchisch angeordnet sind, z.B. Wohnzimmer/Klima/Luftfeuchtigkeit.

Home Assistant, oder ein anderer Client, kann diesen Topic abonnieren und den Nachrichteninhalt („Payload„) auswerten (z.B. 65%).

Home Assistant OS vs. Home Assistant Container

In Home Assistant OS und Supervisor gibt es ein Addon, das einen MQTT-Broker installiert. Das ist sehr einfach, komfortabel und funktioniert wohl recht zurverlässig. In den Installationsarten Home Assistant Container und Core gibt es diese Möglichkeit nicht. Hier muss man manuell einen MQTT-Broker aufsetzen.

In diesem Artikel beschäftige ich mich damit, wie man den MQTT-Brocker Mosquitto über Docker installiert. Anschließend zeige ich, wie man die Konfigurationsdatei gestaltet und eine Verbindung zu Home Assistant herstellt. Das Ergebnis ist dann ungefähr so, als hätte man das Addon installiert. Los gehts!

Schritt für Schritt: MQTT-Broker Mosquitto mit Docker installieren

Als MQTT-Broker verwende ich die weit verbreitete Software Mosquitto von Eclipse. Dieser wird auch von Home Assistant bevorzugt und ist derjenige Broker, den das Addon installieren würde.
Für diese Anleitung wird vorausgesetzt, dass Docker bereits installiert ist und eine SSH-Verbindung zum Server hergestellt werden kann.

Schritt 1: Zunächst erstellen wir ein paar Ordner, die wir später benötigen. Mosquitto wird später so konfiguriert, dass in diese Ordner alle wichtigen Dateien abgelegt werden. Dadurch kann man auf dem Filesystem des Servers Mosquitto konfigurieren und beobachten.

$ mkdir mosquitto
$ mkdir mosquitto/config 
$ mkdir mosquitto/data 
$ mkdir mosquitto/log

Schritt 2: Nun wird die Konfigurationsdatei für Mosquitto erstellt. Über diese Datei kann man das Verhalten von Mosquitto steuern.

$ nano config/mosquitto.conf

persistence true
persistence_location /mosquitto/data/
log_dest file /mosquitto/log/mosquitto.log
log_dest stdout
password_file /mosquitto/config/mosquitto.passwd
allow_anonymous false
listener 1883

Schritt 3: Mit dem folgenden Befehl lädt man sich das aktuelle Image von Eclipse Mosquitto auf den Server.

$ docker pull eclipse-mosquitto

Schritt 4: Mit dem folgenden Befehl wird der Docker-Container gestartet. Das ist der Schlüsselmoment, jetzt muss alles klappen.

$ docker run -it -p 1883:1883 -p 9001:9001 --name mosquitto -v /home/pi/mosquitto/config:/mosquitto/config -v /home/pi/mosquitto/data:/mosquitto/data -v /home/pi/mosquitto/log:/mosquitto/log eclipse-mosquitt

Die Flags bedeuten hierbei folgendes:

-p 1883:1883 Der genannte Port ist die Standardeinstellung für MQTT. Alles was auf diesen Port am Server ankommt, wird in den Mosquitto-Container geleitet.
-p 9001:9001 Über diesen Port laufen die Websocket-Anwendungen. Falls das nicht benötigt wird, kann man das weg lassen
name mosquitto Über diesen kurzen Namen können wir den Docker-Container steuern
-v <filesystem-Pfad>:<Container-Pfad> Die in Schritt 1 erstellten Ordner werden in den Container eingebunden

Wer lieber Docker Compose verwendet, trägt diesen Eintrag in seine *.yaml ein:

services:
    eclipse-mosquitto:
        stdin_open: true
        tty: true
        ports:
            - 1883:1883
            - 9001:9001
        restart: unless-stopped
        container_name: mosquitto
        volumes:
            - /home/pi/mosquitto/config:/mosquitto/config
            - /home/pi/mosquitto/data:/mosquitto/data
            - /home/pi/mosquitto/log:/mosquitto/log
        image: eclipse-mosquitto

Schritt 5: Checken, ob der Container ordnungsgemäß läuft. In der folgenden Liste sollte eine Zeile mit dem Mosquitto-Docker auftauchen. Dieser sollte außerdem „up“ sein. Falls nicht, nochmal versuchen den Container zu starten und kontrollieren, ob er läuft.

$ docker container ls -a
CONTAINER ID   IMAGE          COMMAND   CREATED        STATUS        PORTS    NAMES
xxxxxxxxx   eclipse-mosquitto "/init"   3 minutes ago   Up 2 minutes  [...]   mosquitto

Schritt 6: Sehr gut, der Container läuft. Es wird dringend empfohlen, den MQTT-Broker so abzusichern, dass nur angemeldete User darauf zugreifen können. Das ist ja schon in Schritt 2 in die Konfigurationsdatei geschrieben worden. Mit dem folgenden Befehl melden wir uns in der Shell innerhalb des Containers an und erstellen einen Benutzer. In diesem Beispiel mosquitto. Im Anschluss an diesen Befehl wird man zweimal gebeten, das Passwort für den User festzulegen. Ist das geschafft, läuft der MQTT-Broker auf dem Server. Herzlichen Glückwunsch!

$ docker exec -it sh // öffnet die Shell innerhalb des Dockers
mosquitto_passwd -c /mosquitto/config/mosquitto.passwd mosquitto

Optional Schritt 7: Den MQTT-Broker bindet man in Home Assistant ein, indem man auf Einstellungen → Geräte und Dienste → + Integration hinzufügen klickt. Im Suchfenster nach „MQTT“ suchen und die Zugangsdaten eingeben.
Die Server-Adresse findet man übrigens am schnellsten über ifconfig heraus.

The post MQTT-Broker Mosquitto als Docker Container installieren first appeared on bejonet - Linux | Smart Home | Technik.

Home Assistant: Digitalen Stromzähler mit ESPHome auslesen 8 May 2022 1:33 AM (3 years ago)

Für unser Smart Home möchten wir den aktuellen Stromverbrauch aufzeichnen. Dafür bietet sich, wie auch in meinem Artikel über die Digitalisierung des Gaszählers, Home Assistant an. In dieser mächtigen Software lassen sich Automatisierungen für das Haus erstellen, aber auch Sensoren einlesen und protokollieren. Das möchten wir mit unserem digitalen Stromzähler machen. Was wir zusätzlich noch benötigen, ist ein ESP8266, sozusagen die Home Assistant Außenstelle, die die Daten an die Zentrale weitergibt. Also, legen wir los!

Hardware: ESP8266 und TCRT5000 zum Auslesen des Stromzählers

Die Hardware lässt sich sehr günstig im Internet erwerben. Zwingend erforderlich sind folgende Bauteile:

ESP8266 oder ESP32, ich verwende gerne den Wemos D1 Mini
TCRT5000, ein Infrarotdiode zum Auslesen des Gaszählers
Litzen oder Jumperkabel

Nicht zwingend erforderlich, aber für den dauerhaften Einsatz gut geeignet sind folgende Bauteile

Lochrasterplatine
Schraubbare Pins um die Kabel zum TCRT5000 mit dem Wemos zu verbinden
Female Pins zum Auflösten auf eine Lochrasterplatine und zum Stecken auf die Pins

Den TCRT5000 muss man vorher noch präparieren. Man erkennt ja, dass dort zwei Dioden verbaut sind, eine helle und eine dunkle. Die hellere sendet ein IR-Licht aus, das die zweite Diode wieder lesen soll. Das kann beispielsweise für eine Lichtschranke verwendet werden. In unserem Fall stört die helle Diode, daher müssen wir sie entfernen. Entweder löten wir die ganze Diode aus, oder wir entfernen den Vorwiderstand. Zweiteres geht deutlich schneller. Dazu einfach den Lötkolben an den SMD-Widerstand halten, dann kann man ihn etwas verschieben.

TCRT5000 Bauteile erklärt: Die Output-LED wird wichtig, wenn man die Empfindlichkeit des Sensors mit dem Potentiometer einstellt

Die Verdrahtung findet nach folgendem Schaltplan statt. Wir verwenden keinen Pullup-Widerstand, da dieser bereits auf dem TCRT5000 vorhanden ist. Es wird die Spannungsversorgung über VCC und GND hergestellt und der D0-Pin des TRCT5000 wird mit D2 (GPIO4) des Wemos D1 Minis verbunden.

Schaltplan um den ESP8266 Wemos D1 Mini mit dem TCRT5000 zu verbinden.

Installation am Stromzähler

Die digitalen Stromzähler, hier im Beispiel von EMH, haben fast immer eine Schnittstelle für den Kunden. Manchmal muss man sie von seinem Netzbetreiber freischalten lassen. In meinem Fall war sie glücklicherweise ohne Freischaltung verfügbar.

In der Regel ist dort eine blinkende LED verbaut. Das Blinklicht ist allerdings im Infrarotbereich, für das menschliche Auge also nicht sichtbar. Mit manchen Handy- oder Digitalkameras kann man es aber sichtbar machen, wenn deren Sensoren noch keinen IR-Filter verbaut haben.

Ich habe mir also aus etwas Schaumstoff und Klebeband einen kleinen Halter gebaut. Den Lesekopf des TCRT5000 habe ich dann unmittelbar vor der blinkenden Diode des Stromzählers platziert. Das Potentiometer des TCRT5000 habe ich mit einem kleinen Schraubendreher so lange verdreht, bis die Output-LED gleichmäßig geblinkt hat.

Am Stromzähler sieht man oben eine LED als Kundenschnittstelle. Darüber wird die lesende Diode des TCRT5000 positioniert. Am Poti wird dann so lange die Empfindlichkeit verstellt, bis die Output-LED des TCRT5000 regelmäßig blinkt.

ESPHome installieren und Home Assistant konfigurieren

Die ausführliche Beschreibung, wie man ESPHome auf den Microcontroller bekommt, habe ich bereits beim Gaszähler beschrieben. Die Konfigurationsdatei für den ESP8266 sieht dann im zweiten Abschnitt, also nach dem „captive_portal“ folgendermaßen aus. Beim Gaszähler habe ich den binary_sensor verwendet. Aus Gründen, die ich nicht verstehe, funktioniert das Setup hier aber nicht. Darum verwende ich nun den Pulse_meter, der wiederum am Gaszähler nicht funktioniert.

# Voher kommt der ganze Kopf der Datei, was der Wizard generiert
# [...]

sensor:

# Stromzähler als Pulse Meter
  - platform: pulse_meter
    name: "Stromverbrauch"
    pin:
      number: GPIO4
      mode: INPUT_PULLUP
    unit_of_measurement: "kW"
    accuracy_decimals: 3
    timeout: 2 min
    filters:
      # Filter outliers
      - median:
          window_size: 3
          send_every: 1
          send_first_at: 1
      # Convert pulses/min to kW bei 10000Imp/kWh
      - multiply: 0.006
    total:
      name: "Stromzähler"
      unit_of_measurement: "kWh"
      accuracy_decimals: 3
      filters:
        - multiply: 0.0001

Diesen Code flasht man auf den ESP8266. Gegebenenfalls müssen die Konstanten verändert werden. Das hängt vom Stromzähler ab, wie viele Impulse er ausgibt und in welcher Einheit das umgerechnet werden kann. Der Pulse-Counter hat als Rohsignal „Impulse pro Minute“, bringt bei mir also die Einheit „kWh/min“.

Nebenrechnung: Ich habe einen Verbraucher, der 1.000 Watt = 1 kW verbraucht. Wenn der Verbraucher eine Stunde läuft, verbrauche ich 1 kWh Energie. Der Stromzähler blinkt also 10.000 mal innerhalb dieser Stunde bzw. 166,6 mal pro Minute (siehe Aufdruck). Also muss ich die Pulse/min mit 60/10.000 multiplizieren, also mit 0,006 um wieder auf 1 kW zu kommen. Daher kommt die Konstante in meinem Beispiel.

Im Home Assistant braucht man ebenfalls eine neue Konfiguration. Man bearbeitet dort die configuration.yaml oder, noch besser, die sensor.yaml und ergänzt dort folgende Zeilen:

- platform: template
  sensors:
    stromverbrauch_in_kwh:
      friendly_name: "Elektrische Energie in kWh"
      value_template: >
          {% if states('sensor.stromzahler') | float == 0 %}
           {{ states('sensor.stromverbrauch_in_kwh') }}
          {% else %}
           {{ states('sensor.stromzahler') | float }}
          {% endif %}
      unit_of_measurement: kWh
      device_class: energy
      attribute_templates:
        state_class: total_increasing

Damit haben wir sozusagen offiziell einen Stromzähler implementiert. Dieser kann wiederum im Energie-Dashboard angezeigt werden.

Eines Morgens habe ich mal ein paar Geräte nacheinander angesteckt und deren Stromverbrauch angesehen.

Stromverbrauch in Home Assistant: verschiedene Elektrogeräte im Haushalt im Vergleich: Wasserkocher, Kaffeemaschine, Handyladen und PC starten

The post Home Assistant: Digitalen Stromzähler mit ESPHome auslesen first appeared on bejonet - Linux | Smart Home | Technik.

ESPHome: Temperaturmessung mit DS18B20 für Home Assistant 26 Apr 2022 12:25 PM (3 years ago)

Wenn man sich ein Smart Home aufbaut, möchte man aus verschiedenen Gründen Temperaturen messen. In meinem Fall möchte ich im Heizungsraum die Temperaturen an den Wasserrohren, sowie im Warmwasserspeicher aufzeichnen. Eine einfache und kostengünstige Lösung ist es, das mit einem ESP8266 und dem DS18B20 Temperatursensor umzusetzen. Mit der Software ESPHome ist das auch schnell eingerichtet. Im Folgenden zeige ich, wie man das macht.

ESP8266 und DS18B20 verdrahten

Für dieses Beispiel verwende ich einen ESP8266 Wemos D1 Mini mit drei DS18B20 Temperatursensoren. Sie werden nach folgendem Schema verdrahtet. Das einzige zusätzliche Bauteil ist ein 4,7 kOhm Widerstand, der zwischen den Signal-Pin und VCC gelötet wird.

ESP8266 mit DS18B20 Temperatursensoren verbinden. Dazu ist ein 4k7 Ohm Widerstand notwendig.

Der Vorteil von den DS18B20 ist, dass man sehr viele von ihnen parallel betreiben kann. Wenn die Schaltung einmal geschafft ist, kann man weitere Sensoren einfach anschließen. Das ist der Grund, warum ich schraubbare Kontaktklemmen verwendet habe: Dadurch kann ich mit wenig Aufwand neue Sensoren anschließen.

DS18B20: Adresse herausfinden

Dieser Temperatursensor arbeitet mit dem 1-Wire-Protokoll. Um jeden Sensor eindeutig ansprechen zu können, ist die Adresse des Sensors notwendig. Die kann man leider nicht am Gehäuse ablesen, sondern man muss sie via Software erfragen. Wir nutzen das gleich, um unsere Verdrahtung zu überprüfen!

Die Adresse der Sensoren findet man ebenfalls mit ESPHome heraus, indem man ein sehr minimalistisches Programm aufspielt. Wie schon beim Auslesen des Gaszählers startet man mit

esphome wizard heizungstemperatur.yaml

und beantwortet dem Wizard wahrheitsgemäß die 4 Fragen. Die entstandene heizungstemperatur.yaml öffnet man mit einem Editor und fügt unten die folgenden Zeilen hinzu:

# Example configuration entry
dallas:
  - pin: GPIO2

Mittels des folgenden Befehls kompiliert man die Datei und flasht sie auf den ESP8266 (siehe Artikel über den Gaszähler).

esphome run heizungstemperatur.yaml

Der folgende Befehl öffnet die Logdatei des Controllers:

esphome logs heizungstemperatur.yaml

Dort werden die Adressen der angeschlossenen Sensoren angezeigt. Kleiner Tipp: Wenn man immer nur einen Sensor anschließt, behält man den Überblick!

In der Logdatei sieht man (in der letzten Zeile) die Adresse des Sensors. Diesen notiert man sich.

ESPHome für Temperaturmessung flashen

Wenn man nun alle Adressen der Sensoren herausgefunden und notiert hat, kann man das den ESP8266 wie folgt konfigurieren. Den Code fügt man an die bereits erzeugte Datei aus dem Wizard an.

dallas:
  - pin: GPIO2

sensor:
  - platform: dallas
    address: 0x773c01f096c1ee28
    name: "Heizung Vorlauf Temperatur"
  - platform: dallas
    address: 0x783c01f096729728
    name: "Heizung Rücklauf Temperatur"
  - platform: dallas
    address: 0x883c01f096ade428
    name: "Warmwasserspeicher oben Temperatur"

Da mittlerweile der Chip schon die ESPHome-Software aufgespielt hat, kann man bereits jetzt kabellos den neuen Programmcode übertragen. Bei ESPHome nennt sich diese Technik „Over the air“, kurz OTA. Der PC und der ESP8266-Chip müssen sich nur im gleichen Netzwerk befinden.

esphome run heizungstemperatur.yaml

Integration der Temperatursensoren in Home Assistant

Jetzt fehlt nur noch die Integration in den Home Assistant. Glücklicherweise arbeiten die beiden Systeme sehr gut miteinander. Man navigiert im Home Assistant auf Einstellungen, Geräte& Dienste und fügt über das Plus unten rechts eine neue Integration hinzu. Dort sucht man nach „ESPHome“ und gibt im folgenden Fenster die IP-Adresse ein. Wichtig: hierfür muss die API aktiviert sein (das ist eine der Fragen des esphome-Wizards).

Weitere Informationen: https://esphome.io/components/sensor/dallas.html

The post ESPHome: Temperaturmessung mit DS18B20 für Home Assistant first appeared on bejonet - Linux | Smart Home | Technik.

Home Assistant: Gaszähler mit ESPHome auslesen, flashen unter WSL 16 Feb 2022 11:26 AM (3 years ago)

Zu einem Smart Home gehört es fast selbstverständlich, dass der Verbrauch von Energie aufgezeichnet wird. Der Stromzähler ist eine der wesentlichen Energiezählern im Haushalt, auch der Gaszähler ist sehr wichtig. Vor allem in Haushalten, in denen der primäre Energieträger Erdgas ist, ist der Gasverbrauch essenziell und wird im Smart Home auch optimiert. Das ist, zumindest für meine Begriffe, eine der wesentlichen Aufgaben des Smart Homes.

Das Schöne an den Gaszähler ist es, dass sie sich in der Regel sehr einfach auslesen lassen. Es ist keine komplizierten und teuren Geräte dafür notwendig. Bei den meisten Gaszählern reicht nämlich ein einfacher Reed-Kontakt aus, die es für einige Cent bei Ebay oder anderen Shops zu kaufen gibt. Als Intelligenz wird der sehr vielseitige ESP8266 verwendet. Dieser ist sehr energiesparend, hat integriertes WLAN, lässt sich verhältnismäßig einfach einrichten und kostet ebenfalls nur sehr wenig Geld.

Wenn der Gaszähler eine Aufschrift wie „1 im = 0,01m³“ trägt, lässt er sich mit wenig Aufwand digitalisieren. Ein Reed-Schalter könnte bereits genügen, um den Gaszähler ins Smart Home einzubinden.

Hardware: ESP8266 und Reed-Kontakt verlöten

Die Einkaufsliste für diesen Sensor:

ESP8266, beispielsweise den Wemos D1 Mini
Reed-Kontakt
optional: 5V Netzteil
optional: Schrumpfschlauchsortiment

Für einen geübten Maker ist diese Aufgabe im Handumdrehen erledigt. Für nicht geübte Maker ist es das perfekte Einsteigerprojekt. Es sind nur sehr wenige Lötstellen zu setzen und man kann kaum etwas falsch machen. Beim ESP8266, in meinem Fall ein Wemos D1 mini, müssen nur die beiden Pinleisten angelötet werden. Für Minimalisten würde sogar je ein Pin bei G (Ground) und D1 (GPIO5) reichen. An diese Pins gehören jeweils die Kabel, idealerweise Litzen 0,15mm², an deren Ende der Reed-Kontakt gehört. Bei diesem Schalter muss man keine Richtung beachten, man kann ich nicht falsch herum anlöten. Das fertige Produkt sieht dann so aus. Ich habe noch versucht, die Lötstellen mit Schrumpfschlauch zu verschönern. Das ist optional.

Update (02.05.2022) Weiterhin habe ich eine optionale LED zur Visualisierung des Signals eingebracht. Diese blinkt immer dann, wenn der Reed-Kontakt schaltet. Das ist vor allem dann sehr nützlich, wenn man den Reed-Schalter am Gaszähler anbringt. Die LED ist eine Hilfe, sie ist aber nicht zwingend nötig. Ihren Vorwiderstand kann man über Online-Tools berechnen, bei mir waren es 220 Ohm.

ESP8266 an der Pinleiste mit einem Reed-Schalter verlötet. Der Reed-Schalter geht auf Pin G und Pin D1

ESPHome auf ESP8266 installieren unter Windows 10

Unter Windows 10 lässt sich über den „Microsoft Store“ Ubuntu installieren. Das ist der kleine Umweg, den ich häufig gehe, um ein fast vollständiges Linux unter Windows 10 zum laufen zu bringen. Dass es leider nicht vollständig ist, sieht man den nun folgenden, etwas umständlichen Herangehensweise, wie man ESPHome auf dem ESP8266 installiert.

Wer ein vollständiges hass.io bzw. Home Assistant hat, kann das übrigens über den Addon-Store mit dem Add-on „ESPHome“ deutlich beschleunigen. Da ich aber, wie bereits beschrieben, Home Assistant als Container laufen habe, ist für mich der Umweg notwendig.

Man startet Ubuntu unter Windows und gelangt in das Terminal. Dort installiert man sich (falls noch nicht geschehen) Python 3 und das nötige Paket „esphome“ aus dem Python-Repsitory. Anschließend prüft man, ob die Installation geklappt hat, indem man sich die Versionsnummer ausgeben lässt.

$ sudo apt-get install python3 python3-pip
$ pip install --user esphome
$ esphome version

Der Einfachheit halber empfehle ich, den Wizard von ESPHome zu verwenden. Er wird benutzt, um die *.yaml zu erstellen. Genau wie bei Home Assistant ist sie dafür da, den Controller zu konfigurieren. Der Wizard zeigt einem glücklicherweise gleich alle möglichen Alternativen auf, die man eingeben kann. Beantwortet also wahrheitsgemäß die 4 Fragen den Wizards und wir erhalten eine Konfigurationsdatei mit dem angegebenen Namen. Ich habe hier willkürlich gaszaehler.yaml gewählt.

$ esphome wizard gaszaehler.yaml
$ nano gaszaehler.yaml

Die nun folgende Datei sieht dann beispielsweise so aus:

esphome:
  name: gaszaehler

esp8266:
  board: d1_mini

# Enable logging
logger:

# Enable Home Assistant API
api:
  password: "1234"

ota:
  password: "1234"

wifi:
  ssid: "hier die Wifi-SSID eintragen"
  password: "hier das Wifi Passwort eintragen"
  manual_ip:
    static_ip: "auf Wunsch"
    gateway: "IP-Adresse des Gateways"
    subnet: "Subnet Maske"

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Gaszaehler Fallback Hotspot"
    password: "hier steht automatisch ein Passwort"

captive_portal:

Das Fallback-Wifi wird gebraucht, falls der Sensor das eigentliche WLAN nicht erreichen kann. Dann baut der ESP8266 eigenständig ein WLAN auf, über das er sich konfigurieren lässt.

Update (02.05.2022) Vor diesem Update habe ich den Pulse_counter von ESPHome verwendet. Dieser liefert leider keine zuverlässigen Werte. Gleiches gilt für den pulse_meter, der eigentlich besser sein sollte. Stattdessen bin ich nach einiger Tüftelei wieder bei dem binary_sensor herausgekommen, der wunderbar funktioniert. Zusätzlich ist eine LED auf GPIO0 angebracht, die schaltet, sobald der Reed-Schalter zieht. Damit könnt ihr live am Gerät sehen, ob ein Puls anliegt. Sie ist nur eine Hilfe und nicht zwingend erforderlich.

globals:
  - id: total_pulses
    type: int
    restore_value: false
    initial_value: '0'  # hier kann der Gaszählerstand initialisiert werden

binary_sensor:
  - platform: gpio
    id: internal_pulse_counter
    pin:
      number: GPIO5
      mode: INPUT_PULLUP
    name: "Live-Impuls"
    filters:
      - delayed_on: 10ms
    on_press:
      then:
        - lambda: id(total_pulses) += 1;
        - output.turn_off: led  # optional: für eine LED, die den Gaszählerpuls visualisiert
    on_release:
      then:
        - output.turn_on: led  # optional: für eine LED, die den Gaszählerpuls visualisiert

sensor:
  - platform: template
    name: "Gasverbrauch"
    device_class: gas
    unit_of_measurement: "m³"
    state_class: "total_increasing"
    icon: "mdi:fire"
    accuracy_decimals: 2
    lambda: |-
      return id(total_pulses) * 0.01;

# Optional: Diese LED soll blinken, sobald ein Signal vom Gaszähler erkannt wird
output:
  - platform: gpio
    pin: GPIO0
    id: 'led'

Fertig mit der Konfiguration. Wir speichern mit Strg + O und schließen Nano mit Strg + X

Mit dem folgenden Befehl wird der Code für den ESP8266 kompiliert. Ich habe es leider nicht geschafft, ihn direkt per USB-Kabel auf meinen Controller zu bekommen. Daher bin ich einen Umweg gegangen.

$ esphome run gaszaehler.yaml

Das endet mit einer Fehlermeldung (connection failed bad indicator errno=11), dass der Code nicht auf den Controller gebracht werden konnte. Stattdessen kopieren wir den Code auf das Laufwerk C: unter Windows und arbeiten von dort aus weiter (sorry Leute!!).

$ cp ~/esphome/.esphome/build/gaszaehler/.pioenvs/gaszaehler/firmware.bin /mnt/c/Users/<Benutzername>

Mittels ESPHome-Flasher, den es auch für Windows gibt und der nicht installiert werden muss (!!) geht es weiter. Die eben kopierte Datei auswählen, den ESP8266 mit USB am PC anstöpseln und den entsprechenden COM-Port auswählen (bei mir wurde nur einer angezeigt). Bestätigen, und warten bis es fertig ist.

ESPHome in Home Assistant installieren

Mit der Entität „ESPHome“ kann der Sensor in den Home Assistant eingebunden werden. Das geht sehr fix, es muss nur die IP-Adresse und das festgelegte Passwort eingegeben werden. Damit er auch korrekt als Energiequelle erkannt wird, muss man noch folgende Zeilen in die configuration.yaml anfügen, besser noch, in die sensor.yaml

Update (15.04.2022): Manchmal fällt der ESP kurzzeitig aus, was den Gasverbrauch kurzfristig auf 0 m³ setzt. Sobald er wieder da ist, gibt es einen unlogischen Peak in der Statistik. Dieser wird über die kleine IF-Schleife herausgefiltert.

- platform: template
  sensors:
# Gaszähler, kommend von ESPHome, aufbereiten für Energy
    gasincubicmeter:
      value_template:  >
          {% if states('sensor.gasverbrauch') | float == 0 %}
           {{ states('sensor.gasincubicmeter') }}
          {% else %}
           {{ states('sensor.gasverbrauch') | float }}
          {% endif %}
      unit_of_measurement: m³
      device_class: gas
      attribute_templates:
        state_class: total_increasing

Nach einem Neustart des Servers klickt man im Home Assistant auf „Einstellungen“, „Energie“ und klickt auf den Gaszähler. Dort taucht nun die neue Entität gasincubicmeter auf und kann ausgewählt werden.

In Home Assistant kann über Einstellungen → Energie eine neue Gasquelle hinzugefügt werden

Der Gasverbrauch wird auf dem Energie-Dashboard von Home Assistant angezeigt

Reed-Schalter am Gaszähler positionieren

Wer Zugriff auf einen 3D-Drucker hat, sollte sich bei Thingiverse mal umsehen, ob dort ein Halter für seinen Gaszähler vorhanden ist. Die Chance dort, oder woanders, einen zu finden, halte ich für sehr hoch. Andernfalls kann man mit etwas Geschick und gutem Klebeband den Schalter direkt am Gaszähler montieren. Er muss in der vorgesehenen Kerbe möglichst genau unter der letzten Ziffer positioniert werden. Wer darauf achtet, wird bemerken, dass die letzte drehende Ziffer einen kleinen Magneten hat. Genau darunter muss der Reed-Schalter geklebt werden.

The post Home Assistant: Gaszähler mit ESPHome auslesen, flashen unter WSL first appeared on bejonet - Linux | Smart Home | Technik.

Home Assistant: Animiertes Regenradar einfügen 8 Feb 2022 1:20 AM (3 years ago)

Zu einem guten Smart Home gehört natürlich auch eine schöne „Kommandozentrale“. Obwohl das Haus ja schlau ist und alles selbst entscheiden soll, möchte man ja dennoch wissen, was gerade los ist. Der Home Assistant, eine freie und open source Software für Hausautomatisierung, bietet mit seinen Dashboards genau solche Übersichten an. Mit wenigen Klicks lassen sich die Messdaten aus dem Haus und um das Haus visualisieren.

Einen Regenradar in Home Assistant kann man einbinden, wenn man die Bild-URL als Kachel im Dashboard hinzufügt.

Regenradar und weitere Wetterdaten

Das Wetter spielt natürlich eine entscheidende Rolle für das Haus und die Bewohner. Die erste Anlaufstelle für aktuelle Wetterdaten und Vorhersagen könnte beispielsweise OpenWeatherMap sein. Die API ist gut dokumentiert, die Einbindung in den Home Assistant ist reibungslos, der Dienst ist kostenlos und es fällt keine Werbung an. Einzig eine Registrierung auf der Webseite ist nötig, um den verpflichtenden API-Schlüssel zu erhalten.

Was leider fehlt, ist der Regenradar. Jede Vorhersage ist ja nur so gut, wie die, die man mit eigenen Augen sieht. Darum lohnt es sich, einen Regenradar in das Home Assistant Dashboard einzubinden.

Die meisten Regenradare lassen sich nicht besonders einfach einbinden. Und falls doch, sind sie meistens mit Werbung übersät. Um so schöner ist es, dass die Webseite morgenwirdes.de den Regenradar vom Deutschen Wetterdienst (DWD) aufbereitet und uns als animierte gif-Datei zur Verfügung stellt. Die Einbindung in den Home Assistant ist explizit erlaubt und funktioniert folgendermaßen.

Einbindung in den Home Assistant

Zunächst bastelt man sich die URL zusammen, die man für sein Dashboard braucht. Das geht relativ einfach, wenn man sich die Struktur der URL ansieht.

https://morgenwirdes.de/api/v3/gif4.php?plz=12345&delay=70&type=1&zoomlvl=1&bar=0&map=1&textcol=ffffff&bgcol=03a9f4

Die Flagge „plz“ gibt die Postleitzahl vor. Delay ist die Zeit in Millisekunden, die pro Zeitstufe angezeigt wird. Es gibt zwei Farbschemen der Karte, typ=0 oder 1. Der Zoomlvl gibt den Zoomlevel an (hier 1 für ganz Deutschland). Eine Zeitleiste (bar) und Hintergrundkarte (map) können optional eingeblendet werden. Farblich anpassen kann man die Karte mit den beiden letzten Flaggen.

In der configuration.yaml habe ich das dann als Kamera eingebunden. Das hat den Vorteil, dass die Daten immer aktualisiert werden. Würde man es als Bild einbinden, könnte es sein, dass der Regenradar nur aus dem Cache geladen wird und deshalb nicht aktuell ist.

##### Kameras und Wetterkarten
camera:
  - platform: generic
    still_image_url: 
https://morgenwirdes.de/api/v3/gif4.php?plz=12345&delay=70&type=1&zoomlvl=1&bar=0&map=1&textcol=ffffff&bgcol=03a9f4
    name: regenradar

In Lovelace, dem Dashboard von Home Assistant, fügt man nun ein Picture-Glance hinzu, schon ist das Radar da:

type: picture-glance
title: Regenradar
entities: []
camera_image: camera.regenradar

Update 15.04.2022:

Ich habe den Artikel angepasst, das Bild wird nicht mehr als normales Bild, sondern als Kamera eingebunden. Dadurch wird das Radar zuverlässiger aktualisiert.

The post Home Assistant: Animiertes Regenradar einfügen first appeared on bejonet - Linux | Smart Home | Technik.

bejonet – Linux | Smart Home | Technik View RSS