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.

loxone smart home - die basics
Loxone Smart Home - Die Basics
Erlerne im Handumdrehen die Basics von Loxone.

Anzeige

Erlerne im Handumdrehen die Basics von Loxone.

Anzeige

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

Letzte Aktualisierung am 16.07.2019 um 06:34 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 16.07.2019 um 06: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 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";
}

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.

define OnOffToLoxone notify .*:(on|off) {OnOffToLoxone("$NAME")}
define OpenClosedToLoxone notify .*:(open|closed|tilted) {OpenClosedToLoxone("$NAME")}
define ClimateToLoxone notify .*:measured-temp.* {ClimateToLoxone("$NAME")}
define ClimateToLoxone2 notify .*:desired-temp.* {ClimateToLoxone("$NAME")}
define EnergyToLoxone notify .*:sensor3.* {EnergyToLoxone("$NAME")}
define EnergyToLoxone2 notify .*:current.* {EnergyToLoxone2("$NAME")}
define MotionToLoxone notify .*:motion.* {MotionToLoxone("$NAME")}
define TempHumidityToLoxone notify .*:temperature.* {TempHumidityToLoxone("$NAME")}

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”); ”

#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("10.0.0.30" , "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("10.0.0.30" , "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("10.0.0.30" , "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.76" , "7000" , "$device: $energy");
}
#Energy2ToLoxone
sub Energy2ToLoxone($)
{
my ($device) = @_;
my $energy=ReadingsVal("$device","current","-1");
UDP_Msg("10.0.0.30" , "7000" , "$device: $energy");
}
#MotionToLoxone
sub MotionToLoxone($)
{
my ($device) = @_;
my $motion=ReadingsVal("$device","motion","-1");
if ($motion eq "on (to HMLAN1)") {
$motion = "1";
}
UDP_Msg("10.0.0.30" , "7000" , "$device: $motion");
}
#TempHumidityToLoxone
sub TempHumidityToLoxone($)
{
my ($device) = @_;
my $temperature=ReadingsVal("$device","temperature","-1");
my $humidity=ReadingsVal("$device","humidity","-1");
UDP_Msg("10.0.0.30" , "7000" , "$device: $temperature $humidity");
}

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

attr WEB.* csrfToken none

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.

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>

loxone smart home - die basics
Loxone Smart Home - Die Basics
Erlerne im Handumdrehen die Basics von Loxone.

Anzeige

Erlerne im Handumdrehen die Basics von Loxone.

Anzeige

Weniger anzeigen

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.

50€ sparen
FHEM Grundlagen Kurs
FHEM Grundlagen Kurs
Spare 50€ bei dem FHEM Grundlagen Kurs!

Anzeige

Spare 50€ bei dem FHEM Grundlagen Kurs!

Anzeige

Weniger anzeigen

 

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 16.07.2019 um 06:34 Uhr | Werbung | Bilder: Amazon Product Advertising API

 

Howto: FHEM mit Loxone erweitern
4.9 ✭ (97.89%) 19 vote[s]

17 Gedanken zu “Howto: FHEM mit Loxone erweitern”

17 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

  4. Servus,

    also von der Loxone zu fhem, das klappt. Aber ich kann meine readings nicht in der Loxone anzeigen. Ich hab ein device angelegt das Bad.Temp heist, das hat die readings measured-temp und humidity, aber ich bekomme die werte nicht in der loxone steuerung angezeigt. Kannst du mir mal ein Beispiel von der device definition geben, bzw. den Aufbau in fhem von deinem device Bad.Temp?

    Kann ich die empfangenen bzw. gesendeten udp daten in der loxone mitloggen?

    Gruß

  5. Hat sich erledigt. Der Port hat sich bei der neuen Installation von LoxoneConfig neu eingestellt.
    Aber für alle die Troubleshooting machen wollen, in der LoxoneConfig kann man im Liveview, wenn man den virtuellen VI des udp auswählt, den UDP Monitor aktivieren. Der zeigt einem, welche Werte übertragen werden.
    Hier wäre noch ein kleines python programm, das auf dem RaspberryPi gut läuft und die Befehle sendet. Damit könnt ihr unabhängig von fhem udp testen(ohne devices anlegen zu müssen):

    import socket
    import subprocess

    UDP_IP = “192.168.x.xxx”; #enter your loxone ip here
    UDP_PORT = 7000;
    MESSAGE = “Bad.Temp: 22 33”;

    #device: temperature humidity

    print(“UDP target IP:”, UDP_IP)
    print(“UDP target port:”, UDP_PORT)
    print(“message:”, MESSAGE)

    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP
    sock.sendto(MESSAGE, (UDP_IP, UDP_PORT))

  6. Hallo,
    erstmal danke für das tolle und hilfreiche Howto!

    Soweit läuft alles obwohl ich ein kompletter FHEM Laie bin.
    Bei ON OFF und DOWN UP kommen die Befehle ohne Probleme an.

    Ich habe nur folgendes Problem:
    Es werden leider keine UDP-Befehle versendet wenn ich die Prozent (pct) der Fenster ändere.
    Dies wäre aber sehr hilfreich um z.B. die Lüftungsklappe der Fenster bzw. den Stand der Fenster zu visualisieren.

    Kannst du mir da vielleicht helfen?

    • Hallo Marko,

      ich besitze leider keine Rolladen, an denen ich es direkt mal testen könnte.
      Von welchen Geräten möchtest du denn den prozentualen Wert zu Loxone übertragen?

      Viele Grüße
      Michael

  7. Hallo Michael,
    es handelt sich um “normale” Velux Dachfenster (VELUX Window opener with integrated rain sensor Type 4.1)
    Der Prozent Wert wird ja schon übermittelt. UDP_Msg(“10.0.0.30” , “7000” , “$device: $state $pct”)
    “pct” ist der Wert.
    Nur leider wird der Wert nur übermittelt wenn ich ON oder OFF sende.

    Es wäre super wenn jedes mal wenn sich “das Fenster bewegt” ein neuer Befehl gesendet wird.

    Ich hoffe du verstehst was ich meine?

    Lg und Danke!

    • Hi Marko,

      ja, ich hoffe ich habe es richtig verstanden. Ich hab es mal mit einem Dummy Rollo Device in FHEM ausprobiert und kann wie folgt die Prozente übergeben.

      In die 99_myUtils.pm muss folgender Code:

       #RolloLoxone sub RolloLoxone($) { my ($device) = @_; my $pct=ReadingsVal("$device","pct","-1"); UDP_Msg("10.0.0.37" , "7000" , "$device: $pct"); } 

      Und in die fhem.cfg:

       define RolloLoxone notify .*:pct.* {RolloLoxone("$NAME")} 

      In Loxone lautet die Befehlserkennung dann:

       Rollo: \v 

      Probier’ es mal aus, so hat es zumindest mit dem Dummy-Device bei mir funktioniert 🙂

      Viel Erfolg!
      Michael

  8. Hallo,
    danke für die schnelle Hilfe.
    Funktionier aber leider nicht…
    Bekomme nach dem speichern der 99_myUtils.pm Datei folgenden Error:
    ERROR:
    Unrecognized character \xE2; marked by <– HERE after adingsVal(<– HERE near column 23 at ./FHEM/99_myUtils.pm line 114.

    Der Rest läuft normal…

    Danke im Voraus!

    • Hi,

      das kann aber nicht an dem Code liegen…
      Was steht denn bei dir in Zeile 114? Da gibt es ja scheinbar einen Fehler.
      Kopier’ den Inhalt mal in Notepad++ dann hast du die Zeilenzahl daneben stehen 😉

      Viele Grüße
      Michael

  9. Bei Zeile 114 steht:
    my $pct = ReadingsVal(“$device”,”pct”,”-1″);

    Danke und viele Grüße!

    • Ich kann den Fehler so derzeit leider nicht reproduzieren…
      Schick mir bitte deine fhem.cfg und die 99_myUtils.pm per Mail, dann kann ich mir das genauer ansehen. Etwaige Passwörter vorher am besten herauslöschen.
      https://ownsmarthome.de/support/

      Viele Grüße
      Michael

  10. Ich habe es dir geschickt.

    Konnte aber den Fehler selber finden. Anstatt ” habe ich ” kopiert. Also die falschen Anführungszeichen.
    Habe sie jetzt geändert (in der fhem.cfg und 99_myUtils.pm)

    Funktioniert aber leider noch immer nicht, bekomme jetzt folgenden Fehler beim speichern:
    Can’t find string terminator ‘”‘ anywhere before EOF at ./FHEM/99_myUtils.pm line 92.

    Bei Zeile 92 steht:
    #RolloLoxone

    Danke und beste Grüße!

Schreibe einen Kommentar

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