[ASC] lüften beenden, schliesst das rollo nicht

Begonnen von frank, 18 August 2022, 14:46:20

Vorheriges Thema - Nächstes Thema

Beta-User

Zitat von: frank am 02 September 2022, 13:58:46
du hast zwave?
Ja! Nachdem mich eQ-3 nachhaltig verärgert hat, habe ich erst MCU-Programmieren gelernt (MySensors) und bei der Kaufhardware nach Alternativen geschaut. Und die Rollladenaktoren von Fibaro sind VIEL universeller wie alles, was man bisher in Homematic hätte bekommen können. (Jalousie/Venetian-blind-Betrieb per Konfigurationskommando einstellbar, Doppel- und Dreifachklick-Erkennung, "Gate"-Modus in verschiedenen Varianten, ...).

Zitat
meldet zwave infos zum fahrtstatus? welche (start/stop/up/down/error/...)?
Die melden nur, dass Energie verbraucht wird, "Stillstand" ist "0 W", und das kommt nach dem "state", der auch den dim-Wert beinhaltet (letzteren muss man da per userReading extrahieren).

(Man sieht daran, auch ZWave braucht eine gründlichere Einarbeitung...)

Zitat
meldet zwave infos, wenn die position nicht mehr stimmt. zb nach device booten?
Wenn die Dinger spannungslos waren, machen (oder brauchen?) sie erst mal eine Kalibrierfahrt. Kein Gefrickel mit der Einstellung der Fahrtdauern...

Zitat
0.4 habe ich noch nicht gefunden.
0.6.x habe ich gefunden, aber .... 214 seiten a 15 beiträge.  8)
::) ich hatte auch keine Lust zum Suchen, war aber eben auch von Anfang an dabei (und hatte nur zwischendurch auch etwas den Faden verloren).

Zitat von: frank am 02 September 2022, 14:23:16
ich bin gespannt!
Ich auch!

Zitat
übrigens (die entwickler haben das sicherlich auf dem schirm):
Falls du damit mich mit ansprechen willst: bin leider aus den Tiefen schon lange wieder draußen, und der Code ist mir zu verteilt...

Zitat
wenn das position reading des rollos events-on-update sendet, erzeugt jeder statusrequest am aktor eine neue manuelle fahrt mit entsprechendem blocking. zusätzliche probleme kann es geben, wenn der request nach einer automatischen fahrt kommt, da dadurch dann die letzte automatische fahrt zur letzten manuellen fahrt wird.

wäre es nicht überlegenswert, dass asc von sich aus wiederholungen des position readings filtert?
wenn ich mir so die list der rollos diverser asc-user anschaue, ist das attribut event-on-change im rollo eher sehr selten selten zu sehen.
Dass event-on-change-reading nicht gesetzt ist, ist in der Tat ein häufiger "Fehler" von Neueinsteigern, die dadurch praktisch "alle" aus der Kurve fliegen. Wenn wir das wegbekämen, wäre das vermutlich hilfreich. Andererseits gibt es eben auch eine nicht unerhebliche Zahl von Usern, die das kennen und ggf. auch aktiv für sich nutzen (?).

Prinzipiell sehe ich auch eigentlich kein Problem darin, das aufzugeben und dazu noch einige andere "alte Zöpfe", wie die vermeintlich strikte 10-er-Unterteilung (Attribut-Vorgabe) und/oder das Verbot gleicher Ziel-Werte für verschiedene Zwecke. In den länglichen Threads zur Entwicklung hatte ich mehrfach schon die Auffassung vertreten, dass es eigentlich genügen müßte, jedem "Fahrgrund" eine Priorität zu geben und dann einfach zu schauen, ob bei Eintritt einer Bedingung für "irgendwas" die Position zu ändern wäre oder ob es Gründe gibt, die dagegen sprechen (höhrere Prio für anderen Fahrgrund).
Dass man den Grund ändert, warum ein Rollladen auf einer bestimmten Position steht, bedeutet ja nicht zwangsläufig, dass auch gefahren werden müßte...
Server: HP-elitedesk@Debian 12, aktuelles FHEM@ConfigDB | CUL_HM (VCCU) | MQTT2: MiLight@ESP-GW, BT@OpenMQTTGw | MySensors: seriell, v.a. 2.3.1@RS485 | ZWave | ZigBee@deCONZ | SIGNALduino | MapleCUN | RHASSPY
svn: u.a MySensors, Weekday-&RandomTimer, Twilight,  div. attrTemplate-files

meier81

Hallo,

hab leider das gleiche Problem. Hatte heute den Fall das die Fenster gekippt waren und meine Frau den Schlafmodus der Kinder eingeschaltet hat. Die Rollläden sind daraufhin auf 30% zugefahren, alles noch korrekt. Jetzt war ich eben im Zimmer und habe die Fenster zugemacht, erwartet hätte ich jetzt eigentlich das die Rollläden nun zufahren, das tun sie aber nicht, bleiben munter auf den 30% stehen. Im ASC-Device steht bei Last Drive "roommate asleep - ventilate mode".

Was mir dann beim weiteren Testen aufgefallen ist, wenn ich nun das Fenster wieder öffne passiert weiterhin nichts, soll ja jetzt wieder auf 30% fahren und ist ja noch auf 30%. Wenn ich aber nun das Fenster wieder schließe fährt der Rollladen jetzt runter.

Gruß Markus
QNAP NAS mit Debian VM, darauf FHEM, debmatic, influxdb2 und Grafana || HB-RF-ETH || SIGNALduino 433MHz mit Maple mini || WS980 Wetterstation || Xiaomi Mi Robot mit valetudo-FW || Buderus web KM100 || div. Tasmota-Devices

frank

Zitat von: CoolTux am 01 September 2022, 15:42:52
@frank

Ich muss gestehen daß ich gefallen an Deine Ideen gefunden habe. Sowohl der Weg über die tatsächliche Endposition sofern von ASC ausgelöst als auch das mit der IdleDetection finde ich sehr erfolgversprechend. Ich werde es mir in nächster Zeit einmal genauer anschauen.
gibt es vielleicht schon was zum testen?  8)
FHEM: 6.0(SVN) => Pi3(buster)
IO: CUL433|CUL868|HMLAN|HMUSB2|HMUART
CUL_HM: CC-TC|CC-VD|SEC-SD|SEC-SC|SEC-RHS|Sw1PBU-FM|Sw1-FM|Dim1TPBU-FM|Dim1T-FM|ES-PMSw1-Pl
IT: ITZ500|ITT1500|ITR1500|GRR3500
WebUI [HMdeviceTools.js (hm.js)]: https://forum.fhem.de/index.php/topic,106959.0.html

CoolTux

Zitat von: frank am 21 Oktober 2022, 10:01:52
gibt es vielleicht schon was zum testen?  8)

Leider noch nicht. Aber vielen Dank für die Erinnerung.
Du musst nicht wissen wie es geht! Du musst nur wissen wo es steht, wie es geht.
Support me to buy new test hardware for development: https://www.paypal.com/paypalme/MOldenburg
My FHEM Git: https://git.cooltux.net/FHEM/
Das TuxNet Wiki:
https://www.cooltux.net

frank

#19
moin,

ich habe bei mir nun die vorgeschlagene erkennung manueller fahrten erfolgreich umgesetzt.

Zitat von: frank am 01 September 2022, 13:20:14
eine ermittlung über einen vergleich von soll-position und ist-position erscheint mir deutlich besser zu sein.
alle positionen die nach dem starten eines automatischen fahrens hereinkommen und ungleich der sollposition sind gehören zur automatischen fahrt. sobald eine position gleich der sollposition ist, wird die erkennung abgebrochen. die automatische fahrt wurde erfolgreich beendet und diese position ist dann natürlich die aktuelle position der automatischen fahrt.

dieses verfahren darf natürlich nicht unendlich lange andauern, falls aus irgendeinem grund keine positionen gemeldet werden oder nie die sollposition gemeldet wird. zb weil die fahrt manuell abgebrochen wurde.
als "timeout" würde ich 2x ASC_DriveUpMaxDuration nehmen (ist abwärtskompatibel für diejenigen, die diesen wert bereits angepasst haben)

wenn also die erkennung durch timeout abgebrochen wurde, gibt es mindestens 2 fälle zu unterscheiden:
1. keine positionsmeldung erhalten => zb fehlermeldung ausgeben? fahrt wiederholen?
2. die letzte gemeldete position innerhalb timeout wird als manuelle position behandelt (manueller abbruch der automatischen fahrt)

alle weiteren positionen, die nach dem ende der erkennung der automatischen (entweder soll=ist oder timeout) eintreffen, werden bis zum nächsten starten einer automatischen fahrt als manuelle positionen behandelt. ohne jegliche weitere vergleiche oder timeouts.


wenn man ASC_Shutter_IdleDetection gesetzt hat, wird die erkennung innerhalb des timeout hierüber beendet.
ist/soll vergleich der letzten position ermöglicht die erkennung eines manuellen abbruchs.
bei timeout auf alle fälle fehler:
1. keine positionsmeldung erhalten => zb fehlermeldung ausgeben? fahrt wiederholen?
2. wenn wert vorhanden => zb fehlermeldung ausgeben? ASC_DriveUpMaxDuration eventuell zu kurz, weil zb nicht gesetzt.
zusätzlich wird nun auch noch das ende jeder fahrt (asc und manuell) erkannt.

die erkennung funktioniert für alle mir bisher bekannten aktortypen.
zwischenpositionen werden ggf "gefiltert" und eine vorhandene und konfigurierte idleDetection erkennt das ende einer manuellen fahrt oder das ende einer manuell abgebrochenen automatischen fahrt quasi in echtzeit.
ohne idleDetection gibt es in diesen fällen eine verzögerung, die durch das attribut ASC_DriveUpMaxDuration definiert wird.

grundsätzlich geht der detector davon aus, dass der motor still steht, wenn nach einer positionsmeldung (oder dem start einer asc fahrt), für die in ASC_DriveUpMaxDuration eingestellte zeit, keine positionsmeldung eingeht (timeout).
einige durch timeout erkannte "zustände" werden als problem eingestuft und als fehler angezeigt.


detector readings
zum ausgibigen testen stellt der detector im asc device für jedes rollo 3 readings bereit.
<rollo>_timerRcvAsc und <rollo>_timerRcvMan zeigen mit on/off die aktivität der 2 timer an.
und <rollo>_driveAction zeigt die zustände des detectors wie folgt an:
asc_posSnd:xx                       # automatische fahrt wird gestartet

asc_posRun:xx                       # position während einer automatischen fahrt
asc_posEnd:xx                       # position am ende einer automatischen fahrt              (idle detektion aktiv)
asc_posEndManBreak:xx               # position durch manuellen stop einer automatischen fahrt (idle detektion aktiv)
asc_noPosEnd:xx                     # error: nur run-positionen empfangen                     (idle detektion aktiv)

asc_timeOut_posEndManBreak:xx       # position durch manuellen stop einer automatischen fahrt (idle detektion inaktiv)
asc_timeOut_noPos                   # error: keine position empfangen
asc_timeOut_noPosEnd:xx             # error: nur run-positionen empfangen                     (idle detektion aktiv)

man_posRun:xx                       # position während einer manuellen fahrt
man_posEnd:xx                       # position am ende einer manuellen fahrt                  (idle detektion aktiv)
man_timeOut_posEnd:xx               # position am ende einer manuellen fahrt                  (idle detektion inaktiv)
man_timeOut_noPosEnd:xx             # error: nur run-positionen empfangen                     (idle detektion aktiv)



code änderungen
zu ändern sind 2 funktionen, zusätzlich gibt es 3 neue funktionen.

1. in /opt/fhem/lib/FHEM/Automation/ShuttersControl.pm sieht der anfang der funktion SetCmdFn() nun so aus:
sub SetCmdFn { #frank
    my $h = shift;

    my $shuttersDev = $h->{shuttersDev};
    my $posValue    = $h->{posValue};

    $shutters->setShuttersDev($shuttersDev);
    $shutters->setLastDrive( $h->{lastDrive} )
      if ( defined( $h->{lastDrive} ) );

#    my $idleDetectionValue = $shutters->getIdleDetectionValue; #frank
#    my $idleDetection      = $shutters->getIdleDetection; #frank
    my $hash = $::defs{$ascDev->{name}}; #frank

    return
      if ( $shutters->getASCenable eq 'off'
        || $ascDev->getASCenable eq 'off'
#        || $idleDetection !~ m{^$idleDetectionValue$}xms #frank
        || $hash->{helper}{$shuttersDev}{timerRcvAsc} #frank: now also for types without detection. should cmd delayed?
        || $hash->{helper}{$shuttersDev}{timerRcvMan} #frank: now also for types without detection. should cmd delayed?
        || $shutters->getWindProtectionStatus eq 'protected' #frank
        || $shutters->getRainProtectionStatus eq 'protected' ); #frank

    if ( $shutters->getStatus != $posValue ) {
        $shutters->setLastPos( $shutters->getStatus );

####### new drive detection ############################################################################### #frank

        $hash->{helper}{$shuttersDev}{timerRcvAsc} = 1;
        $hash->{helper}{$shuttersDev}{posSnd}      = $posValue;
        $hash->{helper}{$shuttersDev}{posRcvVal}   = -1; #no position received yet

        my $t = ::gettimeofday() + $shutters->getDriveUpMaxDuration;
        ::RemoveInternalTimer("timerRcvAsc:$shuttersDev");
        ::InternalTimer($t, \&ASC_TimeoutRcvAsc, "timerRcvAsc:$shuttersDev");

        ::readingsSingleUpdate($hash,$shuttersDev.'_timerRcvAsc','on',1);
        ::readingsSingleUpdate($hash,$shuttersDev.'_driveAction',"asc_posSnd:$posValue",1);

########################################################################################################### #frank

    }
    else {


nach SetCmdFn() werden folgende 3 neue funktionen eingefügt:
sub ASC_TimeoutRcvAsc { #frank
    my $in = shift;
    my (undef,$shuttersDev) = split(':',$in);

    my $hash = $::defs{$ascDev->{name}};
    $shutters->setShuttersDev($shuttersDev);

    $hash->{helper}{$shuttersDev}{timerRcvAsc} = 0;
    ::readingsSingleUpdate($hash,$shuttersDev.'_timerRcvAsc','off',1);
   
    #we have timeout because no position received with value==posSnd
    #possible problems (fhem freeze?, bad rssi?, bad config?, timeout too short?)
    my $posRcv = $hash->{helper}{$shuttersDev}{posRcvVal};
    my $err = '';
    if($shutters->getIdleDetection eq 'none') {                        #without idle detection:
        if($posRcv >= 0) {                                             #manual break if no problems
            ::readingsSingleUpdate($hash, $shuttersDev.'_driveAction', "asc_timeOut_posEndManBreak:$posRcv", 1);

            $hash->{helper}{$shuttersDev}{timerRcvMan} = 1;
            my $t = $hash->{helper}{$shuttersDev}{posRcvTS} + $shutters->getDriveUpMaxDuration;
            ::InternalTimer($t, \&ASC_TimeoutRcvMan, "timerRcvMan:$shuttersDev");
            ::readingsSingleUpdate($hash,$shuttersDev.'_timerRcvMan','on',1);
        }
        else {                                                         #no positions received
            $err = 'asc_timeOut_noPos';
            ::readingsSingleUpdate($hash, $shuttersDev.'_driveAction', $err, 1);
            ASC_DoAfterPosRcv($shuttersDev, -1, $err);
        }
    }
    else {                                                             #with idle detection:
        if($posRcv >= 0) {                                             #only received running positions
            $err = 'asc_timeOut_noPosEnd';
            ::readingsSingleUpdate($hash, $shuttersDev.'_driveAction', "$err:$posRcv", 1);
            ASC_DoAfterPosRcv($shuttersDev, $posRcv, $err);
        }
        else {                                                         #no positions received
            $err = 'asc_timeOut_noPos';
            ::readingsSingleUpdate($hash, $shuttersDev.'_driveAction', $err, 1);
            ASC_DoAfterPosRcv($shuttersDev, -1, $err);
        }
    }
    return;
}

sub ASC_TimeoutRcvMan { #frank
    my $in = shift;
    my (undef,$shuttersDev) = split(':',$in);

    my $hash = $::defs{$ascDev->{name}};
    $shutters->setShuttersDev($shuttersDev);

    $hash->{helper}{$shuttersDev}{timerRcvMan} = 0;
    ::readingsSingleUpdate($hash,$shuttersDev.'_timerRcvMan','off',1);

    #we have timeout: normal for no detection, else error
    #possible problems (fhem freeze?, bad rssi?, bad config?, timeout too short?)
    my $posRcv = $hash->{helper}{$shuttersDev}{posRcvVal};
    if($shutters->getIdleDetection eq 'none') {                    #without detection => normal if no problems
        ::readingsSingleUpdate($hash, $shuttersDev.'_driveAction', "man_timeOut_posEnd:$posRcv", 1);
        ASC_DoAfterPosRcv($shuttersDev, $posRcv, 'manual');
    }
    else {                                                         #with detection => error: missing idle position
        my $err = 'man_timeOut_noPosEnd';
        ::readingsSingleUpdate($hash, $shuttersDev.'_driveAction', "$err:$posRcv", 1);
        ASC_DoAfterPosRcv($shuttersDev, $posRcv, $err);
    }
    return;
}

sub ASC_DoAfterPosRcv { #frank
    my $shuttersDev = shift;
    my $posRcv      = shift;
    my $type        = shift;

    $shutters->setShuttersDev($shuttersDev);

    if($posRcv >= 0) {
        $ascDev->setPosReading;
        if($type eq 'manual') {
            $shutters->setLastDrive('manual');
            $shutters->setLastDriveReading;
            $ascDev->setStateReading;
            $shutters->setLastManPos($posRcv);
            $shutters->setShadingManualDriveStatus(1) if($shutters->getIsDay && $shutters->getIfInShading);

            FHEM::Automation::ShuttersControl::ASC_Debug( 'EventProcessingShutters:'
                  . ' eine manuelle Fahrt wurde erkannt!'
                  . ' die Position wird ggf automatisch auf die Frostschutzposition korrigiert.'
            );
        }
        elsif($type eq 'asc') {
            $shutters->setLastDriveReading;
            $ascDev->setStateReading;
            $shutters->setHardLockOut('on') if( (  $posRcv == $shutters->getComfortOpenPos
                                                || $posRcv == $shutters->getOpenPos
                                                && $shutters->getLastDrive eq 'ventilate - window open'
                                                )
                                                && $shutters->getShuttersPlace eq 'terrace'
            );
            FHEM::Automation::ShuttersControl::ASC_Debug( 'EventProcessingShutters: '
                  . ' eine automatisierte Fahrt durch ASC wurde erkannt!'
                  . ' Es werden nun die LastDriveReading und StateReading Werte gesetzt!'
            );
        }
        else { #error with position
            $shutters->setLastDrive("missing idle position ($type:$posRcv)");
            $shutters->setLastDriveReading;
            $ascDev->setStateReading;
        }
    }
    else { #error without position
        $shutters->setLastDrive("no position received ($type)");
        $shutters->setLastDriveReading;
        $ascDev->setStateReading;
    }
    return;
}



2. in /opt/fhem/lib/FHEM/Automation/ShuttersControl/EventProcessingFunctions.pm sieht die funktion EventProcessingShutters() nun so aus:
sub EventProcessingShutters { #frank
    my $hash        = shift;
    my $shuttersDev = shift;
    my $events      = shift;

    my $name = $hash->{NAME};

    FHEM::Automation::ShuttersControl::ASC_Debug( 'EventProcessingShutters: '
          . ' Fn wurde durch Notify aufgerufen da ASC_Pos_Reading Event erkannt wurde '
          . ' - RECEIVED EVENT: '
          . Dumper $events
    );


####### new drive detection ############################################################################### #frank

    my $aH = $FHEM::Automation::ShuttersControl::ascDev;
    my $sH = $FHEM::Automation::ShuttersControl::shutters;
    $sH->setShuttersDev($shuttersDev);
    my $posReading = $sH->getPosCmd;
   
    if ( $events =~ m{.*$posReading:\s([0-9\.]+)}xms ) { #check with readingname and point
        my $posRcv = $1; #also change all other $1 and getStatus() in the rest of the function

#    if ( $events =~ m{.*:\s(\d+)}xms ) { #frank: dangerous!
#        $FHEM::Automation::ShuttersControl::shutters->setShuttersDev(
#            $shuttersDev);
#        $FHEM::Automation::ShuttersControl::ascDev->setPosReading;
#
########################################################################################################### #frank


        FHEM::Automation::ShuttersControl::ASC_Debug( 'EventProcessingShutters: '
              . $shuttersDev
              . ' - Event vom Rollo erkannt. Es wird nun eine etwaige manuelle Fahrt ausgewertet.'
              . ' Int von ::gettimeofday: '  . int( ::gettimeofday() )
              . ' Last Position Timestamp: ' . $sH->getLastPosTimestamp
              . ' Drive Up Max Duration: '   . $sH->getDriveUpMaxDuration
              . ' Last Position: '           . $sH->getLastPos
              . ' aktuelle Position: '       . $posRcv #frank: change $posRcv
        );


####### new drive detection ############################################################################### #frank

        $hash->{helper}{$shuttersDev}{timerRcvAsc} = 0 if(!defined($hash->{helper}{$shuttersDev}{timerRcvAsc}));
        $hash->{helper}{$shuttersDev}{timerRcvMan} = 0 if(!defined($hash->{helper}{$shuttersDev}{timerRcvMan}));
        $hash->{helper}{$shuttersDev}{posRcvVal} = $posRcv;
        $hash->{helper}{$shuttersDev}{posRcvTS} = ::gettimeofday();

        if($hash->{helper}{$shuttersDev}{timerRcvAsc} == 1) {                #asc drive
            if($posRcv == $hash->{helper}{$shuttersDev}{posSnd}) {           #pos==snd
                $hash->{helper}{$shuttersDev}{timerRcvAsc} = 0;
                ::RemoveInternalTimer("timerRcvAsc:$shuttersDev");
                ::readingsSingleUpdate($hash,$shuttersDev.'_timerRcvAsc','off',1);

                if(   $sH->getIdleDetection eq 'none'                        #detection: no or idle
                   || $sH->getIdleDetection ne 'none' && $sH->getIdleDetection eq $sH->getIdleDetectionValue) {
                    ::readingsSingleUpdate($hash,$shuttersDev.'_driveAction',"asc_posEnd:$posRcv",1);
                    FHEM::Automation::ShuttersControl::ASC_DoAfterPosRcv($shuttersDev, $posRcv, 'asc');
                }
                else {                                                       #detection: run => error: position without idle
                    ::readingsSingleUpdate($hash,$shuttersDev.'_driveAction',"asc_noPosEndWithIdle:$posRcv",1);
                    FHEM::Automation::ShuttersControl::ASC_DoAfterPosRcv($shuttersDev, $posRcv, 'error');
                }
            }
            else {                                                           #pos!=snd
                if(   $sH->getIdleDetection eq 'none'                        #detection: no or run
                   || $sH->getIdleDetection ne 'none' && $sH->getIdleDetection ne $sH->getIdleDetectionValue) {
                    ::readingsSingleUpdate($hash,$shuttersDev.'_driveAction',"asc_posRun:$posRcv",1);
                }
                else {                                                       #detection: idle
                    $hash->{helper}{$shuttersDev}{timerRcvAsc} = 0;
                    ::RemoveInternalTimer("timerRcvAsc:$shuttersDev");

                    ::readingsSingleUpdate($hash,$shuttersDev.'_timerRcvAsc','off',1);
                    ::readingsSingleUpdate($hash,$shuttersDev.'_driveAction',"asc_posEndManBreak:$posRcv",1);
                    FHEM::Automation::ShuttersControl::ASC_DoAfterPosRcv($shuttersDev, $posRcv, 'manual');
                }
            }
        }
        else {                                                           #manual drive (not a asc drive)
            if(   $sH->getIdleDetection eq 'none'                        #detection: no or run
               || $sH->getIdleDetection ne 'none' && $sH->getIdleDetection ne $sH->getIdleDetectionValue) {
                $hash->{helper}{$shuttersDev}{timerRcvMan} = 1;
                my $t = ::gettimeofday() + $sH->getDriveUpMaxDuration;
                ::RemoveInternalTimer("timerRcvMan:$shuttersDev");
                ::InternalTimer($t, \&FHEM::Automation::ShuttersControl::ASC_TimeoutRcvMan, "timerRcvMan:$shuttersDev");

                ::readingsSingleUpdate($hash,$shuttersDev.'_timerRcvMan','on',1);
                ::readingsSingleUpdate($hash,$shuttersDev.'_driveAction',"man_posRun:$posRcv",1);
            }
            else {                                                       #detection: idle
                if($hash->{helper}{$shuttersDev}{timerRcvMan}) {
                    $hash->{helper}{$shuttersDev}{timerRcvMan} = 0;
                    ::RemoveInternalTimer("timerRcvMan:$shuttersDev");
                    ::readingsSingleUpdate($hash,$shuttersDev.'_timerRcvMan','off',1);
                }
                ::readingsSingleUpdate($hash,$shuttersDev.'_driveAction',"man_posEnd:$posRcv",1);
                FHEM::Automation::ShuttersControl::ASC_DoAfterPosRcv($shuttersDev, $posRcv, 'manual');
            }
       }

########################################################################################################### #frank


# what we want to do for manual/asc drive is now extern in FHEM::Automation::ShuttersControl::ASC_DoAfterPosRcv() #frank
#
#        if(   (int( ::gettimeofday() ) - $sH->getLastPosTimestamp )    > $sH->getDriveUpMaxDuration
#           && (int( ::gettimeofday() ) - $sH->getLastManPosTimestamp ) > $sH->getDriveUpMaxDuration
#        ){
#            $sH->setLastDrive('manual');
#            $sH->setLastDriveReading;
#            $aH->setStateReading;
#            $sH->setLastManPos($posRcv); #frank: change $posRcv
#            $sH->setShadingManualDriveStatus(1) if ( $sH->getIsDay && $sH->getIfInShading );
#
#            FHEM::Automation::ShuttersControl::ASC_Debug(
#                'EventProcessingShutters: eine manuelle Fahrt wurde erkannt!'
#            );
#        }
#        else {
#            $sH->setLastDriveReading;
#            $aH->setStateReading;
#            $sH->setHardLockOut('on') if(   (   $posRcv == $sH->getComfortOpenPos #frank: change $posRcv
#                                             || (   $posRcv == $sH->getOpenPos #frank: change $posRcv
#                                                 && $sH->getLastDrive eq 'ventilate - window open'
#                                             ))
#                                             && $sH->getShuttersPlace eq 'terrace'
#            );
#
#            FHEM::Automation::ShuttersControl::ASC_Debug( 'EventProcessingShutters: '
#                  . ' eine automatisierte Fahrt durch ASC wurde erkannt!'
#                  . ' Es werden nun die LastDriveReading und StateReading Werte gesetzt!'
#            );
#        }
    }

    FHEM::Automation::ShuttersControl::ASC_Debug( 'EventProcessingShutters: '
          . ' Fn wurde durlaufen und es sollten Debugausgaben gekommen sein. '
          . ' !!!Wenn nicht!!! wurde der Event nicht korrekt als Nummerisch erkannt. '
    );
    return;
}
FHEM: 6.0(SVN) => Pi3(buster)
IO: CUL433|CUL868|HMLAN|HMUSB2|HMUART
CUL_HM: CC-TC|CC-VD|SEC-SD|SEC-SC|SEC-RHS|Sw1PBU-FM|Sw1-FM|Dim1TPBU-FM|Dim1T-FM|ES-PMSw1-Pl
IT: ITZ500|ITT1500|ITR1500|GRR3500
WebUI [HMdeviceTools.js (hm.js)]: https://forum.fhem.de/index.php/topic,106959.0.html

meier81

Zitat von: meier81 am 12 September 2022, 20:10:10Hallo,

hab leider das gleiche Problem. Hatte heute den Fall das die Fenster gekippt waren und meine Frau den Schlafmodus der Kinder eingeschaltet hat. Die Rollläden sind daraufhin auf 30% zugefahren, alles noch korrekt. Jetzt war ich eben im Zimmer und habe die Fenster zugemacht, erwartet hätte ich jetzt eigentlich das die Rollläden nun zufahren, das tun sie aber nicht, bleiben munter auf den 30% stehen. Im ASC-Device steht bei Last Drive "roommate asleep - ventilate mode".

Was mir dann beim weiteren Testen aufgefallen ist, wenn ich nun das Fenster wieder öffne passiert weiterhin nichts, soll ja jetzt wieder auf 30% fahren und ist ja noch auf 30%. Wenn ich aber nun das Fenster wieder schließe fährt der Rollladen jetzt runter.

Gruß Markus

Hallo CoolTux,

muss das Thema nochmals aufgreifen, hatte ja den oben angegebenen Fehler letztes Jahr bei mir gefunden. Nun habe ich aber das gleiche Problem auch umgekehrt, ich hatte jetzt schon einige Male den Fall das Rollläden in der Beschattung waren und meine Frau hat die Fenster gekippt, dann sind die Rollläden von 10% auf 30% gefahren, auch alles soweit korrekt. Geht jetzt die Beschattung raus während die Fenster noch gekippt sind bleiben die Rollläden stehen und fahren nicht auf, auch nicht wenn ich jetzt die Fenster wieder zu mache. Spätestens jetzt müssten die doch hochfahren, oder?

Hoffe ich kann das hier mit anhängen, ansonsten mach ich einen eigenen Thread auf.

Gruß Markus
QNAP NAS mit Debian VM, darauf FHEM, debmatic, influxdb2 und Grafana || HB-RF-ETH || SIGNALduino 433MHz mit Maple mini || WS980 Wetterstation || Xiaomi Mi Robot mit valetudo-FW || Buderus web KM100 || div. Tasmota-Devices

CoolTux

Eigener Thread ist besser. Und list vom ASC und Rollo bitte
Du musst nicht wissen wie es geht! Du musst nur wissen wo es steht, wie es geht.
Support me to buy new test hardware for development: https://www.paypal.com/paypalme/MOldenburg
My FHEM Git: https://git.cooltux.net/FHEM/
Das TuxNet Wiki:
https://www.cooltux.net