Smart Meter in openHAB integrieren

Im Januar 2021 haben wir eine Moderne Messeinrichtung von bayernwerk, also einen intelligenten Zähler bekommen. Das Thema hatte ich hier kurz dargestellt: „Intelligenter Zähler“ jetzt auch bei uns 🙂

Es handelt sich hier um den Smart Meter Gateway (SMGW) von Itron / PPC. In den letzten Monaten habe ich versucht den SMGW in unser Smart Home einzubinden. 

Mit den Stichworten „TRuDI“ und „HAN“ kommt man im openHAB-Universum leider nicht weit. Im openHAB-Forum habe ich dann diesen Hinweis bekommen – LINK. Hier wird als Smart Home Integration ein Beispiel für openHAB verwendet. Leider ist für mich nicht ersichtlich welche Bindings dort verwendet wurden. Eine Integration in openHAB ist somit aktuell noch etwas weit weg.

Ich habe aktuell auch noch Probleme in der Verwendung mit dem bayernwerk-Portal. Ein Excel-Export der zurückgemeldeten Daten funktioniert aber schon. Im nächsten Schritt werden ich versuchen durch Rückfragen bei bayernwerk das System auch Extern ansprechen zu können. Dann kann ich mir weitere Gedanken über die openHAB-Integration machen.

Habt Ihr euren Smart Meter schon in openHAB integriert? Gibt es dazu Praxisbeispiele und Informationen?

Non-Fungible Token (NFT) – Ist das Kunst oder kann das weg?

Über Non-Fungible Token (NFT) liest man die letzte Zeit immer mehr – Was steckt hinter dem aktuellen Hype?

Was ist ein NFT? Ein „nicht ersetzbares“ kryptografisches Token, das im Vergleich zum Fungible Token z.B. Bitcoin nicht tauschbar ist d.h. ein Unikat ist. Dieser Token kann nicht repliziert werden. Damit findet ein NFT überall dort Verwendung, wo virtuelle Güter als einmalige Objekte gesammelt oder gehandelt werden können z.B. Digitale Kunst, Computerspiele oder Musik.

Bekannt geworden sind die NFT’s mit dem Katzen bei CryptoKitties bei dem virtuelle Katzen als Sammelobjekte gehandelt werden. Mittels NFT lässt sich ein JPEG-Bild als exklusives Kunstwerk verkaufen wie auch bekannte Werke. Damit ist ein digitaler Kunstmarkt für exklusive Sammlerobjekte möglich. Und für Exklusivität bezahlt man gerne viel Geld.

NFTs setzen wie Kryptowährungen auf einer Blockchain auf. Ein Gemälde ist aber dort einzigartig und kann nicht getauscht werden. NFTs sind damit wie ein Echtheitszertifikat zu sehen. Wer das NFT besitzt ist, gilt als der rechtmäßige Eigentümer des damit verknüpften Gegenstands.

Plattformen

Welche Plattformen gibt es für NFTs? Beim Marktplatz Valuables by Cent kann mit mit Twitter-Tweets handeln. Man kauft hier aber nicht den Tweet oder ein Recht daran, sondern der NFT entspricht einem signierten Exemplar eines Buches. Auf Nifty Gateway kann man digitale Kunstwerke beziehen. Bei OpenSea handelt es sich um eine dezentrale Handelsplattform für NFTs auf Ethereum-Basis.

Wie erstellt man NFTs?

NFTs können wie folgt erstellt werden:

  1. Ein Wallet anlegen – Für den Verkauf von NFTs braucht man eine Kryptowährung. Diese wird in einem digitalen Geldbeutel (Wallet) aufbewahrt. Auf ethereum.org gibt es einen Wallet-Finder.
  2. Kryptowährung kaufen – Über die Wallet-Anwendung entsprechende Währung kaufen.
  3. Wallet mit Verkaufsplattform verbinden – Entscheidung für Handelsplatz für das NFT-Werk z.B. OpenSea
  4. NFT erstellen und verkaufen – Werk auf der Plattform im geeigneten Format hochladen. Dann werden Details zum Verkauf festgelegt.

Fazit

Bei NFTs handelt es sich aktuell um reine Spekulation und ist für unbedarfte Käufer nicht geeignet. Ob ein Kunstwerk im Preis steigt, lässt sich vorab nicht absehen. Man darf die CO2-Bilanz bei Kryptowährungen auch nicht aus den Augen verlieren. 

Hat von euch schon mal jemand NFT’s erstellt, gekauft oder verkauft? Gibt es bereits Erfahrungswerte beim Verkauf von physikalischen Objekten?

openHAB 3.1 – Was ist neu?

Beim openHAB 3.0 Release-Blog wurde die Version 3.1 für den Sommer 2021 angekündigt.

Am 28.06.2021 wurde dann die finale Version veröffentlicht. Die Version ist komplett kompatibel zum 3.0 Release.

Anfang Juni 2021 wurde auch bereits der openHAB 3.1.0 Milestone 5 veröffentlicht. Der 3.1 GA Release ist für den Ende Juni 2021 geplant. 

Im Juni waren noch wenige Neuerungen bekannt, außer man ließt alle Milestone-Changes durch:

Hier gibt es im Forum über die Milestones ein paar weiterführende Diskussionen: LINK.

Wie ich gesehen habe, gibt es viele neue Addons: Ich habe ca. 50 Stück in den Milestone-Builds grob gesehen. Bei den Add-ons gab es hauptsächlich Erweiterungen und Fehlerbehebungen (hier habe ich am meisten Änderungen gesehen, das muss man sich für seine eigene Umgebung ansehen). In der Runtime gab es auch diverse Erweiterungen und Fehlerbehebungen. Auch das User Interfaces wurde erweitert und entsprechend gefixt. 

Außerdem gab es 3 Breaking Changes in bestimmten Add-ons d.h. das bitte genau anschauen. 

Aus meiner Sicht sind sehr viele und gute Detailverbesserungen vorhanden. 

Welche Verbesserungen in openHAB 3.1 sind für eure Umgebung interessant? Auf was wartet ihr ganz gespannt?

 

 

Routinen mit openHAB und Amazon Alexa

Per Zufall bin ich in der Amazon Alexa App auf die Funktionalität der Routinen gestoßen. Eigentlich bilde ich die gesamte Logik unseres SmartHome in openHAB ab, aber wegen der vereinfachten Befehlskette wollte ich es auch einmal direkt per Alexa testen.

Zum St. Patricks Day gab es ein paar „Dekorationsanforderungen“ bei uns im Haus, die eine manuelle Aktivierung notwendig gemacht haben.

Items

Im ersten Schritt werden „virtuelle Items“ in openHAB konfiguriert, damit diese auch in der Alexa App verwendet werden können. Die Konfiguration führe ich (wie immer) in der textuellen Konfiguration durch.

// St. Patricks Beleuchtung per Alexa Routine, 07.03.2021
Switch Koboldbeleuchtung_Ein "Ich bin ein Kobold" [ "Lighting" ]
Switch Koboldbeleuchtung_Aus "Ich bin kein Kobold" [ "Lighting" ]

Rules

Die Aktivierung und die Deaktivierung möchte ich dann über eine Regel in openHAB steuern und die notwendigen Geräte aktivieren / deaktivieren.

rule "Kobold Routine Ein"
    when
        Item Koboldbeleuchtung_Ein received command
    then
        if (receivedCommand == ON) {
            // Gewünschte Aktionen durchführen
            logInfo("INFO","Koboldroutine eingeschalten")
        }   
end

rule "Kobold Routine Aus"
    when
        Item Koboldbeleuchtung_Aus received command
    then
        if (receivedCommand == ON) {
            // Gewünschte Aktionen durchführen
            logInfo("INFO","Koboldroutine ausgeschalten")
        }
end

Amazon Alexa App

Im letzten Schritt wird dann die Alexa-Konfiguration in der App wie folgt vorgenommen:

  • Alexa App – Mehr – Routinen – Routine erstellen
  • Wenn (der Satz gesprochen wird): Alexa, Ich bin ein Kobold
  • Aktion ausführen: Smart Home – Alle Geräte – „Virtuelles Item“: Ich bin ein Kobold – AN schalten

Das sieht graphisch wie folgt aus:

Zusammenfassung

Die Alexa Routinen sind sehr schnell und einfach eingerichtet. Ob sich der Aufwand lohnt, um nur das „schalte“ Aktivierungswort zu umgehen, muss jeder selbst entscheiden.

Es gibt aber interessante Routinen-Vorschläge, die man sich einmal ansehen kann.

Da ich meine Logiken alle eher zentral in openHAB, anstatt verteilt auf diverse Systeme abbilden möchte, ist es eher nicht für meinen Anwendungsfall geeignet. Aber ein netter Versuch war es auf alle Fälle. 🙂

DWD Unwetter Anbindung mit openHAB

In diesem Artikel habe ich beschrieben, wie man die Unwetterdaten vom DWD in openHAB per Scripting-Lösung integriert:

Beim Umstieg auf openHAB 3 wollte ich anstatt der eigenen Scripting-Lösung auf die integrierte Binding-Variante wechseln.

Ich musste aber Anfang Januar 2021 (openHAB 3.0) und im Mai 2021 (openHAB 3.0.2) feststellen, dass die Variante mit dem Binding bei mir nicht funktioniert und keine Unwetterdaten visualisiert.

Auch wenn ich  mit der richtigen WARNCELLID Unwetterwarnungen bekommen sollten, werden diese (aus meiner Sicht) trotz korrekter Konfiguration nicht in openHAB angezeigt. Leider habe ich im openHAB-Forum dazu auch keine Lösung gefunden. Auch in den DEBUG-Meldungen ist leider nichts weiterführendes an Informationen ersichtlich. 

Hat jemand das DWD Unwetter Binding in openHAB 3 schon einmal erfolgreich eingerichtet? Kann jemand dazu Erfahrungswerte teilen?

Der VW Corrado als Oldtimer

Ende der Achtzigerjahre kam der VW Corrado als Nachfolger des Scirocco II auf den Markt. Nach 30 Jahren ist es also ab 2018 möglich seinen Corrado mit einem H-Kennzeichen zu bestücken. Unser Corrado ist mit der Zulassung April 1992 also auch in 2022 an der Reihe.

Aber für wen lohnt sich ein H-Kennzeichen (H = Historisches Kennzeichen) oder der Oldtimerstatus?

Folgende Aspekte kann man beim H-Kennzeichen für sich beachten:

  • Pauschale Kfz-Steuer
  • Preiswertere Kfz-Versicherung
  • Unbeschränkte Durchfahrt durch Umweltzonen
  • Wegfall der grünen Plakette

Interessant wäre beim H-Kennzeichen für mich die pauschale Versteuerung. Unabhängig von Hubraum und Emission ist eine Pauschale von 191,73 Euro pro Jahr zu zahlen. Durch den Kaltlaufregler / G-Kat in unserem VR6 ist aber hier fast kein Einsparpotential vorhanden (wir bezahlen aktuell 114 Euro für den Sechs-Zylinder von April bis Oktober).

Eine preiswertere Kfz-Versicherung kann bei ca. 80 Euro Haftpflicht in unserem Falls fast nicht ins Gewicht fallen. Die freie Fahrt in Umweltzonen wäre ein interessanter Aspekt, aber durch den KLR hat der Corrado eh schon eine grüne Plakette. Bei einer kommenden Pkw-Maut könnte das H-Kennzeichen durch eine Pauschale interessant werden. Aber bei den paar KM die wir pro Jahr damit fahren ist das Einsparpotential gering.

Das H-Kennzeichen hat aber auch ein paar negative Aspekte:

  • Beschränkung der jährlichen Fahrleistung auf 10.000 KM
  • Aufwändiger Prüfprozess
  • Verkehrstauglichkeit muss gegeben sein

Eine interessante Option könnte ein Saison-Kennzeichen in Kombination mit dem H-Kennzeichen sein. Hauptsächlich geht es bei uns also um den „Ritterschlag“ für den Corrado, damit es sich um ein geprüftes und erhaltenswertes Kulturgut handelt.

Hier findet Ihr auch noch eine Checkliste für die Oldtimer-Begutachtung (kann man auch unabhängig vom Corrado verwenden).

Fazit: Vor- oder Nachteile? Ich denke ich werde trotzdem das H-Kennzeichen für unseren VW-Corrado holen. 🙂

 

 

Speedtest der Internetverbindung mit openHAB regelmäßig durchführen

Ich wollte in unserem SmartHome einen regelmäßigen Speedtest unserer Internetverbindung regelmäßig durchführen lassen. Damit wollte ich herausfinden, ob die zugesicherten Bandbreiten unseres Glasfaser-Anschlusses immer eingehalten werden. Da in openHAB 3 automatisch alle Items persistiert werden, war das nach der Umstellung eine gute Möglichkeit.

Die Erste Idee für die Geschwindigkeitsmessung war das Network Binding. Das habe ich aber dann nicht verwendet, da dies eine ISO-Datei für den Test benötigt (das wollte ich so nicht umsetzen).

Im openHAB-Forum habe ich dann eine individuelle Scripting-Lösung auf Basis Speedtest CLI by Ookla gefunden.

Die Umsetzung war dort sehr gut dort beschrieben. Man muss nur die Systemvoraussetzungen beachten, nicht das hier etwas auf dem eigenen System fehlt (das kann zum Teil im Debugging des Scripts etwas aufwändiger sein).

Die Scripte stellen für mich eine sehr runde Lösung dar, die alle Informationen incl. graphischer Aufbereitung / Icons enthält. In openHAB 3.x werden die Daten automatisch persistiert und damit dann auch längerfristig auswertbar gespeichert.

Ein paar Anpassungen für openHAB 3.x mussten durchgeführt werden:

SpeedTest.items

Die Items werden wie folgt definiert:

Group gSpeedtest <"speedtest">
Group gSpeedChart
String SpeedtestCharts

String      SpeedtestSummary        "Speedtest [%s]"                                            <"speedtest_summary">   (gSpeedtest, gPersist)
Number      SpeedtestResultPing     "Ping [%.3f ms]"                                            <"speedtest_ping">      (gSpeedtest, gSpeedChart)
Number      SpeedtestResultDown     "Download [%.2f Mbit/s]"                                    <"speedtest_download">  (gSpeedtest, gSpeedChart)
Number      SpeedtestResultUp       "Upload [%.2f Mbit/s]"                                      <"speedtest_upload">    (gSpeedtest, gSpeedChart)
String      SpeedtestRunning        "Speedtest läuft ... [%s]"                                  <"speedtest_run">       (gSpeedtest)
Switch      SpeedtestRerun          "Manuell starten"                                           <"speedtest_reload">    (gSpeedtest)
DateTime    SpeedtestResultDate     "Letzte Ausführung [%1$td.%1$tm.%1$tY, %1$tH:%1$tM]"        <"speedtest_date">      (gSpeedtest, gPersist)
String      SpeedtestResultError    "Fehlermeldung [%s]"                                        <"speedtest_error">     (gSpeedtest, gPersist)
String      SpeedtestResultImage    "Bild"

SpeedTest.rules

Die Regel steuert dann die gesamte Logik an (hier ist eine automatischer und eine manueller Start möglich). Hier habe ich meine Anpassungen im Kommentar erfasst: 

val String ruleId = "Speedtest"
val Number calc = 125000 // Converting from bits to Mbits

rule "Speedtest init"
when
    System started
then
    createTimer(now.plusSeconds(195))
    [|
        if(SpeedtestRerun.state == NULL)
        {
            SpeedtestRerun.postUpdate(OFF)
        }
        if(SpeedtestRunning.state == NULL)
        {
            SpeedtestRunning.postUpdate("-")
        }
        if(SpeedtestSummary.state == NULL || SpeedtestSummary.state == "")
        {
            SpeedtestSummary.postUpdate("⁉ (unbekannt)")
        }
    ]
end
rule "Speedtest"
when
    // 1 x am Tag 4 Uhr früh
    Time cron "0 0 4 * * ?" or
    //Time cron "0 0/15 * * * ?" or     // alle 15 Minuten
    Item SpeedtestRerun changed from OFF to ON or
    Item SpeedtestRerun received command ON
then
    //logInfo(ruleId, "--> speedtest executed...")
    SpeedtestRunning.postUpdate("Messung läuft...")
    // execute the script, you may have to change the path depending on your system
    // Please use -f json and not -f json-pretty
    
    //val speedtestExecute = "speedtest -f json"
    // 13.02.2021 - Anpassung damit Lizenz akzeptiert wird
    //val speedtestExecute = "sudo -u openhab /usr/bin/speedtest -f json --accept-license --accept-gdpr"
    //val speedtestExecute = "speedtest -f json"
    
    //var speedtestCliOutput = executeCommandLine(speedtestExecute, 120*1000)
    
    // 13.02.2021 - Anpassung für openHAB 3
    var speedtestCliOutput = executeCommandLine(Duration.ofSeconds(120), "speedtest", "-f", "json")
    // for debugging:
    //var String speedtestCliOutput = "Ping: 43.32 ms\nDownload: 21.64 Mbit/s\nUpload: 4.27 Mbit/s"
    logInfo(ruleId, "--> speedtest output:\n" + speedtestCliOutput + "\n\n")
    SpeedtestRunning.postUpdate("Datenauswertung...")
    // starts off with a fairly simple error check, should be enough to catch all problems I can think of
    // 13.02.2021 - Anpassung notwendig zum Beispiel
    //if (speedtestCliOutput.startsWith("{\"type\":\"result\",") && speedtestCliOutput.endsWith("}}"))
    if (speedtestCliOutput.startsWith("{\"type\":\"result\","))
    {
        var ping = Float::parseFloat(transform("JSONPATH", "$.ping.latency", speedtestCliOutput))
        SpeedtestResultPing.postUpdate(ping)
        var float down = Float::parseFloat(transform("JSONPATH", "$.download.bandwidth", speedtestCliOutput))
        down = (down / calc)
        SpeedtestResultDown.postUpdate(down)
        var float up = Float::parseFloat(transform("JSONPATH", "$.upload.bandwidth", speedtestCliOutput))
        up = (up / calc)
        SpeedtestResultUp.postUpdate(up)
        var String url = transform("JSONPATH", "$.result.url", speedtestCliOutput)
        val img = url + ".png"
        SpeedtestResultImage.postUpdate(img)
        SpeedtestSummary.postUpdate(String::format("ᐁ  %.1f Mbit/s  ᐃ %.1f Mbit/s (%.0f ms)", down, up, ping))
        SpeedtestRunning.postUpdate("-")
        // update timestamp for last execution
        val DateTimeType ResultDate = DateTimeType.valueOf(transform("JSONPATH", "$.timestamp", speedtestCliOutput))
        SpeedtestResultDate.postUpdate(ResultDate)
    }
    else
    {
        SpeedtestResultPing.postUpdate(0)
        SpeedtestResultDown.postUpdate(0)
        SpeedtestResultUp.postUpdate(0)
        SpeedtestSummary.postUpdate("(unbekannt)")
        SpeedtestRunning.postUpdate("Fehler")
        logError(ruleId, "--> speedtest failed. Output:\n" + speedtestCliOutput + "\n\n")
    }
    SpeedtestRerun.postUpdate(OFF)
end

Sitemap

Die Visualisierung erfolgt dann in der Sitemap wie folgt:

        Text item=SpeedtestSummary icon="speedtest" {
            Frame label="Ergebnisse" {
                Text item=SpeedtestResultDown
                Text item=SpeedtestResultUp
                Text item=SpeedtestResultPing
            }
            Frame label="Steuerung" {
                Text item=SpeedtestResultDate
                Text item=SpeedtestRunning label="Speedtest [%s]" visibility=[SpeedtestRunning != "-"]
                Text item=SpeedtestResultError visibility=[SpeedtestRunning == "Fehler"]
                Switch item=SpeedtestRerun mappings=[ON="Start"]
            }
            Frame label="Statistik" {
                Switch item=Chart_Zeitraum_D_W_M_Y label="" mappings=[0="Woche", 1="Monat", 2="Jahr"]
                Chart item=gSpeedtest service="rrd4j" period=W refresh=15000 visibility=[Chart_Zeitraum_D_W_M_Y==0, Chart_Zeitraum_D_W_M_Y=="Uninitialized"]
                Chart item=gSpeedtest service="rrd4j" period=M refresh=15000 visibility=[Chart_Zeitraum_D_W_M_Y==1]
                Chart item=gSpeedtest service="rrd4j" period=Y refresh=15000 visibility=[Chart_Zeitraum_D_W_M_Y==2]
            }
        }

Fazit

Damit konnte ich recht einfach die Messung der Bandbreite bei uns zu Hause in openHAB integrieren. Eine schöne Erweiterung wäre noch die Verfügbarkeit des Internetzugangs regelmäßig zu protokollieren.

Wie messt Ihr in eurem SmartHome die Bandbreite eurer Internetverbindung? Habt Ihr eine bessere Variante als diese manuelle Scripting-Lösung?