Die Items

date:

    month:
        since:
            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.month.since.year
                    eval: str(sh.date.month.since.year()) + 'm'

        until:
            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.month.until.year
                    eval: str(sh.date.month.until.year()) + 'm'

    week:
        since:
            month:
                type: num
                cache: 'yes'
            year:
                type: num
                cache: 'yes'
        until:
            month:
                type: num
                cache: 'yes'
            year:
                type: num
                cache: 'yes'

    day:
        since:
            week:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.day.since.week
                    eval: str(sh.date.day.since.week()) + 'd'

            month:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.day.since.month
                    eval: str(sh.date.day.since.month()) + 'd'
            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.day.since.year
                    eval: str(sh.date.day.since.year()) + 'd'

        until:
            week:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.day.since.week
                    eval: str(sh.date.day.since.week()) + 'd'

            month:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.day.until.month
                    eval: str(sh.date.day.until.month()) + 'd'

            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.day.until.year
                    eval: str(sh.date.day.until.year()) + 'd'

    hour:
        since:
            midnight:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.since.midnight
                    eval: str(sh.date.hour.since.midnight()) + 'h'

            week:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.since.week
                    eval: str(sh.date.hour.since.week()) + 'h'

            month:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.since.month
                    eval: str(sh.date.hour.since.month()) + 'h'

            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.since.year
                    eval: str(sh.date.hour.since.year()) + 'h'

        until:
            midnight:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.until.midnight
                    eval: str(sh.date.hour.until.midnight()) + 'h'

            week:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.until.week
                    eval: str(sh.date.hour.until.week()) + 'h'

            month:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.until.month
                    eval: str(sh.date.hour.until.month()) + 'h'

            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.hour.until.year
                    eval: str(sh.date.hour.until.year()) + 'h'

    minute:
        since:
            hour:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.since.hour
                    eval: str(sh.date.minute.since.hour()) + 'i'

            midnight:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.since.midnight
                    eval: str(sh.date.minute.since.midnight()) + 'i'

            week:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.since.week
                    eval: str(sh.date.minute.since.week()) + 'i'

            month:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.since.month
                    eval: str(sh.date.minute.since.month()) + 'i'

            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.since.year
                    eval: str(sh.date.minute.since.year()) + 'i'

        until:
            hour:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.until.hour
                    eval: str(sh.date.minute.until.hour()) + 'i'

            midnight:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.until.midnight
                    eval: str(sh.date.minute.until.midnight()) + 'i'

            week:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.until.week
                    eval: str(sh.date.minute.until.week()) + 'i'

            month:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.until.month
                    eval: str(sh.date.minute.until.month()) + 'i'

            year:
                type: num
                cache: 'yes'
                dbstr:
                    type: str
                    cache: 'yes'
                    eval_trigger: date.minute.until.year
                    eval: str(sh.date.minute.until.year()) + 'i'

    second:
        since:
            minute:
                type: num

            hour:
                type: num

            midnight:
                type: num

            week:
                type: num

            month:
                type: num

            year:
                type: num

        until:

            minute:
                type: num

            hour:
                type: num

            midnight:
                type: num

            week:
                type: num

            month:
                type: num

            year:
                type: num

Die Logik

Als Logik wird unter logics/zeit.py die nachfolgende Datei angelegt.

# /logics/zeit.py
# !/usr/bin/env python3


from lib.shtime import Shtime

sh_now = Shtime.get_instance().now()

# Funktionen

def days_of_month(month, year):
    if month in [1, 3, 5, 7, 8, 10, 12]:
        days = 31
    elif month in [4, 6, 9, 11]:
        days = 30
    elif (year % 400 == 0) or ((year % 4 == 0) and not (year % 100 == 0)):  # Schaltjahr
        days = 29
    else:
        days = 28
    return days

def days_of_year(year):
    period_end = datetime.datetime(year, 12, 31)
    days_of_year = (period_end - datetime.datetime(period_end.year, 1, 1)).days + 1
    return (days_of_year)

def day_of_year(year, month, day):
    period_end = datetime.datetime(year, month, day)
    day_of_year = (period_end - datetime.datetime(period_end.year, 1, 1)).days + 1
    return (day_of_year)

# Sekunde/Minute
sh.date.second.since.minute(sh_now.second)
sh.date.second.until.minute(60 - sh_now.second - 1)

# Minute/Stunde
sh.date.minute.since.hour(sh_now.minute)
sh.date.minute.until.hour(60 - sh_now.minute - 1)

# Stunde/Tag
sh.date.hour.since.midnight(sh_now.hour)
sh.date.hour.until.midnight(24 - sh_now.hour - 1)

# Tag/Woche
sh.date.day.since.week(sh_now.isoweekday())
sh.date.day.until.week(7 - sh_now.isoweekday())

# Stunde/Woche
sh.date.hour.since.week(sh.date.hour.since.midnight() + (24 * (sh.date.day.since.week() - 1)))
sh.date.hour.until.week(sh.date.hour.until.midnight() + (24 * sh.date.day.until.week()))

# Kalenderwoche/Jahr
sh.date.week.since.year(sh_now.isocalendar()[1])
sh.date.week.until.year(52-sh_now.isocalendar()[1])

# Monat/Jahr
sh.date.month.since.year(sh_now.month)
sh.date.month.until.year(12 - sh_now.month)

# Sekunde/Stunde
sh.date.second.since.hour(sh.date.second.since.minute() + (60 * sh.date.minute.since.hour()))
sh.date.second.until.hour(sh.date.second.until.minute() + (60 * sh.date.minute.until.hour()))

# Sekunde/Tag
sh.date.second.since.midnight(sh.date.second.since.minute() + (3600 * sh.date.hour.since.midnight()))
sh.date.second.until.midnight(sh.date.second.until.minute() + (3600 * sh.date.hour.until.midnight()))

# Minute/Tag
sh.date.minute.since.midnight(sh.date.minute.since.hour() + (60 * sh.date.hour.since.midnight()))
sh.date.minute.until.midnight(sh.date.minute.until.hour() + (60 * sh.date.hour.until.midnight()))

# Minute/Woche
sh.date.minute.since.week(sh.date.minute.since.hour() + (60 * sh.date.hour.since.week()))
sh.date.minute.until.week(sh.date.minute.until.hour() + (60 * sh.date.hour.until.week()))

# Sekunde/Woche
sh.date.second.since.week(sh.date.second.since.minute() + (60 * sh.date.minute.since.week()))
sh.date.second.until.week(sh.date.second.until.minute() + (60 * sh.date.minute.until.week()))

# Tage/Monat
sh.date.day.since.month(sh_now.day)
sh.date.day.until.month(days_of_month(sh_now.month, sh_now.year) - sh.date.day.since.month() - 1)

# Wochen/Monat
sh.date.week.since.month((sh.date.day.since.month()-1)//7+1)
sh.date.week.until.month((sh.date.day.until.month())//7)

# Tage/Jahr
sh.date.day.since.year(day_of_year(sh_now.year, sh_now.month, sh_now.day) - 1)
sh.date.day.until.year(days_of_year(sh_now.year) - sh.date.day.since.year() - 1)

# Stunde/Monat
sh.date.hour.since.month((24 * sh.date.day.since.month()) + sh.date.hour.since.midnight())
sh.date.hour.until.month((24 * days_of_month(sh_now.month, sh_now.year)) - sh.date.hour.since.month() - 1)

# Stunde/Jahr
sh.date.hour.since.year((24 * sh.date.day.since.year()) + sh.date.hour.since.midnight())
sh.date.hour.until.year((24 * days_of_year(sh_now.year)) - sh.date.hour.since.year() - 1)

# Minute/Monat
sh.date.minute.since.month((60 * sh.date.hour.since.month()) + sh.date.minute.since.hour())
sh.date.minute.until.month(sh.date.minute.since.month() - (60 * sh.date.hour.until.month()) - 1)

# Minute/Jahr
sh.date.minute.since.year((60 * sh.date.hour.since.year()) + sh.date.minute.since.hour())
sh.date.minute.until.year((60 * sh.date.hour.until.year()) + sh.date.minute.until.hour())

# Sekunde/Monat
sh.date.second.since.month((60 * sh.date.minute.since.month()) + sh.date.second.since.minute())
sh.date.second.until.month((60 * sh.date.minute.until.month()) + sh.date.second.until.minute())

# Sekunde/Jahr
sh.date.second.since.year((60 * sh.date.minute.since.year()) + sh.date.second.since.minute())
sh.date.second.until.year((60 * sh.date.minute.until.year()) + sh.date.second.until.minute())

In der etc/logic.yaml wird sie wie folgt eingebunden:

zeitberechnung:
    filename: zeit.py
    crontab:
        -   init
        -   '* * * *'

Anwendungsbeispiel: Database Plugin

Neben der Anzeige der Daten, macht es vor allem Sinn, die Werte im Zusammenspiel mit (historischen) Datenbank-Daten zu verwenden. Ein Beispiel wäre wie folgt:

consumption_since_midnight:
	type: num
	eval: sh.knx.cellar.utility_room.water_meter.db('count>0', sh.date.minute.since.midnight.dbstr(), 'now')
	eval_trigger: knx.cellar.utility_room.water_meter
	database@mysqldb: init

Im Eval-Ausdruck wird die Anzahl der Werte > 0 ermittelt, die zwischen Mitternacht und dem IST-Zeitpunkt erfasst wurden. Da für 1 Liter jedes Mal ein Impuls mit einer „1“ erfasst wird, erhält man so minutengenau die Anzahl der Liter seit Mitternacht. Die Methode dbstr() in sh.date.minute.since.midnight.dbstr() liefert direkt den Wert, den das Database-Plugin benötigt. Präziser gesagt, hängt sie dem numerischen Wert noch ein „i“ an, so dass die Angabe auf Ebene des Plugins korrekt interpretiert wird.
Über die Methode .db auf dem Item, wird die Datenbankabfrage gestartet. Das Item muss dazu mit dem Database-Plugin verknüpft sein database@mysqldb: init und bereits Daten im abgefragten Zeitraum erfasst haben.

(Das Titelbild ist unter der Creative Commons Zero (CC0) Lizenz veröffentlicht und wurde von www.pexels.com bezogen.)

Anmerkung: mittlerweile sind die API Keys für Wundergrund leider nicht mehr kostenlos! Die Anleitung muss also mit einem alternativen Plugin wie Darksky oder OpenWeatherMap durchgeführt werden!

Basis des Artikels sind Daten zu Windrichtung und Windgeschwindigkeit über das Wundergrund Plugin. Es lassen sich aber bspw. auch Daten der KNX Wetterstation verwenden, sofern vorhanden.

Das Wundergrund Plugin konfigurieren

Die automatisch generierte Doku zum Wundergrund Plugin findet sich unter https://www.smarthomeng.de/user/plugins_doc/config/wunderground.html.

Das Plugin liegt auf Github unter https://github.com/smarthomeNG/plugins/tree/master/wunderground.

Als Erstes muss das Plugin in der etc/plugin.yaml eingetragen werden. Der apikey kann kostenlos (Update: leider sind die API Keys inzwischen nicht mehr kostenlos!) über https://www.wunderground.com/weather/api/d/pricing.html beantragt werden. Es ist darauf zu achten, dass das Updateintervall eine bestimmte Zeitdauer nicht überschreitet, speziell, wenn man Wundergrund auch direkt in der smartVISU nutzt. Das Limit sind 500 Calls pro Tag bzw. 10 Calls pro Minute. Das Default-Updateintervall für das Plugin sind 600 Sekunden, also einmal in 10 Minuten. Per cycle Attribut ließe sich dieses in der plugin.yaml anpassen.

Als location setzt man bspw. seinen Ort, es sind hier neben dem Namen aber auch Geokoordinaten möglich.

wundergrund_wetter:
    class_name: Wunderground
    class_path: plugins.wunderground
    apikey: 'xxxxyyyyxxxxyyyy'
    language: 'de'
    location: 'Germany/Hamburg'
    item_subtree: weather.wundergrund
    # cycle: 600

item_subtree ist der Ast im Itemtree, unter dem die Wundergrund-relevanten Items liegen. Im Beispiel ist es weather.wundergrund.
Die notwendigen Items sehen wie folgt aus:

%YAML 1.1
---
# items/wetter.yaml
weather:

    wundergrund:

        windrichtung:
            type: str
            wug_matchstring: current_observation/wind_dir

        windrichtung_grad:
            type: num
            wug_matchstring: current_observation/wind_degrees

        windgeschwindigkeit:
            type: num
            value: -9999
            wug_matchstring: current_observation/wind_kph
            wug_datatype: positive

            ms:
                type: num
                eval: (sh.weather.wundergrund.windgeschwindigkeit()/3.6)
                eval_trigger: weather.wundergrund.windgeschwindigkeit

            beaufort:
                type: num

            string:
                type: str
               
        windboeen:
            type: num
            value: -9999
            wug_matchstring: current_observation/wind_gust_kph
            wug_datatype: positive

Tipp: Neben dem Wind gibt es über Wundergrund noch viele weitere Wetterdaten.

Anzeige der Windrichtung in der smartVISU

Die Windrichtung lässt sich nun in der smartVISU 2.9 sehr einfach ausgeben:

{{ icon.compass('weather.wundergrund.windrichtung_compass', '', 'weather.wundergrund.windrichtung_grad',  '0', '360', '') }}
{{ basic.print('weather.wundergrund.windrichtung', 'weather.wundergrund.windrichtung', 'text') }}

Das Ergebnis ist eine sehr schöne Darstellung der Windrichtung:

Windstärke auswerten und in der smartVISU anzeigen

Als nächstes soll die Windstärke ausgewertet werden. Dafür dient die nach Sir Francis Beaufort benannte Beaufortskala, die Windstärken in 13 Bereichte von 0 (Windstille) bis 12 (Orkan) klassifiziert.

Für diese Skala ist der Wert im Item weather.wundergrund.windgeschwindigkeit.ms notwendig, das via Eval-Ausdruck die Windgeschwindigkeit von Kilometer pro Stunde in Meter pro Sekunde umrechnet (sh.weather.wundergrund.windgeschwindigkeit()/3.6). Die Umrechnung triggert jedes Mal, wenn sich weather.wundergrund.windgeschwindigkeit verändert.

Für die Auswertung der Windstärke muss unter logics/wind.py eine neue Logik erstellt werden, die die Items weather.wundergrund.windgeschwindigkeit.string und weather.wundergrund.windgeschwindigkeit.beaufort befüllt:
Der Eintrag in der etc/logic.yaml sieht wie folgt aus:

WindLogic:
    crontab: init
    filename: wind.py
    watch_item: weather.wundergrund.windgeschwindigkeit.ms

Die Logik löst also jedes Mal aus, wenn sich weather.wundergrund.windgeschwindigkeit.ms ändert.

Der Code der Logik in der Datei logics/wind.py mappt nun die Windgeschwindigkeit in Meter pro Sekunde auf die Beaufortskala:

if sh.weather.wundergrund.windgeschwindigkeit.ms() < 0.3:
    sh.weather.wundergrund.windgeschwindigkeit.string("Windstille")
    sh.weather.wundergrund.windgeschwindigkeit.beaufort(0)
elif 0.3 <= sh.weather.wundergrund.windgeschwindigkeit.ms() < 1.6:
    sh.weather.wundergrund.windgeschwindigkeit.string("leiser Zug")
    sh.weather.wundergrund.windgeschwindigkeit.beaufort(1)
elif 1.6 <= sh.weather.wundergrund.windgeschwindigkeit.ms() < 3.4:
    sh.weather.wundergrund.windgeschwindigkeit.string("leichte Brise")
    sh.weather.wundergrund.windgeschwindigkeit.beaufort(2)
elif 3.4 <= sh.weather.wundergrund.windgeschwindigkeit.ms() < 5.5:
    sh.weather.wundergrund.windgeschwindigkeit.string("schwacher Wind")
    sh.weather.wundergrund.windgeschwindigkeit.beaufort(3)
elif 5.5 <= sh.weather.wundergrund.windgeschwindigkeit.ms() < 8.0:
    sh.weather.wundergrund.windgeschwindigkeit.string("mäßiger Wind")
    sh.weather.wundergrund.windgeschwindigkeit.beaufort(4)
elif 8.0 <= sh.weather.wundergrund.windgeschwindigkeit.ms() < 10.8:
    sh.weather.wundergrund.windgeschwindigkeit.string("frischer Wind")
    sh.weather.wundergrund.windgeschwindigkeit.beaufort(5)
elif 10.8 <= sh.weather.wundergrund.windgeschwindigkeit.ms() < 13.9:
    sh.weather.wundergrund.windgeschwindigkeit.string("starker Wind")
    sh.weather.wundergrund.windgeschwindigkeit.beaufort(6)
elif 13.9 <= sh.weather.wundergrund.windgeschwindigkeit.ms() < 17.2:
    sh.weather.wundergrund.windgeschwindigkeit.string("steifer Wind")
    sh.weather.wundergrund.windgeschwindigkeit.beaufort(7)
elif 17.2 <= sh.weather.wundergrund.windgeschwindigkeit.ms() < 20.8:
    sh.weather.wundergrund.windgeschwindigkeit.string("stürmischer Wind")
    sh.weather.wundergrund.windgeschwindigkeit.beaufort(8)
elif 20.8 <= sh.weather.wundergrund.windgeschwindigkeit.ms() < 24.5:
    sh.weather.wundergrund.windgeschwindigkeit.string("Sturm")
    sh.weather.wundergrund.windgeschwindigkeit.beaufort(9)
elif 24.5 <= sh.weather.wundergrund.windgeschwindigkeit.ms() < 28.5:
    sh.weather.wundergrund.windgeschwindigkeit.string("schwerer Sturm")
    sh.weather.wundergrund.windgeschwindigkeit.beaufort(10)
elif 28.5 <= sh.weather.wundergrund.windgeschwindigkeit.ms() < 32.7:
    sh.weather.wundergrund.windgeschwindigkeit.ms.string("orkanartiger Sturm")
    sh.weather.wundergrund.windgeschwindigkeit.beaufort(11)
else:
    sh.weather.wundergrund.windgeschwindigkeit.string("Orkan")
    sh.weather.wundergrund.windgeschwindigkeit.beaufort(12)

Damit die Logik effektiv wird, muss SmartHomeNG neu gestartet oder die Logik via Backend-Plugin aktiviert werden.

Sinnvollerweise kann diese Logik auch in einer Funktion gekapselt werden. Dies ist an einem Alternativansatz, der mit einer Lookup-Tabelle arbeitet, im Folgenden dargestellt:

#!/usr/bin/env python3
# beaufort3.py

def get_beaufort(speed):
    """
    :parameter speed: windspeed in meter per second
    :return: a tuple of a string with the (german) description and an integer with beaufort speed
    """
    table = [ 
        (  0.3, "Windstille",0),
        (  1.6, "leiser Zug",1),
        (  3.4, "leichte Brise",2),
        (  5.5, "schwacher Wind",3),
        (  8.0, "mäßiger Wind",4),
        ( 10.8, "frischer Wind ",5),
        ( 13.9, "starker Wind",6),
        ( 17.2, "steifer Wind",7),
        ( 20.8, "stürmischer Wind",8),
        ( 24.5, "Sturm",9),
        ( 28.5, "schwerer Sturm",10),
        ( 32.7, "orkanartiger Sturm",11),
        ( 999,  "Orkan",12) ]
    
    try:
        description = min(filter(lambda x: x[0] >= speed, table))[1]
        bft = min(filter(lambda x: x[0] >= speed, table))[2]
        return description,bft
    except ValueError:
        return None, None

decription, bft = get_beaufort(sh.weather.wundergrund.windgeschwindigkeit.ms())
sh.weather.wundergrund.windgeschwindigkeit.string(description)
sh.weather.wundergrund.windgeschwindigkeit.beaufort(bft)

In der smartVISU können diese Werte nun wie folgt angezeigt werden:

{{ basic.symbol('', '', '', 'weather_wind_speed_bft') }}                       
Bft: {{ basic.print('wind_weatherstation_bfvalue', 'knx.weather.wind.beaufort') }}, 
{{ basic.print('wind_weatherstation_string', 'knx.weather.wind.string', 'text') }}

Das Ergebnis:

(Die in diesem Artikel verwendeten Screenshots wurden selber erstellt. Das Titelbild ist unter der Creative Commons Zero (CC0) Lizenz veröffentlicht und wurde von www.pexels.com bezogen.)