Ankündigung

Einklappen
Keine Ankündigung bisher.

Plugin RollladenAutomatik und hallo zusammen

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

    [WireGate-Plugin] Plugin RollladenAutomatik und hallo zusammen

    Hallo zusammen,

    nach langem Mitlesen hier im Forum ist es nun mal an der Zeit meinen ersten Beitrag zu schreiben.
    Zunächst mal zu mir.
    Ich heiße Martin, bin 33 Jahre alt und komme aus dem schönen Bayerisch-Schwaben.
    Nach einem abgebrochenen Studium machte ich eine Lehre als Elektroniker für Automatisierungstechnik und bin nun seit 6 Jahren in einem mittelständischen Unternehmen in der Elektrokonstruktion mit Schwerpunkt Antriebstechnik tätig.

    In meinem Haus habe ich diverese KNX-Geräte, 1-Wire und Dali verbaut. Die meiste Steuerungen übernimmt seit knapp über einem Jahr ein WireGate.
    Bei den Plugins habe ich zum Teil leider gemerkt, dass hier es oft leider noch Änderungswünsche gab aber leider nicht realisiert wurden.

    Da ich vom Forum viel profitiert habe möchte ich euch an meinen Änderungen teilhaben lassen.

    So habe ich das Plugin RolladenAutomatik V1.1 2014-09-16 etwas überarbeitet.
    Vielen Dank aber an die Grundlage an kleinklausi und krumboeck

    Meine Änderungen:
    • Bei Fensterdefinition auch Elevation oben bzw. unten angeben
    • Hysterese von Temperatur getrennt einstellbar
    • Möglichkeit bei gekippten oder geöffnetem Fenster auf bestimmte Positionen zu fahren
    • Beschattung aufgrund von Helligkeit je nach Sonnen-Elevation (Auswertung seperates Plugin)
    • Sperre der einzelnen Rolläden wurde auf eine Freigabe geändert, da meine Rademacher bei Automatik immer eine 1 ausgeben
    • Auffahren bzw. Zufahren der Rolläden in der Früh bzw. am Abend nicht über Elevation, sondern über Helligkeitswert

    RolladenAutomatik
    Code:
    ######################################################################################
    # Plugin RollladenAutomatik
    # V1.2 2018-09-03
    # Lizenz: GPLv2
    # Autoren: kleinklausi (http://knx-user-forum.de/members/kleinklausi.html)
    #          krumboeck (http://knx-user-forum.de/members/krumboeck.html)
    #       Advenoni (http://knx-user-forum.de/members/advenoni.html)
    # Benötigt: libastro-satpass-perl -> 'apt-get install libastro-satpass-perl'
    #
    # Ein Wiregate Plugin zum automatischen Fahren der Rollläden. Es berechnet unter Anderem
    # den Stand der Sonne und fährt je nach Winkel der Sonne zum Fenster, den Rollladen in
    # eine Beschattungsposition. Folgende Funktionen werden unterstützt:
    #    - Sonnenstand (Azimuth)
    #    - Anfangs- und Endwinkel (Azimuth) ab dem das Fenster beschienen wird
    #    - Globale Sperre duch eine Gruppenadresse
    #    - Sperre eines einzelnen Rollladens durch eine Gruppenadresse
    #    - Fahren des Rollladen zu (1) oder auf (0) oder Positionsfahren mit Prozentwert
    #    - Zufahren bei Dunkelheit am Abend und Hell am Morgen
    #    - Bugfix für Busch-Jäger USB Schnittstelle (muss eingeschaltet werden)
    #    - Vorlagen um die Konfiguration zu vereinfachen (krumboeck)
    #    - Rolladenschutz vor hohen Windgeschwindigkeiten (krumboeck)
    #    - Zufahren bei sehr niedgrigen Außentemperaturen um die Isolationswirkung zu erhöhen (krumboeck)
    #    - Öffnen bei sehr starker Bewölkung um die Helligkeit im Raum zu erhöhen (krumboeck)
    #    - Seperate Konfigurationsdatei (krumboeck)
    #    - Steuerung aufgrund der Raumtemperatur (krumboeck)
    #    - Hysteresewerte für Temperatur, Wind und Bewölkung (krumboeck)
    #    - Speichern der Rolladenposition und aktuellen Zuständen (krumboeck)
    #    - Fahren auf Positionen welche im Aktor (z.B. Siemens 523/03) gespeichert sind (krumboeck)
    #    - Überprüfen von Positionen vor Sonnenauf bzw. -untergang (krumboeck)
    #    - Nach Aufhebung der Sperre auf Position fahren (krumboeck)
    #    - Hinzufügen von Bedingungen (krumboeck)
    #    - Erweiterte Einstellungen für Sonnenauf- und untergang (krumboeck)
    #    - Bei Fensterdefinition auch Elevation oben bzw. unten angeben (Advenoni)
    #    - Hysterese von Temperatur getrennt einstellbar (Advenoni)
    #    - Möglichkeit bei gekippten oder geöffnetem Fenster auf bestimmte Positionen zu fahren (Advenoni)
    #    - Beschattung aufgrund von Helligkeit je nach Sonnen-Elevation (Advenoni) (Auswertung seperates Plugin)
    #    - Sperre der einzelnen Rolläden wurde auf eine Freigabe geändert, da meine Rademacher bei Automatik immer eine 1 ausgeben (Advenoni)
    #    - Auffahren bzw. Zufahren der Rolläden in der Früh bzw. am Abend nicht über Elevation, sondern über Helligkeitswert (Advenoni)
    ######################################################################################
    
    
    #########################
    ### BEGINN DEFINITION ###
    #########################
    
    use constant HIGHER => 1;
    use constant EQUAL => 0;
    use constant LOWER => -1;
    
    use constant MONTAG => 1;
    use constant DIENSTAG => 2;
    use constant MITTWOCH => 3;
    use constant DONNERSTAG => 4;
    use constant FREITAG => 5;
    use constant SAMSTAG => 6;
    use constant SONNTAG => 7;
    
    # Die Koordinaten des Hauses. Sehr einfach über http://www.getlatlon.com/ zu ermitteln.
    # Und die Höhe über NN
    my ($lat, $lon, $elev);
    
    # Elevation der Sonne, ab der es abends dunkel ist bzw. morgens hell ist.
    # Bürgerliche Dämmerung ist bei -6 Grad.
    my $daemmerung_helligkeit;
    my $Sonne_aufgegangen = $plugin_info{$plugname.'_Sonne_aufgegangen'};
    
    # Gruppenadresse, über welche die komplette Automatik für alle Rollläden gesperrt werden kann
    my $GAsperreAlle;
    
    # Bugfix für KNX-Schnittstellen die sich bei zu schneller Telegrammabfolge
    # verschlucken, und denen wir deshalb die Geschwindigkeit der Telegramme drosseln müssen
    my $bugfixSlowInterface = 0;
    
    # Ein Array von Hashes, wobei jeder Hash ein Rollladen/Fenster/Raum ist.
    my @AlleRolllaeden;
    
    # Gruppenadresse für die Windgeschwindigkeit
    my $GAWindSpeed;
    
    
    # Gruppenadresse für die Helligkeit
    my $HelligkeitMax = 0;
    my $Beschattung_Ein = 0;
    my $Var_Beschattung_Freigabe_Helligkeit;
    my $Var_Beschattung_Max_Helligkeit;
    
    # Gruppenadresse für die Außentemperatur
    my $GATemperature;
    
    # Gruppenadressen für den Sonnenstand
    my $gv_gaAzimuth;
    my $gv_gaElevation;
    
    
    #################################
    ### Lesen der Konfigurationsdatei
    #################################
    
    my ($user, $pass, $name, $lat, $lon, $alt, $GAtemp);
    my @TimeExclusions;
    
    # Read config file in conf.d
    my $confFile = '/etc/wiregate/plugin/generic/conf.d/'.basename($plugname,'.pl').'.conf';
    if (! -f $confFile) {
        plugin_log($plugname, " no conf file [$confFile] found.");
        return "no conf file [$confFile] found.";
    } else {
        open(CONF, $confFile);
        my @lines = <CONF>;
        close($confFile);
        my $result = eval("@lines");
        if ($@) {
            plugin_log($plugname, "conf file [$confFile] returned:");
            my @parts = split(/\n/, $@);
            plugin_log($plugname, "--> $_") foreach (@parts);
        }
    }
    
    # Festlegen, dass das Plugin alle 5 Minuten laufen soll
    $plugin_info{$plugname.'_cycle'} = 300;
    
    my $debug = 0;
    
    #######################
    ### ENDE DEFINITION ###
    #######################
    
    if (defined $GAsperreAlle) {
        # Auf die GA der globalen Sperre anmelden
        # TODO: muss man sich überhaupt auf die GA anmelden. Sollte doch reichen wenn man den letzten Stand liest...
        $plugin_subscribe{$GAsperreAlle}{$plugname} = 1;
        # Fals global gesperrt, Plugin-Durchgang beenden
        if (knx_read($GAsperreAlle, 0) == 1) {
            return "Global gesperrt";
        }
    }
    
    my $weather = {};
    if (defined $GAWindSpeed) {
        $weather->{windSpeed} = knx_read($GAWindSpeed, 1800);
    }
    
    # Sonnenstands-Berechnungen durchführen
    my ($azimuth, $elevation) = berechneSonnenstand($lat, $lon, $elev);
    
    # Auslesen wo die Sonne beim letzten Durchgang war
    my $lastAzimuth = $plugin_info{$plugname.'_lastAzimuth'};
    my $lastElevation = $plugin_info{$plugname.'_lastElevation'};
    
    $weather->{beschattung} = $plugin_info{$Var_Beschattung_Freigabe_Helligkeit};
    $HelligkeitMax = $plugin_info{$Var_Beschattung_Max_Helligkeit};
    
    my $MorgenDaemmerung = (round(rad2deg($azimuth)) < 180 &&  $HelligkeitMax > $daemmerung_helligkeit && !$Sonne_aufgegangen);
    my $AbendDaemmerung = (round(rad2deg($azimuth)) > 180 &&  $HelligkeitMax < $daemmerung_helligkeit && $Sonne_aufgegangen);
    
    if (170 < round(rad2deg($azimuth)) && round(rad2deg($azimuth)) < 180) {$Sonne_aufgegangen = 1;} # Falls etwas schiefging auf jeden Fall setzen.
    if (round(rad2deg($azimuth)) < 10) {$Sonne_aufgegangen = 0;}  # Falls etwas schiefging auf jeden Fall rücksetzen.
    
    if ($AbendDaemmerung) {$Sonne_aufgegangen = 0;}
    if ($MorgenDaemmerung) {$Sonne_aufgegangen = 1;}
    my $Nacht = !$Sonne_aufgegangen;
    
    $plugin_info{$plugname.'_Sonne_aufgegangen'} = $Sonne_aufgegangen;
    
    
    if (defined $GATemperature) {
        $weather->{temperature} = knx_read($GATemperature, 1800);
    }
    
    my %rolllaeden;
    foreach my $element (@AlleRolllaeden) {
        $rolllaeden{$element->{name}} = $element;
    }
    
    # Los gehts. Jeden Rolladen/Fenster/Raum abarbeiten.
    foreach my $element (@AlleRolllaeden) {
    
        if (defined $element->{istVorlage} && $element->{istVorlage}) {
            next;
        }
    
        my $rolladen = berechneRolladenParameter($element, 0);
    
        if (defined $rolladen->{bedingung} && !callBedingung($rolladen)) {
            if (defined $rolladen->{debug} && $rolladen->{debug}) {
                plugin_log($plugname, "Name: " . $rolladen->{name} . "; Bedingung nicht erfüllt");
            }
            next;
        }
    
        if (defined $rolladen->{GAautomatik}) {
            $plugin_subscribe{$rolladen->{GAautomatik}}{$plugname} = 1;
            # Falls gesperrt, mit nächstem Rollladen fortfahren
            if (knx_read($rolladen->{GAautomatik}, 0) == 0) {
                speichereRolladenParameter($rolladen, "locked", 1);
                plugin_log($plugname,"Name: " . $rolladen->{name} . "; Sperre für Rolladen wurde empfangen");
                next;
            }
        }
    
        if (defined $rolladen->{GAFensterStatus}) {
            $plugin_subscribe{$rolladen->{GAFensterStatus}}{$plugname} = 1;
        }
    
        # Ermittle gewünschte Position und Grund des Fahrens für den Rollladen
        my ($position, $bemerkung) = berechneRolladenposition($rolladen, $azimuth, $elevation, $lastAzimuth, $lastElevation, $weather);
    
        # Fahre den Rollladen wenn es einen Positionswunsch gibt
        if (defined $position) {
    
            if ($position =~ m/((\d+|\*));Position:(\d+)/) {
                if (positionChanged($rolladen, $position)) {
                    ladeRollladenPosition($rolladen, $position, $3);
                    plugin_log($plugname,"Name: " . $rolladen->{name} . " (Lade Pos); " . $bemerkung);
                }
            } else {
                if (positionChanged($rolladen, $position)) {
                    fahreRollladen($rolladen, $position);
                    plugin_log($plugname,"Name: " . $rolladen->{name} . "; " . $bemerkung);
                }
            }
        } elsif (defined $rolladen->{debug} && $rolladen->{debug}) {
            plugin_log($plugname,"Name: " . $rolladen->{name} . "; Fahren wird fuer diesen Zyklus ausgesetzt");
        }
    
    }
    
    # Für die nächste Iteration den aktuellen Sonnenstand merken
    $plugin_info{$plugname.'_lastAzimuth'} = $azimuth;
    $plugin_info{$plugname.'_lastElevation'} = $elevation;
    if ($gv_gaAzimuth ne '') { knx_write($gv_gaAzimuth, round(rad2deg($azimuth))); }
    if ($gv_gaElevation ne '') { knx_write($gv_gaElevation, round(rad2deg($elevation))); }
    
    return "Azimuth: " . round(rad2deg($azimuth)) . "; Elevation: " . round(rad2deg($elevation));
    
    
    ############################################
    # Bedingung ausführen
    ############################################
    sub callBedingung {
        my ($rolladen) = @_;
        my ($sekunde, $minute, $stunde, $tag, $monat, $jahr, $wochentag, $tagImJahr, $isdst) = localtime(time);
        $monat += 1;
        $tagImJahr += 1;
        if ($wochentag == 0) {
            $wochentag = 7;
        }
        $jahr += 1900;
        my $result = eval $rolladen->{bedingung};
        if ($@) {
            plugin_log($plugname,"Name: " . $rolladen->{name} . "; Fehler in Bedingung: " . $@);
            return 0;
        }
        return $result;
    }
    
    sub toDayOfYear {
        my ($day, $month, $year)=@_;
        my @cumul_d_in_m = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365);
        my $doy=$cumul_d_in_m[--$month]+$day;
        return $doy if $month < 2;
        return $doy unless $year % 4 == 0;
        return ++$doy unless $year % 100 == 0;
        return $doy unless $year % 400 == 0;
        return ++$doy;
    }
    
    ############################################
    # Prüft ob der Rolladen gefahren werden muss
    ############################################
    sub positionChanged {
        my ($rolladen, $newPosition) = @_;
    
        # Ermittle die aktuelle Position
        my $lastPosition = ladeRolladenParameter($rolladen, "position");
    
        my $testLockChanged = 0;
        if (defined $rolladen->{GAautomatik}) {
            my $parameterLocked = ladeRolladenParameter($rolladen, "locked");
            if (defined $parameterLocked && $parameterLocked && knx_read($rolladen->{GAautomatik}, 0) == 1) {
                speichereRolladenParameter($rolladen, "locked", 0);
                if (defined $rolladen->{pruefePositionNachSperre} && $rolladen->{pruefePositionNachSperre}) {
                    $testLockChanged = 1;
    
                }
            }
        }
    
        my $fensterschalter_changed = 0;
        if (defined $rolladen->{GAFensterStatus}){
            my $FensterStatus = ladeRolladenParameter($rolladen, "FensterStatus");
            if (defined $FensterStatus && ($FensterStatus != knx_read($rolladen->{GAFensterStatus}, 0))) {
                speichereRolladenParameter($rolladen, "FensterStatus", $FensterStatus);
                $fensterschalter_changed = 1;
            }
        }
    
        my $newPositionValue = $newPosition;
        if ($newPosition =~ m/((\d+|\*));Position:(\d+)/) {
            $newPositionValue = $1;
        }
        my $lastPositionValue = $lastPosition;
        if ($lastPosition =~ m/((\d+|\*));Position:(\d+)/) {
            $lastPositionValue = $1;
        }
    
        if ((defined $rolladen->{pruefePositionSonnenAufUnter} && $rolladen->{pruefePositionSonnenAufUnter} == 1
                && ($AbendDaemmerung || $MorgenDaemmerung))
            || $testLockChanged
            || $fensterschalter_changed
            || (($lastPosition ne $newPosition) && ($lastPositionValue eq "*"))) {
            if (defined $rolladen->{GAistPos}) {
                $lastPositionValue = knx_read($rolladen->{GAistPos}, 0);
                $lastPositionValue = sprintf("%d", $lastPositionValue);
                if (defined $rolladen->{debug} && $rolladen->{debug}) {
                    plugin_log($plugname,"Name: " . $rolladen->{name} . "; Rollladen meldete Position: " . $lastPositionValue);
                }
            } elsif ($testLockChanged || $fensterschalter_changed) {
                $lastPositionValue = -1;
            } else {
                plugin_log($plugname,"Name: " . $rolladen->{name} . "; Konfiguration benötigt GAistPos für diesen Rollladen");
            }
        }
    
        if ($newPosition == 1) {
            $newPosition = 100;
        }
        if ($newPositionValue == 1) {
            $newPositionValue = 100;
        }
        if (defined $rolladen->{debug} && $rolladen->{debug}) {
            plugin_log($plugname,"Name: " . $rolladen->{name} . "; Last-Pos: " . $lastPosition . "; Pos: " . $newPosition);
            plugin_log($plugname,"Name: " . $rolladen->{name} . "; Last-Pos-Value: " . $lastPositionValue . "; Pos-Value: " . $newPositionValue);
        }
        if (($lastPosition ne $newPosition) || ($newPositionValue <= ($lastPositionValue - 1)) || ($newPositionValue >= ($lastPositionValue + 1))) {
            return 1;
        } else {
            return 0;
        }
    }
    
    ###################################
    # Berechne Parameter eines Rolladen
    ###################################
    sub berechneRolladenParameter {
        my ($rolladen, $counter) = @_;
        if ($counter > 20) {
            die $plugname . "Name: " . $rolladen->{name} . "; Endlosschleife bei Templates";
        }
        if (defined $rolladen->{vorlage}) {
            my $template = berechneRolladenParameter($rolllaeden{$rolladen->{vorlage}}, $counter + 1);
            foreach my $key (keys (%$template)) {
                if (!defined $rolladen->{$key}) {
                    if ($debug) {
                        plugin_log($plugname,"Name: " . $rolladen->{name} . "; Uebernehme Parameter " . $key . " aus Template " . $template->{name});
                    }
                    $rolladen->{$key} = $template->{$key};
                }
            }
        }
        return $rolladen;
    }
    
    
    ####################################################
    # Aufruf mit berechneSonnenstand($lat, $lon, $elev);
    ####################################################
    sub berechneSonnenstand {
        # Module laden
        use Astro::Coord::ECI;
        use Astro::Coord::ECI::Sun;
        use Astro::Coord::ECI::TLE;
        use Astro::Coord::ECI::Utils qw{rad2deg deg2rad};
        # Aktuelle Zeit
        my $time = time ();
        # Die eigenen Koordinaten
        my $loc = Astro::Coord::ECI->geodetic(deg2rad(shift), deg2rad(shift), shift);
        # Sonne instanzieren
        my $sun = Astro::Coord::ECI::Sun->universal($time);
        # Feststellen wo die Sonne gerade ist
        my ($azimuth, $elevation, $range) = $loc->azel($sun);
        return ($azimuth, $elevation);
    }
    
    
    ##################################
    # Berechne Position eines Rolladen
    ##################################
    sub berechneRolladenposition {
        my ($element, $azimuth, $elevation, $lastAzimuth, $lastElevation, $weather) = @_;
    
        # Die Azimuthwinkel in Radians umrechnen
        my $azimuth1 = deg2rad($element->{azimuth1});
        my $azimuth2 = deg2rad($element->{azimuth2});
    
        # Die Elevationwinkel in Radians umrechnen
        my $elevation1 = deg2rad($element->{elevation1});
        my $elevation2 = deg2rad($element->{elevation2});
    
        # Teste ob das Fenster beschienen wird
        my $testAktuellBeschienen = ($azimuth > $azimuth1 && $azimuth < $azimuth2 && $elevation > $elevation1 && $elevation < $elevation2) || 0;
        my $testVoherBeschienen = ($lastAzimuth > $azimuth1 && $lastAzimuth < $azimuth2 && $lastElevation > $elevation1 && $lastElevation < $elevation2) || 0;
    
        my $aenderung_pos = 0;
    
        # Test ob Rolladen gesperrt war, damit gefahren wird obwohl das betreffende Fenster nicht mehr beschienen wird
        my $parameterLocked = ladeRolladenParameter($element, "locked");
        if (! defined $parameterLocked) {
            $parameterLocked = 0;
        }
    
        my ($position, $bemerkung);
    
        if (defined $element->{maxWindGeschw}) {
            if (defined $weather->{windSpeed}) {
                my $compare = vergleicheWert($weather->{windSpeed}, $element->{maxWindGeschw}, $element->{windGeschwHysterese});
                if ($compare == HIGHER) {
                    speichereRolladenParameter($element, "windProtection", 1);
                }
                if ($compare == LOWER) {
                    speichereRolladenParameter($element, "windProtection", 0);
                }
            }
            my $windProtection = ladeRolladenParameter($element, "windProtection");
            if (defined $windProtection && $windProtection) {
                $position = $element->{wertAufSchutz} || 0;
                $bemerkung = "Wegen zu hoher Windgeschwindigkeit auffahren bei " + $weather->{windSpeed} . " km/h";
                return ($position, $bemerkung);
            }
        }
        # Ermittle die aktuelle Position
        my $lastPosition = ladeRolladenParameter($element, "position");
    
        if (defined $element->{GAFensterStatus}) {
            my $FensterStatus = knx_read($element->{GAFensterStatus}, 0);
            speichereRolladenParameter($element, "FensterStatus", $FensterStatus);
            if ($FensterStatus == 0 && defined $element->{wertOffen}) {
                if ($element->{wertOffen} < $lastPosition){    # nur fahren wenn weiter geöffnet werden muss
                    $position = $element->{wertOffen};
                    $bemerkung = "Fenster geöffnet";
                } else {
                    $position = $lastPosition;
                    $bemerkung = "Fenster geöffnet und Rolladen schon oben";
                }
                return ($position, $bemerkung);
            }elsif ($FensterStatus == 1 && defined $element->{wertGekippt}) {
                if ($element->{wertGekippt} < $lastPosition){    # nur fahren wenn weiter geöffnet werden muss
                    $position = $element->{wertGekippt};
                    $bemerkung = "Fenster gekippt";
                } else {
                    $position = $lastPosition;
                    $bemerkung = "Fenster gekippt und Rolladen schon oben";
                }
                return ($position, $bemerkung);
            }
        }
    
    
        if ($element->{sonnenAufUnter} > 0) {
            if ($Nacht && ($element->{sonnenAufUnter} == 1 || $element->{sonnenAufUnter} == 3)) {
                $position = $element->{wertZuNacht};
                $bemerkung = "Wegen Abenddaemmerung zufahren bei: " . round(rad2deg($azimuth));
                return ($position, $bemerkung);
            } elsif ($MorgenDaemmerung && ($element->{sonnenAufUnter} == 1 || $element->{sonnenAufUnter} == 2)) {
                $position = $element->{wertAufNacht};
                $bemerkung = "Wegen Morgendaemmerung auffahren bei: " . round(rad2deg($azimuth));
            }
        }
    
        # Fenster wird von der Sonne beschienen
        if (!$testVoherBeschienen && $testAktuellBeschienen) {
            $position = $element->{wertZuBesch};
            $aenderung_pos = 1;
            $bemerkung = "Wegen Sonne zufahren bei: " . round(rad2deg($azimuth));
        } elsif (($parameterLocked || $testVoherBeschienen) && !$testAktuellBeschienen) {
            $position = $element->{wertAufBesch};
            $bemerkung = "Wegen Sonne auffahren bei: " . round(rad2deg($azimuth));
        }
    
        my $testTempNiedrig = 0;
        my $testTempHoch = 0;
        if (!$Nacht && $testAktuellBeschienen) {
            if ($element->{tempGesteuert}) {
                # Solltemperatur für den Raum feststellen
                my $sollTemp;
                if (defined $element->{GAraumSollTemp}) {
                    $sollTemp = knx_read($element->{GAraumSollTemp}, 300);
                }
                    if (!defined $sollTemp) {
                        $sollTemp = $element->{raumSollTemp};
                    }
    
                # Aktuelle Temperatur für den Raum feststellen
                my $istTemp = knx_read($element->{GAraumIstTemp}, 300);
    
                if (defined $sollTemp && defined $istTemp) {
                    my $tempHystereseplus = $element->{tempHystereseplus};
                    my $tempHystereseminus = $element->{tempHystereseminus};
                    if (!defined $tempHystereseplus) {
                        $tempHystereseplus = 1;
                    }
                    if (!defined $tempHystereseminus) {
                        $tempHystereseminus = 1;
                    }
                     $testTempHoch = ($istTemp > ($sollTemp + $tempHystereseplus));
                     $testTempNiedrig = ($istTemp < ($sollTemp - $tempHystereseminus)) || (($aenderung_pos == 1) && (!$testTempHoch));
    
                    # Fenster ist beschienen, Rolladen ist zu und Temperatur ist zu niedrig
                    if ($testTempNiedrig) {
                        $position = $element->{wertAufBesch};
                        $aenderung_pos = 1;
                        $bemerkung = "Wegen Temperatur auffahren bei: " . $istTemp . ' °C';
                    }
    
                    # Fenster ist beschienen, Rolladen ist offen und Temperatur ist zu hoch
                    if ($testTempHoch) {
                        $position = $element->{wertZuBesch};
                        $aenderung_pos = 1;
                        $bemerkung = "Wegen Temperatur zufahren bei: " . $istTemp . ' °C';
                    }
                } else {
                    plugin_log($plugname,"Name: " . $element->{name} . "; Temperatur konnte nicht festgestellt werden");
                    return (undef, undef);
                }
            } else {
                $position = $element->{wertZuBesch};
                $bemerkung = "Wegen Beschattung zufahren";
            }
        }
    
        if (!$Nacht && $testAktuellBeschienen) {
            if (defined $weather->{beschattung}) {
                if ($weather->{beschattung} == 0) {
                    speichereRolladenParameter($element, "bewölkt", 1);
                }
                else {            
                    speichereRolladenParameter($element, "bewölkt", 0);
                }
            }
    
            if ($weather->{beschattung} == 0){
                $position = $element->{wertAufBesch};
                $bemerkung = "Wegen Helligkeit auffahren bei: " . $weather->{helligkeit} . ' Lux';
            }
            elsif ($testTempHoch) {
                $position = $element->{wertZuBesch};
            }
        }
    
        if (defined $element->{minAussenTemp}) {
            if (defined $weather->{temperature}) {
                my $compare = vergleicheWert($weather->{temperature}, $element->{minAussenTemp}, $element->{aussenTempHysterese});
                if ($compare == LOWER) {
                    speichereRolladenParameter($element, "tempProtection", 1);
                }
                if ($compare == HIGHER) {
                    speichereRolladenParameter($element, "tempProtection", 0);
                }
            }
            my $tempProtection = ladeRolladenParameter($element, "tempProtection");
            if (defined $tempProtection && $tempProtection) {
                $position = $element->{wertZuSchutz} || 1;
                $bemerkung = "Wegen zu niedriger Temperatur zufahren bei " + $weather->{temperature} . ' °C';
            }
        }
    
        return ($position, $bemerkung);
    }
    
    
    ######################################################################
    # Prüfen ob der aktuelle Wert eine Grenze über bzw. unterschritten hat
    ######################################################################
    sub vergleicheWert {
        my ($currentValue, $reference, $hysterese) = @_;
        my $current = EQUAL;
        my $last = EQUAL;
        if (!defined $hysterese) {
            $hysterese = 0;
        }
        if ($currentValue < ($reference - $hysterese)) {
            $current = LOWER;
        }
        if ($currentValue > ($reference + $hysterese)) {
            $current = HIGHER;
        }
        return $current;
    }
    
    
    ####################################################
    # Aufruf mit fahreRollladen($richtung, $GA);
    ####################################################
    sub fahreRollladen {
        # Falls $richtung 0 oder 1 ist, wird angenommen, dass der Rollladen
        # komplett zu- bzw. aufgefahren werden soll (DPT3).
        # Bei $richtung>1 wird angenommen, dass eine Positionsfahrt
        # durchgeführt werden soll (DPT5).
        # TODO: man muss bei Positionsfahrt für den Offen-Zustand mindestens 2% angeben...
        #    hm, wenn man die GAs ins Wiregate importiert hat, bräuchte man keinerlei
        #    Unterscheidung mehr! Und man kann auch 0% bzw 1% benutzen
        my ($rolladen, $richtung) = @_;
        my $GA = $rolladen->{GAfahren};
    
        if (defined $rolladen->{debug} && $rolladen->{debug}) {
            plugin_log($plugname, "Name: " . $rolladen->{name} . "; Fahre Rolladen Position: " . $richtung);
        }
    
        if ($richtung == 0 || $richtung == 1) {
            # Auf/Zu fahren
            knx_write($GA,$richtung);        
        } else {
            # Position anfahren
            knx_write($GA,$richtung);
        }
    
        # Position speichern
        if ($richtung == 1) {
            $richtung = 100;
        }
        speichereRolladenParameter($rolladen, "position", $richtung);
    
        # kurze Pause, falls das benutzte Interface das braucht...
            if ($bugfixSlowInterface) {
                usleep(20000);
        }
    }
    
    ####################################################
    # Aufruf mit fahreRollladen($richtung, $GA);
    ####################################################
    sub ladeRollladenPosition {
        my ($rolladen, $wert, $position) = @_;
    
        if (! defined $rolladen->{GAladePos}) {
            plugin_log($plugname,"Name: " . $rolladen->{name} . "; Wert für GAladePos ist nicht definiert!");
            return;
        }
    
        if (defined $rolladen->{debug} && $rolladen->{debug}) {
            plugin_log($plugname, "Name: " . $rolladen->{name} . "; Fahre zur gespeicherten Position: " . $position);
        }
        knx_write($rolladen->{GAladePos}, $position);
    
        speichereRolladenParameter($rolladen, "position", $wert);
    
        # kurze Pause, falls das benutzte Interface das braucht...
            if ($bugfixSlowInterface) {
                usleep(20000);
        }
    }
    
    ########################################
    # Parameter für einen Rolladen speichern
    ########################################
    sub speichereRolladenParameter {
        my ($rolladen, $parameter, $value) = @_;
        $plugin_info{$plugname . '_Rolladen_' . $rolladen->{GAfahren} . "_" . $parameter} = $value;
    }
    
    
    ####################################
    # Parameter für einen Rolladen laden
    ####################################
    sub ladeRolladenParameter {
        my ($rolladen, $parameter) = @_;
        return $plugin_info{$plugname . '_Rolladen_' . $rolladen->{GAfahren} . "_" . $parameter};
    }
    RolladenAutomatik.conf
    Code:
    # Die Koordinaten des Hauses. Sehr einfach über http://www.latlong.net/ zu ermitteln.
    # Und die Höhe über Normalnull (NN)
    $lat = 45.67890;    # Breitengrad in Grad
    $lon = 12.34567;    # Längengrad in Grad
    $elev = 123 / 1000;    # Höhe über NN in Kilometer (dewegen geteilt durch 1000)
    # GA wo Azimuth und Elevation hingeschrieben werden sollen
    $gv_gaAzimuth = '1/4/156';
    $gv_gaElevation = '1/4/157';
    # Helligkeit ab der die Rolläden in der Früh geöffnet bzw. am Abend geschlossen werden sollen
    $daemmerung_helligkeit = 30;
    
    # Gruppenadresse, über welche die komplette Automatik für alle Rollläden gesperrt werden kann
    $GAsperreAlle = "1/5/72";
    
    # Gruppenadresse für die Außentemperatur
    $GATemperature = "1/1/46";
    
    # Gruppenadresse für die Windgeschwindigkeit
    $GAWindSpeed = "1/1/55";
    
    # Freigaben für Beschattung
    $Var_Beschattung_Freigabe_Helligkeit = 'RolladenAutomatik_Beschattung_beschattung';
    $Var_Beschattung_Max_Helligkeit = 'RolladenAutomatik_Beschattung_Max_Helligkeit';
    
    # Bugfix für KNX-Schnittstellen die sich bei zu schneller Telegrammabfolge
    # verschlucken, und denen wir deshalb die Geschwindigkeit der Telegramme drosseln müssen
    # 0 = nicht anschalten (Telegramme mit voller Geschwindigkeit abfeuern)
    # 1 = anschalten (Telegramme um 20 millisekunden verzögern)
    # nur für "Busch-Jäger 6196 USB REG" ist bekannt das dies benötigt wird
    # $bugfixSlowInterface = 1;
    
    # Ein Array von Hashes, wobei jeder Hash ein Rollladen/Fenster/Raum ist.
    # Name des Rolladen                    
    #     name => "Speisekammer"
    # Definition ist ausschließlich eine Vorlage und wird daher nicht gesteuert
    #     istVorlage => 1
    # Name des Rollladen oder der Definition, welche als Vorlage dienen soll (Rekursionen sind möglich)
    #     vorlage => "default"
    # Winkel zum Norden, ab dem das Fenster beschienen wird.
    # Echter Osten = 90°, echter Süden = 180°, echter Westen = 270°, echter Norden = 0°
    #     winkel1 => 66    
    # Winkel zum Norden, bis zu dem das Fenster beschienen wird
    #     winkel2 => 186
    # Richtung bei Beschattung: wenn 1 wird DPT3 angenommen und ganz zugefahren.
    # Bei ungleich 1, wird DPT5 angenommen und Position angefahren
    #     wertZuBesch => 1
    # Richtung bei keiner Beschattung: wenn 0 wird DPT3 angenommen und ganz aufgefahren.
    # Bei ungleich 0, wird DPT5 angenommen und Position angefahren
    #     wertAufBesch => 0
    # Richtung bei Nacht: wenn 1 wird DPT3 angenommen und ganz zugefahren.
    # Bei ungleich 1, wird DPT5 angenommen und Position angefahren
    #     wertZuNacht => 1
    # Richtung bei keiner Nacht: wenn 0 wird DPT3 angenommen und ganz aufgefahren.
    # Bei ungleich 0, wird DPT5 angenommen und Position angefahren
    #     wertAufNacht => 0
    # Schließen für Schutzfunktion (z.B.: zu niedrige Temp): wenn 1 wird DPT3 angenommen und ganz zugefahren.
    # Bei ungleich 1, wird DPT5 angenommen und Position angefahren
    #     wertZuSchutz => 1
    # Öffnen für Schutzfunktion (z.B.: zu hoher Wind): wenn 0 wird DPT3 angenommen und ganz aufgefahren.
    # Bei ungleich 0, wird DPT5 angenommen und Position angefahren
    #     wertAufSchutz => 0
    # Ob der Rollladen in die Automatik für Sonnenauf- und untergang einbezogen werden soll
    #     sonnenAufUnter => 1        # bei Sonnenaufgang und Sonnenuntergang
    #     sonnenAufUnter => 2        # nur Sonnenaufgang
    #     sonnenAufUnter => 3        # nur Sonnenuntergang
    # Raum-Solltemperatur, wenn keine GA angegeben wurde oder kein Wert vom Bus gelesen wurde
    #     raumSollTemp => 22
    # GA der Raum-Solltemperatur
    #     GAraumsollTemp => "0/0/127"
    # GA der Raum-Isttemperatur
    #     GAraumIstTemp => "0/0/128"
    # GA um Rollladen zu fahren
    #     GAfahren => "0/0/126"
    # GA um die Automatik dieses einen Rollladen zu sperren
    #     GAautomatik=> "0/0/129"
    # GA für die aktuelle Position des Rollladen
    #     GAistPos => "0/0/130"
    # GA für das Laden einer Position des Rollladen (für Aktoren welche gespeicherte Positionen unterstützen)
    #     GAladePos => "0/0/131"
    # Rolladen soll aufgrund der Raumtemperatur gesteuert werden
    #    tempGesteuert => 1
    # Hysterese für Regelung aufgrund der Raumtemperatur (in °C)
    #    tempHysterese => 0.5
    # Rolladenschutz für zu hohe Windgeschwindigkeiten (max. Geschwindigkeit in km/h)
    #    maxWindGeschw => 50
    # Hysterese für Regelung aufgrund der Windgeschwindigkeit (in km/h)
    #    windGeschwHysterese => 5
    # Rolladen wird ab einer maximalen Bewölkung (in %) nicht mehr runtergefahren
    #    maxBewoelkung => 75
    # Hysterese für Regelung aufgrund der Bewölkung (in %-Punkten)
    #    bewoelkungHysterese => 5
    # Rolladen wird runtergefahren wenn die Temperatur unterschritten wird (in °C)
    #    minAussenTemp => -15
    # Hysterese für Regelung aufgrund der Außentemperatur (in °C)
    #    aussenTempHysterese => 2
    # Prüft die Position vor dem Fahren bei Sonnenauf und Untergang (boolean)
    #   pruefePositionSonnenAufUnter => 1
    # Debugging für Rolladen einschalten
    #   debug => 1
    # Prüft die Position nach Aufhebung einer Sperre (boolean)
    #   pruefePositionNachSperre => 1
    # Regel wird nur ausgeführt wenn die Bedingung erfüllt ist (boolean)
    #   Beispiel für Heizzeitraum
    #     bedingung => '($tagImJahr < toDayOfYear(15, 5, $jahr) || $tagImJahr >= toDayOfYear(15, 9, $jahr)) ? 1 : 0'
    #   Beispiel für Wochenende
    #     bedingung => '($wochentag == SAMSTAG || $wochentag == SONNTAG) ? 1 : 0'
    
    # Format für im Aktor gespeicherte Positionen:
    # "44;Position:0" bezeichnet die im Aktor gespeicherte Position 0. Der Wert 44 dient lediglich zur Kontrolle.
    
    
    
    # Elevation der Sonne, ab der das Fenster beschienen wird
    #    elevation1
    # Elevation der Sonne, bis zu der das Fenster beschienen wird
    #    elevation2
    # Temperaturhysterese aufgeteilt um z.B. bei einer Solltemperatur von 22 bis 24° die Rolläden oben zu lassen und bei 23° schon wieder zu öffnen
    # Altes System hätte erst wieder bei 20° den Rolladen geöffnet
    #    tempHystereseplus bzw. tempHystereseminus
    # Status des Fensters 0=geöffnet, 1=gekippt, 2=geschlossen
    #    GAFensterStatus
    # Positionen auf die das Fenster bei geöffnetem bzw. gekippten Fenster fahren soll
    # Die Positionen werden nur angefahren, sofern der Rolladen hierbei nach oben fahren muss. Ist der Rolladen also bereits oben und es wird gekippt, so wird
    # eine evtl. tiefere Position nicht angefahren.
    #    wertOffen bzw. wertGekippt
    
    push @AlleRolllaeden, { name => "default", istVorlage => 1, wertZuBesch => 1, wertAufBesch => 0,
                wertZuNacht => 1, wertAufNacht => 0, sonnenAufUnter => 1,
                tempGesteuert => 1, tempHystereseplus => 2, tempHystereseminus => -1, maxWindGeschw => 80,
                windGeschwHysterese => 5, minAussenTemp => -15, aussenTempHysterese => 2, wertAufSchutz => 0, wertZuSchutz => 100,
                pruefePositionSonnenAufUnter => 1, pruefePositionNachSperre => 1};
    
    push @AlleRolllaeden, { name => "Gästebad", vorlage => "default", azimuth1 => 90, azimuth2 => 160,
                elevation1 => 5, elevation2 => 90, wertZuBesch => 80, wertZuNacht => 92, sonnenAufUnter => 1,
                GAraumIstTemp => "0/3/235", GAfahren => "1/3/189", GAautomatik => "1/5/73",
                GAistPos => "1/3/190", GAraumSollTemp => "0/3/253",
                GAFensterStatus => "1/4/248", wertOffen => 0, wertGekippt => 75,  
                bedingung => '(($stunde == 6 && $minute >= 30) || $stunde >= 7) ? 1 : 0' };
    Da ich die Auswertung der Helligkeit nicht einfach nur alle 5 Minuten aufrufen wollte, sondern bei Änderung der Helligkeit habe ich wegen der Plugin-Größe in ein separates Plugin ausgelagert.

    Hier vielen Dank an das Plugin "beschattung_freigabe" von Marcus Lichtenberger (marcus@lichtenbergers.at) welches mit hierbei als Vorlage diente.

    RolladenAutomatik_Beschattung
    Code:
    # Gruppenadresse für die Helligkeit
    my $GAHelligkeit1;
    my $GAHelligkeit2;
    my $GAHelligkeit3;
    my $Helligkeit1 = 0;
    my $Helligkeit2 = 0;
    my $Helligkeit3 = 0;
    my $HelligkeitMax = 0;
    my $Beschattung_Ein = 0;
    # Gruppenadressen für den Sonnenstand
    my $Elevation = $plugin_info{RolladenAutomatik_lastElevation};
    my $Elevation_Grad;
    
    # Zeitpunkt auslesen
    my $gv_sekunden;
    my $gv_minuten;
    my $gv_stunden;
    my $gv_monatstag;
    my $gv_monat;
    my $gv_jahr;
    my $gv_wochentag;
    my $gv_jahrestag;
    my $gv_sommerzeit;
    my $gv_zeitpunkt;
    my $gv_zeitdifferenz;
    
    my $Zeit_verdunkeln;
    my $Zeit_aufhellen;
    
    #################################
    ### Lesen der Konfigurationsdatei
    #################################
    # Read config file in conf.d
    my $confFile = '/etc/wiregate/plugin/generic/conf.d/'.basename($plugname,'.pl').'.conf';
    if (! -f $confFile) {
        plugin_log($plugname, " no conf file [$confFile] found.");
        return "no conf file [$confFile] found.";
    } else {
        open(CONF, $confFile);
        my @lines = <CONF>;
        close($confFile);
        my $result = eval("@lines");
        if ($@) {
            plugin_log($plugname, "conf file [$confFile] returned:");
            my @parts = split(/\n/, $@);
            plugin_log($plugname, "--> $_") foreach (@parts);
        }
    }
    # Festlegen, dass das Plugin alle 5 Minuten laufen soll
    $plugin_info{$plugname.'_cycle'} = 300;
    
    if (defined $GAHelligkeit1) {
        if (defined $GAHelligkeit2) {
            if (defined $GAHelligkeit3) {
                $plugin_subscribe{$GAHelligkeit3}{$plugname} = 1;
                $Helligkeit3 = knx_read($GAHelligkeit3, 1800);
            }
            $plugin_subscribe{$GAHelligkeit2}{$plugname} = 1;
            $Helligkeit2 = knx_read($GAHelligkeit2, 1800);
        }
        $plugin_subscribe{$GAHelligkeit1}{$plugname} = 1;
        $Helligkeit1 = knx_read($GAHelligkeit1, 1800);
    }
    $HelligkeitMax = $Helligkeit1;    
    if ($Helligkeit2 > $HelligkeitMax) {
        $HelligkeitMax = $Helligkeit2;
    }    
    if ($Helligkeit3 > $HelligkeitMax) {
        $HelligkeitMax = $Helligkeit3;
    }    
    
    # Evtl. Werte initialisieren, falls es sie noch nicht gibt.
    if (!exists $plugin_info{$plugname.'_beschattungEin'}) {
        $plugin_info{$plugname.'_beschattungEin'} = 0;
    }
    if (!exists $plugin_info{$plugname.'_beschattungEinTime'}) {
        ($gv_sekunden, $gv_minuten, $gv_stunden, $gv_monatstag, $gv_monat, $gv_jahr, $gv_wochentag, $gv_jahrestag, $gv_sommerzeit) = localtime(time);
        $gv_zeitpunkt = $gv_minuten + ($gv_stunden*60);
        $plugin_info{$plugname.'_beschattungEinTime'} = $gv_zeitpunkt;
    }
    
    # Prüfen, ob das Telegramm etwas am aktuellen Status ändert und ggf. merken
    $Elevation_Grad = round(rad2deg($Elevation));
    if ($Elevation_Grad >  0 and $Elevation_Grad <= 10 and $HelligkeitMax >= 5000) { $Beschattung_Ein = 1; }
    if ($Elevation_Grad > 10 and $Elevation_Grad <= 20 and $HelligkeitMax >= 10000) { $Beschattung_Ein = 1; }
    if ($Elevation_Grad > 20 and $Elevation_Grad <= 30 and $HelligkeitMax >= 20000) { $Beschattung_Ein = 1; }
    if ($Elevation_Grad > 30 and $Elevation_Grad <= 40 and $HelligkeitMax >= 30000) { $Beschattung_Ein = 1; }
    if ($Elevation_Grad > 40 and $Elevation_Grad <= 50 and $HelligkeitMax >= 40000) { $Beschattung_Ein = 1; }
    if ($Elevation_Grad > 50 and $Elevation_Grad <= 90 and $HelligkeitMax >= 75000) { $Beschattung_Ein = 1; }
    
    if ($Elevation_Grad <  0) { $Beschattung_Ein = 0; }
    if ($Elevation_Grad >  0 and $Elevation_Grad <= 10 and $HelligkeitMax < 5000) { $Beschattung_Ein = 0; }
    if ($Elevation_Grad > 10 and $Elevation_Grad <= 20 and $HelligkeitMax < 10000) { $Beschattung_Ein = 0; }
    if ($Elevation_Grad > 20 and $Elevation_Grad <= 30 and $HelligkeitMax < 20000) { $Beschattung_Ein = 0; }
    if ($Elevation_Grad > 30 and $Elevation_Grad <= 40 and $HelligkeitMax < 30000) { $Beschattung_Ein = 0; }
    if ($Elevation_Grad > 40 and $Elevation_Grad <= 50 and $HelligkeitMax < 40000) { $Beschattung_Ein = 0; }
    if ($Elevation_Grad > 50 and $Elevation_Grad <= 90 and $HelligkeitMax < 75000) { $Beschattung_Ein = 0; }
    
    if ($Beschattung_Ein == 1 and $plugin_info{$plugname.'_beschattungEin'} == 0) {
        ($gv_sekunden, $gv_minuten, $gv_stunden, $gv_monatstag, $gv_monat, $gv_jahr, $gv_wochentag, $gv_jahrestag, $gv_sommerzeit) = localtime(time);
        $gv_zeitpunkt = $gv_minuten + ($gv_stunden*60);
        $plugin_info{$plugname.'_beschattungEin'} = 1;
        $plugin_info{$plugname.'_beschattungEinTime'} = $gv_zeitpunkt;
    } elsif ($Beschattung_Ein == 0 and $plugin_info{$plugname.'_beschattungEin'} == 1) {
        ($gv_sekunden, $gv_minuten, $gv_stunden, $gv_monatstag, $gv_monat, $gv_jahr, $gv_wochentag, $gv_jahrestag, $gv_sommerzeit) = localtime(time);
        $gv_zeitpunkt = $gv_minuten + ($gv_stunden*60);
        $plugin_info{$plugname.'_beschattungEin'} = 0;
        $plugin_info{$plugname.'_beschattungEinTime'} = $gv_zeitpunkt;
    }
    
    # Prüfen, ob die Beschattung aktiviert oder deaktiviert werden muss
    if ($plugin_info{$plugname.'_beschattungEin'} == 1) {
        ($gv_sekunden, $gv_minuten, $gv_stunden, $gv_monatstag, $gv_monat, $gv_jahr, $gv_wochentag, $gv_jahrestag, $gv_sommerzeit) = localtime(time);
        $gv_zeitpunkt = $gv_minuten + ($gv_stunden*60);
        $gv_zeitdifferenz = $gv_zeitpunkt - $plugin_info{$plugname.'_beschattungEinTime'};
        if ($gv_zeitdifferenz > $Zeit_verdunkeln) {
            $plugin_info{$plugname.'_beschattung'} = 1;
        }
    }
    elsif ($plugin_info{$plugname.'_beschattungEin'} == 0) {
        ($gv_sekunden, $gv_minuten, $gv_stunden, $gv_monatstag, $gv_monat, $gv_jahr, $gv_wochentag, $gv_jahrestag, $gv_sommerzeit) = localtime(time);
        $gv_zeitpunkt = $gv_minuten + ($gv_stunden*60);
        $gv_zeitdifferenz = $gv_zeitpunkt - $plugin_info{$plugname.'_beschattungEinTime'};
        if ($gv_zeitdifferenz > $Zeit_aufhellen) {
            $plugin_info{$plugname.'_beschattung'} = 0;
        }
    }
    $plugin_info{$plugname.'_Max_Helligkeit'} = $HelligkeitMax;
    
    return "Beschattung: " . $plugin_info{$plugname.'_beschattung'} . "; Speicher " . $plugin_info{$plugname.'_beschattungEin'};
    RolladenAutomatik_Beschattung.conf
    Code:
    # Gruppenadresse für die Helligkeit wobei die 2 und 3 optional sind
    $GAHelligkeit1= "1/1/51";
    $GAHelligkeit2= "1/1/52";
    $GAHelligkeit3= "1/1/53";
    $Zeit_verdunkeln=5;
    $Zeit_aufhellen=15;
    Das ganze läuft bei soweit Problemlos und zuverlässig seit ca. 5 Monaten, wobei die Funktion mit den Fensterstatus erst letzte Woche dazu kam.
    Evtl. kann es ja jemand brauchen :-)

    Gruß,
    Martin
Lädt...
X