FHEMWiki - Benutzerbeiträge [de]

Rolladensteuerung mit Eingabemöglichkeiten

2015-04-08T07:05:55Z

Max: /* Codierung */

In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere.

==Grundsätzliche Beschreibung==
Mein erstes große Projekt in Sachen FHEM war es meine Rolläden automatisiert zu steuern, so dass man möglichst wenig manuell eingreifen muss.
Da der ein und andere Riemen der manuellen Steuerung den Geist aufgegeben hat, habe ich nach und nach alle Rolläden mit Motoren und HM Aktoren versehen.

Da ich eine Photovoltaikanlage besitze habe ich ein kleines Modul geschrieben, welches mir die Ertragsleistung in FHEM darstellt.
Anhand dieser Werte steuere ich Rolläden, welche zur Südseite gerichtet sind. Dadurch wird dann dynamisch die Sonneneinstrahlung und damit die Erwärmung der Zimmer eingestellt.
Zwischenzeitlich ist ein Helligkeitssensor installiert worden. Dieser sorgt für das Herunterfahren der Rolläden bei Eintreten der Dunkelheit.

Dieser Wert korreliert zwar mit den Werten der PV Anlage, dies habe ich aber bislang noch nicht aufgelöst.

==Komponenten==
1. HM Funk-Jalousieaktor HM-LC-Bi1PBU-FM

2. Solarlog-Modul

3. Helligkeitssensor aus diesem Posting
[http://forum.fhem.de/index.php/topic,20620.0.html Selbstbau HM_WDS10_TH_O mit Luftdruckmessung]

==Visualisierung==
Hier ist der Status eines jeden Rolladens ersichtlich und dieser ist bedienbar.
Die Darstellung habe ich mittels [[Dashboard]] umgesetzt.

[[Datei:Dashboard01.png]]

Über diese Einstellungsseite können diverse Parameter der Steuerung gesetzt werden.

[[Datei:Dashboard02.png]]

==Einstellungen==
;'''Automatik aktiv:'''
:Hiermit wird die komplette Steuerung der Rolläden ein- bzw ausgeschaltet.
:Sofern der Modus "aus" aktiv ist, werden meine Rolläden lediglich über die Aktoren direkt oder eine HM Fernbedienung gesteuert.

;'''Art:'''
:Hier werden derzeit drei Modi unterstützt:

:''1. Normal''
:Bei diesem Modus fahren die Rollläden zu den definierten Zeiten hoch. Dabei wird eine Unterscheidung zwischen Wochentagen und Wochenenden berücksichtigt. Ausserdem werden mit Hilfe einer Holiday-Datei auch Feiertage und Urlaube berücksichtigt.
:Abends ist ein Zeitraum und ein Helligkeitswert definiert. Sobald dieser Helligkeitswert in dem Zeitfenster unterschritten wird, fahren die Rolläden runter. Spätestens aber zum Ende des Zeitfensters.

:''2. Weihnachten''
:Vom Prinzip arbeitet dieser Modus wie der Modus "Normal". Lediglich ein Rolladen fährt zum Ende des Zeitfensters runter und nicht bei Unterschreitung des Helligkeitswertes, damit die Weihnachtsaussenbeleuchtung auch von innen begutachtet werden kann.

:''3. Urlaub''
:Dieser Modus schaltet die Rolläden genauso wie der Modus "Normal". Des Weiteren aktiviere ich noch eine Zufallssteuerung für eine Anwesenheitsbeleuchtung.

;'''PV:'''
:Hiermit wird der Ertrag der Photovoltaikanlage mit einbezogen, damit die Rolläden zur Südseite anhand definierter Werte geschaltet werden.

;'''Zeit hoch:'''
:Hier wird der Zeitpunkt definiert, wann die Rollläden an Werktagen geöffnet werden sollen.

;'''Zeit hoch WE:'''
:Dies definiert die Zeit, wann die Rolläden am Wochenende bzw an Tagen, welche in einer Holiday Datei definiert sind hoch gehen sollen.

;'''Helligkeit runter:'''
:Dieser Wert ist der untere Schwellwert des Helligkeitssensors, ab wann die Rolläden in dem definierten Zeitraum geschlossen werden sollen.

;'''Zeit runter:'''
:Zu dieser Zeit fahren die Rolläden runter, egal ob der angegebene Hellgleitswert erreicht wurde. Sofern eventuelle Tür-/Fensterkontakte den Status "open" aufweisen, bleiben diese oben.

==Codierung==
Meine Aktoren haben den folgenden Aufbau, was den Namen angeht:

'''OG_ki1_RO_Carport'''

Die ersten zwei Zeichen geben das Geschoss an.
Die Zeichen 4-6 beschreiben das Zimmer.
Die Zeichen 8 und 9 stellen die Art des Aktors dar.
Ab Zeichen 11 wird noch weiter beschrieben wo sich der Aktor befindet bzw was für eine Funktion dieser besitzt.

===Dummys===
Beginnen möchte ich hier mit den Dummys, welche die Konfiguration der Steuerung darstellen.

;'''Automatik aktiv:'''

<nowiki>NAME du_Rollo_Master
TYPE dummy

Attributes:
alias Automatik aktiv:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_automatic
room LichtRollo
setList state:an,aus
sortby 01
webCmd state</nowiki>

;'''Art:'''

<nowiki>NAME du_Rollo_Art
TYPE dummy

Attributes:
alias Art:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_updown
room LichtRollo
setList state:Normal,Urlaub,Weihnachten
sortby 02
webCmd state</nowiki>

;'''PV:'''

<nowiki>NAME du_Rollo_PV
TYPE dummy

Attributes:
alias PV:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon weather_sun
room LichtRollo
setList state:an,aus
sortby 03
webCmd state</nowiki>

;'''Zeit hoch:'''

<nowiki>NAME du_Rollo_Zeit_ho
TYPE dummy

Attributes:
alias Zeit hoch:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 10
webCmd state</nowiki>

;'''Zeit hoch WE:'''

<nowiki> NAME du_Rollo_Zeit_ho_WE
TYPE dummy

Attributes:
alias Zeit hoch WE:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 11
webCmd state</nowiki>

;'''Helligkeit runter:'''

<nowiki>NAME du_Rollo_Luminosity_ru
TYPE dummy

Attributes:
alias Helligkeit runter
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon sani_solar
room LichtRollo
setList state:textField
sortby 20
webCmd state</nowiki>

;'''Zeit runter:'''

<nowiki>NAME du_Rollo_Zeit_ru
TYPE dummy

Attributes:
alias Zeit runter:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 21
webCmd state</nowiki>

;'''Tageslicht:'''

Dieser Dummy beinhaltet den Wert "hell" oder "dunkel".
Diese beiden Werte werden von zwei at's in Abhängigkeit von Sunset/Sunrise gesetzt.
Dadurch gehen die Rollos hoch, wenn im Dunkeln eine Tür geöffnet wird. Wird die Tür geschlossen. Geht der Rollo auch wieder runter.

<nowiki>NAME du_Tageslicht
TYPE dummy

Attributes:
alias Tageslicht
devStateIcon devStateIcon hell:hell dunkel:nacht@crimson
icon sani_solar
</nowiki>

===ATs===

'''at_LichtRollo_hell'''

<nowiki>NAME at_LichtRollo_hell
DEF *{sunrise(1200)} set du_Tageslicht hell </nowiki>

'''at_LichtRollo_dunkel'''

<nowiki>NAME at_LichtRollo_dunkel
DEF *{sunset(1200)} set du_Tageslicht dunkel</nowiki>

===DOIFs===

'''di_EG_ku_RO_StrasseLinks'''

Dieses DOIF beachtet den Helligkeitswert und den Modus "Weihnachten".
D.h., daß dieser Rollo erst am Ende des definierten Zeitraums herunterfährt.

<nowiki>(([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru] and [du_Rollo_Art] ne "Weihnachten" and [du_Tageslicht:state] eq "dunkel") or [{ReadingsVal("du_Rollo_Zeit_ru", "state", "22:00:00")}])
({if (ReadingsVal("EG_ku_RO_StrasseLinks", "state", "---") ne "off") {fhem("set EG_ku_RO_StrasseLinks off")}})
DOELSEIF (([[du_Rollo_Zeit_ho]|8] or [[du_Rollo_Zeit_ho_WE]|7]))
({if (ReadingsVal("EG_ku_RO_StrasseLinks", "state", "---") ne "on") {fhem("set EG_ku_RO_StrasseLinks on")}})</nowiki>

'''di_EG_ku_RO_StrasseRechts'''

Hier wird ein Fensterkontakt mit in die Schaltung einbezogen.
D.h. während des definierten Zeitraums gehen Rollos hoch, wenn eine Tür oder ein Fenster geöffnet wird. Ebenso wieder runter, sofern der Kontakt wieder geschlossen wird.

<nowiki>([EG_ku_TK_Strasse] eq "closed" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state] and [du_Tageslicht:state] eq "dunkel") or [[du_Rollo_Zeit_ru]])
({if (ReadingsVal("EG_ku_RO_StrasseRechts", "state", "---") ne "off") {fhem("set EG_ku_RO_StrasseRechts off")}})
DOELSEIF (([[du_Rollo_Zeit_ho]|8] or [[du_Rollo_Zeit_ho_WE]|7]) or ([EG_ku_TK_Strasse:state] eq "open") and ([du_Tageslicht:state] eq "dunkel"))
({if (ReadingsVal("EG_ku_RO_StrasseRechts", "state", "---") ne "on") {fhem("set EG_ku_RO_StrasseRechts on")}})</nowiki>

'''di_EG_wz_RO_TerrasseLinks'''

Dieses DOIF beachtet einen Fensterkontakt und bezieht die Photovoltaikanlage mit ein.
Dieser Rollo geht während des Zeitraums der Dunkelheit rauf und runter, sofern der Türkontakt geöffnet oder geschlossen wird.

<nowiki>([EG_wz_TK_Terrasse:state] eq "closed" and (([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state] and [du_Tageslicht:state] eq "dunkel") or [[du_Rollo_Zeit_ru]]))
({if (ReadingsVal("EG_wz_RO_TerrasseLinks", "state", "---") ne "off") {fhem("set EG_wz_RO_TerrasseLinks off")}})
DOELSEIF (([[du_Rollo_Zeit_ho]|8] or [[du_Rollo_Zeit_ho_WE]|7]) or (([EG_wz_TK_Terrasse:state] eq "open") and [du_Tageslicht:state] eq "dunkel"))
({if (ReadingsVal("EG_wz_RO_TerrasseLinks", "state", "---") ne "on") {fhem("set EG_wz_RO_TerrasseLinks on")}})
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 2100)
(set EG_wz_RO_TerrasseLinks 0)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 1501)
(set EG_wz_RO_TerrasseLinks 30)
DOELSEIF ([du_Rollo_PV] eq "aus")
(set EG_wz_RO_TerrasseLinks on)

wait 0:0:300:300:0 </nowiki>

Alle anderen Aktoren sind vereinfachte Versionen der genannten DOIFs und werden daher hier nicht genannt.

'''di_Rollo_Art'''

Dieses DOIF enabled und disabled einen Randomtimer, welcher ein Zufallslicht schaltet.

<nowiki>([du_Rollo_Art:state] eq "Urlaub") (attr UrlaubTimer disable 0, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 0)
DOELSE ([du_Rollo_Art:state] ne "Urlaub") (attr UrlaubTimer disable 1, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 1)</nowiki>

===ReadingsGroup===

Hier seien noch die beiden ReadingsGroup aufgeführt, welche im Dashboard dargestellt werden.

Folgende Funktionen sind in der myRollosUtils.pm gespeichert und dienen der Bedienung ausgehend aus den ReadingsGroups.

<nowiki>############## Rollos hoch/runter in Readingsgroup

sub myRollosUtils_RollosUpDown($$) {
my($DEVICE,$CMD) = @_;

my $icon = $CMD;
my $link;

if( $CMD eq "up" ) {
$icon = "remotecontrol/black_btn_CHUP";
$link = "setreading $DEVICE cmd-new on";
} elsif( $CMD eq "down" ) {
$icon = "remotecontrol/black_btn_CHDOWN";
$link = "setreading $DEVICE cmd-new off";
} elsif( $CMD eq "stop" ) {
$icon = "remotecontrol/black_btn_STOP";
$link = "setreading $DEVICE cmd-new stop";
}

my $notify = "no_RollosUpDown";
if( !defined($defs{$notify}) ) {
CommandDefine(undef,
"$notify notify .*:cmd-new.* "
."{ myRollos_RollosUpDownNotify(\$NAME,\$EVTPART1); }" );
}

my $ret = "%$icon";
$ret .= "%$link" if( $link );

return $ret;
}

sub myRollosUtils_RollosUpDownNotify($$) {
my($DEVICE,$CMD) = @_;

return if( $CMD eq "" );

CommandSet(undef, "$DEVICE $CMD");

return undef;
}

sub myRollosUtils_RollosIcon($) {
my($DEVICE) = @_;
my $level = ReadingsVal($DEVICE,"level", "0");
my $pct = ReadingsVal($DEVICE, "pct", "0");

my $ret = int((100 - $level)/10)*10;

my $icon;
if ($ret eq "0") {
$icon = "fts_window_2w\@orange";
} else {
$icon = "fts_shutter_".$ret."\@orange";
}

return $pct." %";
}
</nowiki>

'''EG_rg_Rolllaeden'''

<nowiki>EG.*_RO_S.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_C.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_T.*:level,
<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_M.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}>

Attributes:
group Rollos/Markise_EG
mapping %ALIAS
valueFormat {pct => "%.1f"}
valueIcon %VALUE </nowiki>

===Notify===

Ein Notify ist für die Bedienung ausgehend aus den ReadingsGroup notwendig.

<nowiki>DEF .*:cmd-new.* { myRollosUtils_RollosUpDownNotify($NAME,$EVTPART1); }
NAME no_RollosUpDown
TYPE notify

Attributes:
group notify</nowiki>

[[Kategorie:HOWTOS]]

Rolladensteuerung mit Eingabemöglichkeiten

2015-04-08T07:05:15Z

Max: /* Dummys */

Datei:Dashboard02.png

2015-03-26T16:46:54Z

Max: Max lud eine neue Version von Datei:Dashboard02.png hoch

Datei:Dashboard02.png

2015-03-26T16:45:17Z

Max: Max lud eine neue Version von Datei:Dashboard02.png hoch

Datei:Dashboard02.png

2015-03-24T07:05:02Z

Max: Max lud eine neue Version von Datei:Dashboard02.png hoch

Rolladensteuerung mit Eingabemöglichkeiten

2015-03-24T07:04:43Z

Max:

Datei:Dashboard02.png

2015-03-24T07:02:49Z

Max: Max lud eine neue Version von Datei:Dashboard02.png hoch

Rolladensteuerung mit Eingabemöglichkeiten

2015-02-13T11:10:06Z

Max: /* Visualisierung */

In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere.

==Grundsätzliche Beschreibung==
Mein erstes große Projekt in Sachen FHEM war es meine Rolläden automatisiert zu steuern, so dass man möglichst wenig manuell eingreifen muss.
Da der ein und andere Riemen der manuellen Steuerung den Geist aufgegeben hat, habe ich nach und nach alle Rolläden mit Motoren und HM Aktoren versehen.

Da ich eine Photovoltaikanlage besitze habe ich ein kleines Modul geschrieben, welches mir die Ertragsleistung in FHEM darstellt.
Anhand dieser Werte steuere ich Rolläden, welche zur Südseite gerichtet sind. Dadurch wird dann dynamisch die Sonneneinstrahlung und damit die Erwärmung der Zimmer eingestellt.
Zwischenzeitlich ist ein Helligkeitssensor installiert worden. Dieser sorgt für das Herunterfahren der Rolläden bei Eintreten der Dunkelheit.

Dieser Wert korreliert zwar mit den Werten der PV Anlage, dies habe ich aber bislang noch nicht aufgelöst.

==Komponenten==
1. HM Funk-Jalousieaktor HM-LC-Bi1PBU-FM

2. Solarlog-Modul

3. Helligkeitssensor aus diesem Posting
[http://forum.fhem.de/index.php/topic,20620.0.html Selbstbau HM_WDS10_TH_O mit Luftdruckmessung]

==Visualisierung==
Hier ist der Status eines jeden Rolladens ersichtlich und dieser ist bedienbar.
Die Darstellung habe ich mittels [[Dashboard]] umgesetzt.

[[Datei:Dashboard01.png]]

Über diese Einstellungsseite können diverse Parameter der Steuerung gesetzt werden.

[[Datei:Dashboard02.png]]

==Einstellungen==
;'''Automatik aktiv:'''
:Hiermit wird die komplette Steuerung der Rolläden ein- bzw ausgeschaltet.
:Sofern der Modus "aus" aktiv ist, werden meine Rolläden lediglich über die Aktoren direkt oder eine HM Fernbedienung gesteuert.

;'''Art:'''
:Hier werden derzeit drei Modi unterstützt:

:''1. Normal''
:Bei diesem Modus fahren die Rollläden zu den definierten Zeiten hoch. Dabei wird eine Unterscheidung zwischen Wochentagen und Wochenenden berücksichtigt. Ausserdem werden mit Hilfe einer Holiday-Datei auch Feiertage und Urlaube berücksichtigt.
:Abends ist ein Zeitraum und ein Helligkeitswert definiert. Sobald dieser Helligkeitswert in dem Zeitfenster unterschritten wird, fahren die Rolläden runter. Spätestens aber zum Ende des Zeitfensters.

:''2. Weihnachten''
:Vom Prinzip arbeitet dieser Modus wie der Modus "Normal". Lediglich ein Rolladen fährt zum Ende des Zeitfensters runter und nicht bei Unterschreitung des Helligkeitswertes, damit die Weihnachtsaussenbeleuchtung auch von innen begutachtet werden kann.

:''3. Urlaub''
:Dieser Modus schaltet die Rolläden genauso wie der Modus "Normal". Des Weiteren aktiviere ich noch eine Zufallssteuerung für eine Anwesenheitsbeleuchtung.

;'''PV:'''
:Hiermit wird der Ertrag der Photovoltaikanlage mit einbezogen, damit die Rolläden zur Südseite anhand definierter Werte geschaltet werden.

;'''Zeit hoch:'''
:Hier wird der Zeitpunkt definiert, wann die Rollläden an Werktagen geöffnet werden sollen.

;'''Zeit hoch WE:'''
:Dies definiert die Zeit, wann die Rolläden am Wochenende bzw an Tagen, welche in einer Holiday Datei definiert sind hoch gehen sollen.

;'''Helligkeit runter:'''
:Dieser Wert ist der untere Schwellwert des Helligkeitssensors, ab wann die Rolläden in dem definierten Zeitraum geschlossen werden sollen.

;'''Zeit runter start:'''
:Ab dieser Zeit fahren die Rolläden bei Erreichen des Helligkeitswertes runter. Sofern eventuelle Tür-/Fensterkontakte den Status "closed" aufweisen. Während des Zeitraums gehen diese Rolläden hoch und auch wieder runter, sofern eine Tür/ein Fenster geöffnet bzw geschlossen wird.

;'''Zeit runter ende:'''
:Dies ist das Ende des Zeitraums. Wenn bis dahin die Helligkeit nicht unterschritten wurde, fahren die Rolläden nun spätestens runter.

==Codierung==
Meine Aktoren haben den folgenden Aufbau, was den Namen angeht:

'''OG_ki1_RO_Carport'''

Die ersten zwei Zeichen geben das Geschoss an.
Die Zeichen 4-6 beschreiben das Zimmer.
Die Zeichen 8 und 9 stellen die Art des Aktors dar.
Ab Zeichen 11 wird noch weiter beschrieben wo sich der Aktor befindet bzw was für eine Funktion dieser besitzt.

===Dummys===
Beginnen möchte ich hier mit den Dummys, welche die Konfiguration der Steuerung darstellen.

;'''Automatik aktiv:'''

<nowiki>NAME du_Rollo_Master
TYPE dummy

Attributes:
alias Automatik aktiv:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_automatic
room LichtRollo
setList state:an,aus
sortby 01
webCmd state</nowiki>

;'''Art:'''

<nowiki>NAME du_Rollo_Art
TYPE dummy

Attributes:
alias Art:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_updown
room LichtRollo
setList state:Normal,Urlaub,Weihnachten
sortby 02
webCmd state</nowiki>

;'''PV:'''

<nowiki>NAME du_Rollo_PV
TYPE dummy

Attributes:
alias PV:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon weather_sun
room LichtRollo
setList state:an,aus
sortby 03
webCmd state</nowiki>

;'''Zeit hoch:'''

<nowiki>NAME du_Rollo_Zeit_ho
TYPE dummy

Attributes:
alias Zeit hoch:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 10
webCmd state</nowiki>

;'''Zeit hoch WE:'''

<nowiki> NAME du_Rollo_Zeit_ho_WE
TYPE dummy

Attributes:
alias Zeit hoch WE:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 11
webCmd state</nowiki>

;'''Helligkeit runter:'''

<nowiki>NAME du_Rollo_Luminosity_ru
TYPE dummy

Attributes:
alias Helligkeit runter
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon sani_solar
room LichtRollo
setList state:textField
sortby 20
webCmd state</nowiki>

;'''Zeit runter start:'''

<nowiki>NAME du_Rollo_Zeit_ru_start
TYPE dummy

Attributes:
alias Zeit runter start:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 21
webCmd state</nowiki>

;'''Zeit runter ende:'''

<nowiki>NAME du_Rollo_Zeit_ru_ende
TYPE dummy

Attributes:
alias Zeit runter ende:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 22
webCmd state</nowiki>

===DOIFs===

'''di_EG_ku_RO_StrasseLinks'''

Dieses DOIF beachtet den Helligkeitswert und den Modus "Weihnachten".
D.h., daß dieser Rollo erst am Ende des definierten Zeitraums herunterfährt.

<nowiki>([du_Rollo_Master] eq "an" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru] and
[du_Rollo_Art] ne "Weihnachten" and
[{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
({if (ReadingsVal("EG_ku_RO_StrasseLinks", "state", "---") ne "off") {fhem("set EG_ku_RO_StrasseLinks off")}})
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]))
({if (ReadingsVal("EG_ku_RO_StrasseLinks", "state", "---") ne "on") {fhem("set EG_ku_RO_StrasseLinks on")}})</nowiki>

'''di_EG_ku_RO_StrasseRechts'''

Hier wird ein Fensterkontakt mit in die Schaltung einbezogen.
D.h. während des definierten Zeitraums gehen Rollos hoch, wenn eine Tür oder ein Fenster geöffnet wird. Ebenso wieder runter, sofern der Kontakt wieder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_ku_TK_Strasse] eq "closed" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
({if (ReadingsVal("EG_ku_RO_StrasseRechts", "state", "---") ne "off") {fhem("set EG_ku_RO_StrasseRechts off")}})
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_ku_TK_Strasse:state] eq "open"))
({if (ReadingsVal("EG_ku_RO_StrasseRechts", "state", "---") ne "on") {fhem("set EG_ku_RO_StrasseRechts on")}})</nowiki>

'''di_EG_wz_RO_TerrasseLinks'''

Dieses DOIF beachtet einen Fensterkontakt und bezieht die Photovoltaikanlage mit ein.
Dieser Rollo geht während des Zeitraums der Dunkelheit rauf und runter, sofern der Türkontakt geöffnet oder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and (([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]))
({if (ReadingsVal("EG_wz_RO_TerrasseLinks", "state", "---") ne "off") {fhem("set EG_wz_RO_TerrasseLinks off")}})
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8]
or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_wz_TK_Terrasse] eq "open"))
({if (ReadingsVal("EG_wz_RO_TerrasseLinks", "state", "---") ne "on") {fhem("set EG_wz_RO_TerrasseLinks on")}})
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 2100)
(set EG_wz_RO_TerrasseLinks 0)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 1501)
(set EG_wz_RO_TerrasseLinks 30)
DOELSEIF ([du_Rollo_PV] eq "aus")
(set EG_wz_RO_TerrasseLinks on)

wait 0:0:300:300:0 </nowiki>

Alle anderen Aktoren sind vereinfachte Versionen der genannten DOIFs und werden daher hier nicht genannt.

'''di_Rollo_Art'''

Dieses DOIF enabled und disabled einen Randomtimer, welcher ein Zufallslicht schaltet.

<nowiki>([du_Rollo_Art:state] eq "Urlaub") (attr UrlaubTimer disable 0, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 0)
DOELSE ([du_Rollo_Art:state] ne "Urlaub") (attr UrlaubTimer disable 1, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 1)</nowiki>

Hier folgt nun ein interessantes DOIF.
Sofern manuelle Änderungen in den Text- bzw Zeitdummys durchgeführt werden, aktualisiert dieses DOIF die Definitionen der Rollo-DOIFs.
Dadurch werden die neuen Werte aus den Dummys für die Timer der DOIFs aktualisiert.

Auch aktualisiert dieses DOIF bei einem Neustart von FHEM die DOIFs.
Andernfalls würden die Defaultwerte der ReadingsVal(...) in den Definitionen die Defaultwerte zurückliefern.

'''di_Rollo_SetTime'''

<nowiki>([global:?INITIALIZED] or [du_Rollo_Zeit_ho:?] or [du_Rollo_Zeit_ho_WE:?] or [du_Rollo_Luminosity_ru:?]
or [du_Rollo_Zeit_ru_start:?] or [du_Rollo_Zeit_ru_ende:?]) (modify di_EG_ku_RO_StrasseLinks [di_EG_ku_RO_StrasseLinks:&DEF],
modify di_EG_ku_RO_StrasseRechts [di_EG_ku_RO_StrasseRechts:&DEF],
modify di_EG_wz_RO_Carport [di_EG_wz_RO_Carport:&DEF], modify di_EG_wz_RO_TerrasseLinks [di_EG_wz_RO_TerrasseLinks:&DEF],
modify di_EG_wz_RO_TerrasseRechts [di_EG_wz_RO_TerrasseRechts:&DEF], modify di_OG_elt_RO_Strasse [di_OG_elt_RO_Strasse:&DEF],
modify di_OG_ki1_RO_Carport [di_OG_ki1_RO_Carport:&DEF], modify di_OG_ki1_RO_Garten [di_OG_ki1_RO_Garten:&DEF],
modify di_OG_ki2_RO_Garten [di_OG_ki2_RO_Garten:&DEF])</nowiki>

===ReadingsGroup===

Hier seien noch die beiden ReadingsGroup aufgeführt, welche im Dashboard dargestellt werden.

Folgende Funktionen sind in der myRollosUtils.pm gespeichert und dienen der Bedienung ausgehend aus den ReadingsGroups.

<nowiki>############## Rollos hoch/runter in Readingsgroup

sub myRollosUtils_RollosUpDown($$) {
my($DEVICE,$CMD) = @_;

my $icon = $CMD;
my $link;

if( $CMD eq "up" ) {
$icon = "remotecontrol/black_btn_CHUP";
$link = "setreading $DEVICE cmd-new on";
} elsif( $CMD eq "down" ) {
$icon = "remotecontrol/black_btn_CHDOWN";
$link = "setreading $DEVICE cmd-new off";
} elsif( $CMD eq "stop" ) {
$icon = "remotecontrol/black_btn_STOP";
$link = "setreading $DEVICE cmd-new stop";
}

my $notify = "no_RollosUpDown";
if( !defined($defs{$notify}) ) {
CommandDefine(undef,
"$notify notify .*:cmd-new.* "
."{ myRollos_RollosUpDownNotify(\$NAME,\$EVTPART1); }" );
}

my $ret = "%$icon";
$ret .= "%$link" if( $link );

return $ret;
}

sub myRollosUtils_RollosUpDownNotify($$) {
my($DEVICE,$CMD) = @_;

return if( $CMD eq "" );

CommandSet(undef, "$DEVICE $CMD");

return undef;
}

sub myRollosUtils_RollosIcon($) {
my($DEVICE) = @_;
my $level = ReadingsVal($DEVICE,"level", "0");
my $pct = ReadingsVal($DEVICE, "pct", "0");

my $ret = int((100 - $level)/10)*10;

my $icon;
if ($ret eq "0") {
$icon = "fts_window_2w\@orange";
} else {
$icon = "fts_shutter_".$ret."\@orange";
}

return $pct." %";
}
</nowiki>

'''EG_rg_Rolllaeden'''

<nowiki>EG.*_RO_S.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_C.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_T.*:level,
<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_M.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}>

Attributes:
group Rollos/Markise_EG
mapping %ALIAS
valueFormat {pct => "%.1f"}
valueIcon %VALUE </nowiki>

===Notify===

Ein Notify ist für die Bedienung ausgehend aus den ReadingsGroup notwendig.

<nowiki>DEF .*:cmd-new.* { myRollosUtils_RollosUpDownNotify($NAME,$EVTPART1); }
NAME no_RollosUpDown
TYPE notify

Attributes:
group notify</nowiki>

[[Kategorie:HOWTOS]]

Rolladensteuerung mit Eingabemöglichkeiten

2015-02-12T19:22:24Z

Max: /* DOIFs */

In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere.

==Grundsätzliche Beschreibung==
Mein erstes große Projekt in Sachen FHEM war es meine Rolläden automatisiert zu steuern, so dass man möglichst wenig manuell eingreifen muss.
Da der ein und andere Riemen der manuellen Steuerung den Geist aufgegeben hat, habe ich nach und nach alle Rolläden mit Motoren und HM Aktoren versehen.

Da ich eine Photovoltaikanlage besitze habe ich ein kleines Modul geschrieben, welches mir die Ertragsleistung in FHEM darstellt.
Anhand dieser Werte steuere ich Rolläden, welche zur Südseite gerichtet sind. Dadurch wird dann dynamisch die Sonneneinstrahlung und damit die Erwärmung der Zimmer eingestellt.
Zwischenzeitlich ist ein Helligkeitssensor installiert worden. Dieser sorgt für das Herunterfahren der Rolläden bei Eintreten der Dunkelheit.

Dieser Wert korreliert zwar mit den Werten der PV Anlage, dies habe ich aber bislang noch nicht aufgelöst.

==Komponenten==
1. HM Funk-Jalousieaktor HM-LC-Bi1PBU-FM

2. Solarlog-Modul

3. Helligkeitssensor aus diesem Posting
[http://forum.fhem.de/index.php/topic,20620.0.html Selbstbau HM_WDS10_TH_O mit Luftdruckmessung]

==Visualisierung==
Hier ist der Status eines jeden Rolladens ersichtlich und dieser ist bedienbar.

[[Datei:Dashboard01.png]]

Über diese Einstellungsseite können diverse Parameter der Steuerung gesetzt werden.

[[Datei:Dashboard02.png]]

==Einstellungen==
;'''Automatik aktiv:'''
:Hiermit wird die komplette Steuerung der Rolläden ein- bzw ausgeschaltet.
:Sofern der Modus "aus" aktiv ist, werden meine Rolläden lediglich über die Aktoren direkt oder eine HM Fernbedienung gesteuert.

;'''Art:'''
:Hier werden derzeit drei Modi unterstützt:

:''1. Normal''
:Bei diesem Modus fahren die Rollläden zu den definierten Zeiten hoch. Dabei wird eine Unterscheidung zwischen Wochentagen und Wochenenden berücksichtigt. Ausserdem werden mit Hilfe einer Holiday-Datei auch Feiertage und Urlaube berücksichtigt.
:Abends ist ein Zeitraum und ein Helligkeitswert definiert. Sobald dieser Helligkeitswert in dem Zeitfenster unterschritten wird, fahren die Rolläden runter. Spätestens aber zum Ende des Zeitfensters.

:''2. Weihnachten''
:Vom Prinzip arbeitet dieser Modus wie der Modus "Normal". Lediglich ein Rolladen fährt zum Ende des Zeitfensters runter und nicht bei Unterschreitung des Helligkeitswertes, damit die Weihnachtsaussenbeleuchtung auch von innen begutachtet werden kann.

:''3. Urlaub''
:Dieser Modus schaltet die Rolläden genauso wie der Modus "Normal". Des Weiteren aktiviere ich noch eine Zufallssteuerung für eine Anwesenheitsbeleuchtung.

;'''PV:'''
:Hiermit wird der Ertrag der Photovoltaikanlage mit einbezogen, damit die Rolläden zur Südseite anhand definierter Werte geschaltet werden.

;'''Zeit hoch:'''
:Hier wird der Zeitpunkt definiert, wann die Rollläden an Werktagen geöffnet werden sollen.

;'''Zeit hoch WE:'''
:Dies definiert die Zeit, wann die Rolläden am Wochenende bzw an Tagen, welche in einer Holiday Datei definiert sind hoch gehen sollen.

;'''Helligkeit runter:'''
:Dieser Wert ist der untere Schwellwert des Helligkeitssensors, ab wann die Rolläden in dem definierten Zeitraum geschlossen werden sollen.

;'''Zeit runter start:'''
:Ab dieser Zeit fahren die Rolläden bei Erreichen des Helligkeitswertes runter. Sofern eventuelle Tür-/Fensterkontakte den Status "closed" aufweisen. Während des Zeitraums gehen diese Rolläden hoch und auch wieder runter, sofern eine Tür/ein Fenster geöffnet bzw geschlossen wird.

;'''Zeit runter ende:'''
:Dies ist das Ende des Zeitraums. Wenn bis dahin die Helligkeit nicht unterschritten wurde, fahren die Rolläden nun spätestens runter.

==Codierung==
Meine Aktoren haben den folgenden Aufbau, was den Namen angeht:

'''OG_ki1_RO_Carport'''

Die ersten zwei Zeichen geben das Geschoss an.
Die Zeichen 4-6 beschreiben das Zimmer.
Die Zeichen 8 und 9 stellen die Art des Aktors dar.
Ab Zeichen 11 wird noch weiter beschrieben wo sich der Aktor befindet bzw was für eine Funktion dieser besitzt.

===Dummys===
Beginnen möchte ich hier mit den Dummys, welche die Konfiguration der Steuerung darstellen.

;'''Automatik aktiv:'''

<nowiki>NAME du_Rollo_Master
TYPE dummy

Attributes:
alias Automatik aktiv:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_automatic
room LichtRollo
setList state:an,aus
sortby 01
webCmd state</nowiki>

;'''Art:'''

<nowiki>NAME du_Rollo_Art
TYPE dummy

Attributes:
alias Art:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_updown
room LichtRollo
setList state:Normal,Urlaub,Weihnachten
sortby 02
webCmd state</nowiki>

;'''PV:'''

<nowiki>NAME du_Rollo_PV
TYPE dummy

Attributes:
alias PV:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon weather_sun
room LichtRollo
setList state:an,aus
sortby 03
webCmd state</nowiki>

;'''Zeit hoch:'''

<nowiki>NAME du_Rollo_Zeit_ho
TYPE dummy

Attributes:
alias Zeit hoch:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 10
webCmd state</nowiki>

;'''Zeit hoch WE:'''

<nowiki> NAME du_Rollo_Zeit_ho_WE
TYPE dummy

Attributes:
alias Zeit hoch WE:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 11
webCmd state</nowiki>

;'''Helligkeit runter:'''

<nowiki>NAME du_Rollo_Luminosity_ru
TYPE dummy

Attributes:
alias Helligkeit runter
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon sani_solar
room LichtRollo
setList state:textField
sortby 20
webCmd state</nowiki>

;'''Zeit runter start:'''

<nowiki>NAME du_Rollo_Zeit_ru_start
TYPE dummy

Attributes:
alias Zeit runter start:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 21
webCmd state</nowiki>

;'''Zeit runter ende:'''

<nowiki>NAME du_Rollo_Zeit_ru_ende
TYPE dummy

Attributes:
alias Zeit runter ende:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 22
webCmd state</nowiki>

===DOIFs===

'''di_EG_ku_RO_StrasseLinks'''

Dieses DOIF beachtet den Helligkeitswert und den Modus "Weihnachten".
D.h., daß dieser Rollo erst am Ende des definierten Zeitraums herunterfährt.

<nowiki>([du_Rollo_Master] eq "an" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru] and
[du_Rollo_Art] ne "Weihnachten" and
[{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
({if (ReadingsVal("EG_ku_RO_StrasseLinks", "state", "---") ne "off") {fhem("set EG_ku_RO_StrasseLinks off")}})
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]))
({if (ReadingsVal("EG_ku_RO_StrasseLinks", "state", "---") ne "on") {fhem("set EG_ku_RO_StrasseLinks on")}})</nowiki>

'''di_EG_ku_RO_StrasseRechts'''

Hier wird ein Fensterkontakt mit in die Schaltung einbezogen.
D.h. während des definierten Zeitraums gehen Rollos hoch, wenn eine Tür oder ein Fenster geöffnet wird. Ebenso wieder runter, sofern der Kontakt wieder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_ku_TK_Strasse] eq "closed" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
({if (ReadingsVal("EG_ku_RO_StrasseRechts", "state", "---") ne "off") {fhem("set EG_ku_RO_StrasseRechts off")}})
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_ku_TK_Strasse:state] eq "open"))
({if (ReadingsVal("EG_ku_RO_StrasseRechts", "state", "---") ne "on") {fhem("set EG_ku_RO_StrasseRechts on")}})</nowiki>

'''di_EG_wz_RO_TerrasseLinks'''

Dieses DOIF beachtet einen Fensterkontakt und bezieht die Photovoltaikanlage mit ein.
Dieser Rollo geht während des Zeitraums der Dunkelheit rauf und runter, sofern der Türkontakt geöffnet oder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and (([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]))
({if (ReadingsVal("EG_wz_RO_TerrasseLinks", "state", "---") ne "off") {fhem("set EG_wz_RO_TerrasseLinks off")}})
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8]
or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_wz_TK_Terrasse] eq "open"))
({if (ReadingsVal("EG_wz_RO_TerrasseLinks", "state", "---") ne "on") {fhem("set EG_wz_RO_TerrasseLinks on")}})
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 2100)
(set EG_wz_RO_TerrasseLinks 0)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 1501)
(set EG_wz_RO_TerrasseLinks 30)
DOELSEIF ([du_Rollo_PV] eq "aus")
(set EG_wz_RO_TerrasseLinks on)

wait 0:0:300:300:0 </nowiki>

Alle anderen Aktoren sind vereinfachte Versionen der genannten DOIFs und werden daher hier nicht genannt.

'''di_Rollo_Art'''

Dieses DOIF enabled und disabled einen Randomtimer, welcher ein Zufallslicht schaltet.

<nowiki>([du_Rollo_Art:state] eq "Urlaub") (attr UrlaubTimer disable 0, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 0)
DOELSE ([du_Rollo_Art:state] ne "Urlaub") (attr UrlaubTimer disable 1, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 1)</nowiki>

Hier folgt nun ein interessantes DOIF.
Sofern manuelle Änderungen in den Text- bzw Zeitdummys durchgeführt werden, aktualisiert dieses DOIF die Definitionen der Rollo-DOIFs.
Dadurch werden die neuen Werte aus den Dummys für die Timer der DOIFs aktualisiert.

Auch aktualisiert dieses DOIF bei einem Neustart von FHEM die DOIFs.
Andernfalls würden die Defaultwerte der ReadingsVal(...) in den Definitionen die Defaultwerte zurückliefern.

'''di_Rollo_SetTime'''

<nowiki>([global:?INITIALIZED] or [du_Rollo_Zeit_ho:?] or [du_Rollo_Zeit_ho_WE:?] or [du_Rollo_Luminosity_ru:?]
or [du_Rollo_Zeit_ru_start:?] or [du_Rollo_Zeit_ru_ende:?]) (modify di_EG_ku_RO_StrasseLinks [di_EG_ku_RO_StrasseLinks:&DEF],
modify di_EG_ku_RO_StrasseRechts [di_EG_ku_RO_StrasseRechts:&DEF],
modify di_EG_wz_RO_Carport [di_EG_wz_RO_Carport:&DEF], modify di_EG_wz_RO_TerrasseLinks [di_EG_wz_RO_TerrasseLinks:&DEF],
modify di_EG_wz_RO_TerrasseRechts [di_EG_wz_RO_TerrasseRechts:&DEF], modify di_OG_elt_RO_Strasse [di_OG_elt_RO_Strasse:&DEF],
modify di_OG_ki1_RO_Carport [di_OG_ki1_RO_Carport:&DEF], modify di_OG_ki1_RO_Garten [di_OG_ki1_RO_Garten:&DEF],
modify di_OG_ki2_RO_Garten [di_OG_ki2_RO_Garten:&DEF])</nowiki>

===ReadingsGroup===

Hier seien noch die beiden ReadingsGroup aufgeführt, welche im Dashboard dargestellt werden.

Folgende Funktionen sind in der myRollosUtils.pm gespeichert und dienen der Bedienung ausgehend aus den ReadingsGroups.

<nowiki>############## Rollos hoch/runter in Readingsgroup

sub myRollosUtils_RollosUpDown($$) {
my($DEVICE,$CMD) = @_;

my $icon = $CMD;
my $link;

if( $CMD eq "up" ) {
$icon = "remotecontrol/black_btn_CHUP";
$link = "setreading $DEVICE cmd-new on";
} elsif( $CMD eq "down" ) {
$icon = "remotecontrol/black_btn_CHDOWN";
$link = "setreading $DEVICE cmd-new off";
} elsif( $CMD eq "stop" ) {
$icon = "remotecontrol/black_btn_STOP";
$link = "setreading $DEVICE cmd-new stop";
}

my $notify = "no_RollosUpDown";
if( !defined($defs{$notify}) ) {
CommandDefine(undef,
"$notify notify .*:cmd-new.* "
."{ myRollos_RollosUpDownNotify(\$NAME,\$EVTPART1); }" );
}

my $ret = "%$icon";
$ret .= "%$link" if( $link );

return $ret;
}

sub myRollosUtils_RollosUpDownNotify($$) {
my($DEVICE,$CMD) = @_;

return if( $CMD eq "" );

CommandSet(undef, "$DEVICE $CMD");

return undef;
}

sub myRollosUtils_RollosIcon($) {
my($DEVICE) = @_;
my $level = ReadingsVal($DEVICE,"level", "0");
my $pct = ReadingsVal($DEVICE, "pct", "0");

my $ret = int((100 - $level)/10)*10;

my $icon;
if ($ret eq "0") {
$icon = "fts_window_2w\@orange";
} else {
$icon = "fts_shutter_".$ret."\@orange";
}

return $pct." %";
}
</nowiki>

'''EG_rg_Rolllaeden'''

<nowiki>EG.*_RO_S.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_C.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_T.*:level,
<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_M.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}>

Attributes:
group Rollos/Markise_EG
mapping %ALIAS
valueFormat {pct => "%.1f"}
valueIcon %VALUE </nowiki>

===Notify===

Ein Notify ist für die Bedienung ausgehend aus den ReadingsGroup notwendig.

<nowiki>DEF .*:cmd-new.* { myRollosUtils_RollosUpDownNotify($NAME,$EVTPART1); }
NAME no_RollosUpDown
TYPE notify

Attributes:
group notify</nowiki>

[[Kategorie:HOWTOS]]

Rolladensteuerung mit Eingabemöglichkeiten

2015-02-12T09:55:35Z

Max: /* Grundsätzliche Beschreibung */

In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere.

==Grundsätzliche Beschreibung==
Mein erstes große Projekt in Sachen FHEM war es meine Rolläden automatisiert zu steuern, so dass man möglichst wenig manuell eingreifen muss.
Da der ein und andere Riemen der manuellen Steuerung den Geist aufgegeben hat, habe ich nach und nach alle Rolläden mit Motoren und HM Aktoren versehen.

Da ich eine Photovoltaikanlage besitze habe ich ein kleines Modul geschrieben, welches mir die Ertragsleistung in FHEM darstellt.
Anhand dieser Werte steuere ich Rolläden, welche zur Südseite gerichtet sind. Dadurch wird dann dynamisch die Sonneneinstrahlung und damit die Erwärmung der Zimmer eingestellt.
Zwischenzeitlich ist ein Helligkeitssensor installiert worden. Dieser sorgt für das Herunterfahren der Rolläden bei Eintreten der Dunkelheit.

Dieser Wert korreliert zwar mit den Werten der PV Anlage, dies habe ich aber bislang noch nicht aufgelöst.

==Komponenten==
1. HM Funk-Jalousieaktor HM-LC-Bi1PBU-FM

2. Solarlog-Modul

3. Helligkeitssensor aus diesem Posting
[http://forum.fhem.de/index.php/topic,20620.0.html Selbstbau HM_WDS10_TH_O mit Luftdruckmessung]

==Visualisierung==
Hier ist der Status eines jeden Rolladens ersichtlich und dieser ist bedienbar.

[[Datei:Dashboard01.png]]

Über diese Einstellungsseite können diverse Parameter der Steuerung gesetzt werden.

[[Datei:Dashboard02.png]]

==Einstellungen==
;'''Automatik aktiv:'''
:Hiermit wird die komplette Steuerung der Rolläden ein- bzw ausgeschaltet.
:Sofern der Modus "aus" aktiv ist, werden meine Rolläden lediglich über die Aktoren direkt oder eine HM Fernbedienung gesteuert.

;'''Art:'''
:Hier werden derzeit drei Modi unterstützt:

:''1. Normal''
:Bei diesem Modus fahren die Rollläden zu den definierten Zeiten hoch. Dabei wird eine Unterscheidung zwischen Wochentagen und Wochenenden berücksichtigt. Ausserdem werden mit Hilfe einer Holiday-Datei auch Feiertage und Urlaube berücksichtigt.
:Abends ist ein Zeitraum und ein Helligkeitswert definiert. Sobald dieser Helligkeitswert in dem Zeitfenster unterschritten wird, fahren die Rolläden runter. Spätestens aber zum Ende des Zeitfensters.

:''2. Weihnachten''
:Vom Prinzip arbeitet dieser Modus wie der Modus "Normal". Lediglich ein Rolladen fährt zum Ende des Zeitfensters runter und nicht bei Unterschreitung des Helligkeitswertes, damit die Weihnachtsaussenbeleuchtung auch von innen begutachtet werden kann.

:''3. Urlaub''
:Dieser Modus schaltet die Rolläden genauso wie der Modus "Normal". Des Weiteren aktiviere ich noch eine Zufallssteuerung für eine Anwesenheitsbeleuchtung.

;'''PV:'''
:Hiermit wird der Ertrag der Photovoltaikanlage mit einbezogen, damit die Rolläden zur Südseite anhand definierter Werte geschaltet werden.

;'''Zeit hoch:'''
:Hier wird der Zeitpunkt definiert, wann die Rollläden an Werktagen geöffnet werden sollen.

;'''Zeit hoch WE:'''
:Dies definiert die Zeit, wann die Rolläden am Wochenende bzw an Tagen, welche in einer Holiday Datei definiert sind hoch gehen sollen.

;'''Helligkeit runter:'''
:Dieser Wert ist der untere Schwellwert des Helligkeitssensors, ab wann die Rolläden in dem definierten Zeitraum geschlossen werden sollen.

;'''Zeit runter start:'''
:Ab dieser Zeit fahren die Rolläden bei Erreichen des Helligkeitswertes runter. Sofern eventuelle Tür-/Fensterkontakte den Status "closed" aufweisen. Während des Zeitraums gehen diese Rolläden hoch und auch wieder runter, sofern eine Tür/ein Fenster geöffnet bzw geschlossen wird.

;'''Zeit runter ende:'''
:Dies ist das Ende des Zeitraums. Wenn bis dahin die Helligkeit nicht unterschritten wurde, fahren die Rolläden nun spätestens runter.

==Codierung==
Meine Aktoren haben den folgenden Aufbau, was den Namen angeht:

'''OG_ki1_RO_Carport'''

Die ersten zwei Zeichen geben das Geschoss an.
Die Zeichen 4-6 beschreiben das Zimmer.
Die Zeichen 8 und 9 stellen die Art des Aktors dar.
Ab Zeichen 11 wird noch weiter beschrieben wo sich der Aktor befindet bzw was für eine Funktion dieser besitzt.

===Dummys===
Beginnen möchte ich hier mit den Dummys, welche die Konfiguration der Steuerung darstellen.

;'''Automatik aktiv:'''

<nowiki>NAME du_Rollo_Master
TYPE dummy

Attributes:
alias Automatik aktiv:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_automatic
room LichtRollo
setList state:an,aus
sortby 01
webCmd state</nowiki>

;'''Art:'''

<nowiki>NAME du_Rollo_Art
TYPE dummy

Attributes:
alias Art:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_updown
room LichtRollo
setList state:Normal,Urlaub,Weihnachten
sortby 02
webCmd state</nowiki>

;'''PV:'''

<nowiki>NAME du_Rollo_PV
TYPE dummy

Attributes:
alias PV:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon weather_sun
room LichtRollo
setList state:an,aus
sortby 03
webCmd state</nowiki>

;'''Zeit hoch:'''

<nowiki>NAME du_Rollo_Zeit_ho
TYPE dummy

Attributes:
alias Zeit hoch:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 10
webCmd state</nowiki>

;'''Zeit hoch WE:'''

<nowiki> NAME du_Rollo_Zeit_ho_WE
TYPE dummy

Attributes:
alias Zeit hoch WE:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 11
webCmd state</nowiki>

;'''Helligkeit runter:'''

<nowiki>NAME du_Rollo_Luminosity_ru
TYPE dummy

Attributes:
alias Helligkeit runter
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon sani_solar
room LichtRollo
setList state:textField
sortby 20
webCmd state</nowiki>

;'''Zeit runter start:'''

<nowiki>NAME du_Rollo_Zeit_ru_start
TYPE dummy

Attributes:
alias Zeit runter start:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 21
webCmd state</nowiki>

;'''Zeit runter ende:'''

<nowiki>NAME du_Rollo_Zeit_ru_ende
TYPE dummy

Attributes:
alias Zeit runter ende:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 22
webCmd state</nowiki>

===DOIFs===

'''di_EG_ku_RO_StrasseLinks'''

Dieses DOIF beachtet den Helligkeitswert und den Modus "Weihnachten".
D.h., daß dieser Rollo erst am Ende des definierten Zeitraums herunterfährt.

<nowiki>([du_Rollo_Master] eq "an" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru] and
[du_Rollo_Art] ne "Weihnachten" and
[{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]))
(set EG_ku_RO_StrasseLinks on)</nowiki>

'''di_EG_ku_RO_StrasseRechts'''

Hier wird ein Fensterkontakt mit in die Schaltung einbezogen.
D.h. während des definierten Zeitraums gehen Rollos hoch, wenn eine Tür oder ein Fenster geöffnet wird. Ebenso wieder runter, sofern der Kontakt wieder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_ku_TK_Strasse] eq "closed" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseRechts off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_ku_TK_Strasse:state] eq "open"))
(set EG_ku_RO_StrasseRechts on)</nowiki>

'''di_EG_wz_RO_TerrasseLinks'''

Dieses DOIF beachtet einen Fensterkontakt und bezieht die Photovoltaikanlage mit ein.
Dieser Rollo geht während des Zeitraums der Dunkelheit rauf und runter, sofern der Türkontakt geöffnet oder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and (([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]))
(set EG_wz_RO_TerrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8]
or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_wz_TK_Terrasse] eq "open"))
(set EG_wz_RO_TerrasseLinks on)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 2100)
(set EG_wz_RO_TerrasseLinks 0)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 1501)
(set EG_wz_RO_TerrasseLinks 30)
DOELSEIF ([du_Rollo_PV] eq "aus")
(set EG_wz_RO_TerrasseLinks on)

wait 0:0:300:300:0 </nowiki>

Alle anderen Aktoren sind vereinfachte Versionen der genannten DOIFs und werden daher hier nicht genannt.

'''di_Rollo_Art'''

Dieses DOIF enabled und disabled einen Randomtimer, welcher ein Zufallslicht schaltet.

<nowiki>([du_Rollo_Art:state] eq "Urlaub") (attr UrlaubTimer disable 0, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 0)
DOELSE ([du_Rollo_Art:state] ne "Urlaub") (attr UrlaubTimer disable 1, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 1)</nowiki>

Hier folgt nun ein interessantes DOIF.
Sofern manuelle Änderungen in den Text- bzw Zeitdummys durchgeführt werden, aktualisiert dieses DOIF die Definitionen der Rollo-DOIFs.
Dadurch werden die neuen Werte aus den Dummys für die Timer der DOIFs aktualisiert.

Auch aktualisiert dieses DOIF bei einem Neustart von FHEM die DOIFs.
Andernfalls würden die Defaultwerte der ReadingsVal(...) in den Definitionen die Defaultwerte zurückliefern.

'''di_Rollo_SetTime'''

<nowiki>([global:?INITIALIZED] or [du_Rollo_Zeit_ho:?] or [du_Rollo_Zeit_ho_WE:?] or [du_Rollo_Luminosity_ru:?]
or [du_Rollo_Zeit_ru_start:?] or [du_Rollo_Zeit_ru_ende:?]) (modify di_EG_ku_RO_StrasseLinks [di_EG_ku_RO_StrasseLinks:&DEF],
modify di_EG_ku_RO_StrasseRechts [di_EG_ku_RO_StrasseRechts:&DEF],
modify di_EG_wz_RO_Carport [di_EG_wz_RO_Carport:&DEF], modify di_EG_wz_RO_TerrasseLinks [di_EG_wz_RO_TerrasseLinks:&DEF],
modify di_EG_wz_RO_TerrasseRechts [di_EG_wz_RO_TerrasseRechts:&DEF], modify di_OG_elt_RO_Strasse [di_OG_elt_RO_Strasse:&DEF],
modify di_OG_ki1_RO_Carport [di_OG_ki1_RO_Carport:&DEF], modify di_OG_ki1_RO_Garten [di_OG_ki1_RO_Garten:&DEF],
modify di_OG_ki2_RO_Garten [di_OG_ki2_RO_Garten:&DEF])</nowiki>

===ReadingsGroup===

Hier seien noch die beiden ReadingsGroup aufgeführt, welche im Dashboard dargestellt werden.

Folgende Funktionen sind in der myRollosUtils.pm gespeichert und dienen der Bedienung ausgehend aus den ReadingsGroups.

<nowiki>############## Rollos hoch/runter in Readingsgroup

sub myRollosUtils_RollosUpDown($$) {
my($DEVICE,$CMD) = @_;

my $icon = $CMD;
my $link;

if( $CMD eq "up" ) {
$icon = "remotecontrol/black_btn_CHUP";
$link = "setreading $DEVICE cmd-new on";
} elsif( $CMD eq "down" ) {
$icon = "remotecontrol/black_btn_CHDOWN";
$link = "setreading $DEVICE cmd-new off";
} elsif( $CMD eq "stop" ) {
$icon = "remotecontrol/black_btn_STOP";
$link = "setreading $DEVICE cmd-new stop";
}

my $notify = "no_RollosUpDown";
if( !defined($defs{$notify}) ) {
CommandDefine(undef,
"$notify notify .*:cmd-new.* "
."{ myRollos_RollosUpDownNotify(\$NAME,\$EVTPART1); }" );
}

my $ret = "%$icon";
$ret .= "%$link" if( $link );

return $ret;
}

sub myRollosUtils_RollosUpDownNotify($$) {
my($DEVICE,$CMD) = @_;

return if( $CMD eq "" );

CommandSet(undef, "$DEVICE $CMD");

return undef;
}

sub myRollosUtils_RollosIcon($) {
my($DEVICE) = @_;
my $level = ReadingsVal($DEVICE,"level", "0");
my $pct = ReadingsVal($DEVICE, "pct", "0");

my $ret = int((100 - $level)/10)*10;

my $icon;
if ($ret eq "0") {
$icon = "fts_window_2w\@orange";
} else {
$icon = "fts_shutter_".$ret."\@orange";
}

return $pct." %";
}
</nowiki>

'''EG_rg_Rolllaeden'''

<nowiki>EG.*_RO_S.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_C.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_T.*:level,
<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_M.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}>

Attributes:
group Rollos/Markise_EG
mapping %ALIAS
valueFormat {pct => "%.1f"}
valueIcon %VALUE </nowiki>

===Notify===

Ein Notify ist für die Bedienung ausgehend aus den ReadingsGroup notwendig.

<nowiki>DEF .*:cmd-new.* { myRollosUtils_RollosUpDownNotify($NAME,$EVTPART1); }
NAME no_RollosUpDown
TYPE notify

Attributes:
group notify</nowiki>

[[Kategorie:HOWTOS]]

Rolladensteuerung mit Eingabemöglichkeiten

2015-02-11T19:52:31Z

Max: /* ReadingsGroup */

In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere.

==Grundsätzliche Beschreibung==
Meine Rollläden im Haus sind allesamt mit HM Aktoren versehen, welche ich nachträglich UP gelegt habe.
Vorher waren die Rolläden manuell bedienbar gewesen.

Da ich eine Photovoltaikanlage besitze habe ich ein kleines Modul geschrieben, welches mir die Ertragsleistung in FHEM darstellt.
Anhand dieser Werte steuere ich Rolläden, welche zur Südseite gerichtet sind. Dadurch wird dann dynamisch die Sonneneinstrahlung und damit die Erwärmung der Zimmer eingestellt.
Zwischenzeitlich ist ein Helligkeitssensor installiert worden. Dieser sorgt für das Herunterfahren der Rolläden bei Eintreten der Dunkelheit.

Dieser Wert korreliert zwar mit den Werten der PV Anlage, dies habe ich aber bislang noch nicht aufgelöst.

==Komponenten==
1. HM Funk-Jalousieaktor HM-LC-Bi1PBU-FM

2. Solarlog-Modul

3. Helligkeitssensor aus diesem Posting
[http://forum.fhem.de/index.php/topic,20620.0.html Selbstbau HM_WDS10_TH_O mit Luftdruckmessung]

==Visualisierung==
Hier ist der Status eines jeden Rolladens ersichtlich und dieser ist bedienbar.

[[Datei:Dashboard01.png]]

Über diese Einstellungsseite können diverse Parameter der Steuerung gesetzt werden.

[[Datei:Dashboard02.png]]

==Einstellungen==
;'''Automatik aktiv:'''
:Hiermit wird die komplette Steuerung der Rolläden ein- bzw ausgeschaltet.
:Sofern der Modus "aus" aktiv ist, werden meine Rolläden lediglich über die Aktoren direkt oder eine HM Fernbedienung gesteuert.

;'''Art:'''
:Hier werden derzeit drei Modi unterstützt:

:''1. Normal''
:Bei diesem Modus fahren die Rollläden zu den definierten Zeiten hoch. Dabei wird eine Unterscheidung zwischen Wochentagen und Wochenenden berücksichtigt. Ausserdem werden mit Hilfe einer Holiday-Datei auch Feiertage und Urlaube berücksichtigt.
:Abends ist ein Zeitraum und ein Helligkeitswert definiert. Sobald dieser Helligkeitswert in dem Zeitfenster unterschritten wird, fahren die Rolläden runter. Spätestens aber zum Ende des Zeitfensters.

:''2. Weihnachten''
:Vom Prinzip arbeitet dieser Modus wie der Modus "Normal". Lediglich ein Rolladen fährt zum Ende des Zeitfensters runter und nicht bei Unterschreitung des Helligkeitswertes, damit die Weihnachtsaussenbeleuchtung auch von innen begutachtet werden kann.

:''3. Urlaub''
:Dieser Modus schaltet die Rolläden genauso wie der Modus "Normal". Des Weiteren aktiviere ich noch eine Zufallssteuerung für eine Anwesenheitsbeleuchtung.

;'''PV:'''
:Hiermit wird der Ertrag der Photovoltaikanlage mit einbezogen, damit die Rolläden zur Südseite anhand definierter Werte geschaltet werden.

;'''Zeit hoch:'''
:Hier wird der Zeitpunkt definiert, wann die Rollläden an Werktagen geöffnet werden sollen.

;'''Zeit hoch WE:'''
:Dies definiert die Zeit, wann die Rolläden am Wochenende bzw an Tagen, welche in einer Holiday Datei definiert sind hoch gehen sollen.

;'''Helligkeit runter:'''
:Dieser Wert ist der untere Schwellwert des Helligkeitssensors, ab wann die Rolläden in dem definierten Zeitraum geschlossen werden sollen.

;'''Zeit runter start:'''
:Ab dieser Zeit fahren die Rolläden bei Erreichen des Helligkeitswertes runter. Sofern eventuelle Tür-/Fensterkontakte den Status "closed" aufweisen. Während des Zeitraums gehen diese Rolläden hoch und auch wieder runter, sofern eine Tür/ein Fenster geöffnet bzw geschlossen wird.

;'''Zeit runter ende:'''
:Dies ist das Ende des Zeitraums. Wenn bis dahin die Helligkeit nicht unterschritten wurde, fahren die Rolläden nun spätestens runter.

==Codierung==
Meine Aktoren haben den folgenden Aufbau, was den Namen angeht:

'''OG_ki1_RO_Carport'''

Die ersten zwei Zeichen geben das Geschoss an.
Die Zeichen 4-6 beschreiben das Zimmer.
Die Zeichen 8 und 9 stellen die Art des Aktors dar.
Ab Zeichen 11 wird noch weiter beschrieben wo sich der Aktor befindet bzw was für eine Funktion dieser besitzt.

===Dummys===
Beginnen möchte ich hier mit den Dummys, welche die Konfiguration der Steuerung darstellen.

;'''Automatik aktiv:'''

<nowiki>NAME du_Rollo_Master
TYPE dummy

Attributes:
alias Automatik aktiv:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_automatic
room LichtRollo
setList state:an,aus
sortby 01
webCmd state</nowiki>

;'''Art:'''

<nowiki>NAME du_Rollo_Art
TYPE dummy

Attributes:
alias Art:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_updown
room LichtRollo
setList state:Normal,Urlaub,Weihnachten
sortby 02
webCmd state</nowiki>

;'''PV:'''

<nowiki>NAME du_Rollo_PV
TYPE dummy

Attributes:
alias PV:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon weather_sun
room LichtRollo
setList state:an,aus
sortby 03
webCmd state</nowiki>

;'''Zeit hoch:'''

<nowiki>NAME du_Rollo_Zeit_ho
TYPE dummy

Attributes:
alias Zeit hoch:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 10
webCmd state</nowiki>

;'''Zeit hoch WE:'''

<nowiki> NAME du_Rollo_Zeit_ho_WE
TYPE dummy

Attributes:
alias Zeit hoch WE:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 11
webCmd state</nowiki>

;'''Helligkeit runter:'''

<nowiki>NAME du_Rollo_Luminosity_ru
TYPE dummy

Attributes:
alias Helligkeit runter
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon sani_solar
room LichtRollo
setList state:textField
sortby 20
webCmd state</nowiki>

;'''Zeit runter start:'''

<nowiki>NAME du_Rollo_Zeit_ru_start
TYPE dummy

Attributes:
alias Zeit runter start:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 21
webCmd state</nowiki>

;'''Zeit runter ende:'''

<nowiki>NAME du_Rollo_Zeit_ru_ende
TYPE dummy

Attributes:
alias Zeit runter ende:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 22
webCmd state</nowiki>

===DOIFs===

'''di_EG_ku_RO_StrasseLinks'''

Dieses DOIF beachtet den Helligkeitswert und den Modus "Weihnachten".
D.h., daß dieser Rollo erst am Ende des definierten Zeitraums herunterfährt.

<nowiki>([du_Rollo_Master] eq "an" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru] and
[du_Rollo_Art] ne "Weihnachten" and
[{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]))
(set EG_ku_RO_StrasseLinks on)</nowiki>

'''di_EG_ku_RO_StrasseRechts'''

Hier wird ein Fensterkontakt mit in die Schaltung einbezogen.
D.h. während des definierten Zeitraums gehen Rollos hoch, wenn eine Tür oder ein Fenster geöffnet wird. Ebenso wieder runter, sofern der Kontakt wieder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_ku_TK_Strasse] eq "closed" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseRechts off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_ku_TK_Strasse:state] eq "open"))
(set EG_ku_RO_StrasseRechts on)</nowiki>

'''di_EG_wz_RO_TerrasseLinks'''

Dieses DOIF beachtet einen Fensterkontakt und bezieht die Photovoltaikanlage mit ein.
Dieser Rollo geht während des Zeitraums der Dunkelheit rauf und runter, sofern der Türkontakt geöffnet oder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and (([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]))
(set EG_wz_RO_TerrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8]
or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_wz_TK_Terrasse] eq "open"))
(set EG_wz_RO_TerrasseLinks on)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 2100)
(set EG_wz_RO_TerrasseLinks 0)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 1501)
(set EG_wz_RO_TerrasseLinks 30)
DOELSEIF ([du_Rollo_PV] eq "aus")
(set EG_wz_RO_TerrasseLinks on)

wait 0:0:300:300:0 </nowiki>

Alle anderen Aktoren sind vereinfachte Versionen der genannten DOIFs und werden daher hier nicht genannt.

'''di_Rollo_Art'''

Dieses DOIF enabled und disabled einen Randomtimer, welcher ein Zufallslicht schaltet.

<nowiki>([du_Rollo_Art:state] eq "Urlaub") (attr UrlaubTimer disable 0, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 0)
DOELSE ([du_Rollo_Art:state] ne "Urlaub") (attr UrlaubTimer disable 1, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 1)</nowiki>

Hier folgt nun ein interessantes DOIF.
Sofern manuelle Änderungen in den Text- bzw Zeitdummys durchgeführt werden, aktualisiert dieses DOIF die Definitionen der Rollo-DOIFs.
Dadurch werden die neuen Werte aus den Dummys für die Timer der DOIFs aktualisiert.

Auch aktualisiert dieses DOIF bei einem Neustart von FHEM die DOIFs.
Andernfalls würden die Defaultwerte der ReadingsVal(...) in den Definitionen die Defaultwerte zurückliefern.

'''di_Rollo_SetTime'''

<nowiki>([global:?INITIALIZED] or [du_Rollo_Zeit_ho:?] or [du_Rollo_Zeit_ho_WE:?] or [du_Rollo_Luminosity_ru:?]
or [du_Rollo_Zeit_ru_start:?] or [du_Rollo_Zeit_ru_ende:?]) (modify di_EG_ku_RO_StrasseLinks [di_EG_ku_RO_StrasseLinks:&DEF],
modify di_EG_ku_RO_StrasseRechts [di_EG_ku_RO_StrasseRechts:&DEF],
modify di_EG_wz_RO_Carport [di_EG_wz_RO_Carport:&DEF], modify di_EG_wz_RO_TerrasseLinks [di_EG_wz_RO_TerrasseLinks:&DEF],
modify di_EG_wz_RO_TerrasseRechts [di_EG_wz_RO_TerrasseRechts:&DEF], modify di_OG_elt_RO_Strasse [di_OG_elt_RO_Strasse:&DEF],
modify di_OG_ki1_RO_Carport [di_OG_ki1_RO_Carport:&DEF], modify di_OG_ki1_RO_Garten [di_OG_ki1_RO_Garten:&DEF],
modify di_OG_ki2_RO_Garten [di_OG_ki2_RO_Garten:&DEF])</nowiki>

===ReadingsGroup===

Hier seien noch die beiden ReadingsGroup aufgeführt, welche im Dashboard dargestellt werden.

Folgende Funktionen sind in der myRollosUtils.pm gespeichert und dienen der Bedienung ausgehend aus den ReadingsGroups.

<nowiki>############## Rollos hoch/runter in Readingsgroup

sub myRollosUtils_RollosUpDown($$) {
my($DEVICE,$CMD) = @_;

my $icon = $CMD;
my $link;

if( $CMD eq "up" ) {
$icon = "remotecontrol/black_btn_CHUP";
$link = "setreading $DEVICE cmd-new on";
} elsif( $CMD eq "down" ) {
$icon = "remotecontrol/black_btn_CHDOWN";
$link = "setreading $DEVICE cmd-new off";
} elsif( $CMD eq "stop" ) {
$icon = "remotecontrol/black_btn_STOP";
$link = "setreading $DEVICE cmd-new stop";
}

my $notify = "no_RollosUpDown";
if( !defined($defs{$notify}) ) {
CommandDefine(undef,
"$notify notify .*:cmd-new.* "
."{ myRollos_RollosUpDownNotify(\$NAME,\$EVTPART1); }" );
}

my $ret = "%$icon";
$ret .= "%$link" if( $link );

return $ret;
}

sub myRollosUtils_RollosUpDownNotify($$) {
my($DEVICE,$CMD) = @_;

return if( $CMD eq "" );

CommandSet(undef, "$DEVICE $CMD");

return undef;
}

sub myRollosUtils_RollosIcon($) {
my($DEVICE) = @_;
my $level = ReadingsVal($DEVICE,"level", "0");
my $pct = ReadingsVal($DEVICE, "pct", "0");

my $ret = int((100 - $level)/10)*10;

my $icon;
if ($ret eq "0") {
$icon = "fts_window_2w\@orange";
} else {
$icon = "fts_shutter_".$ret."\@orange";
}

return $pct." %";
}
</nowiki>

'''EG_rg_Rolllaeden'''

<nowiki>EG.*_RO_S.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_C.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_T.*:level,
<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_M.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}>

Attributes:
group Rollos/Markise_EG
mapping %ALIAS
valueFormat {pct => "%.1f"}
valueIcon %VALUE </nowiki>

===Notify===

Ein Notify ist für die Bedienung ausgehend aus den ReadingsGroup notwendig.

<nowiki>DEF .*:cmd-new.* { myRollosUtils_RollosUpDownNotify($NAME,$EVTPART1); }
NAME no_RollosUpDown
TYPE notify

Attributes:
group notify</nowiki>

Rolladensteuerung mit Eingabemöglichkeiten

2015-02-11T19:51:57Z

Max: /* DOIFs */

In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere.

==Grundsätzliche Beschreibung==
Meine Rollläden im Haus sind allesamt mit HM Aktoren versehen, welche ich nachträglich UP gelegt habe.
Vorher waren die Rolläden manuell bedienbar gewesen.

Da ich eine Photovoltaikanlage besitze habe ich ein kleines Modul geschrieben, welches mir die Ertragsleistung in FHEM darstellt.
Anhand dieser Werte steuere ich Rolläden, welche zur Südseite gerichtet sind. Dadurch wird dann dynamisch die Sonneneinstrahlung und damit die Erwärmung der Zimmer eingestellt.
Zwischenzeitlich ist ein Helligkeitssensor installiert worden. Dieser sorgt für das Herunterfahren der Rolläden bei Eintreten der Dunkelheit.

Dieser Wert korreliert zwar mit den Werten der PV Anlage, dies habe ich aber bislang noch nicht aufgelöst.

==Komponenten==
1. HM Funk-Jalousieaktor HM-LC-Bi1PBU-FM

2. Solarlog-Modul

3. Helligkeitssensor aus diesem Posting
[http://forum.fhem.de/index.php/topic,20620.0.html Selbstbau HM_WDS10_TH_O mit Luftdruckmessung]

==Visualisierung==
Hier ist der Status eines jeden Rolladens ersichtlich und dieser ist bedienbar.

[[Datei:Dashboard01.png]]

Über diese Einstellungsseite können diverse Parameter der Steuerung gesetzt werden.

[[Datei:Dashboard02.png]]

==Einstellungen==
;'''Automatik aktiv:'''
:Hiermit wird die komplette Steuerung der Rolläden ein- bzw ausgeschaltet.
:Sofern der Modus "aus" aktiv ist, werden meine Rolläden lediglich über die Aktoren direkt oder eine HM Fernbedienung gesteuert.

;'''Art:'''
:Hier werden derzeit drei Modi unterstützt:

:''1. Normal''
:Bei diesem Modus fahren die Rollläden zu den definierten Zeiten hoch. Dabei wird eine Unterscheidung zwischen Wochentagen und Wochenenden berücksichtigt. Ausserdem werden mit Hilfe einer Holiday-Datei auch Feiertage und Urlaube berücksichtigt.
:Abends ist ein Zeitraum und ein Helligkeitswert definiert. Sobald dieser Helligkeitswert in dem Zeitfenster unterschritten wird, fahren die Rolläden runter. Spätestens aber zum Ende des Zeitfensters.

:''2. Weihnachten''
:Vom Prinzip arbeitet dieser Modus wie der Modus "Normal". Lediglich ein Rolladen fährt zum Ende des Zeitfensters runter und nicht bei Unterschreitung des Helligkeitswertes, damit die Weihnachtsaussenbeleuchtung auch von innen begutachtet werden kann.

:''3. Urlaub''
:Dieser Modus schaltet die Rolläden genauso wie der Modus "Normal". Des Weiteren aktiviere ich noch eine Zufallssteuerung für eine Anwesenheitsbeleuchtung.

;'''PV:'''
:Hiermit wird der Ertrag der Photovoltaikanlage mit einbezogen, damit die Rolläden zur Südseite anhand definierter Werte geschaltet werden.

;'''Zeit hoch:'''
:Hier wird der Zeitpunkt definiert, wann die Rollläden an Werktagen geöffnet werden sollen.

;'''Zeit hoch WE:'''
:Dies definiert die Zeit, wann die Rolläden am Wochenende bzw an Tagen, welche in einer Holiday Datei definiert sind hoch gehen sollen.

;'''Helligkeit runter:'''
:Dieser Wert ist der untere Schwellwert des Helligkeitssensors, ab wann die Rolläden in dem definierten Zeitraum geschlossen werden sollen.

;'''Zeit runter start:'''
:Ab dieser Zeit fahren die Rolläden bei Erreichen des Helligkeitswertes runter. Sofern eventuelle Tür-/Fensterkontakte den Status "closed" aufweisen. Während des Zeitraums gehen diese Rolläden hoch und auch wieder runter, sofern eine Tür/ein Fenster geöffnet bzw geschlossen wird.

;'''Zeit runter ende:'''
:Dies ist das Ende des Zeitraums. Wenn bis dahin die Helligkeit nicht unterschritten wurde, fahren die Rolläden nun spätestens runter.

==Codierung==
Meine Aktoren haben den folgenden Aufbau, was den Namen angeht:

'''OG_ki1_RO_Carport'''

Die ersten zwei Zeichen geben das Geschoss an.
Die Zeichen 4-6 beschreiben das Zimmer.
Die Zeichen 8 und 9 stellen die Art des Aktors dar.
Ab Zeichen 11 wird noch weiter beschrieben wo sich der Aktor befindet bzw was für eine Funktion dieser besitzt.

===Dummys===
Beginnen möchte ich hier mit den Dummys, welche die Konfiguration der Steuerung darstellen.

;'''Automatik aktiv:'''

<nowiki>NAME du_Rollo_Master
TYPE dummy

Attributes:
alias Automatik aktiv:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_automatic
room LichtRollo
setList state:an,aus
sortby 01
webCmd state</nowiki>

;'''Art:'''

<nowiki>NAME du_Rollo_Art
TYPE dummy

Attributes:
alias Art:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_updown
room LichtRollo
setList state:Normal,Urlaub,Weihnachten
sortby 02
webCmd state</nowiki>

;'''PV:'''

<nowiki>NAME du_Rollo_PV
TYPE dummy

Attributes:
alias PV:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon weather_sun
room LichtRollo
setList state:an,aus
sortby 03
webCmd state</nowiki>

;'''Zeit hoch:'''

<nowiki>NAME du_Rollo_Zeit_ho
TYPE dummy

Attributes:
alias Zeit hoch:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 10
webCmd state</nowiki>

;'''Zeit hoch WE:'''

<nowiki> NAME du_Rollo_Zeit_ho_WE
TYPE dummy

Attributes:
alias Zeit hoch WE:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 11
webCmd state</nowiki>

;'''Helligkeit runter:'''

<nowiki>NAME du_Rollo_Luminosity_ru
TYPE dummy

Attributes:
alias Helligkeit runter
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon sani_solar
room LichtRollo
setList state:textField
sortby 20
webCmd state</nowiki>

;'''Zeit runter start:'''

<nowiki>NAME du_Rollo_Zeit_ru_start
TYPE dummy

Attributes:
alias Zeit runter start:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 21
webCmd state</nowiki>

;'''Zeit runter ende:'''

<nowiki>NAME du_Rollo_Zeit_ru_ende
TYPE dummy

Attributes:
alias Zeit runter ende:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 22
webCmd state</nowiki>

===DOIFs===

'''di_EG_ku_RO_StrasseLinks'''

Dieses DOIF beachtet den Helligkeitswert und den Modus "Weihnachten".
D.h., daß dieser Rollo erst am Ende des definierten Zeitraums herunterfährt.

<nowiki>([du_Rollo_Master] eq "an" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru] and
[du_Rollo_Art] ne "Weihnachten" and
[{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]))
(set EG_ku_RO_StrasseLinks on)</nowiki>

'''di_EG_ku_RO_StrasseRechts'''

Hier wird ein Fensterkontakt mit in die Schaltung einbezogen.
D.h. während des definierten Zeitraums gehen Rollos hoch, wenn eine Tür oder ein Fenster geöffnet wird. Ebenso wieder runter, sofern der Kontakt wieder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_ku_TK_Strasse] eq "closed" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseRechts off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_ku_TK_Strasse:state] eq "open"))
(set EG_ku_RO_StrasseRechts on)</nowiki>

'''di_EG_wz_RO_TerrasseLinks'''

Dieses DOIF beachtet einen Fensterkontakt und bezieht die Photovoltaikanlage mit ein.
Dieser Rollo geht während des Zeitraums der Dunkelheit rauf und runter, sofern der Türkontakt geöffnet oder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and (([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]))
(set EG_wz_RO_TerrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8]
or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_wz_TK_Terrasse] eq "open"))
(set EG_wz_RO_TerrasseLinks on)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 2100)
(set EG_wz_RO_TerrasseLinks 0)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 1501)
(set EG_wz_RO_TerrasseLinks 30)
DOELSEIF ([du_Rollo_PV] eq "aus")
(set EG_wz_RO_TerrasseLinks on)

wait 0:0:300:300:0 </nowiki>

Alle anderen Aktoren sind vereinfachte Versionen der genannten DOIFs und werden daher hier nicht genannt.

'''di_Rollo_Art'''

Dieses DOIF enabled und disabled einen Randomtimer, welcher ein Zufallslicht schaltet.

<nowiki>([du_Rollo_Art:state] eq "Urlaub") (attr UrlaubTimer disable 0, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 0)
DOELSE ([du_Rollo_Art:state] ne "Urlaub") (attr UrlaubTimer disable 1, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 1)</nowiki>

Hier folgt nun ein interessantes DOIF.
Sofern manuelle Änderungen in den Text- bzw Zeitdummys durchgeführt werden, aktualisiert dieses DOIF die Definitionen der Rollo-DOIFs.
Dadurch werden die neuen Werte aus den Dummys für die Timer der DOIFs aktualisiert.

Auch aktualisiert dieses DOIF bei einem Neustart von FHEM die DOIFs.
Andernfalls würden die Defaultwerte der ReadingsVal(...) in den Definitionen die Defaultwerte zurückliefern.

'''di_Rollo_SetTime'''

<nowiki>([global:?INITIALIZED] or [du_Rollo_Zeit_ho:?] or [du_Rollo_Zeit_ho_WE:?] or [du_Rollo_Luminosity_ru:?]
or [du_Rollo_Zeit_ru_start:?] or [du_Rollo_Zeit_ru_ende:?]) (modify di_EG_ku_RO_StrasseLinks [di_EG_ku_RO_StrasseLinks:&DEF],
modify di_EG_ku_RO_StrasseRechts [di_EG_ku_RO_StrasseRechts:&DEF],
modify di_EG_wz_RO_Carport [di_EG_wz_RO_Carport:&DEF], modify di_EG_wz_RO_TerrasseLinks [di_EG_wz_RO_TerrasseLinks:&DEF],
modify di_EG_wz_RO_TerrasseRechts [di_EG_wz_RO_TerrasseRechts:&DEF], modify di_OG_elt_RO_Strasse [di_OG_elt_RO_Strasse:&DEF],
modify di_OG_ki1_RO_Carport [di_OG_ki1_RO_Carport:&DEF], modify di_OG_ki1_RO_Garten [di_OG_ki1_RO_Garten:&DEF],
modify di_OG_ki2_RO_Garten [di_OG_ki2_RO_Garten:&DEF])</nowiki>

===ReadingsGroup===

Hier seien noch die beiden ReadingsGroup aufgeführt, welche im Dashboard dargestellt werden.

Folgende Funktionen sind in der myRollosUtils gespeichert und dienen der Bedienung ausgehend aus den ReadingsGroups.

<nowiki>############## Rollos hoch/runter in Readingsgroup

sub myRollosUtils_RollosUpDown($$) {
my($DEVICE,$CMD) = @_;

my $icon = $CMD;
my $link;

if( $CMD eq "up" ) {
$icon = "remotecontrol/black_btn_CHUP";
$link = "setreading $DEVICE cmd-new on";
} elsif( $CMD eq "down" ) {
$icon = "remotecontrol/black_btn_CHDOWN";
$link = "setreading $DEVICE cmd-new off";
} elsif( $CMD eq "stop" ) {
$icon = "remotecontrol/black_btn_STOP";
$link = "setreading $DEVICE cmd-new stop";
}

my $notify = "no_RollosUpDown";
if( !defined($defs{$notify}) ) {
CommandDefine(undef,
"$notify notify .*:cmd-new.* "
."{ myRollos_RollosUpDownNotify(\$NAME,\$EVTPART1); }" );
}

my $ret = "%$icon";
$ret .= "%$link" if( $link );

return $ret;
}

sub myRollosUtils_RollosUpDownNotify($$) {
my($DEVICE,$CMD) = @_;

return if( $CMD eq "" );

CommandSet(undef, "$DEVICE $CMD");

return undef;
}

sub myRollosUtils_RollosIcon($) {
my($DEVICE) = @_;
my $level = ReadingsVal($DEVICE,"level", "0");
my $pct = ReadingsVal($DEVICE, "pct", "0");

my $ret = int((100 - $level)/10)*10;

my $icon;
if ($ret eq "0") {
$icon = "fts_window_2w\@orange";
} else {
$icon = "fts_shutter_".$ret."\@orange";
}

return $pct." %";
}
</nowiki>

'''EG_rg_Rolllaeden'''

<nowiki>EG.*_RO_S.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_C.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_T.*:level,
<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_M.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}>

Attributes:
group Rollos/Markise_EG
mapping %ALIAS
valueFormat {pct => "%.1f"}
valueIcon %VALUE </nowiki>

===Notify===

Ein Notify ist für die Bedienung ausgehend aus den ReadingsGroup notwendig.

<nowiki>DEF .*:cmd-new.* { myRollosUtils_RollosUpDownNotify($NAME,$EVTPART1); }
NAME no_RollosUpDown
TYPE notify

Attributes:
group notify</nowiki>

Rolladensteuerung mit Eingabemöglichkeiten

2015-02-11T19:50:03Z

Max: /* Codierung */

In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere.

==Grundsätzliche Beschreibung==
Meine Rollläden im Haus sind allesamt mit HM Aktoren versehen, welche ich nachträglich UP gelegt habe.
Vorher waren die Rolläden manuell bedienbar gewesen.

Da ich eine Photovoltaikanlage besitze habe ich ein kleines Modul geschrieben, welches mir die Ertragsleistung in FHEM darstellt.
Anhand dieser Werte steuere ich Rolläden, welche zur Südseite gerichtet sind. Dadurch wird dann dynamisch die Sonneneinstrahlung und damit die Erwärmung der Zimmer eingestellt.
Zwischenzeitlich ist ein Helligkeitssensor installiert worden. Dieser sorgt für das Herunterfahren der Rolläden bei Eintreten der Dunkelheit.

Dieser Wert korreliert zwar mit den Werten der PV Anlage, dies habe ich aber bislang noch nicht aufgelöst.

==Komponenten==
1. HM Funk-Jalousieaktor HM-LC-Bi1PBU-FM

2. Solarlog-Modul

3. Helligkeitssensor aus diesem Posting
[http://forum.fhem.de/index.php/topic,20620.0.html Selbstbau HM_WDS10_TH_O mit Luftdruckmessung]

==Visualisierung==
Hier ist der Status eines jeden Rolladens ersichtlich und dieser ist bedienbar.

[[Datei:Dashboard01.png]]

Über diese Einstellungsseite können diverse Parameter der Steuerung gesetzt werden.

[[Datei:Dashboard02.png]]

==Einstellungen==
;'''Automatik aktiv:'''
:Hiermit wird die komplette Steuerung der Rolläden ein- bzw ausgeschaltet.
:Sofern der Modus "aus" aktiv ist, werden meine Rolläden lediglich über die Aktoren direkt oder eine HM Fernbedienung gesteuert.

;'''Art:'''
:Hier werden derzeit drei Modi unterstützt:

:''1. Normal''
:Bei diesem Modus fahren die Rollläden zu den definierten Zeiten hoch. Dabei wird eine Unterscheidung zwischen Wochentagen und Wochenenden berücksichtigt. Ausserdem werden mit Hilfe einer Holiday-Datei auch Feiertage und Urlaube berücksichtigt.
:Abends ist ein Zeitraum und ein Helligkeitswert definiert. Sobald dieser Helligkeitswert in dem Zeitfenster unterschritten wird, fahren die Rolläden runter. Spätestens aber zum Ende des Zeitfensters.

:''2. Weihnachten''
:Vom Prinzip arbeitet dieser Modus wie der Modus "Normal". Lediglich ein Rolladen fährt zum Ende des Zeitfensters runter und nicht bei Unterschreitung des Helligkeitswertes, damit die Weihnachtsaussenbeleuchtung auch von innen begutachtet werden kann.

:''3. Urlaub''
:Dieser Modus schaltet die Rolläden genauso wie der Modus "Normal". Des Weiteren aktiviere ich noch eine Zufallssteuerung für eine Anwesenheitsbeleuchtung.

;'''PV:'''
:Hiermit wird der Ertrag der Photovoltaikanlage mit einbezogen, damit die Rolläden zur Südseite anhand definierter Werte geschaltet werden.

;'''Zeit hoch:'''
:Hier wird der Zeitpunkt definiert, wann die Rollläden an Werktagen geöffnet werden sollen.

;'''Zeit hoch WE:'''
:Dies definiert die Zeit, wann die Rolläden am Wochenende bzw an Tagen, welche in einer Holiday Datei definiert sind hoch gehen sollen.

;'''Helligkeit runter:'''
:Dieser Wert ist der untere Schwellwert des Helligkeitssensors, ab wann die Rolläden in dem definierten Zeitraum geschlossen werden sollen.

;'''Zeit runter start:'''
:Ab dieser Zeit fahren die Rolläden bei Erreichen des Helligkeitswertes runter. Sofern eventuelle Tür-/Fensterkontakte den Status "closed" aufweisen. Während des Zeitraums gehen diese Rolläden hoch und auch wieder runter, sofern eine Tür/ein Fenster geöffnet bzw geschlossen wird.

;'''Zeit runter ende:'''
:Dies ist das Ende des Zeitraums. Wenn bis dahin die Helligkeit nicht unterschritten wurde, fahren die Rolläden nun spätestens runter.

==Codierung==
Meine Aktoren haben den folgenden Aufbau, was den Namen angeht:

'''OG_ki1_RO_Carport'''

Die ersten zwei Zeichen geben das Geschoss an.
Die Zeichen 4-6 beschreiben das Zimmer.
Die Zeichen 8 und 9 stellen die Art des Aktors dar.
Ab Zeichen 11 wird noch weiter beschrieben wo sich der Aktor befindet bzw was für eine Funktion dieser besitzt.

===Dummys===
Beginnen möchte ich hier mit den Dummys, welche die Konfiguration der Steuerung darstellen.

;'''Automatik aktiv:'''

<nowiki>NAME du_Rollo_Master
TYPE dummy

Attributes:
alias Automatik aktiv:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_automatic
room LichtRollo
setList state:an,aus
sortby 01
webCmd state</nowiki>

;'''Art:'''

<nowiki>NAME du_Rollo_Art
TYPE dummy

Attributes:
alias Art:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_updown
room LichtRollo
setList state:Normal,Urlaub,Weihnachten
sortby 02
webCmd state</nowiki>

;'''PV:'''

<nowiki>NAME du_Rollo_PV
TYPE dummy

Attributes:
alias PV:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon weather_sun
room LichtRollo
setList state:an,aus
sortby 03
webCmd state</nowiki>

;'''Zeit hoch:'''

<nowiki>NAME du_Rollo_Zeit_ho
TYPE dummy

Attributes:
alias Zeit hoch:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 10
webCmd state</nowiki>

;'''Zeit hoch WE:'''

<nowiki> NAME du_Rollo_Zeit_ho_WE
TYPE dummy

Attributes:
alias Zeit hoch WE:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 11
webCmd state</nowiki>

;'''Helligkeit runter:'''

<nowiki>NAME du_Rollo_Luminosity_ru
TYPE dummy

Attributes:
alias Helligkeit runter
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon sani_solar
room LichtRollo
setList state:textField
sortby 20
webCmd state</nowiki>

;'''Zeit runter start:'''

<nowiki>NAME du_Rollo_Zeit_ru_start
TYPE dummy

Attributes:
alias Zeit runter start:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 21
webCmd state</nowiki>

;'''Zeit runter ende:'''

<nowiki>NAME du_Rollo_Zeit_ru_ende
TYPE dummy

Attributes:
alias Zeit runter ende:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 22
webCmd state</nowiki>

===DOIFs===

'''di_EG_ku_RO_StrasseLinks'''

Dieses DOIF beachtet den Helligkeitswert und den Modus "Weihnachten".
D.h., daß dieser Rollo erst am Ende des definierten Zeitraums herunterfährt.

<nowiki>([du_Rollo_Master] eq "an" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru] and
[du_Rollo_Art] ne "Weihnachten" and
[{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]))
(set EG_ku_RO_StrasseLinks on)</nowiki>

'''di_EG_ku_RO_StrasseRechts'''

Hier wird ein Fensterkontakt mit in die Schaltung einbezogen.
D.h. während des definierten Zeitraums gehen Rollos hoch, wenn eine Tür oder ein Fenster geöffnet wird. Ebenso wieder runter, sofern der Kontakt wieder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_ku_TK_Strasse] eq "closed" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseRechts off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_ku_TK_Strasse:state] eq "open"))
(set EG_ku_RO_StrasseRechts on)</nowiki>

'''di_EG_wz_RO_TerrasseLinks'''

Dieses DOIF beachtet einen Fensterkontakt und bezieht die Photovoltaikanlage mit ein.
Dieser Rollo geht während des Zeitraums der Dunkelheit rauf und runter, sofern der Türkontakt geöffnet oder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and (([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]))
(set EG_wz_RO_TerrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8]
or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_wz_TK_Terrasse] eq "open"))
(set EG_wz_RO_TerrasseLinks on)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 2100)
(set EG_wz_RO_TerrasseLinks 0)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 1501)
(set EG_wz_RO_TerrasseLinks 30)
DOELSEIF ([du_Rollo_PV] eq "aus")
(set EG_wz_RO_TerrasseLinks on)

wait 0:0:300:300:0 </nowiki>

Alle anderen Aktoren sind vereinfachte Versionen der genannten DOIFs und werden daher hier nicht genannt.

'''di_Rollo_Art'''

Dieses DOIF enabled und disabled einen Randomtimer, welcher ein Zufallslicht schaltet.

<nowiki>([du_Rollo_Art:state] eq "Urlaub") (attr UrlaubTimer disable 0, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 0)
DOELSE ([du_Rollo_Art:state] ne "Urlaub") (attr UrlaubTimer disable 1, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 1)</nowiki>

Hier folgt nun das mMn wichtigste DOIF.
Sofern manuelle Änderungen in den Text- bzw Zeitdummys durchgeführt werden, aktualisiert dieses DOIF die Definitionen der Rollo-DOIFs.
Dadurch werden die neuen Werte aus den Dummys für die Timer der DOIFs aktualisiert.

Auch aktualisiert dieses DOIF bei einem Neustart von FHEM die DOIFs.
Andernfalls würden die Defaultwerte der ReadingsVal(...) in den Definitionen die Defaultwerte zurückliefern.

'''di_Rollo_SetTime'''

<nowiki>([global:?INITIALIZED] or [du_Rollo_Zeit_ho:?] or [du_Rollo_Zeit_ho_WE:?] or [du_Rollo_Luminosity_ru:?]
or [du_Rollo_Zeit_ru_start:?] or [du_Rollo_Zeit_ru_ende:?]) (modify di_EG_ku_RO_StrasseLinks [di_EG_ku_RO_StrasseLinks:&DEF],
modify di_EG_ku_RO_StrasseRechts [di_EG_ku_RO_StrasseRechts:&DEF],
modify di_EG_wz_RO_Carport [di_EG_wz_RO_Carport:&DEF], modify di_EG_wz_RO_TerrasseLinks [di_EG_wz_RO_TerrasseLinks:&DEF],
modify di_EG_wz_RO_TerrasseRechts [di_EG_wz_RO_TerrasseRechts:&DEF], modify di_OG_elt_RO_Strasse [di_OG_elt_RO_Strasse:&DEF],
modify di_OG_ki1_RO_Carport [di_OG_ki1_RO_Carport:&DEF], modify di_OG_ki1_RO_Garten [di_OG_ki1_RO_Garten:&DEF],
modify di_OG_ki2_RO_Garten [di_OG_ki2_RO_Garten:&DEF])</nowiki>

===ReadingsGroup===

Hier seien noch die beiden ReadingsGroup aufgeführt, welche im Dashboard dargestellt werden.

Folgende Funktionen sind in der myRollosUtils gespeichert und dienen der Bedienung ausgehend aus den ReadingsGroups.

<nowiki>############## Rollos hoch/runter in Readingsgroup

sub myRollosUtils_RollosUpDown($$) {
my($DEVICE,$CMD) = @_;

my $icon = $CMD;
my $link;

if( $CMD eq "up" ) {
$icon = "remotecontrol/black_btn_CHUP";
$link = "setreading $DEVICE cmd-new on";
} elsif( $CMD eq "down" ) {
$icon = "remotecontrol/black_btn_CHDOWN";
$link = "setreading $DEVICE cmd-new off";
} elsif( $CMD eq "stop" ) {
$icon = "remotecontrol/black_btn_STOP";
$link = "setreading $DEVICE cmd-new stop";
}

my $notify = "no_RollosUpDown";
if( !defined($defs{$notify}) ) {
CommandDefine(undef,
"$notify notify .*:cmd-new.* "
."{ myRollos_RollosUpDownNotify(\$NAME,\$EVTPART1); }" );
}

my $ret = "%$icon";
$ret .= "%$link" if( $link );

return $ret;
}

sub myRollosUtils_RollosUpDownNotify($$) {
my($DEVICE,$CMD) = @_;

return if( $CMD eq "" );

CommandSet(undef, "$DEVICE $CMD");

return undef;
}

sub myRollosUtils_RollosIcon($) {
my($DEVICE) = @_;
my $level = ReadingsVal($DEVICE,"level", "0");
my $pct = ReadingsVal($DEVICE, "pct", "0");

my $ret = int((100 - $level)/10)*10;

my $icon;
if ($ret eq "0") {
$icon = "fts_window_2w\@orange";
} else {
$icon = "fts_shutter_".$ret."\@orange";
}

return $pct." %";
}
</nowiki>

'''EG_rg_Rolllaeden'''

<nowiki>EG.*_RO_S.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_C.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_T.*:level,
<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_M.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}>

Attributes:
group Rollos/Markise_EG
mapping %ALIAS
valueFormat {pct => "%.1f"}
valueIcon %VALUE </nowiki>

===Notify===

Ein Notify ist für die Bedienung ausgehend aus den ReadingsGroup notwendig.

<nowiki>DEF .*:cmd-new.* { myRollosUtils_RollosUpDownNotify($NAME,$EVTPART1); }
NAME no_RollosUpDown
TYPE notify

Attributes:
group notify</nowiki>

Rolladensteuerung mit Eingabemöglichkeiten

2015-02-11T18:22:47Z

Max: /* DOIFs */

In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere.

==Grundsätzliche Beschreibung==
Meine Rollläden im Haus sind allesamt mit HM Aktoren versehen, welche ich nachträglich UP gelegt habe.
Vorher waren die Rolläden manuell bedienbar gewesen.

Da ich eine Photovoltaikanlage besitze habe ich ein kleines Modul geschrieben, welches mir die Ertragsleistung in FHEM darstellt.
Anhand dieser Werte steuere ich Rolläden, welche zur Südseite gerichtet sind. Dadurch wird dann dynamisch die Sonneneinstrahlung und damit die Erwärmung der Zimmer eingestellt.
Zwischenzeitlich ist ein Helligkeitssensor installiert worden. Dieser sorgt für das Herunterfahren der Rolläden bei Eintreten der Dunkelheit.

Dieser Wert korreliert zwar mit den Werten der PV Anlage, dies habe ich aber bislang noch nicht aufgelöst.

==Komponenten==
1. HM Funk-Jalousieaktor HM-LC-Bi1PBU-FM

2. Solarlog-Modul

3. Helligkeitssensor aus diesem Posting
[http://forum.fhem.de/index.php/topic,20620.0.html Selbstbau HM_WDS10_TH_O mit Luftdruckmessung]

==Visualisierung==
Hier ist der Status eines jeden Rolladens ersichtlich und dieser ist bedienbar.

[[Datei:Dashboard01.png]]

Über diese Einstellungsseite können diverse Parameter der Steuerung gesetzt werden.

[[Datei:Dashboard02.png]]

==Einstellungen==
;'''Automatik aktiv:'''
:Hiermit wird die komplette Steuerung der Rolläden ein- bzw ausgeschaltet.
:Sofern der Modus "aus" aktiv ist, werden meine Rolläden lediglich über die Aktoren direkt oder eine HM Fernbedienung gesteuert.

;'''Art:'''
:Hier werden derzeit drei Modi unterstützt:

:''1. Normal''
:Bei diesem Modus fahren die Rollläden zu den definierten Zeiten hoch. Dabei wird eine Unterscheidung zwischen Wochentagen und Wochenenden berücksichtigt. Ausserdem werden mit Hilfe einer Holiday-Datei auch Feiertage und Urlaube berücksichtigt.
:Abends ist ein Zeitraum und ein Helligkeitswert definiert. Sobald dieser Helligkeitswert in dem Zeitfenster unterschritten wird, fahren die Rolläden runter. Spätestens aber zum Ende des Zeitfensters.

:''2. Weihnachten''
:Vom Prinzip arbeitet dieser Modus wie der Modus "Normal". Lediglich ein Rolladen fährt zum Ende des Zeitfensters runter und nicht bei Unterschreitung des Helligkeitswertes, damit die Weihnachtsaussenbeleuchtung auch von innen begutachtet werden kann.

:''3. Urlaub''
:Dieser Modus schaltet die Rolläden genauso wie der Modus "Normal". Des Weiteren aktiviere ich noch eine Zufallssteuerung für eine Anwesenheitsbeleuchtung.

;'''PV:'''
:Hiermit wird der Ertrag der Photovoltaikanlage mit einbezogen, damit die Rolläden zur Südseite anhand definierter Werte geschaltet werden.

;'''Zeit hoch:'''
:Hier wird der Zeitpunkt definiert, wann die Rollläden an Werktagen geöffnet werden sollen.

;'''Zeit hoch WE:'''
:Dies definiert die Zeit, wann die Rolläden am Wochenende bzw an Tagen, welche in einer Holiday Datei definiert sind hoch gehen sollen.

;'''Helligkeit runter:'''
:Dieser Wert ist der untere Schwellwert des Helligkeitssensors, ab wann die Rolläden in dem definierten Zeitraum geschlossen werden sollen.

;'''Zeit runter start:'''
:Ab dieser Zeit fahren die Rolläden bei Erreichen des Helligkeitswertes runter. Sofern eventuelle Tür-/Fensterkontakte den Status "closed" aufweisen. Während des Zeitraums gehen diese Rolläden hoch und auch wieder runter, sofern eine Tür/ein Fenster geöffnet bzw geschlossen wird.

;'''Zeit runter ende:'''
:Dies ist das Ende des Zeitraums. Wenn bis dahin die Helligkeit nicht unterschritten wurde, fahren die Rolläden nun spätestens runter.

==Codierung==
Meine Aktoren haben den folgenden Aufbau, was den Namen angeht:

'''OG_ki1_RO_Carport'''

Die ersten zwei Zeichen geben das Geschoss an.
Die Zeichen 4-6 beschreiben das Zimmer.
Die Zeichen 8 und 9 stellen die Art des Aktors dar.
Ab Zeichen 11 wird noch weiter beschrieben, wenn es mehrere Aktoren in einem Zimmer gibt.

===Dummys===
Beginnen möchte ich hier mit den Dummys, welche die Konfiguration der Steuerung darstellen.

;'''Automatik aktiv:'''

<nowiki>NAME du_Rollo_Master
TYPE dummy

Attributes:
alias Automatik aktiv:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_automatic
room LichtRollo
setList state:an,aus
sortby 01
webCmd state</nowiki>

;'''Art:'''

<nowiki>NAME du_Rollo_Art
TYPE dummy

Attributes:
alias Art:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_updown
room LichtRollo
setList state:Normal,Urlaub,Weihnachten
sortby 02
webCmd state</nowiki>

;'''PV:'''

<nowiki>NAME du_Rollo_PV
TYPE dummy

Attributes:
alias PV:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon weather_sun
room LichtRollo
setList state:an,aus
sortby 03
webCmd state</nowiki>

;'''Zeit hoch:'''

<nowiki>NAME du_Rollo_Zeit_ho
TYPE dummy

Attributes:
alias Zeit hoch:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 10
webCmd state</nowiki>

;'''Zeit hoch WE:'''

<nowiki> NAME du_Rollo_Zeit_ho_WE
TYPE dummy

Attributes:
alias Zeit hoch WE:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 11
webCmd state</nowiki>

;'''Helligkeit runter:'''

<nowiki>NAME du_Rollo_Luminosity_ru
TYPE dummy

Attributes:
alias Helligkeit runter
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon sani_solar
room LichtRollo
setList state:textField
sortby 20
webCmd state</nowiki>

;'''Zeit runter start:'''

<nowiki>NAME du_Rollo_Zeit_ru_start
TYPE dummy

Attributes:
alias Zeit runter start:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 21
webCmd state</nowiki>

;'''Zeit runter ende:'''

<nowiki>NAME du_Rollo_Zeit_ru_ende
TYPE dummy

Attributes:
alias Zeit runter ende:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 22
webCmd state</nowiki>

===DOIFs===

'''di_EG_ku_RO_StrasseLinks'''

Dieses DOIF beachtet den Helligkeitswert und den Modus "Weihnachten".
D.h., daß dieser Rollo erst am Ende des definierten Zeitraums herunterfährt.

<nowiki>([du_Rollo_Master] eq "an" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru] and
[du_Rollo_Art] ne "Weihnachten" and
[{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]))
(set EG_ku_RO_StrasseLinks on)</nowiki>

'''di_EG_ku_RO_StrasseRechts'''

Hier wird ein Fensterkontakt mit in die Schaltung einbezogen.
D.h. während des definierten Zeitraums gehen Rollos hoch, wenn eine Tür oder ein Fenster geöffnet wird. Ebenso wieder runter, sofern der Kontakt wieder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_ku_TK_Strasse] eq "closed" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseRechts off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_ku_TK_Strasse:state] eq "open"))
(set EG_ku_RO_StrasseRechts on)</nowiki>

'''di_EG_wz_RO_TerrasseLinks'''

Dieses DOIF beachtet einen Fensterkontakt und bezieht die Photovoltaikanlage mit ein.
Dieser Rollo geht während des Zeitraums der Dunkelheit rauf und runter, sofern der Türkontakt geöffnet oder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and (([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]))
(set EG_wz_RO_TerrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8]
or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_wz_TK_Terrasse] eq "open"))
(set EG_wz_RO_TerrasseLinks on)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 2100)
(set EG_wz_RO_TerrasseLinks 0)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 1501)
(set EG_wz_RO_TerrasseLinks 30)
DOELSEIF ([du_Rollo_PV] eq "aus")
(set EG_wz_RO_TerrasseLinks on)

wait 0:0:300:300:0 </nowiki>

Alle anderen Aktoren sind vereinfachte Versionen der genannten DOIFs und werden daher hier nicht genannt.

'''di_Rollo_Art'''

Dieses DOIF enabled und disabled einen Randomtimer, welcher ein Zufallslicht schaltet.

<nowiki>([du_Rollo_Art:state] eq "Urlaub") (attr UrlaubTimer disable 0, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 0)
DOELSE ([du_Rollo_Art:state] ne "Urlaub") (attr UrlaubTimer disable 1, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 1)</nowiki>

Hier folgt nun das mMn wichtigste DOIF.
Sofern manuelle Änderungen in den Text- bzw Zeitdummys durchgeführt werden, aktualisiert dieses DOIF die Definitionen der Rollo-DOIFs.
Dadurch werden die neuen Werte aus den Dummys für die Timer der DOIFs aktualisiert.

Auch aktualisiert dieses DOIF bei einem Neustart von FHEM die DOIFs.
Andernfalls würden die Defaultwerte der ReadingsVal(...) in den Definitionen die Defaultwerte zurückliefern.

'''di_Rollo_SetTime'''

<nowiki>([global:?INITIALIZED] or [du_Rollo_Zeit_ho:?] or [du_Rollo_Zeit_ho_WE:?] or [du_Rollo_Luminosity_ru:?]
or [du_Rollo_Zeit_ru_start:?] or [du_Rollo_Zeit_ru_ende:?]) (modify di_EG_ku_RO_StrasseLinks [di_EG_ku_RO_StrasseLinks:&DEF],
modify di_EG_ku_RO_StrasseRechts [di_EG_ku_RO_StrasseRechts:&DEF],
modify di_EG_wz_RO_Carport [di_EG_wz_RO_Carport:&DEF], modify di_EG_wz_RO_TerrasseLinks [di_EG_wz_RO_TerrasseLinks:&DEF],
modify di_EG_wz_RO_TerrasseRechts [di_EG_wz_RO_TerrasseRechts:&DEF], modify di_OG_elt_RO_Strasse [di_OG_elt_RO_Strasse:&DEF],
modify di_OG_ki1_RO_Carport [di_OG_ki1_RO_Carport:&DEF], modify di_OG_ki1_RO_Garten [di_OG_ki1_RO_Garten:&DEF],
modify di_OG_ki2_RO_Garten [di_OG_ki2_RO_Garten:&DEF])</nowiki>

===ReadingsGroup===

Hier seien noch die beiden ReadingsGroup aufgeführt, welche im Dashboard dargestellt werden.

Folgende Funktionen sind in der myRollosUtils gespeichert und dienen der Bedienung ausgehend aus den ReadingsGroups.

<nowiki>############## Rollos hoch/runter in Readingsgroup

sub myRollosUtils_RollosUpDown($$) {
my($DEVICE,$CMD) = @_;

my $icon = $CMD;
my $link;

if( $CMD eq "up" ) {
$icon = "remotecontrol/black_btn_CHUP";
$link = "setreading $DEVICE cmd-new on";
} elsif( $CMD eq "down" ) {
$icon = "remotecontrol/black_btn_CHDOWN";
$link = "setreading $DEVICE cmd-new off";
} elsif( $CMD eq "stop" ) {
$icon = "remotecontrol/black_btn_STOP";
$link = "setreading $DEVICE cmd-new stop";
}

my $notify = "no_RollosUpDown";
if( !defined($defs{$notify}) ) {
CommandDefine(undef,
"$notify notify .*:cmd-new.* "
."{ myRollos_RollosUpDownNotify(\$NAME,\$EVTPART1); }" );
}

my $ret = "%$icon";
$ret .= "%$link" if( $link );

return $ret;
}

sub myRollosUtils_RollosUpDownNotify($$) {
my($DEVICE,$CMD) = @_;

return if( $CMD eq "" );

CommandSet(undef, "$DEVICE $CMD");

return undef;
}

sub myRollosUtils_RollosIcon($) {
my($DEVICE) = @_;
my $level = ReadingsVal($DEVICE,"level", "0");
my $pct = ReadingsVal($DEVICE, "pct", "0");

my $ret = int((100 - $level)/10)*10;

my $icon;
if ($ret eq "0") {
$icon = "fts_window_2w\@orange";
} else {
$icon = "fts_shutter_".$ret."\@orange";
}

return $pct." %";
}
</nowiki>

'''EG_rg_Rolllaeden'''

<nowiki>EG.*_RO_S.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_C.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_T.*:level,
<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_M.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}>

Attributes:
group Rollos/Markise_EG
mapping %ALIAS
valueFormat {pct => "%.1f"}
valueIcon %VALUE </nowiki>

===Notify===

Ein Notify ist für die Bedienung ausgehend aus den ReadingsGroup notwendig.

<nowiki>DEF .*:cmd-new.* { myRollosUtils_RollosUpDownNotify($NAME,$EVTPART1); }
NAME no_RollosUpDown
TYPE notify

Attributes:
group notify</nowiki>

Rolladensteuerung mit Eingabemöglichkeiten

2015-02-11T18:22:13Z

Max: /* ReadingsGroup */

In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere.

==Grundsätzliche Beschreibung==
Meine Rollläden im Haus sind allesamt mit HM Aktoren versehen, welche ich nachträglich UP gelegt habe.
Vorher waren die Rolläden manuell bedienbar gewesen.

Da ich eine Photovoltaikanlage besitze habe ich ein kleines Modul geschrieben, welches mir die Ertragsleistung in FHEM darstellt.
Anhand dieser Werte steuere ich Rolläden, welche zur Südseite gerichtet sind. Dadurch wird dann dynamisch die Sonneneinstrahlung und damit die Erwärmung der Zimmer eingestellt.
Zwischenzeitlich ist ein Helligkeitssensor installiert worden. Dieser sorgt für das Herunterfahren der Rolläden bei Eintreten der Dunkelheit.

Dieser Wert korreliert zwar mit den Werten der PV Anlage, dies habe ich aber bislang noch nicht aufgelöst.

==Komponenten==
1. HM Funk-Jalousieaktor HM-LC-Bi1PBU-FM

2. Solarlog-Modul

3. Helligkeitssensor aus diesem Posting
[http://forum.fhem.de/index.php/topic,20620.0.html Selbstbau HM_WDS10_TH_O mit Luftdruckmessung]

==Visualisierung==
Hier ist der Status eines jeden Rolladens ersichtlich und dieser ist bedienbar.

[[Datei:Dashboard01.png]]

Über diese Einstellungsseite können diverse Parameter der Steuerung gesetzt werden.

[[Datei:Dashboard02.png]]

==Einstellungen==
;'''Automatik aktiv:'''
:Hiermit wird die komplette Steuerung der Rolläden ein- bzw ausgeschaltet.
:Sofern der Modus "aus" aktiv ist, werden meine Rolläden lediglich über die Aktoren direkt oder eine HM Fernbedienung gesteuert.

;'''Art:'''
:Hier werden derzeit drei Modi unterstützt:

:''1. Normal''
:Bei diesem Modus fahren die Rollläden zu den definierten Zeiten hoch. Dabei wird eine Unterscheidung zwischen Wochentagen und Wochenenden berücksichtigt. Ausserdem werden mit Hilfe einer Holiday-Datei auch Feiertage und Urlaube berücksichtigt.
:Abends ist ein Zeitraum und ein Helligkeitswert definiert. Sobald dieser Helligkeitswert in dem Zeitfenster unterschritten wird, fahren die Rolläden runter. Spätestens aber zum Ende des Zeitfensters.

:''2. Weihnachten''
:Vom Prinzip arbeitet dieser Modus wie der Modus "Normal". Lediglich ein Rolladen fährt zum Ende des Zeitfensters runter und nicht bei Unterschreitung des Helligkeitswertes, damit die Weihnachtsaussenbeleuchtung auch von innen begutachtet werden kann.

:''3. Urlaub''
:Dieser Modus schaltet die Rolläden genauso wie der Modus "Normal". Des Weiteren aktiviere ich noch eine Zufallssteuerung für eine Anwesenheitsbeleuchtung.

;'''PV:'''
:Hiermit wird der Ertrag der Photovoltaikanlage mit einbezogen, damit die Rolläden zur Südseite anhand definierter Werte geschaltet werden.

;'''Zeit hoch:'''
:Hier wird der Zeitpunkt definiert, wann die Rollläden an Werktagen geöffnet werden sollen.

;'''Zeit hoch WE:'''
:Dies definiert die Zeit, wann die Rolläden am Wochenende bzw an Tagen, welche in einer Holiday Datei definiert sind hoch gehen sollen.

;'''Helligkeit runter:'''
:Dieser Wert ist der untere Schwellwert des Helligkeitssensors, ab wann die Rolläden in dem definierten Zeitraum geschlossen werden sollen.

;'''Zeit runter start:'''
:Ab dieser Zeit fahren die Rolläden bei Erreichen des Helligkeitswertes runter. Sofern eventuelle Tür-/Fensterkontakte den Status "closed" aufweisen. Während des Zeitraums gehen diese Rolläden hoch und auch wieder runter, sofern eine Tür/ein Fenster geöffnet bzw geschlossen wird.

;'''Zeit runter ende:'''
:Dies ist das Ende des Zeitraums. Wenn bis dahin die Helligkeit nicht unterschritten wurde, fahren die Rolläden nun spätestens runter.

==Codierung==
Meine Aktoren haben den folgenden Aufbau, was den Namen angeht:

'''OG_ki1_RO_Carport'''

Die ersten zwei Zeichen geben das Geschoss an.
Die Zeichen 4-6 beschreiben das Zimmer.
Die Zeichen 8 und 9 stellen die Art des Aktors dar.
Ab Zeichen 11 wird noch weiter beschrieben, wenn es mehrere Aktoren in einem Zimmer gibt.

===Dummys===
Beginnen möchte ich hier mit den Dummys, welche die Konfiguration der Steuerung darstellen.

;'''Automatik aktiv:'''

<nowiki>NAME du_Rollo_Master
TYPE dummy

Attributes:
alias Automatik aktiv:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_automatic
room LichtRollo
setList state:an,aus
sortby 01
webCmd state</nowiki>

;'''Art:'''

<nowiki>NAME du_Rollo_Art
TYPE dummy

Attributes:
alias Art:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_updown
room LichtRollo
setList state:Normal,Urlaub,Weihnachten
sortby 02
webCmd state</nowiki>

;'''PV:'''

<nowiki>NAME du_Rollo_PV
TYPE dummy

Attributes:
alias PV:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon weather_sun
room LichtRollo
setList state:an,aus
sortby 03
webCmd state</nowiki>

;'''Zeit hoch:'''

<nowiki>NAME du_Rollo_Zeit_ho
TYPE dummy

Attributes:
alias Zeit hoch:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 10
webCmd state</nowiki>

;'''Zeit hoch WE:'''

<nowiki> NAME du_Rollo_Zeit_ho_WE
TYPE dummy

Attributes:
alias Zeit hoch WE:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 11
webCmd state</nowiki>

;'''Helligkeit runter:'''

<nowiki>NAME du_Rollo_Luminosity_ru
TYPE dummy

Attributes:
alias Helligkeit runter
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon sani_solar
room LichtRollo
setList state:textField
sortby 20
webCmd state</nowiki>

;'''Zeit runter start:'''

<nowiki>NAME du_Rollo_Zeit_ru_start
TYPE dummy

Attributes:
alias Zeit runter start:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 21
webCmd state</nowiki>

;'''Zeit runter ende:'''

<nowiki>NAME du_Rollo_Zeit_ru_ende
TYPE dummy

Attributes:
alias Zeit runter ende:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 22
webCmd state</nowiki>

===DOIFs===

'''di_EG_ku_RO_StrasseLinks'''

Dieses DOIF beachtet den Helligkeitswert und den Modus "Weihnachten".
D.h., daß dieser Rollo erst am Ende des definierten Zeitraums herunterfährt.

<nowiki>([du_Rollo_Master] eq "an" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru] and
[du_Rollo_Art] ne "Weihnachten" and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]))
(set EG_ku_RO_StrasseLinks on)</nowiki>

'''di_EG_ku_RO_StrasseRechts'''

Hier wird ein Fensterkontakt mit in die Schaltung einbezogen.
D.h. während des definierten Zeitraums gehen Rollos hoch, wenn eine Tür oder ein Fenster geöffnet wird. Ebenso wieder runter, sofern der Kontakt wieder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_ku_TK_Strasse] eq "closed" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseRechts off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_ku_TK_Strasse:state] eq "open"))
(set EG_ku_RO_StrasseRechts on)</nowiki>

'''di_EG_wz_RO_TerrasseLinks'''

Dieses DOIF beachtet einen Fensterkontakt und bezieht die Photovoltaikanlage mit ein.
Dieser Rollo geht während des Zeitraums der Dunkelheit rauf und runter, sofern der Türkontakt geöffnet oder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and (([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]))
(set EG_wz_RO_TerrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8]
or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_wz_TK_Terrasse] eq "open"))
(set EG_wz_RO_TerrasseLinks on)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 2100)
(set EG_wz_RO_TerrasseLinks 0)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 1501)
(set EG_wz_RO_TerrasseLinks 30)
DOELSEIF ([du_Rollo_PV] eq "aus")
(set EG_wz_RO_TerrasseLinks on)

wait 0:0:300:300:0 </nowiki>

Alle anderen Aktoren sind vereinfachte Versionen der genannten DOIFs und werden daher hier nicht genannt.

'''di_Rollo_Art'''

Dieses DOIF enabled und disabled einen Randomtimer, welcher ein Zufallslicht schaltet.

<nowiki>([du_Rollo_Art:state] eq "Urlaub") (attr UrlaubTimer disable 0, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 0)
DOELSE ([du_Rollo_Art:state] ne "Urlaub") (attr UrlaubTimer disable 1, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 1)</nowiki>

Hier folgt nun das mMn wichtigste DOIF.
Sofern manuelle Änderungen in den Text- bzw Zeitdummys durchgeführt werden, aktualisiert dieses DOIF die Definitionen der Rollo-DOIFs.
Dadurch werden die neuen Werte aus den Dummys für die Timer der DOIFs aktualisiert.

Auch aktualisiert dieses DOIF bei einem Neustart von FHEM die DOIFs.
Andernfalls würden die Defaultwerte der ReadingsVal(...) in den Definitionen die Defaultwerte zurückliefern.

'''di_Rollo_SetTime'''

<nowiki>([global:?INITIALIZED] or [du_Rollo_Zeit_ho:?] or [du_Rollo_Zeit_ho_WE:?] or [du_Rollo_Luminosity_ru:?]
or [du_Rollo_Zeit_ru_start:?] or [du_Rollo_Zeit_ru_ende:?]) (modify di_EG_ku_RO_StrasseLinks [di_EG_ku_RO_StrasseLinks:&DEF],
modify di_EG_ku_RO_StrasseRechts [di_EG_ku_RO_StrasseRechts:&DEF],
modify di_EG_wz_RO_Carport [di_EG_wz_RO_Carport:&DEF], modify di_EG_wz_RO_TerrasseLinks [di_EG_wz_RO_TerrasseLinks:&DEF],
modify di_EG_wz_RO_TerrasseRechts [di_EG_wz_RO_TerrasseRechts:&DEF], modify di_OG_elt_RO_Strasse [di_OG_elt_RO_Strasse:&DEF],
modify di_OG_ki1_RO_Carport [di_OG_ki1_RO_Carport:&DEF], modify di_OG_ki1_RO_Garten [di_OG_ki1_RO_Garten:&DEF],
modify di_OG_ki2_RO_Garten [di_OG_ki2_RO_Garten:&DEF])</nowiki>

===ReadingsGroup===

Hier seien noch die beiden ReadingsGroup aufgeführt, welche im Dashboard dargestellt werden.

Folgende Funktionen sind in der myRollosUtils gespeichert und dienen der Bedienung ausgehend aus den ReadingsGroups.

<nowiki>############## Rollos hoch/runter in Readingsgroup

sub myRollosUtils_RollosUpDown($$) {
my($DEVICE,$CMD) = @_;

my $icon = $CMD;
my $link;

if( $CMD eq "up" ) {
$icon = "remotecontrol/black_btn_CHUP";
$link = "setreading $DEVICE cmd-new on";
} elsif( $CMD eq "down" ) {
$icon = "remotecontrol/black_btn_CHDOWN";
$link = "setreading $DEVICE cmd-new off";
} elsif( $CMD eq "stop" ) {
$icon = "remotecontrol/black_btn_STOP";
$link = "setreading $DEVICE cmd-new stop";
}

my $notify = "no_RollosUpDown";
if( !defined($defs{$notify}) ) {
CommandDefine(undef,
"$notify notify .*:cmd-new.* "
."{ myRollos_RollosUpDownNotify(\$NAME,\$EVTPART1); }" );
}

my $ret = "%$icon";
$ret .= "%$link" if( $link );

return $ret;
}

sub myRollosUtils_RollosUpDownNotify($$) {
my($DEVICE,$CMD) = @_;

return if( $CMD eq "" );

CommandSet(undef, "$DEVICE $CMD");

return undef;
}

sub myRollosUtils_RollosIcon($) {
my($DEVICE) = @_;
my $level = ReadingsVal($DEVICE,"level", "0");
my $pct = ReadingsVal($DEVICE, "pct", "0");

my $ret = int((100 - $level)/10)*10;

my $icon;
if ($ret eq "0") {
$icon = "fts_window_2w\@orange";
} else {
$icon = "fts_shutter_".$ret."\@orange";
}

return $pct." %";
}
</nowiki>

'''EG_rg_Rolllaeden'''

<nowiki>EG.*_RO_S.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_C.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_T.*:level,
<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_M.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,
<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}>

Attributes:
group Rollos/Markise_EG
mapping %ALIAS
valueFormat {pct => "%.1f"}
valueIcon %VALUE </nowiki>

===Notify===

Ein Notify ist für die Bedienung ausgehend aus den ReadingsGroup notwendig.

<nowiki>DEF .*:cmd-new.* { myRollosUtils_RollosUpDownNotify($NAME,$EVTPART1); }
NAME no_RollosUpDown
TYPE notify

Attributes:
group notify</nowiki>

Rolladensteuerung mit Eingabemöglichkeiten

2015-02-11T18:21:38Z

Max: /* DOIFs */

In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere.

==Grundsätzliche Beschreibung==
Meine Rollläden im Haus sind allesamt mit HM Aktoren versehen, welche ich nachträglich UP gelegt habe.
Vorher waren die Rolläden manuell bedienbar gewesen.

Da ich eine Photovoltaikanlage besitze habe ich ein kleines Modul geschrieben, welches mir die Ertragsleistung in FHEM darstellt.
Anhand dieser Werte steuere ich Rolläden, welche zur Südseite gerichtet sind. Dadurch wird dann dynamisch die Sonneneinstrahlung und damit die Erwärmung der Zimmer eingestellt.
Zwischenzeitlich ist ein Helligkeitssensor installiert worden. Dieser sorgt für das Herunterfahren der Rolläden bei Eintreten der Dunkelheit.

Dieser Wert korreliert zwar mit den Werten der PV Anlage, dies habe ich aber bislang noch nicht aufgelöst.

==Komponenten==
1. HM Funk-Jalousieaktor HM-LC-Bi1PBU-FM

2. Solarlog-Modul

3. Helligkeitssensor aus diesem Posting
[http://forum.fhem.de/index.php/topic,20620.0.html Selbstbau HM_WDS10_TH_O mit Luftdruckmessung]

==Visualisierung==
Hier ist der Status eines jeden Rolladens ersichtlich und dieser ist bedienbar.

[[Datei:Dashboard01.png]]

Über diese Einstellungsseite können diverse Parameter der Steuerung gesetzt werden.

[[Datei:Dashboard02.png]]

==Einstellungen==
;'''Automatik aktiv:'''
:Hiermit wird die komplette Steuerung der Rolläden ein- bzw ausgeschaltet.
:Sofern der Modus "aus" aktiv ist, werden meine Rolläden lediglich über die Aktoren direkt oder eine HM Fernbedienung gesteuert.

;'''Art:'''
:Hier werden derzeit drei Modi unterstützt:

:''1. Normal''
:Bei diesem Modus fahren die Rollläden zu den definierten Zeiten hoch. Dabei wird eine Unterscheidung zwischen Wochentagen und Wochenenden berücksichtigt. Ausserdem werden mit Hilfe einer Holiday-Datei auch Feiertage und Urlaube berücksichtigt.
:Abends ist ein Zeitraum und ein Helligkeitswert definiert. Sobald dieser Helligkeitswert in dem Zeitfenster unterschritten wird, fahren die Rolläden runter. Spätestens aber zum Ende des Zeitfensters.

:''2. Weihnachten''
:Vom Prinzip arbeitet dieser Modus wie der Modus "Normal". Lediglich ein Rolladen fährt zum Ende des Zeitfensters runter und nicht bei Unterschreitung des Helligkeitswertes, damit die Weihnachtsaussenbeleuchtung auch von innen begutachtet werden kann.

:''3. Urlaub''
:Dieser Modus schaltet die Rolläden genauso wie der Modus "Normal". Des Weiteren aktiviere ich noch eine Zufallssteuerung für eine Anwesenheitsbeleuchtung.

;'''PV:'''
:Hiermit wird der Ertrag der Photovoltaikanlage mit einbezogen, damit die Rolläden zur Südseite anhand definierter Werte geschaltet werden.

;'''Zeit hoch:'''
:Hier wird der Zeitpunkt definiert, wann die Rollläden an Werktagen geöffnet werden sollen.

;'''Zeit hoch WE:'''
:Dies definiert die Zeit, wann die Rolläden am Wochenende bzw an Tagen, welche in einer Holiday Datei definiert sind hoch gehen sollen.

;'''Helligkeit runter:'''
:Dieser Wert ist der untere Schwellwert des Helligkeitssensors, ab wann die Rolläden in dem definierten Zeitraum geschlossen werden sollen.

;'''Zeit runter start:'''
:Ab dieser Zeit fahren die Rolläden bei Erreichen des Helligkeitswertes runter. Sofern eventuelle Tür-/Fensterkontakte den Status "closed" aufweisen. Während des Zeitraums gehen diese Rolläden hoch und auch wieder runter, sofern eine Tür/ein Fenster geöffnet bzw geschlossen wird.

;'''Zeit runter ende:'''
:Dies ist das Ende des Zeitraums. Wenn bis dahin die Helligkeit nicht unterschritten wurde, fahren die Rolläden nun spätestens runter.

==Codierung==
Meine Aktoren haben den folgenden Aufbau, was den Namen angeht:

'''OG_ki1_RO_Carport'''

Die ersten zwei Zeichen geben das Geschoss an.
Die Zeichen 4-6 beschreiben das Zimmer.
Die Zeichen 8 und 9 stellen die Art des Aktors dar.
Ab Zeichen 11 wird noch weiter beschrieben, wenn es mehrere Aktoren in einem Zimmer gibt.

===Dummys===
Beginnen möchte ich hier mit den Dummys, welche die Konfiguration der Steuerung darstellen.

;'''Automatik aktiv:'''

<nowiki>NAME du_Rollo_Master
TYPE dummy

Attributes:
alias Automatik aktiv:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_automatic
room LichtRollo
setList state:an,aus
sortby 01
webCmd state</nowiki>

;'''Art:'''

<nowiki>NAME du_Rollo_Art
TYPE dummy

Attributes:
alias Art:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_updown
room LichtRollo
setList state:Normal,Urlaub,Weihnachten
sortby 02
webCmd state</nowiki>

;'''PV:'''

<nowiki>NAME du_Rollo_PV
TYPE dummy

Attributes:
alias PV:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon weather_sun
room LichtRollo
setList state:an,aus
sortby 03
webCmd state</nowiki>

;'''Zeit hoch:'''

<nowiki>NAME du_Rollo_Zeit_ho
TYPE dummy

Attributes:
alias Zeit hoch:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 10
webCmd state</nowiki>

;'''Zeit hoch WE:'''

<nowiki> NAME du_Rollo_Zeit_ho_WE
TYPE dummy

Attributes:
alias Zeit hoch WE:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 11
webCmd state</nowiki>

;'''Helligkeit runter:'''

<nowiki>NAME du_Rollo_Luminosity_ru
TYPE dummy

Attributes:
alias Helligkeit runter
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon sani_solar
room LichtRollo
setList state:textField
sortby 20
webCmd state</nowiki>

;'''Zeit runter start:'''

<nowiki>NAME du_Rollo_Zeit_ru_start
TYPE dummy

Attributes:
alias Zeit runter start:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 21
webCmd state</nowiki>

;'''Zeit runter ende:'''

<nowiki>NAME du_Rollo_Zeit_ru_ende
TYPE dummy

Attributes:
alias Zeit runter ende:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 22
webCmd state</nowiki>

===DOIFs===

'''di_EG_ku_RO_StrasseLinks'''

Dieses DOIF beachtet den Helligkeitswert und den Modus "Weihnachten".
D.h., daß dieser Rollo erst am Ende des definierten Zeitraums herunterfährt.

<nowiki>([du_Rollo_Master] eq "an" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru] and
[du_Rollo_Art] ne "Weihnachten" and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]))
(set EG_ku_RO_StrasseLinks on)</nowiki>

'''di_EG_ku_RO_StrasseRechts'''

Hier wird ein Fensterkontakt mit in die Schaltung einbezogen.
D.h. während des definierten Zeitraums gehen Rollos hoch, wenn eine Tür oder ein Fenster geöffnet wird. Ebenso wieder runter, sofern der Kontakt wieder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_ku_TK_Strasse] eq "closed" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseRechts off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_ku_TK_Strasse:state] eq "open"))
(set EG_ku_RO_StrasseRechts on)</nowiki>

'''di_EG_wz_RO_TerrasseLinks'''

Dieses DOIF beachtet einen Fensterkontakt und bezieht die Photovoltaikanlage mit ein.
Dieser Rollo geht während des Zeitraums der Dunkelheit rauf und runter, sofern der Türkontakt geöffnet oder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and (([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]))
(set EG_wz_RO_TerrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8]
or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_wz_TK_Terrasse] eq "open"))
(set EG_wz_RO_TerrasseLinks on)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 2100)
(set EG_wz_RO_TerrasseLinks 0)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 1501)
(set EG_wz_RO_TerrasseLinks 30)
DOELSEIF ([du_Rollo_PV] eq "aus")
(set EG_wz_RO_TerrasseLinks on)

wait 0:0:300:300:0 </nowiki>

Alle anderen Aktoren sind vereinfachte Versionen der genannten DOIFs und werden daher hier nicht genannt.

'''di_Rollo_Art'''

Dieses DOIF enabled und disabled einen Randomtimer, welcher ein Zufallslicht schaltet.

<nowiki>([du_Rollo_Art:state] eq "Urlaub") (attr UrlaubTimer disable 0, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 0)
DOELSE ([du_Rollo_Art:state] ne "Urlaub") (attr UrlaubTimer disable 1, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 1)</nowiki>

Hier folgt nun das mMn wichtigste DOIF.
Sofern manuelle Änderungen in den Text- bzw Zeitdummys durchgeführt werden, aktualisiert dieses DOIF die Definitionen der Rollo-DOIFs.
Dadurch werden die neuen Werte aus den Dummys für die Timer der DOIFs aktualisiert.

Auch aktualisiert dieses DOIF bei einem Neustart von FHEM die DOIFs.
Andernfalls würden die Defaultwerte der ReadingsVal(...) in den Definitionen die Defaultwerte zurückliefern.

'''di_Rollo_SetTime'''

<nowiki>([global:?INITIALIZED] or [du_Rollo_Zeit_ho:?] or [du_Rollo_Zeit_ho_WE:?] or [du_Rollo_Luminosity_ru:?]
or [du_Rollo_Zeit_ru_start:?] or [du_Rollo_Zeit_ru_ende:?]) (modify di_EG_ku_RO_StrasseLinks [di_EG_ku_RO_StrasseLinks:&DEF],
modify di_EG_ku_RO_StrasseRechts [di_EG_ku_RO_StrasseRechts:&DEF],
modify di_EG_wz_RO_Carport [di_EG_wz_RO_Carport:&DEF], modify di_EG_wz_RO_TerrasseLinks [di_EG_wz_RO_TerrasseLinks:&DEF],
modify di_EG_wz_RO_TerrasseRechts [di_EG_wz_RO_TerrasseRechts:&DEF], modify di_OG_elt_RO_Strasse [di_OG_elt_RO_Strasse:&DEF],
modify di_OG_ki1_RO_Carport [di_OG_ki1_RO_Carport:&DEF], modify di_OG_ki1_RO_Garten [di_OG_ki1_RO_Garten:&DEF],
modify di_OG_ki2_RO_Garten [di_OG_ki2_RO_Garten:&DEF])</nowiki>

===ReadingsGroup===

Hier seien noch die beiden ReadingsGroup aufgeführt, welche im Dashboard dargestellt werden.

Folgende Funktionen sind in der myRollosUtils gespeichert und dienen der Bedienung ausgehend aus den ReadingsGroups.

<nowiki>############## Rollos hoch/runter in Readingsgroup

sub myRollosUtils_RollosUpDown($$) {
my($DEVICE,$CMD) = @_;

my $icon = $CMD;
my $link;

if( $CMD eq "up" ) {
$icon = "remotecontrol/black_btn_CHUP";
$link = "setreading $DEVICE cmd-new on";
} elsif( $CMD eq "down" ) {
$icon = "remotecontrol/black_btn_CHDOWN";
$link = "setreading $DEVICE cmd-new off";
} elsif( $CMD eq "stop" ) {
$icon = "remotecontrol/black_btn_STOP";
$link = "setreading $DEVICE cmd-new stop";
}

my $notify = "no_RollosUpDown";
if( !defined($defs{$notify}) ) {
CommandDefine(undef,
"$notify notify .*:cmd-new.* "
."{ myRollos_RollosUpDownNotify(\$NAME,\$EVTPART1); }" );
}

my $ret = "%$icon";
$ret .= "%$link" if( $link );

return $ret;
}

sub myRollosUtils_RollosUpDownNotify($$) {
my($DEVICE,$CMD) = @_;

return if( $CMD eq "" );

CommandSet(undef, "$DEVICE $CMD");

return undef;
}

sub myRollosUtils_RollosIcon($) {
my($DEVICE) = @_;
my $level = ReadingsVal($DEVICE,"level", "0");
my $pct = ReadingsVal($DEVICE, "pct", "0");

my $ret = int((100 - $level)/10)*10;

my $icon;
if ($ret eq "0") {
$icon = "fts_window_2w\@orange";
} else {
$icon = "fts_shutter_".$ret."\@orange";
}

return $pct." %";
}
</nowiki>

'''EG_rg_Rolllaeden'''

<nowiki>EG.*_RO_S.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_C.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_T.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_M.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}>

Attributes:
group Rollos/Markise_EG
mapping %ALIAS
valueFormat {pct => "%.1f"}
valueIcon %VALUE </nowiki>

===Notify===

Ein Notify ist für die Bedienung ausgehend aus den ReadingsGroup notwendig.

<nowiki>DEF .*:cmd-new.* { myRollosUtils_RollosUpDownNotify($NAME,$EVTPART1); }
NAME no_RollosUpDown
TYPE notify

Attributes:
group notify</nowiki>

Rolladensteuerung mit Eingabemöglichkeiten

2015-02-11T18:19:38Z

Max: /* DOIFs */

In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere.

==Grundsätzliche Beschreibung==
Meine Rollläden im Haus sind allesamt mit HM Aktoren versehen, welche ich nachträglich UP gelegt habe.
Vorher waren die Rolläden manuell bedienbar gewesen.

Da ich eine Photovoltaikanlage besitze habe ich ein kleines Modul geschrieben, welches mir die Ertragsleistung in FHEM darstellt.
Anhand dieser Werte steuere ich Rolläden, welche zur Südseite gerichtet sind. Dadurch wird dann dynamisch die Sonneneinstrahlung und damit die Erwärmung der Zimmer eingestellt.
Zwischenzeitlich ist ein Helligkeitssensor installiert worden. Dieser sorgt für das Herunterfahren der Rolläden bei Eintreten der Dunkelheit.

Dieser Wert korreliert zwar mit den Werten der PV Anlage, dies habe ich aber bislang noch nicht aufgelöst.

==Komponenten==
1. HM Funk-Jalousieaktor HM-LC-Bi1PBU-FM

2. Solarlog-Modul

3. Helligkeitssensor aus diesem Posting
[http://forum.fhem.de/index.php/topic,20620.0.html Selbstbau HM_WDS10_TH_O mit Luftdruckmessung]

==Visualisierung==
Hier ist der Status eines jeden Rolladens ersichtlich und dieser ist bedienbar.

[[Datei:Dashboard01.png]]

Über diese Einstellungsseite können diverse Parameter der Steuerung gesetzt werden.

[[Datei:Dashboard02.png]]

==Einstellungen==
;'''Automatik aktiv:'''
:Hiermit wird die komplette Steuerung der Rolläden ein- bzw ausgeschaltet.
:Sofern der Modus "aus" aktiv ist, werden meine Rolläden lediglich über die Aktoren direkt oder eine HM Fernbedienung gesteuert.

;'''Art:'''
:Hier werden derzeit drei Modi unterstützt:

:''1. Normal''
:Bei diesem Modus fahren die Rollläden zu den definierten Zeiten hoch. Dabei wird eine Unterscheidung zwischen Wochentagen und Wochenenden berücksichtigt. Ausserdem werden mit Hilfe einer Holiday-Datei auch Feiertage und Urlaube berücksichtigt.
:Abends ist ein Zeitraum und ein Helligkeitswert definiert. Sobald dieser Helligkeitswert in dem Zeitfenster unterschritten wird, fahren die Rolläden runter. Spätestens aber zum Ende des Zeitfensters.

:''2. Weihnachten''
:Vom Prinzip arbeitet dieser Modus wie der Modus "Normal". Lediglich ein Rolladen fährt zum Ende des Zeitfensters runter und nicht bei Unterschreitung des Helligkeitswertes, damit die Weihnachtsaussenbeleuchtung auch von innen begutachtet werden kann.

:''3. Urlaub''
:Dieser Modus schaltet die Rolläden genauso wie der Modus "Normal". Des Weiteren aktiviere ich noch eine Zufallssteuerung für eine Anwesenheitsbeleuchtung.

;'''PV:'''
:Hiermit wird der Ertrag der Photovoltaikanlage mit einbezogen, damit die Rolläden zur Südseite anhand definierter Werte geschaltet werden.

;'''Zeit hoch:'''
:Hier wird der Zeitpunkt definiert, wann die Rollläden an Werktagen geöffnet werden sollen.

;'''Zeit hoch WE:'''
:Dies definiert die Zeit, wann die Rolläden am Wochenende bzw an Tagen, welche in einer Holiday Datei definiert sind hoch gehen sollen.

;'''Helligkeit runter:'''
:Dieser Wert ist der untere Schwellwert des Helligkeitssensors, ab wann die Rolläden in dem definierten Zeitraum geschlossen werden sollen.

;'''Zeit runter start:'''
:Ab dieser Zeit fahren die Rolläden bei Erreichen des Helligkeitswertes runter. Sofern eventuelle Tür-/Fensterkontakte den Status "closed" aufweisen. Während des Zeitraums gehen diese Rolläden hoch und auch wieder runter, sofern eine Tür/ein Fenster geöffnet bzw geschlossen wird.

;'''Zeit runter ende:'''
:Dies ist das Ende des Zeitraums. Wenn bis dahin die Helligkeit nicht unterschritten wurde, fahren die Rolläden nun spätestens runter.

==Codierung==
Meine Aktoren haben den folgenden Aufbau, was den Namen angeht:

'''OG_ki1_RO_Carport'''

Die ersten zwei Zeichen geben das Geschoss an.
Die Zeichen 4-6 beschreiben das Zimmer.
Die Zeichen 8 und 9 stellen die Art des Aktors dar.
Ab Zeichen 11 wird noch weiter beschrieben, wenn es mehrere Aktoren in einem Zimmer gibt.

===Dummys===
Beginnen möchte ich hier mit den Dummys, welche die Konfiguration der Steuerung darstellen.

;'''Automatik aktiv:'''

<nowiki>NAME du_Rollo_Master
TYPE dummy

Attributes:
alias Automatik aktiv:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_automatic
room LichtRollo
setList state:an,aus
sortby 01
webCmd state</nowiki>

;'''Art:'''

<nowiki>NAME du_Rollo_Art
TYPE dummy

Attributes:
alias Art:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_updown
room LichtRollo
setList state:Normal,Urlaub,Weihnachten
sortby 02
webCmd state</nowiki>

;'''PV:'''

<nowiki>NAME du_Rollo_PV
TYPE dummy

Attributes:
alias PV:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon weather_sun
room LichtRollo
setList state:an,aus
sortby 03
webCmd state</nowiki>

;'''Zeit hoch:'''

<nowiki>NAME du_Rollo_Zeit_ho
TYPE dummy

Attributes:
alias Zeit hoch:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 10
webCmd state</nowiki>

;'''Zeit hoch WE:'''

<nowiki> NAME du_Rollo_Zeit_ho_WE
TYPE dummy

Attributes:
alias Zeit hoch WE:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 11
webCmd state</nowiki>

;'''Helligkeit runter:'''

<nowiki>NAME du_Rollo_Luminosity_ru
TYPE dummy

Attributes:
alias Helligkeit runter
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon sani_solar
room LichtRollo
setList state:textField
sortby 20
webCmd state</nowiki>

;'''Zeit runter start:'''

<nowiki>NAME du_Rollo_Zeit_ru_start
TYPE dummy

Attributes:
alias Zeit runter start:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 21
webCmd state</nowiki>

;'''Zeit runter ende:'''

<nowiki>NAME du_Rollo_Zeit_ru_ende
TYPE dummy

Attributes:
alias Zeit runter ende:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 22
webCmd state</nowiki>

===DOIFs===

'''di_EG_ku_RO_StrasseLinks'''

Dieses DOIF beachtet den Helligkeitswert und den Modus "Weihnachten".
D.h., daß dieser Rollo erst am Ende des definierten Zeitraums herunterfährt.

<nowiki>([du_Rollo_Master] eq "an" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru] and
[du_Rollo_Art] ne "Weihnachten" and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]))
(set EG_ku_RO_StrasseLinks on)</nowiki>

'''di_EG_ku_RO_StrasseRechts'''

Hier wird ein Fensterkontakt mit in die Schaltung einbezogen.
D.h. während des definierten Zeitraums gehen Rollos hoch, wenn eine Tür oder ein Fenster geöffnet wird. Ebenso wieder runter, sofern der Kontakt wieder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_ku_TK_Strasse] eq "closed" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]) or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseRechts off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or
[{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_ku_TK_Strasse:state] eq "open"))
(set EG_ku_RO_StrasseRechts on)</nowiki>

'''di_EG_wz_RO_TerrasseLinks'''

Dieses DOIF beachtet einen Fensterkontakt und bezieht die Photovoltaikanlage mit ein.
Dieser Rollo geht während des Zeitraums der Dunkelheit rauf und runter, sofern der Türkontakt geöffnet oder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and (([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state]
and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]))
(set EG_wz_RO_TerrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8]
or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_wz_TK_Terrasse] eq "open"))
(set EG_wz_RO_TerrasseLinks on)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 2100)
(set EG_wz_RO_TerrasseLinks 0)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 1501)
(set EG_wz_RO_TerrasseLinks 30)
DOELSEIF ([du_Rollo_PV] eq "aus")
(set EG_wz_RO_TerrasseLinks on)

wait 0:0:300:300:0 </nowiki>

Alle anderen Aktoren sind vereinfachte Versionen der genannten DOIFs und werden daher hier nicht genannt.

'''di_Rollo_Art'''

Dieses DOIF enabled und disabled einen Randomtimer, welcher ein Zufallslicht schaltet.

<nowiki>([du_Rollo_Art:state] eq "Urlaub") (attr UrlaubTimer disable 0, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 0)
DOELSE ([du_Rollo_Art:state] ne "Urlaub") (attr UrlaubTimer disable 1, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 1)</nowiki>

Hier folgt nun das mMn wichtigste DOIF.
Sofern manuelle Änderungen in den Text- bzw Zeitdummys durchgeführt werden, aktualisiert dieses DOIF die Definitionen der Rollo-DOIFs.
Dadurch werden die neuen Werte aus den Dummys für die Timer der DOIFs aktualisiert.

Auch aktualisiert dieses DOIF bei einem Neustart von FHEM die DOIFs.
Andernfalls würden die Defaultwerte der ReadingsVal(...) in den Definitionen die Defaultwerte zurückliefern.

'''di_Rollo_SetTime'''

<nowiki>([global:?INITIALIZED] or [du_Rollo_Zeit_ho:?] or [du_Rollo_Zeit_ho_WE:?] or [du_Rollo_Luminosity_ru:?] or [du_Rollo_Zeit_ru_start:?] or [du_Rollo_Zeit_ru_ende:?]) (modify di_EG_ku_RO_StrasseLinks [di_EG_ku_RO_StrasseLinks:&DEF], modify di_EG_ku_RO_StrasseRechts [di_EG_ku_RO_StrasseRechts:&DEF], modify di_EG_wz_RO_Carport [di_EG_wz_RO_Carport:&DEF], modify di_EG_wz_RO_TerrasseLinks [di_EG_wz_RO_TerrasseLinks:&DEF], modify di_EG_wz_RO_TerrasseRechts [di_EG_wz_RO_TerrasseRechts:&DEF], modify di_OG_elt_RO_Strasse [di_OG_elt_RO_Strasse:&DEF], modify di_OG_ki1_RO_Carport [di_OG_ki1_RO_Carport:&DEF], modify di_OG_ki1_RO_Garten [di_OG_ki1_RO_Garten:&DEF], modify di_OG_ki2_RO_Garten [di_OG_ki2_RO_Garten:&DEF])</nowiki>

===ReadingsGroup===

Hier seien noch die beiden ReadingsGroup aufgeführt, welche im Dashboard dargestellt werden.

Folgende Funktionen sind in der myRollosUtils gespeichert und dienen der Bedienung ausgehend aus den ReadingsGroups.

<nowiki>############## Rollos hoch/runter in Readingsgroup

sub myRollosUtils_RollosUpDown($$) {
my($DEVICE,$CMD) = @_;

my $icon = $CMD;
my $link;

if( $CMD eq "up" ) {
$icon = "remotecontrol/black_btn_CHUP";
$link = "setreading $DEVICE cmd-new on";
} elsif( $CMD eq "down" ) {
$icon = "remotecontrol/black_btn_CHDOWN";
$link = "setreading $DEVICE cmd-new off";
} elsif( $CMD eq "stop" ) {
$icon = "remotecontrol/black_btn_STOP";
$link = "setreading $DEVICE cmd-new stop";
}

my $notify = "no_RollosUpDown";
if( !defined($defs{$notify}) ) {
CommandDefine(undef,
"$notify notify .*:cmd-new.* "
."{ myRollos_RollosUpDownNotify(\$NAME,\$EVTPART1); }" );
}

my $ret = "%$icon";
$ret .= "%$link" if( $link );

return $ret;
}

sub myRollosUtils_RollosUpDownNotify($$) {
my($DEVICE,$CMD) = @_;

return if( $CMD eq "" );

CommandSet(undef, "$DEVICE $CMD");

return undef;
}

sub myRollosUtils_RollosIcon($) {
my($DEVICE) = @_;
my $level = ReadingsVal($DEVICE,"level", "0");
my $pct = ReadingsVal($DEVICE, "pct", "0");

my $ret = int((100 - $level)/10)*10;

my $icon;
if ($ret eq "0") {
$icon = "fts_window_2w\@orange";
} else {
$icon = "fts_shutter_".$ret."\@orange";
}

return $pct." %";
}
</nowiki>

'''EG_rg_Rolllaeden'''

<nowiki>EG.*_RO_S.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_C.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_T.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_M.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}>

Attributes:
group Rollos/Markise_EG
mapping %ALIAS
valueFormat {pct => "%.1f"}
valueIcon %VALUE </nowiki>

===Notify===

Ein Notify ist für die Bedienung ausgehend aus den ReadingsGroup notwendig.

<nowiki>DEF .*:cmd-new.* { myRollosUtils_RollosUpDownNotify($NAME,$EVTPART1); }
NAME no_RollosUpDown
TYPE notify

Attributes:
group notify</nowiki>

Rolladensteuerung mit Eingabemöglichkeiten

2015-02-11T17:43:08Z

Max: /* DOIFs */

In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere.

==Grundsätzliche Beschreibung==
Meine Rollläden im Haus sind allesamt mit HM Aktoren versehen, welche ich nachträglich UP gelegt habe.
Vorher waren die Rolläden manuell bedienbar gewesen.

Da ich eine Photovoltaikanlage besitze habe ich ein kleines Modul geschrieben, welches mir die Ertragsleistung in FHEM darstellt.
Anhand dieser Werte steuere ich Rolläden, welche zur Südseite gerichtet sind. Dadurch wird dann dynamisch die Sonneneinstrahlung und damit die Erwärmung der Zimmer eingestellt.
Zwischenzeitlich ist ein Helligkeitssensor installiert worden. Dieser sorgt für das Herunterfahren der Rolläden bei Eintreten der Dunkelheit.

Dieser Wert korreliert zwar mit den Werten der PV Anlage, dies habe ich aber bislang noch nicht aufgelöst.

==Komponenten==
1. HM Funk-Jalousieaktor HM-LC-Bi1PBU-FM

2. Solarlog-Modul

3. Helligkeitssensor aus diesem Posting
[http://forum.fhem.de/index.php/topic,20620.0.html Selbstbau HM_WDS10_TH_O mit Luftdruckmessung]

==Visualisierung==
Hier ist der Status eines jeden Rolladens ersichtlich und dieser ist bedienbar.

[[Datei:Dashboard01.png]]

Über diese Einstellungsseite können diverse Parameter der Steuerung gesetzt werden.

[[Datei:Dashboard02.png]]

==Einstellungen==
;'''Automatik aktiv:'''
:Hiermit wird die komplette Steuerung der Rolläden ein- bzw ausgeschaltet.
:Sofern der Modus "aus" aktiv ist, werden meine Rolläden lediglich über die Aktoren direkt oder eine HM Fernbedienung gesteuert.

;'''Art:'''
:Hier werden derzeit drei Modi unterstützt:

:''1. Normal''
:Bei diesem Modus fahren die Rollläden zu den definierten Zeiten hoch. Dabei wird eine Unterscheidung zwischen Wochentagen und Wochenenden berücksichtigt. Ausserdem werden mit Hilfe einer Holiday-Datei auch Feiertage und Urlaube berücksichtigt.
:Abends ist ein Zeitraum und ein Helligkeitswert definiert. Sobald dieser Helligkeitswert in dem Zeitfenster unterschritten wird, fahren die Rolläden runter. Spätestens aber zum Ende des Zeitfensters.

:''2. Weihnachten''
:Vom Prinzip arbeitet dieser Modus wie der Modus "Normal". Lediglich ein Rolladen fährt zum Ende des Zeitfensters runter und nicht bei Unterschreitung des Helligkeitswertes, damit die Weihnachtsaussenbeleuchtung auch von innen begutachtet werden kann.

:''3. Urlaub''
:Dieser Modus schaltet die Rolläden genauso wie der Modus "Normal". Des Weiteren aktiviere ich noch eine Zufallssteuerung für eine Anwesenheitsbeleuchtung.

;'''PV:'''
:Hiermit wird der Ertrag der Photovoltaikanlage mit einbezogen, damit die Rolläden zur Südseite anhand definierter Werte geschaltet werden.

;'''Zeit hoch:'''
:Hier wird der Zeitpunkt definiert, wann die Rollläden an Werktagen geöffnet werden sollen.

;'''Zeit hoch WE:'''
:Dies definiert die Zeit, wann die Rolläden am Wochenende bzw an Tagen, welche in einer Holiday Datei definiert sind hoch gehen sollen.

;'''Helligkeit runter:'''
:Dieser Wert ist der untere Schwellwert des Helligkeitssensors, ab wann die Rolläden in dem definierten Zeitraum geschlossen werden sollen.

;'''Zeit runter start:'''
:Ab dieser Zeit fahren die Rolläden bei Erreichen des Helligkeitswertes runter. Sofern eventuelle Tür-/Fensterkontakte den Status "closed" aufweisen. Während des Zeitraums gehen diese Rolläden hoch und auch wieder runter, sofern eine Tür/ein Fenster geöffnet bzw geschlossen wird.

;'''Zeit runter ende:'''
:Dies ist das Ende des Zeitraums. Wenn bis dahin die Helligkeit nicht unterschritten wurde, fahren die Rolläden nun spätestens runter.

==Codierung==
Meine Aktoren haben den folgenden Aufbau, was den Namen angeht:

'''OG_ki1_RO_Carport'''

Die ersten zwei Zeichen geben das Geschoss an.
Die Zeichen 4-6 beschreiben das Zimmer.
Die Zeichen 8 und 9 stellen die Art des Aktors dar.
Ab Zeichen 11 wird noch weiter beschrieben, wenn es mehrere Aktoren in einem Zimmer gibt.

===Dummys===
Beginnen möchte ich hier mit den Dummys, welche die Konfiguration der Steuerung darstellen.

;'''Automatik aktiv:'''

<nowiki>NAME du_Rollo_Master
TYPE dummy

Attributes:
alias Automatik aktiv:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_automatic
room LichtRollo
setList state:an,aus
sortby 01
webCmd state</nowiki>

;'''Art:'''

<nowiki>NAME du_Rollo_Art
TYPE dummy

Attributes:
alias Art:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_updown
room LichtRollo
setList state:Normal,Urlaub,Weihnachten
sortby 02
webCmd state</nowiki>

;'''PV:'''

<nowiki>NAME du_Rollo_PV
TYPE dummy

Attributes:
alias PV:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon weather_sun
room LichtRollo
setList state:an,aus
sortby 03
webCmd state</nowiki>

;'''Zeit hoch:'''

<nowiki>NAME du_Rollo_Zeit_ho
TYPE dummy

Attributes:
alias Zeit hoch:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 10
webCmd state</nowiki>

;'''Zeit hoch WE:'''

<nowiki> NAME du_Rollo_Zeit_ho_WE
TYPE dummy

Attributes:
alias Zeit hoch WE:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 11
webCmd state</nowiki>

;'''Helligkeit runter:'''

<nowiki>NAME du_Rollo_Luminosity_ru
TYPE dummy

Attributes:
alias Helligkeit runter
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon sani_solar
room LichtRollo
setList state:textField
sortby 20
webCmd state</nowiki>

;'''Zeit runter start:'''

<nowiki>NAME du_Rollo_Zeit_ru_start
TYPE dummy

Attributes:
alias Zeit runter start:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 21
webCmd state</nowiki>

;'''Zeit runter ende:'''

<nowiki>NAME du_Rollo_Zeit_ru_ende
TYPE dummy

Attributes:
alias Zeit runter ende:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 22
webCmd state</nowiki>

===DOIFs===

'''di_EG_ku_RO_StrasseLinks'''

Dieses DOIF beachtet den Helligkeitswert und den Modus "Weihnachten".
D.h., daß dieser Rollo erst am Ende des definierten Zeitraums herunterfährt.

<nowiki>([du_Rollo_Master] eq "an" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru] and [du_Rollo_Art] ne "Weihnachten" and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]) or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]))
(set EG_ku_RO_StrasseLinks on)</nowiki>

'''di_EG_ku_RO_StrasseRechts'''

Hier wird ein Fensterkontakt mit in die Schaltung einbezogen.
D.h. während des definierten Zeitraums gehen Rollos hoch, wenn eine Tür oder ein Fenster geöffnet wird. Ebenso wieder runter, sofern der Kontakt wieder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_ku_TK_Strasse] eq "closed" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state] and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]) or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseRechts off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_ku_TK_Strasse:state] eq "open"))
(set EG_ku_RO_StrasseRechts on)</nowiki>

'''di_EG_wz_RO_TerrasseLinks'''

Dieses DOIF beachtet einen Fensterkontakt und bezieht die Photovoltaikanlage mit ein.
Dieser Rollo geht während des Zeitraums der Dunkelheit rauf und runter, sofern der Türkontakt geöffnet oder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and (([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state] and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]) or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]))
(set EG_wz_RO_TerrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_wz_TK_Terrasse] eq "open"))
(set EG_wz_RO_TerrasseLinks on)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 2100)
(set EG_wz_RO_TerrasseLinks 0)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 1501)
(set EG_wz_RO_TerrasseLinks 30)
DOELSEIF ([du_Rollo_PV] eq "aus")
(set EG_wz_RO_TerrasseLinks on)

wait 0:0:300:300:0 </nowiki>

Alle anderen Aktoren sind vereinfachte Versionen der genannten DOIFs und werden daher hier nicht genannt.

'''di_Rollo_Art'''

Dieses DOIF enabled und disabled einen Randomtimer, welcher ein Zufallslicht schaltet.

<nowiki>([du_Rollo_Art:state] eq "Urlaub") (attr UrlaubTimer disable 0, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 0) DOELSE ([du_Rollo_Art:state] ne "Urlaub") (attr UrlaubTimer disable 1, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 1)</nowiki>

Hier folgt nun das mMn wichtigste DOIF.
Sofern manuelle Änderungen in den Text- bzw Zeitdummys durchgeführt werden, aktualisiert dieses DOIF die Definitionen der Rollo-DOIFs.
Dadurch werden die neuen Werte aus den Dummys für die Timer der DOIFs aktualisiert.

Auch aktualisiert dieses DOIF bei einem Neustart von FHEM die DOIFs.
Andernfalls würden die Defaultwerte der ReadingsVal(...) in den Definitionen die Defaultwerte zurückliefern.

'''di_Rollo_SetTime'''

<nowiki>([global:?INITIALIZED] or [du_Rollo_Zeit_ho:?] or [du_Rollo_Zeit_ho_WE:?] or [du_Rollo_Luminosity_ru:?] or [du_Rollo_Zeit_ru_start:?] or [du_Rollo_Zeit_ru_ende:?]) (modify di_EG_ku_RO_StrasseLinks [di_EG_ku_RO_StrasseLinks:&DEF], modify di_EG_ku_RO_StrasseRechts [di_EG_ku_RO_StrasseRechts:&DEF], modify di_EG_wz_RO_Carport [di_EG_wz_RO_Carport:&DEF], modify di_EG_wz_RO_TerrasseLinks [di_EG_wz_RO_TerrasseLinks:&DEF], modify di_EG_wz_RO_TerrasseRechts [di_EG_wz_RO_TerrasseRechts:&DEF], modify di_OG_elt_RO_Strasse [di_OG_elt_RO_Strasse:&DEF], modify di_OG_ki1_RO_Carport [di_OG_ki1_RO_Carport:&DEF], modify di_OG_ki1_RO_Garten [di_OG_ki1_RO_Garten:&DEF], modify di_OG_ki2_RO_Garten [di_OG_ki2_RO_Garten:&DEF])</nowiki>

===ReadingsGroup===

Hier seien noch die beiden ReadingsGroup aufgeführt, welche im Dashboard dargestellt werden.

Folgende Funktionen sind in der myRollosUtils gespeichert und dienen der Bedienung ausgehend aus den ReadingsGroups.

<nowiki>############## Rollos hoch/runter in Readingsgroup

sub myRollosUtils_RollosUpDown($$) {
my($DEVICE,$CMD) = @_;

my $icon = $CMD;
my $link;

if( $CMD eq "up" ) {
$icon = "remotecontrol/black_btn_CHUP";
$link = "setreading $DEVICE cmd-new on";
} elsif( $CMD eq "down" ) {
$icon = "remotecontrol/black_btn_CHDOWN";
$link = "setreading $DEVICE cmd-new off";
} elsif( $CMD eq "stop" ) {
$icon = "remotecontrol/black_btn_STOP";
$link = "setreading $DEVICE cmd-new stop";
}

my $notify = "no_RollosUpDown";
if( !defined($defs{$notify}) ) {
CommandDefine(undef,
"$notify notify .*:cmd-new.* "
."{ myRollos_RollosUpDownNotify(\$NAME,\$EVTPART1); }" );
}

my $ret = "%$icon";
$ret .= "%$link" if( $link );

return $ret;
}

sub myRollosUtils_RollosUpDownNotify($$) {
my($DEVICE,$CMD) = @_;

return if( $CMD eq "" );

CommandSet(undef, "$DEVICE $CMD");

return undef;
}

sub myRollosUtils_RollosIcon($) {
my($DEVICE) = @_;
my $level = ReadingsVal($DEVICE,"level", "0");
my $pct = ReadingsVal($DEVICE, "pct", "0");

my $ret = int((100 - $level)/10)*10;

my $icon;
if ($ret eq "0") {
$icon = "fts_window_2w\@orange";
} else {
$icon = "fts_shutter_".$ret."\@orange";
}

return $pct." %";
}
</nowiki>

'''EG_rg_Rolllaeden'''

<nowiki>EG.*_RO_S.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_C.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_T.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_M.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}>

Attributes:
group Rollos/Markise_EG
mapping %ALIAS
valueFormat {pct => "%.1f"}
valueIcon %VALUE </nowiki>

===Notify===

Ein Notify ist für die Bedienung ausgehend aus den ReadingsGroup notwendig.

<nowiki>DEF .*:cmd-new.* { myRollosUtils_RollosUpDownNotify($NAME,$EVTPART1); }
NAME no_RollosUpDown
TYPE notify

Attributes:
group notify</nowiki>

Rolladensteuerung mit Eingabemöglichkeiten

2015-02-11T17:08:03Z

Max: /* DOIFs */

In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere.

==Grundsätzliche Beschreibung==
Meine Rollläden im Haus sind allesamt mit HM Aktoren versehen, welche ich nachträglich UP gelegt habe.
Vorher waren die Rolläden manuell bedienbar gewesen.

Da ich eine Photovoltaikanlage besitze habe ich ein kleines Modul geschrieben, welches mir die Ertragsleistung in FHEM darstellt.
Anhand dieser Werte steuere ich Rolläden, welche zur Südseite gerichtet sind. Dadurch wird dann dynamisch die Sonneneinstrahlung und damit die Erwärmung der Zimmer eingestellt.
Zwischenzeitlich ist ein Helligkeitssensor installiert worden. Dieser sorgt für das Herunterfahren der Rolläden bei Eintreten der Dunkelheit.

Dieser Wert korreliert zwar mit den Werten der PV Anlage, dies habe ich aber bislang noch nicht aufgelöst.

==Komponenten==
1. HM Funk-Jalousieaktor HM-LC-Bi1PBU-FM

2. Solarlog-Modul

3. Helligkeitssensor aus diesem Posting
[http://forum.fhem.de/index.php/topic,20620.0.html Selbstbau HM_WDS10_TH_O mit Luftdruckmessung]

==Visualisierung==
Hier ist der Status eines jeden Rolladens ersichtlich und dieser ist bedienbar.

[[Datei:Dashboard01.png]]

Über diese Einstellungsseite können diverse Parameter der Steuerung gesetzt werden.

[[Datei:Dashboard02.png]]

==Einstellungen==
;'''Automatik aktiv:'''
:Hiermit wird die komplette Steuerung der Rolläden ein- bzw ausgeschaltet.
:Sofern der Modus "aus" aktiv ist, werden meine Rolläden lediglich über die Aktoren direkt oder eine HM Fernbedienung gesteuert.

;'''Art:'''
:Hier werden derzeit drei Modi unterstützt:

:''1. Normal''
:Bei diesem Modus fahren die Rollläden zu den definierten Zeiten hoch. Dabei wird eine Unterscheidung zwischen Wochentagen und Wochenenden berücksichtigt. Ausserdem werden mit Hilfe einer Holiday-Datei auch Feiertage und Urlaube berücksichtigt.
:Abends ist ein Zeitraum und ein Helligkeitswert definiert. Sobald dieser Helligkeitswert in dem Zeitfenster unterschritten wird, fahren die Rolläden runter. Spätestens aber zum Ende des Zeitfensters.

:''2. Weihnachten''
:Vom Prinzip arbeitet dieser Modus wie der Modus "Normal". Lediglich ein Rolladen fährt zum Ende des Zeitfensters runter und nicht bei Unterschreitung des Helligkeitswertes, damit die Weihnachtsaussenbeleuchtung auch von innen begutachtet werden kann.

:''3. Urlaub''
:Dieser Modus schaltet die Rolläden genauso wie der Modus "Normal". Des Weiteren aktiviere ich noch eine Zufallssteuerung für eine Anwesenheitsbeleuchtung.

;'''PV:'''
:Hiermit wird der Ertrag der Photovoltaikanlage mit einbezogen, damit die Rolläden zur Südseite anhand definierter Werte geschaltet werden.

;'''Zeit hoch:'''
:Hier wird der Zeitpunkt definiert, wann die Rollläden an Werktagen geöffnet werden sollen.

;'''Zeit hoch WE:'''
:Dies definiert die Zeit, wann die Rolläden am Wochenende bzw an Tagen, welche in einer Holiday Datei definiert sind hoch gehen sollen.

;'''Helligkeit runter:'''
:Dieser Wert ist der untere Schwellwert des Helligkeitssensors, ab wann die Rolläden in dem definierten Zeitraum geschlossen werden sollen.

;'''Zeit runter start:'''
:Ab dieser Zeit fahren die Rolläden bei Erreichen des Helligkeitswertes runter. Sofern eventuelle Tür-/Fensterkontakte den Status "closed" aufweisen. Während des Zeitraums gehen diese Rolläden hoch und auch wieder runter, sofern eine Tür/ein Fenster geöffnet bzw geschlossen wird.

;'''Zeit runter ende:'''
:Dies ist das Ende des Zeitraums. Wenn bis dahin die Helligkeit nicht unterschritten wurde, fahren die Rolläden nun spätestens runter.

==Codierung==
Meine Aktoren haben den folgenden Aufbau, was den Namen angeht:

'''OG_ki1_RO_Carport'''

Die ersten zwei Zeichen geben das Geschoss an.
Die Zeichen 4-6 beschreiben das Zimmer.
Die Zeichen 8 und 9 stellen die Art des Aktors dar.
Ab Zeichen 11 wird noch weiter beschrieben, wenn es mehrere Aktoren in einem Zimmer gibt.

===Dummys===
Beginnen möchte ich hier mit den Dummys, welche die Konfiguration der Steuerung darstellen.

;'''Automatik aktiv:'''

<nowiki>NAME du_Rollo_Master
TYPE dummy

Attributes:
alias Automatik aktiv:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_automatic
room LichtRollo
setList state:an,aus
sortby 01
webCmd state</nowiki>

;'''Art:'''

<nowiki>NAME du_Rollo_Art
TYPE dummy

Attributes:
alias Art:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_updown
room LichtRollo
setList state:Normal,Urlaub,Weihnachten
sortby 02
webCmd state</nowiki>

;'''PV:'''

<nowiki>NAME du_Rollo_PV
TYPE dummy

Attributes:
alias PV:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon weather_sun
room LichtRollo
setList state:an,aus
sortby 03
webCmd state</nowiki>

;'''Zeit hoch:'''

<nowiki>NAME du_Rollo_Zeit_ho
TYPE dummy

Attributes:
alias Zeit hoch:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 10
webCmd state</nowiki>

;'''Zeit hoch WE:'''

<nowiki> NAME du_Rollo_Zeit_ho_WE
TYPE dummy

Attributes:
alias Zeit hoch WE:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 11
webCmd state</nowiki>

;'''Helligkeit runter:'''

<nowiki>NAME du_Rollo_Luminosity_ru
TYPE dummy

Attributes:
alias Helligkeit runter
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon sani_solar
room LichtRollo
setList state:textField
sortby 20
webCmd state</nowiki>

;'''Zeit runter start:'''

<nowiki>NAME du_Rollo_Zeit_ru_start
TYPE dummy

Attributes:
alias Zeit runter start:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 21
webCmd state</nowiki>

;'''Zeit runter ende:'''

<nowiki>NAME du_Rollo_Zeit_ru_ende
TYPE dummy

Attributes:
alias Zeit runter ende:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 22
webCmd state</nowiki>

===DOIFs===

'''di_EG_ku_RO_StrasseLinks'''

Dieses DOIF beachtet den Helligkeitswert und den Modus "Weihnachten".
D.h., daß dieser Rollo erst am Ende des definierten Zeitraums herunterfährt.

<nowiki>([du_Rollo_Master] eq "an" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru] and [du_Rollo_Art] ne "Weihnachten" and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]) or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]))
(set EG_ku_RO_StrasseLinks on)</nowiki>

'''di_EG_ku_RO_StrasseRechts'''

Hier wird ein Fensterkontakt mit in die Schaltung einbezogen.
D.h. während des definierten Zeitraums gehen Rollos hoch, wenn eine Tür oder ein Fenster geöffnet wird. Ebenso wieder runter, sofern der Kontakt wieder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_ku_TK_Strasse] eq "closed" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state] and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]) or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseRechts off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_ku_TK_Strasse:state] eq "open"))
(set EG_ku_RO_StrasseRechts on)</nowiki>

'''di_EG_wz_RO_TerrasseLinks'''

Dieses DOIF beachtet einen Fensterkontakt und bezieht die Photovoltaikanlage mit ein.
Dieser Rollo geht während des Zeitraums der Dunkelheit rauf und runter, sofern der Türkontakt geöffnet oder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and (([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state] and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]) or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]))
(set EG_wz_RO_TerrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_wz_TK_Terrasse] eq "open"))
(set EG_wz_RO_TerrasseLinks on)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 2100)
(set EG_wz_RO_TerrasseLinks 0)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 1501)
(set EG_wz_RO_TerrasseLinks 30)
DOELSEIF ([du_Rollo_PV] eq "aus")
(set EG_wz_RO_TerrasseLinks on)</nowiki>

Alle anderen Aktoren sind vereinfachte Versionen der genannten DOIFs und werden daher hier nicht genannt.

'''di_Rollo_Art'''

Dieses DOIF enabled und disabled einen Randomtimer, welcher ein Zufallslicht schaltet.

<nowiki>([du_Rollo_Art:state] eq "Urlaub") (attr UrlaubTimer disable 0, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 0) DOELSE ([du_Rollo_Art:state] ne "Urlaub") (attr UrlaubTimer disable 1, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 1)</nowiki>

Hier folgt nun das mMn wichtigste DOIF.
Sofern manuelle Änderungen in den Text- bzw Zeitdummys durchgeführt werden, aktualisiert dieses DOIF die Definitionen der Rollo-DOIFs.
Dadurch werden die neuen Werte aus den Dummys für die Timer der DOIFs aktualisiert.

Auch aktualisiert dieses DOIF bei einem Neustart von FHEM die DOIFs.
Andernfalls würden die Defaultwerte der ReadingsVal(...) in den Definitionen die Defaultwerte zurückliefern.

'''di_Rollo_SetTime'''

<nowiki>([global:?INITIALIZED] or [du_Rollo_Zeit_ho:?] or [du_Rollo_Zeit_ho_WE:?] or [du_Rollo_Luminosity_ru:?] or [du_Rollo_Zeit_ru_start:?] or [du_Rollo_Zeit_ru_ende:?]) (modify di_EG_ku_RO_StrasseLinks [di_EG_ku_RO_StrasseLinks:&DEF], modify di_EG_ku_RO_StrasseRechts [di_EG_ku_RO_StrasseRechts:&DEF], modify di_EG_wz_RO_Carport [di_EG_wz_RO_Carport:&DEF], modify di_EG_wz_RO_TerrasseLinks [di_EG_wz_RO_TerrasseLinks:&DEF], modify di_EG_wz_RO_TerrasseRechts [di_EG_wz_RO_TerrasseRechts:&DEF], modify di_OG_elt_RO_Strasse [di_OG_elt_RO_Strasse:&DEF], modify di_OG_ki1_RO_Carport [di_OG_ki1_RO_Carport:&DEF], modify di_OG_ki1_RO_Garten [di_OG_ki1_RO_Garten:&DEF], modify di_OG_ki2_RO_Garten [di_OG_ki2_RO_Garten:&DEF])</nowiki>

===ReadingsGroup===

Hier seien noch die beiden ReadingsGroup aufgeführt, welche im Dashboard dargestellt werden.

Folgende Funktionen sind in der myRollosUtils gespeichert und dienen der Bedienung ausgehend aus den ReadingsGroups.

<nowiki>############## Rollos hoch/runter in Readingsgroup

sub myRollosUtils_RollosUpDown($$) {
my($DEVICE,$CMD) = @_;

my $icon = $CMD;
my $link;

if( $CMD eq "up" ) {
$icon = "remotecontrol/black_btn_CHUP";
$link = "setreading $DEVICE cmd-new on";
} elsif( $CMD eq "down" ) {
$icon = "remotecontrol/black_btn_CHDOWN";
$link = "setreading $DEVICE cmd-new off";
} elsif( $CMD eq "stop" ) {
$icon = "remotecontrol/black_btn_STOP";
$link = "setreading $DEVICE cmd-new stop";
}

my $notify = "no_RollosUpDown";
if( !defined($defs{$notify}) ) {
CommandDefine(undef,
"$notify notify .*:cmd-new.* "
."{ myRollos_RollosUpDownNotify(\$NAME,\$EVTPART1); }" );
}

my $ret = "%$icon";
$ret .= "%$link" if( $link );

return $ret;
}

sub myRollosUtils_RollosUpDownNotify($$) {
my($DEVICE,$CMD) = @_;

return if( $CMD eq "" );

CommandSet(undef, "$DEVICE $CMD");

return undef;
}

sub myRollosUtils_RollosIcon($) {
my($DEVICE) = @_;
my $level = ReadingsVal($DEVICE,"level", "0");
my $pct = ReadingsVal($DEVICE, "pct", "0");

my $ret = int((100 - $level)/10)*10;

my $icon;
if ($ret eq "0") {
$icon = "fts_window_2w\@orange";
} else {
$icon = "fts_shutter_".$ret."\@orange";
}

return $pct." %";
}
</nowiki>

'''EG_rg_Rolllaeden'''

<nowiki>EG.*_RO_S.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_C.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_T.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_M.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}>

Attributes:
group Rollos/Markise_EG
mapping %ALIAS
valueFormat {pct => "%.1f"}
valueIcon %VALUE </nowiki>

===Notify===

Ein Notify ist für die Bedienung ausgehend aus den ReadingsGroup notwendig.

<nowiki>DEF .*:cmd-new.* { myRollosUtils_RollosUpDownNotify($NAME,$EVTPART1); }
NAME no_RollosUpDown
TYPE notify

Attributes:
group notify</nowiki>

Rolladensteuerung mit Eingabemöglichkeiten

2015-02-11T17:03:42Z

Max: Die Seite wurde neu angelegt: „In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere. ==Grundsätzliche Beschreibung== Meine Rollläden im Haus sind allesamt mit HM Aktoren ver…“

In diesem Artikel beschreibe ich, wie ich meine Rollläden steuere.

==Grundsätzliche Beschreibung==
Meine Rollläden im Haus sind allesamt mit HM Aktoren versehen, welche ich nachträglich UP gelegt habe.
Vorher waren die Rolläden manuell bedienbar gewesen.

Da ich eine Photovoltaikanlage besitze habe ich ein kleines Modul geschrieben, welches mir die Ertragsleistung in FHEM darstellt.
Anhand dieser Werte steuere ich Rolläden, welche zur Südseite gerichtet sind. Dadurch wird dann dynamisch die Sonneneinstrahlung und damit die Erwärmung der Zimmer eingestellt.
Zwischenzeitlich ist ein Helligkeitssensor installiert worden. Dieser sorgt für das Herunterfahren der Rolläden bei Eintreten der Dunkelheit.

Dieser Wert korreliert zwar mit den Werten der PV Anlage, dies habe ich aber bislang noch nicht aufgelöst.

==Komponenten==
1. HM Funk-Jalousieaktor HM-LC-Bi1PBU-FM

2. Solarlog-Modul

3. Helligkeitssensor aus diesem Posting
[http://forum.fhem.de/index.php/topic,20620.0.html Selbstbau HM_WDS10_TH_O mit Luftdruckmessung]

==Visualisierung==
Hier ist der Status eines jeden Rolladens ersichtlich und dieser ist bedienbar.

[[Datei:Dashboard01.png]]

Über diese Einstellungsseite können diverse Parameter der Steuerung gesetzt werden.

[[Datei:Dashboard02.png]]

==Einstellungen==
;'''Automatik aktiv:'''
:Hiermit wird die komplette Steuerung der Rolläden ein- bzw ausgeschaltet.
:Sofern der Modus "aus" aktiv ist, werden meine Rolläden lediglich über die Aktoren direkt oder eine HM Fernbedienung gesteuert.

;'''Art:'''
:Hier werden derzeit drei Modi unterstützt:

:''1. Normal''
:Bei diesem Modus fahren die Rollläden zu den definierten Zeiten hoch. Dabei wird eine Unterscheidung zwischen Wochentagen und Wochenenden berücksichtigt. Ausserdem werden mit Hilfe einer Holiday-Datei auch Feiertage und Urlaube berücksichtigt.
:Abends ist ein Zeitraum und ein Helligkeitswert definiert. Sobald dieser Helligkeitswert in dem Zeitfenster unterschritten wird, fahren die Rolläden runter. Spätestens aber zum Ende des Zeitfensters.

:''2. Weihnachten''
:Vom Prinzip arbeitet dieser Modus wie der Modus "Normal". Lediglich ein Rolladen fährt zum Ende des Zeitfensters runter und nicht bei Unterschreitung des Helligkeitswertes, damit die Weihnachtsaussenbeleuchtung auch von innen begutachtet werden kann.

:''3. Urlaub''
:Dieser Modus schaltet die Rolläden genauso wie der Modus "Normal". Des Weiteren aktiviere ich noch eine Zufallssteuerung für eine Anwesenheitsbeleuchtung.

;'''PV:'''
:Hiermit wird der Ertrag der Photovoltaikanlage mit einbezogen, damit die Rolläden zur Südseite anhand definierter Werte geschaltet werden.

;'''Zeit hoch:'''
:Hier wird der Zeitpunkt definiert, wann die Rollläden an Werktagen geöffnet werden sollen.

;'''Zeit hoch WE:'''
:Dies definiert die Zeit, wann die Rolläden am Wochenende bzw an Tagen, welche in einer Holiday Datei definiert sind hoch gehen sollen.

;'''Helligkeit runter:'''
:Dieser Wert ist der untere Schwellwert des Helligkeitssensors, ab wann die Rolläden in dem definierten Zeitraum geschlossen werden sollen.

;'''Zeit runter start:'''
:Ab dieser Zeit fahren die Rolläden bei Erreichen des Helligkeitswertes runter. Sofern eventuelle Tür-/Fensterkontakte den Status "closed" aufweisen. Während des Zeitraums gehen diese Rolläden hoch und auch wieder runter, sofern eine Tür/ein Fenster geöffnet bzw geschlossen wird.

;'''Zeit runter ende:'''
:Dies ist das Ende des Zeitraums. Wenn bis dahin die Helligkeit nicht unterschritten wurde, fahren die Rolläden nun spätestens runter.

==Codierung==
Meine Aktoren haben den folgenden Aufbau, was den Namen angeht:

'''OG_ki1_RO_Carport'''

Die ersten zwei Zeichen geben das Geschoss an.
Die Zeichen 4-6 beschreiben das Zimmer.
Die Zeichen 8 und 9 stellen die Art des Aktors dar.
Ab Zeichen 11 wird noch weiter beschrieben, wenn es mehrere Aktoren in einem Zimmer gibt.

===Dummys===
Beginnen möchte ich hier mit den Dummys, welche die Konfiguration der Steuerung darstellen.

;'''Automatik aktiv:'''

<nowiki>NAME du_Rollo_Master
TYPE dummy

Attributes:
alias Automatik aktiv:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_automatic
room LichtRollo
setList state:an,aus
sortby 01
webCmd state</nowiki>

;'''Art:'''

<nowiki>NAME du_Rollo_Art
TYPE dummy

Attributes:
alias Art:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon fts_shutter_updown
room LichtRollo
setList state:Normal,Urlaub,Weihnachten
sortby 02
webCmd state</nowiki>

;'''PV:'''

<nowiki>NAME du_Rollo_PV
TYPE dummy

Attributes:
alias PV:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon weather_sun
room LichtRollo
setList state:an,aus
sortby 03
webCmd state</nowiki>

;'''Zeit hoch:'''

<nowiki>NAME du_Rollo_Zeit_ho
TYPE dummy

Attributes:
alias Zeit hoch:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 10
webCmd state</nowiki>

;'''Zeit hoch WE:'''

<nowiki> NAME du_Rollo_Zeit_ho_WE
TYPE dummy

Attributes:
alias Zeit hoch WE:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 11
webCmd state</nowiki>

;'''Helligkeit runter:'''

<nowiki>NAME du_Rollo_Luminosity_ru
TYPE dummy

Attributes:
alias Helligkeit runter
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon sani_solar
room LichtRollo
setList state:textField
sortby 20
webCmd state</nowiki>

;'''Zeit runter start:'''

<nowiki>NAME du_Rollo_Zeit_ru_start
TYPE dummy

Attributes:
alias Zeit runter start:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 21
webCmd state</nowiki>

;'''Zeit runter ende:'''

<nowiki>NAME du_Rollo_Zeit_ru_ende
TYPE dummy

Attributes:
alias Zeit runter ende:
devStateIcon .*:rc_BLANK
group Rollos_Settings
icon icoUhr
room LichtRollo
setList state:time
sortby 22
webCmd state</nowiki>

===DOIFs===

'''di_EG_ku_RO_StrasseLinks'''

Dieses DOIF beachtet den Helligkeitswert und den Modus "Weihnachten".
D.h., daß dieser Rollo erst am Ende des definierten Zeitraums herunterfährt.

<nowiki>([du_Rollo_Master] eq "an" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru] and [du_Rollo_Art] ne "Weihnachten" and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]) or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]))
(set EG_ku_RO_StrasseLinks on)</nowiki>

'''di_EG_ku_RO_StrasseRechts'''

Hier wird ein Fensterkontakt mit in die Schaltung einbezogen.
D.h. während des definierten Zeitraums gehen Rollos hoch, wenn eine Tür oder ein Fenster geöffnet wird. Ebenso wieder runter, sofern der Kontakt wieder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_ku_TK_Strasse] eq "closed" and ([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state] and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]) or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}])
(set EG_ku_RO_StrasseRechts off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_ku_TK_Strasse:state] eq "open"))
(set EG_ku_RO_StrasseRechts on)</nowiki>

'''di_EG_wz_RO_TerrasseLinks'''

Dieses DOIF beachtet einen Fensterkontakt und bezieht die Photovoltaikanlage mit ein.
Dieser Rollo geht während des Zeitraums der Dunkelheit rauf und runter, sofern der Türkontakt geöffnet oder geschlossen wird.

<nowiki>([du_Rollo_Master] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and (([EG_dr_TS_Terrasse:luminosity] < [du_Rollo_Luminosity_ru:state] and [{ReadingsVal("du_Rollo_Zeit_ru_start", "state", "22:00:00")}-{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]) or [{ReadingsVal("du_Rollo_Zeit_ru_ende", "state", "22:00:00")}]))
(set EG_wz_RO_TerrasseLinks off)
DOELSEIF ([du_Rollo_Master] eq "an" and ([{ReadingsVal("du_Rollo_Zeit_ho", "state", "10:00:00")}|8] or [{ReadingsVal("du_Rollo_Zeit_ho_WE", "state", "10:00:00")}|7]) or ([EG_wz_TK_Terrasse] eq "open"))
(set EG_wz_RO_TerrasseLinks on)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 2100)
(set EG_wz_RO_TerrasseLinks 0)
DOELSEIF ([du_Rollo_PV] eq "an" and [EG_wz_TK_Terrasse] eq "closed" and [mySL:Pac_avg] >= 1501)
(set EG_wz_RO_TerrasseLinks 30)
DOELSEIF ([du_Rollo_PV] eq "aus")
(set EG_wz_RO_TerrasseLinks on)</nowiki>

Alle anderen Aktoren sind vereinfachte Versionen der genannten DOIFs und werden daher hier nicht genannt.

'''di_Rollo_Art'''

Dieser enabled und disabled einen Randomtimer, welche Zufallslicht schaltet.

<nowiki>([du_Rollo_Art:state] eq "Urlaub") (attr UrlaubTimer disable 0, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 0) DOELSE ([du_Rollo_Art:state] ne "Urlaub") (attr UrlaubTimer disable 1, attr at_Urlaub_DG_hz_SD_Zirkpumpe disable 1)</nowiki>

Hier folgt nun das mMn wichtigste DOIF.
Sofern manuelle Änderungen in den Text- bzw Zeitdummys durchgeführt werden, aktualisiert dieses DOIF die Definitionen der Rollo-DOIFs.
Dadurch werden die neuen Werte aus den Dummys für die Timer der DOIFs aktualisiert.

Auch aktualisiert dieses DOIF bei einem Neustart von FHEM die DOIFs.
Andernfalls würden die Defaultwerte der ReadingsVal(...) in den Definitionen die Defaultwerte zurückliefern.

'''di_Rollo_SetTime'''

<nowiki>([global:?INITIALIZED] or [du_Rollo_Zeit_ho:?] or [du_Rollo_Zeit_ho_WE:?] or [du_Rollo_Luminosity_ru:?] or [du_Rollo_Zeit_ru_start:?] or [du_Rollo_Zeit_ru_ende:?]) (modify di_EG_ku_RO_StrasseLinks [di_EG_ku_RO_StrasseLinks:&DEF], modify di_EG_ku_RO_StrasseRechts [di_EG_ku_RO_StrasseRechts:&DEF], modify di_EG_wz_RO_Carport [di_EG_wz_RO_Carport:&DEF], modify di_EG_wz_RO_TerrasseLinks [di_EG_wz_RO_TerrasseLinks:&DEF], modify di_EG_wz_RO_TerrasseRechts [di_EG_wz_RO_TerrasseRechts:&DEF], modify di_OG_elt_RO_Strasse [di_OG_elt_RO_Strasse:&DEF], modify di_OG_ki1_RO_Carport [di_OG_ki1_RO_Carport:&DEF], modify di_OG_ki1_RO_Garten [di_OG_ki1_RO_Garten:&DEF], modify di_OG_ki2_RO_Garten [di_OG_ki2_RO_Garten:&DEF])</nowiki>

===ReadingsGroup===

Hier seien noch die beiden ReadingsGroup aufgeführt, welche im Dashboard dargestellt werden.

Folgende Funktionen sind in der myRollosUtils gespeichert und dienen der Bedienung ausgehend aus den ReadingsGroups.

<nowiki>############## Rollos hoch/runter in Readingsgroup

sub myRollosUtils_RollosUpDown($$) {
my($DEVICE,$CMD) = @_;

my $icon = $CMD;
my $link;

if( $CMD eq "up" ) {
$icon = "remotecontrol/black_btn_CHUP";
$link = "setreading $DEVICE cmd-new on";
} elsif( $CMD eq "down" ) {
$icon = "remotecontrol/black_btn_CHDOWN";
$link = "setreading $DEVICE cmd-new off";
} elsif( $CMD eq "stop" ) {
$icon = "remotecontrol/black_btn_STOP";
$link = "setreading $DEVICE cmd-new stop";
}

my $notify = "no_RollosUpDown";
if( !defined($defs{$notify}) ) {
CommandDefine(undef,
"$notify notify .*:cmd-new.* "
."{ myRollos_RollosUpDownNotify(\$NAME,\$EVTPART1); }" );
}

my $ret = "%$icon";
$ret .= "%$link" if( $link );

return $ret;
}

sub myRollosUtils_RollosUpDownNotify($$) {
my($DEVICE,$CMD) = @_;

return if( $CMD eq "" );

CommandSet(undef, "$DEVICE $CMD");

return undef;
}

sub myRollosUtils_RollosIcon($) {
my($DEVICE) = @_;
my $level = ReadingsVal($DEVICE,"level", "0");
my $pct = ReadingsVal($DEVICE, "pct", "0");

my $ret = int((100 - $level)/10)*10;

my $icon;
if ($ret eq "0") {
$icon = "fts_window_2w\@orange";
} else {
$icon = "fts_shutter_".$ret."\@orange";
}

return $pct." %";
}
</nowiki>

'''EG_rg_Rolllaeden'''

<nowiki>EG.*_RO_S.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_C.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_T.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}> EG.*_RO_M.*:level,<{myRollosUtils_RollosUpDown($DEVICE,"up")}>,<{myRollosUtils_RollosUpDown($DEVICE,"stop")}>,<{myRollosUtils_RollosUpDown($DEVICE,"down")}>

Attributes:
group Rollos/Markise_EG
mapping %ALIAS
valueFormat {pct => "%.1f"}
valueIcon %VALUE </nowiki>

===Notify===

Ein Notify ist für die Bedienung ausgehend aus den ReadingsGroup notwendig.

<nowiki>DEF .*:cmd-new.* { myRollosUtils_RollosUpDownNotify($NAME,$EVTPART1); }
NAME no_RollosUpDown
TYPE notify

Attributes:
group notify</nowiki>

Datei:Dashboard02.png

2015-02-11T16:57:25Z

Max:

Datei:Dashboard01.png

2015-02-11T16:55:45Z

Max:

Benutzer:Max

2015-01-25T16:07:08Z

Max: Die Seite wurde geleert.

Benutzer:Max

2015-01-25T16:06:44Z

Max: Die Seite wurde neu angelegt: „Testseite“

Testseite