mirror of
https://github.com/fhem/fhem-mirror.git
synced 2025-04-29 17:37:09 +00:00
98_DOIF.pm: deleted functions: set_Timer, get_Timer, del_timer, commandref: perl mode revised
git-svn-id: https://svn.fhem.de/fhem/trunk@17411 2b470e98-0d58-463d-a4d8-8e2adae1ed80
This commit is contained in:
Damian
parent
608d23bd85
commit
948b77ac6c
@ -3262,16 +3262,6 @@ DOIF_Get($@)
|
||||
return undef;
|
||||
}
|
||||
|
||||
sub DOIF_PerlTimer
|
||||
{
|
||||
my ($timername)=@_;
|
||||
my ($name,$event)=split(":",$timername);
|
||||
DoTrigger($name, $event);
|
||||
$event =~ s/\W/_/g;
|
||||
delete ($::defs{$name}{READINGS}{"timer_$event"});
|
||||
}
|
||||
|
||||
|
||||
package DOIF;
|
||||
|
||||
use Date::Parse qw(str2time);
|
||||
@ -3290,7 +3280,7 @@ sub DOIF_ExecTimer
|
||||
eval ("package DOIF;$subname");
|
||||
} else {
|
||||
#eval ("package DOIF;$subname(\"$param\")");
|
||||
eval('no strict "refs";&{$subname}($param);use strict "refs"');
|
||||
eval('package DOIF;no strict "refs";&{$subname}($param);use strict "refs"');
|
||||
}
|
||||
if ($@) {
|
||||
::Log3 ($::defs{$name}{NAME},1 , "$name error in $subname: $@");
|
||||
@ -3316,7 +3306,6 @@ sub set_Exec
|
||||
::InternalTimer($next_time, "DOIF::DOIF_ExecTimer",\$hs->{ptimer}{$timername}, 0);
|
||||
}
|
||||
|
||||
|
||||
sub get_Exec
|
||||
{
|
||||
my ($timername)=@_;
|
||||
@ -3342,59 +3331,10 @@ sub del_Exec
|
||||
delete ($::defs{$hs->{NAME}}{READINGS}{"timer_$timername"});
|
||||
}
|
||||
|
||||
|
||||
sub set_Timer
|
||||
{
|
||||
my ($event,$seconds)=@_;
|
||||
my $name=$hs->{NAME};
|
||||
my $timername="$name:$event";
|
||||
my $current = ::gettimeofday();
|
||||
my $next_time = $current+$seconds;
|
||||
::RemoveInternalTimer($timername);
|
||||
$hs->{ptimer}{$timername}=$next_time;
|
||||
if ($seconds > 0) {
|
||||
$event =~ s/\W/_/g;
|
||||
::readingsSingleUpdate ($hs,"timer_$event",::strftime("%d.%m.%Y %H:%M:%S",localtime($next_time)),0);
|
||||
}
|
||||
::InternalTimer($next_time, "DOIF_PerlTimer", $timername, 0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
sub get_Timer
|
||||
{
|
||||
my ($event)=@_;
|
||||
my $name=$hs->{NAME};
|
||||
my $timername="$name:$event";
|
||||
my $current = ::gettimeofday();
|
||||
if (defined $hs->{ptimer}{$timername}) {
|
||||
my $sec=$hs->{ptimer}{$timername}-$current;
|
||||
if ($sec > 0) {
|
||||
return ($sec);
|
||||
} else {
|
||||
delete ($hs->{ptimer}{$timername});
|
||||
return (0);
|
||||
}
|
||||
} else {
|
||||
return (0);
|
||||
}
|
||||
}
|
||||
|
||||
sub del_Timer
|
||||
{
|
||||
my ($event)=@_;
|
||||
my $name=$hs->{NAME};
|
||||
my $timername="$name:$event";
|
||||
delete $hs->{ptimer}{$timername};
|
||||
$event =~ s/\W/_/g;
|
||||
delete ($::defs{$hs->{NAME}}{READINGS}{"timer_$event"});
|
||||
::RemoveInternalTimer($timername);
|
||||
}
|
||||
|
||||
sub set_Event
|
||||
{
|
||||
my ($event)=@_;
|
||||
set_Timer($event,0);
|
||||
::DoTrigger($hs->{NAME}, $event);
|
||||
}
|
||||
|
||||
sub set_State
|
||||
@ -3455,9 +3395,9 @@ sub fhem_set {
|
||||
return(::CommandSet(undef,$content));
|
||||
}
|
||||
|
||||
sub fhem {
|
||||
my ($content)=@_;
|
||||
return(::fhem($content));
|
||||
sub fhem ($@){
|
||||
my ($param, $silent) = @_;
|
||||
return(::fhem($param, $silent));
|
||||
}
|
||||
|
||||
sub Log {
|
||||
@ -5706,11 +5646,12 @@ Ein Ereignisblock wird ausgeführt, wenn dieser bedingt durch <a href="#DOIF_Ope
|
||||
Es wird die vollständige Perl-Syntax unterstützt. Es können beliebig viele Ereignisblöcke innerhalb eines DOIF-Devices definiert werden. Sie werden unabhängig voneinander durch passende Trigger ausgeführt. Der Name eines Ereignisblocks ist optional.<br>
|
||||
<br>
|
||||
Der Status des Moduls wird nicht vom Modul gesetzt, er kann vom Anwender mit Hilfe der Funktion <code>set_State</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. Für den häufig genutzten fhem-Befehl <b>set</b> wurde eine kompatible Perlfunkton namens <b>fhem_set</b> definiert. Sie ist performanter und sollte bevorzugt verwendet werden, da das Parsen nach dem FHEM-set Befehl entfällt.<br>
|
||||
FHEM-Befehle werden durch den Aufruf der Perlfunktion <code>fhem("...")</code> ausgeführt. Für den häufig genutzten fhem-Befehl <b>set</b> wurde eine kompatible Perlfunkton namens <b>fhem_set</b> definiert.
|
||||
Sie ist performanter und sollte bevorzugt verwendet werden, da das Parsen nach dem FHEM set-Befehl entfällt.<br>
|
||||
<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>
|
||||
Der Benutzer kann mit der Funktion <code>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>
|
||||
Definitionen im FHEM-Modus der Form:<br>
|
||||
Definitionen im FHEM-Modus mit do-Attribut der Form:<br>
|
||||
<br>
|
||||
<code>DOIF (<Bedingung mit Trigger>) (<FHEM-Befehle>) DOELSE (<FHEM-Befehle>)</code><br>
|
||||
<br>
|
||||
@ -5786,7 +5727,7 @@ Lampe ausschalten, beim Auftreten des Events "FS:on":<br>
|
||||
<br>
|
||||
<u>Eigene Funktionen</u><br>
|
||||
<br>
|
||||
Ein besonderer Block ist der Block namens "subs". In diesem Block werden Perlfunktionen definiert, die innerhalb des DOIFs genutzt werden.
|
||||
Ein besonderer Block ist der Block namens <b>subs</b>. In diesem Block werden Perlfunktionen definiert, 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>
|
||||
@ -5802,8 +5743,8 @@ subs { ## Definition von Perlfunktionen lamp_on und lamp_off<br>
|
||||
set_State("off");<br>
|
||||
}<br>
|
||||
}<br>
|
||||
{[06:00];lamp_on()} ## Um 06:00 Uhr wird die Funktion lamp_on aufgerufen<br>
|
||||
{[08:00}];lamp_off()} ## Um 08:00 Uhr wird die Funktion lamp_off aufgerufen<br>
|
||||
{[06:00];lamp_on()} ## Um 06:00 Uhr wird die Funktion lamp_on aufgerufen<br>
|
||||
{[08:00];lamp_off()} ## Um 08:00 Uhr wird die Funktion lamp_off aufgerufen<br>
|
||||
</code><br>
|
||||
<br>
|
||||
<u>Eigene Funktionen mit Parametern</u><br>
|
||||
@ -5813,7 +5754,7 @@ Unter Verwendung von Funktionsparamerter lassen sich Definitionen oft vereinfach
|
||||
DOIF
|
||||
subs { ## Definition der Perlfunktion lamp<br>
|
||||
sub lamp {<br>
|
||||
my ($state)=@_; # Variable $state mit dem Parameter belegen<br>
|
||||
my ($state)=@_;  # Variable $state mit dem Parameter belegen<br>
|
||||
fhem_set("lamp $state");<br>
|
||||
set_State($state);<br>
|
||||
}<br>
|
||||
@ -5822,43 +5763,30 @@ subs { ## Definition der Perlfunktion lamp<br>
|
||||
{[08:00];lamp("off")} ## Um 08:00 Uhr wird die Funktion lamp mit dem Parameter "off" aufgerufen<br>
|
||||
</code><br>
|
||||
<br>
|
||||
<br>Der Namensraum im Perl-Modus ist gekapselt. Selbst definierte Funktionen können nicht bereits existierende Perlfunktionen in FHEM überschreiben.
|
||||
Selten genutze Funktionen aus dem Namensraum von FHEM müssen mit vorangestellem Doppelpunkt (Namensraum main von FHEM) angegeben werden: ::<perlfunction><br>
|
||||
Der Namensraum im Perl-Modus ist gekapselt. Selbstdefinierte Funktionen im DOIF-Device können nicht bereits existierende Perlfunktionen in FHEM (Namensraum main) überschreiben.
|
||||
Funktionen aus dem Namensraum main müssen mit vorangestellem Doppelpunkt angegeben werden: <code>::<perlfunction></code><br>
|
||||
<br>
|
||||
Folgende FHEM-Perlfunktonen wurden im DOIF-Namensraum definiert: <code><b>fhem, Log, Log3, InternVal, InternalNum, OldReadingsVal, OldReadingsNum, OldReadingsTimestamp, ReadingsVal, ReadingsNum, ReadingsTeimestamp, ReadingsAge, Value, OldValue, OldTimestamp, AttrVal, AttrNum</code></b><br>
|
||||
Eigene Perlfunktionen, die in myutils ausgelagert sind, befinden sich ebenfalls im Namensraum main. Wenn sie ausschließich in DOIF-Devices benutzt werden sollen, so kann am Anfang vor deren Definition in myutils "package DOIF;" angegeben werden.
|
||||
In diesen Fall sind auch diese Funktion im DOIF-Device bekannt - sie können dann ohne vorangestellten Doppelpunkt genutzt werden.<br>
|
||||
<br>
|
||||
Die obigen Funktionen können wie gewohnt ohne vorangestellten Doppelpunkt genutzt werden.<br>
|
||||
Folgende FHEM-Perlfunktonen wurden ebenfalls im DOIF-Namensraum definiert, sie können, wie gewohnt ohne Doppelpunkt genutzt werden:<br>
|
||||
<br>
|
||||
<code><b>fhem, Log, Log3, InternVal, InternalNum, OldReadingsVal, OldReadingsNum, OldReadingsTimestamp, ReadingsVal, ReadingsNum, ReadingsTimestamp, ReadingsAge, Value, OldValue, OldTimestamp, AttrVal, AttrNum</code></b><br>
|
||||
<br>
|
||||
<a name="DOIF_Spezifische_Perl-Funktionen_im_Perl-Modus"></a>
|
||||
<b>Spezifische Perl-Funktionen im Perl-Modus</b><br>
|
||||
<br>
|
||||
<u>Ereignistimer</u><br>
|
||||
FHEM set-Befehl ausführen: <code><b>fhem_set(<content>)</code></b>, mit <content> Übergabeparameter des FHEM set-Befehls<br>
|
||||
<br>
|
||||
Timer setzen: <code><b>set_Timer(<TimerEvent>, <seconds>)</code></b>, mit <TimerEvent>: beliebige Angabe, sie spezifiziert eindeutig einen Timer und ist gleichzeitig ein Ereignis,
|
||||
welches nach Ablauf des Timers in FHEM erzeugt wird. Auf dieses Ereignis kann wie üblich mit der DOIF-Syntax durch die Angabe [$SELF:"^<TimerEvent>$"] reagiert werden.
|
||||
Wird set_Timer mit dem gleichen <TimerEvent> vor seinem Ablauf erneut aufgerufen, so wird der laufender Timer gelöscht und neugesetzt.<br>
|
||||
Beispiel: Lampe ausschalten:<br>
|
||||
<br>
|
||||
Timer holen: <code><b>get_Timer(<TimerEvent>)</code></b>, Returnwert: 0, wenn Timer abgelaufen oder nicht gesetzt ist, sonst Anzahl der Sekunden bis zum Ablauf des Timers<br>
|
||||
<code>fhem_set("lamp off");</code><br>
|
||||
<br>
|
||||
Laufenden Timer löschen: <code><b>del_Timer(<TimerEvent>)</code></b><br>
|
||||
entspricht:<br>
|
||||
<br>
|
||||
Beispiel: Das Event "hello" 30 Sekunden verzögert auslösen:<br>
|
||||
<code>fhem("set lamp off");</code><br>
|
||||
<br>
|
||||
<code>set_Time("hello",30);</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>
|
||||
Der Aufruf der fhem_set-Funktion ist performater, da das Parsen nach dem set-Befehl im Gegensatz zum Aufruf mit der Funkton <code>fhem</code> entfällt.<br>
|
||||
<br>
|
||||
Ein beliebiges FHEM-Event absetzen: <code><b>set_Event(<Event>)</code></b><br>
|
||||
<br>
|
||||
@ -5868,27 +5796,27 @@ Beispiel: Setze das Event "on":<br>
|
||||
<br>
|
||||
Status setzen: <code><b>set_State(<value>,<trigger>)</code></b>, mit <trigger>: 0 ohne Trigger, 1 mit Trigger, <trigger> ist optional, default ist 1<br>
|
||||
<br>
|
||||
Beispiel: Status auf "on" setzen:<br>
|
||||
Beispiel: Status des eignen DOIF-Device auf "on" setzen:<br>
|
||||
<br>
|
||||
<code>set_State("on");</code><br>
|
||||
<br>
|
||||
Status des eigenen Devices holen: <code><b>get_State()</code></b><br>
|
||||
Status des eigenen DOIF-Devices holen: <code><b>get_State()</code></b><br>
|
||||
<br>
|
||||
Beispiel: Schalte lampe mit dem eigenen Status:<br>
|
||||
<br>
|
||||
<code>fhem_set("lamp ".get_State());</code><br>
|
||||
<br>
|
||||
Eigenes Reading schreiben: <code><b>set_Reading(<readingName>,<value>,<trigger>)</code></b>, mit <trigger>: 0 ohne Trigger, 1 mit Trigger, <trigger> ist optional, default ist 0<br>
|
||||
Reading des eigenen DOIF-Devices schreiben: <code><b>set_Reading(<readingName>,<value>,<trigger>)</code></b>, mit <trigger>: 0 ohne Trigger, 1 mit Trigger, <trigger> ist optional, default ist 0<br>
|
||||
<br>
|
||||
<code>set_Reading("weather","cold");</code><br>
|
||||
<br>
|
||||
Reading des eigenen Devices holen: <code><b>get_Reading("readingName")</code></b><br>
|
||||
Reading des eigenen DOIF-Devices holen: <code><b>get_Reading(<readingName>)</code></b><br>
|
||||
<br>
|
||||
Beispiel: Schalte Lampe mit dem Inhalt des eigenen Readings "dim":<br>
|
||||
<br>
|
||||
<code>fhem_set("lamp ".get_Reading("dim"));</code><br>
|
||||
<br>
|
||||
Setzen mehrere Readings des eigenen Devices in einem Eventblock:<br>
|
||||
Setzen mehrerer Readings des eigenen DOIF-Devices in einem Eventblock:<br>
|
||||
<br>
|
||||
<code><b>set_Reading_Begin()</code></b><br>
|
||||
<code><b>set_Reading_Update(<readingName>,<value>,<change>)</code></b>, <change> ist optional<br>
|
||||
@ -5898,20 +5826,50 @@ Die obigen Funktionen entsprechen den FHEM-Perlfunktionen: <code>readingsBegin,
|
||||
<br>
|
||||
Beispiel:<br>
|
||||
<br>
|
||||
Die Readings "temperature" und "humidity" sollen in einem Eventblock mit dem zuvor belegten Inhalt der Perlvariablen $temp bzw. $hum belegt werden.<br>
|
||||
Die Readings "temperature" und "humidity" sollen in einem Eventblock mit dem zuvor belegten Inhalt der Variablen $temp bzw. $hum belegt werden.<br>
|
||||
<br>
|
||||
<code>set_Reading_Begin;</code><br>
|
||||
<code>set_Reading_Update("temperature",$temp);</code><br>
|
||||
<code>set_Reading_Update("humidity",$hum);</code><br>
|
||||
<code>set_Reading_End(1);</code><br>
|
||||
<br>
|
||||
<u>Ausführungstimer</u><br>
|
||||
<br>
|
||||
Mit Hilfe von Ausführungstimern können Anweisungen verzögert ausgeführt werden. Im Gegensatz zum FHEM-Modus können beliebig viele Timer gleichzeitig genutzt werden.
|
||||
Ein Ausführungstimer wird mit einem Timer-Namen eindeutig definiert. Über den Timer-Namen kann die Restlaufzeit abgefragt werden, ebenfalls kann er vor seinem Ablauf gelöscht werden.<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: Funktion namens "lamp" mit dem Übergabeparameter "on" 5 Sekunden verögert aufrufen:<br>
|
||||
<br>
|
||||
<code>set_Exec("lamp_timer",30,'lamp','on');</code><br>
|
||||
<br>
|
||||
alternativ<br>
|
||||
<br>
|
||||
<code>set_Exec("lamp_timer",30,'lamp("on")');</code><br>
|
||||
<br>
|
||||
Beispiel: Lampe verzögert um 30 Sekunden ausschalten:<br>
|
||||
<br>
|
||||
<code>set_Exec("off",30,'fhem_set("lamp off")');</code><br>
|
||||
<br>
|
||||
Beispiel: Das Event "off" 30 Sekunden verzögert auslösen:<br>
|
||||
<br>
|
||||
<code>set_Exec("off_Event",30,'set_Event("off")');</code><br>
|
||||
<br>
|
||||
<u>init-Block</u><br>
|
||||
<br>
|
||||
Wird ein Perlblock mit dem Namen "init" benannt, so wird dieser Block beim Systemstart ausgeführt. Er bietet sich insb. an, um Instanzvariablen des Moduls vorzubelegen.<br>
|
||||
Wird ein Ereignisblock mit dem Namen <b>init</b> benannt, so wird dieser Block beim Systemstart ausgeführt. Er bietet sich insb. an, um Device-Variablen des Moduls vorzubelegen.<br>
|
||||
<br>
|
||||
<u>Instanzvariablen</u><br>
|
||||
<u>Device-Variablen</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>
|
||||
Device-Variablen sind sogenannte Instanzvariablen, die global innerhalb eines DOIF-Devices genutzt werden können. Deren Inhalt bleibt während der Laufzeit des System erhalten. Sie beginnen mit <b>$_</b> 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>
|
||||
@ -5919,11 +5877,7 @@ Instanzvariablen überleben nicht den Neustart, sie können jedoch z.B. im init-
|
||||
<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>
|
||||
<code>init {$_status=get_State()}</code><br>
|
||||
<br>
|
||||
Instanzvariablen lassen sich indizieren, z. B.:<br>
|
||||
<br>
|
||||
@ -5936,14 +5890,16 @@ Ebenso funktionieren hash-Variablen z. B.: <br>
|
||||
<u>Blokierende Funktionsaufrufe (blocking calls)</u><br>
|
||||
<br>
|
||||
DOIF verwaltet blockierende Funktionsaufrufe, d.h. die in diesem Zusammenhang gestarteten FHEM-Instanzen werden gelöscht, beim Herunterfahren (shutdown), Wiedereinlesen der Konfiguration (rereadcfg) Änderung der Konfiguration (modify) und Deaktivieren des Gerätes (disabled).<br>
|
||||
<br>
|
||||
Die Handhabung von blockierenden Funktionsaufrufen ist im FHEMwiki erklärt, s. <a href="https://wiki.fhem.de/wiki/Blocking_Call">Blocking Call</a>.<br>
|
||||
Der von der Funktion BlockingCall zurückgegebene Datensatz ist unterhalb von $_blockingcalls abzulegen, z.B.<br>
|
||||
<br>
|
||||
Der von der Funktion BlockingCall zurückgegebene Datensatz ist unterhalb von <b>$_blockingcalls</b> abzulegen, z.B.<br>
|
||||
<br>
|
||||
<code>$_blockingcalls{<blocking call name>} = BlockingCall(<blocking function>, <argument>, <finish function>, <timeout>, <abort function>, <abort argument>) unless(defined($_blockingcalls{<blocking call name>}));</code><br>
|
||||
<br>
|
||||
Für unterschiedliche blockierende Funktionen ist jeweils ein eigener Name (<blocking call name>) unterhalb von $_blockingcalls anzulegen.<br>
|
||||
<br>
|
||||
<b>$_blockingcalls</b> ist eine für DOIF reservierte Variable und darf nur in der beschriebenen Weise verwendet werden.<br>
|
||||
<b>$_blockingcalls</b> ist eine für DOIF reservierte Variable und darf nur in der beschriebener Weise verwendet werden.<br>
|
||||
<br>
|
||||
<a name="DOIF_Attribute_Perl_Modus"></a>
|
||||
<u>Nutzbare Attribute im Perl-Modus</u><br>
|
||||
@ -5970,7 +5926,7 @@ Für unterschiedliche blockierende Funktionen ist jeweils ein eigener Name (<
|
||||
<u>Treppenhauslicht mit Bewegungsmelder</u><br>
|
||||
<br><code>
|
||||
define di_light DOIF {<br>
|
||||
if (["FS:motion"]) { # bei Bewegung<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>
|
||||
@ -5985,17 +5941,17 @@ Anforderung: Wenn eine Taste innerhalb von zwei Sekunden zwei mal betätig wird,
|
||||
<code>
|
||||
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>
|
||||
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>
|
||||
del_Exec("shutter"); # Timer löschen<br>
|
||||
fhem_set("shutter up"); # Rollladen hoch<br>
|
||||
}<br>
|
||||
}<br>
|
||||
</code>
|
||||
<br>
|
||||
<u>Aktion auslösen, wenn innerhalb einer bestimmten Zeitspanne ein Ereignis x mal eintritt</u><br>
|
||||
<br>
|
||||
Im folgenden Beispiel wird die Nutzung von Instanzvariablen demonstriert.<br>
|
||||
Im folgenden Beispiel wird die Nutzung von Device-Variablen demonstriert.<br>
|
||||
<br>
|
||||
<code>
|
||||
define di_count DOIF {<br>
|
||||
@ -6011,23 +5967,17 @@ define di_count DOIF {<br>
|
||||
<a name="DOIF_Fenster_offen_Meldung"></a>
|
||||
<u>Verzögerte Fenster-offen-Meldung mit Wiederholung für mehrere Fenster</u><br>
|
||||
<br>
|
||||
<code>define di_window DOIF { # Block zum Auswerten des Ereignisses: "Fenster geöffnet"<br>
|
||||
if (["_window$:open"]) { # wenn ein Fensterdevice endend mit "_window" geöffnet wird<br>
|
||||
set_Timer ("WINDOW_$DEVICE",600) # setze einen Timer auf 10 Minuten<br>
|
||||
}<br>
|
||||
}<br>
|
||||
{ # Block zum Auswerten des Ereignisses: "Fenster gechlossen"<br>
|
||||
if (["_window$:closed"]) {<br>
|
||||
del_Timer ("WINDOW_$DEVICE") # Timer löschen, wenn Fenster geschlossen wird<br>
|
||||
}<br>
|
||||
}<br>
|
||||
{ # Block zur Auswertung des zuvor gesetzten Timers<br>
|
||||
if (["^$SELF:^WINDOW_"]) { # wenn das zuvor gesetzte Timerevent kommt<br>
|
||||
my ($window,$device)=split("_","$EVENT"); # bestimme das Device aus dem Timerevent "WINDOW_$DEVICE"<br>
|
||||
Log 3,"Fenster offen, bitte schließen: $device"; # Meldung wird protokolliert<br>
|
||||
set_Timer ("WINDOW_$device",1800) # setze einen neuen Timer für das Fenster für eine erneute Meldung in 30 Minuten<br>
|
||||
<code>
|
||||
define di_window DOIF<br>
|
||||
subs {<br>
|
||||
sub logwin { # Definition der Funkton namens "logwin"<br>
|
||||
my ($window)=@_; # übernehme Parameter in die Variable $window<br>
|
||||
Log 3,"Fenster offen, bitte schließen: $window"; # protokolliere Fenster-Offen-Meldung<br>
|
||||
set_Exec ("$window",1800,"logwin",$window); # setze Timer auf 30 Minuten für eine wiederholte Meldung<br>
|
||||
}<br>
|
||||
}<br>
|
||||
{ if (["_window$:open"]) {set_Exec ("$DEVICE",600,'logwin("$DEVICE")')}} # wenn, Fenster geöffnet wird, dann setze Timer auf Funktion zum Loggen namens "logwin"<br>
|
||||
{ if (["_window$:closed"]) {del_Exec ("$DEVICE")}} # wenn, Fenster geschlossen wird, dann lösche Timer<br>
|
||||
</code>
|
||||
</ul>
|
||||
=end html_DE
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user