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.

cLoxone App Room Controller web 300x300 - Howto: FHEM mit Loxone erweitern
Loxone Visualisierung Heizung
fhem visu 300x296 - Howto: FHEM mit Loxone erweitern
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

lox tempHZ 300x240 - Howto: FHEM mit Loxone erweitern
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.

thumb spacer - Howto: FHEM mit Loxone erweitern
thumb spacer - Howto: FHEM mit Loxone erweitern
thumb spacer - Howto: FHEM mit Loxone erweitern

Letzte Aktualisierung am 19.05.2018 um 03:00 Uhr | Affiliate Links | 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.

thumb spacer - Howto: FHEM mit Loxone erweitern

Letzte Aktualisierung am 19.05.2018 um 03:28 Uhr | Affiliate Links | Bilder: Amazon Product Advertising API

lox gconfig 1024x553 - Howto: FHEM mit Loxone erweitern

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.” einfügen.

fhem udplox - Howto: FHEM mit Loxone erweitern

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.

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.

fhem udplox 1 1024x588 - Howto: FHEM mit Loxone erweitern

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.

lox udpfhem be - Howto: FHEM mit Loxone erweitern

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

lox fhemhttp - Howto: FHEM mit Loxone erweitern

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.

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>

lox fhemhttp virt - Howto: FHEM mit Loxone erweitern

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 19.05.2018 um 03:28 Uhr | Affiliate Links | Bilder: Amazon Product Advertising API

 

Howto: FHEM mit Loxone erweitern
4.9 ✭ (97.5%) 16 votes

Das könnte dich auch interessieren:
Homematic für Anfänger verständlich erklärt Wer sich mit dem Thema Smart Home bereits auseinander gesetzt hat, ist sicherlich auch schon über Homematic gestolpert. Homematic sehe ich im Bereich der Einsteiger & Fortgeschrittenen. Die Programmierung kann je nach Wunsch allerdings auch schne...
Tutorial: Installation von Node-Red und Mosquitto Node-RED ist ein Programmierwerkzeug um Geräte, APIs und Online-Dienste auf neue und interessante Weise miteinander zu verbinden. Es stellt einen Browserbasierten Editor zur Verfügung, der das Zusammenfassen von Datenflüssen mithilfe der zahlreichen ...
Philips Hue in Loxone integrieren Nicht nur via FHEM lassen sich Geräte in Loxone integrieren, auch Philips Hue bietet eine direkte Integrationsmöglichkeit. Wie das geht, beschreibe ich im nachfolgenden Blogeintrag. Hue-Bridge vorbereiten Ganz zu Anfang muss erst die eigene IP-Adre...
Howto: FHEM Grundeinstellung Wie im vorherigen Post versprochen, geht es nun mit der Grundeinrichtung von FHEM weiter. Zwar wäre FHEM nun schon voll lauffähig und nutzbar, nichtsdestotrotz ist die nachfolgende Grundeinrichtung unabdinglich. Nachfolgend wird erklärt, welche Einst...
Howto: Waschmaschine in Loxone integrieren "Waschmaschine ist fertig!" Wäre das nicht toll, wenn die Waschmaschine im Smart Home sprechen könnte? Naja - bis sie sprechen kann, wird wohl noch eine Weile vergehen. Allerdings ist es mittels Steckdosen-Zwischenstecker möglich, festzustellen wann...

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!