Anzeige

Howto: FHEM mit Loxone erweitern

Loxone

Ein (Loxone) Smart Home – was ist das eigentlich genau? Alles was zu Hause in irgendeiner Weise steuerbar ist, bestenfalls mittels Smartphone, wird als Smart Home betitelt. Doch was ist nun genau ein Smart Home? Für mich persönlich ist es erst dann ein Smart Home, wenn das Zuhause wirklich “intelligent” wird. FHEM allein ist schon ein sehr starkes System, das super stabil läuft und eine tolle Community im Rücken hat, die einem (fast) Tag und Nacht tatkräftig bei der eigenen Einrichtung untersützt. Richtig intelligent wird allerdings dann, wenn man die Vorteile von FHEM mit denen von Loxone verbindet. Das ist in meinen Augen ein tolles Dreamteam, welches ich nicht mehr missen möchte. Wieso das die in meinen Augen die perfekt Lösung ist, möchte ich im nachfolgenden Blogeintrag verdeutlichen.

Wieso Loxone?

Ich schreibe zwar, dass FHEM und Loxone ein Dreamteam sind, doch wieso ist das überhaupt so? Dies möchte ich kurz anhand von 4 Punkten erläutern.

1: Visualisierung

FHEM ist zwar extrem umfangreich und zugleich toll erweiterbar, doch das Thema Visualisierung hat bei FHEM in meinen Augen so einige Schwächen. Eine übersichtliche und einfache Steuerbarkeit gehört für mich zu einem Smart Home ebenfalls zwingend dazu. Loxone hat es geschafft, eine ansprechende Visualisierung zu erstellen.

Loxone Visualisierung Heizung | Bild: Loxone.com
FHEM Visualisierung

2: Einfacher programmieren dank Baukastenprinzip!

Wie bereits erwähnt, funktioniert FHEM super – wäre da nicht der für Einsteiger eher schwierige PERL-Code. Ebenso wird es in einer großen Programmierung schnell unübersichtlich. Natürlich hat man viel Freiheit bei der eigenen Programmierung, doch eben auch den großen Nachteil, dass man diese Programmiersprache ebenso erlernen muss, wie etwa HTML.

Loxone benutzt das Baukasten- bzw. Bausteinprinzip. Verschiedene Logikbausteine werden geliefert und man kann per Drag & Drop programmieren, ohne vorab viel Code studieren zu müssen. Jeder dieser Bausteine besitzt sogar eine Hilfe-Funktion, die u.U. sehr schnell hilft. So hat der Technikaffine Einsteiger eine tolle Möglichkeit, schnell erste Erfolge zu erzielen.

3: Eingebaute Intelligenz

Heizzeiten-Tabelle aus Loxone

Wie immer wieder von mir erwähnt, muss das Smart Home in meinen Augen auch intelligent sein. Jeder der Bausteine in Loxone besitzt von Haus auf eine eigene gewisse Intelligenz. So z.B. bei der Heizungsregelung: In der Schaltuhr werden die gewünschten Heizzeiten hinterlegt und dank der eingebauten Intelligenz, lernt Loxone die Heizung so zu steuern, sodass wirklich zu den angebenen Zeiten die Temperaturen herrschen.

HomeMatic Funk-Heizkörperthermostat
HomeMatic Funk-Schaltaktor 1-fach mit Leistungsmessung,...
Homematic 130297 Funk Tür-/ Fensterkontakt optisch...

Letzte Aktualisierung am 12.11.2018 um 18:43 Uhr | Werbung | Bilder: Amazon Product Advertising API

4: Unbegrenzte Möglichkeiten

Loxone hat mit der Bausteinprogrammierung einen großen Schritt in die richtig Richtung gemacht. Allerdings kommt diese Art der Programmierung auch irgendwann an Ihre Grenzen, sodass mithilfe von FHEM nachgeholfen werden kann, was einem unbegrenzte Möglichkeiten verschafft und so unendliche Smart Home-Szenarien erstellt werden können.
Sollten noch weitere Fragen zu Loxone bestehen, bitte gerne über die Kommentarfunktion melden.

 

Ok, los geht’s: Ich will Loxone!

Inbetriebnahme

Loxone bietet 2 Miniserver an. Zum einen, den Miniserver der für einen Schaltschrankeinbau vorgesehen ist und diverse analoge & digitale Ein- und Ausgänge besitzt. Zum Anderen wird der Miniserver GO angeboten, den ich für dieses Vorhaben empfehle, zumal er auch etwas günstiger zu haben ist. Der Miniserver Go besitzt zwar keine Ein- und Ausgänge, allerdins kommt er mit einem eingebauten Funk-Gateway für Loxone-Air Komponenten. Beide Miniserver verfügen über die gleiche Visualisierungs- und Programmierungsoberfläche.

Die Installation des Miniservers ist denkbar einfach:
– Stromversorgung per USB anschließen
– Eine Netzwerkverbindung per Ethernet herstellen

Mit der Loxone Config Software, die es leider nur für Windows gibt, wird der Miniserver dann im Netzwerk gefunden und mit grundlegenden Infos versorgt.

Loxone Smart Home

Letzte Aktualisierung am 12.11.2018 um 17:34 Uhr | Werbung | Bilder: Amazon Product Advertising API

UDP-Kommunikation in FHEM einrichten

Damit später alles funktioniert, müssen wir in FHEM nun einige Anpassungen vornehmen, um so von FHEM zu Loxone per UDP kommunizieren zu können.
Hierzu fügen wir in FHEM der Datei “99_myutils.pm” (Im FHEM-Webinterface über “Edit Files” -> “99_myutils”) den nachfolgenden Code unter die Zeile “# Enter your functions below _this_ line.” ein.

UDP-Befehle aus FHEM senden

Es wird nun definiert, welche Werte an FHEM übergeben werden sollen. Der Einfachheit halber sollte dies pro Device-Klasse gemacht werden.

Der nachfolgende Code wird in die fhem.cfg gespeichert.

Sobald z.B. ein Device auf den Status “on”, “off”, “open”, “close” aktualisiert, wird eine Funktion zu einer UDP-basierten Übertragung an Loxone angetriggert, um so die neuen Statuswerte zu übertragen.  Daher muss der nachfolgende Code ebenfalls in die “99_myutils.pm” rein.
Achtung: Die IP-Adresse muss hier in die des eigenen Loxone-Server geändert werden, bei jeder Funktion!
” UDP_Msg(“10.0.0.30” , “7000” , “$device: $state $pct”); ”

UDP Informationen in Loxone empfangen und verarbeiten

Jedes Gerät, dass in FHEM angelegt wurde, muss nun einzeln in Loxone angelegt werden. Das hört sich erstmal viel an, doch wenn man von Raum zu Raum die Gerät abarbeitet sind diese in Loxone sehr schnell anzulegen.

Der FHEM Server muss vorweg als virtueller Eingang in Loxone angelegt werden. Wir gehen wiefolgt vor: Zuerst “Virtuelle Eingänge” anklicken (1), danach im oberen Bereich “Virtueller UDP Eingang” anlegen (2). Der Eingang kann nach belieben benannt werden, ich habe ihn “FHEM UDP” (3) genannt. Wichtig ist nun noch, dass der “UDP Empfangsport” (4) auf 7000 eingestellt wird.

Nach diesem Schritt erhält Loxone durch den UDP-Eingang nun bei Statusänderungen in FHEM sofort eine Mitteilung. Allerdings müssen diese Mitteilungen noch in Loxone zugordnet werden. Eingängsseitig werden daher nun alle Geräte in Loxone als “Virtuelle UDP Eingang Befehle” angelegt.

Zuerst muss der gerade angelegte “Virtuelle UDP Eingang” ausgewählt werden (1). Danach wird ein neuer “Virtuelle UDP Eingang Befehl” angelegt (2). Im linken Bereich kann nun eine freie Bezeichnung gewählt werden (3). Die Befehlserkennung (4) ist das Wichtigste. Hier muss nun der exakte Name des FHEM Devices angegeben werden, gefolgt von einem Doppelpunkt und einem “\v”. Das “\v” bedeutet, dass der erste Wert der UDP-Nachricht nach dem Device Namen verwendet werden soll.

Für ein Device, das in FHEM “Bad.Temp” heißt und z.B. die Temperatur sowie die Luftfeuchtigkeit misst, muss je ein Befehl für die Temperatur und die Luftfeuchtigkeit angelegt werden. Im Screenshot wird der erste gesendete Wert verwendet, also die Temperatur. Um festzustellen, an welcher Stelle sich welcher Befehl befindet, kann im Code der “99_myUtils” ermittelt werden.

UDP_Msg(“10.0.0.30” , “7000” , “$device: $measuredTemp $humidity $alive $battery $desiredTemp $controlMode $dewpoint $actuator”)

Anhand diesem Beispiel erkennt man, dass “measured-temp” (die gemessene Temperatur) der erste gesendete Wert ist. Der zweite Wert ist dann “humidity” (die Luftfeuchtigkeit) usw…
Möchte man nun den zweiten Wert verwenden, muss in der Befehlserkennung “Bad.Temp: \# \v” stehen. Es wird also mittels “\#” der erste Wert übersprungen und durch “\v” der Wert verwendet. Anhand diesen Ablaufes muss nun jedes FHEM Gerät in Loxone angelegt werden. Natürlich muss man nicht jede Befehlserkennung anlegen, sondern nur die, die man auch benötigt wie z.B. Temperatur und die Luftfeuchtigkeit. Wem der Batteriezustand egal ist und diesen in Loxone nicht übernehmen möchte, kann ihn getröst weg lassen.

Schaltbefehle an FHEM weiter geben

Achtung: Bei FHEM wurde seit dem vergangen Update (5.8) ein Sicherheitsmechanismus eingeführt, der die Schaltbefehle per URL verbietet.
Eine Vorab-Lösung wäre, diesen Sicherheitsmechanismus zu deaktivieren, mittels

Weiter Infos zum csrf Token gibt es im FHEMWiki.

Damit ist FHEM aber auch anfällig für das sogenannte Cross-Site-Request-Forgery. Im schlimmsten Fall könnte ein Aufruf einer manipulierten Website dann die komplette FHEM-Installation löschen.

Bislang schickt uns FHEM lediglich die Informationen der einzelnen Geräte und Loxone kann diese verarbeiten. Nun sollen aber noch die FHEM-Geräte über Loxone geschaltet werden können. Hier ist das Vorgehen ähnlich wie beim Anlegen des “Virtuellen Eingangs”.

Zuerst wird “Virtuelle Ausgänge” markiert (1). Danach wird ein neuer “Virtueller Ausgang” angelegt (2). Dieser kann wiederrum nach belieben benannt werden, der Übersicht halber heißt er bei mir “FHEM HTTP” (3). Im linken Bereich wird als Adresse des FHEM Geräte angegeben, in diesem Format: http://Nutzer:Passwort@IP-ADRESSE-FHEM-SERVER

Nach dem Anlegen des “Virtuellen Ausgang”, benötigt man wieder pro Smart Home-Device einen Ausgangsbefehl. Natürlich nur für die Geräte, die auch manuell geschaltet werden können. Für alle anderen Sensoren wird dieser Schritt nicht benötigt.

50€ sparen
FHEM Grundlagen Kurs

FHEM Grundlagen Kurs

Spare 50€ bei dem FHEM Grundlagen Kurs!

Anzeige

Spare 50€ bei dem FHEM Grundlagen Kurs!

Anzeige

Less

Zuerst wird wieder der bereits angelegte “Virtuelle UDP Eingang” ausgewählt (1) und danach ein neuer “Virtuelle Ausgang Befehl” angelegt (2). Nun müssen noch die HTTP Kommandos zum Ein- und Ausschalten vergeben werden (3 | 4 ). Für das Gerät WZ.Lampe wäre an diesem Beispiel der Einschaltbefehl “/fhem?cmd=set WZ.Lampe on” bzw. “/fhem?cmd=set Ga.Licht off”. Bei einem Heizungs-Device muss lediglich bei “Befehl bei EIN” (3) diese Syntax eingetragen werden: /fhem?cmd=set WZ:Heizung <v>

An dieser Stelle ist die Grundkonfiguration geschafft. Alle Aktoren sind in Loxone eingebunden und FHEM sendet bei jeder Statusändern eine Mitteilung an Loxone.

Die Programmierung

Die Programmierung funktioniert bei Loxone immer nach einem gewissen Grundprinzip – Drag’n’Drop.
Auf das “Programmierblatt” wird z.B. der Baustein “Lichtsteuerung” gezogen und an diesen dann Ein- und Ausgänge, ebenfalls per Drag’n’Drop, angelegt. Da ich mich selbst an diese Art der Programmierung auch erst einige Zeit lange gewöhnen musste, möchte ich es anhand des nachfolgenden Bildes kurz aufzeigen.

 

Meine Meinung:

Loxone brachte für mich einen echten Mehrwert. Natürlich muss auch hier wieder Geld investiert werden, doch es hat sich auf jeden Fall gelohnt. Nachdem ich alle Geräte von FHEM mit Loxone verknüpft hatte, habe ich inzwischen auch einige Aktoren von Loxone gekauft. Auch bei den Produkten überzeugt mich die Qualität und Funktion voll und ganz.
An dieser Stelle auch lieben Dank an die Männer von meintechblog.de, die mir den FHEM-Code zur Verfügung gestellt haben. Dieser stammt aus deren Blogpost 5 Gründe zur Erweiterung deines FHEM-Servers mit Loxone + Howto.

 

Für Einsteiger empfohlen

Letzte Aktualisierung am 12.11.2018 um 17:34 Uhr | Werbung | Bilder: Amazon Product Advertising API

 

Howto: FHEM mit Loxone erweitern
4.9 ✭ (97.65%) 17 votes

Das könnte dich auch interessieren:
Anleitung: Loxone HomeKit Integration mit Homebridge simpel ... Um Apples HomeKit nutzen zu können, benötigt man kompatible Geräte. Hat man diese nicht, bleibt einem die Steuerung über HomeKit verwehrt. Doch durch die Homebridge, die auf dem Raspberry Pi installiert werden kann, ist es möglich auch nicht zertifiz...
Howto: FHEM Server auf Raspberry einrichten Mit FHEM das eigene zu Hause jederzeit steuern, ohne große Kosten? FHEM macht einen großen Schritt hierhin, nicht zuletzt durch den Raspberry Pi. In diesem Post möchte ich euch nun zeigen, wie schnell die Installation von FHEM vonstatten geht. Konf...
SMS bei Stromausfall – per GSM Stromausfallmelder Im Smart Home ein Horrorszenario: Stromausfall! Abhilfe schafft ein Stromausfallmelder. Denn da bei Stromausfall natürlich die komplette Steuerung, samt der integrierten Alarmanlage ausfällt, macht es Sinn per SMS (unabhängig von Strom) informiert z...
FHEM Batteriestatus an Loxone übergeben Wie der Batteriestatus von FHEM an Loxone übergeben werden kann, darum geht es in diesem Blogpost. Die allgemeine Konfiguration bzw. Erweiterung von FHEM mittels Loxone habe ich bereits schon erläutert. Hier ging es aber bislang noch nicht explizit u...
Loxone Taster als Wandthermostat für Homematic nutzen Mit FHEM das volle Potential ausschöpfen Das Homematic Heizkörperthermostat arbeitet als solches natürlich komplett autark, sofern man das möchte. Da sich das Thermometer allerdings unmittelbar am Wandthermostat und so in unmittelbarer Nähe des Heiz...

6 Gedanken zu “Howto: FHEM mit Loxone erweitern

6 Kommentare

  1. Hallo Michael, klasse Anleitung. In Richtung Loxone funzt bei mir auch alles, nur in die andere Richtung geht es nicht.
    Mein Fhem ist mit https abgesichert und ich kann selbst über den Browser keine Schaltbefehle senden, ohne dass das Login Fenster sich öffnet.
    Gibt es außer HTTP keine Alternative, über die ich auch einen abgesicherten FHEM erreichen kann?
    Hab mir schon die Finger wundgesucht.

    Vielen Dank
    Jörg

    • Hallo Jörg,

      Ich selbst habe meine FHEM nicht per https abgesichert. Normalerweise sollte allerdings die Steuerung über das gleich Schema erfolgen können, also z.B.:

      https://Nutzer:Passwort@IP-ADRESSE-FHEM-SERVER

      Achte auch darauf, dass das csrfToken Attribut auf none gesetzt ist, sonst funktioniert es definitiv nicht über den HTTP-Befehl.

      Gruß
      Michael

  2. Hallo Michael,

    ich habe das Problem, dass ich in Loxone keine Statusänderungen angezeigt bekomme.
    Schalte ich z.B. über FHEM oder einen Wandtaster eine Lampe aus, wird dieses in Loxone nicht aktualisiert.
    Schalte ich aber über Loxone eine Lampe Aus/Ein, aktualisiert sich FHEM.
    Kannst du mir vielleicht sagen woran es liegen könnte?

    Gruß Stephan

    • Hallo Stephan,

      wenn FHEM keine Statusänderung an Loxone sendet, kann das Problem daran liegen, dass du entweder:
      – in der 99_myutils die Befehle nicht automatisch weitergeben lässt, oder
      – in Loxone der Virtuelle UDP Eingang Befehl falsch angelegt ist.

      Wenn du absolut nicht weiter kommst, kannst du mir auch gerne deine Loxone Config und von FHEM die 99_myutils Datei schicken und ich schaue mal drüber. Kann eigentlich nicht viel sein 🙂

      Gruß
      Michael

  3. Die IP Adresse( hier 192.168.178.xx) habe ich natürlich ersetzt gegen die vom Miniserver.

    ##############################################
    # $Id: myUtilsTemplate.pm 7570 2015-01-14 18:31:44Z rudolfkoenig $
    #
    # Save this file as 99_myUtils.pm, and create your own functions in the new
    # file. They are then available in every Perl expression.

    package main;

    use strict;
    use warnings;
    use POSIX;

    sub
    myUtils_Initialize($$)
    {
    my ($hash) = @_;
    }

    # Enter you functions below _this_ line.

    #UDP Befehle senden

    sub UDP_Msg($$$)
    {
    my ($dest,$port,$cmd) = @_;
    my $sock = IO::Socket::INET->new(
    Proto => ‘udp’,
    PeerPort => $port,
    PeerAddr => $dest
    ) or die “Could not create socket: $!\n”;
    $sock->send($cmd) or die “Send error: $!\n”;
    return “send $cmd”;
    }

    #OnOffToLoxone
    #device:
    #1 state(0,1)
    #2 pct(0-100)
    sub OnOffToLoxone($)
    {
    my ($device) = @_;
    my $state = ReadingsVal(“$device”,”state”,”-1″);
    if ($state eq “on”) {
    $state = “1”;
    }
    if ($state eq “off”) {
    $state = “0”;
    }
    my $pct = ReadingsVal(“$device”,”pct”,”-1″);

    #fhem(“set $device: $state $pct”);
    UDP_Msg(“192.168.178.xx” , “7000” , “$device: $state $pct”);
    }

    #OpenClosedToLoxone
    #device
    #1 state(0,1)
    #2 alive(1-0)
    #3 battery(0,1)
    sub OpenClosedToLoxone($)
    {
    my ($device) = @_;
    my $state = ReadingsVal(“$device”,”state”,”-1″);
    if ($state eq “closed”) {
    $state = “0”;
    }
    if ($state eq “open”) {
    $state = “1”;
    }
    if ($state eq “tilted”) {
    $state = “2”;
    }
    my $alive = ReadingsVal(“$device”,”alive”,”-1″);
    if ($alive eq “yes”) {
    $alive = “1”;
    }
    if ($alive eq “no”) {
    $alive = “0”;
    }
    my $battery = ReadingsVal(“$device”,”battery”,”-1″);
    if ($battery eq “ok”) {
    $battery = “1”;
    }
    if ($battery eq “low”) {
    $battery = “0”;
    }
    my $sabotage = ReadingsVal(“$device”,”sabotageError”,”-1″);
    if ($sabotage eq “on”) {
    $sabotage = “1”;
    }
    if ($sabotage eq “off”) {
    $sabotage = “0”;
    }

    UDP_Msg(“192.168.178.xx” , “7000” , “$device: $state $alive $battery $sabotage”);
    }

    #ClimateToLoxone
    #device:
    #1 measured-temp
    #2 humidity
    #3 alive
    #4 battery
    #5 desired-temp
    #6 controlMode
    #7 dewpoint
    sub ClimateToLoxone($)
    {
    my ($device) = @_;

    my $measuredTemp=ReadingsVal(“$device”,”measured-temp”,”-1″);
    my $humidity=ReadingsVal(“$device”,”humidity”,”-1″);
    my $alive = ReadingsVal(“$device”,”alive”,”-1″);
    if ($alive eq “yes”) {
    $alive = “1”;
    }
    if ($alive eq “no”) {
    $alive = “0”;
    }
    my $battery = ReadingsVal(“$device”,”battery”,”-1″);
    if ($battery eq “ok”) {
    $battery = “1”;
    }
    if ($battery eq “low”) {
    $battery = “0”;
    }
    my $desiredTemp=ReadingsVal(“$device”,”desired-temp”,”-1″);
    my $controlMode=ReadingsVal(“$device”,”controlMode”,”-1″);
    if ($controlMode eq “manual”) {
    $controlMode = “0”;
    }
    if ($controlMode eq “auto”) {
    $controlMode = “1”;
    }
    my $dewpoint=ReadingsVal(“$device”,”dewpoint”,”-1″);
    my $actuator=ReadingsVal(“$device”,”actuator”,”-1″);

    UDP_Msg(“192.168.178.xx” , “7000” , “$device: $measuredTemp $humidity $alive $battery $desiredTemp $controlMode $dewpoint $actuator”);
    }

    #EnergyToLoxone
    sub EnergyToLoxone($)
    {
    my ($device) = @_;
    my $energy=ReadingsVal(“$device”,”sensor3″,”-1″);

    UDP_Msg(“192.168.178.xx” , “7000” , “$device: $energy”);
    }

    #Energy2ToLoxone
    sub Energy2ToLoxone($)
    {
    my ($device) = @_;
    my $energy=ReadingsVal(“$device”,”current”,”-1″);

    UDP_Msg(“192.168.178.xx” , “7000” , “$device: $energy”);
    }

    #MotionToLoxone
    sub MotionToLoxone($)
    {
    my ($device) = @_;
    my $motion=ReadingsVal(“$device”,”motion”,”-1″);
    if ($motion eq “on (to HMLAN1)”) {
    $motion = “1”;
    }
    UDP_Msg(“192.168.178.xx” , “7000” , “$device: $motion”);
    }

    #TempHumidityToLoxone
    sub TempHumidityToLoxone($)
    {
    my ($device) = @_;
    my $temperature=ReadingsVal(“$device”,”temperature”,”-1″);
    my $humidity=ReadingsVal(“$device”,”humidity”,”-1″);

    UDP_Msg(“192.168.178.xx” , “7000” , “$device: $temperature $humidity”);
    }

    1;

    • Ok, wenn du das so 1:1 übernommen hast, sollte das kein Problem sein bzw. ich sehe da keinen Fehler.
      Dann wird der Fehler in der Loxone-Config sein. Kannst du mir gerne an kontakt@owsh.de schicken 🙂
      Schaue sie mir dann morgen mal an. Und schreib mir in der Mail bitte noch rein, welche Hardware du genau besitzt, quasi eine kleine Funktionsbeschreibung.

      Grüße

Schreibe einen Kommentar

Do NOT follow this link or you will be banned from the site!