Abbildung „Müllkalender“ in openHAB

Um regelmäßig seine Mülltonnen am Entsorgungstag am Straßenrand zu stellen, haben die meisten Personen einen Papierkalender im Haus. Viele Entsorger stellen aber auch die Abholdaten der Mülltonnen online oder per Kalender bereit

Für den Landkreis Dachau gibt es eine App (DAH-Müll) und eine Oberfläche zur Visualisierung. Leider kann man auf die Daten dort nicht direkt per ICS / iCalendar zugreifen  (da haben sich die Zuständigen etwas sehr gutes einfallen lassen).

Deswegen muss man jetzt manuell einmal die Kalenderdaten pro Jahr dort exportieren und sie in einen eigenen Kalender importieren (geht auch, aber Anwenderfreundlich ist etwas anderes).

Der Anwendungsfall ist also einen Kalender auszulesen und am Vortag eine Erinnerung an die digitalen Endgeräte, Sprachsteuerungen oder Kalender zu senden. Dazu wird in openHAB das CalDAV-Binding verwendet.

Beispiele für die Verwendung findet Ihr hier bei onesmarthome.de oder im openhabforum.de.

Kalendereinrichtung

Im ersten Schritt besorgt man sich die iCalendar-Daten aus seinem jeweiligen Landkreis / Ort. Bei mir waren die Daten hier.

Leider musste ich die Inhalte noch etwas „umformatieren“:

  • DTEND-Tag fehlt in den Kalenderdaten (ohne diese können die Daten nicht in der ownCloud verwendet werden)
  • DTEND-Tag muss einen Tag nach dem DTSTART-Tag gesetzt sein (sonst können die Daten nicht in der ownCloud verwendet werden)

Danach habe ich in meinem System (hier ownCloud) einen Kalender „Müll“ erstellt und die oben beschriebenen Daten importiert.

Danach kann ich folgenden Link für die weitere Integration verwenden:

https://URL/remote.php/dav/calendars/USER/CALENDAR/

Die URL, USER und CALENDAR müsst Ihr an eure Anforderungen anpassen.

Binding

Das CalDAV1-Binding wird wie folgt installiert:

Paper UI – Add-ons – Bindings – CalDAV Binding (personal) – INSTALL

ACHTUNG: Das CalDAV Binding (command) wird zur Steuerung und Präsenzmeldung verwendet und ist für diesen Beitrag nicht notwendig.

Services (caldavio.cfg)

Es wird die Datei services/caldavio mit folgendem Inhalt erstellt:

caldavio:Muell:url=https://URL/remote.php/dav/calendars/USER/CALENDAR/

caldavio:Muell:username=USER

caldavio:Muell:password=PASSWORD

caldavio:Muell:reloadInterval=60

caldavio:Muell:preloadTime=2880

caldavio:Muell:disableCertificateVerification=true

caldavio:Muell:charset=utf8

Die groß geschriebenen Wörter bitte mit euren Daten ergänzen. Wichtig war in meiner Konfiguration noch disableCertificateVerification (wahrscheinlich wegen meinen kostenlosen Zertifikaten) und charset auf UTF-8.

Den reloadInterval kann man zum Testen auch auf 1 Minute stellen.

Items (CalDAV.items)

Ich habe für zwei Kalendereinträge und Datumswerte die Items generiert (es können bei mir zwei Tonnen zum gleichen Tag abgeholt werden):

/* Müllkalender */
String      CalDAV_Muell_1       "Erste Tonne [%s]"                          <calendar>    { caldavPersonal="calendar:Muell type:EVENT eventNr:1 value:NAME" }
DateTime    CalDAV_Muell_1_Date  "Datum der Abholung [%1$td.%1$tm.%1$tY]"    <calendar>    { caldavPersonal="calendar:Muell type:EVENT eventNr:1 value:START" }
String      CalDAV_Muell_2       "Zweite Tonne [%s]"                         <calendar>    { caldavPersonal="calendar:Muell type:EVENT eventNr:2 value:NAME" }
DateTime    CalDAV_Muell_2_Date  "Datum der Abholung [%1$td.%1$tm.%1$tY]"    <calendar>    { caldavPersonal="calendar:Muell type:EVENT eventNr:2 value:START" }

Sitemap

In der Sitemap habe ich das recht einfach so dargestellt:

Frame label="Informationen" {
Frame label="Müllkalender"{
                           Text item=CalDAV_Muell_1
                           Text item=CalDAV_Muell_1_Date
                           Text item=CalDAV_Muell_2
                           Text item=CalDAV_Muell_2_Date
              }
}

Rules (CalDAV.rules)

Nun erfolgt die Automatisierung und die Benachrichtigung in der Regel (das kann man bestimmt noch etwas eleganter „scripten“):

rule "Müllkalender"
when
//Time cron "0 * * ? * *"    //every 1 Minute
    Time cron "0 15 17 * * ?"    //once per Day 17:15
    //Item date_today changed
then
    var String muelltonne_1
    muelltonne_1 = CalDAV_Muell_1.state.toString

    var String muelltonne_2
    muelltonne_2 = CalDAV_Muell_2.state.toString

    // Prüfung ob der Wert gefüllt ist (damit beim cast auf DateTimeType keine Fehlermeldung erscheint)
    if (muelltonne_1 != "UNDEF") {
        // Datum der Abholung wird mit dem aktuellen Datum verglichen
        // die erste Bedingung prüft, ob das aktuelle Datum vor dem Ablaufdatum + 24 Std. liegt
        // die zweite Bedingung prüft, ob das aktuelle Datum nach dem Datum der Abholung liegt
        if (now.isBefore(new DateTime((CalDAV_Muell_1_Date.state as DateTimeType).getCalendar().getTime()).plusHours(24)) &&
            now.isAfter(new DateTime((CalDAV_Muell_1_Date.state as DateTimeType).getCalendar().getTime()))) {

            // Benachrichtigung per Telegram an Bot senden
            if(muelltonne_2 == "UNDEF") {
                sendTelegram("xxx_bot", "Müllkalender: %s", muelltonne_1)
                logInfo("INFO","CalDAV.rules - Müllkalender: %s", muelltonne_1)           
            } else {
                sendTelegram("xxx_bot", "Müllkalender: %s & %s", muelltonne_1, muelltonne_2)
                logInfo("INFO","CalDAV.rules - Müllkalender: %s & %s", muelltonne_1, muelltonne_2)           
            }         
        }
    }
end

Fazit

Die Anbindung des Kalenders in openHAB war relativ einfach. Etwas schwieriger hat sich die Anpassung der ICS-Datei aus meinem Landkreis gestaltet. Danach hat man recht einfach (nach ein paar Tests) seine Kalenderdaten angebunden.

In der Regel waren dann noch ein paar Workarounds notwendig, aber dann waren die Daten auch richtig vorhanden. Die Konvertierung in UTF-8 / Unicode war nicht so einfach in der cfg zu finden. Auch den CRON-Job nur einmal am Tag zu einer bestimmten Zeit auszuführen war für einen „Nicht-UNIXer“ nicht das einfachste 😉

Nun bekomme ich aber am Vortag um 17:15 Uhr eine Information per Telegram, dass die Müllabfuhr am nächsten Tag kommt.

Habt Ihr noch Ideen für die weitere Anbindung von Kalenderdaten? Habt Ihr eine Präsenzmeldung oder Steuerung eures SmartHome damit realisiert?

Aktuelle Zeit und Datum in openHAB per NTP

Für Berechnungen und zur allgemeinen Visualisierung soll in openHAB das aktuelle Datum und Uhrzeit über NTP aktualisiert und dargestellt werden. Weitere Informationen über das Network Time Protocol findet Ihr bei Wikipedia.

Binding

Die Dokumentation zum NTP-Binding findet Ihr hier – https://docs.openhab.org/addons/bindings/ntp/readme.html

Die Installation in der Paper UI wird über „Add-ons – Bindings – NTP Binding – INSTALL“ vorgenommen.

Things (NTP.things)

Eine Konfiguration des Servers wird in der Things-Datei konfiguriert:

ntp:ntp:zeit  [ hostname="nl.pool.ntp.org", refreshInterval=60, refreshNtp=30 ]

Items (NTP.items)

Das Format wird in der Items-Datei den Wünschen entsprechend angepasst:

DateTime Date  "Date [%1$tA, %1$td.%1$tm.%1$tY %1$tH:%1$tM]"  { channel="ntp:ntp:zeit:dateTime" }

Fazit

Mit ein paar Klicks hat man das Zeitprotokoll (NTP) in openHAB integriert.

Eine Visualisierung in der Sitemap ist nicht notwendig, da ich in meinem Fall die Werte nur in Regeln benötige.

In den nächsten Beiträgen werden ich darstellen, für was ich die NTP-Daten benötige.

Unwetterdaten vom DWD in openHAB

Da wir letzte Woche an einem Abend ein größeres Unwetter hatten, habe ich mich entschlossen Unwetterdaten vom Deutschen Wetterdienst in openHAB zu integrieren.

Die Daten vom DWD sollen in der GUI angezeigt werden und wenn ein Unwetter im Anmarsch ist eine Benachrichtigung auf ein mobiles Endgerät senden.

Ein gutes Beispiel wie man die JSON-Daten in openHAB übernimmt, findet Ihr hier im openHAB-Forum.

Vorbereitung

Für die Integration der Unwettermeldungen benötigt Ihr deine „WARNCELLID“ für euren Ort.

Außerdem müssen / können noch bestimmte Bilder für die Visualisierung integriert werden (die Images findet Ihr auch in dem oben genannten Forums-Beitrag):

  • Images nach /icons/classic kopieren
  • Dauert eine Zeit bis diese in der Paper UI dargestellt werden
  • Option: Paper UI – Configuration – Services – UI – Basic UI / Classic UI – Icon Format von „Vecotr“ auf „Bitmap“ stellen (Standard: Vector)
  • Rechte und User in Linux kontrollieren (chmod + chown) – /etc/openhab2/icons/classic

Bindings

Diese Bindings benötigt Ihr für die Integration:

  • Paper UI – Add-ons – Transformations – Javascript Transformation (Version 2.3.0) – INSTALL
  • Paper UI – Add-ons – Transformations – JSONPath Transformation (Version 2.3.0) – INSTALL
  • Paper UI – Add-ons – Transformations – Map Transformation (Version 2.3.0) (war bereits installiert)

Items (Wetter_DWD.items)

Diese Items habe ich für die Visualisierung erstellt:

DateTime        DWD_Warnung_start                   "von: [%1$td.%1$tm.%1$tY %1$tH:%1$tM Uhr]"        <time>                        
DateTime        DWD_Warnung_end                     "bis: [%1$td.%1$tm.%1$tY %1$tH:%1$tM Uhr]"        <time>
Number          DWD_Warnung_level                   "Warnstufe: [MAP(Wetter_DWD.map):%s]"             <dwdwarnung>
String          DWD_Warnung_description             "Beschreibung: [%s]"                              <warnung>
String          DWD_Warnung_headline                "Betreff: [%s]"                                   <warnung>
String          DWD_Warnung_instruction             "Hinweis: [%s]"                                   <warnung>
String          DWD_Warnung_event                   "Event: [%s]"                                     <warnung>

String          DWDSelectedSite

Map (Wetter_DWD.map)

Für die Darstellung muss eine Map erstellt werden:

0=Keine Warnung (0)

1=Wetterwarnung (1)

2=markantes Wetter (2)

3=Unwetterwarnung (3)

4=extremes Unwetter (4)

10=Hitzewarnung (10)

Transform (Wetter_DWD_getWarningsJSON.js)

Die Transformaton der Wetterdaten wird mit diesem Script durchgeführt:

(function(jsonString) {
    var newString = jsonString.replace('warnWetter.loadWarnings(','');
    newString = newString.replace(');','');
    var newJSON = JSON.parse(newString);
    var jsonResult = "";
    if (newJSON.warnings.hasOwnProperty('WARNCELLIC')) {
        jsonResult =JSON.stringify(newJSON.warnings['WARNCELLID'][0]);
    } else jsonResult = 'NULL'
    return jsonResult;
    })(input)

ACHTUNG: Die WARNCELLID muss durch eure individuelle ID ersetzt werden.

Rules (Wetter_DWD.rules)

Für die Automatisierung wird noch folgende Regel erstellt:

rule "DWD Warnungen"
when
Time cron "0 */30 * ? * *"  //every 30 Minutes
//Time cron "0 * * ? * *"    //every 1 Minute

then
var String jsonString = sendHttpGetRequest("https://www.dwd.de/DWD/warnungen/warnapp/json/warnings.json")
var String newString = transform("JS", "Wetter_DWD_getWarningsJSON.js", jsonString)
if (newString !="NULL") {
var String newStart = transform("JSONPATH", "$.start", newString)
var DateTime timestart = new DateTime(Long::parseLong(newStart))
DWD_Warnung_start.postUpdate(new DateTimeType(timestart.toString))
var String newEnd = transform("JSONPATH", "$.end", newString)
if (newEnd !==null) {
var DateTime timeend = new DateTime(Long::parseLong(newEnd))
DWD_Warnung_end.postUpdate(new DateTimeType(timeend.toString))
}

DWD_Warnung_level.postUpdate(transform("JSONPATH","$.level",newString))
DWD_Warnung_description.postUpdate(transform("JSONPATH","$.description",newString))
DWD_Warnung_headline.postUpdate(transform("JSONPATH","$.headline",newString))
DWD_Warnung_instruction.postUpdate(transform("JSONPATH","$.instruction",newString))
DWD_Warnung_event.postUpdate(transform("JSONPATH","$.event",newString))

// Benachrichtigung per Telegram an Bot senden
sendTelegram("BOTNAME", "Wetterwarnung in Altomünster" + "\n" +
                                    "\nWarnstufe: " + DWD_Warnung_level.state.toString +
                                    "\nBeschreibung: " + DWD_Warnung_description.state.toString +
                                    "\nBetreff: " + DWD_Warnung_headline.state.toString +
                                    "\nHinweis: " + DWD_Warnung_instruction.state.toString +
                                    "\nEvent: " + DWD_Warnung_event.state.toString)
}

if (newString =="NULL") {
DWD_Warnung_start.postUpdate("NULL")
DWD_Warnung_end.postUpdate("NULL")
DWD_Warnung_level.postUpdate(0)
DWD_Warnung_description.postUpdate("-")
DWD_Warnung_headline.postUpdate("derzeit keine Warnungen")
DWD_Warnung_instruction.postUpdate("-")
DWD_Warnung_event.postUpdate("-")        
}
end

ACHTUNG: Die Regel wird alle 30 Minuten ausgeführt und aktualisiert so die Daten. Die Funktion sendTelegram sendet an meinen Telegram-Bot die Informationen für die Benachrichtigung auf dem SmartPhone (dieses müsst Ihr dann ggf. hinzufügen oder die Zeilen entfernen – der BOTNAME muss gegen eure Konfiguration getauscht werden).

Sitemap

In der Sitemap können die Inhalte so angezeigt werden:

Text label=“Wetterwarnungen“ icon=“dwdicon“ {

Frame label=““ {

Selection item=DWDSelectedSite label=“Wetter“ icon=“dwd“ mappings=[1=“Aktuell“, 2=“Regenradar“, 3=“Heute“, 4=“Morgen“, 5=“Übermorgen“, 6=“Unwetter“, 7=“Pollenflug“, 8=“Warnungen“]

}

Frame label=“ “        visibility=[DWDSelectedSite==8] {

Text item=DWD_Warnung_headline                label=““                                                                                                        valuecolor=[DWD_Warnung_level==1=“#ffff00″, DWD_Warnung_level==2=“#ffa500″, DWD_Warnung_level==3=“#ff0000″, DWD_Warnung_level==4=“#800000″]

Text item=DWD_Warnung_level                                                        visibility=[DWD_Warnung_level!=0]                        valuecolor=[1=“#ffff00″, 2=“#ffa500″, 3=“#ff0000″, 4=“#800000″]

Text item=DWD_Warnung_start                                                        visibility=[DWD_Warnung_start!=“NULL“]

Text item=DWD_Warnung_end                        icon=“null“                visibility=[DWD_Warnung_end!=“NULL“]

}

Frame label=“ “         visibility=[DWDSelectedSite==8] {

Text item=DWD_Warnung_description                                        visibility=[DWD_Warnung_description!=“-„]

Text item=DWD_Warnung_instruction        icon=“null“                visibility=[DWD_Warnung_instruction!=“-„]

}

Frame label=“ “         visibility=[DWDSelectedSite==8] {

Text item=DWD_Warnung_event                                                        visibility=[DWD_Warnung_event!=“-„]                        valuecolor=[DWD_Warnung_level==1=“#ffff00″, DWD_Warnung_level==2=“#ffa500″, DWD_Warnung_level==3=“#ff0000″, DWD_Warnung_level==4=“#800000“]

}

}

Test

Für einen ersten Test könnt Ihr die DWD-URL manuell aufrufen:

  • https://www.dwd.de/DWD/warnungen/warnapp/json/warnings.json

Bei dieser URL könnt Ihr dann eine WARNCELLID kopieren und in euer Script (JS) einbauen. Damit könnt Ihr dann eine „Warnung“ simulieren und die oben genannten Konfigurationen testen.

Fazit

Im Zusammenspiel mit den mobilen Benachrichtigungen und dem Auslesen der Daten des Deutschen Wetterdienstes ergeben sich sinnvolle Anwendungsbeispiele. Wenn man etwas tiefer in openHAB einsteigen möchte (und es keine Standard-Bindings für die Anforderung gibt) kann man mit dem JSON-Binding und dem JavaScript-Binding recht einfach Webservices anbinden.

Das Auslesen der JSON-Datei klappt recht einfach und ist mit wenigen Zeilen Scripting erledigt.

Würdet Ihr Unwetterdaten in eure SmartHome-Umgebung integrieren? Fallen euch noch weitere Szenarien z.B. Pollenflug etc. ein?

Speicherung von Daten in openHAB

In den letzten Blog-Artikeln habe ich ein paar Wetterdaten in openHAB integriert und diese Daten entsprechend visualisiert.

In diesem Artikel sollen jetzt Daten aus dem WetherBinding von ForecastIo langristig im System gespeichert werden. Dazu wird die Round-Robin-Datenbank RRD4j verwendet.

Die Idee zur Speicherung der Daten ist mir beim Lesen des Beitrags auf  zukunftathome.de gekommen.

Es soll die erfasste Außentemperatur einmal am Tag gespeichert und in einem Diagramm visualisiert werden.

ACHTUNG: RRD4j ist nicht für die langfristige Datenspeicherung geeignet, da ältere Werte immer weniger verfügbar sind.

Installation

Die Installation erfolgt ganz einfach über die Paper UI:

  • Add-ons – Persitence – RRD4j Persistence

Dort die Schaltfläche INSTALL auswählen und die Persistenzschicht ist installiert.

Konfiguration

Mit einem beliebigen Editor (bei mir Visual Studio Code) die Datei rrd4j.persist im Ordner persistence mit folgendem Inhalt anlegen:

Strategies
{
   everyMinute  : "0 * * * * ?"
   everyHour    : "0 0 * * * ?"
   everyDay     : "0 0 0 * * ?"
   default = everyChange
}

Items
{
    weatherTemperature : strategy = everyDay, restoreOnStartup
}

In den Strategies wird definiert in welchen Zeitinverallen Daten abgespeichert werden. Die Strategie für everyMinute muss zwingend angelegt werden.

Unter Items werden die Daten hinterlegt die in der Datenbank gespeichert werden sollen.  Die Daten müssen in den zugehörigen *.items-Dateien vorhanden sein.

In meinem Beispiel wird einmal am Tag die Variable weatherTemperature (also meine Außentemperatur) gespeichert.

Items

In den zugehörigen Items-Dateien muss normalerweise nichts angepasst werden.

Es wird aber eine Hilfsvariable für die Darstellung des Zeitraums in einem Diagramm benötigt:

Number Chart_Zeitraum_D_W_M_Y

Sitemap

Für die Visualisierung können die Daten dann wie folgt eingebunden werden:

Frame label=“Historie Außentemperatur (Altomünster)“ {

Switch item=Chart_Zeitraum_D_W_M_Y label=““ mappings=[0=“Tag“, 1=“Woche“, 2=“Monat“, 3=“Jahr“]

Chart item=weatherTemperature period=D refresh=60000 visibility=[Chart_Zeitraum_D_W_M_Y==0, Chart_Zeitraum_D_W_M_Y==“Uninitialized“]

Chart item=weatherTemperature period=W refresh=60000 visibility=[Chart_Zeitraum_D_W_M_Y==1]

Chart item=weatherTemperature period=M refresh=60000 visibility=[Chart_Zeitraum_D_W_M_Y==2]

Chart item=weatherTemperature period=Y refresh=60000 visibility=[Chart_Zeitraum_D_W_M_Y==3]

}

Funktionstest

Da ich momentan die Daten nur einmal am Tag speichere, wollte ich auch sehen ob etwas in den RRD4j-Datenbanken ankommt.

Dazu kann die REST-API wie folgt aufgerufen werden – http://IP:PORT/doc/index.html

Mit dieser URL kann ein Item aus der Persistenzschicht abgerufen werden (hier weatherTemperature):

http://IP:PORT/rest/persistence/items/weatherTemperature

Als Ergebnis sollte dann eine Struktur wie hier dargestellt werden:

{„name“:“weatherTemperature“,“datapoints“:“1″,“data“:[{„time“:1535463840000,“state“:“24.64999999999999857891452847979962825775146484375″}]}

Fazit

Mit ein paar Handgriffen kann man seine openHAB-Daten in einer Datenbank ablegen. Für einen ersten Test sollte RRD4j für meine Anforderungen ausreichen (eine langfristige Speicherung der Wetterdaten werde ich erst mit einer eigenen Wetterstation umsetzen).

Welche Daten würdet Ihr langfristig aus eurem System speichern? Habt Ihr andere Datenbanken verwendet?

Wetterprognosen in openHAB

Ich hatte in einem vorherigen Beitrag schon einmal dargestellt wie man Wetter-Daten in openHAB visualisieren kann. Hier hatte ich das Problem, dass ich über den Provider keine Wetterprognosen über die kostenlose API bekommen habe.

Ich habe jetzt ein paar Provider verglichen und mich für einen entschieden:

  • WeatherUnderground (keine kostenlose API für den Privatgebrauch)
  • OpenWeatherMap (keine Wetterprognosen da nur Premium-Key unterstützt wird, gute Möglichkeit für aktuelle Daten)
  • Wunderground (keine kostenlose API für den Privatgebrauch)
  • ForecastIo (kostenlose API, Wetterprognose funktioniert, 1000 Aufrufe pro Tag)

Die meisten meiner Anforderungen erfüllt ForcastIo momentan. Ich habe den Provider jetzt für den ersten Test eingebunden und werde die aktuellen Wetterdaten und Prognosen die nächsten Tage mit dem echten Wetter vergleichen.

Welchen Wetterprovider nutzt Ihr für eure Wetterdaten?

Wetterdaten in openHAB integrieren

Für weitere Regeln und Automatisierungen wollte ich die aktuellen Wetterdaten in openHAB integrieren. Im ersten Schritt wollte ich das ohne eigene Wetterstation umsetzen und die externen Daten etwas aggregieren und testen welche Daten ich überhaupt benötige.

Alle Artikel die ich gefunden habe, referenzieren aktuell auf das WeatherUnderground Binding. Leider gibt es dafür keine kostenlosen API-Keys zur privaten Nutzung mehr. Als Alternative habe ich jetzt das Weather1 Binding mit Daten von OpenWetherMap verwendet.

Die Grundlagen für den Artikel habe ich bei Wenzlaff.de gefunden.

Installation

Die Installation wird wie gewohnt in openHAB in der Paper UI durchgeführt:

openHAB – Paper UI – Add-ons – Bindings – Weather Binding – INSTALL

Bitte achtet darauf, dass die Legacy-Bindings für ein Version 1 Binding in den Einstellungen aktiviert sind.

OpenWeatherMap

Für die Verwendung von externen Wetterdaten benötigt man bei OpenWeatherMap einen API-Key. Der Account wird hier erstellt und danach per E-Mail verschickt.

Services

Die Anpassung der Services wird in der Datei services/weather.cfg vorgenommen.

apikey.OpenWeatherMap=xxx

# Location – Altomünster – OpenWeatherMap

weather:location.Altomuenster-OWM.latitude=48.3859

weather:location.Altomuenster-OWM.longitude=11.2535

weather:location.Altomuenster-OWM.provider=OpenWeatherMap

weather:location.Altomuenster-OWM.language=de

weather:location.Altomuenster-OWM.updateInterval=30

Der apiKey muss durch den vorher generierten Schlüssel ersetzt werden. Die location kann an die eigenen Bedürfnisse angepasst werden. Den Aktualisierungsintervall habe ich auf 30 Minuten gesetzt.

Um die GPS-Koordinaten (latitude, longitude) für Altomünster herauszufinden, habe ich den Service von gpskoordniaten.de genutzt.

Items

Als erste Test-Items kann man den Satz an Daten verwenden:

// OpenWeatherMap Daten
Number   owmHumidity                              "Feuchte [%d %%]"                                                        {weather="locationId=Altomuenster-OWM, type=atmosphere, property=humidity"}
Number   owmTemperature                           "Temperatur [%.2f °C]"                                                   {weather="locationId=Altomuenster-OWM, type=temperature, property=current"}
Number   owmPressure                            "Luftdruck [%.2f hPa]"                                                   {weather="locationId=Altomuenster-OWM, type=atmosphere, property=pressure"}
String   owmPressureTrend                    "Luftdruck Trend [%s]"                                                   {weather="locationId=Altomuenster-OWM, type=atmosphere, property=pressureTrend"}
Number   owmWindSpeed               "Windgeschwindigkeit [%.2f km/h]"                            {weather="locationId=Altomuenster-OWM, type=wind, property=speed"}
String   owmWindDirection           "Windrichtung [%s]"                                                      {weather="locationId=Altomuenster-OWM, type=wind, property=direction"}
Number   owmWindDegree                            "Windrichtung in Grad [%.0f °]"                                   {weather="locationId=Altomuenster-OWM, type=wind, property=degree"}
Number   owmClouds                                   "Bewölkung [%.0f %%]"                                                          {weather="locationId=Altomuenster-OWM, type=clouds, property=percent"}
Number   owmRain                                  "Regen der letzten 3 Stunden [%.2f mm/h]"           {weather="locationId=Altomuenster-OWM, type=precipitation, property=rain"}
Number   owmSnow                                  "Schnee der letzten 3 Stunden [%.2f mm/h]"      {weather="locationId=Altomuenster-OWM, type=precipitation, property=snow"}

// Forecast +1 ist der nächste Tag
// ACHTUNG: Funktioniert aktuell nicht mit OpenWeatherMap, 25.08.2018
Number   ownForecastTempMin         "Temperatur min. [%.2f °C]"                      {weather="locationId=Altomuenster-OWM, forecast=1, type=temperature, property=min"}
Number   ownForecastTempMax         "Temperatur max. [%.2f °C]"                      {weather="locationId=Altomuenster-OWM, forecast=1, type=temperature, property=max"}

Sitemap

Danach habe ich die Sitemap zur Visualisierung an meine Anforderungen angepasst:

Text label="Wetter" icon="temperature" {
Frame label="Altomünster (Open Weather Map)" {           
Frame label="Heutiger Tag" {           
Text item=owmTemperature icon="selfTemperature"
Text item=owmHumidity icon="selfWater"
Text item=owmPressure
Text item=owmPressureTrend
Text item=owmWindSpeed icon="wind"
Text item=owmWindDirection icon="wind"
Text item=owmWindDegree icon="wind"
Text item=owmClouds
Text item=owmRain icon="rain"
Text item=owmSnow
}

Frame label="Morgiger Tag" {           
Text item=ownForecastTempMin
Text item=ownForecastTempMax
}
}        
}

Fazit

Mit dem Weather1 Binding sind schnell und unkompliziert „grobe“ Wetterdaten in openHAB integriert.

Was ich leider erst im Nachgang gesehen habe ist das von OpenWeatherMap mit den kostenlosen Accounts momentan nur aktuelle Tagesdaten und keine Wettervorschau für die nächsten Tage verwendet werden kann (obwohl das in der Dokumentation anders beschrieben steht).  Das Problem wird in diesem Ticket im Detail beschrieben.

Wie habt Ihr eure Wetterdaten zur Hausautomatisierung verwendet? Soll ich doch besser gleich auf eine „richtige“ Wetterstation für die Daten umsteigen?

Anbindung Amazon Alexa an openHAB

Nachdem Update auf openHAB 2.3 steht mir nun auch das Amazon Echo Control Binding zur Verfügung. Bis jetzt konnte ich unsere Echo-Geräte (also „Alexa“) nur zur Steuerung der Hausautomatisierung per Sprachbefehlen verwenden. Mit dem neuen Binding ist es jetzt auch möglich die Echo-Geräte direkt in openHAB zu integrieren und damit eine Steuerung zu ermöglichen.

Es ist zum Beispiel damit möglich beim Betätigen eines KNX-Lichtschalters einen bestimmten Sender / Playlist auf allen Echo-Geräten abzuspielen. Auch können die Echo-Geräte für die Ausgabe von bestimmten Befehlen der Hausautomatisierung benutzt werden. Mir fallen da so einige Einsatzgebiete für die Zukunft ein 🙂

Aber im ersten Schritt muss erst einmal alles in openHAB eingebunden werden

Installation

Als erstes muss das Binding unter „Paper UI – Add-ons – Bindings – Amazon Echo Control Binding“ installiert werden.

Die ersten Schritte zu Konfiguration werden hier beschrieben.

Beispiel

Das komplette Beispiel auf der openHAB-Seite findet Ihr hier. Ich habe einige Anpassungen vorgenommen, aber der Ablauf sollte auch an meiner Konfiguration erkennbar sein.

Things

Nach der Installation muss ein Thing für den Amazon Account und die zugehörigen Geräte erstellt werden.

In meiner Konfiguration sieht das wie folgt aus (2 Echo’s, 1 Echo Dot, eine Multi-Room-Gruppe und zwei Flash Briefings):

Bridge amazonechocontrol:account:account1 "Amazon Account" @ "Alexa" [amazonSite="amazon.de", email="xxx", password="xxx", pollingIntervalInSeconds=60]
{
    // Echo Geräte
    Thing echo                 echodot1            "Alexa (Kinderzimmer)" @ "Alexa" [serialNumber="xxx"]
    Thing echo                 echo1               "Alexa (Wohnbereich)" @ "Alexa" [serialNumber="xxx"]
    Thing echo                 echo2               "Alexa (Büro)" @ "Alexa" [serialNumber="xxx"]

    // Musikgruppen
    Thing wha                  wha1                "Multi-Room: Erdgeschoss" @ "Alexa" [serialNumber="xxx"] 

    // Flash Briefings
    Thing flashbriefingprofile flashbriefing1      "Flash Briefing Technical" @ "Alexa"
    Thing flashbriefingprofile flashbriefing2      "Flash Briefing Life Style" @ "Alexa"
}

Beim Account muss noch email und password entsprechend angepasst werden. In den Geräten muss man die serialNumber an seine entsprechenden Devices anpassen.

Danach ist der Account in openHAB über http://IP:PORT/amazonechocontrol/account1 erreichbar. Von dort können auch alle notwendigen Seriennummern ausgelesen werden.

Items

Eine Konfiguration der Items sieht wie folgt aus (hier ist ein Echo konfiguriert):

Group Alexa_Living_Room <player>

// Player control
Player Echo_Living_Room_Player                "Player"                                (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:player"}
Dimmer Echo_Living_Room_Volume                "Volume [%.0f %%]" <soundvolume>        (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:volume"}
Switch Echo_Living_Room_Shuffle               "Shuffle"                               (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:shuffle"}

// Player Information
String Echo_Living_Room_ImageUrl              "Image URL"                             (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:imageUrl"}
String Echo_Living_Room_Title                 "Title"                                 (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:title"}
String Echo_Living_Room_Subtitle1             "Subtitle 1"                            (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:subtitle1"}
String Echo_Living_Room_Subtitle2             "Subtitle 2"                            (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:subtitle2"}
String Echo_Living_Room_ProviderDisplayName   "Provider"                              (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:providerDisplayName"}

// Music provider and start command
String Echo_Living_Room_MusicProviderId       "Music Provider Id"                     (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:musicProviderId"}
String Echo_Living_Room_PlayMusicCommand      "Play music voice command (Write Only)" (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:playMusicVoiceCommand"}
String Echo_Living_Room_StartCommand          "Start Information"                     (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:startCommand"}

// TuneIn Radio
String Echo_Living_Room_RadioStationId        "TuneIn Radio Station Id"               (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:radioStationId"}
Switch Echo_Living_Room_Radio                 "TuneIn Radio"                          (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:radio"}

// Amazon Music
String Echo_Living_Room_AmazonMusicTrackId    "Amazon Music Track Id"                 (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:amazonMusicTrackId"}
String Echo_Living_Room_AmazonMusicPlayListId "Amazon Music Playlist Id"              (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:amazonMusicPlayListId"}
Switch Echo_Living_Room_AmazonMusic           "Amazon Music"                          (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:amazonMusic"}

// Bluetooth
String Echo_Living_Room_BluetoothMAC          "Bluetooth MAC Address" <bluetooth>     (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:bluetoothMAC"}
Switch Echo_Living_Room_Bluetooth             "Bluetooth"             <bluetooth>     (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:bluetooth"}
String Echo_Living_Room_BluetoothDeviceName   "Bluetooth Device"      <bluetooth>     (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:bluetoothDeviceName"}

// Commands
String Echo_Living_Room_TTS                   "Text to Speech"                        (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:textToSpeech"}
String Echo_Living_Room_Remind                "Remind"                                (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:remind"}
String Echo_Living_Room_PlayAlarmSound        "Play Alarm Sound"                      (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:playAlarmSound"}
String Echo_Living_Room_StartRoutine          "Start Routine"                         (Alexa_Living_Room) {channel="amazonechocontrol:echo:account1:echo1:startRoutine"}

Sitemap

In der Visualisierung habe ich dann ein Gerät wie folgt integriert (damit kann man dann sehr viel schon einmal in der Basic UI darstellen):

Text label="Wohnbereich" icon="recorder" {
Frame label="Wohnbereich" icon="recorder" {
Default   item=Echo_Living_Room_Player
Slider    item=Echo_Living_Room_Volume
Switch    item=Echo_Living_Room_Shuffle
Image     item=Echo_Living_Room_ImageUrl      label=""
Text      item=Echo_Living_Room_Title
Text      item=Echo_Living_Room_Subtitle1
Text      item=Echo_Living_Room_Subtitle2
Text      item=Echo_Living_Room_ProviderDisplayName

// The listed providers are only samples, you could have more
Selection item=Echo_Living_Room_MusicProviderId mappings=[ 'TUNEIN'='Radio', 'SPOTIFY'='Spotify', 'AMAZON_MUSIC'='Amazon Music', 'CLOUDPLAYER'='Amazon']
Text    item=Echo_Living_Room_MusicProviderId

// To start one of your flashbriefings use Flashbriefing.<YOUR FLASHBRIEFING THING ID>
Selection item=Echo_Living_Room_StartCommand mappings=[ 'Weather'='Weather', 'Traffic'='Traffic', 'GoodMorning'='Good Morning', 'SingASong'='Song', 'TellStory'='Story', 'FlashBriefing'='Flash Briefing', 'FlashBriefing.flashbriefing1'='Technical', 'FlashBriefing.flashbriefing2'='Life Style' ]

Selection item=Echo_Living_Room_RadioStationId mappings=[ ''='Off', 's97458'='TOP FM', 's25217'='ROCK ANTENNE' ]
Text    item=Echo_Living_Room_RadioStationId
Switch  item=Echo_Living_Room_Radio

Text    item=Echo_Living_Room_AmazonMusicTrackId
Text    item=Echo_Living_Room_AmazonMusicPlayListId
Switch  item=Echo_Living_Room_AmazonMusic

Text    item=Echo_Living_Room_BluetoothMAC
// Change the <YOUR_DEVICE_MAC> Place holder with the MAC address shown, if alexa is connected to the device
Selection item=Echo_Living_Room_BluetoothMAC mappings=[ ''='Disconnected', '<YOUR_DEVICE_MAC>'='Bluetooth Device 1', '<YOUR_DEVICE_MAC>'='Bluetooth Device 2']

// These are only view of the possible options. Enable ShowIDsInGUI in the binding configuration and look in drop-down-box of this channel in the Paper UI Control section
Selection item=Echo_Living_Room_PlayAlarmSound mappings=[ ''='None', 'ECHO:system_alerts_soothing_01'='Adrift', 'ECHO:system_alerts_atonal_02'='Clangy']

Switch  item=Echo_Living_Room_Bluetooth
Text    item=Echo_Living_Room_BluetoothDeviceName
     }
}

Rules

Eine mögliche Regel für die Automatisierung habe ich wie folgt umgesetzt (damit kann sobald der Lichtschalter im Büro betätigt wird per TTS eine Sprachausgabe erfolgen und auf einen Amazon Music Sender geschalten werden):

rule "ALEXA_TEST"
when
Item Licht_EG_Buero received update ON
then

Echo_Living_Room_TTS.sendCommand('Hello World')

Echo_Living_MusicProviderId.sendCommand('AMAZON_MUSIC')
Echo_Living_PlayMusicCommand.sendCommand('Heavy Metal')
end

Fazit

Im Großen und Ganzen war die Umsetzung für die Integration in openHAB aller Amazon-Devices bei mir recht schnell erledigt. Jetzt kommt dann die Anpassung an die Szenarien (was erfahrungsgemäß mehr Spaß macht).

Folgende Punkte haben mich etwas Zeit gekostet (hier könntet Ihr etwas aufpassen):

  • die ID’s der Sender in TuneIn findet man am einfachsten über die URL auf der Seite https://tunein.com heraus
  • Sender / Playlists in Amazon Music konnte ich bis jetzt nicht in Paper UI einbinden, sondern nur über Regeln selektieren (hier habe ich noch keine weitere Idee)
  • Wenn Ihr mehrere Geräte in „Gruppen“ zusammengefasst habt, müsst Ihr diese wha-Gruppe in den Things und im Channel der Items entsprechend anpassen (die Anpassung in den Channels habe ich übersehen)

Habt Ihr das neue Amazon Echo Control bei euch auch schon verwendet? Welche Szenarien bildet Ihr damit ab?

Visual Studio als Code-Editor für openHAB

Mit dem Update 2.2.0 von openHAB ist es jetzt auch möglich Visual Studio anstatt dem Eclipse SmartHome Designer zu verwenden.

Es muss mindestens openHAB 2.2.0 (Build #1065) verwendet werden, da mit dieser Version erst das Language Server Protocol (LSP) implementiert wurde. Aus meiner Sicht der wichtigste Vorteil ist jetzt ein besserer Syntax-Check des generierten Codes.

Bei onesmarthome.de habe ich dazu eine gute Einführung gefunden.

Installation und Basis-Konfiguration

  • Installation von Microsoft direkt starten (64 Bit User Installer verwendet)
  • Die Installation wird mit den Standard-Parametern durchgeführt
  • Visual Studio Code wird gestartet
  • Danach kann man direkt im Willkommens-Bildschirm noch das Deutsche Sprachpaket aktivieren
  • Nun wird die openHAB Extension installiert:
    • Extensions – openHAB eingeben und mit Install bestätigen
  • VS neu starten
  • Über „Open Folder“ wird der Pfad zum conf-Verzeichnis angegeben
  • IP-Adresse des openHAB-Rechners anpassen:
    • Zahnrad – Einstellungen – openHAB Configuration – openhab.host anpassen (wenn Ihr eine andere IP / Namen habt)

Fazit

Nun könnt Ihr anstatt dem Eclipse SmartHome Designer auch Visual Studio Code für die Anpassungen in openHAB verwenden. Momentan habe ich keine größeren „Customizings“ – ich werde dann im Laufe der Zeit dazu etwas schreiben.