Schalthandlung erst auslösen wenn Variablenwert für 10 Minuten überschritten

Hallo

ich möchte meine Rollos zum beschatten herunter fahren wenn 25000 Lux für 10 Minuten überschritten sind.
Bis jetzt setze ich bei 25000Lux eine Bool Variable auf true und ich löse ein Skript aus das einen Verzögerungstimer von 10 Minuten hat.
Jetzt fährt natürlich mein Rollo auch wenn 2 Minuten nach überschreiten von 25000Lux wieder eine Wolke den Wert unter 25000Lux fallen lässt.
Die Bool Variable setze ich erst bei einem Wert unter 8000Lux wieder zurück auf false, was zum hoch fahren der Rollos führt.

Ich steh leicht auf dem Schlauch wie ich das in IPS lösen kann.

Gruß
Jürgen

Werte doch aus, wann das Rollo das letzte Mal gefahren ist und setze keinen erneuten Fahrbefehl ab, wenn es z.B. vor vier Minuten gerade erst gefahren ist.

Ich möchte das runter fahren um 10 Minuten verzögern solange der Grenzwert überschritten ist. Fällt der Wert während der Timer läuft unter den Grenzwert soll der Timer wieder auf 0 gesetzt werden.

Dann solltest Du die Boolean Variable wieder auf FALSE setzen, wenn die Wolke kommt.

Hi,

du hast ja eine Variable sobald die 25000 überschritten werden.

Hier ein Beispiel:

<?

$status = GetValue(12345); // deine Variable
$time   = 600; // Zeit in Sekunden für den Timer

If ($_IPS['SENDER'] == "Variable")  
{

   If ($status == true)
   {
    IPS_SetScriptTimer($_IPS['SELF'],$time);
   }
   else
   {
   //mach nix
   }
}

else
{
echo "Dieses Sript kann nur entweder durch eine Variable oder ein Timerevent gestartet werden";
}

If ($_IPS['SENDER'] == "TimerEvent") // Wenn das Script durch den Timer gestartet wird
{
    If ($status == true)
    {
    //Befehl für Beschattung
    IPS_SetScriptTimer($_IPS['SELF'],0); // Timer ausschalten
    }
    else
    {
    IPS_SetScriptTimer($_IPS['SELF'],0); // Timer ausschalten
    }
}
else
{
}


?>

Erreigniss hinzufügen: Wenn deine Variable „true“ ist (also über 25000) soll dieser Script ausgeführt werden.
Einfach mal testen :slight_smile:

Gruß

so ähnlich sieht mein Skript im Moment aus. Wenn das Skript einmal läuft werden nach 10 Minuten die Rollos gefahren. Abbruch währe nur möglich wenn der Luxwert unter 8000 sinkt

Das Skript ist mein fahre ohne Sonne hoch Skript, bei meinem fahre runter Skript habe ich im Moment alles mit dem Timer aus kommentiert, sieht aber sonst gleich aus nur das natürlich alle Bedingungen gedreht sind.

<?

$verzoegerung = "10"; //in Minuten
$Sonne = GetValueBoolean(54025 /*[Sonne\Sensor West]*/);
$Tag = GetValueBoolean(24029 /*[Location\Ist es Tag]*/);
print "Sonne ist $Sonne";

if($_IPS['SENDER'] == "TimerEvent")
{
// Ist noch Sonne vorhanden oder kein Tag mehr, dann Skript abbrechen
if ($Sonne == true or $Tag == false)
{
//Timer ausschalten
IPS_SetScriptTimer($_IPS['SELF'], 0);
return;
}

// Rollos hoch fahren
HP_SetPosition(55011 /*[Rollos\ROL Kueche]*/, 0);
HP_SetPosition(17823 /*[Rollos\ROL Kueche Tuer]*/, 0);

//Timer ausschalten
IPS_SetScriptTimer($_IPS['SELF'], 0);
} else {
//Timer anschalten
IPS_SetScriptTimer($_IPS['SELF'], $verzoegerung*60);
}

?>

In einer SPS würde das Netzwerk so aussehen
-----|Vergleicher >25000|----------|Timer|---------(Merker Sonne setzen)
der Merker wird erst gesetzt wenn der Vergleicher die gesamte Zeit des Timers True setzt.

Ganz Allgemein würde ich so was mal unter Funktionswünsche eintragen, das lässt sich mit Skripten realisieren, es wäre aber aus meiner Sicht sehr wünschenswert, so was als bedingtes Ereignis bei Ereignissen in IP-Symcon zu ergänzen.

…so was ähnliches suche ich auch:D: Meine Rolladen sollen erst hinauffahren, wenn eine bestimmte Luxanzahl eine gewisse Zeit unterschritten ist (nicht bei jeder kleinen Wolke rauf und runter)

Bin leider auch nicht der Held in PHP :banghead:

Gruß, Werner

Man munkelt, dass es Systemintegratoren gibt, die für genau diesen Anwendungsfall fertige Lösungen anbieten :wink:

Ich glaube ich habe die Lösung für mein Problem

Wie schon eingangs geschrieben habe ich eine Variable die Sonne true oder false meldet
Ich habe ein Ereignis das bei Grenzwertüberschreitung von 25000 Lux auslöst und die Variable Sonne auf true setzt
Variable Sonne true.JPG

Das runter fahr Skript hat eine Scripttimer von 10 Minuten und eine Abfrage ob die Sonne false ist, wenn ja macht es nichts und setzt den Skripttimer auf 0

<?
$verzoegerung = "10";
$Sonne = GetValueBoolean(54025 /*[Sonne\Sensor West]*/);
//echo $Sonne;

if($_IPS['SENDER'] == "TimerEvent")
{
// Ist keine Sonne mehr vorhanden Skript abbrechen
if ($Sonne == false)
{
//Timer ausschalten
IPS_SetScriptTimer($_IPS['SELF'], 0);
return;
}

// Rollos auf Sonnenposition fahren
HP_SetPosition(55011 /*[Rollos\ROL Kueche]*/, 80);
HP_SetPosition(17823 /*[Rollos\ROL Kueche Tuer]*/, 80);

// BP_Beschattung West setzen
SetValue(33300 /*[Rollos\Beschattung West]*/,true);

//Timer ausschalten
IPS_SetScriptTimer($_IPS['SELF'], 0);
} else {
//An Befehl
//Timer anschalten
IPS_SetScriptTimer($_IPS['SELF'], $verzoegerung*60);
}

?>

weiter habe ich eine Variabel die Beschattung true oder false meldet. Hat das runterfahr Skript seine Arbeit getan und das Rollo ist in Beschattungsposition wird die Variable Beschattung true, solange der Skripttimer läuft ist die Variable Beschattung noch false.

Wird der Grenzwert von 25000 Lux unterschritten wird folgender Code ausgeführt.

$Sonne = GetValue($_IPS['TARGET']);
$Beschattung = GetValue(33300);
if ($Sonne == true and $Beschattung == false)
{
SetValue($_IPS['TARGET'], false);
}
else
{
return;
}

Ist noch nicht beschattet wird die Variable Sonne auf false gesetzt und das Skript bricht wie oben beschrieben ab wenn es durch den noch laufenden Spripttimer gestartet wird.

Bei Grenzwert unter 8000 Lux findet alles in umgekehrter Reihenfolge statt.

Ich hoffe das man mit meiner Erklärung was anfangen kann.

Gruß
Jürgen

Ich würde es über Mittelwertbildung, wie hier beschrieben regeln. So hab ichs zumindest gelöst und 10 Min finde ich relativ knapp. Das kann nerven an einem wechselhaft bewölktem Tag :wink:

Hi,
Ich würde so etwas über einen Zeitlich Gewichteten Mittelwert machen. Hat den Charme, das bei relativ sonnigem Wetter die RL runterfahren und wenn dann mal kurz ne Wolke vorbeikommt nicht gleich reagieren. Steigert sich die „Wolkenrate“ fährt der RL wieder hoch.

Funktioniert recht simpel:

Einen Script anlegen, der regelmäßig aufgerufen wird, Bspw. Alle 30 Sekunden.


$curlux= GetValue(12345);
$templux=GetValue(23456);//zwischenSpeicher (float)

$k=0.1; //Verzögerungswert abhängig von Aufrufrate und gewünschter Verzögerung
$new=($k*$curlux)+(1-$k)*$templux;
SetValue(23456,$new);

//Auswertung 
$einschaltschwelle=25000;
$ausschaltschwelle=20000;
if($new>$einschaltschwelle) SetValue(34567,....);//hochfahren
If($new<$ausschaltschwelle) SetValue (.....,.....);// runter fahren 

//fertig

Code sieht Handytippereibedingt etwas verpeilt aus.
VG Tom

Gesendet von iPhone mit Tapatalk

Hallo Tom,

das klingt interessant. Könntest Du die Formel für $new kurz erläutern und in diesem Zusammenhang, wie man den idealen Wert $k ermittelt?

Besten Dank und viele Grüße…!

Hi

Das ganze nennt sich Verzögerungsglied, PT1-Glied usw. kommt aus der Regelungstechnik. Den richtigen Wert von K kann man berechnen. Das halte ich aber für sehr kompliziert und überhaupt nicht nötig.

Die Formel funktioniert relativ einfach. Im Prinzip kannst du dir das so vorstellen, dass du eine Variable hast, die dir den Zustand deiner Helligkeit abbildet (=$templux) und zwar mit einer gewissen Trägheit. Jeder neue Messwert ($curlux) verändert diesen inneren Zustand. Das besondere ist, dass jeder neue Wert nur geringen Einfluss auf den neuen inneren Wert hat ($k*$curlux).

Damit sich der innere Wert irgendwann auf den tatsächlichen Wert einpendelt muss nur noch er aktuelle innere Wert mit 1-$k multipliziert werden und dazu addiert werden.

So genug der Vorrede.

Je größer $k ist, desto schneller reagiert der neue innere Wert auf die aktuelle tatsächliche Helligkeit. (setz mal im Extremfall $k=1).

Als Faustformel kannst Du annehmen, dass dein innerer Wert ($templux) nach 1/$k Zyklen fast ausgeglichen ist.

Mit anderen Worten: Je öfter (Zyklen pro Minute) Du berechnest, desto kleiner muss $k sein, je schneller Du Dein System machen willst desto größer muss $k sein. Je träger es sein soll, desto kleiner muss es sein.

Am einfachsten Du beginnst bei 0,1 und tastest Dich in den nächsten Tagen immer weiter an Dein gewünschtes Verhalten ran.

VG
Tom

Herzlichen Dank, Tom. Das werde ich entsprechend versuchen…

Viele Grüße!!!

@tommes:
Vielen Dank für den Code, Tom!
Das funktioniert für diese Anwendung (Helligkeit zur Beschattungssteuerung bei Bewölkung) wunderbar.

Guten Tag,

Das Skript funktioniert bei mir leider nicht ganz, mache ich hier etwas in Zeile 8 Falsch?

$curlux= GetValue(37384 /*[Systemgeräte\Eltako FWS61\Illumination West]*/);
$templux=GetValue(37384 /*[Systemgeräte\Eltako FWS61\Illumination West]*/);//zwischenSpeicher (float)

$k=0.1; //Verzögerungswert abhängig von Aufrufrate und gewünschter Verzögerung
$new=($k*$curlux)+(1-$k)*$templux;
SetValue(37384 /*[Systemgeräte\Eltako FWS61\Illumination West]*/,$new);

//Auswertung 
$einschaltschwelle=25000;
$ausschaltschwelle=20000;
if($new>$einschaltschwelle) SetValue(40972 /*[BLIND\LEVEL]*/,100);//hochfahren
If($new<$ausschaltschwelle) SetValue (40972 /*[BLIND\LEVEL]*/,0);// runter fahren 

//fertig


Gruß, Adrian

Hi,
Ja Bitte erstelle eine float Variable (Templux) und speichere dort den new-Wert als zwischenwert rein.

Also: oben templux auslesen, new berechnen, und zum Schluss den new-Wert wieder in templux abspeichern.
Dann sollte es klappen.
VG
Tom

Gesendet von iPhone mit Tapatalk