mirror of
https://github.com/fhem/fhem-mirror.git
synced 2025-02-07 23:09:26 +00:00
98_DOIF.pm: set_Exec with perl code, new doc for perl mode
git-svn-id: https://svn.fhem.de/fhem/trunk@17356 2b470e98-0d58-463d-a4d8-8e2adae1ed80
This commit is contained in:
Damian
parent
bc48439ee6
commit
581e945645
@ -2821,13 +2821,12 @@ DOIF_SleepTrigger ($)
|
||||
sub DOIF_set_Exec
|
||||
{
|
||||
my ($hash,$timername,$seconds,$subname,$param)=@_;
|
||||
$param="" if (!defined $param);
|
||||
my $current = gettimeofday();
|
||||
my $next_time = $current+$seconds;
|
||||
$hash->{ptimer}{$timername}{time}=$next_time;
|
||||
$hash->{ptimer}{$timername}{name}=$timername;
|
||||
$hash->{ptimer}{$timername}{subname}=$subname;
|
||||
$hash->{ptimer}{$timername}{param}=$param;
|
||||
$hash->{ptimer}{$timername}{param}=$param if (defined $param);
|
||||
$hash->{ptimer}{$timername}{hash}=$hash;
|
||||
RemoveInternalTimer(\$hash->{ptimer}{$timername});
|
||||
if ($seconds > 0) {
|
||||
@ -2869,8 +2868,12 @@ sub DOIF_ExecTimer
|
||||
my $timername=${$timer}->{name};
|
||||
my $name=$hash->{NAME};
|
||||
my $subname=${$timer}->{subname};
|
||||
my $param=${$timer}->{param};
|
||||
eval ("$subname(\"$param\")");
|
||||
my $param=${$timer}->{param} if (defined ${$timer}->{param});
|
||||
if (!defined ($param)) {
|
||||
eval ("$subname");
|
||||
} else {
|
||||
eval ('$subname("$param")');
|
||||
}
|
||||
if ($@) {
|
||||
Log3 ($defs{$name}{NAME},1 , "$name error in $subname: $@");
|
||||
readingsSingleUpdate ($hash, "error", "in $subname: $@",0);
|
||||
@ -3453,15 +3456,16 @@ DOIF (ausgeprochen: du if, übersetzt: tue wenn) ist ein universelles Modul mit
|
||||
Mit diesem Modul ist es möglich, einfache wie auch komplexere Automatisierungsvorgänge zu definieren oder in Perl zu programmieren.
|
||||
Ereignisse, Zeittrigger, Readings oder Status werden durch DOIF-spezifische Angaben in eckigen Klammern angegeben. Sie führen zur Triggerung des Moduls und damit zur Auswertung und Ausführung der definierten Anweisungen.<br>
|
||||
<br>
|
||||
Das Modul verfügt über zwei Modi: FHEM-Modus und <a href="#DOIF_Perl_Modus"><b>[NEU]</b> Perl-Modus</a>. Der Modus eines definierten DOIF-Devices wird automatisch aufgrund der Definition vom Modul erkannt
|
||||
Das Modul verfügt über zwei Modi: FHEM-Modus und <a href="#DOIF_Perl_Modus"><b>Perl-Modus</b></a>. Der Modus eines definierten DOIF-Devices wird automatisch aufgrund der Definition vom Modul erkannt
|
||||
(FHEM-Modus beginnt mit einer runden Klammer auf).
|
||||
Der Perl-Modus kommt weitgehend ohne Attribute aus, er ist aufgrund seiner Flexibilität,
|
||||
der Möglichkeit strukturiert zu programmieren und seiner hohen Performance insb. bei umfangreichen Automatisierungsaufgaben dem FHEM-Modus vorzuziehen. Hier geht´s zum <a href="#DOIF_Perl_Modus"><b>Perl-Modus</b></a>.
|
||||
Beide Modi sind innerhalb eines DOIF-Devices nicht miteinander kombinierbar. Im Folgendem wird der FHEM-Modus beschrieben.<br>
|
||||
<br>
|
||||
Syntax FHEM-Modus:<br>
|
||||
<br>
|
||||
<ol><code>define <name> DOIF (<Bedingung>) (<Befehle>) DOELSEIF (<Bedingung>) (<Befehle>) DOELSEIF ... DOELSE (<Befehle>)</code></ol>
|
||||
<br>
|
||||
Im FHEM-Modus lassen sich Automatisierungsabläufe ohne Perlkenntnisse definieren.
|
||||
Die Angaben werden immer von links nach rechts abgearbeitet. Logische Abfragen werden in DOIF/DOELSEIF-Bedingungen vornehmlich mit Hilfe von and/or-Operatoren erstellt.
|
||||
Zu beachten ist, dass nur die Bedingungen überprüft werden,
|
||||
die zum ausgelösten Event das dazughörige Device bzw. die dazugehörige Triggerzeit beinhalten.
|
||||
@ -5539,35 +5543,79 @@ Hier passiert das nicht mehr, da die ursprünglichen Zustände cmd_1 und cmd_2 j
|
||||
<a name="DOIF_Perl_Modus"></a>
|
||||
<b>Perl Modus</b><br>
|
||||
<br>
|
||||
Im Perl-Modus lassen sich insb. komplexere Abläufe innerhalb eines DOIF-Devices in Perl programmieren.
|
||||
Der Anwender hat mehr Einfluss auf den Ablauf der Steuerung als im FHEM-Modus. Einfache Perlkenntnise werden in diesem Modus vorausgesetzt.<br>
|
||||
<br>
|
||||
Die Steuerungsabläufe werden im Gegensatz zum FHEM-Modus nicht durch Attibute beinflusst, daher werden im Perl-Modus selten Attribute benötigt.
|
||||
Die Auswahl der <a href="#DOIF_Attribute_Perl_Modus">DOIF-spezifischen Attribute im Perl-Modus</a> ist auf einige sinnvolle beschränkt.<br>
|
||||
<br>
|
||||
Der Status des Moduls wird nicht vom Modul gesetzt, er kann vom Anwender mit Hilfe der Funktion <code>set_Reading</code> verändert werden, siehe <a href="#DOIF_Spezifische_Perl-Funktionen_im_Perl-Modus">spezifische Perl-Funktionen im Perl-Modus</a>.
|
||||
DOIF-spezifische <a href="#DOIF_Operanden">Operanden-Angaben in eckigen Klammern</a> entsprechen vollständig den Angaben im FHEM-Modus des Moduls. Sie können an beliebiger Stelle im Perlcode angegeben werden, wo auch Perl-Funktionen angegeben werden können.<br>
|
||||
Der Perl-Modus ist sowohl für einfache, als auch für komplexere Automatisierungsabläufe geeignet. Der Anwender hat mehr Einfluss auf den Ablauf der Steuerung als im FHEM-Modus.
|
||||
Die Abläufe lassen sich, wie in höheren Programmiersprachen üblich, strukturiert programmieren. Zum Zeitpunkt der Definition werden alle DOIF-spezifischen Angaben in Perl übersetzt, zum Zeitpunkt der Ausführung wird nur noch Perl ausgeführt, damit wird maximale Performance gewährleistet.<br>
|
||||
<br>
|
||||
Syntax Perl-Modus:<br>
|
||||
<br>
|
||||
<ol><code>define <name> DOIF <Blockname> {<Perl mit DOIF-Syntax in eckigen Klammern>} <Blockname> {<Perl mit DOIF-Syntax in eckigen Klammern>} ...</code></ol><br>
|
||||
<ol><code>define <name> DOIF <Blockname> {<Perlcode mit Ereignis-/Zeittriggern in eckigen Klammern>}</code></ol>
|
||||
<br>
|
||||
Ein Perlblock wird ausgeführt, wenn dieser, bedingt durch DOIF-spezifischen Angaben in eckigen Klammern innerhalb des Blocks, getriggert wird.
|
||||
Es wird die vollständige Perl-Syntax unterstützt. Es können beliebig viele Perlblöcke definiert werden. Der Name eines Blocks ist optional. Wird ein Perlblock mit dem Namen "init" benannt, so wird er ausgeführt, nachdem das FHEM-System hochgefahren wurde. Er bietet sich insb. an, um Instatnzvariablen des Moduls vorzubelegen.<br>
|
||||
Ein besonderer Perlblock ist der Block namens "subs". Dieser Block wird nur zum Definitionszeitpunkt ausgeführt. In diesem Block sollten vornehmlich Perlfunktionen definiert werden, die innerhalb des DOIFs genutzt werden. Um eine möglichst hohe Kompatibilität zu Perl sicherzustellen, wird keine DOIF-Syntax in eckigen Klammern unterstützt, insb. gibt es keine Trigger, die den Block ausführen können.<br>
|
||||
Ein Perlblock wird ausgeführt, wenn dieser bedingt durch <a href="#DOIF_Operanden">Ereignis- und Zeittrigger in eckigen Klammern</a> innerhalb des Blocks, getriggert wird.
|
||||
Es wird die vollständige Perl-Syntax unterstützt. Es können beliebig viele Perlblöcke innerhalb eines DOIF-Devices definiert werden. Sie werden unabhängig voneinander durch passende Trigger ausgeführt. Der Name eines Blocks ist optional.<br>
|
||||
<br>
|
||||
FHEM-Befehle werden durch den Aufruf der Perlfunktion <code>fhem"..."</code> ausgeführt. Im Gegensatz zum FHEM-Modus können im Perl-Modus mehrere Blöcke unabhängig voneinander, ausgelöst durch einen Ereignis- oder Zeit-Trigger, ausgeführt werden. So kann die Funktionalität mehrer DOIF-Module im FHEM-Modus innerhalb eines DOIF-Moduls im Perl-Moduls realisiert werden.<br>
|
||||
Der Status des Moduls wird nicht vom Modul gesetzt, er kann vom Anwender mit Hilfe der Funktion <code>set_Reading</code> verändert werden, siehe <a href="#DOIF_Spezifische_Perl-Funktionen_im_Perl-Modus">spezifische Perl-Funktionen im Perl-Modus</a>.
|
||||
FHEM-Befehle werden durch den Aufruf der Perlfunktion <code>fhem"..."</code> ausgeführt.<br>
|
||||
<br>
|
||||
Im Perl-Modus gibt es keinen wait-Timer, stattdessen kann der Benutzer mit der Funktion <code>set_Timer</code> beliebig viele eigene Timer definieren, die unabhängig voneinander gesetzt und ausgewertet werden können, siehe <a href="#DOIF_Spezifische_Perl-Funktionen_im_Perl-Modus">Spezifische Perl-Funktionen im Perl-Modus</a>.<br>
|
||||
Der Benutzer kann mit der Funktion <code>set_Timer/set_Exec</code> beliebig viele eigene Timer definieren, die unabhängig voneinander gesetzt und ausgewertet werden können, siehe <a href="#DOIF_Spezifische_Perl-Funktionen_im_Perl-Modus">Spezifische Perl-Funktionen im Perl-Modus</a>.<br>
|
||||
<br>
|
||||
Zum Zeitpunkt der Definition werden alle DOIF-spezifischen Angaben in Perl übersetzt, zum Zeitpunkt der Ausführung wird nur noch Perl ausgeführt, damit wird maximale Performance gewährleistet.<br>
|
||||
Definitionen im FHEM-Modus der Form:<br>
|
||||
<br>
|
||||
<code>DOIF (<Bedingung mit Trigger>) (<FHEM-Befehle>) DOELSE (<FHEM-Befehle>)</code><br>
|
||||
<br>
|
||||
lassen sich wie folgt in Perl-Modus übertragen:<br>
|
||||
<br>
|
||||
<code>DOIF {if (<Bedingung mit Trigger>) {fhem"<FHEM-Befehle>"} else {fhem"<FHEM-Befehle>"}}</code><br>
|
||||
<br>
|
||||
Die Bedingungen des FHEM-Modus können ohne Änderungen in Perl-Modus übernommen werden können.<br>
|
||||
<br>
|
||||
Im Perl-Modus können beliebig viele Blöcke definiert werden, die unabhängig von einander durch einen Trigger ausgewertet und zur Ausführung führen können:<br>
|
||||
<br>
|
||||
<code>DOIF<br>
|
||||
{ if (<Bedingung mit Trigger>) ... }<br>
|
||||
{ if (<Bedingung mit Trigger>) ... }<br>
|
||||
...</code><br>
|
||||
<br>
|
||||
Im Perlmodus sind beliebige Hierarchietiefen möglich:<br>
|
||||
<br>
|
||||
<code>DOIF<br>
|
||||
{ if (<Bedingung>) {<br>
|
||||
if (<Bedingung>) {<br>
|
||||
if (...<br>
|
||||
...<br>
|
||||
}<br>
|
||||
}<br>
|
||||
}<br>
|
||||
}</code><br>
|
||||
<br>
|
||||
Bemerkung: Innerhalb eines DOIF-Blocks muss mindestens ein Trigger in irgendeiner Bedingung definiert werden, damit der gesamte Block beim passenden Trigger ausgewertet wird.<br>
|
||||
<br>
|
||||
<u>Eigene Funktionen</u><br>
|
||||
<br>
|
||||
Ein besonderer Perlblock ist der Block namens "subs". In diesem Block werden Perlfunktionen definiert werden, die innerhalb des DOIFs genutzt werden.
|
||||
Um eine möglichst hohe Kompatibilität zu Perl sicherzustellen, wird keine DOIF-Syntax in eckigen Klammern unterstützt, insb. gibt es keine Trigger, die den Block ausführen können.<br>
|
||||
<br>
|
||||
Beispiel:<br>
|
||||
<br><code>
|
||||
DOIF
|
||||
subs { ## Definition von Perlfunktionen lamp_on und lamp_off<br>
|
||||
sub lamp_on {<br>
|
||||
fhem"set lamp on";<br>
|
||||
set_Reading("state","on",1);<br>
|
||||
}<br>
|
||||
sub lamp_off {<br>
|
||||
fhem"set lamp off";<br>
|
||||
set_Reading("state","off",1);<br>
|
||||
}<br>
|
||||
}<br>
|
||||
{if ([06:00]) {lamp_on() # Um 06:00 Uhr wird die Funktion lamp_on aufgerufen }<br>
|
||||
{if ([08:00]) {lamp_off() # Um 08:00 Uhr wird die Funktion lamp_off aufgerufen }<br>
|
||||
</code><br>
|
||||
<a name="DOIF_Einfache_Anwendungsbeispiele_Perl"></a>
|
||||
<u>Einfache Anwendungsbeispiele (vgl. <a href="#DOIF_Einfache_Anwendungsbeispiele">Anwendungsbeispiele im FHEM-Modus</a>):</u><ol>
|
||||
<br>
|
||||
<code>define di_rc_tv DOIF {if ([remotecontol:"on"]) {fhem"set tv on"} else {fhem"set tv off"}}</code><br>
|
||||
<br>
|
||||
<code>define di_clock_radio DOIF {if ([06:30|Mo Di Mi] or [08:30|Do Fr Sa So]) {fhem"set radio on"} elsif ([08:00|Mo Di Mi] or [09:30|Do Fr Sa So]) {fhem"set radio off"}}</code><br>
|
||||
<code>define di_clock_radio DOIF {if ([06:30|Mo Di Mi] or [08:30|Do Fr Sa So]) {fhem"set radio on"}} {if ([08:00|Mo Di Mi] or [09:30|Do Fr Sa So]) {fhem"set radio off"}}</code><br>
|
||||
<br>
|
||||
<code>define di_lamp DOIF {if ([06:00-09:00] and [sensor:brightness] < 40) {fhem"set lamp:FILTER=STATE!=on on"} else {fhem"set lamp:FILTER=STATE!=off off"}}</code><br>
|
||||
<br>
|
||||
@ -5587,33 +5635,50 @@ Timer holen: <code><b>get_Timer(<TimerEvent>)</code></b>, Returnwert: 0, w
|
||||
<br>
|
||||
Laufenden Timer löschen: <code><b>del_Timer(<TimerEvent>)</code></b><br>
|
||||
<br>
|
||||
<u>Funktionstimer</u><br>
|
||||
Beispiel: Das Event "hello" 30 Sekunden verzögert auslösen:<br>
|
||||
<br>
|
||||
Timer setzen: <code><b>set_Exec(<timerName>, <seconds>, <function>, <parameter>)</code></b>, mit <timerName>: beliebige Angabe, sie spezifiziert eindeutig einen Timer,
|
||||
welcher nach Ablauf die angegebene Perl-Funktion <function> mit optionalen Parameter <parameter> aufruft. Die Perlfunkion muss eindeutig sein und in FHEM zuvor deklariert worden sein.
|
||||
<code>set_Time("event",30,"hello");</code><br>
|
||||
<br>
|
||||
<u>Ausführungstimer</u><br>
|
||||
<br>
|
||||
Timer setzen: <code><b>set_Exec(<timerName>, <seconds>, <perlCode>, <parameter>)</code></b>, mit <timerName>: beliebige Angabe, sie spezifiziert eindeutig einen Timer,
|
||||
welcher nach Ablauf den angegebenen Perlcode <perlCode> aufruft. Falls als Perlcode eine Perlfunktion angegeben wird, kann optional ein Übergabeparameter <parameter> angegeben werden. Die Perlfunkion muss eindeutig sein und in FHEM zuvor deklariert worden sein.
|
||||
Wird set_Exec mit dem gleichen <timerName> vor seinem Ablauf erneut aufgerufen, so wird der laufender Timer gelöscht und neugesetzt.<br>
|
||||
<br>
|
||||
Timer holen: <code><b>get_Exec(<timerName>)</code></b>, Returnwert: 0, wenn Timer abgelaufen oder nicht gesetzt ist, sonst Anzahl der Sekunden bis zum Ablauf des Timers<br>
|
||||
<br>
|
||||
Laufenden Timer löschen: <code><b>del_Exec(<timerName>)</code></b><br>
|
||||
<br>
|
||||
Beispiel: Lampe verzögert um 30 Sekunden ausschalten:<br>
|
||||
<br>
|
||||
<code>set_Exec("aus",30,'fhem"set lamp off"');</code><br>
|
||||
<br>
|
||||
Ein beliebiges FHEM-Event absetzen: <code><b>set_Event(<Event>)</code></b><br>
|
||||
<br>
|
||||
Reading schreiben: <code><b>set_Reading(<readingName>,<content>,<trigger>)</code></b>, mit <trigger>: 0 ohne Trigger, 1 mit Trigger<br>
|
||||
<br>
|
||||
Es können alle in FHEM vorhanden Funktionen genutzt werden. Größere Perlblöcke sollten in eigene Funktionen im subs-Block ausgelagert werden.
|
||||
Der Anwender hat die Möglichkeit Instanzvariablen beginnen mit $_ zu nutzen. Sie müssen nicht deklariert werden. Deren Gültigkeitsbereich ist ein definiertes DOIF-Device. Wenn sie nicht vorbelegt werden, gelten sie als nicht definiert. Das lässt sich abfragen mit:<br>
|
||||
<u>init-Block</u><br>
|
||||
<br>
|
||||
Wird ein Perlblock mit dem Namen "init" benannt, so wird er ausgeführt, nachdem das FHEM-System hochgefahren wurde. Er bietet sich insb. an, um Instanzvariablen des Moduls vorzubelegen.<br>
|
||||
<br>
|
||||
<u>Instanzvariablen</u><br>
|
||||
<br>
|
||||
Instanzvariablen sind Devicevariablen, die global innerhalb eines DOIF-Devices genutzt werden können. Sie beginnen mit $_ und müssen nicht deklariert werden. Wenn sie nicht vorbelegt werden, gelten sie als nicht definiert. Das lässt sich abfragen mit:<br>
|
||||
<br>
|
||||
<code>if (defined $_...) ...</code><br>
|
||||
<br>
|
||||
Instanzvariablen überleben nicht den Neustart, sie können jedoch im init-Block aus Readings vorbelegt werden.<br>
|
||||
Instanzvariablen überleben nicht den Neustart, sie können jedoch z.B. im init-Block, der beim Systemstart ausgewertet wird, aus Readings vorbelegt werden.<br>
|
||||
<br>
|
||||
Bsp. Vorbelgung einer Instanzvariablen beim Systemstart mit dem Status des Moduls:<br>
|
||||
<br>
|
||||
<code>init {$_status=ReadingsVal("$SELF","state",0)}</code><br>
|
||||
<br>
|
||||
alternativ<br>
|
||||
<br>
|
||||
<code>init {$_status=[?$SELF:state]}</code><br>
|
||||
<br>
|
||||
Instanzvariablen lassen sich indizieren, z. B.:<br>
|
||||
<br>
|
||||
<code>my $i=0;<br>
|
||||
$_betrag{$i}=100;</code><br>
|
||||
<br>
|
||||
@ -5653,23 +5718,29 @@ Für unterschiedliche blockierende Funktionen ist jeweils ein eigener Name (<
|
||||
<br>
|
||||
<b>Weitere Anwendungsbeispiele:</b><br>
|
||||
<br>
|
||||
<a name="DOIF_Treppenhauslicht mit Bewegungsmelder"></a>
|
||||
<u>Treppenhauslicht mit Bewegungsmelder</u><br>
|
||||
<br><code>
|
||||
define di_light DOIF {<br>
|
||||
if (["FS:motion"]) { # bei Bewegung<br>
|
||||
fhem"set lamp on" if ([?lamp] ne "on"); # Lampe einschalten, wenn sie nicht an ist<br>
|
||||
set_Exec("off",30,'fhem"set lamp off"'); # Timer namens "off" für das Ausschalten der Lampe auf 30 Sekunden setzen bzw. verlängern<br>
|
||||
}<br>
|
||||
}<br>
|
||||
</code>
|
||||
<br>
|
||||
<a name="DOIF_Einknopf_Fernbedienung"></a>
|
||||
<u>Einknopf-Fernbedienung</u><br>
|
||||
<br>
|
||||
Anforderung: Wenn eine Taste innerhalb von zwei Sekunden zwei mal betätig wird, soll der Rollladen nach oben, bei einem Tastendruck nach unten.<br>
|
||||
<br>
|
||||
<code>
|
||||
define di_shutter DOIF { # Block zur Auswertung des Tastendruckes<br>
|
||||
if (["FS:^on$"] and get_Timer("Timer_shutter")==0){ # wenn Taste betätigt wird und kein Timer läuft<br>
|
||||
set_Timer("Timer_shutter",2); # Timer für zwei Sekunden setzen<br>
|
||||
} else { # wenn Timer läuft, d.h. ein weitere Tastendruck innerhalb von zwei Sekunden<br>
|
||||
del_Timer("Timer_shutter") # Timer löschen<br>
|
||||
fhem"set shutter up"; # Rollladen hoch<br>
|
||||
}<br>
|
||||
}<br>
|
||||
{ # Block für die Bearbeitung des Timerevents<br>
|
||||
if ([$SELF:"Timer_shutter"]){ # wenn nach zwei Sekunden Timer abläuft, d.h. nur ein Tastendruck<br>
|
||||
fhem"set shutter down"; # Rollladen runter<br>
|
||||
define di_shutter DOIF {<br>
|
||||
if (["FS:^on$"] and !get_Exec("shutter")){ # wenn Taste betätigt wird und kein Timer läuft<br>
|
||||
set_Exec("shutter",2,'fhem"set shutter down"'); # Timer zum shutter down auf zwei Sekunden setzen<br>
|
||||
} else { # wenn Timer läuft, d.h. ein weitere Tastendruck innerhalb von zwei Sekunden<br>
|
||||
del_Timer("shutter"); # Timer löschen<br>
|
||||
fhem"set shutter up"; # Rollladen hoch<br>
|
||||
}<br>
|
||||
}<br>
|
||||
</code>
|
||||
@ -5679,43 +5750,12 @@ define di_shutter DOIF { &n
|
||||
Im folgenden Beispiel wird die Nutzung von Instanzvariablen demonstriert.<br>
|
||||
<br>
|
||||
<code>
|
||||
define di_count DOIF { # Block zur Auswertung des Ereignisses<br>
|
||||
if (["FS:on"] and get_Timer("Timer_counter")==0){ # wenn Ereignis (hier "FS:on") eintritt und kein Timer läuft<br>
|
||||
$_count=1; # setze count-Variable auf 1<br>
|
||||
set_Timer("Timer_counter",3600); # setze Timer auf eine Stunde<br>
|
||||
} else {<br>
|
||||
$_count++; # wenn Timer bereits läuft zähle Ereignis<br>
|
||||
}<br>
|
||||
}<br>
|
||||
{ # Block für die Auswertung nach Ablauf des Timers<br>
|
||||
if ([$SELF:"Timer_counter"]) { # wenn Timer nach einer Stunde abläuft<br>
|
||||
if ($_count > 10) {<br>
|
||||
Log 3,"count: $_count action"; # protokolliere im Log die Anzahl der Ereignisse, wenn sie über 10 ist<br>
|
||||
}<br>
|
||||
}<br>
|
||||
}<br>
|
||||
</code><br>
|
||||
<br>
|
||||
<a name="DOIF_Treppenhauslicht mit Bewegungsmelder"></a>
|
||||
<u>Treppenhauslicht mit Bewegungsmelder</u><br>
|
||||
<br><code><br>
|
||||
define di_light DOIF<br>
|
||||
subs { # Block "subs" zur Definition eigener Perl-Funktionen, hier ist nur Perl erlaubt ohne DOIF-Syntax<br>
|
||||
sub ein { # Perlfunktion "ein" zum Einschalten wird definiert<br>
|
||||
if (ReadingsVal ("lamp","state","") ne "on") {<br>
|
||||
fhem"set lamp on";<br>
|
||||
set_Reading ("state","on",1);<br>
|
||||
}<br>
|
||||
}<br>
|
||||
sub aus { # Perlfunkton "aus" zum Ausschalten wird definiert<br>
|
||||
fhem"set lamp off";<br>
|
||||
set_Reading ("state","off",1);<br>
|
||||
}<br>
|
||||
}<br>
|
||||
bewegung { # Block namens "bewegung" reagiert auf Bewegung von FS<br>
|
||||
if (["FS:motion"]) {<br>
|
||||
ein(); # Perlfunktion "ein" wird ausgeführt<br>
|
||||
set_Exec("light_off",10,"aus"); # Timer namens "light_off"für das Ausschalten über Perlfunktion "aus" wird gesetzt bzw. verlängert<br>
|
||||
define di_count DOIF {<br>
|
||||
if (["FS:on"] and !get_Exec("counter")) { # wenn Ereignis (hier "FS:on") eintritt und kein Timer läuft<br>
|
||||
$_count=1; # setze count-Variable auf 1<br>
|
||||
set_Exec("counter",3600,'Log (3,"count: $_count action") if ($_count > 10)'); # setze Timer auf eine Stunde zum Protokollieren der Anzahl der Ereignisse, wenn sie über 10 ist<br>
|
||||
} else {<br>
|
||||
$_count++; # wenn Timer bereits läuft zähle Ereignis<br>
|
||||
}<br>
|
||||
}<br>
|
||||
</code>
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user