2018-08-15 08:27:53 +00:00
###############################################################################
2018-10-14 16:19:23 +00:00
#
2018-08-15 08:27:53 +00:00
# Developed with Kate
#
2019-01-27 13:19:51 +00:00
# (c) 2018-2019 Copyright: Marko Oldenburg (leongaultier at gmail dot com)
2018-08-15 08:27:53 +00:00
# All rights reserved
#
# Special thanks goes to:
2018-09-02 21:00:40 +00:00
# - Bernd (Cluni) this module is based on the logic of his script "Rollladensteuerung für HM/ROLLO inkl. Abschattung und Komfortfunktionen in Perl" (https://forum.fhem.de/index.php/topic,73964.0.html)
2019-06-03 05:44:35 +00:00
# - Beta-User for many tests, many suggestions and good discussions
2018-11-11 11:31:20 +00:00
# - pc1246 write english commandref
2019-05-17 20:18:13 +00:00
# - FunkOdyssey commandref style
2018-11-12 11:56:18 +00:00
# - sledge fix many typo in commandref
# - many User that use with modul and report bugs
2019-05-24 09:22:58 +00:00
# - Christoph (christoph.kaiser.in) Patch that expand RegEx for Window Events
2019-05-24 09:31:07 +00:00
# - Julian (Loredo) expand Residents Events for new Residents functions
2019-06-03 05:44:35 +00:00
# - Christoph (Christoph Morrison) for fix Commandref, many suggestions and good discussions
2018-08-15 08:27:53 +00:00
#
#
# This script is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
2018-10-14 16:19:23 +00:00
# the Free Software Foundation; either version 2 of the License,or
2018-08-15 08:27:53 +00:00
# any later version.
#
# The GNU General Public License can be found at
# http://www.gnu.org/copyleft/gpl.html.
# A copy is found in the textfile GPL.txt and important notices to the license
# from the author is found in LICENSE.txt distributed with these scripts.
#
# This script is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
#
# $Id$
#
###############################################################################
2018-09-24 13:29:39 +00:00
### Notizen
2019-04-08 08:19:09 +00:00
# !!!!! - Innerhalb einer Shutterschleife kein CommandAttr verwenden. Bring Fehler!!! Kommen Raumnamen in die Shutterliste !!!!!!
#
2018-08-15 08:27:53 +00:00
package main ;
use strict ;
use warnings ;
2019-07-29 09:28:53 +00:00
sub ascAPIget ($@) {
my ( $ getCommand , $ shutterDev , $ value ) = @ _ ;
2019-05-20 11:52:05 +00:00
2019-07-29 09:28:53 +00:00
return AutoShuttersControl_ascAPIget ( $ getCommand , $ shutterDev , $ value ) ;
2019-05-20 11:52:05 +00:00
}
2018-10-15 12:51:04 +00:00
## unserer packagename
2019-03-27 07:41:15 +00:00
package FHEM::AutoShuttersControl ;
2018-11-09 08:11:13 +00:00
2018-08-15 08:27:53 +00:00
use strict ;
use warnings ;
use POSIX ;
2019-06-18 13:26:41 +00:00
use utf8 ;
2019-08-22 17:42:46 +00:00
use Encode ;
2019-03-27 07:41:15 +00:00
use FHEM::Meta ;
2019-06-19 14:56:17 +00:00
use GPUtils qw( GP_Import GP_Export ) ;
2018-10-14 16:19:23 +00:00
use Data::Dumper ; #only for Debugging
2018-08-28 17:49:01 +00:00
use Date::Parse ;
2019-06-10 19:52:01 +00:00
# try to use JSON::MaybeXS wrapper
# for chance of better performance + open code
eval {
require JSON::MaybeXS ;
import JSON:: MaybeXS qw( decode_json encode_json ) ;
1 ;
} ;
2019-06-11 06:05:54 +00:00
2019-06-10 19:52:01 +00:00
if ( $@ ) {
$@ = undef ;
# try to use JSON wrapper
# for chance of better performance
eval {
# JSON preference order
local $ ENV { PERL_JSON_BACKEND } =
'Cpanel::JSON::XS,JSON::XS,JSON::PP,JSON::backportPP'
unless ( defined ( $ ENV { PERL_JSON_BACKEND } ) ) ;
require JSON ;
import JSON qw( decode_json encode_json ) ;
1 ;
} ;
if ( $@ ) {
$@ = undef ;
# In rare cases, Cpanel::JSON::XS may
# be installed but JSON|JSON::MaybeXS not ...
eval {
require Cpanel::JSON::XS ;
import Cpanel::JSON:: XS qw( decode_json encode_json ) ;
1 ;
} ;
if ( $@ ) {
$@ = undef ;
# In rare cases, JSON::XS may
# be installed but JSON not ...
eval {
require JSON::XS ;
import JSON:: XS qw( decode_json encode_json ) ;
1 ;
} ;
if ( $@ ) {
$@ = undef ;
# Fallback to built-in JSON which SHOULD
# be available since 5.014 ...
eval {
require JSON::PP ;
import JSON:: PP qw( decode_json encode_json ) ;
1 ;
} ;
if ( $@ ) {
$@ = undef ;
# Fallback to JSON::backportPP in really rare cases
require JSON::backportPP ;
import JSON:: backportPP qw( decode_json encode_json ) ;
1 ;
}
}
}
}
}
2018-08-15 08:27:53 +00:00
2018-08-29 12:58:10 +00:00
## Import der FHEM Funktionen
2019-06-18 13:26:41 +00:00
#-- Run before package compilation
2018-08-15 08:27:53 +00:00
BEGIN {
2019-06-18 13:26:41 +00:00
# Import from main context
2018-10-14 16:19:23 +00:00
GP_Import (
2019-06-18 13:26:41 +00:00
qw(
devspec2array
2018-10-14 16:19:23 +00:00
readingsSingleUpdate
readingsBulkUpdate
readingsBulkUpdateIfChanged
readingsBeginUpdate
readingsEndUpdate
defs
modules
Log3
CommandAttr
attr
CommandDeleteAttr
CommandDeleteReading
CommandSet
2019-06-18 13:26:41 +00:00
readingFnAttributes
2018-10-14 16:19:23 +00:00
AttrVal
ReadingsVal
IsDisabled
deviceEvents
init_done
addToDevAttrList
addToAttrList
delFromDevAttrList
delFromAttrList
gettimeofday
2019-09-06 16:36:48 +00:00
sunset
2018-10-14 16:19:23 +00:00
sunset_abs
2019-09-06 16:36:48 +00:00
sunrise
2018-10-14 16:19:23 +00:00
sunrise_abs
InternalTimer
RemoveInternalTimer
computeAlignTime
ReplaceEventMap )
) ;
}
2018-08-15 08:27:53 +00:00
2019-06-20 10:13:03 +00:00
#-- Export to main context with different name
GP_Export (
qw(
Initialize
ascAPIget
)
) ;
2018-08-29 12:58:10 +00:00
## Die Attributsliste welche an die Rolläden verteilt wird. Zusammen mit Default Werten
2018-10-14 16:19:23 +00:00
my % userAttrList = (
2019-04-25 15:15:56 +00:00
'ASC_Mode_Up:absent,always,off,home' = > '-' ,
'ASC_Mode_Down:absent,always,off,home' = > '-' ,
2019-08-15 07:29:15 +00:00
'ASC_Up:time,astro,brightness,roommate' = > '-' ,
'ASC_Down:time,astro,brightness,roommate' = > '-' ,
2019-04-25 15:15:56 +00:00
'ASC_AutoAstroModeMorning:REAL,CIVIL,NAUTIC,ASTRONOMIC,HORIZON' = > '-' ,
2018-12-07 12:04:41 +00:00
'ASC_AutoAstroModeMorningHorizon:-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9'
2019-04-25 15:15:56 +00:00
= > '-' ,
'ASC_AutoAstroModeEvening:REAL,CIVIL,NAUTIC,ASTRONOMIC,HORIZON' = > '-' ,
2018-12-07 12:04:41 +00:00
'ASC_AutoAstroModeEveningHorizon:-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9'
2019-04-25 15:15:56 +00:00
= > '-' ,
2018-10-14 16:19:23 +00:00
'ASC_Open_Pos:0,10,20,30,40,50,60,70,80,90,100' = > [ '' , 0 , 100 ] ,
2019-04-25 19:34:46 +00:00
'ASC_Closed_Pos:0,10,20,30,40,50,60,70,80,90,100' = > [ '' , 100 , 0 ] ,
2019-09-17 14:24:48 +00:00
'ASC_Sleep_Pos:0,10,20,30,40,50,60,70,80,90,100' = > '-' ,
2018-11-28 12:11:32 +00:00
'ASC_Pos_Reading' = > [ '' , 'position' , 'pct' ] ,
2019-04-25 15:15:56 +00:00
'ASC_Time_Up_Early' = > '-' ,
'ASC_Time_Up_Late' = > '-' ,
'ASC_Time_Up_WE_Holiday' = > '-' ,
'ASC_Time_Down_Early' = > '-' ,
'ASC_Time_Down_Late' = > '-' ,
2019-10-25 08:44:08 +00:00
'ASC_PrivacyUpValue_beforeDayOpen' = > '-' ,
'ASC_PrivacyDownValue_beforeNightClose' = > '-' ,
'ASC_PrivacyUp_Pos' = > '-' ,
2019-04-25 15:15:56 +00:00
'ASC_PrivacyDown_Pos' = > '-' ,
2019-06-21 12:20:08 +00:00
'ASC_TempSensor' = > '-' ,
2019-04-25 15:15:56 +00:00
'ASC_Ventilate_Window_Open:on,off' = > '-' ,
'ASC_LockOut:soft,hard,off' = > '-' ,
'ASC_LockOut_Cmd:inhibit,blocked,protection' = > '-' ,
'ASC_BlockingTime_afterManual' = > '-' ,
'ASC_BlockingTime_beforNightClose' = > '-' ,
'ASC_BlockingTime_beforDayOpen' = > '-' ,
'ASC_BrightnessSensor' = > '-' ,
2019-04-25 19:49:11 +00:00
'ASC_Shading_Pos:10,20,30,40,50,60,70,80,90,100' = > [ '' , 80 , 20 ] ,
'ASC_Shading_Mode:absent,always,off,home' = > '-' ,
2019-09-19 11:46:42 +00:00
'ASC_Shading_InOutAzimuth' = > '-' ,
'ASC_Shading_StateChange_SunnyCloudy' = > '-' ,
2019-06-10 11:41:46 +00:00
'ASC_Shading_MinMax_Elevation' = > '-' ,
2019-04-25 19:49:11 +00:00
'ASC_Shading_Min_OutsideTemperature' = > '-' ,
'ASC_Shading_WaitingPeriod' = > '-' ,
2019-09-17 11:42:55 +00:00
'ASC_Drive_Delay' = > '-' ,
'ASC_Drive_DelayStart' = > '-' ,
2019-09-20 10:53:52 +00:00
'ASC_Shutter_IdleDetection' = > '-' ,
2019-07-29 10:55:38 +00:00
'ASC_WindowRec' = > '-' ,
2019-04-25 15:15:56 +00:00
'ASC_WindowRec_subType:twostate,threestate' = > '-' ,
2019-07-29 10:55:38 +00:00
'ASC_WindowRec_PosAfterDayClosed:open,lastManual' = > '-' ,
2019-04-25 15:15:56 +00:00
'ASC_ShuttersPlace:window,terrace' = > '-' ,
2018-11-19 08:06:50 +00:00
'ASC_Ventilate_Pos:10,20,30,40,50,60,70,80,90,100' = > [ '' , 70 , 30 ] ,
'ASC_ComfortOpen_Pos:0,10,20,30,40,50,60,70,80,90,100' = > [ '' , 20 , 80 ] ,
2019-04-25 15:15:56 +00:00
'ASC_GuestRoom:on,off' = > '-' ,
'ASC_Antifreeze:off,soft,hard,am,pm' = > '-' ,
2018-12-07 12:04:41 +00:00
'ASC_Antifreeze_Pos:5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100'
2018-11-19 08:06:50 +00:00
= > [ '' , 85 , 15 ] ,
2019-09-16 15:15:02 +00:00
'ASC_Partymode:on,off' = > '-' ,
'ASC_Roommate_Device' = > '-' ,
'ASC_Roommate_Reading' = > '-' ,
'ASC_Self_Defense_Mode:absent,gone,off' = > '-' ,
'ASC_Self_Defense_AbsentDelay' = > '-' ,
'ASC_WiggleValue' = > '-' ,
'ASC_WindParameters' = > '-' ,
'ASC_DriveUpMaxDuration' = > '-' ,
'ASC_WindProtection:on,off' = > '-' ,
2019-11-04 07:09:46 +00:00
'ASC_RainProtection:on,off' = > '-' ,
2019-11-11 18:16:47 +00:00
'ASC_ExternalTrigger' = > '-' ,
'ASC_Adv:on,off' = > '-'
2018-10-14 16:19:23 +00:00
) ;
2018-11-07 07:22:11 +00:00
my % posSetCmds = (
2019-08-14 08:06:05 +00:00
ZWave = > 'dim' ,
Siro = > 'pct' ,
CUL_HM = > 'pct' ,
ROLLO = > 'pct' ,
SOMFY = > 'position' ,
tahoma = > 'dim' ,
KLF200Node = > 'pct' ,
DUOFERN = > 'position' ,
HM485 = > 'level' ,
2019-07-30 06:51:46 +00:00
SELVECommeo = > 'position' ,
SELVE = > 'position' ,
2019-08-22 15:09:50 +00:00
EnOcean = > 'position' ,
2018-11-07 07:22:11 +00:00
) ;
2018-10-14 16:19:23 +00:00
my $ shutters = new ASC_Shutters ( ) ;
my $ ascDev = new ASC_Dev ( ) ;
2018-10-10 08:43:42 +00:00
2019-07-29 09:28:53 +00:00
sub ascAPIget ($@) {
my ( $ getCommand , $ shutterDev , $ value ) = @ _ ;
2019-05-20 11:52:05 +00:00
2019-05-20 12:23:11 +00:00
my $ getter = 'get' . $ getCommand ;
2019-07-29 10:55:38 +00:00
2019-07-29 09:28:53 +00:00
if ( defined ( $ value ) and $ value ) {
$ shutters - > setShuttersDev ( $ shutterDev ) ;
return $ shutters - > $ getter ( $ value ) ;
}
elsif ( defined ( $ shutterDev ) and $ shutterDev ) {
2019-05-20 11:52:05 +00:00
$ shutters - > setShuttersDev ( $ shutterDev ) ;
return $ shutters - > $ getter ;
}
else {
return $ ascDev - > $ getter ;
}
}
2019-06-18 13:26:41 +00:00
sub Initialize ($) {
my ( $ hash ) = @ _ ;
2019-09-17 11:42:55 +00:00
### alte Attribute welche entfernt werden
2019-09-17 14:24:48 +00:00
my $ oldAttr = 'ASC_shuttersDriveOffset ' ;
2019-09-17 11:42:55 +00:00
2019-06-18 13:26:41 +00:00
## Da ich mit package arbeite müssen in die Initialize für die jeweiligen hash Fn Funktionen der Funktionsname
# und davor mit :: getrennt der eigentliche package Name des Modules
$ hash - > { SetFn } = 'FHEM::AutoShuttersControl::Set' ;
$ hash - > { GetFn } = 'FHEM::AutoShuttersControl::Get' ;
$ hash - > { DefFn } = 'FHEM::AutoShuttersControl::Define' ;
$ hash - > { NotifyFn } = 'FHEM::AutoShuttersControl::Notify' ;
$ hash - > { UndefFn } = 'FHEM::AutoShuttersControl::Undef' ;
$ hash - > { AttrFn } = 'FHEM::AutoShuttersControl::Attr' ;
$ hash - > { AttrList } =
'ASC_tempSensor '
. 'ASC_brightnessDriveUpDown '
. 'ASC_autoShuttersControlMorning:on,off '
. 'ASC_autoShuttersControlEvening:on,off '
. 'ASC_autoShuttersControlComfort:on,off '
. 'ASC_residentsDev '
. 'ASC_rainSensor '
. 'ASC_autoAstroModeMorning:REAL,CIVIL,NAUTIC,ASTRONOMIC,HORIZON '
. 'ASC_autoAstroModeMorningHorizon:-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9 '
. 'ASC_autoAstroModeEvening:REAL,CIVIL,NAUTIC,ASTRONOMIC,HORIZON '
. 'ASC_autoAstroModeEveningHorizon:-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9 '
. 'ASC_freezeTemp:-5,-4,-3,-2,-1,0,1,2,3,4,5 '
2019-09-17 11:42:55 +00:00
. 'ASC_shuttersDriveDelay '
2019-06-18 13:26:41 +00:00
. 'ASC_twilightDevice '
. 'ASC_windSensor '
. 'ASC_expert:1 '
. 'ASC_blockAscDrivesAfterManual:0,1 '
. 'ASC_debug:1 '
2019-09-17 11:42:55 +00:00
. $ oldAttr
2019-06-18 13:26:41 +00:00
. $ readingFnAttributes ;
$ hash - > { NotifyOrderPrefix } = '51-' ; # Order Nummer für NotifyFn
return FHEM::Meta:: InitMod ( __FILE__ , $ hash ) ;
}
2018-10-14 16:19:23 +00:00
sub Define ($$) {
my ( $ hash , $ def ) = @ _ ;
2018-11-28 12:07:52 +00:00
my @ a = split ( '[ \t][ \t]*' , $ def ) ;
2018-08-15 08:27:53 +00:00
2019-03-27 07:41:15 +00:00
return $@ unless ( FHEM::Meta:: SetInternals ( $ hash ) ) ;
2019-06-19 19:34:27 +00:00
use version 0.60 ; our $ VERSION = FHEM::Meta:: Get ( $ hash , 'version' ) ;
2019-06-19 14:56:17 +00:00
2018-11-28 12:07:52 +00:00
return 'only one AutoShuttersControl instance allowed'
2018-10-14 16:19:23 +00:00
if ( devspec2array ( 'TYPE=AutoShuttersControl' ) > 1 )
; # es wird geprüft ob bereits eine Instanz unseres Modules existiert,wenn ja wird abgebrochen
2018-11-28 12:07:52 +00:00
return 'too few parameters: define <name> ShuttersControl' if ( @ a != 2 ) ;
2019-06-13 13:06:30 +00:00
2018-10-14 16:19:23 +00:00
my $ name = $ a [ 0 ] ;
2019-06-21 07:19:49 +00:00
$ hash - > { MID } = 'da39a3ee5e6b4b0d3255bfef95601890afd80709'
2018-10-14 16:19:23 +00:00
; # eine Ein Eindeutige ID für interne FHEM Belange / nicht weiter wichtig
2019-09-17 14:24:48 +00:00
$ hash - > { VERSION } = version - > parse ( $ VERSION ) - > normal ;
2019-06-21 07:19:49 +00:00
$ hash - > { NOTIFYDEV } = 'global,'
2018-10-14 16:19:23 +00:00
. $ name ; # Liste aller Devices auf deren Events gehört werden sollen
2019-05-20 12:23:11 +00:00
#$hash->{shutters} = $shutters;
#$hash->{ascDev} = $ascDev;
2018-10-14 16:19:23 +00:00
$ ascDev - > setName ( $ name ) ;
2018-08-15 08:27:53 +00:00
2018-11-15 09:15:36 +00:00
readingsSingleUpdate (
$ hash ,
2018-11-28 12:07:52 +00:00
'state' ,
'please set attribute ASC with value 1 or 2 in all auto controlled shutter devices and then execute \'set DEVICENAME scanForShutters\'' ,
2018-11-15 09:15:36 +00:00
1
) ;
2018-11-14 23:44:41 +00:00
2018-10-14 16:19:23 +00:00
CommandAttr ( undef , $ name . ' room ASC' )
if ( AttrVal ( $ name , 'room' , 'none' ) eq 'none' ) ;
CommandAttr ( undef , $ name . ' icon fts_shutter_automatic' )
if ( AttrVal ( $ name , 'icon' , 'none' ) eq 'none' ) ;
2019-05-04 21:01:57 +00:00
2018-11-08 07:32:47 +00:00
CommandAttr ( undef ,
$ name
2019-06-25 07:18:50 +00:00
. ' devStateIcon selfDefense.terrace:fts_door_tilt created.new.drive.timer:clock .*asleep:scene_sleeping roommate.(awoken|home):user_available residents.(home|awoken):status_available manual:fts_shutter_manual selfDefense.active:status_locked selfDefense.inactive:status_open day.open:scene_day night.close:scene_night shading.in:weather_sun shading.out:weather_cloudy'
2018-11-08 07:32:47 +00:00
) if ( AttrVal ( $ name , 'devStateIcon' , 'none' ) eq 'none' ) ;
2018-08-15 08:27:53 +00:00
2018-10-14 16:19:23 +00:00
addToAttrList ( 'ASC:0,1,2' ) ;
2018-08-15 08:27:53 +00:00
2018-10-14 16:19:23 +00:00
Log3 ( $ name , 3 , "AutoShuttersControl ($name) - defined" ) ;
2018-08-15 08:27:53 +00:00
2018-10-14 16:19:23 +00:00
$ modules { AutoShuttersControl } { defptr } { $ hash - > { MID } } = $ hash ;
2018-08-15 08:27:53 +00:00
return undef ;
}
sub Undef ($$) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ arg ) = @ _ ;
2018-08-15 08:27:53 +00:00
my $ name = $ hash - > { NAME } ;
2018-10-14 16:19:23 +00:00
UserAttributs_Readings_ForShutters ( $ hash , 'del' )
; # es sollen alle Attribute und Readings in den Rolläden Devices gelöscht werden welche vom Modul angelegt wurden
2018-09-27 08:19:41 +00:00
delFromAttrList ( 'ASC:0,1,2' ) ;
2018-10-14 16:19:23 +00:00
delete ( $ modules { AutoShuttersControl } { defptr } { $ hash - > { MID } } ) ;
Log3 ( $ name , 3 , "AutoShuttersControl ($name) - delete device $name" ) ;
2018-08-15 08:27:53 +00:00
return undef ;
}
sub Attr (@) {
my ( $ cmd , $ name , $ attrName , $ attrVal ) = @ _ ;
2019-06-03 05:44:35 +00:00
# my $hash = $defs{$name};
2018-08-15 08:27:53 +00:00
return undef ;
}
sub Notify ($$) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ dev ) = @ _ ;
2018-08-15 08:27:53 +00:00
my $ name = $ hash - > { NAME } ;
2018-09-03 20:19:25 +00:00
2018-08-15 08:27:53 +00:00
my $ devname = $ dev - > { NAME } ;
my $ devtype = $ dev - > { TYPE } ;
2018-10-14 16:19:23 +00:00
my $ events = deviceEvents ( $ dev , 1 ) ;
return if ( ! $ events ) ;
2019-03-06 14:53:48 +00:00
Log3 ( $ name , 4 ,
2018-10-14 16:19:23 +00:00
"AutoShuttersControl ($name) - Devname: "
. $ devname
. " Name: "
. $ name
. " Notify: "
. Dumper $ events ) ; # mit Dumper
if (
(
grep /^DEFINED.$name$/ ,
@ { $ events } and $ devname eq 'global' and $ init_done
)
or (
grep /^INITIALIZED$/ ,
@ { $ events } or grep /^REREADCFG$/ ,
@ { $ events } or grep /^MODIFIED.$name$/ ,
@ { $ events }
)
2018-08-15 08:27:53 +00:00
and $ devname eq 'global'
2018-10-14 16:19:23 +00:00
)
{
readingsSingleUpdate ( $ hash , 'partyMode' , 'off' , 0 )
2018-11-03 18:01:29 +00:00
if ( $ ascDev - > getPartyMode eq 'none' ) ;
2018-12-06 14:24:16 +00:00
readingsSingleUpdate ( $ hash , 'hardLockOut' , 'off' , 0 )
if ( $ ascDev - > getHardLockOut eq 'none' ) ;
2018-10-14 16:19:23 +00:00
readingsSingleUpdate ( $ hash , 'sunriseTimeWeHoliday' , 'off' , 0 )
if ( $ ascDev - > getSunriseTimeWeHoliday eq 'none' ) ;
readingsSingleUpdate ( $ hash , 'selfDefense' , 'off' , 0 )
if ( $ ascDev - > getSelfDefense eq 'none' ) ;
2019-05-04 21:01:57 +00:00
readingsSingleUpdate ( $ hash , 'controlShading' , 'off' , 0 )
if ( $ ascDev - > getAutoShuttersControlShading eq 'none' ) ;
2019-05-17 12:20:57 +00:00
readingsSingleUpdate ( $ hash , 'ascEnable' , 'on' , 0 )
if ( $ ascDev - > getASCenable eq 'none' ) ;
2019-01-02 08:38:00 +00:00
2018-10-14 16:19:23 +00:00
# Ist der Event ein globaler und passt zum Rest der Abfrage oben wird nach neuen Rolläden Devices gescannt und eine Liste im Rolladenmodul sortiert nach Raum generiert
ShuttersDeviceScan ( $ hash )
unless ( ReadingsVal ( $ name , 'userAttrList' , 'none' ) eq 'none' ) ;
}
return
unless ( ref ( $ hash - > { helper } { shuttersList } ) eq 'ARRAY'
and scalar ( @ { $ hash - > { helper } { shuttersList } } ) > 0 ) ;
2018-10-19 18:13:01 +00:00
2018-10-17 13:58:05 +00:00
my $ posReading = $ shutters - > getPosCmd ;
2018-10-14 16:19:23 +00:00
if ( $ devname eq $ name ) {
if ( grep /^userAttrList:.rolled.out$/ , @ { $ events } ) {
unless ( scalar ( @ { $ hash - > { helper } { shuttersList } } ) == 0 ) {
2018-09-04 09:42:47 +00:00
WriteReadingsShuttersList ( $ hash ) ;
2018-10-14 16:19:23 +00:00
UserAttributs_Readings_ForShutters ( $ hash , 'add' ) ;
InternalTimer ( gettimeofday ( ) + 3 ,
2019-03-27 07:41:15 +00:00
'FHEM::AutoShuttersControl::RenewSunRiseSetShuttersTimer' ,
2018-10-14 16:19:23 +00:00
$ hash ) ;
2018-11-14 23:44:41 +00:00
InternalTimer ( gettimeofday ( ) + 5 ,
2019-03-27 07:41:15 +00:00
'FHEM::AutoShuttersControl::AutoSearchTwilightDev' , $ hash ) ;
2018-09-04 09:42:47 +00:00
}
2018-10-14 16:19:23 +00:00
}
elsif ( grep /^partyMode:.off$/ , @ { $ events } ) {
2018-11-12 11:56:18 +00:00
EventProcessingPartyMode ( $ hash ) ;
2018-10-14 16:19:23 +00:00
}
elsif ( grep /^sunriseTimeWeHoliday:.(on|off)$/ , @ { $ events } ) {
2018-09-18 07:35:45 +00:00
RenewSunRiseSetShuttersTimer ( $ hash ) ;
2018-09-04 09:42:47 +00:00
}
2018-10-14 16:19:23 +00:00
}
elsif ( $ devname eq "global" )
{ # Kommt ein globales Event und beinhaltet folgende Syntax wird die Funktion zur Verarbeitung aufgerufen
if (
grep
2019-11-05 12:44:40 +00:00
/^(ATTR|DELETEATTR)\s(.*ASC_Time_Up_WE_Holiday|.*ASC_Up|.*ASC_Down|.*ASC_AutoAstroModeMorning|.*ASC_AutoAstroModeMorningHorizon|.*ASC_AutoAstroModeEvening|.*ASC_AutoAstroModeEveningHorizon|.*ASC_Time_Up_Early|.*ASC_Time_Up_Late|.*ASC_Time_Down_Early|.*ASC_Time_Down_Late|.*ASC_autoAstroModeMorning|.*ASC_autoAstroModeMorningHorizon|.*ASC_PrivacyDownValue_beforeNightClose|.*ASC_PrivacyUpValue_beforeDayOpen|.*ASC_autoAstroModeEvening|.*ASC_autoAstroModeEveningHorizon|.*ASC_Roommate_Device|.*ASC_WindowRec|.*ASC_residentsDev|.*ASC_rainSensor|.*ASC_windSensor|.*ASC_BrightnessSensor|.*ASC_twilightDevice|.*ASC_ExternalTrigger)(\s.*|$)/ ,
2018-10-27 11:36:11 +00:00
@ { $ events }
)
2018-10-14 16:19:23 +00:00
{
2018-11-12 11:56:18 +00:00
EventProcessingGeneral ( $ hash , undef , join ( ' ' , @ { $ events } ) ) ;
2018-08-16 08:37:09 +00:00
}
2018-08-15 08:27:53 +00:00
}
2018-10-19 18:13:01 +00:00
elsif ( grep /^($posReading):\s\d+$/ , @ { $ events } ) {
2019-08-26 08:34:11 +00:00
ASC_Debug ( 'Notify: '
. ' ASC_Pos_Reading Event vom Rollo wurde erkannt '
. ' - RECEIVED EVENT: '
. Dumper $ events ) ;
2018-11-12 11:56:18 +00:00
EventProcessingShutters ( $ hash , $ devname , join ( ' ' , @ { $ events } ) ) ;
2018-10-19 18:13:01 +00:00
}
2018-10-14 16:19:23 +00:00
else {
2018-11-12 11:56:18 +00:00
EventProcessingGeneral ( $ hash , $ devname , join ( ' ' , @ { $ events } ) )
2018-10-14 16:19:23 +00:00
; # bei allen anderen Events wird die entsprechende Funktion zur Verarbeitung aufgerufen
}
2018-08-15 08:27:53 +00:00
return ;
}
2018-11-12 11:56:18 +00:00
sub EventProcessingGeneral ($$$) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ devname , $ events ) = @ _ ;
my $ name = $ hash - > { NAME } ;
2018-08-16 08:37:09 +00:00
2018-10-14 16:19:23 +00:00
if ( defined ( $ devname ) and ( $ devname ) )
{ # es wird lediglich der Devicename der Funktion mitgegeben wenn es sich nicht um global handelt daher hier die Unterschiedung
while ( my ( $ device , $ deviceAttr ) =
each % { $ hash - > { monitoredDevs } { $ devname } } )
{
2018-11-12 11:56:18 +00:00
EventProcessingWindowRec ( $ hash , $ device , $ events )
2018-10-14 16:19:23 +00:00
if ( $ deviceAttr eq 'ASC_WindowRec' )
; # ist es ein Fensterdevice wird die Funktion gestartet
2018-11-12 11:56:18 +00:00
EventProcessingRoommate ( $ hash , $ device , $ events )
2018-10-14 16:19:23 +00:00
if ( $ deviceAttr eq 'ASC_Roommate_Device' )
; # ist es ein Bewohner Device wird diese Funktion gestartet
2018-11-12 11:56:18 +00:00
EventProcessingResidents ( $ hash , $ device , $ events )
2019-03-04 13:02:54 +00:00
if ( $ deviceAttr eq 'ASC_residentsDev' ) ;
2018-11-12 11:56:18 +00:00
EventProcessingRain ( $ hash , $ device , $ events )
2019-03-04 13:02:54 +00:00
if ( $ deviceAttr eq 'ASC_rainSensor' ) ;
2019-02-26 11:04:10 +00:00
EventProcessingWind ( $ hash , $ device , $ events )
2019-03-04 09:57:39 +00:00
if ( $ deviceAttr eq 'ASC_windSensor' ) ;
2018-11-14 02:41:38 +00:00
EventProcessingTwilightDevice ( $ hash , $ device , $ events )
if ( $ deviceAttr eq 'ASC_twilightDevice' ) ;
2019-11-04 07:09:46 +00:00
EventProcessingExternalTriggerDevice ( $ hash , $ device , $ events )
2019-11-05 12:44:40 +00:00
if ( $ deviceAttr eq 'ASC_ExternalTrigger' ) ;
2018-10-14 16:19:23 +00:00
$ shutters - > setShuttersDev ( $ device )
2019-03-24 15:41:48 +00:00
if ( $ deviceAttr eq 'ASC_BrightnessSensor' ) ;
2018-11-14 02:41:38 +00:00
if (
2019-03-24 15:41:48 +00:00
$ deviceAttr eq 'ASC_BrightnessSensor'
2018-11-19 08:06:50 +00:00
and ( $ shutters - > getDown eq 'brightness'
or $ shutters - > getUp eq 'brightness' )
)
{
2018-11-14 02:41:38 +00:00
EventProcessingBrightness ( $ hash , $ device , $ events ) ;
}
2019-03-24 15:41:48 +00:00
elsif ( $ deviceAttr eq 'ASC_BrightnessSensor' ) {
2018-11-14 02:41:38 +00:00
EventProcessingShadingBrightness ( $ hash , $ device , $ events ) ;
}
2018-08-28 17:49:01 +00:00
}
2018-10-14 16:19:23 +00:00
}
else { # alles was kein Devicenamen mit übergeben hat landet hier
if ( $ events =~
2019-11-05 12:44:40 +00:00
m #^ATTR\s(.*)\s(ASC_Roommate_Device|ASC_WindowRec|ASC_residentsDev|ASC_rainSensor|ASC_windSensor|ASC_BrightnessSensor|ASC_ExternalTrigger|ASC_twilightDevice)\s(.*)$#
2018-10-14 16:19:23 +00:00
)
{ # wurde den Attributen unserer Rolläden ein Wert zugewiesen ?
2018-11-07 07:22:11 +00:00
AddNotifyDev ( $ hash , $ 3 , $ 1 , $ 2 ) if ( $ 3 ne 'none' ) ;
2018-10-14 16:19:23 +00:00
Log3 ( $ name , 4 ,
"AutoShuttersControl ($name) - EventProcessing: ATTR" ) ;
2018-08-28 17:49:01 +00:00
}
2018-10-14 16:19:23 +00:00
elsif ( $ events =~
2019-11-05 12:44:40 +00:00
m #^DELETEATTR\s(.*)\s(ASC_Roommate_Device|ASC_WindowRec|ASC_residentsDev|ASC_rainSensor|ASC_windSensor|ASC_BrightnessSensor|ASC_ExternalTrigger|ASC_twilightDevice)$#
2018-10-14 16:19:23 +00:00
)
{ # wurde das Attribut unserer Rolläden gelöscht ?
Log3 ( $ name , 4 ,
"AutoShuttersControl ($name) - EventProcessing: DELETEATTR" ) ;
DeleteNotifyDev ( $ hash , $ 1 , $ 2 ) ;
2018-08-27 09:08:08 +00:00
}
2018-10-27 11:36:11 +00:00
elsif ( $ events =~
2019-10-25 08:44:08 +00:00
m #^(DELETEATTR|ATTR)\s(.*)\s(ASC_Time_Up_WE_Holiday|ASC_Up|ASC_Down|ASC_AutoAstroModeMorning|ASC_AutoAstroModeMorningHorizon|ASC_PrivacyDownValue_beforeNightClose|ASC_PrivacyUpValue_beforeDayOpen|ASC_AutoAstroModeEvening|ASC_AutoAstroModeEveningHorizon|ASC_Time_Up_Early|ASC_Time_Up_Late|ASC_Time_Down_Early|ASC_Time_Down_Late)(.*)?#
2018-10-27 11:36:11 +00:00
)
{
2019-05-28 07:23:10 +00:00
CreateSunRiseSetShuttersTimer ( $ hash , $ 2 )
2018-10-27 11:36:11 +00:00
if (
2019-05-28 07:23:10 +00:00
$ 3 ne 'ASC_Time_Up_WE_Holiday'
or ( $ 3 eq 'ASC_Time_Up_WE_Holiday'
2018-10-27 11:36:11 +00:00
and $ ascDev - > getSunriseTimeWeHoliday eq 'on' )
) ;
}
2018-11-07 07:22:11 +00:00
elsif ( $ events =~
2019-05-28 07:23:10 +00:00
m #^(DELETEATTR|ATTR)\s(.*)\s(ASC_autoAstroModeMorning|ASC_autoAstroModeMorningHorizon|ASC_autoAstroModeEvening|ASC_autoAstroModeEveningHorizon)(.*)?#
2018-11-07 07:22:11 +00:00
)
{
RenewSunRiseSetShuttersTimer ( $ hash ) ;
}
2018-08-16 08:37:09 +00:00
}
}
2018-08-15 08:27:53 +00:00
sub Set ($$@) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ name , @ aa ) = @ _ ;
my ( $ cmd , @ args ) = @ aa ;
2019-09-19 12:16:04 +00:00
if ( lc $ cmd eq 'renewalltimer' ) {
2018-10-14 16:19:23 +00:00
return "usage: $cmd" if ( @ args != 0 ) ;
2018-08-29 12:58:10 +00:00
RenewSunRiseSetShuttersTimer ( $ hash ) ;
2018-10-14 16:19:23 +00:00
}
2019-09-19 12:16:04 +00:00
elsif ( lc $ cmd eq 'renewtimer' ) {
return "usage: $cmd" if ( @ args > 1 ) ;
2019-09-20 12:03:13 +00:00
CreateSunRiseSetShuttersTimer ( $ hash , $ args [ 0 ] ) ;
2019-09-19 12:16:04 +00:00
}
2018-10-14 16:19:23 +00:00
elsif ( lc $ cmd eq 'scanforshutters' ) {
return "usage: $cmd" if ( @ args != 0 ) ;
2018-09-03 20:19:25 +00:00
ShuttersDeviceScan ( $ hash ) ;
2018-10-14 16:19:23 +00:00
}
elsif ( lc $ cmd eq 'createnewnotifydev' ) {
return "usage: $cmd" if ( @ args != 0 ) ;
2018-10-08 01:59:51 +00:00
CreateNewNotifyDev ( $ hash ) ;
2018-10-14 16:19:23 +00:00
}
elsif ( lc $ cmd eq 'partymode' ) {
return "usage: $cmd" if ( @ args > 1 ) ;
2019-02-11 20:26:42 +00:00
readingsSingleUpdate ( $ hash , $ cmd , join ( ' ' , @ args ) , 1 )
2019-04-09 10:13:46 +00:00
if ( join ( ' ' , @ args ) ne ReadingsVal ( $ name , 'partyMode' , 0 ) ) ;
2018-10-14 16:19:23 +00:00
}
2018-11-21 20:56:29 +00:00
elsif ( lc $ cmd eq 'hardlockout' ) {
2018-10-14 16:19:23 +00:00
return "usage: $cmd" if ( @ args > 1 ) ;
readingsSingleUpdate ( $ hash , $ cmd , join ( ' ' , @ args ) , 1 ) ;
2018-11-21 07:38:32 +00:00
HardewareBlockForShutters ( $ hash , join ( ' ' , @ args ) ) ;
2018-10-14 16:19:23 +00:00
}
elsif ( lc $ cmd eq 'sunrisetimeweholiday' ) {
return "usage: $cmd" if ( @ args > 1 ) ;
readingsSingleUpdate ( $ hash , $ cmd , join ( ' ' , @ args ) , 1 ) ;
}
2019-05-04 21:01:57 +00:00
elsif ( lc $ cmd eq 'controlshading' ) {
return "usage: $cmd" if ( @ args > 1 ) ;
readingsSingleUpdate ( $ hash , $ cmd , join ( ' ' , @ args ) , 1 ) ;
}
2018-10-14 16:19:23 +00:00
elsif ( lc $ cmd eq 'selfdefense' ) {
return "usage: $cmd" if ( @ args > 1 ) ;
readingsSingleUpdate ( $ hash , $ cmd , join ( ' ' , @ args ) , 1 ) ;
}
2019-05-17 12:20:57 +00:00
elsif ( lc $ cmd eq 'ascenable' ) {
return "usage: $cmd" if ( @ args > 1 ) ;
readingsSingleUpdate ( $ hash , $ cmd , join ( ' ' , @ args ) , 1 ) ;
}
2019-11-11 18:16:47 +00:00
elsif ( lc $ cmd eq 'advdrivedown' ) {
return "usage: $cmd" if ( @ args != 0 ) ;
EventProcessingAdvShuttersClose ( $ hash ) ;
}
2019-05-17 12:20:57 +00:00
elsif ( lc $ cmd eq 'shutterascenabletoggle' ) {
return "usage: $cmd" if ( @ args > 1 ) ;
readingsSingleUpdate (
$ defs { $ args [ 0 ] } ,
'ASC_Enable' ,
(
ReadingsVal ( $ args [ 0 ] , 'ASC_Enable' , 'off' ) eq 'on'
? 'off'
: 'on'
) ,
1
) ;
}
2018-11-07 07:22:11 +00:00
elsif ( lc $ cmd eq 'wiggle' ) {
return "usage: $cmd" if ( @ args > 1 ) ;
2018-11-08 07:32:47 +00:00
( $ args [ 0 ] eq 'all' ? wiggleAll ( $ hash ) : wiggle ( $ hash , $ args [ 0 ] ) ) ;
2018-11-07 07:22:11 +00:00
}
2018-10-14 16:19:23 +00:00
else {
2019-05-17 12:20:57 +00:00
my $ list = 'scanForShutters:noArg' ;
2018-10-14 16:19:23 +00:00
$ list . =
2019-11-11 18:16:47 +00:00
' renewAllTimer:noArg advDriveDown:noArg partyMode:on,off hardLockOut:on,off sunriseTimeWeHoliday:on,off controlShading:on,off selfDefense:on,off ascEnable:on,off wiggle:all,'
2018-11-08 07:32:47 +00:00
. join ( ',' , @ { $ hash - > { helper } { shuttersList } } )
2019-09-19 12:16:04 +00:00
. ' shutterASCenableToggle:'
. join ( ',' , @ { $ hash - > { helper } { shuttersList } } )
. ' renewTimer:'
. join ( ',' , @ { $ hash - > { helper } { shuttersList } } )
2019-09-20 12:03:13 +00:00
if ( ReadingsVal ( $ name , 'userAttrList' , 'none' ) eq 'rolled out' ) ;
2019-05-17 12:20:57 +00:00
$ list . = ' createNewNotifyDev:noArg'
2018-10-28 17:12:40 +00:00
if ( ReadingsVal ( $ name , 'userAttrList' , 'none' ) eq 'rolled out'
2018-11-11 11:31:20 +00:00
and AttrVal ( $ name , 'ASC_expert' , 0 ) == 1 ) ;
2018-10-08 01:59:51 +00:00
2018-10-14 16:19:23 +00:00
return "Unknown argument $cmd,choose one of $list" ;
2018-08-15 08:27:53 +00:00
}
return undef ;
}
2018-09-21 06:44:38 +00:00
sub Get ($$@) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ name , @ aa ) = @ _ ;
2018-09-21 06:44:38 +00:00
2018-10-14 16:19:23 +00:00
my ( $ cmd , @ args ) = @ aa ;
2018-09-21 06:44:38 +00:00
2018-10-14 16:19:23 +00:00
if ( lc $ cmd eq 'showshuttersinformations' ) {
return "usage: $cmd" if ( @ args != 0 ) ;
2018-09-21 06:44:38 +00:00
my $ ret = GetShuttersInformation ( $ hash ) ;
return $ ret ;
2018-10-14 16:19:23 +00:00
}
elsif ( lc $ cmd eq 'shownotifydevsinformations' ) {
return "usage: $cmd" if ( @ args != 0 ) ;
2018-10-08 01:59:51 +00:00
my $ ret = GetMonitoredDevs ( $ hash ) ;
return $ ret ;
2018-10-14 16:19:23 +00:00
}
else {
2018-09-21 06:44:38 +00:00
my $ list = "" ;
2018-10-28 17:12:40 +00:00
$ list . = " showShuttersInformations:noArg"
2018-10-14 16:19:23 +00:00
if ( ReadingsVal ( $ name , 'userAttrList' , 'none' ) eq 'rolled out' ) ;
2018-10-27 12:09:02 +00:00
$ list . = " showNotifyDevsInformations:noArg"
2018-10-27 11:36:11 +00:00
if ( ReadingsVal ( $ name , 'userAttrList' , 'none' ) eq 'rolled out'
2018-11-11 11:31:20 +00:00
and AttrVal ( $ name , 'ASC_expert' , 0 ) == 1 ) ;
2018-10-28 17:12:40 +00:00
2018-10-14 16:19:23 +00:00
return "Unknown argument $cmd,choose one of $list" ;
2018-09-21 06:44:38 +00:00
}
}
2018-08-15 08:27:53 +00:00
sub ShuttersDeviceScan ($) {
2018-10-14 16:19:23 +00:00
my $ hash = shift ;
my $ name = $ hash - > { NAME } ;
2018-09-13 08:38:35 +00:00
delete $ hash - > { helper } { shuttersList } ;
2018-08-15 08:27:53 +00:00
my @ list ;
2018-09-27 08:19:41 +00:00
@ list = devspec2array ( 'ASC=[1-2]' ) ;
2018-09-13 13:21:29 +00:00
2018-10-14 16:19:23 +00:00
CommandDeleteReading ( undef , $ name . ' .*_nextAstroTimeEvent' ) ;
unless ( scalar ( @ list ) > 0 ) {
2018-09-03 20:19:25 +00:00
readingsBeginUpdate ( $ hash ) ;
2018-10-14 16:19:23 +00:00
readingsBulkUpdate ( $ hash , 'userAttrList' , 'none' ) ;
readingsBulkUpdate ( $ hash , 'state' , 'no shutters found' ) ;
readingsEndUpdate ( $ hash , 1 ) ;
2018-09-03 20:19:25 +00:00
return ;
}
2018-10-17 13:58:05 +00:00
my $ shuttersList = '' ;
2018-10-14 16:19:23 +00:00
foreach ( @ list ) {
push ( @ { $ hash - > { helper } { shuttersList } } , $ _ )
; ## einem Hash wird ein Array zugewiesen welches die Liste der erkannten Rollos beinhaltet
2019-09-06 16:40:10 +00:00
2019-09-06 16:36:48 +00:00
$ shutters - > setShuttersDev ( $ _ ) ;
2019-09-06 16:40:10 +00:00
2019-09-06 16:36:48 +00:00
#### Ab hier können temporäre Änderungen der Attribute gesetzt werden
#### Gleichlautende Attribute wo lediglich die Parameter geändert werden sollen müssen hier gelöscht und die Parameter in der Funktion renewSetSunriseSunsetTimer gesetzt werden,
#### vorher empfiehlt es sich die dort vergebenen Parameter aus zu lesen um sie dann hier wieder neu zu setzen. Dazu wird das shutters Objekt um einen Eintrag
#### 'AttrUpdateChanges' erweitert
2019-09-06 16:40:10 +00:00
if ( ReadingsVal ( $ _ , '.ASC_AttrUpdateChanges_' . $ hash - > { VERSION } , 0 )
== 0 )
{
$ shutters - > setAttrUpdateChanges ( 'ASC_Up' ,
AttrVal ( $ _ , 'ASC_Up' , 'none' ) ) ;
2019-09-06 16:36:48 +00:00
delFromDevAttrList ( $ _ , 'ASC_Up' ) ;
2019-09-06 16:40:10 +00:00
$ shutters - > setAttrUpdateChanges ( 'ASC_Down' ,
AttrVal ( $ _ , 'ASC_Down' , 'none' ) ) ;
2019-09-06 16:36:48 +00:00
delFromDevAttrList ( $ _ , 'ASC_Down' ) ;
2019-09-16 15:15:02 +00:00
$ shutters - > setAttrUpdateChanges ( 'ASC_Self_Defense_Mode' ,
AttrVal ( $ _ , 'ASC_Self_Defense_Mode' , 'none' ) ) ;
delFromDevAttrList ( $ _ , 'ASC_Self_Defense_Mode' ) ;
$ shutters - > setAttrUpdateChanges ( 'ASC_Self_Defense_Exclude' ,
AttrVal ( $ _ , 'ASC_Self_Defense_Exclude' , 'none' ) ) ;
delFromDevAttrList ( $ _ , 'ASC_Self_Defense_Exclude' ) ;
2019-09-06 16:40:10 +00:00
}
2019-09-17 11:42:55 +00:00
####
2019-09-06 16:36:48 +00:00
####
2019-03-07 16:58:30 +00:00
2018-10-17 13:58:05 +00:00
$ shuttersList = $ shuttersList . ',' . $ _ ;
2018-10-19 18:13:01 +00:00
$ shutters - > setLastManPos ( $ shutters - > getStatus ) ;
2018-10-28 17:12:40 +00:00
$ shutters - > setLastPos ( $ shutters - > getStatus ) ;
2018-10-27 11:36:11 +00:00
$ shutters - > setDelayCmd ( 'none' ) ;
2019-09-17 14:52:19 +00:00
$ shutters - > setNoDelay ( 0 ) ;
2019-06-25 11:19:22 +00:00
$ shutters - > setSelfDefenseAbsent ( 0 , 0 ) ;
2018-11-12 08:12:04 +00:00
$ shutters - > setPosSetCmd ( $ posSetCmds { $ defs { $ _ } - > { TYPE } } ) ;
2019-04-09 10:13:46 +00:00
$ shutters - > setShadingStatus (
( $ shutters - > getStatus != $ shutters - > getShadingPos ? 'out' : 'in' )
) ;
2019-06-13 13:41:03 +00:00
$ shutters - > setShadingLastStatus (
( $ shutters - > getStatus != $ shutters - > getShadingPos ? 'in' : 'out' )
) ;
2019-09-02 12:34:42 +00:00
$ shutters - > setPushBrightnessInArray ( $ shutters - > getBrightness ) ;
2019-05-17 12:20:57 +00:00
readingsSingleUpdate ( $ defs { $ _ } , 'ASC_Enable' , 'on' , 0 )
if ( ReadingsVal ( $ _ , 'ASC_Enable' , 'none' ) eq 'none' ) ;
2019-11-11 08:32:28 +00:00
if ( $ shutters - > getIsDay ) {
$ shutters - > setSunrise ( 1 ) ;
$ shutters - > setSunset ( 0 ) ;
}
else {
$ shutters - > setSunrise ( 0 ) ;
$ shutters - > setSunset ( 1 ) ;
}
2018-08-15 08:27:53 +00:00
}
2019-03-07 16:58:30 +00:00
2019-09-19 11:46:42 +00:00
####
CommandAttr ( undef ,
$ name
. ' ASC_shuttersDriveDelay '
. AttrVal ( $ name , 'ASC_shuttersDriveOffset' , - 1 ) )
if ( AttrVal ( $ name , 'ASC_shuttersDriveOffset' , 'none' ) ne 'none' ) ;
CommandDeleteAttr ( undef , $ name . ' ASC_shuttersDriveOffset' )
if ( AttrVal ( $ name , 'ASC_shuttersDriveOffset' , 'none' ) ne 'none' ) ;
####
2018-11-19 08:06:50 +00:00
$ hash - > { NOTIFYDEV } = "global," . $ name . $ shuttersList ;
2018-10-19 18:13:01 +00:00
2018-10-14 16:19:23 +00:00
if ( $ ascDev - > getMonitoredDevs ne 'none' ) {
$ hash - > { monitoredDevs } =
eval { decode_json ( $ ascDev - > getMonitoredDevs ) } ;
2018-09-07 12:10:46 +00:00
my $ notifyDevString = $ hash - > { NOTIFYDEV } ;
2018-10-14 16:19:23 +00:00
while ( each % { $ hash - > { monitoredDevs } } ) {
2018-10-19 18:13:01 +00:00
$ notifyDevString . = ',' . $ _ ;
2018-08-16 08:37:09 +00:00
}
2018-10-14 16:19:23 +00:00
$ hash - > { NOTIFYDEV } = $ notifyDevString ;
2018-08-16 08:37:09 +00:00
}
2018-10-14 16:19:23 +00:00
readingsSingleUpdate ( $ hash , 'userAttrList' , 'rolled out' , 1 ) ;
2018-08-15 08:27:53 +00:00
}
2018-08-29 12:58:10 +00:00
## Die Funktion schreibt in das Moduldevice Readings welche Rolläden in welchen Räumen erfasst wurden.
2018-08-15 08:27:53 +00:00
sub WriteReadingsShuttersList ($) {
2018-10-14 16:19:23 +00:00
my $ hash = shift ;
my $ name = $ hash - > { NAME } ;
2018-08-15 08:27:53 +00:00
2018-10-14 16:19:23 +00:00
CommandDeleteReading ( undef , $ name . ' room_.*' ) ;
2018-08-15 08:27:53 +00:00
readingsBeginUpdate ( $ hash ) ;
2018-10-14 16:19:23 +00:00
foreach ( @ { $ hash - > { helper } { shuttersList } } ) {
readingsBulkUpdate (
$ hash ,
'room_' . makeReadingName ( AttrVal ( $ _ , 'room' , 'unsorted' ) ) ,
ReadingsVal (
$ name ,
'room_' . makeReadingName ( AttrVal ( $ _ , 'room' , 'unsorted' ) ) ,
''
)
. ','
. $ _
)
if (
ReadingsVal (
$ name ,
'room_' . makeReadingName ( AttrVal ( $ _ , 'room' , 'unsorted' ) ) ,
'none'
) ne 'none'
) ;
readingsBulkUpdate ( $ hash ,
'room_' . makeReadingName ( AttrVal ( $ _ , 'room' , 'unsorted' ) ) , $ _ )
if (
ReadingsVal (
$ name ,
'room_' . makeReadingName ( AttrVal ( $ _ , 'room' , 'unsorted' ) ) ,
'none'
) eq 'none'
) ;
2018-08-15 08:27:53 +00:00
}
2018-10-14 16:19:23 +00:00
readingsBulkUpdate ( $ hash , 'state' , 'active' ) ;
readingsEndUpdate ( $ hash , 0 ) ;
2018-08-15 08:27:53 +00:00
}
2018-08-31 07:32:16 +00:00
sub UserAttributs_Readings_ForShutters ($$) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ cmd ) = @ _ ;
my $ name = $ hash - > { NAME } ;
2018-08-15 08:27:53 +00:00
2018-10-14 16:19:23 +00:00
while ( my ( $ attrib , $ attribValue ) = each % { userAttrList } ) {
foreach ( @ { $ hash - > { helper } { shuttersList } } ) {
addToDevAttrList ( $ _ , $ attrib )
; ## fhem.pl bietet eine Funktion um ein userAttr Attribut zu befüllen. Wir schreiben also in den Attribut userAttr alle unsere Attribute rein. Pro Rolladen immer ein Attribut pro Durchlauf
2018-08-29 12:58:10 +00:00
## Danach werden die Attribute die im userAttr stehen gesetzt und mit default Werten befüllt
2019-04-04 17:11:23 +00:00
## CommandAttr hat nicht funktioniert. Führte zu Problemen
2019-04-09 10:13:46 +00:00
## https://github.com/LeonGaultier/fhem-AutoShuttersControl/commit/e33d3cc7815031b087736c1054b98c57817e7083
2018-10-14 16:19:23 +00:00
if ( $ cmd eq 'add' ) {
if ( ref ( $ attribValue ) ne 'ARRAY' ) {
$ attr { $ _ } { ( split ( ':' , $ attrib ) ) [ 0 ] } = $ attribValue
if (
2019-04-25 19:34:46 +00:00
not defined ( $ attr { $ _ } { ( split ( ':' , $ attrib ) ) [ 0 ] } )
2019-04-25 15:15:56 +00:00
and $ attribValue ne '-' ) ;
2018-10-14 16:19:23 +00:00
}
else {
$ attr { $ _ } { ( split ( ':' , $ attrib ) ) [ 0 ] } =
$ attribValue - > [ AttrVal ( $ _ , 'ASC' , 2 ) ]
if (
2019-04-25 19:34:46 +00:00
not defined ( $ attr { $ _ } { ( split ( ':' , $ attrib ) ) [ 0 ] } )
2019-04-25 15:15:56 +00:00
and $ attrib eq 'ASC_Pos_Reading' ) ;
2018-09-03 20:19:25 +00:00
}
2019-05-03 11:36:39 +00:00
### associatedWith damit man sieht das der Rollladen mit einem ASC Device verbunden ist
my $ associatedString =
ReadingsVal ( $ _ , 'associatedWith' , 'none' ) ;
if ( $ associatedString ne 'none' ) {
my % hash ;
% hash = map { ( $ _ = > 1 ) }
split ( ',' , "$associatedString,$name" ) ;
readingsSingleUpdate ( $ defs { $ _ } ,
'associatedWith' , join ( ',' , sort keys % hash ) , 0 ) ;
}
else {
readingsSingleUpdate ( $ defs { $ _ } ,
'associatedWith' , $ name , 0 ) ;
}
#######################################
2018-10-14 16:19:23 +00:00
}
2019-03-07 16:58:30 +00:00
## Oder das Attribut wird wieder gelöscht.
2018-10-14 16:19:23 +00:00
elsif ( $ cmd eq 'del' ) {
2018-10-17 07:50:11 +00:00
$ shutters - > setShuttersDev ( $ _ ) ;
RemoveInternalTimer ( $ shutters - > getInTimerFuncHash ) ;
2019-09-06 16:40:10 +00:00
CommandDeleteReading ( undef , $ _ . ' .?(ASC)_.*' ) ;
2018-10-14 16:19:23 +00:00
CommandDeleteAttr ( undef , $ _ . ' ASC' ) ;
delFromDevAttrList ( $ _ , $ attrib ) ;
2019-05-03 11:36:39 +00:00
### associatedWith wird wieder entfernt
my $ associatedString =
ReadingsVal ( $ _ , 'associatedWith' , 'none' ) ;
my % hash ;
% hash = map { ( $ _ = > 1 ) }
grep { " $name " !~ m/ $_ / }
split ( ',' , "$associatedString,$name" ) ;
if ( keys % hash > 1 ) {
readingsSingleUpdate ( $ defs { $ _ } ,
'associatedWith' , join ( ',' , sort keys % hash ) , 0 ) ;
}
else { CommandDeleteReading ( undef , $ _ . ' associatedWith' ) ; }
###################################
2018-08-16 08:37:09 +00:00
}
2018-08-15 08:27:53 +00:00
}
}
}
2018-08-29 12:58:10 +00:00
## Fügt dem NOTIFYDEV Hash weitere Devices hinzu
2018-08-27 09:08:08 +00:00
sub AddNotifyDev ($@) {
2019-03-04 07:40:58 +00:00
### Beispielaufruf: AddNotifyDev( $hash, $3, $1, $2 ) if ( $3 ne 'none' );
2018-10-14 16:19:23 +00:00
my ( $ hash , $ dev , $ shuttersDev , $ shuttersAttr ) = @ _ ;
2019-04-09 10:13:46 +00:00
$ dev = ( split ( ':' , $ dev ) ) [ 0 ] ;
my ( $ key , $ value ) = split ( ':' , ( split ( ' ' , $ dev ) ) [ 0 ] , 2 )
; ## Wir versuchen die Device Attribute anders zu setzen. device=DEVICE reading=READING
2019-03-06 14:53:48 +00:00
$ dev = $ key ;
2019-03-07 16:58:30 +00:00
2018-10-14 16:19:23 +00:00
my $ name = $ hash - > { NAME } ;
2019-03-07 16:58:30 +00:00
2018-10-14 16:19:23 +00:00
my $ notifyDev = $ hash - > { NOTIFYDEV } ;
2019-03-06 14:53:48 +00:00
$ notifyDev = '' if ( ! $ notifyDev ) ;
2018-08-16 08:37:09 +00:00
2019-03-06 14:53:48 +00:00
my % hash ;
2018-10-14 16:19:23 +00:00
% hash = map { ( $ _ = > 1 ) }
2019-05-03 11:36:39 +00:00
split ( ',' , "$notifyDev,$dev" ) ;
2018-08-29 12:58:10 +00:00
2019-05-03 11:36:39 +00:00
$ hash - > { NOTIFYDEV } = join ( ',' , sort keys % hash ) ;
2018-10-14 16:19:23 +00:00
my @ devs = split ( ',' , $ dev ) ;
foreach ( @ devs ) {
$ hash - > { monitoredDevs } { $ _ } { $ shuttersDev } = $ shuttersAttr ;
2018-09-30 19:05:30 +00:00
}
2018-10-14 16:19:23 +00:00
readingsSingleUpdate ( $ hash , '.monitoredDevs' ,
eval { encode_json ( $ hash - > { monitoredDevs } ) } , 0 ) ;
2018-08-16 08:37:09 +00:00
}
2018-08-29 12:58:10 +00:00
## entfernt aus dem NOTIFYDEV Hash Devices welche als Wert in Attributen steckten
2018-09-30 19:05:30 +00:00
sub DeleteNotifyDev ($@) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ shuttersDev , $ shuttersAttr ) = @ _ ;
my $ name = $ hash - > { NAME } ;
2018-08-16 08:37:09 +00:00
2018-10-14 16:19:23 +00:00
my $ notifyDevs =
ExtractNotifyDevFromEvent ( $ hash , $ shuttersDev , $ shuttersAttr ) ;
2018-08-27 09:08:08 +00:00
2018-10-14 16:19:23 +00:00
foreach my $ notifyDev ( keys ( % { $ notifyDevs } ) ) {
Log3 ( $ name , 4 ,
"AutoShuttersControl ($name) - DeleteNotifyDev - NotifyDev: "
. $ _ ) ;
2018-09-30 19:05:30 +00:00
delete $ hash - > { monitoredDevs } { $ notifyDev } { $ shuttersDev } ;
2018-08-27 09:08:08 +00:00
2018-10-14 16:19:23 +00:00
if ( ! keys % { $ hash - > { monitoredDevs } { $ notifyDev } } ) {
2018-09-30 19:05:30 +00:00
delete $ hash - > { monitoredDevs } { $ notifyDev } ;
2018-10-14 16:19:23 +00:00
my $ notifyDevString = $ hash - > { NOTIFYDEV } ;
2019-05-03 11:36:39 +00:00
$ notifyDevString = '' if ( ! $ notifyDevString ) ;
2018-09-30 19:05:30 +00:00
my % hash ;
2018-10-14 16:19:23 +00:00
% hash = map { ( $ _ = > 1 ) }
grep { " $notifyDev " !~ m/ $_ / }
2019-05-03 11:36:39 +00:00
split ( ',' , "$notifyDevString,$notifyDev" ) ;
2018-09-30 19:05:30 +00:00
2019-05-03 11:36:39 +00:00
$ hash - > { NOTIFYDEV } = join ( ',' , sort keys % hash ) ;
2018-09-30 19:05:30 +00:00
}
2018-09-01 06:14:42 +00:00
}
2018-10-14 16:19:23 +00:00
readingsSingleUpdate ( $ hash , '.monitoredDevs' ,
eval { encode_json ( $ hash - > { monitoredDevs } ) } , 0 ) ;
2018-08-27 09:08:08 +00:00
}
2018-08-29 12:58:10 +00:00
## Sub zum steuern der Rolläden bei einem Fenster Event
2018-11-12 11:56:18 +00:00
sub EventProcessingWindowRec ($@) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ shuttersDev , $ events ) = @ _ ;
my $ name = $ hash - > { NAME } ;
2018-08-29 12:58:10 +00:00
2019-11-08 08:31:41 +00:00
my $ reading = $ shutters - > getWinDevReading ;
2019-11-07 12:48:56 +00:00
if ( $ events =~
2019-11-08 08:31:41 +00:00
m #.*$reading:.*?([Oo]pen(?>ed)?|[Cc]losed?|tilt(?>ed)?|true|false)#
2019-05-24 09:36:06 +00:00
and IsAfterShuttersManualBlocking ( $ shuttersDev ) )
2019-01-27 13:19:51 +00:00
{
2019-05-24 09:49:40 +00:00
my $ match = $ 1 ;
2019-05-24 09:22:58 +00:00
ASC_Debug ( 'EventProcessingWindowRec: '
2019-05-24 09:36:06 +00:00
. $ shutters - > getShuttersDev
. ' - RECEIVED EVENT: '
. $ events
. ' - IDENTIFIED EVENT: '
. $ 1
. ' - STORED EVENT: '
. $ match ) ;
2019-05-24 09:22:58 +00:00
2018-10-10 08:43:42 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2019-02-08 07:13:45 +00:00
my $ homemode = $ shutters - > getRoommatesStatus ;
$ homemode = $ ascDev - > getResidentsStatus if ( $ homemode eq 'none' ) ;
2018-11-21 20:56:29 +00:00
#### Hardware Lock der Rollläden
2018-11-28 12:11:32 +00:00
$ shutters - > setHardLockOut ( 'off' )
2019-11-07 18:28:01 +00:00
if ( $ match =~ /[Cc]lose|true/
2019-06-13 13:06:30 +00:00
and $ shutters - > getShuttersPlace eq 'terrace' ) ;
2018-11-28 12:11:32 +00:00
$ shutters - > setHardLockOut ( 'on' )
2019-11-07 18:28:01 +00:00
if ( $ match =~ /[Oo]pen|false/
2019-04-09 10:13:46 +00:00
and $ shutters - > getShuttersPlace eq 'terrace' ) ;
2018-11-28 12:11:32 +00:00
2019-04-30 07:53:45 +00:00
ASC_Debug ( 'EventProcessingWindowRec: '
2019-04-30 07:56:19 +00:00
. $ shutters - > getShuttersDev
. ' - HOMEMODE: '
. $ homemode
2019-05-27 11:45:38 +00:00
. ' QueryShuttersPosWinRecTilted:'
2019-06-04 04:37:38 +00:00
. $ shutters - > getQueryShuttersPos ( $ shutters - > getVentilatePos )
2019-04-30 07:56:19 +00:00
. ' QueryShuttersPosWinRecComfort: '
2019-06-04 04:37:38 +00:00
. $ shutters - > getQueryShuttersPos ( $ shutters - > getComfortOpenPos )
) ;
2018-10-14 16:19:23 +00:00
2019-04-09 10:13:46 +00:00
if (
2019-11-07 12:48:56 +00:00
$ match =~ /[Cc]lose|true/
2019-04-20 19:53:05 +00:00
and IsAfterShuttersTimeBlocking ( $ shuttersDev )
2019-04-09 10:13:46 +00:00
and ( $ shutters - > getStatus == $ shutters - > getVentilatePos
or $ shutters - > getStatus == $ shutters - > getComfortOpenPos
or $ shutters - > getStatus == $ shutters - > getOpenPos )
2019-10-24 08:41:38 +00:00
and ( $ shutters - > getVentilateOpen eq 'on'
or $ ascDev - > getAutoShuttersControlComfort eq 'on' )
2019-04-09 10:13:46 +00:00
)
2019-01-28 17:20:19 +00:00
{
2019-05-01 08:11:53 +00:00
ASC_Debug ( 'EventProcessingWindowRec: '
2019-05-01 09:45:46 +00:00
. $ shutters - > getShuttersDev
. ' Event Closed' ) ;
2019-03-12 22:02:02 +00:00
if (
2019-06-27 08:48:06 +00:00
$ shutters - > getIsDay
2019-04-30 07:56:19 +00:00
and ( ( $ homemode ne 'asleep' and $ homemode ne 'gotosleep' )
2019-03-12 22:02:02 +00:00
or $ homemode eq 'none' )
2019-04-30 07:53:45 +00:00
and $ shutters - > getModeUp ne 'absent'
and $ shutters - > getModeUp ne 'off'
2019-04-09 10:13:46 +00:00
)
2019-03-12 22:02:02 +00:00
{
2019-11-05 12:22:03 +00:00
if ( $ shutters - > getIfInShading
2019-05-01 09:45:46 +00:00
and $ shutters - > getShadingPos != $ shutters - > getStatus )
2019-05-01 08:11:53 +00:00
{
$ shutters - > setLastDrive ( 'shading in' ) ;
2019-09-17 14:52:19 +00:00
$ shutters - > setNoDelay ( 1 ) ;
2019-05-01 09:45:46 +00:00
$ shutters - > setDriveCmd ( $ shutters - > getShadingPos ) ;
2019-05-01 08:11:53 +00:00
}
2019-07-29 10:55:38 +00:00
elsif ( $ shutters - > getStatus != $ shutters - > getOpenPos
or $ shutters - > getStatus != $ shutters - > getLastManPos )
{
2019-11-05 09:49:36 +00:00
if ( $ shutters - > getPrivacyDownStatus == 2 ) {
$ shutters - > setLastDrive (
'window closed at privacy night close' ) ;
$ shutters - > setNoDelay ( 1 ) ;
$ shutters - > setDriveCmd ( $ shutters - > getPrivacyDownPos ) ;
}
2019-11-05 12:22:03 +00:00
# elsif ( $shutters->getPrivacyUpStatus == 2 ) {
# $shutters->setLastDrive(
# 'window closed at privacy day open');
# $shutters->setNoDelay(1);
# $shutters->setDriveCmd( $shutters->getPrivacyUpPos );
# }
2019-11-01 10:18:53 +00:00
else {
$ shutters - > setLastDrive ( 'window closed at day' ) ;
$ shutters - > setNoDelay ( 1 ) ;
$ shutters - > setDriveCmd (
(
$ shutters - > getVentilatePosAfterDayClosed eq
'open'
? $ shutters - > getOpenPos
: $ shutters - > getLastManPos
)
) ;
}
2019-05-01 08:11:53 +00:00
}
2019-03-12 22:02:02 +00:00
}
2019-04-30 07:56:19 +00:00
elsif (
2019-11-04 13:39:55 +00:00
$ shutters - > getModeDown ne 'absent'
and $ shutters - > getModeDown ne 'off'
2019-06-27 08:48:06 +00:00
and ( not $ shutters - > getIsDay
2019-04-30 07:56:19 +00:00
or $ homemode eq 'asleep'
or $ homemode eq 'gotosleep' )
2019-10-07 05:02:33 +00:00
and $ ascDev - > getAutoShuttersControlEvening eq 'on'
2019-04-30 07:53:45 +00:00
)
2019-03-12 22:02:02 +00:00
{
2019-11-05 12:22:03 +00:00
if ( $ shutters - > getPrivacyUpStatus == 2 ) {
2019-11-01 10:18:53 +00:00
$ shutters - > setLastDrive (
2019-11-05 12:22:03 +00:00
'window closed at privacy day open' ) ;
2019-11-01 10:18:53 +00:00
$ shutters - > setNoDelay ( 1 ) ;
$ shutters - > setDriveCmd ( $ shutters - > getPrivacyDownPos ) ;
}
else {
$ shutters - > setLastDrive ( 'window closed at night' ) ;
$ shutters - > setNoDelay ( 1 ) ;
$ shutters - > setDriveCmd (
(
$ shutters - > getSleepPos > 0
? $ shutters - > getSleepPos
: $ shutters - > getClosedPos
)
) ;
}
2018-11-17 17:23:10 +00:00
}
2018-10-14 16:19:23 +00:00
}
elsif (
(
2019-05-24 09:36:06 +00:00
$ match =~ /tilt/
2019-11-07 12:48:56 +00:00
or ( $ match =~ /[Oo]pen|false/
2019-04-09 10:13:46 +00:00
and $ shutters - > getSubTyp eq 'twostate' )
2018-10-14 16:19:23 +00:00
)
and $ shutters - > getVentilateOpen eq 'on'
2019-06-04 04:37:38 +00:00
and $ shutters - > getQueryShuttersPos ( $ shutters - > getVentilatePos )
2018-10-14 16:19:23 +00:00
)
{
2018-11-18 15:49:09 +00:00
$ shutters - > setLastDrive ( 'ventilate - window open' ) ;
2019-09-17 14:52:19 +00:00
$ shutters - > setNoDelay ( 1 ) ;
2019-08-26 11:11:35 +00:00
$ shutters - > setDriveCmd (
(
(
$ shutters - > getShuttersPlace eq 'terrace'
and $ shutters - > getSubTyp eq 'twostate'
) ? $ shutters - > getOpenPos : $ shutters - > getVentilatePos
)
) ;
2018-10-14 16:19:23 +00:00
}
2019-11-07 12:48:56 +00:00
elsif ( $ match =~ /[Oo]pen|false/
2019-03-12 22:02:02 +00:00
and $ shutters - > getSubTyp eq 'threestate' )
2018-10-14 16:19:23 +00:00
{
2019-03-12 22:02:02 +00:00
my $ posValue ;
my $ setLastDrive ;
2019-04-09 10:13:46 +00:00
if ( $ ascDev - > getAutoShuttersControlComfort eq 'on'
2019-06-04 04:37:38 +00:00
and
$ shutters - > getQueryShuttersPos ( $ shutters - > getComfortOpenPos ) )
2019-03-12 22:02:02 +00:00
{
2019-04-09 10:13:46 +00:00
$ posValue = $ shutters - > getComfortOpenPos ;
2019-03-12 22:02:02 +00:00
$ setLastDrive = 'comfort - window open' ;
}
2019-06-04 04:37:38 +00:00
elsif ( $ shutters - > getQueryShuttersPos ( $ shutters - > getVentilatePos )
2019-04-09 10:13:46 +00:00
and $ shutters - > getVentilateOpen eq 'on' )
2019-03-12 22:02:02 +00:00
{
2019-04-09 10:13:46 +00:00
$ posValue = $ shutters - > getVentilatePos ;
2019-03-12 22:02:02 +00:00
$ setLastDrive = 'ventilate - window open' ;
}
2019-04-09 10:13:46 +00:00
2019-04-02 17:28:54 +00:00
if ( defined ( $ posValue ) and $ posValue ) {
$ shutters - > setLastDrive ( $ setLastDrive ) ;
2019-09-17 14:52:19 +00:00
$ shutters - > setNoDelay ( 1 ) ;
2019-08-26 11:11:35 +00:00
$ shutters - > setDriveCmd (
2019-09-17 14:24:48 +00:00
# (
# $shutters->getShuttersPlace eq 'terrace'
# ? $shutters->getOpenPos
$ posValue
# )
2019-08-26 11:11:35 +00:00
) ;
2019-04-02 17:28:54 +00:00
}
2018-08-29 12:58:10 +00:00
}
2018-08-27 09:08:08 +00:00
}
}
2018-08-29 12:58:10 +00:00
## Sub zum steuern der Rolladen bei einem Bewohner/Roommate Event
2018-11-12 11:56:18 +00:00
sub EventProcessingRoommate ($@) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ shuttersDev , $ events ) = @ _ ;
my $ name = $ hash - > { NAME } ;
2018-11-07 07:22:11 +00:00
2018-10-10 08:43:42 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2018-10-14 16:19:23 +00:00
my $ reading = $ shutters - > getRoommatesReading ;
2018-10-30 07:18:09 +00:00
if ( $ events =~ m #$reading:\s(absent|gotosleep|asleep|awoken|home)# ) {
2018-10-14 16:19:23 +00:00
Log3 ( $ name , 4 ,
2018-11-19 08:06:50 +00:00
"AutoShuttersControl ($name) - EventProcessingRoommate: "
. $ shutters - > getRoommatesReading ) ;
2018-10-14 16:19:23 +00:00
Log3 ( $ name , 4 ,
2018-11-19 08:06:50 +00:00
"AutoShuttersControl ($name) - EventProcessingRoommate: $shuttersDev und Events $events"
2018-10-14 16:19:23 +00:00
) ;
2019-04-09 10:13:46 +00:00
my $ getModeUp = $ shutters - > getModeUp ;
my $ getModeDown = $ shutters - > getModeDown ;
2019-08-22 04:19:31 +00:00
my $ getRoommatesStatus = $ shutters - > getRoommatesStatus ;
2019-03-04 09:40:31 +00:00
my $ getRoommatesLastStatus = $ shutters - > getRoommatesLastStatus ;
2019-06-26 11:49:10 +00:00
my $ posValue ;
2018-10-30 18:10:50 +00:00
2018-10-30 07:18:09 +00:00
if (
2018-10-30 18:10:50 +00:00
( $ 1 eq 'home' or $ 1 eq 'awoken' )
2019-08-19 08:50:34 +00:00
and ( $ getRoommatesStatus eq 'home'
or $ getRoommatesStatus eq 'awoken' )
2019-09-24 09:30:50 +00:00
and ( $ ascDev - > getAutoShuttersControlMorning eq 'on'
or $ shutters - > getUp eq 'roommate' )
2019-04-09 10:13:46 +00:00
and IsAfterShuttersManualBlocking ( $ shuttersDev )
)
2018-10-30 07:18:09 +00:00
{
2018-11-15 14:01:34 +00:00
Log3 ( $ name , 4 ,
2018-11-19 08:06:50 +00:00
"AutoShuttersControl ($name) - EventProcessingRoommate_1: $shuttersDev und Events $events"
) ;
2018-10-30 18:10:50 +00:00
if (
2019-04-09 10:13:46 +00:00
(
2019-03-04 09:10:53 +00:00
$ getRoommatesLastStatus eq 'asleep'
or $ getRoommatesLastStatus eq 'awoken'
2019-04-09 10:13:46 +00:00
)
2019-09-17 14:24:48 +00:00
and ( $ shutters - > getIsDay
or $ shutters - > getUp eq 'roommate' )
2019-10-24 08:41:38 +00:00
and ( IsAfterShuttersTimeBlocking ( $ shuttersDev )
2019-09-23 06:11:00 +00:00
or $ shutters - > getUp eq 'roommate' )
2019-04-09 10:13:46 +00:00
)
2018-10-30 07:18:09 +00:00
{
2018-11-15 14:01:34 +00:00
Log3 ( $ name , 4 ,
2018-11-19 08:06:50 +00:00
"AutoShuttersControl ($name) - EventProcessingRoommate_2: $shuttersDev und Events $events"
) ;
2019-06-26 11:49:10 +00:00
if ( $ shutters - > getIfInShading
2019-07-01 17:32:49 +00:00
and not $ shutters - > getShadingManualDriveStatus
2019-06-26 11:49:10 +00:00
and $ shutters - > getStatus != $ shutters - > getShadingPos )
{
$ shutters - > setLastDrive ( 'shading in' ) ;
$ posValue = $ shutters - > getShadingPos ;
}
else {
$ shutters - > setLastDrive ( 'roommate awoken' ) ;
$ posValue = $ shutters - > getOpenPos ;
}
ShuttersCommandSet ( $ hash , $ shuttersDev , $ posValue ) ;
2018-10-30 07:18:09 +00:00
}
2019-06-28 19:55:28 +00:00
elsif (
2019-04-09 10:13:46 +00:00
(
2019-03-04 09:10:53 +00:00
$ getRoommatesLastStatus eq 'absent'
or $ getRoommatesLastStatus eq 'gone'
2019-04-09 10:13:46 +00:00
)
2019-08-19 08:50:34 +00:00
and $ getRoommatesStatus eq 'home'
2019-04-09 10:13:46 +00:00
)
2018-10-30 07:18:09 +00:00
{
2019-09-20 18:35:48 +00:00
if (
not $ shutters - > getIsDay
2019-04-20 19:53:05 +00:00
and IsAfterShuttersTimeBlocking ( $ shuttersDev )
2019-03-04 09:10:53 +00:00
and ( $ getModeDown eq 'home'
or $ getModeDown eq 'always' )
2019-04-09 10:13:46 +00:00
)
2018-12-07 11:57:45 +00:00
{
2019-09-20 12:55:52 +00:00
$ shutters - > setLastDrive ( 'roommate come home' ) ;
2018-11-19 08:06:50 +00:00
2018-10-30 14:26:04 +00:00
if ( CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 0
or $ shutters - > getVentilateOpen eq 'off' )
{
2019-09-17 14:52:19 +00:00
$ posValue = (
$ shutters - > getSleepPos > 0
2019-09-17 14:24:48 +00:00
? $ shutters - > getSleepPos
2019-09-17 14:52:19 +00:00
: $ shutters - > getClosedPos
) ;
2018-10-30 14:26:04 +00:00
}
2018-11-15 14:01:34 +00:00
else {
2019-06-26 11:49:10 +00:00
$ posValue = $ shutters - > getVentilatePos ;
2018-11-19 08:06:50 +00:00
$ shutters - > setLastDrive (
$ shutters - > getLastDrive . ' - ventilate mode' ) ;
2018-11-15 14:01:34 +00:00
}
2018-11-19 08:06:50 +00:00
2019-06-26 11:49:10 +00:00
ShuttersCommandSet ( $ hash , $ shuttersDev , $ posValue ) ;
2018-10-30 14:26:04 +00:00
}
2019-04-09 10:13:46 +00:00
elsif (
2019-09-17 14:24:48 +00:00
(
$ shutters - > getIsDay
or $ shutters - > getUp eq 'roommate'
)
2019-04-20 19:53:05 +00:00
and IsAfterShuttersTimeBlocking ( $ shuttersDev )
2019-03-04 09:10:53 +00:00
and ( $ getModeUp eq 'home'
2019-04-09 10:13:46 +00:00
or $ getModeUp eq 'always' )
)
2018-10-30 18:10:50 +00:00
{
2019-06-26 11:49:10 +00:00
if ( $ shutters - > getIfInShading
2019-07-01 17:32:49 +00:00
and not $ shutters - > getShadingManualDriveStatus
2019-08-12 17:51:03 +00:00
and $ shutters - > getStatus == $ shutters - > getOpenPos
2019-08-14 08:06:05 +00:00
and $ shutters - > getShadingMode eq 'home' )
2019-06-26 11:49:10 +00:00
{
$ shutters - > setLastDrive ( 'shading in' ) ;
$ posValue = $ shutters - > getShadingPos ;
2019-06-28 19:55:28 +00:00
ShuttersCommandSet ( $ hash , $ shuttersDev , $ posValue ) ;
2019-06-26 11:49:10 +00:00
}
elsif (
2019-08-14 08:06:05 +00:00
(
not $ shutters - > getIfInShading
or $ shutters - > getShadingMode eq 'absent'
)
2019-06-26 11:49:10 +00:00
and ( $ shutters - > getStatus == $ shutters - > getClosedPos
or $ shutters - > getStatus ==
$ shutters - > getShadingPos )
)
{
$ shutters - > setLastDrive (
(
$ shutters - > getStatus == $ shutters - > getClosedPos
2019-09-20 12:55:52 +00:00
? 'roommate come home'
2019-06-26 11:49:10 +00:00
: 'shading out'
)
) ;
$ posValue = $ shutters - > getOpenPos ;
2019-06-28 19:55:28 +00:00
ShuttersCommandSet ( $ hash , $ shuttersDev , $ posValue ) ;
}
2018-10-30 07:18:09 +00:00
}
}
2018-10-30 18:10:50 +00:00
}
2019-10-24 08:41:38 +00:00
elsif (
( $ 1 eq 'gotosleep' or $ 1 eq 'asleep' )
2019-09-24 09:30:50 +00:00
and ( $ ascDev - > getAutoShuttersControlEvening eq 'on'
or $ shutters - > getDown eq 'roommate' )
2019-10-24 08:41:38 +00:00
and ( IsAfterShuttersManualBlocking ( $ shuttersDev )
2019-09-23 06:11:00 +00:00
or $ shutters - > getDown eq 'roommate' )
)
2018-10-14 16:19:23 +00:00
{
2018-11-15 14:01:34 +00:00
$ shutters - > setLastDrive ( 'roommate asleep' ) ;
2018-11-19 08:06:50 +00:00
2018-10-14 16:19:23 +00:00
if ( CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 0
or $ shutters - > getVentilateOpen eq 'off' )
{
2019-09-17 14:52:19 +00:00
$ posValue = (
$ shutters - > getSleepPos > 0
2019-09-17 14:24:48 +00:00
? $ shutters - > getSleepPos
2019-09-17 14:52:19 +00:00
: $ shutters - > getClosedPos
) ;
2018-09-13 06:11:10 +00:00
}
2018-11-15 14:01:34 +00:00
else {
2019-06-26 11:49:10 +00:00
$ posValue = $ shutters - > getVentilatePos ;
2018-11-19 08:06:50 +00:00
$ shutters - > setLastDrive (
$ shutters - > getLastDrive . ' - ventilate mode' ) ;
2018-11-15 14:01:34 +00:00
}
2018-10-14 16:19:23 +00:00
2019-06-26 11:49:10 +00:00
ShuttersCommandSet ( $ hash , $ shuttersDev , $ posValue ) ;
2018-09-10 06:27:11 +00:00
}
2019-06-26 11:49:10 +00:00
elsif (
2019-08-22 04:19:31 +00:00
$ 1 eq 'absent'
2019-09-17 14:24:48 +00:00
and ( not $ shutters - > getIsDay
2019-09-16 06:49:58 +00:00
or $ shutters - > getDown eq 'roommate'
2019-06-26 11:49:10 +00:00
or $ shutters - > getShadingMode eq 'absent' )
)
2018-10-30 07:18:09 +00:00
{
2019-09-17 14:24:48 +00:00
if (
(
$ shutters - > getIsDay
or $ shutters - > getUp eq 'roommate'
)
2019-06-26 11:49:10 +00:00
and $ shutters - > getIfInShading
and
not $ shutters - > getQueryShuttersPos ( $ shutters - > getShadingPos )
2019-09-17 14:24:48 +00:00
and $ shutters - > getShadingMode eq 'absent'
)
2019-06-26 11:49:10 +00:00
{
$ posValue = $ shutters - > getShadingPos ;
$ shutters - > setLastDrive ( 'shading in' ) ;
2019-08-05 09:33:21 +00:00
ShuttersCommandSet ( $ hash , $ shuttersDev , $ posValue ) ;
2019-06-26 11:49:10 +00:00
}
2019-09-17 14:24:48 +00:00
elsif (
(
not $ shutters - > getIsDay
or $ shutters - > getDown eq 'roommate'
)
2019-08-19 08:50:34 +00:00
and $ getModeDown eq 'absent'
2019-09-17 14:24:48 +00:00
and $ getRoommatesStatus eq 'absent'
)
2019-08-19 08:50:34 +00:00
{
2019-06-26 11:49:10 +00:00
$ posValue = $ shutters - > getClosedPos ;
$ shutters - > setLastDrive ( 'roommate absent' ) ;
2019-08-05 09:33:21 +00:00
ShuttersCommandSet ( $ hash , $ shuttersDev , $ posValue ) ;
2019-06-26 11:49:10 +00:00
}
2018-10-30 07:18:09 +00:00
}
2018-08-28 17:49:01 +00:00
}
2018-08-27 09:08:08 +00:00
}
2018-11-12 11:56:18 +00:00
sub EventProcessingResidents ($@) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ device , $ events ) = @ _ ;
2018-10-09 16:05:55 +00:00
2019-04-09 10:13:46 +00:00
my $ name = $ device ;
my $ reading = $ ascDev - > getResidentsReading ;
2019-03-04 09:10:53 +00:00
my $ getResidentsLastStatus = $ ascDev - > getResidentsLastStatus ;
2018-10-14 16:19:23 +00:00
2019-05-24 09:31:07 +00:00
if ( $ events =~ m #$reading:\s((?:pet_[a-z]+)|(?:absent))# ) {
2018-10-14 16:19:23 +00:00
foreach my $ shuttersDev ( @ { $ hash - > { helper } { shuttersList } } ) {
2018-10-10 08:43:42 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2019-04-09 10:13:46 +00:00
my $ getModeUp = $ shutters - > getModeUp ;
2019-03-04 09:40:31 +00:00
my $ getModeDown = $ shutters - > getModeDown ;
2018-11-28 12:07:52 +00:00
$ shutters - > setHardLockOut ( 'off' ) ;
2018-10-30 18:10:50 +00:00
if (
2019-06-25 07:18:50 +00:00
$ ascDev - > getSelfDefense eq 'on'
2019-09-16 15:15:02 +00:00
and $ shutters - > getSelfDefenseMode ne 'off'
2019-06-25 13:13:35 +00:00
or ( $ getModeDown eq 'absent'
2019-06-26 04:53:32 +00:00
or $ getModeDown eq 'always' )
2018-10-30 18:10:50 +00:00
)
2018-10-30 14:26:04 +00:00
{
2019-06-25 11:19:22 +00:00
if (
2019-09-17 14:24:48 +00:00
$ ascDev - > getSelfDefense eq 'on'
and (
$ shutters - > getSelfDefenseMode eq 'absent'
or ( CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 2
and $ shutters - > getSelfDefenseMode eq 'gone'
and $ shutters - > getShuttersPlace eq 'terrace'
and $ shutters - > getSelfDefenseMode ne 'off' )
2019-09-16 11:57:08 +00:00
)
2019-09-17 14:24:48 +00:00
)
2018-11-03 18:01:29 +00:00
{
2019-06-25 07:18:50 +00:00
$ shutters - > setLastDrive ( 'selfDefense active' ) ;
2019-09-17 14:24:48 +00:00
$ shutters - > setSelfDefenseAbsent ( 0 , 1 )
; # der erste Wert ist ob der timer schon läuft, der zweite ist ob self defense aktiv ist durch die Bedingungen
2019-06-25 13:13:35 +00:00
$ shutters - > setDriveCmd ( $ shutters - > getClosedPos ) ;
}
elsif (
2019-06-26 04:53:32 +00:00
(
$ getModeDown eq 'absent'
or $ getModeDown eq 'always'
2019-06-25 13:13:35 +00:00
)
2019-06-27 08:48:06 +00:00
and not $ shutters - > getIsDay
2019-06-25 13:13:35 +00:00
and IsAfterShuttersTimeBlocking ( $ shuttersDev )
2019-06-27 13:14:56 +00:00
and $ shutters - > getRoommatesStatus eq 'none'
2019-06-25 13:13:35 +00:00
)
{
$ shutters - > setLastDrive ( 'residents absent' ) ;
$ shutters - > setDriveCmd ( $ shutters - > getClosedPos ) ;
2018-11-03 18:01:29 +00:00
}
2018-10-30 14:26:04 +00:00
}
2018-10-14 16:19:23 +00:00
}
}
2018-10-22 06:05:19 +00:00
elsif ( $ events =~ m #$reading:\s(gone)#
2019-09-16 08:12:28 +00:00
and $ ascDev - > getSelfDefense eq 'on' )
2018-10-22 06:05:19 +00:00
{
foreach my $ shuttersDev ( @ { $ hash - > { helper } { shuttersList } } ) {
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2018-11-28 12:07:52 +00:00
$ shutters - > setHardLockOut ( 'off' ) ;
2019-09-16 15:15:02 +00:00
if ( $ shutters - > getSelfDefenseMode ne 'off' ) {
2019-09-16 08:12:28 +00:00
$ shutters - > setLastDrive ( 'selfDefense' ) ;
2018-10-30 14:26:04 +00:00
$ shutters - > setDriveCmd ( $ shutters - > getClosedPos ) ;
}
2018-10-22 06:05:19 +00:00
}
}
2018-10-27 11:36:11 +00:00
elsif (
2019-05-24 09:31:07 +00:00
$ events =~ m #$reading:\s((?:[a-z]+_)?home)#
2019-03-04 09:10:53 +00:00
and ( $ getResidentsLastStatus eq 'absent'
or $ getResidentsLastStatus eq 'gone'
or $ getResidentsLastStatus eq 'asleep'
or $ getResidentsLastStatus eq 'awoken' )
2018-10-27 11:36:11 +00:00
)
2018-10-14 16:19:23 +00:00
{
foreach my $ shuttersDev ( @ { $ hash - > { helper } { shuttersList } } ) {
2018-10-22 06:05:19 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2019-04-09 10:13:46 +00:00
my $ getModeUp = $ shutters - > getModeUp ;
2019-03-04 09:40:31 +00:00
my $ getModeDown = $ shutters - > getModeDown ;
2018-10-30 18:10:50 +00:00
2018-11-03 18:01:29 +00:00
if (
$ shutters - > getStatus != $ shutters - > getClosedPos
2019-06-27 08:48:06 +00:00
and not $ shutters - > getIsDay
2018-11-03 18:01:29 +00:00
and $ shutters - > getRoommatesStatus eq 'none'
2019-03-04 09:10:53 +00:00
and ( $ getModeDown eq 'home'
or $ getModeDown eq 'always' )
and ( $ getResidentsLastStatus ne 'asleep'
or $ getResidentsLastStatus ne 'awoken' )
2019-04-20 19:53:05 +00:00
and IsAfterShuttersTimeBlocking ( $ shuttersDev )
2018-11-03 18:01:29 +00:00
)
2018-10-30 07:18:09 +00:00
{
2019-09-22 06:13:34 +00:00
$ shutters - > setLastDrive ( 'residents come home' ) ;
2018-10-30 07:18:09 +00:00
$ shutters - > setDriveCmd ( $ shutters - > getClosedPos ) ;
}
2019-05-20 07:47:28 +00:00
elsif (
2019-06-25 11:19:22 +00:00
(
$ shutters - > getShadingMode eq 'home'
or $ shutters - > getShadingMode eq 'always'
)
2019-06-27 08:48:06 +00:00
and $ shutters - > getIsDay
2019-05-20 07:47:28 +00:00
and $ shutters - > getIfInShading
2019-06-27 13:14:56 +00:00
and $ shutters - > getRoommatesStatus eq 'none'
2019-05-20 07:47:28 +00:00
and $ shutters - > getStatus != $ shutters - > getShadingPos
2019-07-01 17:32:49 +00:00
and not $ shutters - > getShadingManualDriveStatus
2019-05-20 07:47:28 +00:00
and not ( CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 2
and $ shutters - > getShuttersPlace eq 'terrace' )
)
{
$ shutters - > setLastDrive ( 'shading in' ) ;
$ shutters - > setDriveCmd ( $ shutters - > getShadingPos ) ;
}
2019-05-28 13:44:44 +00:00
elsif (
$ shutters - > getShadingMode eq 'absent'
2019-06-27 08:48:06 +00:00
and $ shutters - > getIsDay
2019-05-28 13:44:44 +00:00
and $ shutters - > getIfInShading
and $ shutters - > getStatus == $ shutters - > getShadingPos
2019-06-27 13:14:56 +00:00
and $ shutters - > getRoommatesStatus eq 'none'
2019-07-01 17:32:49 +00:00
and not $ shutters - > getShadingManualDriveStatus
2019-05-28 13:44:44 +00:00
and not ( CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 2
and $ shutters - > getShuttersPlace eq 'terrace' )
)
{
$ shutters - > setLastDrive ( 'shading out' ) ;
$ shutters - > setDriveCmd ( $ shutters - > getLastPos ) ;
}
2019-06-25 11:19:22 +00:00
elsif (
2019-09-16 08:12:28 +00:00
$ ascDev - > getSelfDefense eq 'on'
2019-09-16 15:15:02 +00:00
and $ shutters - > getSelfDefenseMode ne 'off'
2019-03-31 15:17:56 +00:00
and not $ shutters - > getIfInShading
2019-06-25 11:19:22 +00:00
and ( $ getResidentsLastStatus eq 'gone'
or $ getResidentsLastStatus eq 'absent' )
2019-06-25 13:13:35 +00:00
and $ shutters - > getLastDrive eq 'selfDefense active'
2018-10-30 07:18:09 +00:00
)
2018-10-30 18:10:50 +00:00
{
2019-06-25 11:19:22 +00:00
RemoveInternalTimer ( $ shutters - > getSelfDefenseAbsentTimerhash )
if ( $ getResidentsLastStatus eq 'absent'
and $ ascDev - > getSelfDefense eq 'on'
2019-09-16 15:15:02 +00:00
and $ shutters - > getSelfDefenseMode ne 'off'
2019-06-25 11:19:22 +00:00
and not $ shutters - > getSelfDefenseAbsent
and $ shutters - > getSelfDefenseAbsentTimerrun ) ;
2019-06-25 10:24:25 +00:00
2019-08-22 04:19:31 +00:00
if ( $ shutters - > getStatus == $ shutters - > getClosedPos
and $ shutters - > getIsDay )
2019-08-20 06:52:46 +00:00
{
2019-06-25 10:24:25 +00:00
$ shutters - > setHardLockOut ( 'on' )
2019-06-25 11:19:22 +00:00
if (
CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 2
2019-06-25 10:24:25 +00:00
and $ shutters - > getShuttersPlace eq 'terrace'
2019-06-25 11:19:22 +00:00
and ( $ getModeUp eq 'absent'
or $ getModeUp eq 'off' )
) ;
2019-06-25 10:24:25 +00:00
$ shutters - > setLastDrive ( 'selfDefense inactive' ) ;
$ shutters - > setDriveCmd (
2019-06-25 11:19:22 +00:00
(
2019-06-26 04:53:32 +00:00
$ shutters - > getPrivacyDownStatus == 2
2019-06-25 11:19:22 +00:00
? $ shutters - > getPrivacyDownPos
: $ shutters - > getOpenPos
)
) ;
2019-06-25 10:24:25 +00:00
}
2018-10-30 07:18:09 +00:00
}
2018-11-03 18:01:29 +00:00
elsif (
$ shutters - > getStatus == $ shutters - > getClosedPos
2019-06-27 08:48:06 +00:00
and $ shutters - > getIsDay
2018-11-03 18:01:29 +00:00
and $ shutters - > getRoommatesStatus eq 'none'
2019-03-04 09:10:53 +00:00
and ( $ getModeUp eq 'home'
or $ getModeUp eq 'always' )
2019-04-20 19:53:05 +00:00
and IsAfterShuttersTimeBlocking ( $ shuttersDev )
2019-03-31 15:17:56 +00:00
and not $ shutters - > getIfInShading
2018-11-03 18:01:29 +00:00
)
{
2019-03-04 09:10:53 +00:00
if ( $ getResidentsLastStatus eq 'asleep'
or $ getResidentsLastStatus eq 'awoken' )
2018-11-03 18:01:29 +00:00
{
$ shutters - > setLastDrive ( 'residents awoken' ) ;
}
else { $ shutters - > setLastDrive ( 'residents home' ) ; }
$ shutters - > setDriveCmd ( $ shutters - > getOpenPos ) ;
}
2018-10-27 11:36:11 +00:00
}
}
}
2018-11-12 11:56:18 +00:00
sub EventProcessingRain ($@) {
2019-10-24 11:53:14 +00:00
#### Ist noch nicht fertig, es fehlt noch das verzögerte Prüfen auf erhalten bleiben des getriggerten Wertes.
2018-10-27 11:36:11 +00:00
my ( $ hash , $ device , $ events ) = @ _ ;
2018-11-08 07:32:47 +00:00
my $ name = $ device ;
2018-10-27 11:36:11 +00:00
my $ reading = $ ascDev - > getRainSensorReading ;
2019-04-29 09:04:27 +00:00
if ( $ events =~ m #$reading:\s(\d+(\.\d+)?|rain|dry)# ) {
2019-03-06 14:53:48 +00:00
my $ val ;
2019-03-07 09:52:23 +00:00
my $ triggerMax = $ ascDev - > getRainTriggerMax ;
2019-03-06 14:53:48 +00:00
my $ triggerMin = $ ascDev - > getRainTriggerMin ;
2019-04-09 10:13:46 +00:00
my $ closedPos = $ ascDev - > getRainSensorShuttersClosedPos ;
2019-03-07 09:52:23 +00:00
if ( $ 1 eq 'rain' ) { $ val = $ triggerMax + 1 }
elsif ( $ 1 eq 'dry' ) { $ val = $ triggerMin }
2018-10-28 17:12:40 +00:00
else { $ val = $ 1 }
2019-10-24 08:41:38 +00:00
RainProtection ( $ hash , $ val , $ triggerMax , $ closedPos ) ;
2019-10-04 04:14:54 +00:00
}
}
2018-10-28 17:12:40 +00:00
2019-10-24 08:41:38 +00:00
sub RainProtection (@) {
my ( $ hash , $ val , $ triggerMax , $ closedPos ) = @ _ ;
2019-04-29 11:22:37 +00:00
2019-10-04 04:14:54 +00:00
foreach my $ shuttersDev ( @ { $ hash - > { helper } { shuttersList } } ) {
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2019-04-29 11:22:37 +00:00
2019-10-04 04:14:54 +00:00
next
2019-10-24 08:41:38 +00:00
if ( $ shutters - > getRainProtection eq 'off' ) ;
2019-10-04 04:14:54 +00:00
if ( $ val > $ triggerMax
and $ shutters - > getStatus != $ closedPos
and IsAfterShuttersManualBlocking ( $ shuttersDev )
and $ shutters - > getRainProtectionStatus eq 'unprotected' )
{
$ shutters - > setLastDrive ( 'rain protected' ) ;
$ shutters - > setDriveCmd ( $ closedPos ) ;
$ shutters - > setRainProtectionStatus ( 'protected' ) ;
}
elsif ( ( $ val == 0 or $ val < $ triggerMax )
and $ shutters - > getStatus == $ closedPos
and IsAfterShuttersManualBlocking ( $ shuttersDev )
and $ shutters - > getRainProtectionStatus eq 'protected' )
{
$ shutters - > setLastDrive ( 'rain un-protected' ) ;
$ shutters - > setDriveCmd (
(
$ shutters - > getIsDay ? $ shutters - > getLastPos
: (
2019-10-24 08:41:38 +00:00
$ shutters - > getPrivacyDownStatus == 2
2019-10-04 04:14:54 +00:00
? $ shutters - > getPrivacyDownPos
: $ shutters - > getClosedPos
2019-06-26 04:53:32 +00:00
)
2019-10-04 04:14:54 +00:00
)
) ;
$ shutters - > setRainProtectionStatus ( 'unprotected' ) ;
2018-10-09 16:05:55 +00:00
}
}
}
2019-02-26 11:04:10 +00:00
sub EventProcessingWind ($@) {
2019-02-28 08:05:23 +00:00
my ( $ hash , $ shuttersDev , $ events ) = @ _ ;
my $ name = $ hash - > { NAME } ;
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2019-02-26 11:04:10 +00:00
2019-03-04 07:40:58 +00:00
my $ reading = $ ascDev - > getWindSensorReading ;
2019-04-29 09:04:27 +00:00
if ( $ events =~ m #$reading:\s(\d+(\.\d+)?)# ) {
2019-02-26 11:04:10 +00:00
foreach my $ shuttersDev ( @ { $ hash - > { helper } { shuttersList } } ) {
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2019-04-25 15:15:56 +00:00
ASC_Debug ( 'EventProcessingWind: '
2019-04-25 19:34:46 +00:00
. $ shutters - > getShuttersDev
. ' - WindProtection1: '
2019-04-28 20:13:27 +00:00
. $ shutters - > getWindProtectionStatus
2019-04-25 19:34:46 +00:00
. ' WindMax1: '
. $ shutters - > getWindMax
. ' WindMin1: '
. $ shutters - > getWindMin
. ' Bekommender Wert1: '
. $ 1 ) ;
2019-04-25 15:15:56 +00:00
2019-04-09 10:13:46 +00:00
next
2019-04-28 20:13:27 +00:00
if (
(
CheckIfShuttersWindowRecOpen ( $ shuttersDev ) != 0
and $ shutters - > getShuttersPlace eq 'terrace'
)
or $ shutters - > getWindProtection eq 'off'
) ;
2019-02-28 08:05:23 +00:00
2019-04-09 10:13:46 +00:00
if ( $ 1 > $ shutters - > getWindMax
2019-06-03 05:44:35 +00:00
and $ shutters - > getWindProtectionStatus eq 'unprotected' )
2019-02-26 11:04:10 +00:00
{
2019-06-03 05:44:35 +00:00
$ shutters - > setLastDrive ( 'wind protected' ) ;
2019-04-09 10:13:46 +00:00
$ shutters - > setDriveCmd ( $ shutters - > getWindPos ) ;
2019-06-03 05:44:35 +00:00
$ shutters - > setWindProtectionStatus ( 'protected' ) ;
2019-02-26 11:04:10 +00:00
}
2019-02-28 08:05:23 +00:00
elsif ( $ 1 < $ shutters - > getWindMin
2019-06-03 05:44:35 +00:00
and $ shutters - > getWindProtectionStatus eq 'protected' )
2019-02-26 11:04:10 +00:00
{
2019-06-03 05:44:35 +00:00
$ shutters - > setLastDrive ( 'wind un-protected' ) ;
2019-06-26 04:53:32 +00:00
$ shutters - > setDriveCmd (
(
2019-06-27 08:48:06 +00:00
$ shutters - > getIsDay ? $ shutters - > getLastPos
2019-06-26 09:20:09 +00:00
: (
$ shutters - > getPrivacyDownStatus == 2
2019-06-26 04:53:32 +00:00
? $ shutters - > getPrivacyDownPos
2019-06-26 09:20:09 +00:00
: $ shutters - > getClosedPos
)
2019-06-26 04:53:32 +00:00
)
) ;
2019-06-03 05:44:35 +00:00
$ shutters - > setWindProtectionStatus ( 'unprotected' ) ;
2019-02-26 11:04:10 +00:00
}
2019-04-25 19:34:46 +00:00
2019-04-25 15:15:56 +00:00
ASC_Debug ( 'EventProcessingWind: '
2019-04-25 19:34:46 +00:00
. $ shutters - > getShuttersDev
. ' - WindProtection2: '
2019-04-28 20:13:27 +00:00
. $ shutters - > getWindProtectionStatus
2019-04-25 19:34:46 +00:00
. ' WindMax2: '
. $ shutters - > getWindMax
. ' WindMin2: '
. $ shutters - > getWindMin
. ' Bekommender Wert2: '
. $ 1 ) ;
2019-02-26 11:04:10 +00:00
}
}
}
2019-02-28 08:05:23 +00:00
##########
2019-02-26 11:04:10 +00:00
2018-11-12 11:56:18 +00:00
sub EventProcessingBrightness ($@) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ shuttersDev , $ events ) = @ _ ;
my $ name = $ hash - > { NAME } ;
2018-10-12 04:32:01 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'EventProcessingBrightness: '
. $ shutters - > getShuttersDev
. ' - Event von einem Helligkeitssensor erkannt. Verarbeitung läuft. Sollten keine weitere Meldungen aus der Funktion kommen, so befindet sich die aktuelle Zeit nicht innerhalb der Verarbeitungszeit für Sunset oder Sunrise'
) ;
2018-10-12 04:32:01 +00:00
2018-11-19 08:06:50 +00:00
return EventProcessingShadingBrightness ( $ hash , $ shuttersDev , $ events )
unless (
2019-04-09 10:13:46 +00:00
(
2019-08-08 11:33:19 +00:00
$ shutters - > getDown eq 'brightness'
or $ shutters - > getUp eq 'brightness'
2019-04-09 10:13:46 +00:00
)
or (
(
2019-04-28 05:32:48 +00:00
(
(
int ( gettimeofday ( ) / 86400 ) != int (
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpEarly ) / 86400
)
2019-05-17 12:20:57 +00:00
and (
not IsWe ( )
or ( IsWe ( )
and $ ascDev - > getSunriseTimeWeHoliday eq 'off' )
)
)
2019-04-28 05:32:48 +00:00
or (
int ( gettimeofday ( ) / 86400 ) != int (
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpWeHoliday ) / 86400
)
and IsWe ( )
and $ ascDev - > getSunriseTimeWeHoliday eq 'on'
)
2019-04-09 10:13:46 +00:00
)
and int ( gettimeofday ( ) / 86400 ) == int (
computeAlignTime ( '24:00' , $ shutters - > getTimeUpLate ) /
86400
)
)
or (
int ( gettimeofday ( ) / 86400 ) != int (
computeAlignTime ( '24:00' , $ shutters - > getTimeDownEarly ) /
86400
)
and int ( gettimeofday ( ) / 86400 ) == int (
computeAlignTime ( '24:00' , $ shutters - > getTimeDownLate ) /
86400
)
)
)
2018-11-19 08:06:50 +00:00
) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'EventProcessingBrightness: '
. $ shutters - > getShuttersDev
. ' - Die aktuelle Zeit befindet sich innerhalb der Sunset/Sunrise Brightness Verarbeitungszeit. Also zwischen Time Early und Time Late'
) ;
2018-10-14 16:19:23 +00:00
2018-12-07 11:57:45 +00:00
my $ reading = $ shutters - > getBrightnessReading ;
2019-04-29 09:04:27 +00:00
if ( $ events =~ m #$reading:\s(\d+(\.\d+)?)# ) {
2018-10-16 08:30:10 +00:00
my $ brightnessMinVal ;
if ( $ shutters - > getBrightnessMinVal > - 1 ) {
$ brightnessMinVal = $ shutters - > getBrightnessMinVal ;
}
else {
$ brightnessMinVal = $ ascDev - > getBrightnessMinVal ;
}
2019-01-02 08:38:00 +00:00
2018-12-21 18:40:16 +00:00
my $ brightnessMaxVal ;
if ( $ shutters - > getBrightnessMaxVal > - 1 ) {
$ brightnessMaxVal = $ shutters - > getBrightnessMaxVal ;
}
else {
$ brightnessMaxVal = $ ascDev - > getBrightnessMaxVal ;
}
2019-04-09 10:13:46 +00:00
2019-10-30 11:43:57 +00:00
my $ brightnessPrivacyUpVal = $ shutters - > getPrivacyUpBrightnessVal ;
2019-11-05 15:40:54 +00:00
my $ brightnessPrivacyDownVal = $ shutters - > getPrivacyDownBrightnessVal ;
2019-10-24 11:53:14 +00:00
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'EventProcessingBrightness: '
. $ shutters - > getShuttersDev
. ' - Es wird geprüft ob Sunset oder Sunrise gefahren werden soll und der aktuelle übergebene Brightness-Wert: '
. $ 1
. ' Größer dem eingestellten Sunrise-Wert: '
. $ brightnessMaxVal
. ' oder kleiner dem eingestellten Sunset-Wert: '
. $ brightnessMinVal
2019-05-07 03:58:59 +00:00
. ' ist. Werte für weitere Parameter - getUp ist: '
. $ shutters - > getUp
. ' getDown ist: '
. $ shutters - > getDown
. ' getSunrise ist: '
. $ shutters - > getSunrise
. ' getSunset ist: '
2019-05-07 09:34:53 +00:00
. $ shutters - > getSunset ) ;
2018-10-16 08:30:10 +00:00
2018-10-14 16:19:23 +00:00
if (
2019-05-07 03:58:59 +00:00
(
(
(
int ( gettimeofday ( ) / 86400 ) != int (
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpEarly ) / 86400
)
2019-05-17 12:20:57 +00:00
and (
not IsWe ( )
or ( IsWe ( )
and $ ascDev - > getSunriseTimeWeHoliday eq 'off' )
)
)
2019-05-07 03:58:59 +00:00
or (
int ( gettimeofday ( ) / 86400 ) != int (
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpWeHoliday ) / 86400
)
and IsWe ( )
and $ ascDev - > getSunriseTimeWeHoliday eq 'on'
)
)
and int ( gettimeofday ( ) / 86400 ) == int (
computeAlignTime ( '24:00' , $ shutters - > getTimeUpLate ) /
86400
)
2018-10-14 16:19:23 +00:00
)
2019-11-09 08:08:29 +00:00
and (
$ 1 > $ brightnessMaxVal
or ( $ 1 > $ brightnessPrivacyUpVal
and $ shutters - > getPrivacyUpStatus == 1 )
)
2018-11-03 18:01:29 +00:00
and $ shutters - > getUp eq 'brightness'
2019-03-27 10:22:06 +00:00
and not $ shutters - > getSunrise
2019-09-24 08:17:50 +00:00
and $ ascDev - > getAutoShuttersControlMorning eq 'on'
2018-10-14 16:19:23 +00:00
)
{
Log3 ( $ name , 4 ,
2018-11-12 11:56:18 +00:00
"AutoShuttersControl ($shuttersDev) - EventProcessingBrightness: Steuerung für Morgens"
2018-10-14 16:19:23 +00:00
) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'EventProcessingBrightness: '
. $ shutters - > getShuttersDev
. ' - Verarbeitungszeit für Sunrise wurd erkannt. Prüfe Status der Roommates'
) ;
2018-10-28 17:12:40 +00:00
my $ homemode = $ shutters - > getRoommatesStatus ;
$ homemode = $ ascDev - > getResidentsStatus
if ( $ homemode eq 'none' ) ;
2019-02-19 11:00:25 +00:00
if (
$ shutters - > getModeUp eq $ homemode
or ( $ shutters - > getModeUp eq 'absent'
and $ homemode eq 'gone' )
or $ shutters - > getModeUp eq 'always'
)
2018-10-28 17:12:40 +00:00
{
2019-10-25 08:44:08 +00:00
## Setzt den PrivacyDown Modus für die Sichtschutzfahrt auf den Status 0
## 1 bedeutet das PrivacyDown Timer aktiviert wurde, 2 beudet das er im privacyDown ist
## also das Rollo in privacyDown Position steht und VOR der endgültigen Nachfahrt
2019-11-09 08:08:29 +00:00
# $shutters->setPrivacyUpStatus(0)
# if ( not defined( $shutters->getPrivacyUpStatus ) );
2019-10-25 08:44:08 +00:00
2018-11-14 02:41:38 +00:00
if (
2018-10-28 17:12:40 +00:00
(
$ shutters - > getRoommatesStatus eq 'home'
or $ shutters - > getRoommatesStatus eq 'awoken'
or $ shutters - > getRoommatesStatus eq 'absent'
or $ shutters - > getRoommatesStatus eq 'gone'
or $ shutters - > getRoommatesStatus eq 'none'
)
and $ ascDev - > getSelfDefense eq 'off'
or ( $ ascDev - > getSelfDefense eq 'on'
and CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 0 )
2019-07-20 13:48:53 +00:00
or ( $ ascDev - > getSelfDefense eq 'on'
and CheckIfShuttersWindowRecOpen ( $ shuttersDev ) != 0
and $ ascDev - > getResidentsStatus eq 'home' )
2018-11-19 08:06:50 +00:00
)
{
2019-10-25 08:44:35 +00:00
2019-10-29 08:33:55 +00:00
if ( $ brightnessPrivacyUpVal > 0
and $ 1 < $ brightnessMaxVal
2019-11-09 08:08:29 +00:00
and $ 1 > $ brightnessPrivacyUpVal )
# and $shutters->getPrivacyUpStatus == 1 )
2019-10-25 08:44:08 +00:00
{
2019-10-30 11:43:57 +00:00
$ shutters - > setPrivacyUpStatus ( 2 ) ;
2019-10-31 06:17:04 +00:00
$ shutters - > setLastDrive ( 'brightness privacy day open' ) ;
2019-10-25 08:44:08 +00:00
ShuttersCommandSet ( $ hash , $ shuttersDev ,
$ shutters - > getPrivacyUpPos )
2019-10-28 15:34:13 +00:00
unless (
not $ shutters - > getQueryShuttersPos (
2019-10-25 08:44:08 +00:00
$ shutters - > getPrivacyUpPos
)
2019-10-25 08:44:35 +00:00
) ;
2019-04-09 10:13:46 +00:00
2019-10-25 08:44:08 +00:00
ASC_Debug ( 'EventProcessingBrightness: '
2019-10-25 08:44:35 +00:00
. $ shutters - > getShuttersDev
. ' - Verarbeitung für Sunset Privacy Down. Roommatestatus korrekt zum fahren. Fahrbefehl wird an die Funktion FnShuttersCommandSet gesendet. Grund des fahrens: '
. $ shutters - > getLastDrive ) ;
2019-10-30 11:43:57 +00:00
CreateSunRiseSetShuttersTimer ( $ hash , $ shuttersDev ) ;
2019-10-25 08:44:08 +00:00
}
else {
$ shutters - > setLastDrive (
'maximum brightness threshold exceeded' ) ;
$ shutters - > setSunrise ( 1 ) ;
$ shutters - > setSunset ( 0 ) ;
2019-10-30 11:43:57 +00:00
$ shutters - > setPrivacyUpStatus ( 0 )
if ( $ shutters - > getPrivacyUpStatus == 2 ) ;
2019-10-25 08:44:08 +00:00
ShuttersCommandSet ( $ hash , $ shuttersDev ,
$ shutters - > getOpenPos ) ;
ASC_Debug ( 'EventProcessingBrightness: '
2019-10-25 08:44:35 +00:00
. $ shutters - > getShuttersDev
. ' - Verarbeitung für Sunrise. Roommatestatus korrekt zum fahren. Fahrbefehl wird an die Funktion FnShuttersCommandSet gesendet. Grund des fahrens: '
. $ shutters - > getLastDrive ) ;
2019-10-25 08:44:08 +00:00
}
2018-11-19 08:06:50 +00:00
}
else {
EventProcessingShadingBrightness ( $ hash , $ shuttersDev ,
$ events ) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'EventProcessingBrightness: '
. $ shutters - > getShuttersDev
. ' - Verarbeitung für Sunrise. Roommatestatus nicht zum hochfahren oder Fenster sind offen. Fahrbebehl bleibt aus!!! Es wird an die Event verarbeitende Beschattungsfunktion weiter gereicht'
) ;
2018-11-19 08:06:50 +00:00
}
2018-10-28 17:12:40 +00:00
}
2018-10-14 16:19:23 +00:00
}
elsif (
int ( gettimeofday ( ) / 86400 ) != int (
computeAlignTime ( '24:00' , $ shutters - > getTimeDownEarly ) / 86400
)
and int ( gettimeofday ( ) / 86400 ) == int (
computeAlignTime ( '24:00' , $ shutters - > getTimeDownLate ) / 86400
)
2019-11-09 08:08:29 +00:00
and (
$ 1 < $ brightnessMinVal
or ( $ 1 < $ brightnessPrivacyDownVal
and $ shutters - > getPrivacyDownStatus == 1 )
)
2018-11-03 18:01:29 +00:00
and $ shutters - > getDown eq 'brightness'
2019-03-27 10:22:06 +00:00
and not $ shutters - > getSunset
2019-01-02 08:38:00 +00:00
and IsAfterShuttersManualBlocking ( $ shuttersDev )
2019-09-24 08:17:50 +00:00
and $ ascDev - > getAutoShuttersControlEvening eq 'on'
2018-10-14 16:19:23 +00:00
)
{
Log3 ( $ name , 4 ,
2018-11-12 11:56:18 +00:00
"AutoShuttersControl ($shuttersDev) - EventProcessingBrightness: Steuerung für Abends"
2018-10-14 16:19:23 +00:00
) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'EventProcessingBrightness: '
. $ shutters - > getShuttersDev
. ' - Verarbeitungszeit für Sunset wurd erkannt. Prüfe Status der Roommates'
) ;
2018-10-28 17:12:40 +00:00
my $ homemode = $ shutters - > getRoommatesStatus ;
$ homemode = $ ascDev - > getResidentsStatus
if ( $ homemode eq 'none' ) ;
2019-02-19 11:00:25 +00:00
if (
2019-02-20 19:28:50 +00:00
$ shutters - > getModeDown eq $ homemode
or ( $ shutters - > getModeDown eq 'absent'
2019-02-19 11:00:25 +00:00
and $ homemode eq 'gone' )
2019-02-20 19:28:50 +00:00
or $ shutters - > getModeDown eq 'always'
2019-02-19 11:00:25 +00:00
)
2018-11-19 08:06:50 +00:00
{
2019-08-10 11:05:33 +00:00
my $ posValue ;
2019-10-29 16:27:31 +00:00
my $ lastDrive ;
2019-10-24 11:53:14 +00:00
## Setzt den PrivacyDown Modus für die Sichtschutzfahrt auf den Status 0
## 1 bedeutet das PrivacyDown Timer aktiviert wurde, 2 beudet das er im privacyDown ist
## also das Rollo in privacyDown Position steht und VOR der endgültigen Nachfahrt
2019-11-09 08:08:29 +00:00
# $shutters->setPrivacyDownStatus(0)
# if ( not defined( $shutters->getPrivacyDownStatus ) );
2019-10-24 11:53:14 +00:00
2019-10-29 08:33:55 +00:00
if ( $ brightnessPrivacyDownVal > 0
and $ 1 > $ brightnessMinVal
2019-10-25 08:44:08 +00:00
and $ 1 < $ brightnessPrivacyDownVal )
2019-10-24 11:53:14 +00:00
{
2019-10-31 06:17:04 +00:00
$ lastDrive = 'brightness privacy night close' ;
2019-10-30 11:43:57 +00:00
$ posValue = (
(
not $ shutters - > getQueryShuttersPos (
$ shutters - > getPrivacyDownPos
)
) ? $ shutters - > getPrivacyDownPos : $ shutters - > getStatus
) ;
2019-11-05 09:49:36 +00:00
$ shutters - > setPrivacyDownStatus ( 2 ) ;
2019-10-24 11:53:14 +00:00
ASC_Debug ( 'EventProcessingBrightness: '
. $ shutters - > getShuttersDev
. ' - Verarbeitung für Sunset Privacy Down. Roommatestatus korrekt zum fahren. Fahrbefehl wird an die Funktion FnShuttersCommandSet gesendet. Grund des fahrens: '
. $ shutters - > getLastDrive ) ;
}
elsif ( CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 2
2019-08-10 11:05:33 +00:00
and $ shutters - > getSubTyp eq 'threestate'
and $ ascDev - > getAutoShuttersControlComfort eq 'on' )
{
2019-10-30 11:43:57 +00:00
$ posValue = $ shutters - > getComfortOpenPos ;
2019-10-29 16:27:31 +00:00
$ lastDrive = 'minimum brightness threshold fell below' ;
2019-08-10 11:05:33 +00:00
}
elsif ( CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 0
or $ shutters - > getVentilateOpen eq 'off' )
{
2019-09-17 14:52:19 +00:00
$ posValue = (
$ shutters - > getSleepPos > 0
2019-09-17 14:24:48 +00:00
? $ shutters - > getSleepPos
2019-09-17 14:52:19 +00:00
: $ shutters - > getClosedPos
) ;
2019-10-29 16:27:31 +00:00
$ lastDrive = 'minimum brightness threshold fell below' ;
2019-08-10 11:05:33 +00:00
}
2019-10-30 11:43:57 +00:00
else {
$ posValue = $ shutters - > getVentilatePos ;
$ lastDrive = 'minimum brightness threshold fell below' ;
}
2019-08-10 11:05:33 +00:00
2019-10-30 11:43:57 +00:00
$ shutters - > setLastDrive ( $ lastDrive ) ;
2019-03-27 10:22:06 +00:00
$ shutters - > setSunrise ( 0 ) ;
2019-10-29 16:27:31 +00:00
$ shutters - > setSunset ( 1 )
2019-11-05 09:49:36 +00:00
unless ( $ shutters - > getPrivacyDownStatus == 2
2019-10-30 11:43:57 +00:00
or $ posValue == $ shutters - > getStatus ) ;
2019-10-31 06:17:04 +00:00
$ shutters - > setPrivacyDownStatus ( 0 )
if ( $ shutters - > getPrivacyDownStatus == 2 ) ;
2019-01-02 08:38:00 +00:00
ShuttersCommandSet ( $ hash , $ shuttersDev , $ posValue ) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'EventProcessingBrightness: '
. $ shutters - > getShuttersDev
. ' - Verarbeitung für Sunset. Roommatestatus korrekt zum fahren. Fahrbefehl wird an die Funktion FnShuttersCommandSet gesendet. Zielposition: '
. $ posValue
. ' Grund des fahrens: '
. $ shutters - > getLastDrive ) ;
2018-11-19 08:06:50 +00:00
}
else {
2019-11-04 21:14:56 +00:00
EventProcessingShadingBrightness ( $ hash , $ shuttersDev , $ events )
2019-11-05 09:49:36 +00:00
unless ( $ shutters - > getPrivacyDownStatus == 2 ) ;
2019-11-04 21:14:56 +00:00
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'EventProcessingBrightness: '
. $ shutters - > getShuttersDev
. ' - Verarbeitung für Sunset. Roommatestatus nicht zum runter fahren. Fahrbebehl bleibt aus!!! Es wird an die Event verarbeitende Beschattungsfunktion weiter gereicht'
) ;
2018-11-19 08:06:50 +00:00
}
2018-10-14 16:19:23 +00:00
}
2019-04-09 10:13:46 +00:00
else {
2019-11-04 21:14:56 +00:00
EventProcessingShadingBrightness ( $ hash , $ shuttersDev , $ events )
2019-11-05 09:49:36 +00:00
unless ( $ shutters - > getPrivacyDownStatus == 2 ) ;
2019-11-04 21:14:56 +00:00
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'EventProcessingBrightness: '
. $ shutters - > getShuttersDev
. ' - Brightness Event kam nicht innerhalb der Verarbeitungszeit für Sunset oder Sunris oder aber für beide wurden die entsprechendne Verarbeitungsschwellen nicht erreicht.'
) ;
2019-04-02 17:28:54 +00:00
}
2018-11-19 08:06:50 +00:00
}
2019-04-09 10:13:46 +00:00
else {
ASC_Debug ( 'EventProcessingBrightness: '
. $ shutters - > getShuttersDev
. ' - Leider konnte kein Korrekter Brightnesswert aus dem Event erkannt werden. Entweder passt das Reading oder der tatsächliche nummerishce Wert des Events nicht'
) ;
}
2018-11-14 02:41:38 +00:00
}
sub EventProcessingShadingBrightness ($@) {
my ( $ hash , $ shuttersDev , $ events ) = @ _ ;
my $ name = $ hash - > { NAME } ;
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2018-12-07 11:57:45 +00:00
my $ reading = $ shutters - > getBrightnessReading ;
2019-06-24 10:57:52 +00:00
my $ outTemp = $ ascDev - > getOutTemp ;
2019-04-09 10:13:46 +00:00
2019-03-24 15:41:48 +00:00
Log3 ( $ name , 4 ,
2019-04-09 10:13:46 +00:00
"AutoShuttersControl ($shuttersDev) - EventProcessingShadingBrightness"
) ;
ASC_Debug ( 'EventProcessingShadingBrightness: '
. $ shutters - > getShuttersDev
. ' - Es wird nun geprüft ob der übergebene Event ein nummerischer Wert vom Brightnessreading ist.'
) ;
2018-11-19 08:06:50 +00:00
2019-04-29 09:04:27 +00:00
if ( $ events =~ m #$reading:\s(\d+(\.\d+)?)# ) {
2019-04-09 10:13:46 +00:00
Log3 (
$ name , 4 ,
" AutoShuttersControl ( $ shuttersDev ) - EventProcessingShadingBrightness
Brightness: " . $ 1
) ;
2019-09-02 12:34:42 +00:00
## Brightness Wert in ein Array schieben zur Berechnung eines Average Wertes
$ shutters - > setPushBrightnessInArray ( $ 1 ) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'EventProcessingShadingBrightness: '
. $ shutters - > getShuttersDev
2019-09-02 12:34:42 +00:00
. ' - Nummerischer Brightness-Wert wurde erkannt. Der Brightness Average Wert ist: '
. $ shutters - > getBrightnessAverage
2019-05-04 16:46:09 +00:00
. ' RainProtection: '
. $ shutters - > getRainProtectionStatus
. ' WindProtection: '
. $ shutters - > getWindProtectionStatus ) ;
2019-04-09 10:13:46 +00:00
2019-06-23 06:30:12 +00:00
if ( $ ascDev - > getAutoShuttersControlShading eq 'on'
2019-06-03 05:44:35 +00:00
and $ shutters - > getRainProtectionStatus eq 'unprotected'
2019-06-21 07:19:49 +00:00
and $ shutters - > getWindProtectionStatus eq 'unprotected' )
2019-04-02 17:28:54 +00:00
{
2019-06-25 11:19:22 +00:00
$ outTemp = $ shutters - > getOutTemp
if ( $ shutters - > getOutTemp != - 100 ) ;
2019-04-02 17:28:54 +00:00
ShadingProcessing (
2019-04-09 10:13:46 +00:00
$ hash ,
$ shuttersDev ,
$ ascDev - > getAzimuth ,
$ ascDev - > getElevation ,
2019-06-24 10:57:52 +00:00
$ outTemp ,
2019-09-19 11:46:42 +00:00
$ shutters - > getShadingAzimuthLeft ,
$ shutters - > getShadingAzimuthRight
2019-04-02 17:28:54 +00:00
) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'EventProcessingShadingBrightness: '
. $ shutters - > getShuttersDev
. ' - Alle Bedingungen zur weiteren Beschattungsverarbeitung sind erfüllt. Es wird nun die eigentliche Beschattungsfunktion aufgerufen'
) ;
2019-04-02 17:28:54 +00:00
}
2018-10-12 04:32:01 +00:00
}
}
2018-09-04 09:42:47 +00:00
2018-11-14 02:41:38 +00:00
sub EventProcessingTwilightDevice ($@) {
my ( $ hash , $ device , $ events ) = @ _ ;
2018-12-07 12:04:41 +00:00
# Twilight
# azimuth = azimuth = Sonnenwinkel
# elevation = elevation = Sonnenhöhe
#
# Astro
# SunAz = azimuth = Sonnenwinkel
2019-02-27 20:30:35 +00:00
# SunAlt = elevation = Sonnenhöhe
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'EventProcessingTwilightDevice: '
. $ shutters - > getShuttersDev
. ' - Event vom Astro oder Twilight Device wurde erkannt. Event wird verarbeitet'
) ;
2018-11-14 14:26:32 +00:00
2019-02-27 20:30:35 +00:00
if ( $ events =~ m #(azimuth|elevation|SunAz|SunAlt):\s(\d+.\d+)# ) {
2018-11-19 08:06:50 +00:00
my $ name = $ device ;
2018-12-05 14:39:11 +00:00
my ( $ azimuth , $ elevation ) ;
2019-06-24 10:57:52 +00:00
my $ outTemp = $ ascDev - > getOutTemp ;
2018-11-19 08:06:50 +00:00
2019-04-09 10:13:46 +00:00
$ azimuth = $ 2 if ( $ 1 eq 'azimuth' or $ 1 eq 'SunAz' ) ;
2019-02-27 20:30:35 +00:00
$ elevation = $ 2 if ( $ 1 eq 'elevation' or $ 1 eq 'SunAlt' ) ;
2018-11-14 14:26:32 +00:00
2018-11-19 08:06:50 +00:00
$ azimuth = $ ascDev - > getAzimuth
if ( not defined ( $ azimuth ) and not $ azimuth ) ;
$ elevation = $ ascDev - > getElevation
if ( not defined ( $ elevation ) and not $ elevation ) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'EventProcessingTwilightDevice: '
. $ name
2019-08-22 17:42:46 +00:00
. ' - Passendes Event wurde erkannt. Verarbeitung über alle Rollos beginnt'
2019-04-09 10:13:46 +00:00
) ;
2018-11-14 14:26:32 +00:00
foreach my $ shuttersDev ( @ { $ hash - > { helper } { shuttersList } } ) {
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2018-12-07 12:04:41 +00:00
2018-12-05 14:39:11 +00:00
my $ homemode = $ shutters - > getRoommatesStatus ;
$ homemode = $ ascDev - > getResidentsStatus if ( $ homemode eq 'none' ) ;
2019-06-25 11:19:22 +00:00
$ outTemp = $ shutters - > getOutTemp
if ( $ shutters - > getOutTemp != - 100 ) ;
2018-12-07 12:04:41 +00:00
2019-05-04 16:46:09 +00:00
ASC_Debug ( 'EventProcessingTwilightDevice: '
. $ shutters - > getShuttersDev
. ' RainProtection: '
. $ shutters - > getRainProtectionStatus
. ' WindProtection: '
. $ shutters - > getWindProtectionStatus ) ;
2019-06-23 16:35:07 +00:00
if ( $ ascDev - > getAutoShuttersControlShading eq 'on'
2019-06-03 05:44:35 +00:00
and $ shutters - > getRainProtectionStatus eq 'unprotected'
2019-06-25 11:19:22 +00:00
and $ shutters - > getWindProtectionStatus eq 'unprotected' )
2019-04-02 17:28:54 +00:00
{
ShadingProcessing (
$ hash ,
$ shuttersDev ,
$ azimuth ,
$ elevation ,
2019-06-24 10:57:52 +00:00
$ outTemp ,
2019-09-19 11:46:42 +00:00
$ shutters - > getShadingAzimuthLeft ,
$ shutters - > getShadingAzimuthRight
2019-04-02 17:28:54 +00:00
) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'EventProcessingTwilightDevice: '
. $ shutters - > getShuttersDev
. ' - Alle Bedingungen zur weiteren Beschattungsverarbeitung sind erfüllt. Es wird nun die Beschattungsfunktion ausgeführt'
) ;
2019-04-02 17:28:54 +00:00
}
2018-11-14 14:26:32 +00:00
}
2018-11-14 02:41:38 +00:00
}
}
sub ShadingProcessing ($@) {
2019-09-19 11:46:42 +00:00
### angleMinus ist $shutters->getShadingAzimuthLeft
### anglePlus ist $shutters->getShadingAzimuthRight
2018-12-05 14:39:11 +00:00
### winPos ist die Fensterposition $shutters->getDirection
2019-09-02 12:34:42 +00:00
my ( $ hash , $ shuttersDev , $ azimuth , $ elevation , $ outTemp ,
2019-09-19 11:46:42 +00:00
$ azimuthLeft , $ azimuthRight )
2019-09-02 12:34:42 +00:00
= @ _ ;
2018-11-14 02:41:38 +00:00
my $ name = $ hash - > { NAME } ;
2018-12-05 14:39:11 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2019-09-02 12:34:42 +00:00
my $ brightness = $ shutters - > getBrightnessAverage ;
2019-04-09 10:13:46 +00:00
ASC_Debug (
'ShadingProcessing: '
. $ shutters - > getShuttersDev
. ' - Übergebende Werte - Azimuth:'
. $ azimuth
. ', Elevation: '
. $ elevation
. ', Brightness: '
. $ brightness
. ', OutTemp: '
. $ outTemp
2019-09-19 11:46:42 +00:00
. ', Azimut Beschattung: '
. $ azimuthLeft
. ', Azimut Endschattung: '
. $ azimuthRight
2019-04-09 10:13:46 +00:00
. ', Ist es nach der Zeitblockadezeit: '
2019-04-20 19:53:05 +00:00
. ( IsAfterShuttersTimeBlocking ( $ shuttersDev ) ? 'JA' : 'NEIN' )
2019-06-30 06:42:21 +00:00
. ', Das Rollo ist in der Beschattung und wurde manuell gefahren: '
. ( $ shutters - > getShadingManualDriveStatus ? 'JA' : 'NEIN' )
2019-04-09 10:13:46 +00:00
. ', Ist es nach der Hälfte der Beschattungswartezeit: '
. (
( int ( gettimeofday ( ) ) - $ shutters - > getShadingStatusTimestamp ) <
( $ shutters - > getShadingWaitingPeriod / 2 ) ? 'NEIN' : 'JA'
)
) ;
2019-04-02 17:28:54 +00:00
2019-01-23 18:32:48 +00:00
Log3 ( $ name , 4 ,
2018-12-07 12:04:41 +00:00
"AutoShuttersControl ($name) - Shading Processing, Rollladen: "
. $ shuttersDev
. " Azimuth: "
. $ azimuth
. " Elevation: "
. $ elevation
. " Brightness: "
. $ brightness
. " OutTemp: "
. $ outTemp ) ;
2018-12-05 14:39:11 +00:00
return
2018-12-07 12:04:41 +00:00
if ( $ azimuth == - 1
or $ elevation == - 1
or $ brightness == - 1
or $ outTemp == - 100
2019-03-31 15:17:56 +00:00
or ( int ( gettimeofday ( ) ) - $ shutters - > getShadingStatusTimestamp ) <
2018-12-07 12:04:41 +00:00
( $ shutters - > getShadingWaitingPeriod / 2 )
2019-06-23 16:25:17 +00:00
or $ shutters - > getShadingMode eq 'off' ) ;
2018-12-07 12:04:41 +00:00
2019-02-16 18:14:25 +00:00
Log3 ( $ name , 4 ,
2018-12-07 12:04:41 +00:00
"AutoShuttersControl ($name) - Shading Processing, Rollladen: "
. $ shuttersDev
. " Nach dem return" ) ;
2019-04-09 10:13:46 +00:00
my $ getShadingPos = $ shutters - > getShadingPos ;
my $ getStatus = $ shutters - > getStatus ;
2019-04-02 17:28:54 +00:00
my $ oldShadingStatus = $ shutters - > getShadingStatus ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'ShadingProcessing: '
. $ shutters - > getShuttersDev
. ' - Alle Werte für die weitere Verarbeitung sind korrekt vorhanden und es wird nun mit der Beschattungsverarbeitung begonnen'
) ;
if (
(
2019-05-20 12:23:11 +00:00
$ outTemp < $ shutters - > getShadingMinOutsideTemperature - 3
2019-09-19 11:46:42 +00:00
or $ azimuth < $ azimuthLeft
or $ azimuth > $ azimuthRight
2019-04-09 10:13:46 +00:00
)
and $ shutters - > getShadingStatus ne 'out'
)
2019-03-23 11:45:50 +00:00
{
2019-06-23 16:25:17 +00:00
$ shutters - > setShadingLastStatus ( 'in' ) ;
2019-03-31 15:17:56 +00:00
$ shutters - > setShadingStatus ( 'out' ) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'ShadingProcessing: '
. $ shutters - > getShuttersDev
. ' - Es ist Nacht oder die Aussentemperatur unterhalb der Shading Temperatur. Die Beschattung wird Zwangsbeendet'
) ;
2019-06-26 05:24:38 +00:00
Log3 ( $ name , 4 ,
"AutoShuttersControl ($name) - Shading Processing - Der Sonnenstand ist ausserhalb der Winkelangaben oder die Aussentemperatur unterhalb der Shading Temperatur "
2019-04-09 10:13:46 +00:00
) ;
2019-03-23 11:45:50 +00:00
}
2019-09-19 11:46:42 +00:00
elsif ( $ azimuth < $ azimuthLeft
or $ azimuth > $ azimuthRight
2018-12-07 12:04:41 +00:00
or $ elevation < $ shutters - > getShadingMinElevation
2019-06-10 11:41:46 +00:00
or $ elevation > $ shutters - > getShadingMaxElevation
2019-04-09 10:47:36 +00:00
or $ brightness < $ shutters - > getShadingStateChangeCloudy
or $ outTemp < $ shutters - > getShadingMinOutsideTemperature )
2018-12-05 14:39:11 +00:00
{
2019-03-31 15:17:56 +00:00
$ shutters - > setShadingStatus ( 'out reserved' )
if ( $ shutters - > getShadingStatus eq 'in'
or $ shutters - > getShadingStatus eq 'in reserved' ) ;
2018-12-06 14:24:16 +00:00
2019-06-26 10:08:02 +00:00
if (
2019-04-09 10:13:46 +00:00
(
$ shutters - > getShadingStatus eq 'out reserved'
and
( int ( gettimeofday ( ) ) - $ shutters - > getShadingStatusTimestamp )
2019-06-26 10:08:02 +00:00
) > $ shutters - > getShadingWaitingPeriod
)
{
$ shutters - > setShadingStatus ( 'out' ) ;
2019-06-30 07:18:50 +00:00
$ shutters - > setShadingLastStatus ( 'in' )
2019-06-30 16:53:28 +00:00
if ( $ shutters - > getShadingLastStatus eq 'out' ) ;
2019-06-26 10:08:02 +00:00
}
2019-06-26 09:20:09 +00:00
2019-02-16 18:14:25 +00:00
Log3 ( $ name , 4 ,
2018-12-07 12:04:41 +00:00
"AutoShuttersControl ($name) - Shading Processing, Rollladen: "
. $ shuttersDev
. " In der Out Abfrage, Shadingwert: "
2019-03-31 15:17:56 +00:00
. $ shutters - > getShadingStatus
2018-12-07 12:04:41 +00:00
. ", Zeitstempel: "
2019-03-31 15:17:56 +00:00
. $ shutters - > getShadingStatusTimestamp ) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'ShadingProcessing: '
. $ shutters - > getShuttersDev
. ' - Einer der Beschattungsbedingungen wird nicht mehr erfüllt und somit wird der Beschattungsstatus um eine Stufe reduziert. Alter Status: '
. $ oldShadingStatus
. ' Neuer Status: '
. $ shutters - > getShadingStatus ) ;
2018-12-07 12:04:41 +00:00
}
2019-09-19 11:46:42 +00:00
elsif ( $ azimuth > $ azimuthLeft
and $ azimuth < $ azimuthRight
2019-03-31 15:17:56 +00:00
and $ elevation > $ shutters - > getShadingMinElevation
2019-06-10 11:41:46 +00:00
and $ elevation < $ shutters - > getShadingMaxElevation
2019-04-09 10:47:36 +00:00
and $ brightness > $ shutters - > getShadingStateChangeSunny
and $ outTemp > $ shutters - > getShadingMinOutsideTemperature )
2018-12-05 14:39:11 +00:00
{
2019-03-31 15:17:56 +00:00
$ shutters - > setShadingStatus ( 'in reserved' )
if ( $ shutters - > getShadingStatus eq 'out'
or $ shutters - > getShadingStatus eq 'out reserved' ) ;
2018-12-07 12:04:41 +00:00
2019-06-26 10:08:02 +00:00
if ( $ shutters - > getShadingStatus eq 'in reserved'
2019-04-09 10:13:46 +00:00
and
( int ( gettimeofday ( ) ) - $ shutters - > getShadingStatusTimestamp ) >
2019-06-26 10:08:02 +00:00
( $ shutters - > getShadingWaitingPeriod / 2 ) )
{
$ shutters - > setShadingStatus ( 'in' ) ;
2019-06-30 07:18:50 +00:00
$ shutters - > setShadingLastStatus ( 'out' )
2019-06-30 16:53:28 +00:00
if ( $ shutters - > getShadingLastStatus eq 'in' ) ;
2019-06-26 10:08:02 +00:00
}
2019-02-16 18:14:25 +00:00
Log3 ( $ name , 4 ,
2018-12-07 12:04:41 +00:00
"AutoShuttersControl ($name) - Shading Processing, Rollladen: "
. $ shuttersDev
. " In der In Abfrage, Shadingwert: "
2019-03-31 15:17:56 +00:00
. $ shutters - > getShadingStatus
2018-12-07 12:04:41 +00:00
. ", Zeitstempel: "
2019-03-31 15:17:56 +00:00
. $ shutters - > getShadingStatusTimestamp ) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'ShadingProcessing: '
. $ shutters - > getShuttersDev
. ' - Alle Beschattungsbedingungen wurden erfüllt und somit wird der Beschattungsstatus um eine Stufe angehoben. Alter Status: '
. $ oldShadingStatus
. ' Neuer Status: '
. $ shutters - > getShadingStatus ) ;
2018-12-05 14:39:11 +00:00
}
2019-05-24 20:24:11 +00:00
ShadingProcessingDriveCommand ( $ hash , $ shuttersDev )
2019-06-13 15:25:17 +00:00
if (
2019-06-30 16:53:28 +00:00
$ shutters - > getIsDay
2019-06-29 17:39:44 +00:00
and IsAfterShuttersTimeBlocking ( $ shuttersDev )
and not $ shutters - > getShadingManualDriveStatus
2019-06-27 08:48:06 +00:00
and (
(
$ shutters - > getShadingStatus eq 'out'
and $ shutters - > getShadingLastStatus eq 'in'
)
or ( $ shutters - > getShadingStatus eq 'in'
and $ shutters - > getShadingLastStatus eq 'out' )
2019-06-13 15:25:17 +00:00
)
) ;
2019-05-24 17:58:26 +00:00
}
2018-12-07 12:04:41 +00:00
2019-05-24 17:58:26 +00:00
sub ShadingProcessingDriveCommand ($$) {
2019-05-24 20:24:11 +00:00
my ( $ hash , $ shuttersDev ) = @ _ ;
2019-03-04 09:10:53 +00:00
2019-05-24 17:58:26 +00:00
my $ name = $ hash - > { NAME } ;
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2018-12-07 12:04:41 +00:00
2019-05-24 20:24:11 +00:00
my $ getShadingPos = $ shutters - > getShadingPos ;
my $ getStatus = $ shutters - > getStatus ;
2019-04-09 10:13:46 +00:00
2019-06-21 07:19:49 +00:00
my $ homemode = $ shutters - > getRoommatesStatus ;
$ homemode = $ ascDev - > getResidentsStatus if ( $ homemode eq 'none' ) ;
2019-05-24 17:58:26 +00:00
2019-06-21 07:19:49 +00:00
if ( $ shutters - > getShadingMode eq 'always'
or $ shutters - > getShadingMode eq $ homemode )
2019-05-24 17:58:26 +00:00
{
2019-06-21 07:19:49 +00:00
$ shutters - > setShadingStatus ( $ shutters - > getShadingStatus )
if (
( int ( gettimeofday ( ) ) - $ shutters - > getShadingStatusTimestamp ) >
( $ shutters - > getShadingWaitingPeriod / 2 ) ) ;
if ( $ shutters - > getShadingStatus eq 'in'
and $ getShadingPos != $ getStatus )
2018-12-06 14:24:16 +00:00
{
2019-06-21 07:19:49 +00:00
if (
2019-06-27 13:14:56 +00:00
not $ shutters - > getQueryShuttersPos ( $ getShadingPos )
2019-06-21 07:19:49 +00:00
and not ( CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 2
and $ shutters - > getShuttersPlace eq 'terrace' )
)
{
$ shutters - > setLastDrive ( 'shading in' ) ;
ShuttersCommandSet ( $ hash , $ shuttersDev , $ getShadingPos ) ;
ASC_Debug ( 'ShadingProcessing: '
. $ shutters - > getShuttersDev
. ' - Der aktuelle Beschattungsstatus ist: '
. $ shutters - > getShadingStatus
. ' und somit wird nun in die Position: '
. $ getShadingPos
. ' zum Beschatten gefahren' ) ;
}
}
elsif ( $ shutters - > getShadingStatus eq 'out'
and $ getShadingPos == $ getStatus )
{
$ shutters - > setLastDrive ( 'shading out' ) ;
2019-06-27 13:14:56 +00:00
2019-06-21 07:19:49 +00:00
ShuttersCommandSet (
$ hash ,
$ shuttersDev ,
(
2019-06-27 13:14:56 +00:00
$ getShadingPos == $ shutters - > getLastPos
2019-06-21 07:19:49 +00:00
? $ shutters - > getOpenPos
2019-06-28 20:12:44 +00:00
: (
$ shutters - > getQueryShuttersPos ( $ shutters - > getLastPos )
2019-06-27 13:14:56 +00:00
? $ shutters - > getLastPos
2019-06-28 20:12:44 +00:00
: $ shutters - > getOpenPos
)
2019-06-21 07:19:49 +00:00
)
) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'ShadingProcessing: '
2019-05-24 20:24:11 +00:00
. $ shutters - > getShuttersDev
. ' - Der aktuelle Beschattungsstatus ist: '
. $ shutters - > getShadingStatus
. ' und somit wird nun in die Position: '
. $ getShadingPos
2019-06-21 07:19:49 +00:00
. ' zum beenden der Beschattung gefahren' ) ;
2018-12-06 14:24:16 +00:00
}
2018-12-07 12:04:41 +00:00
2019-06-21 07:19:49 +00:00
Log3 ( $ name , 4 ,
"AutoShuttersControl ($name) - Shading Processing - In der Routine zum fahren der Rollläden, Shading Wert: "
. $ shutters - > getShadingStatus ) ;
ASC_Debug (
'ShadingProcessing: '
2019-05-24 20:24:11 +00:00
. $ shutters - > getShuttersDev
. ' - Der aktuelle Beschattungsstatus ist: '
. $ shutters - > getShadingStatus
2019-06-21 07:19:49 +00:00
. ', Beschattungsstatus Zeitstempel: '
. strftime (
"%Y.%m.%e %T" , localtime ( $ shutters - > getShadingStatusTimestamp )
)
) ;
2019-05-24 17:58:26 +00:00
}
2018-11-14 02:41:38 +00:00
}
2018-11-12 11:56:18 +00:00
sub EventProcessingPartyMode ($) {
2019-11-11 18:16:47 +00:00
my $ hash = shift ;
2018-10-14 16:19:23 +00:00
my $ name = $ hash - > { NAME } ;
2018-09-04 09:42:47 +00:00
2019-04-28 05:32:48 +00:00
foreach my $ shuttersDev ( @ { $ hash - > { helper } { shuttersList } } ) {
2018-10-10 08:43:42 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2019-04-27 18:58:17 +00:00
next
if ( $ shutters - > getPartyMode eq 'off' ) ;
2019-04-28 05:32:48 +00:00
2019-06-27 08:48:06 +00:00
if ( not $ shutters - > getIsDay
2019-03-27 10:22:06 +00:00
and $ shutters - > getModeDown ne 'off'
and IsAfterShuttersManualBlocking ( $ shuttersDev ) )
2019-01-01 17:54:08 +00:00
{
2018-11-03 18:01:29 +00:00
if ( CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 2
and $ shutters - > getSubTyp eq 'threestate' )
{
Log3 ( $ name , 4 ,
2018-11-12 11:56:18 +00:00
"AutoShuttersControl ($name) - EventProcessingPartyMode Fenster offen"
2018-11-03 18:01:29 +00:00
) ;
$ shutters - > setDelayCmd ( $ shutters - > getClosedPos ) ;
Log3 ( $ name , 4 ,
2018-11-12 11:56:18 +00:00
"AutoShuttersControl ($name) - EventProcessingPartyMode - Spring in ShuttersCommandDelaySet"
2018-11-03 18:01:29 +00:00
) ;
}
else {
Log3 ( $ name , 4 ,
2018-11-12 11:56:18 +00:00
"AutoShuttersControl ($name) - EventProcessingPartyMode Fenster nicht offen"
2018-11-03 18:01:29 +00:00
) ;
2018-11-14 04:44:02 +00:00
$ shutters - > setLastDrive ( 'drive after party mode' ) ;
2018-11-03 18:01:29 +00:00
ShuttersCommandSet (
$ hash ,
$ shuttersDev ,
(
CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 0
? $ shutters - > getClosedPos
: $ shutters - > getVentilatePos
)
) ;
}
2018-09-04 09:42:47 +00:00
}
2019-09-22 06:10:55 +00:00
elsif ( $ shutters - > getDelayCmd ne 'none'
and $ shutters - > getIsDay
2019-04-09 10:13:46 +00:00
and IsAfterShuttersManualBlocking ( $ shuttersDev ) )
{
2019-01-01 17:54:08 +00:00
$ shutters - > setLastDrive ( 'drive after party mode' ) ;
2019-01-02 08:38:00 +00:00
ShuttersCommandSet ( $ hash , $ shuttersDev , $ shutters - > getDelayCmd ) ;
2019-01-01 17:54:08 +00:00
}
2018-09-04 09:42:47 +00:00
}
}
2019-11-11 18:16:47 +00:00
sub EventProcessingAdvShuttersClose ($) {
my $ hash = shift ;
my $ name = $ hash - > { NAME } ;
foreach my $ shuttersDev ( @ { $ hash - > { helper } { shuttersList } } ) {
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
next
if ( not $ shutters - > getAdv
and not $ shutters - > getAdvDelay ) ;
$ shutters - > setLastDrive ( 'adv delay close' ) ;
$ shutters - > setAdvDelay ( 1 ) ;
ShuttersCommandSet (
$ hash ,
$ shuttersDev ,
(
$ shutters - > getDelayCmd ne 'none'
? $ shutters - > getDelayCmd
: $ shutters - > getClosedPos
)
) ;
}
}
2018-11-12 11:56:18 +00:00
sub EventProcessingShutters ($@) {
2018-10-17 13:58:05 +00:00
my ( $ hash , $ shuttersDev , $ events ) = @ _ ;
2018-10-19 18:13:01 +00:00
my $ name = $ hash - > { NAME } ;
2018-10-17 13:58:05 +00:00
2019-08-26 08:34:11 +00:00
ASC_Debug ( 'EventProcessingShutters: '
. ' Fn wurde durch Notify aufgerufen da ASC_Pos_Reading Event erkannt wurde '
. ' - RECEIVED EVENT: '
. Dumper $ events ) ;
2018-10-17 13:58:05 +00:00
if ( $ events =~ m #.*:\s(\d+)# ) {
2018-10-19 18:13:01 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2018-11-04 18:17:11 +00:00
$ ascDev - > setPosReading ;
2019-05-07 09:34:53 +00:00
2019-05-07 09:30:55 +00:00
ASC_Debug ( 'EventProcessingShutters: '
. $ shutters - > getShuttersDev
2019-08-22 17:42:46 +00:00
. ' - Event vom Rollo erkannt. Es wird nun eine etwaige manuelle Fahrt ausgewertet.'
2019-05-07 09:34:53 +00:00
. ' Int von gettimeofday: '
. int ( gettimeofday ( ) )
2019-05-07 09:30:55 +00:00
. ' Last Position Timestamp: '
. $ shutters - > getLastPosTimestamp
. ' Drive Up Max Duration: '
. $ shutters - > getDriveUpMaxDuration
. ' Last Position: '
. $ shutters - > getLastPos
. ' aktuelle Position: '
2019-05-07 09:34:53 +00:00
. $ shutters - > getStatus ) ;
2019-04-25 19:34:46 +00:00
if ( ( int ( gettimeofday ( ) ) - $ shutters - > getLastPosTimestamp ) >
2019-05-07 09:34:53 +00:00
$ shutters - > getDriveUpMaxDuration
2019-05-07 09:30:55 +00:00
and ( int ( gettimeofday ( ) ) - $ shutters - > getLastManPosTimestamp ) >
2019-05-07 09:34:53 +00:00
$ shutters - > getDriveUpMaxDuration )
2018-11-03 18:01:29 +00:00
{
2018-10-27 11:36:11 +00:00
$ shutters - > setLastDrive ( 'manual' ) ;
$ shutters - > setLastDriveReading ;
2018-11-07 07:22:11 +00:00
$ ascDev - > setStateReading ;
2018-10-27 11:36:11 +00:00
$ shutters - > setLastManPos ( $ 1 ) ;
2019-06-03 04:24:53 +00:00
2019-06-29 17:39:44 +00:00
$ shutters - > setShadingManualDriveStatus ( 1 )
2019-06-30 16:53:28 +00:00
if ( $ shutters - > getIsDay
and $ shutters - > getIfInShading ) ;
2019-06-29 17:39:44 +00:00
2019-06-03 04:24:53 +00:00
ASC_Debug (
'EventProcessingShutters: eine manualle Fahrt wurde erkannt!' ) ;
}
else {
$ shutters - > setLastDriveReading ;
$ ascDev - > setStateReading ;
ASC_Debug (
'EventProcessingShutters: eine automatisierte Fahrt durch ASC wurde erkannt! Es werden nun die LastDriveReading und StateReading Werte gesetzt!'
) ;
2018-10-27 11:36:11 +00:00
}
2018-10-17 13:58:05 +00:00
}
2019-08-26 08:34:11 +00:00
ASC_Debug ( 'EventProcessingShutters: '
. ' Fn wurde durlaufen und es sollten Debugausgaben gekommen sein. '
. ' !!!Wenn nicht!!! wurde der Event nicht korrekt als Nummerisch erkannt. '
) ;
2018-10-17 13:58:05 +00:00
}
2019-11-04 07:09:46 +00:00
sub EventProcessingExternalTriggerDevice ($@) {
my ( $ hash , $ shuttersDev , $ events ) = @ _ ;
my $ name = $ hash - > { NAME } ;
2019-11-04 13:39:55 +00:00
2019-11-04 07:09:46 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
ASC_Debug ( 'EventProcessingExternalTriggerDevice: '
. ' Fn wurde durch Notify '
. ' - RECEIVED EVENT: '
. Dumper $ events ) ;
2019-11-04 13:39:55 +00:00
my $ reading = $ shutters - > getExternalTriggerReading ;
my $ triggerValActive = $ shutters - > getExternalTriggerValueActive ;
my $ triggerValInactive = $ shutters - > getExternalTriggerValueInactive ;
my $ triggerPosActive = $ shutters - > getExternalTriggerPosActive ;
my $ triggerPosInactive = $ shutters - > getExternalTriggerPosInactive ;
2019-11-04 07:09:46 +00:00
2019-11-05 12:22:03 +00:00
if ( $ events =~ m #$reading:\s($triggerValActive)#
and not $ shutters - > getQueryShuttersPos ( $ triggerPosActive ) )
{
2019-11-04 07:09:46 +00:00
ASC_Debug ( 'EventProcessingExternalTriggerDevice: '
2019-11-04 21:14:56 +00:00
. ' In der RegEx Schleife Trigger Val Aktiv'
2019-11-04 13:39:55 +00:00
. ' - TriggerVal: '
. $ triggerValActive ) ;
2019-11-05 12:22:03 +00:00
$ shutters - > setLastDrive ( 'external trigger device active' ) ;
$ shutters - > setNoDelay ( 1 ) ;
ShuttersCommandSet ( $ hash , $ shuttersDev , $ triggerPosActive ) ;
2019-11-04 07:09:46 +00:00
}
2019-11-05 12:22:03 +00:00
elsif (
$ events =~ m #$reading:\s($triggerValInactive)#
and ( $ shutters - > getPrivacyDownStatus != 2
or $ shutters - > getPrivacyUpStatus != 2 )
and not $ shutters - > getIfInShading
)
{
2019-11-04 07:09:46 +00:00
ASC_Debug ( 'EventProcessingExternalTriggerDevice: '
2019-11-04 21:14:56 +00:00
. ' In der RegEx Schleife Trigger Val Inaktiv'
2019-11-04 13:39:55 +00:00
. ' - TriggerVal: '
. $ triggerValInactive ) ;
2019-11-05 12:22:03 +00:00
$ shutters - > setLastDrive ( 'external trigger device inactive' ) ;
$ shutters - > setNoDelay ( 1 ) ;
ShuttersCommandSet ( $ hash , $ shuttersDev , $ triggerPosInactive ) ;
2019-11-04 07:09:46 +00:00
}
2019-11-05 12:22:03 +00:00
ASC_Debug (
'EventProcessingExternalTriggerDevice: ' . ' Funktion durchlaufen' ) ;
2019-11-04 07:09:46 +00:00
}
2018-08-29 12:58:10 +00:00
# Sub für das Zusammensetzen der Rolläden Steuerbefehle
2018-09-04 09:42:47 +00:00
sub ShuttersCommandSet ($$$) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ shuttersDev , $ posValue ) = @ _ ;
my $ name = $ hash - > { NAME } ;
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2018-11-19 08:06:50 +00:00
2019-09-20 18:36:47 +00:00
if (
(
$ posValue == $ shutters - > getShadingPos
and (
CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 2
and $ shutters - > getShuttersPlace eq 'terrace'
and ( $ shutters - > getLockOut eq 'soft'
or $ shutters - > getLockOut eq 'hard' )
and not $ shutters - > getQueryShuttersPos ( $ posValue )
)
2019-09-20 10:53:52 +00:00
)
2019-09-20 18:36:47 +00:00
or (
$ posValue != $ shutters - > getShadingPos
2019-09-20 18:35:48 +00:00
and (
(
$ shutters - > getPartyMode eq 'on'
and $ ascDev - > getPartyMode eq 'on'
)
or (
CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 2
and $ shutters - > getSubTyp eq 'threestate'
and ( $ ascDev - > getAutoShuttersControlComfort eq 'off'
or $ shutters - > getComfortOpenPos != $ posValue )
and $ shutters - > getVentilateOpen eq 'on'
and $ shutters - > getShuttersPlace eq 'window'
and $ shutters - > getLockOut ne 'off'
)
or ( CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 2
and $ shutters - > getSubTyp eq 'threestate'
and $ ascDev - > getAutoShuttersControlComfort eq 'on'
and $ shutters - > getVentilateOpen eq 'off'
and $ shutters - > getShuttersPlace eq 'window'
and $ shutters - > getLockOut ne 'off' )
or (
2019-01-23 09:00:47 +00:00
CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 2
2019-09-20 18:35:48 +00:00
and ( $ shutters - > getLockOut eq 'soft'
or $ shutters - > getLockOut eq 'hard' )
and not $ shutters - > getQueryShuttersPos ( $ posValue )
)
or ( CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 2
and $ shutters - > getShuttersPlace eq 'terrace'
and not $ shutters - > getQueryShuttersPos ( $ posValue ) )
or ( $ shutters - > getRainProtectionStatus eq 'protected'
and $ shutters - > getWindProtectionStatus eq 'protected' )
2019-01-23 09:00:47 +00:00
)
2018-12-07 12:04:41 +00:00
)
2019-09-20 18:36:47 +00:00
)
2018-10-14 16:19:23 +00:00
{
2018-10-27 11:36:11 +00:00
$ shutters - > setDelayCmd ( $ posValue ) ;
$ ascDev - > setDelayCmdReading ;
2019-09-17 14:52:19 +00:00
$ shutters - > setNoDelay ( 0 ) ;
2018-11-15 14:01:34 +00:00
Log3 ( $ name , 4 ,
2018-11-19 08:06:50 +00:00
"AutoShuttersControl ($name) - ShuttersCommandSet in Delay" ) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'FnShuttersCommandSet: '
. $ shutters - > getShuttersDev
. ' - Die Fahrt wird zurückgestellt. Grund kann ein geöffnetes Fenster sein oder ein aktivierter Party Modus'
) ;
2018-09-04 09:42:47 +00:00
}
2018-10-14 16:19:23 +00:00
else {
$ shutters - > setDriveCmd ( $ posValue ) ;
2018-10-27 11:36:11 +00:00
$ ascDev - > setLastPosReading ;
2018-11-15 14:01:34 +00:00
Log3 ( $ name , 4 ,
2018-11-19 08:06:50 +00:00
"AutoShuttersControl ($name) - ShuttersCommandSet setDriveCmd wird aufgerufen"
) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'FnShuttersCommandSet: '
. $ shutters - > getShuttersDev
. ' - Das Rollo wird gefahren. Kein Partymodus aktiv und das zugordnete Fenster ist entweder nicht offen oder keine Terassentür'
) ;
2018-10-14 16:19:23 +00:00
}
2018-08-28 17:49:01 +00:00
}
2018-08-29 12:58:10 +00:00
## Sub welche die InternalTimer nach entsprechenden Sunset oder Sunrise zusammen stellt
2018-08-28 17:49:01 +00:00
sub CreateSunRiseSetShuttersTimer ($$) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ shuttersDev ) = @ _ ;
my $ name = $ hash - > { NAME } ;
my $ shuttersDevHash = $ defs { $ shuttersDev } ;
2018-10-10 08:43:42 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2018-11-07 07:22:11 +00:00
2018-10-14 16:19:23 +00:00
return if ( IsDisabled ( $ name ) ) ;
2018-08-30 08:24:39 +00:00
2019-04-20 19:53:05 +00:00
my $ shuttersSunriseUnixtime = ShuttersSunrise ( $ shuttersDev , 'unix' ) + 1 ;
my $ shuttersSunsetUnixtime = ShuttersSunset ( $ shuttersDev , 'unix' ) + 1 ;
2018-09-13 06:11:10 +00:00
2018-10-28 17:12:40 +00:00
$ shutters - > setSunriseUnixTime ( $ shuttersSunriseUnixtime ) ;
$ shutters - > setSunsetUnixTime ( $ shuttersSunsetUnixtime ) ;
2018-10-14 16:19:23 +00:00
## In jedem Rolladen werden die errechneten Zeiten hinterlegt,es sei denn das autoShuttersControlEvening/Morning auf off steht
2018-09-13 06:11:10 +00:00
readingsBeginUpdate ( $ shuttersDevHash ) ;
2018-10-14 16:19:23 +00:00
readingsBulkUpdate (
$ shuttersDevHash ,
'ASC_Time_DriveDown' ,
(
$ ascDev - > getAutoShuttersControlEvening eq 'on'
2019-09-06 16:40:10 +00:00
? (
$ shutters - > getDown eq 'roommate' ? 'roommate only' : strftime (
"%e.%m.%Y - %H:%M" ,
localtime ( $ shuttersSunsetUnixtime )
)
)
2018-10-14 16:19:23 +00:00
: 'AutoShuttersControl off'
2019-02-19 20:18:06 +00:00
)
2018-10-14 16:19:23 +00:00
) ;
readingsBulkUpdate (
$ shuttersDevHash ,
'ASC_Time_DriveUp' ,
(
$ ascDev - > getAutoShuttersControlMorning eq 'on'
2019-09-06 16:40:10 +00:00
? (
$ shutters - > getUp eq 'roommate' ? 'roommate only' : strftime (
"%e.%m.%Y - %H:%M" ,
localtime ( $ shuttersSunriseUnixtime )
)
)
2018-10-14 16:19:23 +00:00
: 'AutoShuttersControl off'
2019-02-19 20:18:06 +00:00
)
2018-10-14 16:19:23 +00:00
) ;
2019-02-19 20:18:06 +00:00
readingsEndUpdate ( $ shuttersDevHash , 0 ) ;
2018-09-13 06:11:10 +00:00
2018-09-07 12:10:46 +00:00
readingsBeginUpdate ( $ hash ) ;
2018-10-14 16:19:23 +00:00
readingsBulkUpdateIfChanged (
$ hash ,
$ shuttersDev . '_nextAstroTimeEvent' ,
(
$ shuttersSunriseUnixtime < $ shuttersSunsetUnixtime
? strftime ( "%e.%m.%Y - %H:%M" ,
localtime ( $ shuttersSunriseUnixtime ) )
: strftime (
"%e.%m.%Y - %H:%M" , localtime ( $ shuttersSunsetUnixtime )
)
)
) ;
readingsEndUpdate ( $ hash , 1 ) ;
RemoveInternalTimer ( $ shutters - > getInTimerFuncHash )
2018-10-17 07:50:11 +00:00
if ( defined ( $ shutters - > getInTimerFuncHash ) ) ;
2018-09-13 06:11:10 +00:00
2018-08-29 12:58:10 +00:00
## kleine Hilfe für InternalTimer damit ich alle benötigten Variablen an die Funktion übergeben kann welche von Internal Timer aufgerufen wird.
2018-10-14 16:19:23 +00:00
my % funcHash = (
hash = > $ hash ,
shuttersdevice = > $ shuttersDev ,
2019-06-26 04:53:32 +00:00
sunsettime = > $ shuttersSunsetUnixtime ,
sunrisetime = > $ shuttersSunriseUnixtime
2018-10-14 16:19:23 +00:00
) ;
2019-10-25 08:44:08 +00:00
## Setzt den Privacy Modus für die Sichtschutzfahrt auf den Status 0
2019-06-26 04:53:32 +00:00
## 1 bedeutet das PrivacyDown Timer aktiviert wurde, 2 beudet das er im privacyDown ist
2019-10-25 08:44:08 +00:00
## also das Rollo in privacy Position steht und VOR der endgültigen Nacht oder Tagfahrt
$ shutters - > setPrivacyUpStatus ( 0 )
if ( not defined ( $ shutters - > getPrivacyUpStatus ) ) ;
2019-06-26 04:53:32 +00:00
$ shutters - > setPrivacyDownStatus ( 0 )
2019-06-28 20:12:10 +00:00
if ( not defined ( $ shutters - > getPrivacyDownStatus ) ) ;
2019-06-21 07:58:41 +00:00
2018-10-14 16:19:23 +00:00
## Ich brauche beim löschen des InternalTimer den Hash welchen ich mitgegeben habe,dieser muss gesichert werden
2018-10-17 07:50:11 +00:00
$ shutters - > setInTimerFuncHash ( \ % funcHash ) ;
2019-10-25 08:44:08 +00:00
## Abfrage für die Sichtschutzfahrt am Morgen vor dem eigentlichen kompletten öffnen
2019-10-30 11:43:57 +00:00
if ( $ shutters - > getPrivacyUpTime > 0 ) {
2019-10-25 08:44:35 +00:00
$ shuttersSunriseUnixtime =
PrivacyUpTime ( $ shuttersDevHash , $ shuttersSunriseUnixtime ) ;
2019-10-25 08:44:08 +00:00
}
else {
2019-10-25 08:44:35 +00:00
CommandDeleteReading ( undef , $ shuttersDev . ' ASC_Time_PrivacyDriveUp' )
if ( ReadingsVal ( $ shuttersDev , 'ASC_Time_PrivacyDriveUp' , 'none' ) ) ;
2019-10-25 08:44:08 +00:00
}
2019-01-23 18:01:54 +00:00
## Abfrage für die Sichtschutzfahrt am Abend vor dem eigentlichen kompletten schließen
2019-10-31 06:17:04 +00:00
if ( $ shutters - > getPrivacyDownTime > 0 ) {
2019-10-25 08:44:35 +00:00
$ shuttersSunsetUnixtime =
PrivacyDownTime ( $ shuttersDevHash , $ shuttersSunsetUnixtime ) ;
2019-01-23 18:01:54 +00:00
}
2019-09-06 16:40:10 +00:00
else {
CommandDeleteReading ( undef ,
$ shuttersDev . ' ASC_Time_PrivacyDriveDown' )
if (
ReadingsVal ( $ shuttersDev , 'ASC_Time_PrivacyDriveDown' , 'none' ) ) ;
}
2019-01-23 18:01:54 +00:00
2018-10-14 16:19:23 +00:00
InternalTimer ( $ shuttersSunsetUnixtime ,
2019-06-10 11:41:46 +00:00
'FHEM::AutoShuttersControl::SunSetShuttersAfterTimerFn' , \ % funcHash ) ;
2018-10-14 16:19:23 +00:00
InternalTimer ( $ shuttersSunriseUnixtime ,
2019-06-10 11:41:46 +00:00
'FHEM::AutoShuttersControl::SunRiseShuttersAfterTimerFn' , \ % funcHash ) ;
2018-11-08 07:32:47 +00:00
2018-11-07 07:22:11 +00:00
$ ascDev - > setStateReading ( 'created new drive timer' ) ;
2018-08-28 17:49:01 +00:00
}
2018-08-29 12:58:10 +00:00
## Funktion zum neu setzen der Timer und der Readings für Sunset/Rise
sub RenewSunRiseSetShuttersTimer ($) {
2018-10-14 16:19:23 +00:00
my $ hash = shift ;
foreach ( @ { $ hash - > { helper } { shuttersList } } ) {
2019-11-02 08:16:32 +00:00
my $ name = $ _ ;
my $ dhash = $ defs { $ name } ;
$ shutters - > setShuttersDev ( $ name ) ;
2018-10-17 07:50:11 +00:00
RemoveInternalTimer ( $ shutters - > getInTimerFuncHash ) ;
$ shutters - > setInTimerFuncHash ( undef ) ;
2019-11-02 08:16:32 +00:00
CreateSunRiseSetShuttersTimer ( $ hash , $ name ) ;
2019-03-07 16:58:30 +00:00
2019-09-06 16:36:48 +00:00
#### Temporär angelegt damit die neue Attributs Parameter Syntax verteilt werden kann
#### Gleichlautende Attribute wo lediglich die Parameter geändert werden sollen müssen bereits in der Funktion ShuttersDeviceScan gelöscht werden
#### vorher empfiehlt es sich die dort vergebenen Parameter aus zu lesen um sie dann hier wieder neu zu setzen. Dazu wird das shutters Objekt um einen Eintrag
#### 'AttrUpdateChanges' erweitert
2019-11-02 08:16:32 +00:00
if (
( int ( gettimeofday ( ) ) - $ ::fhem_started ) < 60
2019-09-06 16:40:10 +00:00
and
2019-11-02 08:16:32 +00:00
ReadingsVal ( $ name , '.ASC_AttrUpdateChanges_' . $ hash - > { VERSION } ,
0 ) == 0
)
2019-09-06 16:40:10 +00:00
{
2019-11-02 08:16:32 +00:00
$ attr { $ name } { 'ASC_Up' } = $ shutters - > getAttrUpdateChanges ( 'ASC_Up' )
2019-09-06 16:40:10 +00:00
if ( $ shutters - > getAttrUpdateChanges ( 'ASC_Up' ) ne 'none' ) ;
2019-11-02 08:16:32 +00:00
$ attr { $ name } { 'ASC_Down' } =
$ shutters - > getAttrUpdateChanges ( 'ASC_Down' )
2019-09-06 16:40:10 +00:00
if ( $ shutters - > getAttrUpdateChanges ( 'ASC_Down' ) ne 'none' ) ;
2019-11-02 08:16:32 +00:00
$ attr { $ name } { 'ASC_Self_Defense_Mode' } =
2019-09-17 14:24:48 +00:00
$ shutters - > getAttrUpdateChanges ( 'ASC_Self_Defense_Mode' )
if ( $ shutters - > getAttrUpdateChanges ( 'ASC_Self_Defense_Mode' ) ne
'none' ) ;
2019-11-02 08:16:32 +00:00
$ attr { $ name } { 'ASC_Self_Defense_Mode' } = 'off'
2019-09-17 14:24:48 +00:00
if (
$ shutters - > getAttrUpdateChanges ( 'ASC_Self_Defense_Exclude' ) eq
'on' ) ;
2019-09-16 15:15:02 +00:00
2019-11-02 08:16:32 +00:00
CommandDeleteReading ( undef , $ name . ' .ASC_AttrUpdateChanges_.*' )
2019-09-06 16:40:10 +00:00
if (
2019-11-02 08:16:32 +00:00
ReadingsVal (
$ name , '.ASC_AttrUpdateChanges_' . $ hash - > { VERSION } ,
'none'
) eq 'none'
2019-09-06 16:40:10 +00:00
) ;
2019-11-02 08:16:32 +00:00
readingsSingleUpdate ( $ dhash ,
2019-09-06 16:40:10 +00:00
'.ASC_AttrUpdateChanges_' . $ hash - > { VERSION } ,
1 , 0 ) ;
}
2019-09-17 14:24:48 +00:00
2019-11-02 08:16:32 +00:00
$ attr { $ name } { ASC_Drive_Delay } =
AttrVal ( $ name , 'ASC_Drive_Offset' , 'none' )
if ( AttrVal ( $ name , 'ASC_Drive_Offset' , 'none' ) ne 'none' ) ;
delFromDevAttrList ( $ name , 'ASC_Drive_Offset' ) ;
2019-09-17 14:24:48 +00:00
2019-11-02 08:16:32 +00:00
$ attr { $ name } { ASC_Drive_DelayStart } =
AttrVal ( $ name , 'ASC_Drive_OffsetStart' , 'none' )
if ( AttrVal ( $ name , 'ASC_Drive_OffsetStart' , 'none' ) ne 'none' ) ;
delFromDevAttrList ( $ name , 'ASC_Drive_OffsetStart' ) ;
2019-09-17 14:24:48 +00:00
2019-11-02 08:16:32 +00:00
$ attr { $ name } { ASC_Shading_StateChange_SunnyCloudy } =
AttrVal ( $ name , 'ASC_Shading_StateChange_Sunny' , 'none' ) . ':'
. AttrVal ( $ name , 'ASC_Shading_StateChange_Cloudy' , 'none' )
if (
AttrVal ( $ name , 'ASC_Shading_StateChange_Sunny' , 'none' ) ne 'none'
and AttrVal ( $ name , 'ASC_Shading_StateChange_Cloudy' , 'none' ) ne
2019-09-19 11:46:42 +00:00
'none' ) ;
2019-11-02 08:16:32 +00:00
delFromDevAttrList ( $ name , 'ASC_Shading_StateChange_Sunny' ) ;
delFromDevAttrList ( $ name , 'ASC_Shading_StateChange_Cloudy' ) ;
2019-09-19 11:46:42 +00:00
2019-11-02 08:16:32 +00:00
$ attr { $ name } { ASC_Shading_InOutAzimuth } =
( AttrVal ( $ name , 'ASC_Shading_Direction' , 180 ) -
AttrVal ( $ name , 'ASC_Shading_Angle_Left' , 85 ) )
2019-09-19 11:46:42 +00:00
. ':'
2019-11-02 08:16:32 +00:00
. ( AttrVal ( $ name , 'ASC_Shading_Direction' , 180 ) +
AttrVal ( $ name , 'ASC_Shading_Angle_Right' , 85 ) )
if ( AttrVal ( $ name , 'ASC_Shading_Direction' , 'none' ) ne 'none'
or AttrVal ( $ name , 'ASC_Shading_Angle_Left' , 'none' ) ne 'none'
or AttrVal ( $ name , 'ASC_Shading_Angle_Right' , 'none' ) ne 'none' ) ;
delFromDevAttrList ( $ name , 'ASC_Shading_Direction' ) ;
delFromDevAttrList ( $ name , 'ASC_Shading_Angle_Left' ) ;
delFromDevAttrList ( $ name , 'ASC_Shading_Angle_Right' ) ;
$ attr { $ name } { ASC_PrivacyDownValue_beforeNightClose } =
AttrVal ( $ name , 'ASC_PrivacyDownTime_beforNightClose' , 'none' )
if (
AttrVal ( $ name , 'ASC_PrivacyDownTime_beforNightClose' , 'none' ) ne
2019-10-24 11:53:14 +00:00
'none' ) ;
2019-11-02 08:16:32 +00:00
delFromDevAttrList ( $ name , 'ASC_PrivacyDownTime_beforNightClose' ) ;
2019-11-07 13:06:47 +00:00
2019-11-05 12:44:40 +00:00
delFromDevAttrList ( $ name , 'ASC_ExternalTriggerDevice' ) ;
2018-08-29 12:58:10 +00:00
}
}
2018-09-14 18:46:55 +00:00
## Funktion zum hardwareseitigen setzen des lock-out oder blocking beim Rolladen selbst
2018-11-21 07:38:32 +00:00
sub HardewareBlockForShutters ($$) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ cmd ) = @ _ ;
foreach ( @ { $ hash - > { helper } { shuttersList } } ) {
2018-11-14 14:26:32 +00:00
$ shutters - > setShuttersDev ( $ _ ) ;
2018-11-21 07:38:32 +00:00
$ shutters - > setHardLockOut ( $ cmd ) ;
2018-09-14 18:46:55 +00:00
}
}
2018-11-07 07:22:11 +00:00
## Funktion für das wiggle aller Shutters zusammen
sub wiggleAll ($) {
my $ hash = shift ;
foreach ( @ { $ hash - > { helper } { shuttersList } } ) {
2018-11-08 07:32:47 +00:00
wiggle ( $ hash , $ _ ) ;
2018-11-07 07:22:11 +00:00
}
}
sub wiggle ($$) {
my ( $ hash , $ shuttersDev ) = @ _ ;
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2019-09-17 14:52:19 +00:00
$ shutters - > setNoDelay ( 1 ) ;
2018-11-29 20:33:08 +00:00
$ shutters - > setLastDrive ( 'wiggle begin drive' ) ;
2018-11-07 07:22:11 +00:00
2018-11-08 07:32:47 +00:00
my % h = (
2018-11-07 07:22:11 +00:00
shuttersDev = > $ shutters - > getShuttersDev ,
posValue = > $ shutters - > getStatus ,
2018-11-29 20:33:08 +00:00
lastDrive = > 'wiggle end drive' ,
2018-11-07 07:22:11 +00:00
) ;
if ( $ shutters - > getShuttersPosCmdValueNegate ) {
2018-11-19 20:58:55 +00:00
if ( $ shutters - > getStatus >= $ shutters - > getClosedPos / 2 ) {
2018-11-19 08:06:50 +00:00
$ shutters - > setDriveCmd (
2018-11-19 20:58:55 +00:00
$ shutters - > getStatus - $ shutters - > getWiggleValue ) ;
2018-11-19 08:06:50 +00:00
}
else {
$ shutters - > setDriveCmd (
2018-11-19 20:58:55 +00:00
$ shutters - > getStatus + $ shutters - > getWiggleValue ) ;
2018-11-07 07:22:11 +00:00
}
}
else {
if ( $ shutters - > getStatus >= $ shutters - > getOpenPos / 2 ) {
2018-11-19 08:06:50 +00:00
$ shutters - > setDriveCmd (
$ shutters - > getStatus - $ shutters - > getWiggleValue ) ;
}
else {
$ shutters - > setDriveCmd (
$ shutters - > getStatus + $ shutters - > getWiggleValue ) ;
2018-11-07 07:22:11 +00:00
}
}
2019-04-09 10:13:46 +00:00
InternalTimer ( gettimeofday ( ) + 60 ,
2019-07-03 09:54:01 +00:00
'FHEM::AutoShuttersControl::_SetCmdFn' , \ % h ) ;
2018-11-07 07:22:11 +00:00
}
####
2018-08-29 12:58:10 +00:00
## Funktion welche beim Ablaufen des Timers für Sunset aufgerufen werden soll
2018-08-28 17:49:01 +00:00
sub SunSetShuttersAfterTimerFn ($) {
2018-10-14 16:19:23 +00:00
my $ funcHash = shift ;
my $ hash = $ funcHash - > { hash } ;
my $ shuttersDev = $ funcHash - > { shuttersdevice } ;
2018-10-10 08:43:42 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2018-09-10 18:12:26 +00:00
2018-10-28 17:12:40 +00:00
my $ homemode = $ shutters - > getRoommatesStatus ;
$ homemode = $ ascDev - > getResidentsStatus if ( $ homemode eq 'none' ) ;
2019-06-10 12:03:03 +00:00
if (
2019-09-06 16:36:48 +00:00
$ shutters - > getDown ne 'roommate'
and $ ascDev - > getAutoShuttersControlEvening eq 'on'
2019-06-10 12:03:03 +00:00
and IsAfterShuttersManualBlocking ( $ shuttersDev )
and (
2019-01-02 08:38:00 +00:00
$ shutters - > getModeDown eq $ homemode
or ( $ shutters - > getModeDown eq 'absent'
and $ homemode eq 'gone' )
or $ shutters - > getModeDown eq 'always'
2019-06-10 12:03:03 +00:00
)
2019-08-22 04:19:31 +00:00
and (
$ ascDev - > getSelfDefense eq 'off'
2019-09-16 15:15:02 +00:00
or $ shutters - > getSelfDefenseMode eq 'off'
2019-09-17 14:24:48 +00:00
or ( $ ascDev - > getSelfDefense eq 'on'
and $ ascDev - > getResidentsStatus ne 'gone' )
2019-08-19 08:50:34 +00:00
)
2019-10-24 08:41:38 +00:00
and (
2019-10-24 11:53:14 +00:00
$ shutters - > getDown ne 'brightness'
or ( $ shutters - > getDown eq 'brightness'
2019-10-24 08:41:38 +00:00
and not $ shutters - > getSunset )
)
2018-11-19 08:06:50 +00:00
)
2018-10-31 08:58:23 +00:00
{
2019-06-25 11:19:22 +00:00
2019-06-26 04:53:32 +00:00
if ( $ shutters - > getPrivacyDownStatus == 1 ) {
$ shutters - > setPrivacyDownStatus ( 2 ) ;
2019-10-31 06:17:04 +00:00
$ shutters - > setLastDrive ( 'timer privacy night close' ) ;
2019-08-22 04:19:31 +00:00
ShuttersCommandSet ( $ hash , $ shuttersDev ,
2019-09-05 06:33:19 +00:00
$ shutters - > getPrivacyDownPos )
2019-09-06 16:40:10 +00:00
unless (
$ shutters - > getQueryShuttersPos ( $ shutters - > getPrivacyDownPos )
) ;
2019-04-12 11:58:26 +00:00
}
2019-06-26 04:53:32 +00:00
else {
2019-10-31 06:17:04 +00:00
$ shutters - > setPrivacyDownStatus ( 0 )
if ( $ shutters - > getPrivacyDownStatus == 2 ) ;
2019-04-12 11:58:26 +00:00
$ shutters - > setLastDrive ( 'night close' ) ;
2019-09-17 14:24:48 +00:00
ShuttersCommandSet (
$ hash ,
$ shuttersDev ,
PositionValueWindowRec (
$ shuttersDev ,
(
$ shutters - > getSleepPos > 0
? $ shutters - > getSleepPos
: $ shutters - > getClosedPos
)
)
2019-06-25 11:19:22 +00:00
) ;
2019-04-12 11:58:26 +00:00
}
2018-10-30 18:10:50 +00:00
}
2018-09-10 18:12:26 +00:00
2019-10-31 06:17:04 +00:00
unless ( $ shutters - > getPrivacyDownStatus == 2 ) {
$ shutters - > setSunrise ( 0 ) ;
$ shutters - > setSunset ( 1 ) ;
}
2018-10-14 16:19:23 +00:00
CreateSunRiseSetShuttersTimer ( $ hash , $ shuttersDev ) ;
2018-08-28 17:49:01 +00:00
}
2018-08-29 12:58:10 +00:00
## Funktion welche beim Ablaufen des Timers für Sunrise aufgerufen werden soll
2018-08-28 17:49:01 +00:00
sub SunRiseShuttersAfterTimerFn ($) {
2018-10-14 16:19:23 +00:00
my $ funcHash = shift ;
my $ hash = $ funcHash - > { hash } ;
my $ shuttersDev = $ funcHash - > { shuttersdevice } ;
2018-10-10 08:43:42 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2019-05-17 12:20:57 +00:00
2018-10-28 17:12:40 +00:00
my $ homemode = $ shutters - > getRoommatesStatus ;
$ homemode = $ ascDev - > getResidentsStatus if ( $ homemode eq 'none' ) ;
2019-06-10 12:03:03 +00:00
if (
2019-09-06 16:36:48 +00:00
$ shutters - > getUp ne 'roommate'
and $ ascDev - > getAutoShuttersControlMorning eq 'on'
2019-06-10 12:03:03 +00:00
and (
$ shutters - > getModeUp eq $ homemode
or ( $ shutters - > getModeUp eq 'absent'
and $ homemode eq 'gone' )
or $ shutters - > getModeUp eq 'always'
)
2019-08-22 04:19:31 +00:00
and (
$ ascDev - > getSelfDefense eq 'off'
2019-09-16 15:15:02 +00:00
or $ shutters - > getSelfDefenseMode eq 'off'
2019-08-22 04:19:31 +00:00
or ( $ ascDev - > getSelfDefense eq 'on'
2019-09-17 14:24:48 +00:00
and $ ascDev - > getResidentsStatus ne 'gone' )
2019-08-19 08:50:34 +00:00
)
2019-10-24 08:41:38 +00:00
and (
2019-10-24 11:53:14 +00:00
$ shutters - > getUp ne 'brightness'
or ( $ shutters - > getUp eq 'brightness'
2019-10-24 08:41:38 +00:00
and not $ shutters - > getSunrise )
)
2018-11-19 08:06:50 +00:00
)
2018-10-14 16:19:23 +00:00
{
2019-06-10 12:03:03 +00:00
2018-10-30 18:10:50 +00:00
if (
2018-10-31 08:58:23 +00:00
(
$ shutters - > getRoommatesStatus eq 'home'
or $ shutters - > getRoommatesStatus eq 'awoken'
or $ shutters - > getRoommatesStatus eq 'absent'
or $ shutters - > getRoommatesStatus eq 'gone'
or $ shutters - > getRoommatesStatus eq 'none'
)
2019-01-17 08:47:53 +00:00
and (
$ ascDev - > getSelfDefense eq 'off'
or ( $ ascDev - > getSelfDefense eq 'on'
and CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 0 )
2019-08-22 04:19:31 +00:00
or (
$ ascDev - > getSelfDefense eq 'on'
2019-07-01 08:14:28 +00:00
and CheckIfShuttersWindowRecOpen ( $ shuttersDev ) != 0
2019-09-12 09:28:51 +00:00
and ( $ ascDev - > getResidentsStatus ne 'absent'
and $ ascDev - > getResidentsStatus ne 'gone' )
2019-08-22 04:19:31 +00:00
)
2019-01-17 08:47:53 +00:00
)
2018-10-30 18:10:50 +00:00
)
{
2019-06-14 12:02:05 +00:00
if ( not $ shutters - > getIfInShading ) {
2019-10-25 08:44:08 +00:00
if ( $ shutters - > getPrivacyUpStatus == 1 ) {
$ shutters - > setPrivacyUpStatus ( 2 ) ;
2019-10-31 06:17:04 +00:00
$ shutters - > setLastDrive ( 'timer privacy day open' ) ;
2019-10-25 08:44:08 +00:00
ShuttersCommandSet ( $ hash , $ shuttersDev ,
$ shutters - > getPrivacyUpPos )
2019-10-29 08:33:55 +00:00
unless (
not $ shutters - > getQueryShuttersPos (
2019-10-25 08:44:35 +00:00
$ shutters - > getPrivacyUpPos
)
) ;
2019-10-25 08:44:08 +00:00
}
else {
$ shutters - > setLastDrive ( 'day open' ) ;
ShuttersCommandSet ( $ hash , $ shuttersDev ,
$ shutters - > getOpenPos ) ;
2019-10-30 11:43:57 +00:00
$ shutters - > setPrivacyUpStatus ( 0 )
if ( $ shutters - > getPrivacyUpStatus == 2 ) ;
2019-10-25 08:44:08 +00:00
}
2019-06-14 12:02:05 +00:00
}
elsif ( $ shutters - > getIfInShading ) {
$ shutters - > setLastDrive ( 'shading in' ) ;
ShuttersCommandSet ( $ hash , $ shuttersDev ,
$ shutters - > getShadingPos ) ;
2019-10-30 11:43:57 +00:00
$ shutters - > setPrivacyUpStatus ( 0 )
if ( $ shutters - > getPrivacyUpStatus == 2 ) ;
2019-06-14 12:02:05 +00:00
}
2018-10-30 18:10:50 +00:00
}
2018-09-02 21:00:40 +00:00
}
2019-06-10 11:41:46 +00:00
2019-10-30 14:07:23 +00:00
unless ( $ shutters - > getPrivacyUpStatus == 2 ) {
2019-10-30 11:43:57 +00:00
$ shutters - > setSunrise ( 1 ) ;
$ shutters - > setSunset ( 0 ) ;
}
2018-10-14 16:19:23 +00:00
CreateSunRiseSetShuttersTimer ( $ hash , $ shuttersDev ) ;
2018-08-28 17:49:01 +00:00
}
2018-10-08 01:59:51 +00:00
sub CreateNewNotifyDev ($) {
2018-10-14 16:19:23 +00:00
my $ hash = shift ;
my $ name = $ hash - > { NAME } ;
2018-10-08 01:59:51 +00:00
2018-10-14 16:19:23 +00:00
$ hash - > { NOTIFYDEV } = "global," . $ name ;
2018-10-08 01:59:51 +00:00
delete $ hash - > { monitoredDevs } ;
2018-10-14 16:38:44 +00:00
2018-10-14 16:19:23 +00:00
CommandDeleteReading ( undef , $ name . ' .monitoredDevs' ) ;
2018-10-17 13:58:05 +00:00
my $ shuttersList = '' ;
2018-10-14 16:19:23 +00:00
foreach ( @ { $ hash - > { helper } { shuttersList } } ) {
AddNotifyDev ( $ hash , AttrVal ( $ _ , 'ASC_Roommate_Device' , 'none' ) ,
$ _ , 'ASC_Roommate_Device' )
if ( AttrVal ( $ _ , 'ASC_Roommate_Device' , 'none' ) ne 'none' ) ;
AddNotifyDev ( $ hash , AttrVal ( $ _ , 'ASC_WindowRec' , 'none' ) ,
$ _ , 'ASC_WindowRec' )
if ( AttrVal ( $ _ , 'ASC_WindowRec' , 'none' ) ne 'none' ) ;
2019-03-07 16:58:30 +00:00
AddNotifyDev ( $ hash , AttrVal ( $ _ , 'ASC_BrightnessSensor' , 'none' ) ,
$ _ , 'ASC_BrightnessSensor' )
if ( AttrVal ( $ _ , 'ASC_BrightnessSensor' , 'none' ) ne 'none' ) ;
2019-11-05 12:44:40 +00:00
AddNotifyDev ( $ hash , AttrVal ( $ _ , 'ASC_ExternalTrigger' , 'none' ) ,
2019-11-04 13:39:55 +00:00
$ _ , 'ASC_BrightnessSensor' )
2019-11-05 12:44:40 +00:00
if ( AttrVal ( $ _ , 'ASC_ExternalTrigger' , 'none' ) ne 'none' ) ;
2019-03-04 13:02:54 +00:00
2019-04-09 10:13:46 +00:00
$ shuttersList = $ shuttersList . ',' . $ _ ;
2018-10-08 01:59:51 +00:00
}
2019-03-07 16:58:30 +00:00
2019-03-04 13:02:54 +00:00
AddNotifyDev ( $ hash , AttrVal ( $ name , 'ASC_residentsDev' , 'none' ) ,
$ name , 'ASC_residentsDev' )
if ( AttrVal ( $ name , 'ASC_residentsDev' , 'none' ) ne 'none' ) ;
AddNotifyDev ( $ hash , AttrVal ( $ name , 'ASC_rainSensor' , 'none' ) ,
$ name , 'ASC_rainSensor' )
if ( AttrVal ( $ name , 'ASC_rainSensor' , 'none' ) ne 'none' ) ;
2018-11-14 02:41:38 +00:00
AddNotifyDev ( $ hash , AttrVal ( $ name , 'ASC_twilightDevice' , 'none' ) ,
2018-11-14 14:26:32 +00:00
$ name , 'ASC_twilightDevice' )
if ( AttrVal ( $ name , 'ASC_twilightDevice' , 'none' ) ne 'none' ) ;
2019-03-04 09:57:39 +00:00
AddNotifyDev ( $ hash , AttrVal ( $ name , 'ASC_windSensor' , 'none' ) ,
$ name , 'ASC_windSensor' )
if ( AttrVal ( $ name , 'ASC_windSensor' , 'none' ) ne 'none' ) ;
2019-04-09 10:13:46 +00:00
2018-10-17 13:58:05 +00:00
$ hash - > { NOTIFYDEV } = $ hash - > { NOTIFYDEV } . $ shuttersList ;
2018-10-08 01:59:51 +00:00
}
2018-09-21 06:44:38 +00:00
sub GetShuttersInformation ($) {
2018-10-28 17:12:40 +00:00
my $ hash = shift ;
my $ ret = '<html><table><tr><td>' ;
2018-09-21 06:44:38 +00:00
$ ret . = '<table class="block wide">' ;
$ ret . = '<tr class="even">' ;
2018-10-09 16:05:55 +00:00
$ ret . = "<td><b>Shutters</b></td>" ;
2018-09-21 18:03:02 +00:00
$ ret . = "<td> </td>" ;
$ ret . = "<td><b>Next DriveUp</b></td>" ;
$ ret . = "<td> </td>" ;
$ ret . = "<td><b>Next DriveDown</b></td>" ;
$ ret . = "<td> </td>" ;
2018-10-28 17:12:40 +00:00
$ ret . = "<td><b>ASC Up</b></td>" ;
$ ret . = "<td> </td>" ;
$ ret . = "<td><b>ASC Down</b></td>" ;
$ ret . = "<td> </td>" ;
$ ret . = "<td><b>ASC Mode Up</b></td>" ;
$ ret . = "<td> </td>" ;
$ ret . = "<td><b>ASC Mode Down</b></td>" ;
$ ret . = "<td> </td>" ;
2018-09-21 18:03:02 +00:00
$ ret . = "<td><b>Partymode</b></td>" ;
$ ret . = "<td> </td>" ;
$ ret . = "<td><b>Lock-Out</b></td>" ;
2018-10-28 17:12:40 +00:00
$ ret . = "<td> </td>" ;
$ ret . = "<td><b>Last Drive</b></td>" ;
$ ret . = "<td> </td>" ;
$ ret . = "<td><b>Position</b></td>" ;
$ ret . = "<td> </td>" ;
$ ret . = "<td><b>Last Position</b></td>" ;
2019-03-23 20:57:19 +00:00
$ ret . = "<td> </td>" ;
$ ret . = "<td><b>Shading Info</b></td>" ;
2018-09-21 06:44:38 +00:00
$ ret . = '</tr>' ;
2018-09-21 20:12:24 +00:00
2018-10-28 17:12:40 +00:00
my $ linecount = 1 ;
foreach my $ shutter ( @ { $ hash - > { helper } { shuttersList } } ) {
$ shutters - > setShuttersDev ( $ shutter ) ;
if ( $ linecount % 2 == 0 ) { $ ret . = '<tr class="even">' ; }
else { $ ret . = '<tr class="odd">' ; }
$ ret . = "<td>$shutter</td>" ;
$ ret . = "<td> </td>" ;
$ ret . = "<td>"
. strftime ( "%e.%m.%Y - %H:%M:%S" ,
localtime ( $ shutters - > getSunriseUnixTime ) )
. "</td>" ;
$ ret . = "<td> </td>" ;
$ ret . = "<td>"
. strftime ( "%e.%m.%Y - %H:%M:%S" ,
localtime ( $ shutters - > getSunsetUnixTime ) )
. "</td>" ;
$ ret . = "<td> </td>" ;
2018-11-03 18:01:29 +00:00
$ ret . = "<td>" . $ shutters - > getUp . "</td>" ;
2018-10-28 17:12:40 +00:00
$ ret . = "<td> </td>" ;
2018-11-03 18:01:29 +00:00
$ ret . = "<td>" . $ shutters - > getDown . "</td>" ;
2018-10-28 17:12:40 +00:00
$ ret . = "<td> </td>" ;
$ ret . = "<td>" . $ shutters - > getModeUp . "</td>" ;
$ ret . = "<td> </td>" ;
$ ret . = "<td>" . $ shutters - > getModeDown . "</td>" ;
$ ret . = "<td> </td>" ;
$ ret . = "<td>" . $ shutters - > getPartyMode . "</td>" ;
$ ret . = "<td> </td>" ;
$ ret . = "<td>" . $ shutters - > getLockOut . "</td>" ;
$ ret . = "<td> </td>" ;
2019-06-26 04:53:32 +00:00
$ ret . = "<td>"
. ReadingsVal ( $ shutter , 'ASC_ShuttersLastDrive' , 'none' ) . "</td>" ;
2018-10-28 17:12:40 +00:00
$ ret . = "<td> </td>" ;
$ ret . = "<td>" . $ shutters - > getStatus . "</td>" ;
$ ret . = "<td> </td>" ;
$ ret . = "<td>" . $ shutters - > getLastPos . "</td>" ;
2019-03-23 20:57:19 +00:00
$ ret . = "<td> </td>" ;
2019-04-09 10:13:46 +00:00
$ ret . = "<td>"
. $ shutters - > getShadingStatus . ' - '
. strftime ( "%H:%M:%S" ,
localtime ( $ shutters - > getShadingStatusTimestamp ) )
. "</td>" ;
2018-10-28 17:12:40 +00:00
$ ret . = '</tr>' ;
$ linecount + + ;
2018-09-21 06:44:38 +00:00
}
$ ret . = '</table></td></tr>' ;
$ ret . = '</table></html>' ;
return $ ret ;
}
2018-10-08 01:59:51 +00:00
sub GetMonitoredDevs ($) {
2018-10-14 16:19:23 +00:00
my $ hash = shift ;
my $ notifydevs = eval {
decode_json ( ReadingsVal ( $ hash - > { NAME } , '.monitoredDevs' , 'none' ) ) ;
} ;
2018-10-08 01:59:51 +00:00
my $ ret = '<html><table><tr><td>' ;
$ ret . = '<table class="block wide">' ;
$ ret . = '<tr class="even">' ;
2018-10-09 16:05:55 +00:00
$ ret . = "<td><b>Shutters/ASC-Device</b></td>" ;
2018-10-08 01:59:51 +00:00
$ ret . = "<td> </td>" ;
2018-10-09 16:05:55 +00:00
$ ret . = "<td><b>NOTIFYDEV</b></td>" ;
2018-10-08 01:59:51 +00:00
$ ret . = "<td> </td>" ;
$ ret . = "<td><b>Attribut</b></td>" ;
$ ret . = "<td> </td>" ;
$ ret . = '</tr>' ;
2018-10-14 16:19:23 +00:00
if ( ref ( $ notifydevs ) eq "HASH" ) {
2018-10-08 01:59:51 +00:00
my $ linecount = 1 ;
2018-10-14 16:19:23 +00:00
foreach my $ notifydev ( sort keys ( % { $ notifydevs } ) ) {
if ( ref ( $ notifydevs - > { $ notifydev } ) eq "HASH" ) {
foreach
my $ shutters ( sort keys ( % { $ notifydevs - > { $ notifydev } } ) )
{
if ( $ linecount % 2 == 0 ) { $ ret . = '<tr class="even">' ; }
else { $ ret . = '<tr class="odd">' ; }
2018-10-08 01:59:51 +00:00
$ ret . = "<td>$shutters</td>" ;
$ ret . = "<td> </td>" ;
2018-10-09 16:05:55 +00:00
$ ret . = "<td>$notifydev</td>" ;
$ ret . = "<td> </td>" ;
2018-10-08 01:59:51 +00:00
$ ret . = "<td>$notifydevs->{$notifydev}{$shutters}</td>" ;
$ ret . = "<td> </td>" ;
$ ret . = '</tr>' ;
$ linecount + + ;
}
}
}
}
$ ret . = '</table></td></tr>' ;
$ ret . = '</table></html>' ;
return $ ret ;
}
2018-08-27 09:08:08 +00:00
#################################
## my little helper
#################################
2019-06-23 13:51:37 +00:00
sub PositionValueWindowRec ($$) {
2019-06-25 11:19:22 +00:00
my ( $ shuttersDev , $ posValue ) = @ _ ;
2019-06-23 13:51:37 +00:00
2019-06-25 11:19:22 +00:00
if ( CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 1
and $ shutters - > getVentilateOpen eq 'on' )
2019-06-23 13:51:37 +00:00
{
$ posValue = $ shutters - > getVentilatePos ;
}
elsif ( CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 2
and $ shutters - > getSubTyp eq 'threestate'
2019-06-25 11:19:22 +00:00
and $ ascDev - > getAutoShuttersControlComfort eq 'on' )
2019-06-23 13:51:37 +00:00
{
$ posValue = $ shutters - > getComfortOpenPos ;
}
2019-06-25 11:19:22 +00:00
elsif (
CheckIfShuttersWindowRecOpen ( $ shuttersDev ) == 2
and ( $ shutters - > getSubTyp eq 'threestate'
or $ shutters - > getSubTyp eq 'twostate' )
2019-06-23 13:51:37 +00:00
and $ shutters - > getVentilateOpen eq 'on'
)
{
$ posValue = $ shutters - > getVentilatePos ;
}
2019-06-25 11:19:22 +00:00
if ( $ shutters - > getQueryShuttersPos ( $ posValue ) ) {
2019-06-23 13:51:37 +00:00
$ posValue = $ shutters - > getStatus ;
}
return $ posValue ;
}
2018-11-14 23:44:41 +00:00
sub AutoSearchTwilightDev ($) {
my $ hash = shift ;
my $ name = $ hash - > { NAME } ;
2018-11-19 08:06:50 +00:00
2018-11-14 23:44:41 +00:00
if ( devspec2array ( 'TYPE=(Astro|Twilight)' ) > 0 ) {
CommandAttr ( undef ,
$ name
2018-11-19 08:06:50 +00:00
. ' ASC_twilightDevice '
. ( devspec2array ( 'TYPE=(Astro|Twilight)' ) ) [ 0 ] )
if ( AttrVal ( $ name , 'ASC_twilightDevice' , 'none' ) eq 'none' ) ;
2018-11-14 23:44:41 +00:00
}
}
2019-03-06 14:53:48 +00:00
sub GetAttrValues ($@) {
2019-04-25 15:15:56 +00:00
my ( $ dev , $ attribut , $ default ) = @ _ ;
2019-03-06 14:53:48 +00:00
2019-04-25 19:34:46 +00:00
my @ values = split ( ' ' ,
AttrVal ( $ dev , $ attribut , ( defined ( $ default ) ? $ default : 'none' ) ) ) ;
2019-04-09 10:13:46 +00:00
my ( $ value1 , $ value2 ) = split ( ':' , $ values [ 0 ] ) ;
my ( $ value3 , $ value4 ) = split ( ':' , $ values [ 1 ] )
if ( defined ( $ values [ 1 ] ) ) ;
my ( $ value5 , $ value6 ) = split ( ':' , $ values [ 2 ] )
if ( defined ( $ values [ 2 ] ) ) ;
my ( $ value7 , $ value8 ) = split ( ':' , $ values [ 2 ] )
if ( defined ( $ values [ 3 ] ) ) ;
2019-03-12 22:02:02 +00:00
2019-04-09 10:13:46 +00:00
return (
$ value1 ,
defined ( $ value2 ) ? $ value2 : 'none' ,
defined ( $ value3 ) ? $ value3 : 'none' ,
defined ( $ value4 ) ? $ value4 : 'none' ,
defined ( $ value5 ) ? $ value5 : 'none' ,
defined ( $ value6 ) ? $ value6 : 'none' ,
defined ( $ value7 ) ? $ value7 : 'none' ,
defined ( $ value8 ) ? $ value8 : 'none'
) ;
2019-03-06 14:53:48 +00:00
}
2018-08-29 12:58:10 +00:00
# Hilfsfunktion welche meinen ReadingString zum finden der getriggerten Devices und der Zurdnung was das Device überhaupt ist und zu welchen Rolladen es gehört aus liest und das Device extraiert
2018-09-30 19:05:30 +00:00
sub ExtractNotifyDevFromEvent ($$$) {
2018-10-14 16:19:23 +00:00
my ( $ hash , $ shuttersDev , $ shuttersAttr ) = @ _ ;
2018-09-30 19:05:30 +00:00
my % notifyDevs ;
2018-10-14 16:19:23 +00:00
while ( my $ notifyDev = each % { $ hash - > { monitoredDevs } } ) {
Log3 ( $ hash - > { NAME } , 4 ,
"AutoShuttersControl ($hash->{NAME}) - ExtractNotifyDevFromEvent - NotifyDev: "
. $ notifyDev ) ;
Log3 ( $ hash - > { NAME } , 5 ,
"AutoShuttersControl ($hash->{NAME}) - ExtractNotifyDevFromEvent - ShuttersDev: "
. $ shuttersDev ) ;
if ( defined ( $ hash - > { monitoredDevs } { $ notifyDev } { $ shuttersDev } )
and $ hash - > { monitoredDevs } { $ notifyDev } { $ shuttersDev } eq
$ shuttersAttr )
{
Log3 ( $ hash - > { NAME } , 4 ,
"AutoShuttersControl ($hash->{NAME}) - ExtractNotifyDevFromEvent - ShuttersDevHash: "
. $ hash - > { monitoredDevs } { $ notifyDev } { $ shuttersDev } ) ;
Log3 ( $ hash - > { NAME } , 5 ,
"AutoShuttersControl ($hash->{NAME}) - ExtractNotifyDevFromEvent - return ShuttersDev: "
. $ notifyDev ) ;
2018-09-30 19:05:30 +00:00
$ notifyDevs { $ notifyDev } = $ shuttersDev ;
2018-08-27 09:08:08 +00:00
}
}
2018-09-30 19:05:30 +00:00
return \ % notifyDevs ;
2018-08-16 08:37:09 +00:00
}
2018-08-31 07:32:16 +00:00
## Ist Tag oder Nacht für den entsprechende Rolladen
2019-06-27 08:48:06 +00:00
sub _IsDay ($) {
2019-04-20 19:53:05 +00:00
my ( $ shuttersDev ) = @ _ ;
2019-02-22 09:02:48 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2019-02-22 09:56:24 +00:00
2019-04-20 19:53:05 +00:00
my $ isday = ( ShuttersSunrise ( $ shuttersDev , 'unix' ) >
ShuttersSunset ( $ shuttersDev , 'unix' ) ? 1 : 0 ) ;
2019-02-22 09:56:24 +00:00
my $ respIsDay = $ isday ;
2019-02-22 09:02:48 +00:00
2019-04-23 12:53:39 +00:00
ASC_Debug ( 'FnIsDay: ' . $ shuttersDev . ' Allgemein: ' . $ respIsDay ) ;
if (
(
2019-05-07 03:58:59 +00:00
$ shutters - > getModeDown eq 'brightness'
or $ shutters - > getModeUp eq 'brightness'
2019-04-23 12:53:39 +00:00
)
2019-05-07 03:58:59 +00:00
or (
2019-04-23 12:53:39 +00:00
(
2019-05-07 03:58:59 +00:00
(
(
int ( gettimeofday ( ) / 86400 ) != int (
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpEarly ) / 86400
)
and not IsWe ( )
)
or (
int ( gettimeofday ( ) / 86400 ) != int (
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpWeHoliday ) / 86400
)
and IsWe ( )
and $ ascDev - > getSunriseTimeWeHoliday eq 'on'
)
2019-04-23 12:53:39 +00:00
)
and int ( gettimeofday ( ) / 86400 ) == int (
computeAlignTime ( '24:00' , $ shutters - > getTimeUpLate ) /
86400
)
)
or (
int ( gettimeofday ( ) / 86400 ) != int (
computeAlignTime ( '24:00' , $ shutters - > getTimeDownEarly ) /
86400
)
and int ( gettimeofday ( ) / 86400 ) == int (
computeAlignTime ( '24:00' , $ shutters - > getTimeDownLate ) /
86400
)
)
)
)
2019-04-23 10:33:01 +00:00
{
my $ brightnessMinVal ;
if ( $ shutters - > getBrightnessMinVal > - 1 ) {
$ brightnessMinVal = $ shutters - > getBrightnessMinVal ;
}
else {
$ brightnessMinVal = $ ascDev - > getBrightnessMinVal ;
}
2019-02-22 09:16:24 +00:00
2019-04-23 10:33:01 +00:00
my $ brightnessMaxVal ;
if ( $ shutters - > getBrightnessMaxVal > - 1 ) {
$ brightnessMaxVal = $ shutters - > getBrightnessMaxVal ;
}
else {
$ brightnessMaxVal = $ ascDev - > getBrightnessMaxVal ;
}
2019-04-23 12:53:39 +00:00
2019-05-07 09:34:53 +00:00
##### Nach Sonnenuntergang / Abends
2019-04-23 10:33:01 +00:00
$ respIsDay = (
2019-04-09 10:13:46 +00:00
(
2019-05-07 09:34:53 +00:00
(
$ shutters - > getBrightness > $ brightnessMinVal
and $ isday
and not $ shutters - > getSunset
)
2019-05-07 03:58:59 +00:00
or not $ shutters - > getSunset
2019-04-23 10:33:01 +00:00
) ? 1 : 0
) if ( $ shutters - > getDown eq 'brightness' ) ;
2019-04-23 12:53:39 +00:00
2019-04-23 10:33:01 +00:00
ASC_Debug ( 'FnIsDay: '
2019-04-23 12:53:39 +00:00
. $ shuttersDev
. ' getDownBrightness: '
. $ respIsDay
. ' Brightness: '
. $ shutters - > getBrightness
. ' BrightnessMin: '
. $ brightnessMinVal
. ' Sunset: '
. $ shutters - > getSunset ) ;
2019-04-23 10:33:01 +00:00
2019-05-07 09:34:53 +00:00
##### Nach Sonnenauf / Morgens
2019-04-23 10:33:01 +00:00
$ respIsDay = (
(
2019-05-07 09:34:53 +00:00
(
$ shutters - > getBrightness > $ brightnessMaxVal
and not $ isday
and not $ shutters - > getSunrise
)
2019-04-23 12:53:39 +00:00
or $ respIsDay
or $ shutters - > getSunrise
2019-04-23 10:33:01 +00:00
) ? 1 : 0
) if ( $ shutters - > getUp eq 'brightness' ) ;
2019-04-23 12:53:39 +00:00
2019-04-23 10:33:01 +00:00
ASC_Debug ( 'FnIsDay: '
2019-04-23 12:53:39 +00:00
. $ shuttersDev
. ' getUpBrightness: '
. $ respIsDay
. ' Brightness: '
. $ shutters - > getBrightness
. ' BrightnessMax: '
. $ brightnessMaxVal
2019-05-07 03:58:59 +00:00
. ' Sunrise: '
2019-04-23 12:53:39 +00:00
. $ shutters - > getSunrise ) ;
2019-04-23 10:33:01 +00:00
}
2019-02-22 09:02:48 +00:00
return $ respIsDay ;
2018-08-31 07:32:16 +00:00
}
2019-04-20 19:53:05 +00:00
sub ShuttersSunrise ($$) {
my ( $ shuttersDev , $ tm ) =
2018-10-14 16:19:23 +00:00
@ _ ; # Tm steht für Timemode und bedeutet Realzeit oder Unixzeit
2018-09-13 06:11:10 +00:00
my $ autoAstroMode ;
2018-10-10 08:43:42 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2018-09-18 07:35:45 +00:00
2018-10-14 16:19:23 +00:00
if ( $ shutters - > getAutoAstroModeMorning ne 'none' ) {
$ autoAstroMode = $ shutters - > getAutoAstroModeMorning ;
$ autoAstroMode =
$ autoAstroMode . '=' . $ shutters - > getAutoAstroModeMorningHorizon
if ( $ autoAstroMode eq 'HORIZON' ) ;
}
else {
$ autoAstroMode = $ ascDev - > getAutoAstroModeMorning ;
$ autoAstroMode =
2018-11-03 18:01:29 +00:00
$ autoAstroMode . '=' . $ ascDev - > getAutoAstroModeMorningHorizon
2018-10-14 16:19:23 +00:00
if ( $ autoAstroMode eq 'HORIZON' ) ;
2018-09-13 13:21:29 +00:00
}
2018-10-14 16:19:23 +00:00
my $ oldFuncHash = $ shutters - > getInTimerFuncHash ;
2019-09-06 16:40:10 +00:00
my $ shuttersSunriseUnixtime =
computeAlignTime ( '24:00' , sunrise ( 'REAL' , 0 , '4:30' , '8:30' ) ) ;
2018-08-28 17:49:01 +00:00
2018-10-14 16:19:23 +00:00
if ( $ tm eq 'unix' ) {
2018-11-03 18:01:29 +00:00
if ( $ shutters - > getUp eq 'astro' ) {
2018-10-14 16:19:23 +00:00
if ( ( IsWe ( ) or IsWeTomorrow ( ) )
2018-10-31 08:55:49 +00:00
and $ ascDev - > getSunriseTimeWeHoliday eq 'on' )
2018-10-14 16:19:23 +00:00
{
if ( not IsWeTomorrow ( ) ) {
2018-10-31 08:58:23 +00:00
if (
IsWe ( )
2018-10-31 08:55:49 +00:00
and int ( gettimeofday ( ) / 86400 ) == int (
(
computeAlignTime (
'24:00' ,
sunrise_abs (
2018-10-31 08:58:23 +00:00
$ autoAstroMode , 0 ,
2018-10-31 08:55:49 +00:00
$ shutters - > getTimeUpWeHoliday
)
) + 1
) / 86400
)
)
{
$ shuttersSunriseUnixtime = (
computeAlignTime (
'24:00' ,
sunrise_abs (
$ autoAstroMode , 0 ,
$ shutters - > getTimeUpWeHoliday
)
) + 1
) ;
}
elsif (
2018-10-14 16:19:23 +00:00
int ( gettimeofday ( ) / 86400 ) == int (
(
computeAlignTime (
'24:00' ,
sunrise_abs (
$ autoAstroMode ,
0 ,
$ shutters - > getTimeUpEarly ,
$ shutters - > getTimeUpLate
)
) + 1
) / 86400
)
)
{
$ shuttersSunriseUnixtime = (
computeAlignTime (
'24:00' ,
sunrise_abs (
$ autoAstroMode , 0 ,
$ shutters - > getTimeUpWeHoliday
)
) + 1
) ;
2018-09-24 13:29:39 +00:00
}
2018-10-14 16:19:23 +00:00
else {
$ shuttersSunriseUnixtime = (
computeAlignTime (
'24:00' ,
sunrise_abs (
$ autoAstroMode ,
0 ,
$ shutters - > getTimeUpEarly ,
$ shutters - > getTimeUpLate
)
) + 1
) ;
2018-09-24 13:29:39 +00:00
}
}
2018-10-14 16:19:23 +00:00
else {
2019-04-09 10:12:13 +00:00
if (
IsWe ( )
2019-04-09 10:13:46 +00:00
and (
int ( gettimeofday ( ) / 86400 ) == int (
(
computeAlignTime (
'24:00' ,
sunrise_abs (
$ autoAstroMode , 0 ,
$ shutters - > getTimeUpWeHoliday
)
) + 1
) / 86400
)
or int ( gettimeofday ( ) / 86400 ) != int (
(
computeAlignTime (
'24:00' ,
sunrise_abs (
$ autoAstroMode , 0 ,
$ shutters - > getTimeUpWeHoliday
)
) + 1
) / 86400
)
2019-04-09 10:12:13 +00:00
)
)
{
$ shuttersSunriseUnixtime = (
computeAlignTime (
'24:00' ,
sunrise_abs (
$ autoAstroMode , 0 ,
$ shutters - > getTimeUpWeHoliday
)
) + 1
) ;
}
elsif (
int ( gettimeofday ( ) / 86400 ) == int (
(
computeAlignTime (
'24:00' ,
sunrise_abs (
$ autoAstroMode ,
0 ,
$ shutters - > getTimeUpEarly ,
$ shutters - > getTimeUpLate
)
) + 1
) / 86400
)
)
{
$ shuttersSunriseUnixtime = (
computeAlignTime (
'24:00' ,
sunrise_abs (
2019-04-09 10:13:46 +00:00
$ autoAstroMode ,
0 ,
2019-04-09 10:12:13 +00:00
$ shutters - > getTimeUpEarly ,
$ shutters - > getTimeUpLate
)
) + 1
) ;
}
else {
if (
2019-04-09 10:13:46 +00:00
int ( gettimeofday ( ) / 86400 ) == int (
2019-04-09 10:12:13 +00:00
(
computeAlignTime (
'24:00' ,
sunrise_abs (
$ autoAstroMode , 0 ,
$ shutters - > getTimeUpWeHoliday
)
) + 1
) / 86400
2019-04-09 10:13:46 +00:00
)
2019-04-09 10:12:13 +00:00
)
{
$ shuttersSunriseUnixtime = (
computeAlignTime (
'24:00' ,
sunrise_abs (
$ autoAstroMode , 0 ,
$ shutters - > getTimeUpWeHoliday
)
) + 86401
) ;
}
else {
$ shuttersSunriseUnixtime = (
computeAlignTime (
'24:00' ,
sunrise_abs (
$ autoAstroMode , 0 ,
$ shutters - > getTimeUpWeHoliday
)
) + 1
) ;
}
}
2019-04-09 10:13:46 +00:00
}
2018-09-18 07:35:45 +00:00
}
2018-10-14 16:19:23 +00:00
else {
$ shuttersSunriseUnixtime = (
computeAlignTime (
'24:00' ,
sunrise_abs (
$ autoAstroMode ,
0 ,
$ shutters - > getTimeUpEarly ,
$ shutters - > getTimeUpLate
)
) + 1
) ;
}
if ( defined ( $ oldFuncHash )
and ref ( $ oldFuncHash ) eq 'HASH'
and ( IsWe ( ) or IsWeTomorrow ( ) )
2018-10-31 08:55:49 +00:00
and $ ascDev - > getSunriseTimeWeHoliday eq 'on' )
2018-10-14 16:19:23 +00:00
{
if ( not IsWeTomorrow ( ) ) {
if (
int ( gettimeofday ( ) / 86400 ) == int (
(
computeAlignTime (
'24:00' ,
sunrise_abs (
$ autoAstroMode ,
0 ,
$ shutters - > getTimeUpEarly ,
$ shutters - > getTimeUpLate
)
) + 1
) / 86400
)
)
{
2019-04-09 07:37:34 +00:00
$ shuttersSunriseUnixtime =
( $ shuttersSunriseUnixtime + 86400 )
2018-10-14 16:19:23 +00:00
if ( $ shuttersSunriseUnixtime <
( $ oldFuncHash - > { sunrisetime } + 180 )
and $ oldFuncHash - > { sunrisetime } < gettimeofday ( ) ) ;
2018-09-27 08:19:41 +00:00
}
}
2018-09-07 09:02:46 +00:00
}
2018-10-14 16:19:23 +00:00
elsif ( defined ( $ oldFuncHash ) and ref ( $ oldFuncHash ) eq 'HASH' ) {
2019-04-09 07:37:34 +00:00
$ shuttersSunriseUnixtime = ( $ shuttersSunriseUnixtime + 86400 )
2018-10-14 16:19:23 +00:00
if ( $ shuttersSunriseUnixtime <
( $ oldFuncHash - > { sunrisetime } + 180 )
and $ oldFuncHash - > { sunrisetime } < gettimeofday ( ) ) ;
}
}
2018-11-03 18:01:29 +00:00
elsif ( $ shutters - > getUp eq 'time' ) {
2018-11-17 16:10:45 +00:00
if ( ( IsWe ( ) or IsWeTomorrow ( ) )
and $ ascDev - > getSunriseTimeWeHoliday eq 'on' )
{
if ( not IsWeTomorrow ( ) ) {
if (
2019-05-28 06:39:52 +00:00
int ( gettimeofday ( ) / 86400 ) == int (
2018-11-19 11:16:54 +00:00
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpWeHoliday ) / 86400
)
2018-11-19 08:06:50 +00:00
)
2018-11-17 16:10:45 +00:00
{
$ shuttersSunriseUnixtime =
2018-11-19 08:06:50 +00:00
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpWeHoliday ) ;
2018-11-17 16:10:45 +00:00
}
elsif (
int ( gettimeofday ( ) / 86400 ) == int (
2018-11-19 11:16:54 +00:00
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpEarly ) / 86400
)
2019-05-28 06:39:52 +00:00
and $ shutters - > getSunrise
2018-11-19 08:06:50 +00:00
)
2018-11-17 16:10:45 +00:00
{
$ shuttersSunriseUnixtime =
2019-05-28 07:27:13 +00:00
computeAlignTime ( '24:00' , $ shutters - > getTimeUpEarly )
+ 86400 ;
2018-11-17 16:10:45 +00:00
}
else {
$ shuttersSunriseUnixtime =
2018-11-19 08:06:50 +00:00
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpEarly ) ;
2018-11-17 16:10:45 +00:00
}
}
else {
2019-05-03 09:03:28 +00:00
if (
IsWe ( )
2019-05-03 11:36:39 +00:00
and int ( gettimeofday ( ) / 86400 ) == int (
2019-05-03 09:03:28 +00:00
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpWeHoliday ) / 86400
)
)
{
$ shuttersSunriseUnixtime =
2019-05-03 11:36:39 +00:00
computeAlignTime ( '24:00' ,
2019-05-03 09:03:28 +00:00
$ shutters - > getTimeUpWeHoliday ) ;
}
elsif (
int ( gettimeofday ( ) / 86400 ) == int (
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpEarly ) / 86400
)
)
{
$ shuttersSunriseUnixtime =
2019-05-03 11:36:39 +00:00
computeAlignTime ( '24:00' ,
2019-05-03 09:03:28 +00:00
$ shutters - > getTimeUpEarly ) ;
}
2019-05-28 06:39:52 +00:00
elsif (
int ( gettimeofday ( ) / 86400 ) != int (
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpWeHoliday ) / 86400
)
)
{
$ shuttersSunriseUnixtime =
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpWeHoliday ) ;
}
2019-05-03 09:03:28 +00:00
else {
$ shuttersSunriseUnixtime =
2019-05-03 11:36:39 +00:00
computeAlignTime ( '24:00' ,
$ shutters - > getTimeUpWeHoliday ) + 86400 ;
2019-05-03 09:03:28 +00:00
}
2018-11-17 16:10:45 +00:00
}
}
else {
$ shuttersSunriseUnixtime =
2018-11-19 08:06:50 +00:00
computeAlignTime ( '24:00' , $ shutters - > getTimeUpEarly ) ;
2018-11-17 16:10:45 +00:00
}
2018-10-14 16:19:23 +00:00
}
2018-11-03 18:01:29 +00:00
elsif ( $ shutters - > getUp eq 'brightness' ) {
2018-10-14 16:19:23 +00:00
$ shuttersSunriseUnixtime =
2018-11-19 08:06:50 +00:00
computeAlignTime ( '24:00' , $ shutters - > getTimeUpLate ) ;
2018-09-07 09:02:46 +00:00
}
return $ shuttersSunriseUnixtime ;
2018-10-14 16:19:23 +00:00
}
elsif ( $ tm eq 'real' ) {
return sunrise_abs ( $ autoAstroMode , 0 , $ shutters - > getTimeUpEarly ,
$ shutters - > getTimeUpLate )
2018-11-03 18:01:29 +00:00
if ( $ shutters - > getUp eq 'astro' ) ;
return $ shutters - > getTimeUpEarly if ( $ shutters - > getUp eq 'time' ) ;
2018-08-31 07:32:16 +00:00
}
2018-08-28 17:49:01 +00:00
}
2019-04-20 19:53:05 +00:00
sub IsAfterShuttersTimeBlocking ($) {
my ( $ shuttersDev ) = @ _ ;
2018-12-07 11:57:45 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
if (
2018-12-07 12:04:41 +00:00
( int ( gettimeofday ( ) ) - $ shutters - > getLastManPosTimestamp ) <
$ shutters - > getBlockingTimeAfterManual
2019-08-14 08:06:05 +00:00
or ( not $ shutters - > getIsDay
2019-08-09 19:19:02 +00:00
and defined ( $ shutters - > getSunriseUnixTime )
2018-12-07 12:04:41 +00:00
and $ shutters - > getSunriseUnixTime - ( int ( gettimeofday ( ) ) ) <
$ shutters - > getBlockingTimeBeforDayOpen )
2019-06-27 08:48:06 +00:00
or ( $ shutters - > getIsDay
2019-08-09 19:19:02 +00:00
and defined ( $ shutters - > getSunriseUnixTime )
2018-12-07 12:04:41 +00:00
and $ shutters - > getSunsetUnixTime - ( int ( gettimeofday ( ) ) ) <
$ shutters - > getBlockingTimeBeforNightClose )
2019-01-02 08:38:00 +00:00
)
2019-01-01 17:54:08 +00:00
{
return 0 ;
}
else { return 1 }
}
sub IsAfterShuttersManualBlocking ($) {
my $ shuttersDev = shift ;
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2019-04-09 10:13:46 +00:00
if ( $ ascDev - > getblockAscDrivesAfterManual
and $ shutters - > getStatus != $ shutters - > getOpenPos
and $ shutters - > getStatus != $ shutters - > getClosedPos
and $ shutters - > getStatus != $ shutters - > getWindPos
and $ shutters - > getStatus != $ shutters - > getShadingPos
and $ shutters - > getStatus != $ shutters - > getComfortOpenPos
and $ shutters - > getStatus != $ shutters - > getVentilatePos
and $ shutters - > getStatus != $ shutters - > getAntiFreezePos
and $ shutters - > getLastDrive eq 'manual' )
2019-03-27 10:22:06 +00:00
{
return 0 ;
}
elsif ( ( int ( gettimeofday ( ) ) - $ shutters - > getLastManPosTimestamp ) <
2019-01-02 08:38:00 +00:00
$ shutters - > getBlockingTimeAfterManual )
2018-12-07 12:04:41 +00:00
{
return 0 ;
}
2018-12-07 11:57:45 +00:00
else { return 1 }
}
2019-04-20 19:53:05 +00:00
sub ShuttersSunset ($$) {
my ( $ shuttersDev , $ tm ) =
2018-10-14 16:19:23 +00:00
@ _ ; # Tm steht für Timemode und bedeutet Realzeit oder Unixzeit
2018-09-13 06:11:10 +00:00
my $ autoAstroMode ;
2018-10-10 08:43:42 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2018-09-18 07:35:45 +00:00
2018-10-14 16:19:23 +00:00
if ( $ shutters - > getAutoAstroModeEvening ne 'none' ) {
$ autoAstroMode = $ shutters - > getAutoAstroModeEvening ;
$ autoAstroMode =
$ autoAstroMode . '=' . $ shutters - > getAutoAstroModeEveningHorizon
if ( $ autoAstroMode eq 'HORIZON' ) ;
2018-09-13 13:21:29 +00:00
}
2018-10-14 16:19:23 +00:00
else {
$ autoAstroMode = $ ascDev - > getAutoAstroModeEvening ;
$ autoAstroMode =
2018-11-03 18:01:29 +00:00
$ autoAstroMode . '=' . $ ascDev - > getAutoAstroModeEveningHorizon
2018-10-14 16:19:23 +00:00
if ( $ autoAstroMode eq 'HORIZON' ) ;
2018-09-13 13:21:29 +00:00
}
2018-10-14 16:19:23 +00:00
my $ oldFuncHash = $ shutters - > getInTimerFuncHash ;
2019-09-06 16:40:10 +00:00
my $ shuttersSunsetUnixtime =
computeAlignTime ( '24:00' , sunset ( 'REAL' , 0 , '15:30' , '21:30' ) ) ;
2018-08-31 07:32:16 +00:00
2018-10-14 16:19:23 +00:00
if ( $ tm eq 'unix' ) {
2018-11-03 18:01:29 +00:00
if ( $ shutters - > getDown eq 'astro' ) {
2018-10-14 16:19:23 +00:00
$ shuttersSunsetUnixtime = (
computeAlignTime (
'24:00' ,
sunset_abs (
$ autoAstroMode ,
0 ,
$ shutters - > getTimeDownEarly ,
$ shutters - > getTimeDownLate
)
) + 1
) ;
if ( defined ( $ oldFuncHash ) and ref ( $ oldFuncHash ) eq 'HASH' ) {
2019-03-31 15:17:56 +00:00
$ shuttersSunsetUnixtime += 86400
2018-10-14 16:19:23 +00:00
if ( $ shuttersSunsetUnixtime <
( $ oldFuncHash - > { sunsettime } + 180 )
and $ oldFuncHash - > { sunsettime } < gettimeofday ( ) ) ;
2018-09-07 09:02:46 +00:00
}
}
2018-11-03 18:01:29 +00:00
elsif ( $ shutters - > getDown eq 'time' ) {
2018-10-14 16:19:23 +00:00
$ shuttersSunsetUnixtime =
computeAlignTime ( '24:00' , $ shutters - > getTimeDownEarly ) ;
}
2018-11-03 18:01:29 +00:00
elsif ( $ shutters - > getDown eq 'brightness' ) {
2018-10-14 16:19:23 +00:00
$ shuttersSunsetUnixtime =
computeAlignTime ( '24:00' , $ shutters - > getTimeDownLate ) ;
}
2018-09-07 09:02:46 +00:00
return $ shuttersSunsetUnixtime ;
2018-10-14 16:19:23 +00:00
}
elsif ( $ tm eq 'real' ) {
return sunset_abs (
$ autoAstroMode , 0 ,
$ shutters - > getTimeDownEarly ,
$ shutters - > getTimeDownLate
2018-11-03 18:01:29 +00:00
) if ( $ shutters - > getDown eq 'astro' ) ;
2018-10-14 16:19:23 +00:00
return $ shutters - > getTimeDownEarly
2018-11-03 18:01:29 +00:00
if ( $ shutters - > getDown eq 'time' ) ;
2018-08-31 07:32:16 +00:00
}
}
2018-08-29 12:58:10 +00:00
## Kontrolliert ob das Fenster von einem bestimmten Rolladen offen ist
2018-08-28 17:49:01 +00:00
sub CheckIfShuttersWindowRecOpen ($) {
my $ shuttersDev = shift ;
2018-10-10 08:43:42 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2018-08-28 17:49:01 +00:00
2019-11-08 08:31:41 +00:00
if ( $ shutters - > getWinStatus =~ /[Oo]pen|false/ ) # CK: covers: open|opened
2019-04-09 10:13:46 +00:00
{
return 2 ;
}
2019-05-24 09:36:06 +00:00
elsif ( $ shutters - > getWinStatus =~ /tilt/
2019-11-08 08:31:41 +00:00
and $ shutters - > getSubTyp eq 'threestate' ) # CK: covers: tilt|tilted
2018-10-14 16:19:23 +00:00
{
2018-08-28 17:49:01 +00:00
return 1 ;
}
2019-11-07 18:28:01 +00:00
elsif ( $ shutters - > getWinStatus =~ /[Cc]lose|true/ ) {
2019-05-24 09:36:06 +00:00
return 0 ;
2019-11-08 08:31:41 +00:00
} # CK: covers: close|closed
2018-08-28 17:49:01 +00:00
}
2018-09-07 12:10:46 +00:00
sub makeReadingName ($) {
2019-04-05 06:07:26 +00:00
my ( $ rname ) = @ _ ;
2018-10-14 16:19:23 +00:00
my % charHash = (
2019-11-08 08:31:41 +00:00
chr ( 0xe4 ) = > "ae" , # ä
chr ( 0xc4 ) = > "Ae" , # Ä
chr ( 0xfc ) = > "ue" , # ü
chr ( 0xdc ) = > "Ue" , # Ü
chr ( 0xf6 ) = > "oe" , # ö
chr ( 0xd6 ) = > "Oe" , # Ö
chr ( 0xdf ) = > "ss" # ß
2018-10-14 16:19:23 +00:00
) ;
2019-08-09 17:31:24 +00:00
my $ charHashkeys = join ( "" , keys ( % charHash ) ) ;
2018-10-14 16:19:23 +00:00
2019-04-05 06:07:26 +00:00
return $ rname if ( $ rname =~ m/^\./ ) ;
2019-08-09 17:31:24 +00:00
$ rname =~ s/([$charHashkeys])/$charHash{$1}/gi ;
2019-04-05 06:07:26 +00:00
$ rname =~ s/[^a-z0-9._\-\/]/_/gi ;
return $ rname ;
2018-09-07 12:10:46 +00:00
}
2018-09-14 18:46:55 +00:00
sub TimeMin2Sec ($) {
my $ min = shift ;
my $ sec ;
2018-10-14 16:19:23 +00:00
$ sec = $ min * 60 ;
2018-09-14 18:46:55 +00:00
return $ sec ;
}
2018-09-18 07:35:45 +00:00
sub IsWe () {
2019-03-25 10:23:49 +00:00
my $ we = main:: IsWe ( ) ;
2018-10-14 16:19:23 +00:00
return $ we ;
2018-09-18 07:35:45 +00:00
}
sub IsWeTomorrow () {
2019-03-25 10:23:49 +00:00
my $ we = main:: IsWe ( 'tomorrow' ) ;
2018-10-14 16:19:23 +00:00
return $ we ;
2018-09-18 07:35:45 +00:00
}
2019-07-03 09:54:01 +00:00
sub _SetCmdFn ($) {
2019-10-24 08:41:38 +00:00
my $ h = shift ;
my $ shuttersDev = $ h - > { shuttersDev } ;
my $ posValue = $ h - > { posValue } ;
2018-10-30 18:10:50 +00:00
2018-10-30 07:18:09 +00:00
$ shutters - > setShuttersDev ( $ shuttersDev ) ;
2018-12-05 08:11:45 +00:00
$ shutters - > setLastDrive ( $ h - > { lastDrive } )
if ( defined ( $ h - > { lastDrive } ) ) ;
2018-11-28 12:11:32 +00:00
2019-09-22 07:07:24 +00:00
my $ idleDetectionValue = $ shutters - > getIdleDetectionValue ;
my $ idleDetection = $ shutters - > getIdleDetection ;
2018-11-20 09:35:10 +00:00
return
2019-09-20 12:03:13 +00:00
unless (
$ shutters - > getASCenable eq 'on'
2019-09-20 10:53:52 +00:00
and $ ascDev - > getASCenable eq 'on'
2019-09-20 12:03:13 +00:00
and ( $ idleDetection =~ /^$idleDetectionValue$/
or $ idleDetection eq 'none' )
2019-09-20 10:53:52 +00:00
) ;
2018-11-20 09:35:10 +00:00
2018-11-04 11:27:46 +00:00
if ( $ shutters - > getStatus != $ posValue ) {
$ shutters - > setLastPos ( $ shutters - > getStatus ) ;
2018-11-04 20:31:05 +00:00
}
else {
2018-11-04 11:27:46 +00:00
$ shutters - > setLastDrive (
ReadingsVal ( $ shuttersDev , 'ASC_ShuttersLastDrive' , 'none' ) ) ;
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'FnSetCmdFn: '
. $ shuttersDev
. ' - Abbruch aktuelle Position ist gleich der Zielposition '
. $ shutters - > getStatus . '='
. $ posValue ) ;
2019-04-02 17:28:54 +00:00
return ;
2018-11-04 11:27:46 +00:00
}
2019-04-09 10:13:46 +00:00
ASC_Debug ( 'FnSetCmdFn: '
. $ shuttersDev
2019-08-22 17:42:46 +00:00
. ' - Rollo wird gefahren, aktuelle Position: '
2019-04-09 10:13:46 +00:00
. $ shutters - > getStatus
. ', Zielposition: '
. $ posValue
. '. Grund der Fahrt: '
. $ shutters - > getLastDrive ) ;
2018-10-30 07:18:09 +00:00
CommandSet ( undef ,
$ shuttersDev
. ':FILTER='
. $ shutters - > getPosCmd . '!='
. $ posValue . ' '
2018-11-07 07:22:11 +00:00
. $ shutters - > getPosSetCmd . ' '
2018-10-30 07:18:09 +00:00
. $ posValue ) ;
2019-06-25 10:24:25 +00:00
2019-06-25 11:19:22 +00:00
$ shutters - > setSelfDefenseAbsent ( 0 , 0 )
2019-06-25 10:24:25 +00:00
if ( not $ shutters - > getSelfDefenseAbsent
and $ shutters - > getSelfDefenseAbsentTimerrun ) ;
2018-10-30 07:18:09 +00:00
}
2019-07-03 09:54:01 +00:00
sub _setShuttersLastDriveDelayed ($) {
my $ h = shift ;
2019-07-03 09:54:48 +00:00
2019-07-03 09:54:01 +00:00
my $ shuttersDevHash = $ h - > { devHash } ;
my $ lastDrive = $ h - > { lastDrive } ;
2019-07-03 09:54:48 +00:00
readingsSingleUpdate ( $ shuttersDevHash , 'ASC_ShuttersLastDrive' ,
$ lastDrive , 1 ) ;
2019-07-03 09:54:01 +00:00
}
2019-04-02 17:28:54 +00:00
sub ASC_Debug ($) {
return
2019-04-09 10:13:46 +00:00
unless ( AttrVal ( $ ascDev - > getName , 'ASC_debug' , 0 ) ) ;
2019-04-02 17:28:54 +00:00
my $ debugMsg = shift ;
2019-04-09 10:13:46 +00:00
my $ debugTimestamp = strftime ( "%Y.%m.%e %T" , localtime ( time ) ) ;
print (
2019-08-26 08:34:11 +00:00
encode_utf8 (
"\n" . 'ASC_DEBUG!!! ' . $ debugTimestamp . ' - ' . $ debugMsg . "\n"
)
) ;
2019-04-02 17:28:54 +00:00
}
2019-09-02 12:34:42 +00:00
sub _averageBrightness (@) {
my @ input = @ _ ;
use List::Util qw( sum ) ;
return int ( sum ( @ input ) / @ input ) ;
2019-04-02 17:28:54 +00:00
}
2019-09-20 06:34:04 +00:00
sub _perlCodeCheck ($) {
my $ exec = shift ;
2019-09-20 12:03:13 +00:00
my $ val = undef ;
2019-09-18 12:55:17 +00:00
if ( $ exec =~ /^\{(.+)\}$/ ) {
2019-09-20 12:03:13 +00:00
$ val = main:: AnalyzePerlCommand ( undef , $ 1 ) ;
2019-09-18 12:55:17 +00:00
}
return $ val ;
}
2019-10-30 11:43:57 +00:00
sub PrivacyUpTime ($$) {
my ( $ shuttersDevHash , $ shuttersSunriseUnixtime ) = @ _ ;
my $ privacyUpUnixtime ;
if ( ( $ shuttersSunriseUnixtime - $ shutters - > getPrivacyUpTime ) >
2019-10-30 14:07:23 +00:00
( gettimeofday ( ) + 1 )
or $ shutters - > getPrivacyUpStatus == 2 )
2019-10-30 11:43:57 +00:00
{
$ privacyUpUnixtime =
$ shuttersSunriseUnixtime - $ shutters - > getPrivacyUpTime ;
$ privacyUpUnixtime += 86400
if ( $ shutters - > getPrivacyUpStatus == 2 ) ;
readingsSingleUpdate ( $ shuttersDevHash , 'ASC_Time_PrivacyDriveUp' ,
strftime ( "%e.%m.%Y - %H:%M" , localtime ( $ privacyUpUnixtime ) ) , 1 ) ;
2019-10-31 06:17:04 +00:00
## Setzt den PrivacyUp Modus für die Sichtschutzfahrt auf den Status 1
2019-10-30 11:43:57 +00:00
## und gibt die Unixtime für die nächste Fahrt korrekt zurück
unless ( $ shutters - > getPrivacyUpStatus == 2 ) {
$ shutters - > setPrivacyUpStatus ( 1 ) ;
$ shuttersSunriseUnixtime = $ privacyUpUnixtime ;
}
}
2019-10-31 15:35:11 +00:00
else {
readingsSingleUpdate (
$ shuttersDevHash ,
'ASC_Time_PrivacyDriveUp' ,
strftime (
"%e.%m.%Y - %H:%M" ,
localtime (
( $ shuttersSunriseUnixtime - $ shutters - > getPrivacyUpTime )
+ 86400
)
) ,
1
) ;
}
2019-10-30 11:43:57 +00:00
return $ shuttersSunriseUnixtime ;
}
sub PrivacyDownTime ($$) {
my ( $ shuttersDevHash , $ shuttersSunsetUnixtime ) = @ _ ;
2019-10-31 06:17:04 +00:00
my $ privacyDownUnixtime ;
2019-10-30 11:43:57 +00:00
if ( ( $ shuttersSunsetUnixtime - $ shutters - > getPrivacyDownTime ) >
2019-10-31 06:17:04 +00:00
( gettimeofday ( ) + 1 )
or $ shutters - > getPrivacyDownStatus == 2 )
2019-10-30 11:43:57 +00:00
{
2019-10-31 06:17:04 +00:00
$ privacyDownUnixtime =
2019-10-30 11:43:57 +00:00
$ shuttersSunsetUnixtime - $ shutters - > getPrivacyDownTime ;
2019-10-31 06:17:04 +00:00
$ privacyDownUnixtime += 86400
if ( $ shutters - > getPrivacyDownStatus == 2 ) ;
readingsSingleUpdate ( $ shuttersDevHash , 'ASC_Time_PrivacyDriveDown' ,
strftime ( "%e.%m.%Y - %H:%M" , localtime ( $ privacyDownUnixtime ) ) ,
1 ) ;
2019-10-30 11:43:57 +00:00
## Setzt den PrivacyDown Modus für die Sichtschutzfahrt auf den Status 1
2019-10-31 06:17:04 +00:00
## und gibt die Unixtime für die nächste Fahrt korrekt zurück
unless ( $ shutters - > getPrivacyDownStatus == 2 ) {
$ shutters - > setPrivacyDownStatus ( 1 ) ;
$ shuttersSunsetUnixtime = $ privacyDownUnixtime ;
}
2019-10-30 11:43:57 +00:00
}
2019-10-31 15:35:11 +00:00
else {
readingsSingleUpdate (
$ shuttersDevHash ,
'ASC_Time_PrivacyDriveDown' ,
strftime (
"%e.%m.%Y - %H:%M" ,
localtime (
( $ shuttersSunsetUnixtime - $ shutters - > getPrivacyDownTime )
+ 86400
)
) ,
1
) ;
}
2019-10-30 11:43:57 +00:00
return $ shuttersSunsetUnixtime ;
}
2019-11-11 18:16:47 +00:00
sub _IsAdv {
my ( undef , undef , undef , $ monthday , $ month , $ year , undef , undef , undef ) =
localtime ( gettimeofday ( ) ) ;
my $ adv = 0 ;
$ year += 1900 ;
if ( $ month < 1 ) {
if ( $ monthday < 7 ) {
$ adv = 1 ;
}
}
else {
my $ time = HTTP::Date:: str2time ( $ year . '-12-25' ) ;
my $ wday = ( localtime ( $ time ) ) [ 6 ] ;
$ wday = $ wday ? $ wday : 7 ;
$ time -= ( $ wday + 21 ) * 86400 ;
$ adv = 1 if ( $ time < time ) ;
}
return $ adv ;
}
2019-04-02 17:28:54 +00:00
######################################
######################################
2018-10-28 17:12:40 +00:00
########## Begin der Klassendeklarierungen für OOP (Objektorientierte Programmierung) #########################
2018-10-10 08:43:42 +00:00
## Klasse Rolläden (Shutters) und die Subklassen Attr und Readings ##
## desweiteren wird noch die Klasse ASC_Roommate mit eingebunden
2019-04-02 17:28:54 +00:00
2018-10-10 08:43:42 +00:00
package ASC_Shutters ;
2018-10-14 16:19:23 +00:00
our @ ISA =
qw( ASC_Shutters::Readings ASC_Shutters::Attr ASC_Roommate ASC_Window ) ;
2018-10-08 19:05:47 +00:00
use strict ;
use warnings ;
2018-11-07 07:22:11 +00:00
use GPUtils qw( GP_Import ) ;
2018-10-14 16:19:23 +00:00
## Import der FHEM Funktionen
BEGIN {
GP_Import (
qw(
defs
ReadingsVal
readingsSingleUpdate
2018-10-30 07:18:09 +00:00
gettimeofday
2018-11-21 07:38:32 +00:00
InternalTimer
2019-03-31 15:17:56 +00:00
CommandSet
Log3 )
2018-10-14 16:19:23 +00:00
) ;
}
2018-10-08 19:05:47 +00:00
sub new {
2018-10-14 16:19:23 +00:00
my $ class = shift ;
my $ self = {
shuttersDev = > undef ,
defaultarg = > undef ,
roommate = > undef ,
} ;
2018-10-08 19:05:47 +00:00
bless $ self , $ class ;
return $ self ;
}
2018-10-10 08:43:42 +00:00
sub setShuttersDev {
2018-10-14 16:19:23 +00:00
my ( $ self , $ shuttersDev ) = @ _ ;
2018-10-17 07:50:11 +00:00
2018-10-14 16:19:23 +00:00
$ self - > { shuttersDev } = $ shuttersDev if ( defined ( $ shuttersDev ) ) ;
2018-10-10 08:43:42 +00:00
return $ self - > { shuttersDev } ;
2018-10-08 19:05:47 +00:00
}
2018-10-27 11:36:11 +00:00
sub getShuttersDev {
my $ self = shift ;
return $ self - > { shuttersDev } ;
}
2019-09-06 16:36:48 +00:00
sub setAttrUpdateChanges {
my ( $ self , $ attr , $ value ) = @ _ ;
2019-09-06 16:40:10 +00:00
2019-09-06 16:36:48 +00:00
$ self - > { $ self - > { shuttersDev } } { AttrUpdateChanges } { $ attr } = $ value ;
return 0 ;
}
2018-11-21 07:38:32 +00:00
sub setHardLockOut {
my ( $ self , $ cmd ) = @ _ ;
2018-11-28 12:11:32 +00:00
if ( $ shutters - > getLockOut eq 'hard'
and $ shutters - > getLockOutCmd ne 'none' )
2018-11-21 07:38:32 +00:00
{
2018-11-21 08:52:02 +00:00
CommandSet ( undef , $ self - > { shuttersDev } . ' inhibit ' . $ cmd )
2018-11-28 12:11:32 +00:00
if ( $ shutters - > getLockOutCmd eq 'inhibit' ) ;
2018-11-21 07:38:32 +00:00
CommandSet ( undef ,
2018-11-28 12:11:32 +00:00
$ self - > { shuttersDev } . ' '
. ( $ cmd eq 'on' ? 'blocked' : 'unblocked' ) )
if ( $ shutters - > getLockOutCmd eq 'blocked' ) ;
2018-11-21 07:38:32 +00:00
CommandSet ( undef ,
2018-11-28 12:11:32 +00:00
$ self - > { shuttersDev } . ' '
. ( $ cmd eq 'on' ? 'protectionOn' : 'protectionOff' ) )
2019-06-03 05:44:35 +00:00
if ( $ shutters - > getLockOutCmd eq 'protected' ) ;
2018-11-21 07:38:32 +00:00
}
return 0 ;
}
2019-09-17 14:52:19 +00:00
sub setNoDelay {
my ( $ self , $ noDelay ) = @ _ ;
2018-11-07 07:22:11 +00:00
2019-09-17 14:52:19 +00:00
$ self - > { $ self - > { shuttersDev } } { noDelay } = $ noDelay ;
2018-11-07 07:22:11 +00:00
return 0 ;
}
2019-06-25 10:24:25 +00:00
sub setSelfDefenseAbsent {
my ( $ self , $ timerrun , $ active , $ timerhash ) = @ _ ;
2019-06-25 11:19:22 +00:00
$ self - > { $ self - > { shuttersDev } } { selfDefenseAbsent } { timerrun } = $ timerrun ;
$ self - > { $ self - > { shuttersDev } } { selfDefenseAbsent } { active } = $ active ;
2019-06-25 10:24:25 +00:00
$ self - > { $ self - > { shuttersDev } } { selfDefenseAbsent } { timerhash } = $ timerhash
2019-06-25 11:19:22 +00:00
if ( defined ( $ timerhash ) ) ;
2019-06-25 10:24:25 +00:00
return 0 ;
}
2018-10-14 16:19:23 +00:00
sub setDriveCmd {
my ( $ self , $ posValue ) = @ _ ;
2019-03-31 15:17:56 +00:00
my $ offSet ;
my $ offSetStart ;
2018-11-19 08:06:50 +00:00
2019-11-11 18:16:47 +00:00
if (
( $ shutters - > getPartyMode eq 'on' and $ ascDev - > getPartyMode eq 'on' )
or ( $ shutters - > getAdv
and not $ shutters - > getQueryShuttersPos ( $ posValue )
and not $ shutters - > getAdvDelay )
)
2019-09-22 06:13:34 +00:00
{
2019-09-22 06:10:55 +00:00
$ shutters - > setDelayCmd ( $ posValue ) ;
$ ascDev - > setDelayCmdReading ;
$ shutters - > setNoDelay ( 0 ) ;
FHEM::AutoShuttersControl:: ASC_Debug ( 'setDriveCmd: '
2019-09-22 06:13:34 +00:00
. $ shutters - > getShuttersDev
2019-11-11 18:16:47 +00:00
. ' - Die Fahrt wird zurückgestellt. Grund kann ein geöffnetes Fenster sein oder ein aktivierter Party Modus oder Weihnachtszeit'
2019-09-22 06:10:55 +00:00
) ;
2018-11-15 14:01:34 +00:00
}
2019-09-22 06:10:55 +00:00
else {
2019-11-11 18:16:47 +00:00
$ shutters - > setAdvDelay ( 0 )
if ( $ shutters - > getAdvDelay ) ;
$ shutters - > setDelayCmd ( 'none' )
if ( $ shutters - > getDelayCmd ne 'none' )
; # setzt den Wert auf none da der Rolladen nun gesteuert werden kann.
2019-09-22 06:10:55 +00:00
### antifreeze Routine
if ( $ shutters - > getFreezeStatus > 0 ) {
if ( $ shutters - > getFreezeStatus != 1 ) {
$ posValue = $ shutters - > getStatus ;
$ shutters - > setLastDrive ( 'no drive - antifreeze defense' ) ;
$ shutters - > setLastDriveReading ;
$ ascDev - > setStateReading ;
}
elsif ( $ posValue == $ shutters - > getClosedPos ) {
$ posValue = $ shutters - > getAntiFreezePos ;
$ shutters - > setLastDrive (
$ shutters - > getLastDrive . ' - antifreeze mode' ) ;
}
}
2018-11-19 08:06:50 +00:00
2019-09-22 06:10:55 +00:00
my % h = (
shuttersDev = > $ self - > { shuttersDev } ,
posValue = > $ posValue ,
) ;
2018-11-04 11:27:46 +00:00
2019-09-22 06:10:55 +00:00
$ offSet = $ shutters - > getDelay if ( $ shutters - > getDelay > - 1 ) ;
$ offSet = $ ascDev - > getShuttersOffset if ( $ shutters - > getDelay < 0 ) ;
$ offSetStart = $ shutters - > getDelayStart ;
2018-10-27 11:36:11 +00:00
2019-09-22 06:10:55 +00:00
if ( $ shutters - > getSelfDefenseAbsent
and not $ shutters - > getSelfDefenseAbsentTimerrun
and $ shutters - > getSelfDefenseMode ne 'off'
and $ shutters - > getLastDrive eq 'selfDefense active'
and $ ascDev - > getSelfDefense eq 'on' )
{
2019-09-22 06:13:34 +00:00
InternalTimer (
gettimeofday ( ) + $ shutters - > getSelfDefenseAbsentDelay ,
2019-09-22 06:10:55 +00:00
'FHEM::AutoShuttersControl::_SetCmdFn' , \ % h ) ;
$ shutters - > setSelfDefenseAbsent ( 1 , 0 , \ % h ) ;
}
elsif ( $ offSetStart > 0 and not $ shutters - > getNoDelay ) {
InternalTimer (
2019-09-22 06:13:34 +00:00
gettimeofday ( ) +
int ( rand ( $ offSet ) + $ shutters - > getDelayStart ) ,
'FHEM::AutoShuttersControl::_SetCmdFn' , \ % h
) ;
2019-09-22 06:10:55 +00:00
FHEM::AutoShuttersControl:: ASC_Debug ( 'FnSetDriveCmd: '
2019-09-22 06:13:34 +00:00
. $ shutters - > getShuttersDev
. ' - versetztes fahren' ) ;
2019-09-22 06:10:55 +00:00
}
elsif ( $ offSetStart < 1 or $ shutters - > getNoDelay ) {
FHEM::AutoShuttersControl:: _SetCmdFn ( \ % h ) ;
FHEM::AutoShuttersControl:: ASC_Debug ( 'FnSetDriveCmd: '
2019-09-22 06:13:34 +00:00
. $ shutters - > getShuttersDev
. ' - NICHT versetztes fahren' ) ;
2019-09-22 06:10:55 +00:00
}
2019-03-31 15:17:56 +00:00
2019-04-09 10:13:46 +00:00
FHEM::AutoShuttersControl:: ASC_Debug ( 'FnSetDriveCmd: '
2019-09-22 06:13:34 +00:00
. $ shutters - > getShuttersDev
. ' - NoDelay: '
. ( $ shutters - > getNoDelay ? 'JA' : 'NEIN' ) ) ;
2019-09-22 06:10:55 +00:00
$ shutters - > setNoDelay ( 0 ) ;
return 0 ;
2019-03-31 15:17:56 +00:00
}
2018-10-14 16:19:23 +00:00
}
2018-10-08 19:05:47 +00:00
2018-10-28 17:12:40 +00:00
sub setSunsetUnixTime {
my ( $ self , $ unixtime ) = @ _ ;
$ self - > { $ self - > { shuttersDev } } { sunsettime } = $ unixtime ;
return 0 ;
}
2019-03-27 10:22:06 +00:00
sub setSunset {
my ( $ self , $ value ) = @ _ ;
$ self - > { $ self - > { shuttersDev } } { sunset } = $ value ;
return 0 ;
}
2018-10-28 17:12:40 +00:00
sub setSunriseUnixTime {
my ( $ self , $ unixtime ) = @ _ ;
$ self - > { $ self - > { shuttersDev } } { sunrisetime } = $ unixtime ;
return 0 ;
}
2019-03-27 10:22:06 +00:00
sub setSunrise {
my ( $ self , $ value ) = @ _ ;
$ self - > { $ self - > { shuttersDev } } { sunrise } = $ value ;
return 0 ;
}
2018-10-27 11:36:11 +00:00
sub setDelayCmd {
2018-10-14 16:19:23 +00:00
my ( $ self , $ posValue ) = @ _ ;
2018-10-27 11:36:11 +00:00
$ self - > { $ self - > { shuttersDev } } { delayCmd } = $ posValue ;
return 0 ;
}
sub setLastDrive {
my ( $ self , $ lastDrive ) = @ _ ;
$ self - > { $ self - > { shuttersDev } } { lastDrive } = $ lastDrive ;
return 0 ;
}
2018-11-07 07:22:11 +00:00
sub setPosSetCmd {
my ( $ self , $ posSetCmd ) = @ _ ;
2018-11-08 07:32:47 +00:00
2018-11-07 07:22:11 +00:00
$ self - > { $ self - > { shuttersDev } } { posSetCmd } = $ posSetCmd ;
return 0 ;
}
2018-10-27 11:36:11 +00:00
sub setLastDriveReading {
my $ self = shift ;
2018-10-14 16:19:23 +00:00
my $ shuttersDevHash = $ defs { $ self - > { shuttersDev } } ;
2018-10-27 11:36:11 +00:00
2019-07-03 09:54:01 +00:00
my % h = (
2019-07-03 09:54:48 +00:00
devHash = > $ shuttersDevHash ,
lastDrive = > $ shutters - > getLastDrive ,
2019-07-03 09:54:01 +00:00
) ;
2019-07-03 09:54:48 +00:00
InternalTimer ( gettimeofday ( ) + 0.1 ,
'FHEM::AutoShuttersControl::_setShuttersLastDriveDelayed' , \ % h ) ;
2018-10-14 16:19:23 +00:00
return 0 ;
}
2018-10-19 18:13:01 +00:00
sub setLastPos
{ # letzte ermittelte Position bevor die Position des Rolladen über ASC geändert wurde
2018-10-14 16:19:23 +00:00
my ( $ self , $ position ) = @ _ ;
2018-10-17 07:50:11 +00:00
2018-10-17 13:58:05 +00:00
$ self - > { $ self - > { shuttersDev } } { lastPos } { VAL } = $ position
2018-10-17 07:50:11 +00:00
if ( defined ( $ position ) ) ;
2018-10-17 13:58:05 +00:00
$ self - > { $ self - > { shuttersDev } } { lastPos } { TIME } = int ( gettimeofday ( ) )
if ( defined ( $ self - > { $ self - > { shuttersDev } } { lastPos } ) ) ;
2018-10-14 16:19:23 +00:00
return 0 ;
}
2018-10-08 19:05:47 +00:00
2018-11-19 08:06:50 +00:00
sub setLastManPos {
2018-10-19 18:13:01 +00:00
my ( $ self , $ position ) = @ _ ;
$ self - > { $ self - > { shuttersDev } } { lastManPos } { VAL } = $ position
if ( defined ( $ position ) ) ;
$ self - > { $ self - > { shuttersDev } } { lastManPos } { TIME } = int ( gettimeofday ( ) )
2018-12-07 11:57:45 +00:00
if ( defined ( $ self - > { $ self - > { shuttersDev } } { lastManPos } )
2018-12-07 12:04:41 +00:00
and defined ( $ self - > { $ self - > { shuttersDev } } { lastManPos } { TIME } ) ) ;
$ self - > { $ self - > { shuttersDev } } { lastManPos } { TIME } =
int ( gettimeofday ( ) ) - 86400
if ( defined ( $ self - > { $ self - > { shuttersDev } } { lastManPos } )
and not defined ( $ self - > { $ self - > { shuttersDev } } { lastManPos } { TIME } ) ) ;
2018-10-19 18:13:01 +00:00
return 0 ;
}
2018-10-14 16:19:23 +00:00
sub setDefault {
my ( $ self , $ defaultarg ) = @ _ ;
2018-10-17 07:50:11 +00:00
2018-10-14 16:19:23 +00:00
$ self - > { defaultarg } = $ defaultarg if ( defined ( $ defaultarg ) ) ;
2018-10-10 08:43:42 +00:00
return $ self - > { defaultarg } ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub setRoommate {
2018-10-14 16:19:23 +00:00
my ( $ self , $ roommate ) = @ _ ;
2018-10-17 07:50:11 +00:00
2018-10-14 16:19:23 +00:00
$ self - > { roommate } = $ roommate if ( defined ( $ roommate ) ) ;
2018-10-10 08:43:42 +00:00
return $ self - > { roommate } ;
2018-10-08 19:05:47 +00:00
}
2018-10-17 07:50:11 +00:00
sub setInTimerFuncHash {
my ( $ self , $ inTimerFuncHash ) = @ _ ;
$ self - > { $ self - > { shuttersDev } } { inTimerFuncHash } = $ inTimerFuncHash
if ( defined ( $ inTimerFuncHash ) ) ;
return 0 ;
}
2019-06-21 07:58:41 +00:00
sub setPrivacyDownStatus {
my ( $ self , $ statusValue ) = @ _ ;
$ self - > { $ self - > { shuttersDev } } - > { privacyDownStatus } = $ statusValue ;
return 0 ;
}
2019-10-25 08:44:08 +00:00
sub setPrivacyUpStatus {
my ( $ self , $ statusValue ) = @ _ ;
$ self - > { $ self - > { shuttersDev } } - > { privacyUpStatus } = $ statusValue ;
return 0 ;
}
2019-11-11 18:16:47 +00:00
sub setAdvDelay {
my ( $ self , $ advDelay ) = @ _ ;
$ self - > { $ self - > { shuttersDev } } - > { AdvDelay } = $ advDelay ;
return 0 ;
}
sub getAdvDelay {
my $ self = shift ;
return (
defined ( $ self - > { $ self - > { shuttersDev } } - > { AdvDelay } )
? $ self - > { $ self - > { shuttersDev } } - > { AdvDelay }
: 0
) ;
}
2019-06-21 07:58:41 +00:00
sub getPrivacyDownStatus {
my $ self = shift ;
2019-06-28 20:12:44 +00:00
return (
defined ( $ self - > { $ self - > { shuttersDev } } - > { privacyDownStatus } )
? $ self - > { $ self - > { shuttersDev } } - > { privacyDownStatus }
2019-06-30 16:53:28 +00:00
: undef
) ;
2019-06-21 07:58:41 +00:00
}
2019-10-25 08:44:08 +00:00
sub getPrivacyUpStatus {
my $ self = shift ;
return (
defined ( $ self - > { $ self - > { shuttersDev } } - > { privacyUpStatus } )
? $ self - > { $ self - > { shuttersDev } } - > { privacyUpStatus }
: undef
) ;
}
2019-09-06 16:36:48 +00:00
sub getAttrUpdateChanges {
my ( $ self , $ attr ) = @ _ ;
return $ self - > { $ self - > { shuttersDev } } { AttrUpdateChanges } { $ attr }
2019-09-06 16:40:10 +00:00
if ( defined ( $ self - > { $ self - > { shuttersDev } } { AttrUpdateChanges } )
and
defined ( $ self - > { $ self - > { shuttersDev } } { AttrUpdateChanges } { $ attr } ) ) ;
2019-09-06 16:36:48 +00:00
}
2019-06-04 08:53:28 +00:00
sub getIsDay {
my $ self = shift ;
2019-06-27 08:48:06 +00:00
return FHEM::AutoShuttersControl:: _IsDay ( $ self - > { shuttersDev } ) ;
2019-06-04 08:53:28 +00:00
}
2018-11-15 20:51:02 +00:00
sub getFreezeStatus {
2018-11-16 08:28:18 +00:00
use POSIX qw( strftime ) ;
2019-06-25 11:19:22 +00:00
my $ self = shift ;
2018-11-19 08:06:50 +00:00
my $ daytime = strftime ( "%P" , localtime ( ) ) ;
2019-06-24 10:57:52 +00:00
my $ outTemp = $ ascDev - > getOutTemp ;
2019-06-25 11:19:22 +00:00
$ outTemp = $ shutters - > getOutTemp if ( $ shutters - > getOutTemp != - 100 ) ;
2018-11-19 08:06:50 +00:00
if ( $ shutters - > getAntiFreeze ne 'off'
2019-06-24 10:57:52 +00:00
and $ outTemp <= $ ascDev - > getFreezeTemp )
2018-11-19 08:06:50 +00:00
{
2018-11-15 20:51:02 +00:00
2018-11-19 08:06:50 +00:00
if ( $ shutters - > getAntiFreeze eq 'soft' ) {
2018-11-16 09:44:54 +00:00
return 1 ;
}
2019-04-09 10:13:46 +00:00
elsif ( $ shutters - > getAntiFreeze eq $ daytime ) {
2018-11-16 09:44:54 +00:00
return 2 ;
}
elsif ( $ shutters - > getAntiFreeze eq 'hard' ) {
return 3 ;
}
2018-11-15 20:51:02 +00:00
}
else { return 0 ; }
}
2018-11-07 07:22:11 +00:00
sub getShuttersPosCmdValueNegate {
my $ self = shift ;
2018-11-08 07:32:47 +00:00
2019-07-29 11:53:18 +00:00
return ( $ shutters - > getOpenPos < $ shutters - > getClosedPos ? 1 : 0 ) ;
2018-11-07 07:22:11 +00:00
}
2019-06-04 04:37:38 +00:00
sub getQueryShuttersPos
{ # Es wird geschaut ob die aktuelle Position des Rollos unterhalb der Zielposition ist
my ( $ self , $ posValue ) =
@ _ ; # wenn dem so ist wird 1 zurück gegeben ansonsten 0
return (
$ shutters - > getShuttersPosCmdValueNegate
? $ shutters - > getStatus > $ posValue
: $ shutters - > getStatus < $ posValue
) ;
}
2018-11-07 07:22:11 +00:00
sub getPosSetCmd {
my $ self = shift ;
2018-11-08 07:32:47 +00:00
return (
defined ( $ self - > { $ self - > { shuttersDev } } { posSetCmd } )
? $ self - > { $ self - > { shuttersDev } } { posSetCmd }
2018-11-12 08:09:30 +00:00
: $ shutters - > getPosCmd
) ;
2018-11-07 07:22:11 +00:00
}
2019-09-17 14:52:19 +00:00
sub getNoDelay {
2018-11-07 07:22:11 +00:00
my $ self = shift ;
2019-09-17 14:52:19 +00:00
return $ self - > { $ self - > { shuttersDev } } { noDelay } ;
2018-11-07 07:22:11 +00:00
}
2019-06-25 10:24:25 +00:00
sub getSelfDefenseAbsent {
my $ self = shift ;
return $ self - > { $ self - > { shuttersDev } } { selfDefenseAbsent } { active } ;
}
sub getSelfDefenseAbsentTimerrun {
my $ self = shift ;
return $ self - > { $ self - > { shuttersDev } } { selfDefenseAbsent } { timerrun } ;
}
sub getSelfDefenseAbsentTimerhash {
my $ self = shift ;
return $ self - > { $ self - > { shuttersDev } } { selfDefenseAbsent } { timerhash }
2019-06-25 11:19:22 +00:00
if (
defined (
$ self - > { $ self - > { shuttersDev } } { selfDefenseAbsent } { timerhash }
)
) ;
2019-06-25 10:24:25 +00:00
}
2018-10-27 11:36:11 +00:00
sub getLastDrive {
my $ self = shift ;
2018-10-28 17:12:40 +00:00
$ self - > { $ self - > { shuttersDev } } { lastDrive } =
ReadingsVal ( $ self - > { shuttersDev } , 'ASC_ShuttersLastDrive' , 'none' )
if ( not defined ( $ self - > { $ self - > { shuttersDev } } { lastDrive } ) ) ;
2018-10-27 11:36:11 +00:00
return $ self - > { $ self - > { shuttersDev } } { lastDrive } ;
}
2018-10-19 18:13:01 +00:00
sub getLastPos
{ # letzte ermittelte Position bevor die Position des Rolladen über ASC geändert wurde
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-17 07:50:11 +00:00
return $ self - > { $ self - > { shuttersDev } } { lastPos } { VAL }
if ( defined ( $ self - > { $ self - > { shuttersDev } } { lastPos } )
and defined ( $ self - > { $ self - > { shuttersDev } } { lastPos } { VAL } ) ) ;
}
sub getLastPosTimestamp {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-17 07:50:11 +00:00
return $ self - > { $ self - > { shuttersDev } } { lastPos } { TIME }
if ( defined ( $ self - > { $ self - > { shuttersDev } } )
and defined ( $ self - > { $ self - > { shuttersDev } } { lastPos } )
and defined ( $ self - > { $ self - > { shuttersDev } } { lastPos } { TIME } ) ) ;
}
2018-10-19 18:13:01 +00:00
sub getLastManPos
{ # letzte ermittelte Position bevor die Position des Rolladen manuell (nicht über ASC) geändert wurde
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-19 18:13:01 +00:00
return $ self - > { $ self - > { shuttersDev } } { lastManPos } { VAL }
if ( defined ( $ self - > { $ self - > { shuttersDev } } { lastManPos } )
and defined ( $ self - > { $ self - > { shuttersDev } } { lastManPos } { VAL } ) ) ;
}
sub getLastManPosTimestamp {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-19 18:13:01 +00:00
return $ self - > { $ self - > { shuttersDev } } { lastManPos } { TIME }
if ( defined ( $ self - > { $ self - > { shuttersDev } } )
and defined ( $ self - > { $ self - > { shuttersDev } } { lastManPos } )
and defined ( $ self - > { $ self - > { shuttersDev } } { lastManPos } { TIME } ) ) ;
}
2018-10-17 07:50:11 +00:00
sub getInTimerFuncHash {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-17 07:50:11 +00:00
return $ self - > { $ self - > { shuttersDev } } { inTimerFuncHash } ;
2018-10-14 16:19:23 +00:00
}
2018-10-08 19:05:47 +00:00
2018-10-28 17:12:40 +00:00
sub getSunsetUnixTime {
my $ self = shift ;
return $ self - > { $ self - > { shuttersDev } } { sunsettime } ;
}
2019-03-27 10:22:06 +00:00
sub getSunset {
my $ self = shift ;
2019-04-09 10:13:46 +00:00
return (
defined ( $ self - > { $ self - > { shuttersDev } } { sunset } )
? $ self - > { $ self - > { shuttersDev } } { sunset }
2019-04-20 16:18:50 +00:00
: 0
) ;
2019-03-27 10:22:06 +00:00
}
2018-10-28 17:12:40 +00:00
sub getSunriseUnixTime {
my $ self = shift ;
return $ self - > { $ self - > { shuttersDev } } { sunrisetime } ;
}
2019-03-27 10:22:06 +00:00
sub getSunrise {
my $ self = shift ;
2019-04-09 10:13:46 +00:00
return (
defined ( $ self - > { $ self - > { shuttersDev } } { sunrise } )
? $ self - > { $ self - > { shuttersDev } } { sunrise }
2019-04-20 16:18:50 +00:00
: 0
) ;
2019-03-27 10:22:06 +00:00
}
2018-10-14 16:19:23 +00:00
sub getRoommatesStatus {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
my $ loop = 0 ;
2018-10-01 06:43:59 +00:00
my @ roState ;
2018-10-14 16:19:23 +00:00
my % statePrio = (
'asleep' = > 1 ,
'gotosleep' = > 2 ,
'awoken' = > 3 ,
'home' = > 4 ,
'absent' = > 5 ,
'gone' = > 6 ,
'none' = > 7
) ;
my $ minPrio = 10 ;
foreach my $ ro ( split ( "," , $ shutters - > getRoommates ) ) {
2018-10-10 08:43:42 +00:00
$ shutters - > setRoommate ( $ ro ) ;
2018-11-03 18:01:29 +00:00
my $ currentPrio = $ statePrio { $ shutters - > _getRoommateStatus } ;
2018-10-14 16:19:23 +00:00
$ minPrio = $ currentPrio if ( $ minPrio > $ currentPrio ) ;
2018-10-01 06:43:59 +00:00
}
2018-10-17 07:50:11 +00:00
2018-10-14 16:19:23 +00:00
my % revStatePrio = reverse % statePrio ;
2018-10-10 08:43:42 +00:00
return $ revStatePrio { $ minPrio } ;
2018-10-01 06:43:59 +00:00
}
2018-10-10 08:43:42 +00:00
sub getRoommatesLastStatus {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
my $ loop = 0 ;
2018-10-01 06:43:59 +00:00
my @ roState ;
2018-10-14 16:19:23 +00:00
my % statePrio = (
'asleep' = > 1 ,
'gotosleep' = > 2 ,
'awoken' = > 3 ,
2019-06-25 11:19:22 +00:00
'home' = > 6 ,
'absent' = > 5 ,
'gone' = > 4 ,
'none' = > 7
2018-10-14 16:19:23 +00:00
) ;
my $ minPrio = 10 ;
foreach my $ ro ( split ( "," , $ shutters - > getRoommates ) ) {
2018-10-10 08:43:42 +00:00
$ shutters - > setRoommate ( $ ro ) ;
2018-11-03 18:01:29 +00:00
my $ currentPrio = $ statePrio { $ shutters - > _getRoommateLastStatus } ;
2018-10-14 16:19:23 +00:00
$ minPrio = $ currentPrio if ( $ minPrio > $ currentPrio ) ;
2018-10-01 06:43:59 +00:00
}
2018-10-14 16:19:23 +00:00
my % revStatePrio = reverse % statePrio ;
2018-10-10 08:43:42 +00:00
return $ revStatePrio { $ minPrio } ;
2018-10-08 19:05:47 +00:00
}
2019-06-21 12:20:08 +00:00
sub getOutTemp {
my $ self = shift ;
2019-06-25 11:19:22 +00:00
return ReadingsVal ( $ shutters - > _getTempSensor ,
$ shutters - > getTempSensorReading , - 100 ) ;
2019-06-21 12:20:08 +00:00
}
2019-09-20 10:53:52 +00:00
sub getIdleDetection {
my $ self = shift ;
return ReadingsVal ( $ self - > { shuttersDev } ,
$ shutters - > _getIdleDetectionReading , 'none' ) ;
}
2018-12-05 14:39:11 +00:00
### Begin Beschattung Objekt mit Daten befüllen
2019-03-31 15:17:56 +00:00
sub setShadingStatus {
2018-12-05 14:39:11 +00:00
my ( $ self , $ value ) = @ _ ;
### Werte für value = in, out, in reserved, out reserved
2019-03-31 15:17:56 +00:00
$ self - > { $ self - > { shuttersDev } } { ShadingStatus } { VAL } = $ value
2018-12-05 14:39:11 +00:00
if ( defined ( $ value ) ) ;
2019-03-31 15:17:56 +00:00
$ self - > { $ self - > { shuttersDev } } { ShadingStatus } { TIME } = int ( gettimeofday ( ) )
if ( defined ( $ self - > { $ self - > { shuttersDev } } { ShadingStatus } ) ) ;
2018-12-05 14:39:11 +00:00
return 0 ;
}
2019-06-13 13:41:03 +00:00
sub setShadingLastStatus {
my ( $ self , $ value ) = @ _ ;
### Werte für value = in, out
$ self - > { $ self - > { shuttersDev } } { ShadingLastStatus } { VAL } = $ value
if ( defined ( $ value ) ) ;
2019-06-13 15:25:17 +00:00
$ self - > { $ self - > { shuttersDev } } { ShadingLastStatus } { TIME } =
int ( gettimeofday ( ) )
2019-06-13 13:41:03 +00:00
if ( defined ( $ self - > { $ self - > { shuttersDev } } { ShadingLastStatus } ) ) ;
2019-06-29 17:39:44 +00:00
$ self - > { $ self - > { shuttersDev } } { ShadingManualDriveStatus } { VAL } = 0
if ( $ value eq 'out' ) ;
return 0 ;
}
sub setShadingManualDriveStatus {
my ( $ self , $ value ) = @ _ ;
### Werte für value = in, out
$ self - > { $ self - > { shuttersDev } } { ShadingManualDriveStatus } { VAL } = $ value
if ( defined ( $ value ) ) ;
2019-06-13 13:41:03 +00:00
return 0 ;
}
2019-06-03 05:44:35 +00:00
sub setWindProtectionStatus { # Werte protected, unprotected
2019-03-23 11:06:21 +00:00
my ( $ self , $ value ) = @ _ ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { VAL } = $ value
if ( defined ( $ value ) ) ;
return 0 ;
}
2019-06-03 05:44:35 +00:00
sub setRainProtectionStatus { # Werte protected, unprotected
2019-05-02 09:49:22 +00:00
my ( $ self , $ value ) = @ _ ;
$ self - > { $ self - > { shuttersDev } } - > { RainProtection } - > { VAL } = $ value
if ( defined ( $ value ) ) ;
return 0 ;
}
2019-09-02 12:34:42 +00:00
sub setPushBrightnessInArray {
my ( $ self , $ value ) = @ _ ;
unshift (
@ { $ self - > { $ self - > { shuttersDev } } - > { BrightnessAverageArray } - > { VAL } } ,
$ value
) ;
pop ( @ { $ self - > { $ self - > { shuttersDev } } - > { BrightnessAverageArray } - > { VAL } } )
if (
scalar (
@ {
$ self - > { $ self - > { shuttersDev } } - > { BrightnessAverageArray } - > { VAL }
}
) > 3
) ;
}
sub getBrightnessAverage {
my $ self = shift ;
return & FHEM::AutoShuttersControl:: _averageBrightness (
2019-09-06 16:40:10 +00:00
@ { $ self - > { $ self - > { shuttersDev } } - > { BrightnessAverageArray } - > { VAL } } )
2019-09-02 12:34:42 +00:00
if (
2019-09-17 14:24:48 +00:00
ref ( $ self - > { $ self - > { shuttersDev } } - > { BrightnessAverageArray } - > { VAL } )
eq 'ARRAY'
and scalar (
2019-09-02 12:34:42 +00:00
@ {
$ self - > { $ self - > { shuttersDev } } - > { BrightnessAverageArray } - > { VAL }
}
) > 0
) ;
}
2019-04-09 10:13:46 +00:00
sub getShadingStatus { # Werte für value = in, out, in reserved, out reserved
2019-03-31 15:17:56 +00:00
my $ self = shift ;
return $ self - > { $ self - > { shuttersDev } } { ShadingStatus } { VAL }
if ( defined ( $ self - > { $ self - > { shuttersDev } } { ShadingStatus } )
and defined ( $ self - > { $ self - > { shuttersDev } } { ShadingStatus } { VAL } ) ) ;
}
2019-06-13 15:25:17 +00:00
sub getShadingLastStatus { # Werte für value = in, out
2019-06-13 13:41:03 +00:00
my $ self = shift ;
return $ self - > { $ self - > { shuttersDev } } { ShadingLastStatus } { VAL }
if ( defined ( $ self - > { $ self - > { shuttersDev } } { ShadingLastStatus } )
2019-06-13 15:25:17 +00:00
and defined ( $ self - > { $ self - > { shuttersDev } } { ShadingLastStatus } { VAL } )
) ;
2019-06-13 13:41:03 +00:00
}
2019-06-29 17:39:44 +00:00
sub getShadingManualDriveStatus { # Werte für value = in, out
my $ self = shift ;
2019-06-30 16:53:28 +00:00
return (
defined ( $ self - > { $ self - > { shuttersDev } } { ShadingManualDriveStatus } )
and defined (
$ self - > { $ self - > { shuttersDev } } { ShadingManualDriveStatus } { VAL }
)
? $ self - > { $ self - > { shuttersDev } } { ShadingManualDriveStatus } { VAL }
: 0
) ;
2019-06-29 17:39:44 +00:00
}
2019-03-31 15:17:56 +00:00
sub getIfInShading {
2018-12-05 14:39:11 +00:00
my $ self = shift ;
2019-04-09 10:13:46 +00:00
return (
(
2019-06-14 12:02:05 +00:00
$ shutters - > getShadingMode ne 'off'
2019-06-25 11:40:09 +00:00
and $ shutters - > getShadingLastStatus eq 'out'
2019-06-14 12:02:05 +00:00
) ? 1 : 0
2019-04-09 10:13:46 +00:00
) ;
2018-12-05 14:39:11 +00:00
}
2019-06-03 05:44:35 +00:00
sub getWindProtectionStatus { # Werte protected, unprotected
2019-03-23 11:06:21 +00:00
my $ self = shift ;
2019-04-09 10:13:46 +00:00
2019-05-03 06:57:35 +00:00
return (
2019-05-04 16:46:09 +00:00
(
defined ( $ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } )
and defined (
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { VAL }
)
)
2019-05-03 06:57:35 +00:00
? $ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { VAL }
2019-06-03 05:44:35 +00:00
: 'unprotected'
2019-05-03 06:57:35 +00:00
) ;
2019-05-02 09:49:22 +00:00
}
2019-06-03 05:44:35 +00:00
sub getRainProtectionStatus { # Werte protected, unprotected
2019-05-02 09:49:22 +00:00
my $ self = shift ;
2019-05-03 11:36:39 +00:00
return (
2019-05-04 16:46:09 +00:00
(
defined ( $ self - > { $ self - > { shuttersDev } } - > { RainProtection } )
and defined (
$ self - > { $ self - > { shuttersDev } } - > { RainProtection } - > { VAL }
)
)
2019-05-03 06:57:35 +00:00
? $ self - > { $ self - > { shuttersDev } } - > { RainProtection } - > { VAL }
2019-06-03 05:44:35 +00:00
: 'unprotected'
2019-05-03 11:36:39 +00:00
) ;
2019-03-23 11:06:21 +00:00
}
2019-03-31 15:17:56 +00:00
sub getShadingStatusTimestamp {
2018-12-05 14:39:11 +00:00
my $ self = shift ;
2019-03-31 15:17:56 +00:00
return $ self - > { $ self - > { shuttersDev } } { ShadingStatus } { TIME }
2018-12-05 14:39:11 +00:00
if ( defined ( $ self - > { $ self - > { shuttersDev } } )
2019-03-31 15:17:56 +00:00
and defined ( $ self - > { $ self - > { shuttersDev } } { ShadingStatus } )
and defined ( $ self - > { $ self - > { shuttersDev } } { ShadingStatus } { TIME } ) ) ;
2018-12-05 14:39:11 +00:00
}
2019-07-01 17:36:54 +00:00
sub getShadingLastStatusTimestamp {
my $ self = shift ;
return $ self - > { $ self - > { shuttersDev } } { ShadingLastStatus } { TIME }
if ( defined ( $ self - > { $ self - > { shuttersDev } } )
and defined ( $ self - > { $ self - > { shuttersDev } } { ShadingLastStatus } )
2019-07-03 09:54:48 +00:00
and defined ( $ self - > { $ self - > { shuttersDev } } { ShadingLastStatus } { TIME } )
) ;
2019-07-01 17:36:54 +00:00
}
2018-12-05 14:39:11 +00:00
### Ende Beschattung
2018-10-09 16:05:55 +00:00
## Subklasse Attr von ASC_Shutters##
package ASC_Shutters::Attr ;
2018-10-08 19:05:47 +00:00
use strict ;
use warnings ;
2018-11-07 07:22:11 +00:00
use GPUtils qw( GP_Import ) ;
2018-10-08 19:05:47 +00:00
## Import der FHEM Funktionen
BEGIN {
2018-10-14 16:19:23 +00:00
GP_Import (
qw(
2019-03-07 09:52:23 +00:00
AttrVal
gettimeofday )
2018-10-14 16:19:23 +00:00
) ;
}
2018-10-08 19:05:47 +00:00
2018-11-15 14:01:34 +00:00
sub getAntiFreezePos {
my $ self = shift ;
2019-09-18 12:55:17 +00:00
my $ val = AttrVal (
$ self - > { shuttersDev } ,
'ASC_Antifreeze_Pos' ,
$ userAttrList {
'ASC_Antifreeze_Pos:5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100'
} [ AttrVal ( $ self - > { shuttersDev } , 'ASC' , 2 ) ]
) ;
2018-11-15 14:01:34 +00:00
2019-09-20 06:34:04 +00:00
if ( FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ) {
$ val = FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ;
2019-09-18 12:55:17 +00:00
}
return (
$ val =~ /^\d+(\.\d+)?$/ ? $ val : $ userAttrList {
'ASC_Antifreeze_Pos:5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100'
} [ AttrVal ( $ self - > { shuttersDev } , 'ASC' , 2 ) ]
) ;
2018-11-15 14:01:34 +00:00
}
2018-10-22 06:05:19 +00:00
sub getShuttersPlace {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-22 06:05:19 +00:00
2018-10-27 11:36:11 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_ShuttersPlace' , 'window' ) ;
2018-10-22 06:05:19 +00:00
}
2019-10-25 08:44:08 +00:00
sub getPrivacyUpTime {
my $ self = shift ;
2019-10-30 11:43:57 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyUpValue_beforeDayOpen }
- > { uptime }
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyUpValue_beforeDayOpen }
- > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyUpValue_beforeDayOpen }
- > { LASTGETTIME } ) < 2
) ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyUpValue_beforeDayOpen }
- > { LASTGETTIME } = int ( gettimeofday ( ) ) ;
my ( $ upTime , $ upBrightnessVal ) =
FHEM::AutoShuttersControl:: GetAttrValues ( $ self - > { shuttersDev } ,
'ASC_PrivacyUpValue_beforeDayOpen' , '-1:-1' ) ;
## Erwartetes Ergebnis
# upTime:upBrightnessVal
$ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyUpValue_beforeDayOpen }
- > { uptime } = $ upTime ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyUpValue_beforeDayOpen }
- > { upbrightnessval } =
( $ upBrightnessVal ne 'none' ? $ upBrightnessVal : - 1 ) ;
$ shutters - > setPrivacyUpStatus ( 0 )
if ( defined ( $ shutters - > getPrivacyUpStatus )
and $ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyUpValue_beforeDayOpen }
- > { uptime } == - 1 ) ;
return $ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyUpValue_beforeDayOpen }
- > { uptime } ;
2019-10-25 08:44:08 +00:00
}
2019-10-30 11:43:57 +00:00
sub getPrivacyUpBrightnessVal {
2019-01-23 18:01:54 +00:00
my $ self = shift ;
2019-10-30 11:43:57 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyUpValue_beforeDayOpen }
- > { upbrightnessval }
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyUpValue_beforeDayOpen }
- > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyUpValue_beforeDayOpen }
- > { LASTGETTIME } ) < 2
) ;
$ shutters - > getPrivacyUpTime ;
return (
defined (
$ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyUpValue_beforeDayOpen }
- > { upbrightnessval }
)
? $ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyUpValue_beforeDayOpen }
- > { upbrightnessval }
: - 1
) ;
}
sub getPrivacyDownTime {
2019-10-31 06:17:04 +00:00
my $ self = shift ;
return $ self - > { $ self - > { shuttersDev } }
- > { ASC_PrivacyDownValue_beforeNightClose } - > { downtime }
if (
exists (
$ self - > { $ self - > { shuttersDev } }
- > { ASC_PrivacyDownValue_beforeNightClose } - > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } }
- > { ASC_PrivacyDownValue_beforeNightClose } - > { LASTGETTIME } ) < 2
) ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyDownValue_beforeNightClose }
- > { LASTGETTIME } = int ( gettimeofday ( ) ) ;
my ( $ downTime , $ downBrightnessVal ) =
FHEM::AutoShuttersControl:: GetAttrValues ( $ self - > { shuttersDev } ,
'ASC_PrivacyDownValue_beforeNightClose' , '-1:-1' ) ;
## Erwartetes Ergebnis
# downTime:downBrightnessVal
$ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyDownValue_beforeNightClose }
- > { downtime } = $ downTime ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_PrivacyDownValue_beforeNightClose }
- > { downbrightnessval } =
( $ downBrightnessVal ne 'none' ? $ downBrightnessVal : - 1 ) ;
2019-10-30 11:43:57 +00:00
$ shutters - > setPrivacyDownStatus ( 0 )
if ( defined ( $ shutters - > getPrivacyDownStatus )
2019-10-31 06:17:04 +00:00
and $ self - > { $ self - > { shuttersDev } }
- > { ASC_PrivacyDownValue_beforeNightClose } - > { downtime } == - 1 ) ;
2019-10-30 11:43:57 +00:00
2019-10-31 06:17:04 +00:00
return $ self - > { $ self - > { shuttersDev } }
- > { ASC_PrivacyDownValue_beforeNightClose } - > { downtime } ;
}
sub getPrivacyDownBrightnessVal {
my $ self = shift ;
return $ self - > { $ self - > { shuttersDev } }
- > { ASC_PrivacyDownValue_beforeNightClose } - > { downbrightnessval }
if (
exists (
$ self - > { $ self - > { shuttersDev } }
- > { ASC_PrivacyDownValue_beforeNightClose } - > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } }
- > { ASC_PrivacyDownValue_beforeNightClose } - > { LASTGETTIME } ) < 2
) ;
$ shutters - > getPrivacyDownTime ;
return (
defined (
$ self - > { $ self - > { shuttersDev } }
- > { ASC_PrivacyDownValue_beforeNightClose } - > { downbrightnessval }
)
? $ self - > { $ self - > { shuttersDev } }
- > { ASC_PrivacyDownValue_beforeNightClose } - > { downbrightnessval }
: - 1
) ;
2019-01-23 18:01:54 +00:00
}
2019-10-25 08:44:08 +00:00
sub getPrivacyUpPos {
my $ self = shift ;
my $ val = AttrVal ( $ self - > { shuttersDev } , 'ASC_PrivacyUp_Pos' , 50 ) ;
if ( FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ) {
$ val = FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ;
}
return ( $ val =~ /^\d+(\.\d+)?$/ ? $ val : 50 ) ;
}
2019-01-23 18:01:54 +00:00
sub getPrivacyDownPos {
my $ self = shift ;
2019-09-18 12:55:17 +00:00
my $ val = AttrVal ( $ self - > { shuttersDev } , 'ASC_PrivacyDown_Pos' , 50 ) ;
2019-09-20 06:34:04 +00:00
if ( FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ) {
$ val = FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ;
2019-09-18 12:55:17 +00:00
}
2019-01-23 18:01:54 +00:00
2019-09-18 12:55:17 +00:00
return ( $ val =~ /^\d+(\.\d+)?$/ ? $ val : 50 ) ;
2019-01-23 18:01:54 +00:00
}
2019-06-25 07:18:50 +00:00
sub getSelfDefenseMode {
my $ self = shift ;
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Self_Defense_Mode' , 'gone' ) ;
}
2019-06-25 10:24:25 +00:00
sub getSelfDefenseAbsentDelay {
my $ self = shift ;
2019-06-25 10:32:25 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Self_Defense_AbsentDelay' , 300 ) ;
2019-06-25 10:24:25 +00:00
}
2018-11-12 11:56:18 +00:00
sub getWiggleValue {
my $ self = shift ;
return AttrVal ( $ self - > { shuttersDev } , 'ASC_WiggleValue' , 5 ) ;
}
2019-11-11 18:16:47 +00:00
sub getAdv {
my $ self = shift ;
return (
AttrVal ( $ self - > { shuttersDev } , 'ASC_Adv' , 'off' ) eq 'on'
? ( FHEM::AutoShuttersControl:: _IsAdv ? 1 : 0 )
: 0
) ;
}
2018-12-05 14:39:11 +00:00
### Begin Beschattung
2018-11-14 02:41:38 +00:00
sub getShadingPos {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
2019-09-18 12:55:17 +00:00
my $ val = AttrVal ( $ self - > { shuttersDev } , 'ASC_Shading_Pos' ,
2019-04-25 19:34:46 +00:00
$ userAttrList { 'ASC_Shading_Pos:10,20,30,40,50,60,70,80,90,100' }
[ AttrVal ( $ self - > { shuttersDev } , 'ASC' , 2 ) ] ) ;
2019-09-18 12:55:17 +00:00
2019-09-20 06:34:04 +00:00
if ( FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ) {
$ val = FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ;
2019-09-18 12:55:17 +00:00
}
2019-09-19 11:46:42 +00:00
return (
$ val =~ /^\d+(\.\d+)?$/
2019-09-18 12:55:17 +00:00
? $ val
: $ userAttrList { 'ASC_Shading_Pos:10,20,30,40,50,60,70,80,90,100' }
2019-09-19 11:46:42 +00:00
[ AttrVal ( $ self - > { shuttersDev } , 'ASC' , 2 ) ]
) ;
2018-11-14 02:41:38 +00:00
}
sub getShadingMode {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
2018-11-14 02:41:38 +00:00
2019-04-25 15:15:56 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Shading_Mode' , 'off' ) ;
2018-11-14 02:41:38 +00:00
}
2019-06-21 12:20:08 +00:00
sub _getTempSensor {
my $ self = shift ;
2019-06-25 11:19:22 +00:00
2019-06-21 12:20:08 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_TempSensor } - > { device }
if (
exists (
2019-06-25 11:19:22 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_TempSensor } - > { LASTGETTIME }
2019-06-21 12:20:08 +00:00
)
and ( gettimeofday ( ) -
2019-06-25 11:19:22 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_TempSensor } - > { LASTGETTIME } )
< 2
2019-06-21 12:20:08 +00:00
) ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_TempSensor } - > { LASTGETTIME } =
int ( gettimeofday ( ) ) ;
my ( $ device , $ reading ) =
FHEM::AutoShuttersControl:: GetAttrValues ( $ self - > { shuttersDev } ,
'ASC_TempSensor' , 'none' ) ;
### erwartetes Ergebnis
# DEVICE:READING
$ self - > { $ self - > { shuttersDev } } - > { ASC_TempSensor } - > { device } = $ device ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_TempSensor } - > { reading } =
( $ reading ne 'none' ? $ reading : 'temperature' ) ;
return $ self - > { $ self - > { shuttersDev } } - > { ASC_TempSensor } - > { device } ;
}
sub getTempSensorReading {
my $ self = shift ;
return $ self - > { $ self - > { shuttersDev } } - > { ASC_TempSensor } - > { reading }
if (
exists (
2019-06-25 11:19:22 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_TempSensor } - > { LASTGETTIME }
2019-06-21 12:20:08 +00:00
)
and ( gettimeofday ( ) -
2019-06-25 11:19:22 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_TempSensor } - > { LASTGETTIME } )
< 2
2019-06-21 12:20:08 +00:00
) ;
$ shutters - > _getTempSensor ;
return (
2019-06-25 11:19:22 +00:00
defined ( $ self - > { $ self - > { shuttersDev } } - > { ASC_TempSensor } - > { reading } )
2019-06-21 12:20:08 +00:00
? $ self - > { $ self - > { shuttersDev } } - > { ASC_TempSensor } - > { reading }
: 'temperature'
) ;
}
2019-09-20 10:53:52 +00:00
sub _getIdleDetectionReading {
my $ self = shift ;
2019-09-20 12:03:13 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_Shutter_IdleDetection }
- > { reading }
2019-09-20 10:53:52 +00:00
if (
exists (
2019-09-20 12:03:13 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shutter_IdleDetection }
- > { LASTGETTIME }
2019-09-20 10:53:52 +00:00
)
and ( gettimeofday ( ) -
2019-09-20 12:03:13 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shutter_IdleDetection }
- > { LASTGETTIME } ) < 2
2019-09-20 10:53:52 +00:00
) ;
2019-09-20 12:03:13 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shutter_IdleDetection } - > { LASTGETTIME }
= int ( gettimeofday ( ) ) ;
2019-09-20 10:53:52 +00:00
my ( $ reading , $ value ) =
FHEM::AutoShuttersControl:: GetAttrValues ( $ self - > { shuttersDev } ,
'ASC_Shutter_IdleDetection' , 'none' ) ;
### erwartetes Ergebnis
# READING:VALUE
2019-09-20 12:03:13 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shutter_IdleDetection } - > { reading } =
$ reading ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shutter_IdleDetection } - > { value } =
$ value ;
2019-09-20 10:53:52 +00:00
2019-09-20 12:03:13 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_Shutter_IdleDetection }
- > { reading } ;
2019-09-20 10:53:52 +00:00
}
sub getIdleDetectionValue {
my $ self = shift ;
return $ self - > { $ self - > { shuttersDev } } - > { ASC_Shutter_IdleDetection } - > { value }
if (
exists (
2019-09-20 12:03:13 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shutter_IdleDetection }
- > { LASTGETTIME }
2019-09-20 10:53:52 +00:00
)
and ( gettimeofday ( ) -
2019-09-20 12:03:13 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shutter_IdleDetection }
- > { LASTGETTIME } ) < 2
2019-09-20 10:53:52 +00:00
) ;
2019-09-20 11:39:28 +00:00
$ shutters - > _getIdleDetectionReading ;
2019-09-20 10:53:52 +00:00
return (
2019-09-20 12:03:13 +00:00
defined (
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shutter_IdleDetection }
- > { value }
)
2019-09-20 10:53:52 +00:00
? $ self - > { $ self - > { shuttersDev } } - > { ASC_Shutter_IdleDetection } - > { value }
: 'none'
) ;
}
2018-12-07 11:57:45 +00:00
sub _getBrightnessSensor {
2019-04-09 10:13:46 +00:00
my $ self = shift ;
return $ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor } - > { device }
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor }
- > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor }
- > { LASTGETTIME } ) < 2
) ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor } - > { LASTGETTIME } =
int ( gettimeofday ( ) ) ;
2019-04-17 14:25:05 +00:00
my ( $ device , $ reading , $ max , $ min ) =
2019-04-09 10:13:46 +00:00
FHEM::AutoShuttersControl:: GetAttrValues ( $ self - > { shuttersDev } ,
'ASC_BrightnessSensor' , 'none' ) ;
2018-10-08 19:05:47 +00:00
2019-03-12 22:02:02 +00:00
### erwartetes Ergebnis
2019-04-17 14:25:05 +00:00
# DEVICE:READING MAX:MIN
2019-03-12 22:02:02 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor } - > { device } = $ device ;
2019-04-09 10:13:46 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor } - > { reading } =
( $ reading ne 'none' ? $ reading : 'brightness' ) ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor } - > { triggermin } =
2019-06-10 16:42:31 +00:00
( $ min ne 'none' ? $ min : - 1 ) ;
2019-04-09 10:13:46 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor } - > { triggermax } =
2019-06-10 16:42:31 +00:00
( $ max ne 'none' ? $ max : - 1 ) ;
2019-03-07 16:58:30 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor } - > { device } ;
2018-10-08 19:05:47 +00:00
}
2018-12-07 11:57:45 +00:00
sub getBrightnessReading {
2019-04-09 10:13:46 +00:00
my $ self = shift ;
2018-10-12 04:32:01 +00:00
2019-04-09 10:13:46 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor } - > { reading }
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor }
- > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor }
- > { LASTGETTIME } ) < 2
) ;
2019-03-07 16:58:30 +00:00
$ shutters - > _getBrightnessSensor ;
2019-04-09 10:13:46 +00:00
return (
defined (
$ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor } - > { reading }
)
? $ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor } - > { reading }
: 'brightness'
) ;
2018-10-12 04:32:01 +00:00
}
2018-10-08 19:05:47 +00:00
2019-09-19 11:46:42 +00:00
sub getShadingAzimuthLeft {
2018-11-19 08:06:50 +00:00
my $ self = shift ;
2018-11-12 11:56:18 +00:00
2019-09-19 11:46:42 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_InOutAzimuth }
- > { leftVal }
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_InOutAzimuth }
- > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_InOutAzimuth }
- > { LASTGETTIME } ) < 2
) ;
$ shutters - > getShadingAzimuthRight ;
return $ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_InOutAzimuth }
- > { leftVal } ;
2018-11-12 11:56:18 +00:00
}
2019-09-19 11:46:42 +00:00
sub getShadingAzimuthRight {
2018-11-19 08:06:50 +00:00
my $ self = shift ;
2019-09-19 11:46:42 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_InOutAzimuth }
- > { rightVal }
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_InOutAzimuth }
- > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_InOutAzimuth }
- > { LASTGETTIME } ) < 2
) ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_InOutAzimuth } - > { LASTGETTIME }
= int ( gettimeofday ( ) ) ;
my ( $ left , $ right ) =
FHEM::AutoShuttersControl:: GetAttrValues ( $ self - > { shuttersDev } ,
'ASC_Shading_InOutAzimuth' , '95:265' ) ;
2018-11-12 11:56:18 +00:00
2019-09-19 11:46:42 +00:00
### erwartetes Ergebnis
# MIN:MAX
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_InOutAzimuth } - > { leftVal } =
$ left ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_InOutAzimuth } - > { rightVal } =
$ right ;
2018-11-19 08:06:50 +00:00
2019-09-19 11:46:42 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_InOutAzimuth }
- > { rightVal } ;
2018-11-12 11:56:18 +00:00
}
2018-12-05 14:39:11 +00:00
sub getShadingMinOutsideTemperature {
my $ self = shift ;
2018-12-07 12:04:41 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Shading_Min_OutsideTemperature' ,
2019-04-25 15:15:56 +00:00
18 ) ;
2018-12-05 14:39:11 +00:00
}
sub getShadingMinElevation {
my $ self = shift ;
2019-06-10 12:03:03 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_MinMax_Elevation }
- > { minVal }
2019-06-10 11:41:46 +00:00
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_MinMax_Elevation }
- > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_MinMax_Elevation }
- > { LASTGETTIME } ) < 2
) ;
2019-06-10 12:03:03 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_MinMax_Elevation }
- > { LASTGETTIME } = int ( gettimeofday ( ) ) ;
2019-06-10 11:41:46 +00:00
my ( $ min , $ max ) =
FHEM::AutoShuttersControl:: GetAttrValues ( $ self - > { shuttersDev } ,
'ASC_Shading_MinMax_Elevation' , '25.0:100.0' ) ;
### erwartetes Ergebnis
# MIN:MAX
2019-06-10 12:03:03 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_MinMax_Elevation } - > { minVal } =
$ min ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_MinMax_Elevation } - > { maxVal } =
2019-06-10 13:36:02 +00:00
( $ max ne 'none' ? $ max : 100 ) ;
2019-06-10 11:41:46 +00:00
2019-06-10 12:03:03 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_MinMax_Elevation }
- > { minVal } ;
2019-06-10 11:41:46 +00:00
}
sub getShadingMaxElevation {
2019-06-10 12:03:03 +00:00
my $ self = shift ;
2019-06-10 11:41:46 +00:00
2019-06-10 12:03:03 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_MinMax_Elevation }
- > { maxVal }
2019-06-10 11:41:46 +00:00
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_MinMax_Elevation }
- > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_MinMax_Elevation }
- > { LASTGETTIME } ) < 2
) ;
$ shutters - > getShadingMinElevation ;
2019-06-10 12:03:03 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_MinMax_Elevation }
- > { maxVal } ;
2018-12-05 14:39:11 +00:00
}
sub getShadingStateChangeSunny {
my $ self = shift ;
2019-09-19 11:46:42 +00:00
return $ self - > { $ self - > { shuttersDev } }
- > { ASC_Shading_StateChange_SunnyCloudy } - > { sunny }
if (
exists (
$ self - > { $ self - > { shuttersDev } }
- > { ASC_Shading_StateChange_SunnyCloudy } - > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } }
- > { ASC_Shading_StateChange_SunnyCloudy } - > { LASTGETTIME } ) < 2
) ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_StateChange_SunnyCloudy }
- > { LASTGETTIME } = int ( gettimeofday ( ) ) ;
my ( $ sunny , $ cloudy ) =
FHEM::AutoShuttersControl:: GetAttrValues ( $ self - > { shuttersDev } ,
'ASC_Shading_StateChange_SunnyCloudy' ,
'35000:20000' ) ;
### erwartetes Ergebnis
# SUNNY:CLOUDY
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_StateChange_SunnyCloudy }
- > { sunny } = $ sunny ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_Shading_StateChange_SunnyCloudy }
- > { cloudy } = $ cloudy ;
return $ self - > { $ self - > { shuttersDev } }
- > { ASC_Shading_StateChange_SunnyCloudy } - > { sunny } ;
2018-12-05 14:39:11 +00:00
}
sub getShadingStateChangeCloudy {
my $ self = shift ;
2019-09-19 11:46:42 +00:00
return $ self - > { $ self - > { shuttersDev } }
- > { ASC_Shading_StateChange_SunnyCloudy } - > { cloudy }
if (
exists (
$ self - > { $ self - > { shuttersDev } }
- > { ASC_Shading_StateChange_SunnyCloudy } - > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } }
- > { ASC_Shading_StateChange_SunnyCloudy } - > { LASTGETTIME } ) < 2
) ;
$ shutters - > getShadingStateChangeSunny ;
return $ self - > { $ self - > { shuttersDev } }
- > { ASC_Shading_StateChange_SunnyCloudy } - > { cloudy } ;
2018-12-05 14:39:11 +00:00
}
sub getShadingWaitingPeriod {
my $ self = shift ;
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Shading_WaitingPeriod' , 1200 ) ;
}
### Ende Beschattung
2019-11-04 07:09:46 +00:00
sub getExternalTriggerDevice {
my $ self = shift ;
2019-11-07 13:06:47 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { device }
2019-11-04 07:09:46 +00:00
if (
exists (
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { LASTGETTIME }
2019-11-04 07:09:46 +00:00
)
and ( gettimeofday ( ) -
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { LASTGETTIME } ) < 2
2019-11-04 07:09:46 +00:00
) ;
2019-11-07 13:06:47 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { LASTGETTIME } =
int ( gettimeofday ( ) ) ;
2019-11-04 13:39:55 +00:00
my ( $ device , $ reading , $ valueActive , $ valueInactive , $ posActive ,
$ posInactive )
= FHEM::AutoShuttersControl:: GetAttrValues ( $ self - > { shuttersDev } ,
2019-11-05 12:44:40 +00:00
'ASC_ExternalTrigger' , 'none' ) ;
2019-11-04 07:09:46 +00:00
### erwartetes Ergebnis
# DEVICE:READING VALUEACTIVE:VALUEINACTIVE POSACTIVE:POSINACTIVE
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { device } =
2019-11-04 13:39:55 +00:00
$ device ;
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { reading } =
2019-11-04 13:39:55 +00:00
$ reading ;
2019-11-07 13:06:47 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { valueactive } =
$ valueActive ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { valueinactive } =
$ valueInactive ;
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { posactive } =
2019-11-04 13:39:55 +00:00
$ posActive ;
2019-11-07 13:06:47 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { posinactive } =
( $ posInactive ne 'none' ? $ posInactive : $ shutters - > getLastPos ) ;
2019-11-04 07:09:46 +00:00
2019-11-07 13:06:47 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { device } ;
2019-11-04 07:09:46 +00:00
}
sub getExternalTriggerReading {
my $ self = shift ;
2019-11-07 13:06:47 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { reading }
2019-11-04 07:09:46 +00:00
if (
exists (
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { LASTGETTIME }
2019-11-04 07:09:46 +00:00
)
and ( gettimeofday ( ) -
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { LASTGETTIME } ) < 2
2019-11-04 07:09:46 +00:00
) ;
$ shutters - > getExternalTriggerDevice ;
2019-11-07 13:06:47 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { reading } ;
2019-11-04 07:09:46 +00:00
}
sub getExternalTriggerValueActive {
my $ self = shift ;
2019-11-07 13:06:47 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { valueactive }
2019-11-04 07:09:46 +00:00
if (
exists (
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { LASTGETTIME }
2019-11-04 07:09:46 +00:00
)
and ( gettimeofday ( ) -
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { LASTGETTIME } ) < 2
2019-11-04 07:09:46 +00:00
) ;
$ shutters - > getExternalTriggerDevice ;
2019-11-05 12:44:40 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { valueactive } ;
2019-11-04 07:09:46 +00:00
}
sub getExternalTriggerValueInactive {
my $ self = shift ;
2019-11-05 12:44:40 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { valueinactive }
2019-11-04 07:09:46 +00:00
if (
exists (
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { LASTGETTIME }
2019-11-04 07:09:46 +00:00
)
and ( gettimeofday ( ) -
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { LASTGETTIME } ) < 2
2019-11-04 07:09:46 +00:00
) ;
$ shutters - > getExternalTriggerDevice ;
2019-11-05 12:44:40 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { valueinactive } ;
2019-11-04 07:09:46 +00:00
}
sub getExternalTriggerPosActive {
my $ self = shift ;
2019-11-07 13:06:47 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { posactive }
2019-11-04 07:09:46 +00:00
if (
exists (
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { LASTGETTIME }
2019-11-04 07:09:46 +00:00
)
and ( gettimeofday ( ) -
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { LASTGETTIME } ) < 2
2019-11-04 07:09:46 +00:00
) ;
$ shutters - > getExternalTriggerDevice ;
2019-11-07 13:06:47 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { posactive } ;
2019-11-04 07:09:46 +00:00
}
sub getExternalTriggerPosInactive {
my $ self = shift ;
2019-11-07 13:06:47 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger } - > { posinactive }
2019-11-04 07:09:46 +00:00
if (
exists (
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { LASTGETTIME }
2019-11-04 07:09:46 +00:00
)
and ( gettimeofday ( ) -
2019-11-05 12:44:40 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { LASTGETTIME } ) < 2
2019-11-04 07:09:46 +00:00
) ;
$ shutters - > getExternalTriggerDevice ;
2019-11-05 12:44:40 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_ExternalTrigger }
2019-11-04 13:39:55 +00:00
- > { posinactive } ;
2019-11-04 07:09:46 +00:00
}
2019-09-17 12:07:26 +00:00
sub getDelay {
2018-10-30 07:18:09 +00:00
my $ self = shift ;
2019-09-17 12:03:36 +00:00
my $ val = AttrVal ( $ self - > { shuttersDev } , 'ASC_Drive_Delay' , - 1 ) ;
2019-06-03 05:44:35 +00:00
return ( $ val =~ /^\d+$/ ? $ val : - 1 ) ;
2018-10-30 07:18:09 +00:00
}
2019-09-17 12:07:26 +00:00
sub getDelayStart {
2019-01-21 11:27:22 +00:00
my $ self = shift ;
2019-01-23 09:00:47 +00:00
2019-09-17 12:03:36 +00:00
my $ val = AttrVal ( $ self - > { shuttersDev } , 'ASC_Drive_DelayStart' , - 1 ) ;
2019-06-03 05:44:35 +00:00
return ( ( $ val > 0 and $ val =~ /^\d+$/ ) ? $ val : - 1 ) ;
2019-01-21 11:27:22 +00:00
}
2018-12-06 14:24:16 +00:00
sub getBlockingTimeAfterManual {
my $ self = shift ;
2018-12-07 12:04:41 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_BlockingTime_afterManual' ,
1200 ) ;
2018-12-06 14:24:16 +00:00
}
2018-12-05 14:39:11 +00:00
sub getBlockingTimeBeforNightClose {
my $ self = shift ;
2018-12-07 12:04:41 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_BlockingTime_beforNightClose' ,
3600 ) ;
2018-12-05 14:39:11 +00:00
}
sub getBlockingTimeBeforDayOpen {
my $ self = shift ;
2018-12-07 12:04:41 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_BlockingTime_beforDayOpen' ,
3600 ) ;
2018-12-05 14:39:11 +00:00
}
2018-10-10 08:43:42 +00:00
sub getPosCmd {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2018-11-07 07:22:11 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Pos_Reading' , 'pct' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getOpenPos {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2019-09-20 04:33:17 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Open_Pos' ,
2019-04-25 19:34:46 +00:00
$ userAttrList { 'ASC_Open_Pos:0,10,20,30,40,50,60,70,80,90,100' }
[ AttrVal ( $ self - > { shuttersDev } , 'ASC' , 2 ) ] ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getVentilatePos {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2019-09-18 12:55:17 +00:00
my $ val = AttrVal ( $ self - > { shuttersDev } , 'ASC_Ventilate_Pos' ,
2019-04-25 19:34:46 +00:00
$ userAttrList { 'ASC_Ventilate_Pos:10,20,30,40,50,60,70,80,90,100' }
[ AttrVal ( $ self - > { shuttersDev } , 'ASC' , 2 ) ] ) ;
2019-09-18 12:55:17 +00:00
2019-09-20 06:34:04 +00:00
if ( FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ) {
$ val = FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ;
2019-09-18 12:55:17 +00:00
}
2019-09-19 11:46:42 +00:00
return (
$ val =~ /^\d+(\.\d+)?$/
2019-09-18 12:55:17 +00:00
? $ val
: $ userAttrList { 'ASC_Ventilate_Pos:10,20,30,40,50,60,70,80,90,100' }
2019-09-19 11:46:42 +00:00
[ AttrVal ( $ self - > { shuttersDev } , 'ASC' , 2 ) ]
) ;
2018-10-08 19:05:47 +00:00
}
2019-07-29 10:55:38 +00:00
sub getVentilatePosAfterDayClosed {
my $ self = shift ;
return AttrVal ( $ self - > { shuttersDev } , 'ASC_WindowRec_PosAfterDayClosed' ,
'open' ) ;
}
2018-10-10 08:43:42 +00:00
sub getClosedPos {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2019-09-20 04:33:17 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Closed_Pos' ,
2019-04-25 19:34:46 +00:00
$ userAttrList { 'ASC_Closed_Pos:0,10,20,30,40,50,60,70,80,90,100' }
[ AttrVal ( $ self - > { shuttersDev } , 'ASC' , 2 ) ] ) ;
2018-10-08 19:05:47 +00:00
}
2019-09-12 09:28:51 +00:00
sub getSleepPos {
my $ self = shift ;
2019-09-18 12:55:17 +00:00
my $ val = AttrVal ( $ self - > { shuttersDev } , 'ASC_Sleep_Pos' , - 1 ) ;
2019-09-12 09:28:51 +00:00
2019-09-20 06:34:04 +00:00
if ( FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ) {
$ val = FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ;
2019-09-18 12:55:17 +00:00
}
return ( $ val =~ /^\d+(\.\d+)?$/ ? $ val : - 1 ) ;
2019-09-12 09:28:51 +00:00
}
2018-10-10 08:43:42 +00:00
sub getVentilateOpen {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2019-04-25 15:15:56 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Ventilate_Window_Open' , 'on' ) ;
2018-10-08 19:05:47 +00:00
}
2018-11-15 14:01:34 +00:00
sub getComfortOpenPos {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2019-09-18 12:55:17 +00:00
my $ val = AttrVal ( $ self - > { shuttersDev } , 'ASC_ComfortOpen_Pos' ,
2019-04-25 19:34:46 +00:00
$ userAttrList { 'ASC_ComfortOpen_Pos:0,10,20,30,40,50,60,70,80,90,100' }
[ AttrVal ( $ self - > { shuttersDev } , 'ASC' , 2 ) ] ) ;
2019-09-18 12:55:17 +00:00
2019-09-20 06:34:04 +00:00
if ( FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ) {
$ val = FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ;
2019-09-18 12:55:17 +00:00
}
2019-09-19 11:46:42 +00:00
return (
$ val =~ /^\d+(\.\d+)?$/
2019-09-18 12:55:17 +00:00
? $ val
: $ userAttrList { 'ASC_ComfortOpen_Pos:0,10,20,30,40,50,60,70,80,90,100' }
2019-09-19 11:46:42 +00:00
[ AttrVal ( $ self - > { shuttersDev } , 'ASC' , 2 ) ]
) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getPartyMode {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2019-04-28 05:32:48 +00:00
2018-10-27 11:36:11 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Partymode' , 'off' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getRoommates {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2019-04-25 15:15:56 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Roommate_Device' , 'none' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getRoommatesReading {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2019-04-25 15:15:56 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Roommate_Reading' , 'state' ) ;
2018-10-08 19:05:47 +00:00
}
2019-02-28 08:05:23 +00:00
sub getWindPos {
my $ self = shift ;
my $ name = $ self - > { name } ;
2019-04-09 10:13:46 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { closedPos }
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { LASTGETTIME }
) < 2
) ;
2019-03-07 09:52:23 +00:00
$ shutters - > getWindMax ;
return $ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { closedPos } ;
2019-02-28 08:05:23 +00:00
}
sub getWindMax {
my $ self = shift ;
my $ name = $ self - > { name } ;
2019-03-07 16:58:30 +00:00
2019-04-09 10:13:46 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { triggermax }
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { LASTGETTIME }
) < 2
) ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { LASTGETTIME } =
int ( gettimeofday ( ) ) ;
my ( $ max , $ hyst , $ pos ) =
FHEM::AutoShuttersControl:: GetAttrValues ( $ self - > { shuttersDev } ,
2019-04-25 15:15:56 +00:00
'ASC_WindParameters' , '50:20' ) ;
2019-04-09 10:13:46 +00:00
2019-03-12 22:02:02 +00:00
## Erwartetes Ergebnis
# max:hyst pos
2019-04-09 10:13:46 +00:00
2019-04-29 11:24:01 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { triggermax } = $ max ;
2019-04-25 19:34:46 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { triggerhyst } =
2019-04-29 09:04:27 +00:00
( $ hyst ne 'none' ? $ max - $ hyst : $ max - 20 ) ;
2019-04-09 10:13:46 +00:00
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { closedPos } =
( $ pos ne 'none' ? $ pos : $ shutters - > getOpenPos ) ;
2019-02-28 08:05:23 +00:00
2019-03-07 09:52:23 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { triggermax } ;
2019-02-28 08:05:23 +00:00
}
sub getWindMin {
my $ self = shift ;
my $ name = $ self - > { name } ;
2019-04-09 10:13:46 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { triggerhyst }
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { LASTGETTIME }
) < 2
) ;
2019-03-07 09:52:23 +00:00
$ shutters - > getWindMax ;
2019-03-12 22:02:02 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_WindParameters } - > { triggerhyst } ;
2019-02-28 08:05:23 +00:00
}
2019-04-28 20:13:27 +00:00
sub getWindProtection {
my $ self = shift ;
return AttrVal ( $ self - > { shuttersDev } , 'ASC_WindProtection' , 'on' ) ;
}
2019-04-29 11:22:37 +00:00
sub getRainProtection {
my $ self = shift ;
return AttrVal ( $ self - > { shuttersDev } , 'ASC_RainProtection' , 'on' ) ;
}
2018-10-10 08:43:42 +00:00
sub getModeUp {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2019-04-25 15:15:56 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Mode_Up' , 'always' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getModeDown {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2019-04-25 15:15:56 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Mode_Down' , 'always' ) ;
2018-10-01 06:43:59 +00:00
}
2018-10-10 08:43:42 +00:00
sub getLockOut {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2018-11-14 14:26:32 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_LockOut' , 'off' ) ;
}
sub getLockOutCmd {
my $ self = shift ;
return AttrVal ( $ self - > { shuttersDev } , 'ASC_LockOut_Cmd' , 'none' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getAntiFreeze {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2018-10-27 11:36:11 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Antifreeze' , 'off' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getAutoAstroModeMorning {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2019-04-25 19:34:46 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_AutoAstroModeMorning' , 'none' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getAutoAstroModeEvening {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2019-04-25 19:34:46 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_AutoAstroModeEvening' , 'none' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getAutoAstroModeMorningHorizon {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2018-10-27 11:36:11 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_AutoAstroModeMorningHorizon' ,
2019-04-25 15:15:56 +00:00
'none' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getAutoAstroModeEveningHorizon {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2018-10-27 11:36:11 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_AutoAstroModeEveningHorizon' ,
2019-04-25 15:15:56 +00:00
'none' ) ;
2018-10-08 19:05:47 +00:00
}
2018-11-03 18:01:29 +00:00
sub getUp {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2018-10-27 11:36:11 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Up' , 'astro' ) ;
2018-10-08 19:05:47 +00:00
}
2018-11-03 18:01:29 +00:00
sub getDown {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2018-10-27 11:36:11 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_Down' , 'astro' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getTimeUpEarly {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2019-09-18 12:55:17 +00:00
my $ val = AttrVal ( $ self - > { shuttersDev } , 'ASC_Time_Up_Early' , '05:00' ) ;
2018-10-08 19:05:47 +00:00
2019-09-20 06:34:04 +00:00
if ( FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ) {
$ val = FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ;
2019-09-18 12:55:17 +00:00
}
2019-09-19 11:46:42 +00:00
return (
$ val =~ /^(?:[01]\d|2[0-3]):(?:[0-5]\d)(:(?:[0-5]\d))?$/
2019-09-18 12:55:17 +00:00
? $ val
2019-09-19 11:46:42 +00:00
: '05:00'
) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getTimeUpLate {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2019-09-18 12:55:17 +00:00
my $ val = AttrVal ( $ self - > { shuttersDev } , 'ASC_Time_Up_Late' , '08:30' ) ;
2019-09-20 06:34:04 +00:00
if ( FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ) {
$ val = FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ;
2019-09-18 12:55:17 +00:00
}
2018-10-08 19:05:47 +00:00
2019-09-19 11:46:42 +00:00
return (
$ val =~ /^(?:[01]\d|2[0-3]):(?:[0-5]\d)(:(?:[0-5]\d))?$/
2019-09-18 12:55:17 +00:00
? $ val
2019-09-19 11:46:42 +00:00
: '08:30'
) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getTimeDownEarly {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2019-09-18 12:55:17 +00:00
my $ val = AttrVal ( $ self - > { shuttersDev } , 'ASC_Time_Down_Early' , '16:00' ) ;
2018-10-08 19:05:47 +00:00
2019-09-20 06:34:04 +00:00
if ( FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ) {
$ val = FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ;
2019-09-18 12:55:17 +00:00
}
2019-09-19 11:46:42 +00:00
return (
$ val =~ /^(?:[01]\d|2[0-3]):(?:[0-5]\d)(:(?:[0-5]\d))?$/
2019-09-18 12:55:17 +00:00
? $ val
2019-09-19 11:46:42 +00:00
: '16:00'
) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getTimeDownLate {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2019-09-18 12:55:17 +00:00
my $ val = AttrVal ( $ self - > { shuttersDev } , 'ASC_Time_Down_Late' , '22:00' ) ;
2019-09-20 06:34:04 +00:00
if ( FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ) {
$ val = FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ;
2019-09-18 12:55:17 +00:00
}
2018-10-08 19:05:47 +00:00
2019-09-19 11:46:42 +00:00
return (
$ val =~ /^(?:[01]\d|2[0-3]):(?:[0-5]\d)(:(?:[0-5]\d))?$/
2019-09-18 12:55:17 +00:00
? $ val
2019-09-19 11:46:42 +00:00
: '22:00'
) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getTimeUpWeHoliday {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2019-09-18 12:55:17 +00:00
my $ val =
AttrVal ( $ self - > { shuttersDev } , 'ASC_Time_Up_WE_Holiday' , '08:00' ) ;
2019-09-20 06:34:04 +00:00
if ( FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ) {
$ val = FHEM::AutoShuttersControl:: _perlCodeCheck ( $ val ) ;
2019-09-18 12:55:17 +00:00
}
2018-10-08 19:05:47 +00:00
2019-09-19 11:46:42 +00:00
return (
$ val =~ /^(?:[01]\d|2[0-3]):(?:[0-5]\d)(:(?:[0-5]\d))?$/
2019-09-18 12:55:17 +00:00
? $ val
2019-09-19 11:46:42 +00:00
: '08:00'
) ;
2018-10-08 19:05:47 +00:00
}
2018-10-16 08:30:10 +00:00
sub getBrightnessMinVal {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-16 08:30:10 +00:00
2019-04-09 10:13:46 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor } - > { triggermin }
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor }
- > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor }
- > { LASTGETTIME } ) < 2
) ;
2019-03-07 16:58:30 +00:00
$ shutters - > _getBrightnessSensor ;
2019-04-09 10:13:46 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor }
- > { triggermin } ;
2018-10-16 08:30:10 +00:00
}
sub getBrightnessMaxVal {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-16 08:30:10 +00:00
2019-04-09 10:13:46 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor } - > { triggermax }
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor }
- > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor }
- > { LASTGETTIME } ) < 2
) ;
2019-03-07 16:58:30 +00:00
$ shutters - > _getBrightnessSensor ;
2019-04-09 10:13:46 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_BrightnessSensor }
- > { triggermax } ;
2018-10-16 08:30:10 +00:00
}
2019-04-25 15:15:56 +00:00
sub getDriveUpMaxDuration {
my $ self = shift ;
2019-04-25 19:34:46 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_DriveUpMaxDuration' , 60 ) ;
2019-04-25 15:15:56 +00:00
}
2018-10-09 16:05:55 +00:00
## Subklasse Readings von ASC_Shutters ##
package ASC_Shutters::Readings ;
2018-10-08 19:05:47 +00:00
use strict ;
use warnings ;
2018-11-07 07:22:11 +00:00
use GPUtils qw( GP_Import ) ;
2018-10-08 19:05:47 +00:00
## Import der FHEM Funktionen
BEGIN {
2018-10-14 16:19:23 +00:00
GP_Import (
qw(
2018-11-29 20:33:08 +00:00
ReadingsVal
ReadingsNum )
2018-10-14 16:19:23 +00:00
) ;
}
2018-10-08 19:05:47 +00:00
2018-10-12 04:32:01 +00:00
sub getBrightness {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-10 08:43:42 +00:00
2019-02-28 08:05:23 +00:00
return ReadingsNum ( $ shutters - > _getBrightnessSensor ,
2018-12-07 11:57:45 +00:00
$ shutters - > getBrightnessReading , - 1 ) ;
2018-10-12 04:32:01 +00:00
}
2018-10-10 08:43:42 +00:00
2019-02-28 08:05:23 +00:00
sub getWindStatus {
my $ self = shift ;
2019-03-04 07:40:58 +00:00
return ReadingsVal ( $ ascDev - > _getWindSensor ,
$ ascDev - > getWindSensorReading , - 1 ) ;
2019-02-28 08:05:23 +00:00
}
2018-10-10 08:43:42 +00:00
sub getStatus {
2018-10-27 11:36:11 +00:00
my $ self = shift ;
2018-10-10 08:43:42 +00:00
2018-11-29 20:33:08 +00:00
return ReadingsNum ( $ self - > { shuttersDev } , $ shutters - > getPosCmd , 0 ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getDelayCmd {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2018-10-27 11:36:11 +00:00
return $ self - > { $ self - > { shuttersDev } } { delayCmd } ;
2018-10-08 19:05:47 +00:00
}
2019-05-17 12:20:57 +00:00
sub getASCenable {
my $ self = shift ;
return ReadingsVal ( $ self - > { shuttersDev } , 'ASC_Enable' , 'on' ) ;
}
2018-10-10 08:43:42 +00:00
## Klasse Fenster (Window) und die Subklassen Attr und Readings ##
package ASC_Window ;
2018-10-14 16:19:23 +00:00
our @ ISA = qw( ASC_Window::Attr ASC_Window::Readings ) ;
2018-10-10 08:43:42 +00:00
## Subklasse Attr von Klasse ASC_Window ##
package ASC_Window::Attr ;
2018-10-08 19:05:47 +00:00
2018-10-10 08:43:42 +00:00
use strict ;
use warnings ;
2018-11-07 07:22:11 +00:00
use GPUtils qw( GP_Import ) ;
2018-10-10 08:43:42 +00:00
## Import der FHEM Funktionen
BEGIN {
2018-10-14 16:19:23 +00:00
GP_Import (
qw(
2019-11-08 08:31:41 +00:00
AttrVal
gettimeofday )
2018-10-14 16:19:23 +00:00
) ;
}
2018-10-10 08:43:42 +00:00
sub getSubTyp {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
2018-10-10 08:43:42 +00:00
2019-04-25 15:15:56 +00:00
return AttrVal ( $ self - > { shuttersDev } , 'ASC_WindowRec_subType' , 'twostate' ) ;
2018-10-10 08:43:42 +00:00
}
2018-11-03 18:01:29 +00:00
sub _getWinDev {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
2018-10-10 08:43:42 +00:00
2019-11-08 08:31:41 +00:00
return $ self - > { $ self - > { shuttersDev } } - > { ASC_WindowRec } - > { device }
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindowRec } - > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindowRec } - > { LASTGETTIME } ) <
2
) ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindowRec } - > { LASTGETTIME } =
int ( gettimeofday ( ) ) ;
my ( $ device , $ reading ) =
FHEM::AutoShuttersControl:: GetAttrValues ( $ self - > { shuttersDev } ,
'ASC_WindowRec' , 'none' ) ;
### erwartetes Ergebnis
# DEVICE:READING VALUEACTIVE:VALUEINACTIVE POSACTIVE:POSINACTIVE
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindowRec } - > { device } =
$ device ;
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindowRec } - > { reading } =
( $ reading ne 'none' ? $ reading : 'state' ) ;
return $ self - > { $ self - > { shuttersDev } } - > { ASC_WindowRec } - > { device } ;
}
sub getWinDevReading {
my $ self = shift ;
return $ self - > { $ self - > { shuttersDev } } - > { ASC_WindowRec } - > { reading }
if (
exists (
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindowRec } - > { LASTGETTIME }
)
and ( gettimeofday ( ) -
$ self - > { $ self - > { shuttersDev } } - > { ASC_WindowRec } - > { LASTGETTIME } ) <
2
) ;
$ shutters - > _getWinDev ;
return $ self - > { $ self - > { shuttersDev } } - > { ASC_WindowRec } - > { reading } ;
2018-10-10 08:43:42 +00:00
}
## Subklasse Readings von Klasse ASC_Window ##
package ASC_Window::Readings ;
use strict ;
use warnings ;
2018-11-07 07:22:11 +00:00
use GPUtils qw( GP_Import ) ;
2018-10-10 08:43:42 +00:00
## Import der FHEM Funktionen
BEGIN {
2018-10-14 16:19:23 +00:00
GP_Import (
qw(
ReadingsVal )
) ;
}
2018-10-10 08:43:42 +00:00
sub getWinStatus {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
2018-10-10 08:43:42 +00:00
2019-11-08 08:31:41 +00:00
return ReadingsVal ( $ shutters - > _getWinDev , $ shutters - > getWinDevReading ,
'closed' ) ;
2018-10-08 19:05:47 +00:00
}
## Klasse ASC_Roommate ##
package ASC_Roommate ;
use strict ;
use warnings ;
2018-11-07 07:22:11 +00:00
use GPUtils qw( GP_Import ) ;
2018-10-08 19:05:47 +00:00
## Import der FHEM Funktionen
BEGIN {
2018-10-14 16:19:23 +00:00
GP_Import (
qw(
ReadingsVal )
) ;
}
2018-10-08 19:05:47 +00:00
2018-11-03 18:01:29 +00:00
sub _getRoommateStatus {
2018-10-14 16:19:23 +00:00
my $ self = shift ;
my $ roommate = $ self - > { roommate } ;
2018-10-08 19:05:47 +00:00
2019-04-25 21:07:18 +00:00
return ReadingsVal ( $ roommate , $ shutters - > getRoommatesReading , 'none' ) ;
2018-10-08 19:05:47 +00:00
}
2018-11-03 18:01:29 +00:00
sub _getRoommateLastStatus {
2018-10-14 16:19:23 +00:00
my $ self = shift ;
my $ roommate = $ self - > { roommate } ;
my $ default = $ self - > { defaultarg } ;
2018-10-08 19:05:47 +00:00
2018-10-28 17:12:40 +00:00
$ default = 'none' if ( not defined ( $ default ) ) ;
2018-10-14 16:19:23 +00:00
return ReadingsVal ( $ roommate , 'lastState' , $ default ) ;
2018-10-08 19:05:47 +00:00
}
## Klasse ASC_Dev plus Subklassen ASC_Attr_Dev und ASC_Readings_Dev##
package ASC_Dev ;
2018-10-14 16:19:23 +00:00
our @ ISA = qw( ASC_Dev::Readings ASC_Dev::Attr ) ;
2018-10-08 19:05:47 +00:00
use strict ;
use warnings ;
sub new {
2018-10-14 16:19:23 +00:00
my $ class = shift ;
my $ self = { name = > undef , } ;
2018-10-08 19:05:47 +00:00
bless $ self , $ class ;
return $ self ;
}
2018-10-10 08:43:42 +00:00
sub setName {
2018-10-14 16:19:23 +00:00
my ( $ self , $ name ) = @ _ ;
2018-10-17 07:50:11 +00:00
2018-10-14 16:19:23 +00:00
$ self - > { name } = $ name if ( defined ( $ name ) ) ;
2018-10-10 08:43:42 +00:00
return $ self - > { name } ;
}
sub setDefault {
2018-10-14 16:19:23 +00:00
my ( $ self , $ defaultarg ) = @ _ ;
2018-10-17 07:50:11 +00:00
2018-10-14 16:19:23 +00:00
$ self - > { defaultarg } = $ defaultarg if ( defined ( $ defaultarg ) ) ;
2018-10-10 08:43:42 +00:00
return $ self - > { defaultarg } ;
}
2019-04-02 17:28:54 +00:00
sub getName {
2019-04-09 10:13:46 +00:00
my $ self = shift ;
2019-04-02 17:28:54 +00:00
return $ self - > { name } ;
}
2018-10-09 16:05:55 +00:00
## Subklasse Readings ##
package ASC_Dev::Readings ;
2018-10-08 19:05:47 +00:00
use strict ;
use warnings ;
2018-11-07 07:22:11 +00:00
use GPUtils qw( GP_Import ) ;
2018-10-08 19:05:47 +00:00
## Import der FHEM Funktionen
BEGIN {
2018-10-14 16:19:23 +00:00
GP_Import (
qw(
2018-10-27 11:36:11 +00:00
readingsSingleUpdate
ReadingsVal
defs )
2018-10-14 16:19:23 +00:00
) ;
}
2018-10-08 19:05:47 +00:00
2018-10-27 11:36:11 +00:00
sub setDelayCmdReading {
my $ self = shift ;
my $ name = $ self - > { name } ;
my $ hash = $ defs { $ name } ;
readingsSingleUpdate ( $ hash ,
$ shutters - > getShuttersDev . '_lastDelayPosValue' ,
$ shutters - > getDelayCmd , 1 ) ;
return 0 ;
}
2018-11-07 07:22:11 +00:00
sub setStateReading {
2018-11-08 07:32:47 +00:00
my $ self = shift ;
my $ value = shift ;
my $ name = $ self - > { name } ;
my $ hash = $ defs { $ name } ;
2018-11-07 07:22:11 +00:00
2018-11-08 07:32:47 +00:00
readingsSingleUpdate ( $ hash , 'state' ,
( defined ( $ value ) ? $ value : $ shutters - > getLastDrive ) , 1 ) ;
2018-11-07 07:22:11 +00:00
return 0 ;
}
2018-11-04 18:17:11 +00:00
sub setPosReading {
my $ self = shift ;
my $ name = $ self - > { name } ;
my $ hash = $ defs { $ name } ;
readingsSingleUpdate ( $ hash , $ shutters - > getShuttersDev . '_PosValue' ,
$ shutters - > getStatus , 1 ) ;
return 0 ;
}
2018-10-27 11:36:11 +00:00
sub setLastPosReading {
my $ self = shift ;
my $ name = $ self - > { name } ;
my $ hash = $ defs { $ name } ;
readingsSingleUpdate ( $ hash , $ shutters - > getShuttersDev . '_lastPosValue' ,
$ shutters - > getLastPos , 1 ) ;
return 0 ;
}
2018-11-03 18:01:29 +00:00
sub getPartyMode {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-10-08 19:05:47 +00:00
2019-04-27 18:58:17 +00:00
return ReadingsVal ( $ name , 'partyMode' , 'off' ) ;
2018-10-08 19:05:47 +00:00
}
2018-12-06 14:24:16 +00:00
sub getHardLockOut {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-10-08 19:05:47 +00:00
2019-04-25 15:15:56 +00:00
return ReadingsVal ( $ name , 'hardLockOut' , 'none' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getSunriseTimeWeHoliday {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-10-08 19:05:47 +00:00
2019-04-25 15:15:56 +00:00
return ReadingsVal ( $ name , 'sunriseTimeWeHoliday' , 'none' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getMonitoredDevs {
2018-10-14 16:19:23 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-10-08 19:05:47 +00:00
2018-10-14 16:19:23 +00:00
$ self - > { monitoredDevs } = ReadingsVal ( $ name , '.monitoredDevs' , 'none' ) ;
2018-10-08 19:05:47 +00:00
return $ self - > { monitoredDevs } ;
}
2018-10-10 08:43:42 +00:00
sub getOutTemp {
2018-10-14 16:19:23 +00:00
my $ self = shift ;
2018-10-08 19:05:47 +00:00
2019-06-21 12:20:08 +00:00
return ReadingsVal ( $ ascDev - > _getTempSensor , $ ascDev - > getTempSensorReading ,
2018-11-19 08:06:50 +00:00
- 100 ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getResidentsStatus {
2018-10-14 16:19:23 +00:00
my $ self = shift ;
2019-05-24 09:31:07 +00:00
my $ val =
ReadingsVal ( $ ascDev - > _getResidentsDev , $ ascDev - > getResidentsReading ,
2018-10-28 17:12:40 +00:00
'none' ) ;
2019-05-24 09:31:07 +00:00
if ( $ val =~ m/^(?:(.+)_)?(.+)$/ ) {
return ( $ 1 , $ 2 ) if ( wantarray ) ;
return $ 1 && $ 1 eq 'pet' ? 'absent' : $ 2 ;
}
elsif (
2019-05-24 09:36:06 +00:00
ReadingsVal ( $ ascDev - > _getResidentsDev , 'homealoneType' , '-' ) eq
'PET' )
2019-05-24 09:31:07 +00:00
{
return ( 'pet' , 'absent' ) if ( wantarray ) ;
return 'absent' ;
}
else {
return ( undef , $ val ) if ( wantarray ) ;
return $ val ;
}
2018-10-09 16:05:55 +00:00
}
2018-10-14 16:19:23 +00:00
sub getResidentsLastStatus {
my $ self = shift ;
2019-05-24 09:31:07 +00:00
my $ val = ReadingsVal ( $ ascDev - > _getResidentsDev , 'lastState' , 'none' ) ;
2018-10-09 16:05:55 +00:00
2019-05-24 09:31:07 +00:00
if ( $ val =~ m/^(?:(.+)_)?(.+)$/ ) {
return ( $ 1 , $ 2 ) if ( wantarray ) ;
return $ 1 && $ 1 eq 'pet' ? 'absent' : $ 2 ;
}
elsif (
2019-05-24 09:36:06 +00:00
ReadingsVal ( $ ascDev - > _getResidentsDev , 'lastHomealoneType' , '-' ) eq
'PET' )
2019-05-24 09:31:07 +00:00
{
return ( 'pet' , 'absent' ) if ( wantarray ) ;
return 'absent' ;
}
else {
return ( undef , $ val ) if ( wantarray ) ;
return $ val ;
}
2018-10-09 16:05:55 +00:00
}
2019-05-04 21:01:57 +00:00
sub getAutoShuttersControlShading {
my $ self = shift ;
my $ name = $ self - > { name } ;
return ReadingsVal ( $ name , 'controlShading' , 'none' ) ;
}
2018-10-14 16:19:23 +00:00
sub getSelfDefense {
my $ self = shift ;
my $ name = $ self - > { name } ;
return ReadingsVal ( $ name , 'selfDefense' , 'none' ) ;
}
2018-10-08 19:05:47 +00:00
2018-11-14 02:41:38 +00:00
sub getAzimuth {
my $ self = shift ;
2018-11-14 14:26:32 +00:00
my $ azimuth ;
2018-11-19 08:06:50 +00:00
$ azimuth = ReadingsVal ( $ ascDev - > _getTwilightDevice , 'azimuth' , - 1 )
if ( $ defs { $ ascDev - > _getTwilightDevice } - > { TYPE } eq 'Twilight' ) ;
$ azimuth = ReadingsVal ( $ ascDev - > _getTwilightDevice , 'SunAz' , - 1 )
if ( $ defs { $ ascDev - > _getTwilightDevice } - > { TYPE } eq 'Astro' ) ;
2018-11-14 14:26:32 +00:00
return $ azimuth ;
2018-11-14 02:41:38 +00:00
}
sub getElevation {
my $ self = shift ;
2018-11-14 14:26:32 +00:00
my $ elevation ;
2018-11-19 08:06:50 +00:00
$ elevation = ReadingsVal ( $ ascDev - > _getTwilightDevice , 'elevation' , - 1 )
if ( $ defs { $ ascDev - > _getTwilightDevice } - > { TYPE } eq 'Twilight' ) ;
$ elevation = ReadingsVal ( $ ascDev - > _getTwilightDevice , 'SunAlt' , - 1 )
if ( $ defs { $ ascDev - > _getTwilightDevice } - > { TYPE } eq 'Astro' ) ;
2018-11-14 14:26:32 +00:00
return $ elevation ;
2018-11-14 02:41:38 +00:00
}
2019-05-17 12:20:57 +00:00
sub getASCenable {
my $ self = shift ;
my $ name = $ self - > { name } ;
return ReadingsVal ( $ name , 'ascEnable' , 'none' ) ;
}
2018-10-09 16:05:55 +00:00
## Subklasse Attr ##
package ASC_Dev::Attr ;
2018-10-08 19:05:47 +00:00
use strict ;
use warnings ;
2018-11-07 07:22:11 +00:00
use GPUtils qw( GP_Import ) ;
2018-10-08 19:05:47 +00:00
## Import der FHEM Funktionen
BEGIN {
2018-10-14 16:19:23 +00:00
GP_Import (
qw(
2019-03-06 14:53:48 +00:00
AttrVal
gettimeofday )
2018-10-14 16:19:23 +00:00
) ;
}
2018-10-08 19:05:47 +00:00
2018-10-30 07:18:09 +00:00
sub getShuttersOffset {
2018-10-30 18:10:50 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2019-09-17 12:03:36 +00:00
return AttrVal ( $ name , 'ASC_shuttersDriveDelay' , - 1 ) ;
2018-10-30 07:18:09 +00:00
}
2018-10-12 04:32:01 +00:00
sub getBrightnessMinVal {
2019-04-09 10:13:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-10-12 04:32:01 +00:00
2019-04-09 10:13:46 +00:00
return $ self - > { ASC_brightness } - > { triggermin }
if ( exists ( $ self - > { ASC_brightness } - > { LASTGETTIME } )
and ( gettimeofday ( ) - $ self - > { ASC_brightness } - > { LASTGETTIME } ) < 2 ) ;
2019-03-12 22:02:02 +00:00
$ ascDev - > getBrightnessMaxVal ;
2019-04-09 10:13:46 +00:00
2019-03-12 22:02:02 +00:00
return $ self - > { ASC_brightness } - > { triggermin } ;
2018-10-12 04:32:01 +00:00
}
sub getBrightnessMaxVal {
2019-04-09 10:13:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
return $ self - > { ASC_brightness } - > { triggermax }
if ( exists ( $ self - > { ASC_brightness } - > { LASTGETTIME } )
and ( gettimeofday ( ) - $ self - > { ASC_brightness } - > { LASTGETTIME } ) < 2 ) ;
$ self - > { ASC_brightness } - > { LASTGETTIME } = int ( gettimeofday ( ) ) ;
2019-04-20 16:18:50 +00:00
2019-04-17 14:25:05 +00:00
my ( $ triggermax , $ triggermin ) =
2019-04-09 10:13:46 +00:00
FHEM::AutoShuttersControl:: GetAttrValues ( $ name ,
2019-04-25 15:15:56 +00:00
'ASC_brightnessDriveUpDown' , '800:500' ) ;
2018-10-08 19:05:47 +00:00
2019-03-12 22:02:02 +00:00
## erwartetes Ergebnis
# max:min
2019-04-25 15:15:56 +00:00
$ self - > { ASC_brightness } - > { triggermin } = $ triggermin ;
$ self - > { ASC_brightness } - > { triggermax } = $ triggermax ;
2019-03-12 22:02:02 +00:00
return $ self - > { ASC_brightness } - > { triggermax } ;
2018-10-12 04:32:01 +00:00
}
2018-10-08 19:05:47 +00:00
2018-11-14 02:41:38 +00:00
sub _getTwilightDevice {
2018-11-19 08:06:50 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-11-14 02:41:38 +00:00
return AttrVal ( $ name , 'ASC_twilightDevice' , 'none' ) ;
}
2018-10-10 08:43:42 +00:00
sub getAutoAstroModeEvening {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-10-08 19:05:47 +00:00
2019-05-04 21:01:57 +00:00
return AttrVal ( $ name , 'ASC_autoAstroModeEvening' , 'REAL' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getAutoAstroModeEveningHorizon {
2018-10-14 16:19:23 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-10-08 19:05:47 +00:00
2018-10-14 16:19:23 +00:00
return AttrVal ( $ name , 'ASC_autoAstroModeEveningHorizon' , 0 ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getAutoAstroModeMorning {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-10-08 19:05:47 +00:00
2019-05-04 21:01:57 +00:00
return AttrVal ( $ name , 'ASC_autoAstroModeMorning' , 'REAL' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getAutoAstroModeMorningHorizon {
2018-10-14 16:19:23 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-10-08 19:05:47 +00:00
2018-10-14 16:19:23 +00:00
return AttrVal ( $ name , 'ASC_autoAstroModeMorningHorizon' , 0 ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getAutoShuttersControlMorning {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-10-08 19:05:47 +00:00
2019-05-04 21:01:57 +00:00
return AttrVal ( $ name , 'ASC_autoShuttersControlMorning' , 'on' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getAutoShuttersControlEvening {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-10-08 19:05:47 +00:00
2019-05-04 21:01:57 +00:00
return AttrVal ( $ name , 'ASC_autoShuttersControlEvening' , 'on' ) ;
2018-10-08 19:05:47 +00:00
}
2018-10-10 08:43:42 +00:00
sub getAutoShuttersControlComfort {
2018-10-14 16:19:23 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-10-08 19:05:47 +00:00
2018-10-14 16:19:23 +00:00
return AttrVal ( $ name , 'ASC_autoShuttersControlComfort' , 'off' ) ;
2018-10-08 19:05:47 +00:00
}
2018-11-12 11:56:18 +00:00
sub getFreezeTemp {
2019-04-25 19:34:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-10-08 19:05:47 +00:00
2019-04-25 15:15:56 +00:00
return AttrVal ( $ name , 'ASC_freezeTemp' , 3 ) ;
2018-10-08 19:05:47 +00:00
}
2018-11-12 11:56:18 +00:00
sub _getTempSensor {
2019-04-09 10:13:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
return $ self - > { ASC_tempSensor } - > { device }
if ( exists ( $ self - > { ASC_tempSensor } - > { LASTGETTIME } )
and ( gettimeofday ( ) - $ self - > { ASC_tempSensor } - > { LASTGETTIME } ) < 2 ) ;
$ self - > { ASC_tempSensor } - > { LASTGETTIME } = int ( gettimeofday ( ) ) ;
my ( $ device , $ reading ) =
FHEM::AutoShuttersControl:: GetAttrValues ( $ name , 'ASC_tempSensor' ,
'none' ) ;
2018-10-08 19:05:47 +00:00
2019-03-12 22:02:02 +00:00
## erwartetes Ergebnis
# DEVICE:READING
2019-03-06 14:53:48 +00:00
2019-04-09 10:13:46 +00:00
return $ device if ( $ device eq 'none' ) ;
2019-03-12 22:02:02 +00:00
$ self - > { ASC_tempSensor } - > { device } = $ device ;
2019-04-09 10:13:46 +00:00
$ self - > { ASC_tempSensor } - > { reading } =
( $ reading ne 'none' ? $ reading : 'temperature' ) ;
2019-03-06 14:53:48 +00:00
return $ self - > { ASC_tempSensor } - > { device } ;
2018-10-08 19:05:47 +00:00
}
2019-06-21 12:20:08 +00:00
sub getTempSensorReading {
2019-04-09 10:13:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
return $ self - > { ASC_tempSensor } - > { reading }
if ( exists ( $ self - > { ASC_tempSensor } - > { LASTGETTIME } )
and ( gettimeofday ( ) - $ self - > { ASC_tempSensor } - > { LASTGETTIME } ) < 2 ) ;
2019-03-06 14:53:48 +00:00
$ ascDev - > _getTempSensor ;
2019-03-12 22:02:02 +00:00
return $ self - > { ASC_tempSensor } - > { reading } ;
2018-10-08 19:05:47 +00:00
}
2018-08-15 08:27:53 +00:00
2018-11-03 18:01:29 +00:00
sub _getResidentsDev {
2019-04-09 10:13:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2018-10-09 16:05:55 +00:00
2019-04-09 10:13:46 +00:00
return $ self - > { ASC_residentsDev } - > { device }
if ( exists ( $ self - > { ASC_residentsDev } - > { LASTGETTIME } )
and ( gettimeofday ( ) - $ self - > { ASC_residentsDev } - > { LASTGETTIME } ) < 2 ) ;
$ self - > { ASC_residentsDev } - > { LASTGETTIME } = int ( gettimeofday ( ) ) ;
my ( $ device , $ reading ) =
FHEM::AutoShuttersControl:: GetAttrValues ( $ name , 'ASC_residentsDev' ,
'none' ) ;
2019-03-12 22:02:02 +00:00
$ self - > { ASC_residentsDev } - > { device } = $ device ;
2019-04-09 10:13:46 +00:00
$ self - > { ASC_residentsDev } - > { reading } =
( $ reading ne 'none' ? $ reading : 'state' ) ;
2019-03-06 14:53:48 +00:00
return $ self - > { ASC_residentsDev } - > { device } ;
2018-10-09 16:05:55 +00:00
}
2018-10-10 08:43:42 +00:00
sub getResidentsReading {
2019-04-09 10:13:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
return $ self - > { ASC_residentsDev } - > { reading }
if ( exists ( $ self - > { ASC_residentsDev } - > { LASTGETTIME } )
and ( gettimeofday ( ) - $ self - > { ASC_residentsDev } - > { LASTGETTIME } ) < 2 ) ;
2019-03-06 14:53:48 +00:00
$ ascDev - > _getResidentsDev ;
2019-03-12 22:02:02 +00:00
return $ self - > { ASC_residentsDev } - > { reading } ;
2018-10-09 16:05:55 +00:00
}
2018-10-27 11:36:11 +00:00
2019-03-06 14:53:48 +00:00
sub _getRainSensor {
2019-04-09 10:13:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
return $ self - > { ASC_rainSensor } - > { device }
if ( exists ( $ self - > { ASC_rainSensor } - > { LASTGETTIME } )
and ( gettimeofday ( ) - $ self - > { ASC_rainSensor } - > { LASTGETTIME } ) < 2 ) ;
$ self - > { ASC_rainSensor } - > { LASTGETTIME } = int ( gettimeofday ( ) ) ;
2019-10-04 04:14:54 +00:00
my ( $ device , $ reading , $ max , $ hyst , $ pos , $ wait ) =
2019-04-09 10:13:46 +00:00
FHEM::AutoShuttersControl:: GetAttrValues ( $ name , 'ASC_rainSensor' ,
'none' ) ;
2018-10-27 11:36:11 +00:00
2019-03-12 22:02:02 +00:00
## erwartetes Ergebnis
# DEVICE:READING MAX:HYST
2019-04-09 10:13:46 +00:00
return $ device if ( $ device eq 'none' ) ;
2019-03-12 22:02:02 +00:00
$ self - > { ASC_rainSensor } - > { device } = $ device ;
2019-04-09 10:13:46 +00:00
$ self - > { ASC_rainSensor } - > { reading } =
( $ reading ne 'none' ? $ reading : 'state' ) ;
2019-03-12 22:02:02 +00:00
$ self - > { ASC_rainSensor } - > { triggermax } = ( $ max ne 'none' ? $ max : 1000 ) ;
2019-04-30 07:56:19 +00:00
$ self - > { ASC_rainSensor } - > { triggerhyst } = (
$ hyst ne 'none'
2019-04-29 11:24:01 +00:00
? $ max - $ hyst
2019-04-30 07:56:19 +00:00
: ( $ self - > { ASC_rainSensor } - > { triggermax } * 0 )
) ;
2019-04-09 10:13:46 +00:00
$ self - > { ASC_rainSensor } - > { shuttersClosedPos } =
2019-04-29 09:04:27 +00:00
( $ pos ne 'none' ? $ pos : $ shutters - > getClosedPos ) ;
2019-10-04 04:14:54 +00:00
$ self - > { ASC_rainSensor } - > { waitingTime } =
( $ pos ne 'none' ? $ wait : 900 ) ;
2019-04-09 10:13:46 +00:00
2019-03-06 14:53:48 +00:00
return $ self - > { ASC_rainSensor } - > { device } ;
2018-10-27 11:36:11 +00:00
}
sub getRainSensorReading {
2019-04-09 10:13:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
return $ self - > { ASC_rainSensor } - > { reading }
if ( exists ( $ self - > { ASC_rainSensor } - > { LASTGETTIME } )
and ( gettimeofday ( ) - $ self - > { ASC_rainSensor } - > { LASTGETTIME } ) < 2 ) ;
2019-03-06 14:53:48 +00:00
$ ascDev - > _getRainSensor ;
2019-03-12 22:02:02 +00:00
return $ self - > { ASC_rainSensor } - > { reading } ;
2019-03-06 14:53:48 +00:00
}
2018-10-27 11:36:11 +00:00
2019-03-06 14:53:48 +00:00
sub getRainTriggerMax {
my $ self = shift ;
my $ name = $ self - > { name } ;
2019-04-09 10:13:46 +00:00
return $ self - > { ASC_rainSensor } - > { triggermax }
if ( exists ( $ self - > { ASC_rainSensor } - > { LASTGETTIME } )
and ( gettimeofday ( ) - $ self - > { ASC_rainSensor } - > { LASTGETTIME } ) < 2 ) ;
2019-03-06 14:53:48 +00:00
$ ascDev - > _getRainSensor ;
2019-03-12 22:02:02 +00:00
return $ self - > { ASC_rainSensor } - > { triggermax } ;
2019-03-06 14:53:48 +00:00
}
sub getRainTriggerMin {
my $ self = shift ;
my $ name = $ self - > { name } ;
2019-04-09 10:13:46 +00:00
return $ self - > { ASC_rainSensor } - > { triggerhyst }
if ( exists ( $ self - > { ASC_rainSensor } - > { LASTGETTIME } )
and ( gettimeofday ( ) - $ self - > { ASC_rainSensor } - > { LASTGETTIME } ) < 2 ) ;
2019-03-06 14:53:48 +00:00
$ ascDev - > _getRainSensor ;
2019-03-12 22:02:02 +00:00
return $ self - > { ASC_rainSensor } - > { triggerhyst } ;
2018-10-27 11:36:11 +00:00
}
sub getRainSensorShuttersClosedPos {
my $ self = shift ;
my $ name = $ self - > { name } ;
2019-04-09 10:13:46 +00:00
return $ self - > { ASC_rainSensor } - > { shuttersClosedPos }
if ( exists ( $ self - > { ASC_rainSensor } - > { LASTGETTIME } )
and ( gettimeofday ( ) - $ self - > { ASC_rainSensor } - > { LASTGETTIME } ) < 2 ) ;
2019-03-06 14:53:48 +00:00
$ ascDev - > _getRainSensor ;
2019-03-12 22:02:02 +00:00
return $ self - > { ASC_rainSensor } - > { shuttersClosedPos } ;
2018-10-27 11:36:11 +00:00
}
2019-02-26 11:04:10 +00:00
2019-10-04 04:14:54 +00:00
sub getRainWaitingTime {
my $ self = shift ;
my $ name = $ self - > { name } ;
return $ self - > { ASC_rainSensor } - > { waitingTime }
if ( exists ( $ self - > { ASC_rainSensor } - > { LASTGETTIME } )
and ( gettimeofday ( ) - $ self - > { ASC_rainSensor } - > { LASTGETTIME } ) < 2 ) ;
$ ascDev - > _getRainSensor ;
return $ self - > { ASC_rainSensor } - > { waitingTime } ;
}
2019-03-04 07:40:58 +00:00
sub _getWindSensor {
2019-04-09 10:13:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2019-03-07 09:52:23 +00:00
2019-04-09 10:13:46 +00:00
return $ self - > { ASC_windSensor } - > { device }
if ( exists ( $ self - > { ASC_windSensor } - > { LASTGETTIME } )
and ( gettimeofday ( ) - $ self - > { ASC_windSensor } - > { LASTGETTIME } ) < 2 ) ;
$ self - > { ASC_windSensor } - > { LASTGETTIME } = int ( gettimeofday ( ) ) ;
my ( $ device , $ reading ) =
FHEM::AutoShuttersControl:: GetAttrValues ( $ name , 'ASC_windSensor' ,
'none' ) ;
return $ device if ( $ device eq 'none' ) ;
2019-03-12 22:02:02 +00:00
$ self - > { ASC_windSensor } - > { device } = $ device ;
2019-04-09 10:13:46 +00:00
$ self - > { ASC_windSensor } - > { reading } =
( $ reading ne 'none' ? $ reading : 'wind' ) ;
2019-03-04 07:40:58 +00:00
2019-03-06 14:53:48 +00:00
return $ self - > { ASC_windSensor } - > { device } ;
2019-03-04 07:40:58 +00:00
}
sub getWindSensorReading {
2019-04-09 10:13:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2019-03-04 07:40:58 +00:00
2019-04-09 10:13:46 +00:00
return $ self - > { ASC_windSensor } - > { reading }
if ( exists ( $ self - > { ASC_windSensor } - > { LASTGETTIME } )
and ( gettimeofday ( ) - $ self - > { ASC_windSensor } - > { LASTGETTIME } ) < 2 ) ;
2019-03-06 14:53:48 +00:00
$ ascDev - > _getWindSensor ;
2019-04-09 10:13:46 +00:00
return (
defined ( $ self - > { ASC_windSensor } - > { reading } )
? $ self - > { ASC_windSensor } - > { reading }
2019-04-20 16:18:50 +00:00
: 'wind'
) ;
2019-03-04 07:40:58 +00:00
}
2019-03-27 10:22:06 +00:00
sub getblockAscDrivesAfterManual {
2019-04-09 10:13:46 +00:00
my $ self = shift ;
my $ name = $ self - > { name } ;
2019-03-27 10:22:06 +00:00
return AttrVal ( $ name , 'ASC_blockAscDrivesAfterManual' , 0 ) ;
}
2018-08-15 08:27:53 +00:00
1 ;
= pod
= item device
2019-03-27 07:41:15 +00:00
= item summary Module for controlling shutters depending on various conditions
2019-06-10 13:16:38 +00:00
= item summary_DE Modul zur automatischen Rolladensteuerung auf Basis bestimmter Ereignisse
2018-08-15 08:27:53 +00:00
= begin html
< a name = "AutoShuttersControl" > </a>
2019-05-09 16:45:30 +00:00
<h3> AutoShuttersControl </h3>
2019-06-03 09:54:27 +00:00
<ul>
<p>
AutoShuttersControl ( <abbr> ASC </abbr> ) provides a complete automation for shutters with comprehensive
configuration options , <abbr> e . g . </abbr> open or close shutters depending on the sunrise or sunset ,
by outdoor brightness or randomly for simulate presence .
2019-10-24 08:41:38 +00:00
< br / > <strong>
So that ASC can drive the blinds on the basis of the astronomical times , it is very important to
correctly set the location ( latitude , longitude ) in the device "global" . </strong>
2019-06-03 09:54:27 +00:00
</p>
<p>
After telling <abbr> ASC </abbr> which shutters should be controlled , several in - depth configuration options
are provided . With these and in combination with a resident presence state , complex scenarios are possible:
For example , shutters could be opened if a resident awakes from sleep and the sun is already rosen . Or if a
closed window with shutters down is tilted , the shutters could be half opened for ventilation .
Many more is possible .
</p>
< a name = "AutoShuttersControlDefine" > </a>
<strong> Define </strong>
<ul>
2019-06-06 06:03:29 +00:00
<p>
<code> define & lt ; name & gt ; AutoShuttersControl </code>
</p>
2019-06-03 09:54:27 +00:00
Usage:
2019-06-06 06:03:29 +00:00
<p>
<ul>
<code> define myASControl AutoShuttersControl </code> <br/>
</ul>
</p>
<p>
This creates an new AutoShuttersControl device , called <em> myASControl </em> . <br/>
Now was the new global attribute <var> ASC </var> added to the <abbr> FHEM </abbr> installation .
Each shutter that is to be controlled by AutoShuttersControl must now have the attribute ASC set to 1 or 2 .
The value 1 is to be used with devices whose state is given as position ( i . e . ROLLO or Siro , shutters
openend is 0 , shutters closed is 100 ) , 2 with devices whose state is given as percent closed ( i . e . HomeMatic ,
shutters opened is 100 , closed is 0 ) .
</p>
<p>
After setting the attributes to all devices who should be controlled , the automatic scan at the main device
can be started for example with <br/>
<code> set myASControl scanForShutters </code>
</p>
2019-06-03 09:54:27 +00:00
</ul>
<br/>
< a name = "AutoShuttersControlReadings" > </a>
<strong> Readings </strong>
<ul>
2019-06-06 06:03:29 +00:00
<p> Within the ASC device: </p>
2019-06-03 09:54:27 +00:00
<ul>
<li> <strong> ... _nextAstroTimeEvent </strong> - Next astro event: sunrise , sunset or fixed time </li>
<li> <strong> ... _PosValue </strong> - current position </li>
<li> <strong> ... _lastPosValue </strong> - shutters last position </li>
<li> <strong> ... _lastDelayPosValue </strong> - last specified order , will be executed with the next matching
event
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> partyMode on | off </strong> - is working mode set to part ? y </li>
<li> <strong> ascEnable on | off </strong> - are the associated shutters control by ASC completely ? </li>
<li> <strong> controlShading on | off </strong> - are the associated shutters controlled for shading by ASC ?
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> hardLockOut on | off </strong> - switch for preventing a global hard lock out </li>
2019-06-03 09:54:27 +00:00
<li> <strong> room_ ... </strong> - list of every found shutter for every room: room_Sleeping: Patio </li>
<li> <strong> selfDefense </strong> - state of the self defense mode </li>
<li> <strong> state </strong> - state of the ASC device: active , enabled , disabled or other state information
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> sunriseTimeWeHoliday on | off </strong> - state of the weekend and holiday support </li>
2019-06-03 09:54:27 +00:00
<li> <strong> userAttrList </strong> - ASC sets some user defined attributes ( <abbr> <em> userattr </em> </abbr> )
for the shutter devices . This readings shows the current state of the given user attributes to the
shutter devices .
</li>
</ul>
2019-06-06 06:03:29 +00:00
<p> Within the shutter devices: </p>
2019-06-03 09:54:27 +00:00
<ul>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Enable on | off </strong> - shutter is controlled by ASC or not </li>
2019-06-03 09:54:27 +00:00
<li> <strong> ASC_Time_DriveUp </strong> - if the astro mode is used , the next sunrise is shown .
If the brightness or time mode is used , the value from <em> ASC_Time_Up_Late </em> is shown .
</li>
<li> <strong> ASC_Time_DriveDown </strong> - if the astro mode is used , the next sunset is shown .
If the brightness or time mode is used , the value from <em> ASC_TASC_Time_Down_Lateime_Up_Late </em> is
shown .
</li>
<li> <strong> ASC_ShuttersLastDrive </strong> - initiator for the last action </li>
</ul>
</ul>
<br/> <br/>
< a name = "AutoShuttersControlSet" > </a>
<strong> Set </strong>
<ul>
2019-06-06 06:03:29 +00:00
<li> <strong> ascEnable on | off </strong> - enable or disable the global control by ASC </li>
<li> <strong> controlShading on | off </strong> - enable or disable the global shading control by ASC </li>
2019-06-03 09:54:27 +00:00
<li> <strong> createNewNotifyDev </strong> - re - creates the internal structure for NOTIFYDEV . Is only present if
the
<em> ASC_Expert </em> attribute is set to 1 .
</li>
2019-07-04 07:48:17 +00:00
<li> <strong> hardLockOut on | off </strong> - <li> <strong> hardLockOut - on /off</s trong > - Aktiviert den hardwareseitigen Aussperrschutz f & uuml ; r die Rolll & auml ; den , bei denen das Attributs <em> ASC_LockOut </em> entsprechend auf hard gesetzt ist . Mehr Informationen in der Beschreibung bei den Attributen f & uuml ; r die Rollladenger & auml ; ten . </li>
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> partyMode on | off </strong> - controls the global party mode for shutters . Every shutters whose
2019-06-03 09:54:27 +00:00
<em> ASC_Partymode </em> attribute is set to <em> on </em> , is not longer controlled by ASC . The last saved
working command send to the device , i . e . by a event , created by a window or presence event , will be executed
once the party mode is disabled .
</li>
2019-09-19 12:16:04 +00:00
<li> <strong> renewAllTimer </strong> - resets the sunrise and sunset timers for every associated
2019-06-03 09:54:27 +00:00
shutter device and creates new internal FHEM timers .
</li>
2019-09-19 12:16:04 +00:00
<li> <strong> renewTimer </strong> - resets the sunrise and sunset timers for selected shutter
device and creates new internal FHEM timers .
</li>
2019-06-03 09:54:27 +00:00
<li> <strong> scanForShutters </strong> - scans the whole FHEM installation for ( new ) devices whose <em> ASC </em>
attribute is set ( to 1 or 2 , see above ) .
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> selfDefense on | off </strong> - controls the self defense function . This function listens for
2019-06-03 09:54:27 +00:00
example on a residents device . If this device is set to <em> absent </em> and a window is still open , ASC will close
the shutter for a rudimentary burglary protection .
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> shutterASCenableToggle on | off </strong> - controls if the ASC controls are shown at a associated
2019-06-03 09:54:27 +00:00
shutter device .
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> sunriseTimeWeHoliday on | off </strong> - controls the weekend and holiday support . If enabled , the
2019-06-03 09:54:27 +00:00
<em> ASC_Time_Up_WE_Holiday </em> attribute is considered .
</li>
<li> <strong> wiggle </strong> - wiggles a device for a given value ( default 5 % , controlled by
<em> ASC_WiggleValue </em> ) up or down and back after a minute . Useful as a deterrence in combination with
alarm system .
</li>
</ul>
<br/> <br/>
< a name = "AutoShuttersControlGet" > </a>
<strong> Get </strong>
<ul>
<li> <strong> showShuttersInformations </strong> - shows an information for all associated shutter devices with
next activation time , mode and several other state informations .
</li>
<li> <strong> showNotifyDevsInformations </strong> - shows the generated <em> NOTIFYDEV </em> structure . Useful for
debugging and only shown if the <em> ASC_expert </em> attribute is set to 1 .
</li>
</ul>
<br/> <br/>
< a name = "AutoShuttersControlAttributes" > </a>
<strong> Attributes </strong>
<ul>
2019-06-06 06:03:29 +00:00
<p> At the global <abbr> ASC </abbr> device: </p>
2019-06-03 09:54:27 +00:00
<ul>
< a name = "ASC_autoAstroModeEvening" > </a>
<li> <strong> ASC_autoAstroModeEvening </strong> - REAL , CIVIL , NAUTIC , ASTRONOMIC or HORIZON </li>
< a name = "ASC_autoAstroModeEveningHorizon" > </a>
<li> <strong> ASC_autoAstroModeEveningHorizon </strong> - Height above the horizon . Is only considered
if the <em> ASC_autoAstroModeEvening </em> attribute is set to <em> HORIZON </em> . Defaults to <em> 0 </em> .
</li>
< a name = "ASC_autoAstroModeMorning" > </a>
<li> <strong> ASC_autoAstroModeMorning </strong> - REAL , CIVIL , NAUTIC , ASTRONOMIC or HORIZON </li>
< a name = "ASC_autoAstroModeMorningHorizon" > </a>
<li> <strong> ASC_autoAstroModeMorningHorizon </strong> - Height above the horizon . Is only considered
if the <em> ASC_autoAstroModeMorning </em> attribute is set to <em> HORIZON </em> . Defaults to <em> 0 </em> .
</li>
< a name = "ASC_autoShuttersControlComfort" > </a>
2019-06-10 13:31:39 +00:00
<li> <strong> ASC_autoShuttersControlComfort - on | off </strong> -
2019-06-03 09:54:27 +00:00
Controls the comfort functions: If a three state sensor , like the <abbr> HmIP - SRH </abbr> window handle
sensor , is installed , <abbr> ASC </abbr> will open the window if the sensor signals open position . The
<em> ASC_ComfortOpen_Pos </em> attribute has to be set for the shutter to <em> on </em> , defaults to <em> off </em> .
</li>
< a name = "ASC_autoShuttersControlEvening" > </a>
2019-06-10 13:31:39 +00:00
<li> <strong> ASC_autoShuttersControlEvening - on | off </strong> - Enables the automatic control by <abbr> ASC </abbr>
2019-06-03 09:54:27 +00:00
at the evenings .
</li>
< a name = "ASC_autoShuttersControlMorning" > </a>
2019-06-10 13:31:39 +00:00
<li> <strong> ASC_autoShuttersControlMorning - on | off </strong> - Enables the automatic control by <abbr> ASC </abbr>
2019-06-03 09:54:27 +00:00
at the mornings .
</li>
< a name = "ASC_blockAscDrivesAfterManual" > </a>
2019-06-10 13:31:39 +00:00
<li> <strong> ASC_blockAscDrivesAfterManual 0 | 1 </strong> - If set to <em> 1 </em> , <abbr> ASC </abbr> will not
2019-06-03 09:54:27 +00:00
automatically control a shutter if there was an manual control to the shutter . To be considered , the
<em> ASC_ShuttersLastDrive </em> reading has to contain the value <em> manual </em> and the shutter is in
an unknown ( i . e . not otherwise configured in <abbr> ASC </abbr> ) position .
</li>
< a name = "ASC_brightnessDriveUpDown" > </a>
<li> <strong> ASC_brightnessDriveUpDown - VALUE - MORNING:VALUE - EVENING </strong> - Drive the shutters by
brightness . <em> VALUE - MORNING </em> sets the brightness threshold for the morning . If the value is
reached in the morning , the shutter will go up . Vice versa in the evening . This is a global setting
and can be overwritte per device with the <em> ASC_BrightnessSensor </em> attribute ( see below ) .
</li>
< a name = "ASC_debug" > </a>
<li> <strong> ASC_debug </strong> -
Extendend logging for debugging purposes
</li>
< a name = "ASC_expert" > </a>
<li> <strong> ASC_expert </strong> - Switches the export mode on . Currently , if set to <em> 1 </em> , <em> get </em>
and <em> set </em> will contain additional functions regarding the NOTIFYDEFs .
</li>
< a name = "ASC_freezeTemp" > </a>
<li> <strong> ASC_freezeTemp </strong> - Temperature threshold for the freeze protection . The freeze protection
prevents the shutter to be operated by <abbr> ASC </abbr> . Last operating order will be kept .
</li>
< a name = "ASC_rainSensor" > </a>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_rainSensor DEVICENAME [ : READINGNAME ] MAXTRIGGER [ : HYSTERESE ] [ CLOSEDPOS ] </strong> - Contains
2019-06-03 09:54:27 +00:00
settings for the rain protection . <em> DEVICNAME </em> specifies a rain sensor , the optional
<em> READINGNAME </em> the name of the reading at the <em> DEVICENAME </em> . The <em> READINGNAME </em>
should contain the values <em> rain </em> and <em> dry </em> or a numeral rain amount . <em> MAXTRIGGER </em>
sets the threshold for the amount of rain for when the shutter is driven to <em> CLOSEDPOS </em> as soon
the threshold is reached . <em> HYSTERESE </em> sets a hysteresis for <em> MAXTRIGGER </em> .
</li>
< a name = "ASC_residentsDev" > </a>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_residentsDev DEVICENAME [ : READINGNAME ] </strong> - <em> DEVICENAME </em> points to a device
2019-06-03 09:54:27 +00:00
for presence , e . g . of type <em> RESIDENTS </em> . <em> READINGNAME </em> points to a reading at
2019-08-05 08:07:44 +00:00
<em> DEVICENAME </em> which contains a presence state , e . g . <em> rgr_Residents:state </em> . The target
2019-06-03 09:54:27 +00:00
should contain values alike the <em> RESIDENTS </em> family .
</li>
< a name = "ASC_shuttersDriveOffset" > </a>
<li> <strong> ASC_shuttersDriveOffset </strong> - Maximum random drive delay in seconds for calculating
the operating time . <em> 0 </em> equals to no delay .
</li>
< a name = "ASC_tempSensor" > </a>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_tempSensor DEVICENAME [ : READINGNAME ] </strong> - <em> DEVICENAME </em> points to a device
2019-06-03 09:54:27 +00:00
with a temperature , <em> READINGNAME </em> to a reading located at the <em> DEVICENAME </em> , for example
<em> OUTDOOR_TEMP:measured - temp </em> . <em> READINGNAME </em> defaults to <em> temperature </em> .
</li>
< a name = "ASC_twilightDevice" > </a>
<li> <strong> ASC_twilightDevice </strong> - points to a <em> DEVICENAME </em> containing values regarding
the sun position . Supports currently devices of type <em> Twilight </em> or <em> Astro </em> .
</li>
< a name = "ASC_windSensor" > </a>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_windSensor DEVICENAME [ : READINGNAME ] </strong> - <em> DEVICENAME </em> points to a device
2019-06-03 09:54:27 +00:00
containing a wind speed . Reads from the <em> wind </em> reading , if not otherwise specified by
<em> READINGNAME </em> .
</li>
</ul>
<br/>
2019-06-06 06:03:29 +00:00
<p> At shutter devices , controlled by <abbr> ASC </abbr> : </p>
2019-06-03 09:54:27 +00:00
<ul>
2019-06-10 13:31:39 +00:00
<li> <strong> ASC - 0 | 1 | 2 </strong>
2019-06-03 09:54:27 +00:00
<ul>
<li> 0 - don 't create attributes for <abbr>ASC</abbr> at the first scan and don' t be controlled
by <abbr> ASC </abbr> </li>
<li> 1 - inverse or venetian type blind mode . Shutter is open equals to 0 , shutter is closed equals
to 100 , is controlled by <em> position </em> values . </li>
<li> 2 - <q> HomeMatic </q> mode . Shutter is open equals to 100 , shutter is closed equals to 0 , is
controlled by <em> <abbr> pct </abbr> </em> values . </li>
</ul>
</li>
2019-06-10 13:31:39 +00:00
<li> <strong> ASC_Antifreeze - soft | am | pm | hard | off </strong> - Freeze protection .
2019-06-03 09:54:27 +00:00
<ul>
<li> soft - see <em> ASC_Antifreeze_Pos </em> . </li>
<li> hard / <abbr>am</ abbr > / <abbr>pm</ abbr > - freeze protection will be active ( everytime ,
ante meridiem or post meridiem ) . </li>
<li> off - freeze protection is disabled , default value </li>
</ul>
</li>
<li> <strong> ASC_Antifreeze_Pos </strong> - Position to be operated if the shutter should be closed ,
2019-09-12 09:28:51 +00:00
but <em> ASC_Antifreeze </em> is not set to <em> off </em> . ( Default: dependent on attribut <em> ASC </em> 85 / 15 ) .
2019-06-03 09:54:27 +00:00
</li>
<li> <strong> ASC_AutoAstroModeEvening </strong> - Can be set to <em> REAL </em> , <em> CIVIL </em> ,
<em> NAUTIC </em> , <em> ASTRONOMIC </em> or <em> HORIZON </em> . Defaults to none of those . </li>
<li> <strong> ASC_AutoAstroModeEveningHorizon </strong> - If this value is reached by the sun , a sunset is
presumed . Is used if <em> ASC_autoAstroModeEvening </em> is set to <em> HORIZON </em> . Defaults to none .
</li>
<li> <strong> ASC_AutoAstroModeMorning </strong> - Can be set to <em> REAL </em> , <em> CIVIL </em> ,
<em> NAUTIC </em> , <em> ASTRONOMIC </em> or <em> HORIZON </em> . Defaults to none of those . </li>
<li> <strong> ASC_AutoAstroModeMorningHorizon </strong> - If this value is reached by the sun , a sunrise is
presumed . Is used if <em> ASC_AutoAstroModeMorning </em> is set to <em> HORIZON </em> . Defaults to none .
</li>
2019-09-20 11:52:00 +00:00
<li> <strong> ASC_Shutter_IdleDetection </strong> - indicates the Reading which gives information about the running status of the roller blind , as well as secondly the value in the Reading which says that the roller blind does not run .
</li>
2019-06-03 09:54:27 +00:00
<li> <strong> ASC_BlockingTime_afterManual </strong> - Time in which operations by <abbr> ASC </abbr> are blocked
after the last manual operation in seconds . Defaults to 1200 ( 20 minutes ) .
</li>
<li> <strong> ASC_BlockingTime_beforDayOpen </strong> - Time in which no closing operation is made by
<abbr> ASC </abbr> after opening at the morning in seconds . Defaults to 3600 ( one hour ) .
</li>
<li> <strong> ASC_BlockingTime_beforNightClose </strong> - Time in which no closing operation is made by
<abbr> ASC </abbr> before closing at the evening in seconds . Defaults to 3600 ( one hour ) .
</li>
<li> <strong> ASC_BrightnessSensor - DEVICE [ : READING ] MORNING - VALUE:EVENING - VALUE </strong> -
Drive this shutter by brightness . <em> MORNING - VALUE </em> sets the brightness threshold for the morning .
If the value is reached in the morning , the shutter will go up . Vice versa in the evening , specified by
<em> EVENING - VALUE </em> . Gets the brightness from <em> DEVICE </em> , reads by default from the
<em> brightness </em> reading , unless <em> READING </em> is specified . Defaults to <em> none </em> .
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Closed_Pos </strong> - The closed position value from 0 to 100 percent in increments of 10 .
2019-09-12 09:28:51 +00:00
( Default: dependent on attribut <em> ASC </em> 100 / 0 ) .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_ComfortOpen_Pos </strong> - The comfort opening position , ranging
2019-09-12 09:28:51 +00:00
from 0 to 100 percent in increments of 10 . ( Default: dependent on attribut <em> ASC </em> 20 / 80 ) .
2019-06-03 09:54:27 +00:00
</li>
2019-09-08 08:17:10 +00:00
<li> <strong> ASC_Down - astro | time | brightness | roommate </strong> - Drive the shutter depending on this setting:
2019-06-03 09:54:27 +00:00
<ul>
<li> astro - drive down at sunset </li>
<li> time - drive at <em> ASC_Time_Down_Early </em> </li>
<li> brightness - drive between <em> ASC_Time_Down_Early </em> and <em> ASC_Time_Down_Late </em> ,
depending on the settings of <em> ASC_BrightnessSensor </em> ( see above ) . </li>
2019-09-08 08:17:10 +00:00
<li> roommate - no drive by time or brightness , roommate trigger only </li>
2019-06-03 09:54:27 +00:00
</ul>
Defaults to <em> astro </em> .
</li>
<li> <strong> ASC_DriveUpMaxDuration </strong> - Drive up duration of the shutter plus 5 seconds . Defaults
to 60 seconds if not set .
</li>
<li> <strong> ASC_Drive_Offset </strong> - Maximum <strong> random </strong> drive delay in seconds for calculating the
driving time . 0 equals to no delay , - 1 <em> ASC_shuttersDriveOffset </em> is used . Defaults to - 1 .
</li>
<li> <strong> ASC_Drive_OffsetStart </strong> - <strong> Fixed </strong> drive delay in seconds for calculating the
driving time . - 1 or 0 equals to no delay . Defaults to - 1 ( no offset ) .
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_LockOut soft | hard | off </strong> - Configures the lock out protection for the current
2019-06-03 09:54:27 +00:00
shutter . Values are:
<ul>
<li> soft - works if the global lock out protection <em> lockOut soft </em> is set and a sensor
specified by <em> ASC_WindowRec </em> is set . If the sensor is set to open , the shutter will not
be closed . Affects only commands issued by <abbr> ASC </abbr> .
</li>
<li>
hard - see soft , but <abbr> ASC </abbr> tries also to block manual issued commands by a switch .
</li>
<li>
off - lock out protection is disabled . Default .
</li>
</ul>
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_LockOut_Cmd inhibit | blocked | protection </strong> - Configures the lock out command for
<em> ASC_LockOut </em> if hard is chosen as a value . Defaults to none .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Mode_Down always | home | absent | off </strong> - When will a shutter be driven down:
<ul>
<li> always - <abbr> ASC </abbr> will drive always . Default value . </li>
<li> off - don ' t drive </li>
<li> home / absent - considers a residents status set by <em>ASC_residentsDev</ em > . If no
resident is configured and this attribute is set to absent , <abbr> ASC </abbr> will not
operate the shutter . </li>
</ul>
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Mode_Up always | home | absent | off </strong> - When will a shutter be driven up:
<ul>
<li> always - <abbr> ASC </abbr> will drive always . Default value . </li>
<li> off - don ' t drive </li>
<li> home / absent - considers a residents status set by <em>ASC_residentsDev</ em > . If no
resident is configured and this attribute is set to absent , <abbr> ASC </abbr> will not
operate the shutter . </li>
</ul>
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Open_Pos </strong> - The opening position value from 0 to 100 percent in increments of 10 .
2019-09-12 09:28:51 +00:00
( Default: dependent on attribut <em> ASC </em> 0 / 100 ) .
</li>
<li> <strong> ASC_Sleep_Pos </strong> - The opening position value from 0 to 100 percent in increments of 10 .
( Default: dependent on attribut <em> ASC </em> 75 / 25 ) .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Partymode on | off </strong> - Party mode . If configured to on , driving orders for the
shutter by <abbr> ASC </abbr> will be queued if <em> partyMode </em> is set to <em> on </em> at the
global <abbr> ASC </abbr> device . Will execute the driving orders after <em> partyMode </em> is disabled .
Defaults to off .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Pos_Reading </strong> - Points to the reading name , which contains the current
position for the shutter in percent . Will be used for <em> set </em> at devices of unknown kind .
2019-06-03 09:54:27 +00:00
</li>
2019-10-24 16:27:06 +00:00
<li> <strong> ASC_PrivacyDownValue_beforeNightClose </strong> - How many seconds is the privacy mode activated
2019-11-01 06:39:00 +00:00
before the shutter is closed in the evening . For Brightness , in addition to the time value ,
the Brightness value must also be specified . 1800 : 300 means 30 min before night close or above a brightness
value of 300 . - 1 is the default
2019-06-06 06:03:29 +00:00
value .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_PrivacyDown_Pos </strong> -
Position in percent for privacy mode , defaults to 50 .
2019-06-03 09:54:27 +00:00
</li>
2019-11-01 06:39:00 +00:00
<li> <strong> ASC_PrivacyUpValue_beforeDayOpen </strong> - How many seconds is the privacy mode activated
before the shutter is open in the morning . For Brightness , in addition to the time value ,
the Brightness value must also be specified . 1800 : 600 means 30 min before day open or above a brightness
value of 600 . - 1 is the default
value .
</li>
<li> <strong> ASC_PrivacyUp_Pos </strong> -
Position in percent for privacy mode , defaults to 50 .
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_WindProtection on | off </strong> - Shutter is protected by the wind protection . Defaults
to off .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Roommate_Device </strong> - Comma separated list of <em> ROOMMATE </em> devices , representing
the inhabitants of the room to which the shutter belongs . Especially useful for bedrooms . Defaults
to none .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Roommate_Reading </strong> - Specifies a reading name to <em> ASC_Roommate_Device </em> .
Defaults to <em> state </em> .
2019-06-03 09:54:27 +00:00
</li>
2019-09-17 09:37:58 +00:00
<li> <strong> ASC_Self_Defense_Mode - absent /gone/o ff </strong> - which Residents status Self Defense should become
active without the window being open . ( default: gone ) off exclude from self defense
2019-06-25 10:24:25 +00:00
</li>
2019-07-08 06:45:48 +00:00
<li> <strong> ASC_Self_Defense_AbsentDelay </strong> - um wie viele Sekunden soll das fahren in Selfdefense bei
2019-06-25 10:32:25 +00:00
Residents absent verz & ouml ; gert werden . ( default: 300 )
2019-06-25 10:24:25 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_ShuttersPlace window | terrace </strong> - If set to <em> terrace </em> , and the
residents device is set to <em> gone </em> , and <em> selfDefense </em> is activated , the shutter will
be closed . If set to window , will not . Defaults to window .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Time_Down_Early </strong> - Will not drive before time is <em> ASC_Time_Down_Early </em>
or later , even the sunset occurs earlier . To be set in military time . Defaults to 16 : 00 .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Time_Down_Late </strong> - Will not drive after time is <em> ASC_Time_Down_Late </em>
or earlier , even the sunset occurs later . To be set in military time . Defaults to 22 : 00 .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Time_Up_Early </strong> - Will not drive before time is <em> ASC_Time_Up_Early </em>
or earlier , even the sunrise occurs earlier . To be set in military time . Defaults to 05 : 00 .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Time_Up_Late </strong> - Will not drive after time is <em> ASC_Time_Up_Late </em>
or earlier , even the sunrise occurs later . To be set in military time . Defaults to 08 : 30 .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Time_Up_WE_Holiday </strong> - Will not drive before time is <em> ASC_Time_Up_WE_Holiday </em>
on weekends and holidays ( <em> holiday2we </em> is considered ) . Defaults to 08 : 00 . <strong> Warning ! </strong>
If <em> ASC_Up </em> set to <em> brightness </em> , the time for <em> ASC_Time_Up_WE_Holiday </em>
must be earlier then <em> ASC_Time_Up_Late </em> .
2019-06-03 09:54:27 +00:00
</li>
2019-09-08 08:17:10 +00:00
<li> <strong> ASC_Up astro | time | brightness | roommate </strong> - Drive the shutter depending on this setting:
2019-06-06 06:03:29 +00:00
<ul>
<li> astro - drive up at sunrise </li>
<li> time - drive at <em> ASC_Time_Up_Early </em> </li>
<li> brightness - drive between <em> ASC_Time_Up_Early </em> and <em> ASC_Time_Up_Late </em> ,
depending on the settings of <em> ASC_BrightnessSensor </em> ( see above ) . </li>
2019-09-08 08:17:10 +00:00
<li> roommate - no drive by time or brightness , roommate trigger only </li>
2019-06-06 06:03:29 +00:00
</ul>
Defaults to <em> astro </em> .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Ventilate_Pos </strong> - The opening position value for ventilation
2019-09-12 09:28:51 +00:00
from 0 to 100 percent in increments of 10 . ( Default: dependent on attribut <em> ASC </em> 70 / 30 ) .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Ventilate_Window_Open on | off </strong> - Drive to ventilation position as window is opened
or tilted , even when the current shutter position is lower than the <em> ASC_Ventilate_Pos </em> .
Defaults to on .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_WiggleValue </strong> - How many percent should the shutter be driven if a wiggle drive
is operated . Defaults to 5 .
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_WindParameters THRESHOLD - ON [ : THRESHOLD - OFF ] [ DRIVEPOSITION ] </strong> -
Threshold for when the shutter is driven to the wind protection position . Optional
<em> THRESHOLD - OFF </em> sets the complementary value when the wind protection is disabled . Disabled
if <em> THRESHOLD - ON </em> is set to - 1 . Defaults to <q> 50 : 20 <em> ASC_Closed_Pos </em> </q> .
2019-06-03 09:54:27 +00:00
</li>
2019-11-08 08:31:41 +00:00
<li> <strong> ASC_WindowRec </strong> - WINDOWREC: [ READING ] , Points to the window contact device , associated with the shutter .
Defaults to none . Reading is optional
2019-06-03 09:54:27 +00:00
</li>
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_WindowRec_subType </strong> - Model type of the used <em> ASC_WindowRec </em> :
<ul>
2019-07-16 18:56:31 +00:00
<li> <strong> twostate </strong> - optical or magnetical sensors with two states: opened or closed </li>
2019-06-06 06:03:29 +00:00
<li> <strong> threestate </strong> - sensors with three states: opened , tilted , closed </li>
</ul>
Defaults to twostate .
</li>
2019-07-30 06:51:46 +00:00
<li> <strong> ASC_WindowRec_PosAfterDayClosed </strong> - open , lastManual / auf welche Position soll das Rollo nach dem schließen am Tag fahren. Open Position oder letzte gespeicherte manuelle Position (default: open)</ li >
2019-06-06 06:03:29 +00:00
<blockquote>
<p>
<strong> <u> Shading </u> </strong>
</p>
<p>
Shading is only available if the following prerequests are met:
<ul>
<li>
2019-06-14 12:02:05 +00:00
The <em> controlShading </em> reading is set to on , and there is a device
2019-06-06 06:03:29 +00:00
of type Astro or Twilight configured to <em> ASC_twilightDevice </em> , and <em> ASC_tempSensor </em>
is set .
</li>
<li>
<em> ASC_BrightnessSensor </em> is configured to any shutter device .
</li>
<li>
All other attributes are optional and the default value for them is used , if they are not
otherwise configured . Please review the settings carefully , especially the values for
<em> StateChange_Cloudy </em> and <em> StateChange_Sunny </em> .
</li>
</ul>
</p>
<p>
The following attributes are available:
</p>
<ul>
2019-09-19 11:46:42 +00:00
<li> <strong> ASC_Shading_InOutAzimuth </strong> - Azimuth value from which shading is to be used when shading is exceeded and shading when undershooting is required .
Defaults to 95 : 265 .
2019-06-06 06:03:29 +00:00
</li>
2019-06-10 11:41:46 +00:00
<li> <strong> ASC_Shading_MinMax_Elevation </strong> - Shading starts as min point of sun elevation is
reached and end as max point of sun elevation is reached , depending also on other sensor values . Defaults to 25.0 : 100.0 .
2019-06-06 06:03:29 +00:00
</li>
<li> <strong> ASC_Shading_Min_OutsideTemperature </strong> - Shading starts at this outdoor temperature ,
depending also on other sensor values . Defaults to 18.0 .
</li>
<li> <strong> ASC_Shading_Mode absent | always | off | home </strong> - see <em> ASC_Mode_Down </em> above ,
but for shading . Defaults to off .
</li>
2019-09-12 09:28:51 +00:00
<li> <strong> ASC_Shading_Pos </strong> - Shading position in percent . ( Default: dependent on attribut <em> ASC </em> 85 /15)</ li >
2019-06-06 06:03:29 +00:00
<li> <strong> ASC_Shading_StateChange_Cloudy </strong> - Shading <strong> ends </strong> at this
outdoor brightness , depending also on other sensor values . Defaults to 20000 .
</li>
2019-09-19 11:46:42 +00:00
<li> <strong> ASC_Shading_StateChange_SunnyCloudy </strong> - Shading <strong> starts /stops</s trong > at this
outdoor brightness , depending also on other sensor values . Defaults to 35000 : 20000 .
2019-06-06 06:03:29 +00:00
</li>
<li> <strong> ASC_Shading_WaitingPeriod </strong> - Waiting time in seconds before additional sensor values
to <em> ASC_Shading_StateChange_Sunny </em> or <em> ASC_Shading_StateChange_Cloudy </em>
are used for shading . Defaults to 120 .
</li>
</ul>
</blockquote>
2019-06-03 09:54:27 +00:00
</ul>
</ul>
<p>
<strong> <u> AutoShuttersControl <abbr> API </abbr> description </u> </strong>
</p>
<p>
2019-06-06 06:03:29 +00:00
It ' s possible to access internal data of the <abbr> ASC </abbr> module by calling the <abbr> API </abbr> function .
2019-06-03 09:54:27 +00:00
</p>
<u> Data points of a shutter device , controlled by <abbr> ASC </abbr> </u>
<p>
<pre> <code> { ascAPIget ( 'Getter' , 'SHUTTERS_DEVICENAME' ) } </code> </pre>
</p>
< table border = "1" >
<tr>
<th> Getter </th>
<th> Description </th>
</tr>
<tr>
<td> FreezeStatus </td>
<td> 1 = soft , 2 = daytime , 3 = hard </td>
</tr>
<tr>
2019-09-17 14:52:19 +00:00
<td> NoDelay </td>
2019-06-03 09:54:27 +00:00
<td> Was the offset handling deactivated ( e . g . by operations triggered by a window event ) </td>
</tr>
<tr>
<td> LastDrive </td>
<td> Reason for the last action caused by <abbr> ASC </abbr> </td>
</tr>
<tr>
<td> LastPos </td>
<td> Last position of the shutter </td>
</tr>
<tr>
<td> LastPosTimestamp </td>
<td> Timestamp of the last position </td>
</tr>
<tr>
<td> LastManPos </td>
<td> Last position manually set of the shutter </td>
</tr>
<tr>
<td> LastManPosTimestamp </td>
<td> Timestamp of the last position manually set </td>
</tr>
<tr>
<td> SunsetUnixTime </td>
<td> Calculated sunset time in seconds since the <abbr> UNIX </abbr> epoche </td>
</tr>
<tr>
<td> Sunset </td>
<td> 1 = operation in the evening was made , 0 = operation in the evening was not yet made </td>
</tr>
<tr>
<td> SunriseUnixTime </td>
<td> Calculated sunrise time in seconds since the <abbr> UNIX </abbr> epoche </td>
</tr>
<tr>
<td> Sunrise </td>
<td> 1 = operation in the morning was made , 0 = operation in the morning was not yet made </td>
</tr>
<tr>
<td> RoommatesStatus </td>
<td> Current state of the room mate set for this shutter </td>
</tr>
<tr>
<td> RoommatesLastStatus </td>
<td> Last state of the room mate set for this shutter </td>
</tr>
<tr>
<td> ShadingStatus </td>
<td> Value of the current shading state . Can hold <em> in </em> , <em> out </em> , <em> in reserved </em> or
<em> out reserved </em> </td>
</tr>
<tr>
<td> ShadingStatusTimestamp </td>
<td> Timestamp of the last shading state </td>
</tr>
<tr>
<td> IfInShading </td>
<td> Is the shutter currently in shading ( depends on the shading mode ) </td>
</tr>
<tr>
<td> WindProtectionStatus </td>
<td> Current state of the wind protection . Can hold <em> protection </em> or <em> unprotection </em> </td>
</tr>
<tr>
<td> RainProtectionStatus </td>
<td> Current state of the rain protection . Can hold <em> protection </em> or <em> unprotection </em> </td>
</tr>
<tr>
<td> DelayCmd </td>
<td> Last operation order in the waiting queue . Set for example by the party mode </td>
</tr>
<tr>
<td> Status </td>
<td> Position of the shutter </td>
</tr>
<tr>
<td> ASCenable </td>
<td> Does <abbr> ASC </abbr> control the shutter ? </td>
</tr>
2019-06-21 07:58:41 +00:00
<tr>
<td> PrivacyDownStatus </td>
<td> Is the shutter currently in privacyDown mode </td>
</tr>
2019-06-21 12:20:08 +00:00
<tr>
<td> outTemp </td>
<td> Current temperature of a configured temperature device , return - 100 is no device configured </td>
</tr>
2019-06-08 12:52:53 +00:00
<table/>
2019-06-03 09:54:27 +00:00
</p>
2019-07-30 06:51:46 +00:00
<u> & Uuml ; bersicht f & uuml ; r das Rollladen - Device mit Parameter & uuml ; bergabe </u>
<ul>
<code> { ascAPIget ( 'Getter' , 'ROLLODEVICENAME' , VALUE ) } </code> <br>
</ul>
< table border = "1" >
<tr>
<th> Getter </th> <th> Erl & auml ; uterung </th>
</tr>
<tr>
<td> QueryShuttersPos </td> <td> R & uuml ; ckgabewert 1 bedeutet das die aktuelle Position des Rollos unterhalb der Valueposition ist . 0 oder nichts bedeutet oberhalb der Valueposition . </td>
</tr>
<table/>
</p>
2019-06-03 09:54:27 +00:00
<u> Data points of the <abbr> ASC </abbr> device </u>
<p>
<code> { ascAPIget ( 'Getter' ) } </code> <br>
</p>
< table border = "1" >
<tr>
<th> Getter </th>
<th> Description </th>
</tr>
<tr>
2019-07-29 09:28:53 +00:00
<td> OutTemp </td>
2019-06-21 12:20:08 +00:00
<td> Current temperature of a configured temperature device , return - 100 is no device configured </td>
2019-06-03 09:54:27 +00:00
</tr>
<tr>
<td> ResidentsStatus </td>
<td> Current state of a configured resident device </td>
</tr>
<tr>
<td> ResidentsLastStatus </td>
<td> Last state of a configured resident device </td>
</tr>
<tr>
<td> Azimuth </td>
<td> Current azimuth of the sun </td>
</tr>
<tr>
<td> Elevation </td>
<td> Current elevation of the sun </td>
</tr>
<tr>
<td> ASCenable </td>
<td> Is <abbr> ASC </abbr> globally activated ? </td>
</tr>
2019-06-08 12:52:53 +00:00
<table/>
2019-06-03 09:54:27 +00:00
</ul>
2018-08-15 08:27:53 +00:00
= end html
= begin html_DE
2019-05-24 17:56:38 +00:00
< a name = "AutoShuttersControl" > </a>
<h3> AutoShuttersControl </h3>
<ul>
2019-10-24 08:41:38 +00:00
<p> AutoShuttersControl ( ASC ) erm & ouml ; glicht eine vollst & auml ; ndige Automatisierung der vorhandenen Rolll & auml ; den . Das Modul bietet umfangreiche Konfigurationsm & ouml ; glichkeiten , um Rolll & auml ; den bspw . nach Sonnenauf - und untergangszeiten , nach Helligkeitswerten oder rein zeitgesteuert zu steuern .
< br /><strong>Damit ASC auf Basis der astronomischen Zeiten die Rollos fahren kann, ist es ganz wichtig im Device "global" die Location (Latitude,Longitude) korrekt zu setzen.</s trong >
</p>
2019-05-24 17:56:38 +00:00
<p>
Man kann festlegen , welche Rolll & auml ; den von ASC in die Automatisierung mit aufgenommen werden sollen . Daraufhin stehen diverse Attribute zur Feinkonfiguration zur Verf & uuml ; gung . So sind unter anderem komplexe L & ouml ; sungen wie Fahrten in Abh & auml ; ngigkeit des Bewohnerstatus einfach umsetzbar . Beispiel: Hochfahren von Rolll & auml ; den , wenn der Bewohner erwacht ist und drau & szlig ; en bereits die Sonne aufgegangen ist . Weiterhin ist es m & ouml ; glich , dass der geschlossene Rollladen z . B . nach dem Ankippen eines Fensters in eine L & uuml ; ftungsposition f & auml ; hrt . Und vieles mehr .
</p>
< a name = "AutoShuttersControlDefine" > </a>
<strong> Define </strong>
<ul>
<code> define & lt ; name & gt ; AutoShuttersControl </code>
< br /><br / >
Beispiel:
<ul>
< br / >
<code> define myASControl AutoShuttersControl </code> < br / >
</ul>
< br / >
Der Befehl erstellt ein AutoShuttersControl Device mit Namen <em> myASControl </em> . < br / >
Nachdem das Device angelegt wurde , muss in allen Rolll & auml ; den Devices , welche gesteuert werden sollen , das Attribut ASC mit Wert 1 oder 2 gesetzt werden .
Dabei bedeutet 1 = "Prozent geschlossen" ( z . B . ROLLO oder Siro Modul ) - Rollo Oben 0 , Rollo Unten 100 , 2 = "Prozent geöffnet" ( z . B . Homematic ) - Rollo Oben 100 , Rollo Unten 0 .
Die Voreinstellung f & uuml ; r den Befehl zum prozentualen Fahren ist in beiden F & auml ; llen unterschiedlich . 1 = "position" und 2 = "pct" . Dies kann , soweit erforderlich , zu sp & auml ; terer Zeit noch angepasst werden .
Habt Ihr das Attribut gesetzt , k & ouml ; nnt Ihr den automatischen Scan nach den Devices ansto & szlig ; en .
</ul>
< br / >
< a name = "AutoShuttersControlReadings" > </a>
<strong> Readings </strong>
<ul>
<u> Im ASC - Device </u>
<ul>
<li> <strong> ... _nextAstroTimeEvent </strong> - Uhrzeit des n & auml ; chsten Astro - Events: Sonnenauf - oder Sonnenuntergang oder feste Zeit </li>
<li> <strong> ... _PosValue </strong> - aktuelle Position des Rollladens </li>
<li> <strong> ... _lastPosValue </strong> - letzte Position des Rollladens </li>
<li> <strong> ... _lastDelayPosValue </strong> - letzter abgesetzter Fahrbefehl , welcher beim n & auml ; chsten zul & auml ; ssigen Event ausgef & uuml ; hrt wird . </li>
<li> <strong> partyMode - on /off</s trong > - Partymodus - Status </li>
<li> <strong> ascEnable - on /off</s trong > - globale ASC Steuerung bei den Rollläden aktiv oder inaktiv </li>
<li> <strong> controlShading - on /off</s trong > - globale Beschattungsfunktion aktiv oder inaktiv </li>
2019-07-02 07:25:18 +00:00
<li> <strong> hardLockOut - on /off</s trong > - Status des hardwareseitigen Aussperrschutzes / gilt nur für Rolläden mit dem Attribut bei denen das Attributs <em>ASC_LockOut</ em > entsprechend auf hard gesetzt ist </li>
2019-05-24 17:56:38 +00:00
<li> <strong> room_ ... </strong> - Auflistung aller Rolll & auml ; den , die in den jeweiligen R & auml ; men gefunden wurde . Beispiel: room_Schlafzimmer: Terrasse </li>
<li> <strong> selfDefense </strong> - Selbstschutz - Status </li>
<li> <strong> state </strong> - Status des ASC - Devices: active , enabled , disabled oder weitere Statusinformationen </li>
<li> <strong> sunriseTimeWeHoliday - on /off</s trong > - Status der Wochenendunterst & uuml ; tzung </li>
<li> <strong> userAttrList </strong> - Das ASC - Modul verteilt an die gesteuerten Rollladen - Geräte diverse Benutzerattribute <em> ( userattr ) </em> . In diesem Reading kann der Status dieser Verteilung gepr & uuml ; ft werden . </li>
</ul> < br / >
<u> In den Rolll & auml ; den - Ger & auml ; ten </u>
<ul>
<li> <strong> ASC_Enable - on /off</s trong > - wird der Rollladen & uuml ; ber ASC gesteuert oder nicht </li>
<li> <strong> ASC_Time_DriveUp </strong> - Im Astro - Modus ist hier die Sonnenaufgangszeit f & uuml ; r das Rollo gespeichert . Im Brightness - und Zeit - Modus ist hier der Zeitpunkt aus dem Attribut <em> ASC_Time_Up_Late </em> gespeichert . </li>
<li> <strong> ASC_Time_DriveDown </strong> - Im Astro - Modus ist hier die Sonnenuntergangszeit f & uuml ; r das Rollo gespeichert . Im Brightness - und Zeit - Modus ist hier der Zeitpunkt aus dem Attribut <em> ASC_Time_Down_Late </em> gespeichert . </li>
<li> <strong> ASC_ShuttersLastDrive </strong> - Grund der letzten Fahrt vom Rollladen </li>
</ul>
</ul>
< br /><br / >
< a name = "AutoShuttersControlSet" > </a>
<strong> Set </strong>
<ul>
2019-11-11 18:16:47 +00:00
<li> <strong> advDriveDown </strong> - holt alle ADV ausgesetzen Fahrten nach . </li>
2019-05-24 17:56:38 +00:00
<li> <strong> ascEnable - on /off</s trong > - Aktivieren oder deaktivieren der globalen ASC Steuerung </li>
<li> <strong> controlShading - on /off</s trong > - Aktiviert oder deaktiviert die globale Beschattungssteuerung </li>
<li> <strong> createNewNotifyDev </strong> - Legt die interne Struktur f & uuml ; r NOTIFYDEV neu an . Diese Funktion steht nur zur Verf & uuml ; gung , wenn Attribut ASC_expert auf 1 gesetzt ist . </li>
2019-07-04 07:48:17 +00:00
<li> <strong> hardLockOut - on /off</s trong > - Aktiviert den hardwareseitigen Aussperrschutz f & uuml ; r die Rolll & auml ; den , bei denen das Attributs <em> ASC_LockOut </em> entsprechend auf hard gesetzt ist . Mehr Informationen in der Beschreibung bei den Attributen f & uuml ; r die Rollladenger & auml ; ten . </li>
2019-05-24 17:56:38 +00:00
<li> <strong> partyMode - on /off</s trong > - Aktiviert den globalen Partymodus . Alle Rollladen - Ger & auml ; ten , in welchen das Attribut <em> ASC_Partymode </em> auf <em> on </em> gesetzt ist , werden durch ASC nicht mehr gesteuert . Der letzte Schaltbefehl , der bspw . durch ein Fensterevent oder Wechsel des Bewohnerstatus an die Rolll & auml ; den gesendet wurde , wird beim Deaktivieren des Partymodus ausgef & uuml ; hrt </li>
2019-09-19 12:16:04 +00:00
<li> <strong> renewTimer </strong> - erneuert beim ausgew & auml ; hlten Rollladen die Zeiten f & uuml ; r Sonnenauf - und - untergang und setzt die internen Timer neu . </li>
<li> <strong> renewAllTimer </strong> - erneuert bei allen Rolll & auml ; den die Zeiten f & uuml ; r Sonnenauf - und - untergang und setzt die internen Timer neu . </li>
2019-05-24 17:56:38 +00:00
<li> <strong> scanForShutters </strong> - Durchsucht das System nach Ger & auml ; tenRo mit dem Attribut <em> ASC = 1 </em> oder <em> ASC = 2 </em> </li>
<li> <strong> selfDefense - on /off</s trong > - Aktiviert bzw . deaktiviert die Selbstschutzfunktion . Beispiel: Wenn das Residents - Ger & auml ; t <em> absent </em> meldet , die Selbstschutzfunktion aktiviert wurde und ein Fenster im Haus noch ge & ouml ; ffnet ist , so wird an diesem Fenster der Rollladen deaktivieren dann heruntergefahren . </li>
<li> <strong> shutterASCenableToggle - on /off</s trong > - Aktivieren oder deaktivieren der ASC Kontrolle beim einzelnen Rollladens </li>
<li> <strong> sunriseTimeWeHoliday - on /off</s trong > - Aktiviert die Wochenendunterst & uuml ; tzung und somit , ob im Rollladenger & auml ; t das Attribut <em> ASC_Time_Up_WE_Holiday </em> beachtet werden soll oder nicht . </li>
<li> <strong> wiggle </strong> - bewegt einen oder mehrere Rolll & auml ; den um einen definierten Wert ( Default: 5 % ) und nach einer Minute wieder zur & uuml ; ck in die Ursprungsposition . Diese Funktion k & ouml ; nnte bspw . zur Abschreckung in einem Alarmsystem eingesetzt werden . </li>
</ul>
< br /><br / >
< a name = "AutoShuttersControlGet" > </a>
<strong> Get </strong>
<ul>
<li> <strong> showShuttersInformations </strong> - zeigt eine & Uuml ; bersicht aller Rolll & auml ; den mit den Fahrzeiten , Modus und diverse weitere Statusanzeigen . </li>
<li> <strong> showNotifyDevsInformations </strong> - zeigt eine & Uuml ; bersicht der abgelegten NOTIFYDEV Struktur . Diese Funktion wird prim & auml ; r f & uuml ; rs Debugging genutzt . Hierzu ist das Attribut <em> ASC_expert = 1 </em> zu setzen . </li>
</ul>
< br /><br / >
< a name = "AutoShuttersControlAttributes" > </a>
<strong> Attributes </strong>
<ul>
<u> Im ASC - Device </u>
<ul>
< a name = "ASC_autoAstroModeEvening" > </a>
<li> <strong> ASC_autoAstroModeEvening </strong> - REAL , CIVIL , NAUTIC , ASTRONOMIC oder HORIZON </li>
< a name = "ASC_autoAstroModeEveningHorizon" > </a>
<li> <strong> ASC_autoAstroModeEveningHorizon </strong> - H & ouml ; he & uuml ; ber dem Horizont . Wird nur ber & uuml ; cksichtigt , wenn im Attribut <em> ASC_autoAstroModeEvening </em> der Wert <em> HORIZON </em> ausgew & auml ; hlt wurde . ( default: 0 ) </li>
< a name = "ASC_autoAstroModeMorning" > </a>
<li> <strong> ASC_autoAstroModeMorning </strong> - REAL , CIVIL , NAUTIC , ASTRONOMIC oder HORIZON </li>
< a name = "ASC_autoAstroModeMorningHorizon" > </a>
2019-06-03 05:44:35 +00:00
<li> <strong> ASC_autoAstroModeMorningHorizon </strong> - H & ouml ; he & uuml ; ber dem Horizont . Wird nur ber & uuml ; cksichtigt , wenn im Attribut <em> ASC_autoAstroModeMorning </em> der Wert <em> HORIZON </em> ausgew & auml ; hlt wurde . ( default: 0 ) </li>
2019-05-24 17:56:38 +00:00
< a name = "ASC_autoShuttersControlComfort" > </a>
<li> <strong> ASC_autoShuttersControlComfort - on /off</s trong > - schaltet die Komfortfunktion an . Bedeutet , dass ein Rollladen mit einem threestate - Sensor am Fenster beim & Ouml ; ffnen in eine Offenposition f & auml ; hrt . Hierzu muss beim Rollladen das Attribut <em> ASC_ComfortOpen_Pos </em> entsprechend konfiguriert sein . ( default: off ) </li>
< a name = "ASC_autoShuttersControlEvening" > </a>
<li> <strong> ASC_autoShuttersControlEvening - on /off</s trong > - Aktiviert die automatische Steuerung durch das ASC - Modul am Abend . </li>
< a name = "ASC_autoShuttersControlMorning" > </a>
<li> <strong> ASC_autoShuttersControlMorning - on /off</s trong > - Aktiviert die automatische Steuerung durch das ASC - Modul am Morgen . </li>
< a name = "ASC_blockAscDrivesAfterManual" > </a>
<li> <strong> ASC_blockAscDrivesAfterManual - 0 , 1 </strong> - wenn dieser Wert auf 1 gesetzt ist , dann werden Rolll & auml ; den vom ASC - Modul nicht mehr gesteuert , wenn zuvor manuell eingegriffen wurde . Voraussetzung hierf & uuml ; r ist jedoch , dass im Reading <em> ASC_ShuttersLastDrive </em> der Status <em> manual </em> enthalten ist und sich der Rollladen auf eine unbekannte ( nicht in den Attributen anderweitig konfigurierte ) Position befindet . </li>
< a name = "ASC_brightnessDriveUpDown" > </a>
<li> <strong> ASC_brightnessDriveUpDown - WERT - MORGENS:WERT - ABENDS </strong> - Werte bei dem Schaltbedingungen f & uuml ; r Sonnenauf - und - untergang gepr & uuml ; ft werden sollen . Diese globale Einstellung kann durch die WERT - MORGENS:WERT - ABENDS Einstellung von ASC_BrightnessSensor im Rollladen selbst & uuml ; berschrieben werden . </li>
< a name = "ASC_debug" > </a>
<li> <strong> ASC_debug </strong> - Aktiviert die erweiterte Logausgabe f & uuml ; r Debugausgaben </li>
< a name = "ASC_expert" > </a>
<li> <strong> ASC_expert </strong> - ist der Wert 1 , so werden erweiterte Informationen bez & uuml ; glich des NotifyDevs unter set und get angezeigt </li>
< a name = "ASC_freezeTemp" > </a>
<li> <strong> ASC_freezeTemp </strong> - Temperatur , ab welcher der Frostschutz greifen soll und der Rollladen nicht mehr f & auml ; hrt . Der letzte Fahrbefehl wird gespeichert . </li>
< a name = "ASC_rainSensor" > </a>
<li> <strong> ASC_rainSensor - DEVICENAME [ : READINGNAME ] MAXTRIGGER [ : HYSTERESE ] [ CLOSEDPOS ] </strong> - der Inhalt ist eine Kombination aus Devicename , Readingname , Wert ab dem getriggert werden soll , Hysterese Wert ab dem der Status Regenschutz aufgehoben werden soll und der "wegen Regen geschlossen Position" . </li>
< a name = "ASC_residentsDev" > </a>
2019-08-05 08:07:44 +00:00
<li> <strong> ASC_residentsDev - DEVICENAME [ : READINGNAME ] </strong> - der Inhalt ist eine Kombination aus Devicenamen und Readingnamen des Residents - Device der obersten Ebene ( z . B . rgr_Residents:state ) </li>
2019-05-24 17:56:38 +00:00
< a name = "ASC_shuttersDriveOffset" > </a>
2019-09-17 11:42:55 +00:00
<li> <strong> ASC_shuttersDriveDelay </strong> - maximale Zufallsverz & ouml ; gerung in Sekunden bei der Berechnung der Fahrzeiten . 0 bedeutet keine Verz & ouml ; gerung </li>
2019-05-24 17:56:38 +00:00
< a name = "ASC_tempSensor" > </a>
<li> <strong> ASC_tempSensor - DEVICENAME [ : READINGNAME ] </strong> - der Inhalt ist eine Kombination aus Device und Reading f & uuml ; r die Au & szlig ; entemperatur </li>
< a name = "ASC_twilightDevice" > </a>
<li> <strong> ASC_twilightDevice </strong> - das Device , welches die Informationen zum Sonnenstand liefert . Wird unter anderem f & uuml ; r die Beschattung verwendet . </li>
< a name = "ASC_windSensor" > </a>
<li> <strong> ASC_windSensor - DEVICE [ : READING ] </strong> - Sensor f & uuml ; r die Windgeschwindigkeit . Kombination aus Device und Reading . </li>
</ul>
< br / >
2019-09-17 11:42:55 +00:00
<ul>
<u> Folgende Attribute sind obsolet und sollten nicht mehr verwendet werden . </u>
< a name = "ASC_shuttersDriveOffset" > </a>
<li> ASC_shuttersDriveOffset - <em> WARNUNG ! ! ! OBSOLET ! ! ! NICHT VERWENDEN ! ! ! </em> </li>
</ul>
< br / >
2019-05-24 17:56:38 +00:00
<u> In den Rolll & auml ; den - Ger & auml ; ten </u>
<ul>
<li> <strong> ASC - 0 /1/ 2 </strong> 0 = "kein Anlegen der Attribute beim ersten Scan bzw. keine Beachtung eines Fahrbefehles" , 1 = "Inverse oder Rollo - Bsp.: Rollo oben 0, Rollo unten 100 und der Befehl zum prozentualen Fahren ist position" , 2 = " Homematic Style - Bsp . : Rollo oben 100 , Rollo unten 0 und der Befehl zum prozentualen Fahren ist pct </li>
<li> <strong> ASC_Antifreeze - soft /am/ pm /hard/o ff </strong> - Frostschutz , wenn soft f & auml ; hrt der Rollladen in die ASC_Antifreeze_Pos und wenn hard /am/ pm wird gar nicht oder innerhalb der entsprechenden Tageszeit nicht gefahren ( default: off ) </li>
2019-09-18 12:55:17 +00:00
<li> <strong> ASC_Antifreeze_Pos </strong> - Position die angefahren werden soll , wenn der Fahrbefehl komplett schlie & szlig ; en lautet , aber der Frostschutz aktiv ist ( Default: ist abh & auml ; ngig vom Attribut <em> ASC </em> 85 /15) !!!Verwendung von Perlcode ist möglich, dieser muss in {} eingeschlossen sein. Rückgabewert muss eine positive Zahl/ Dezimalzahl sein ! ! ! </li>
2019-05-24 17:56:38 +00:00
<li> <strong> ASC_AutoAstroModeEvening </strong> - aktuell REAL , CIVIL , NAUTIC , ASTRONOMIC ( default: none ) </li>
<li> <strong> ASC_AutoAstroModeEveningHorizon </strong> - H & ouml ; he & uuml ; ber Horizont , wenn beim Attribut ASC_autoAstroModeEvening HORIZON ausgew & auml ; hlt ( default: none ) </li>
<li> <strong> ASC_AutoAstroModeMorning </strong> - aktuell REAL , CIVIL , NAUTIC , ASTRONOMIC ( default: none ) </li>
<li> <strong> ASC_AutoAstroModeMorningHorizon </strong> - H & ouml ; he & uuml ; ber Horizont , a wenn beim Attribut ASC_autoAstroModeMorning HORIZON ausgew & auml ; hlt ( default: none ) </li>
<li> <strong> ASC_BlockingTime_afterManual </strong> - wie viel Sekunden soll die Automatik nach einer manuellen Fahrt aussetzen . ( default: 1200 ) </li>
<li> <strong> ASC_BlockingTime_beforDayOpen </strong> - wie viel Sekunden vor dem morgendlichen & ouml ; ffnen soll keine schlie & szlig ; en Fahrt mehr stattfinden . ( default: 3600 ) </li>
<li> <strong> ASC_BlockingTime_beforNightClose </strong> - wie viel Sekunden vor dem n & auml ; chtlichen schlie & szlig ; en soll keine & ouml ; ffnen Fahrt mehr stattfinden . ( default: 3600 ) </li>
<li> <strong> ASC_BrightnessSensor - DEVICE [ : READING ] WERT - MORGENS:WERT - ABENDS </strong> / 'Sensorname[:brightness [400:800]]' Angaben zum Helligkeitssensor mit (Readingname, optional) für die Beschattung und dem Fahren der Rollladen nach brightness und den optionalen Brightnesswerten für Sonnenauf- und Sonnenuntergang. (default: none)</ li >
2019-09-20 04:33:17 +00:00
<li> <strong> ASC_Closed_Pos </strong> - in 10 Schritten von 0 bis 100 ( Default: ist abh & auml ; ngig vom Attribut <em> ASC </em> 0 /100)</ li >
<li> <strong> ASC_Open_Pos </strong> - in 10 Schritten von 0 bis 100 ( default: ist abh & auml ; ngig vom Attribut <em> ASC </em> 100 /0)</ li >
2019-09-18 12:55:17 +00:00
<li> <strong> ASC_Sleep_Pos </strong> - in 10 Schritten von 0 bis 100 ( default: ist abh & auml ; ngig vom Attribut <em> ASC </em> 75 /25) !!!Verwendung von Perlcode ist möglich, dieser muss in {} eingeschlossen sein. Rückgabewert muss eine positive Zahl/ Dezimalzahl sein ! ! ! </li>
<li> <strong> ASC_ComfortOpen_Pos </strong> - in 10 Schritten von 0 bis 100 ( Default: ist abh & auml ; ngig vom Attribut <em> ASC </em> 20 /80) !!!Verwendung von Perlcode ist möglich, dieser muss in {} eingeschlossen sein. Rückgabewert muss eine positive Zahl/ Dezimalzahl sein ! ! ! </li>
2019-06-03 09:32:50 +00:00
<li> <strong> ASC_Down - astro /time/ brightness </strong> - bei astro wird Sonnenuntergang berechnet , bei time wird der Wert aus ASC_Time_Down_Early als Fahrzeit verwendet und bei brightness muss ASC_Time_Down_Early und ASC_Time_Down_Late korrekt gesetzt werden . Der Timer l & auml ; uft dann nach ASC_Time_Down_Late Zeit , es wird aber in der Zeit zwischen ASC_Time_Down_Early und ASC_Time_Down_Late geschaut , ob die als Attribut im Moduldevice hinterlegte ASC_brightnessDriveUpDown der Down Wert erreicht wurde . Wenn ja , wird der Rollladen runter gefahren ( default: astro ) </li>
2019-09-20 11:52:00 +00:00
<li> <strong> ASC_Shutter_IdleDetection </strong> - <strong> READING:VALUE </strong> gibt das Reading an welches Auskunft & uuml ; ber den Fahrstatus des Rollos gibt , sowie als zweites den Wert im Reading welcher aus sagt das das Rollo <strong> nicht </strong> f & auml ; hrt </li>
2019-05-24 17:56:38 +00:00
<li> <strong> ASC_DriveUpMaxDuration </strong> - die Dauer des Hochfahrens des Rollladens plus 5 Sekunden ( default: 60 ) </li>
<li> <strong> ASC_Drive_Offset </strong> - maximaler Wert f & uuml ; r einen zuf & auml ; llig ermittelte Verz & ouml ; gerungswert in Sekunden bei der Berechnung der Fahrzeiten , 0 bedeutet keine Verz & ouml ; gerung , - 1 bedeutet , dass das gleichwertige Attribut aus dem ASC Device ausgewertet werden soll . ( default: - 1 ) </li>
<li> <strong> ASC_Drive_OffsetStart </strong> - in Sekunden verz & ouml ; gerter Wert ab welchen dann erst das Offset startet und dazu addiert wird . Funktioniert nur wenn gleichzeitig ASC_Drive_Offset gesetzt wird . ( default: - 1 ) </li>
<li> <strong> ASC_LockOut - soft /hard/o ff </strong> - stellt entsprechend den Aussperrschutz ein . Bei global aktivem Aussperrschutz ( set ASC - Device lockOut soft ) und einem Fensterkontakt open bleibt dann der Rollladen oben . Dies gilt nur bei Steuerbefehlen & uuml ; ber das ASC Modul . Stellt man global auf hard , wird bei entsprechender M & ouml ; glichkeit versucht den Rollladen hardwareseitig zu blockieren . Dann ist auch ein Fahren & uuml ; ber die Taster nicht mehr m & ouml ; glich . ( default: off ) </li>
<li> <strong> ASC_LockOut_Cmd - inhibit /blocked/ protection </strong> - set Befehl f & uuml ; r das Rollladen - Device zum Hardware sperren . Dieser Befehl wird gesetzt werden , wenn man "ASC_LockOut" auf hard setzt ( default: none ) </li>
<li> <strong> ASC_Mode_Down - always /home/ absent /off</s trong > - Wann darf die Automatik steuern . immer , niemals , bei Abwesenheit des Roommate ( ist kein Roommate und absent eingestellt , wird gar nicht gesteuert ) ( default: always ) </li>
<li> <strong> ASC_Mode_Up - always /home/ absent /off</s trong > - Wann darf die Automatik steuern . immer , niemals , bei Abwesenheit des Roommate ( ist kein Roommate und absent eingestellt , wird gar nicht gesteuert ) ( default: always ) </li>
<li> <strong> ASC_Partymode - on /off</s trong > - schaltet den Partymodus an oder aus . Wird am ASC Device set ASC - DEVICE partyMode on geschalten , werden alle Fahrbefehle an den Rolll & auml ; den , welche das Attribut auf on haben , zwischengespeichert und sp & auml ; ter erst ausgef & uuml ; hrt ( default: off ) </li>
<li> <strong> ASC_Pos_Reading </strong> - Name des Readings , welches die Position des Rollladen in Prozent an gibt ; wird bei unbekannten Device Typen auch als set Befehl zum fahren verwendet </li>
2019-11-01 06:39:00 +00:00
<li> <strong> ASC_PrivacyUpValue_beforeDayOpen </strong> - wie viele Sekunden vor dem morgendlichen & ouml ; ffnen soll der Rollladen in die Sichtschutzposition fahren , oder bei Brightness ab welchem minimum Brightnesswert soll das Rollo in die Privacy Position fahren . Bei Brightness muss zusätzlich zum Zeitwert der Brightnesswert mit angegeben werden 1800 : 600 bedeutet 30 min vor day open oder bei über einem Brightnesswert von 600 ( default: - 1 ) </li>
<li> <strong> ASC_PrivacyDownValue_beforeNightClose </strong> - wie viele Sekunden vor dem abendlichen schlie & szlig ; en soll der Rollladen in die Sichtschutzposition fahren , oder bei Brightness ab welchem minimum Brightnesswert soll das Rollo in die Privacy Position fahren . Bei Brightness muss zusätzlich zum Zeitwert der Brightnesswert mit angegeben werden 1800 : 300 bedeutet 30 min vor night close oder bei unter einem Brightnesswert von 300 ( default: - 1 ) </li>
2019-10-25 08:44:08 +00:00
<li> <strong> ASC_PrivacyUp_Pos </strong> - Position den Rollladens f & uuml ; r den morgendlichen Sichtschutz ( default: 50 ) ! ! ! Verwendung von Perlcode ist möglich , dieser muss in { } eingeschlossen sein . Rückgabewert muss eine positive Zahl /Dezimalzahl sein!!!</ li >
<li> <strong> ASC_PrivacyDown_Pos </strong> - Position den Rollladens f & uuml ; r den abendlichen Sichtschutz ( default: 50 ) ! ! ! Verwendung von Perlcode ist möglich , dieser muss in { } eingeschlossen sein . Rückgabewert muss eine positive Zahl /Dezimalzahl sein!!!</ li >
2019-11-15 11:42:58 +00:00
<li> <strong> ASC_ExternalTrigger </strong> - DEVICE:READING VALUEACTIVE:VALUEINACTIVE POSACTIVE:POSINACTIVE , Beispiel: "WohnzimmerTV:state on:off 66:100" bedeutet das wenn ein "state:on" Event kommt soll das Rollo in Position 66 fahren , kommt ein "state:off" Event soll es in Position 100 fahren . Es ist m & ouml ; glich die POSINACTIVE weg zu lassen dann f & auml ; hrt das Rollo in LastStatus Position . </li>
2019-06-10 11:41:46 +00:00
<li> <strong> ASC_WindProtection - on /off</s trong > - soll der Rollladen beim Regenschutz beachtet werden . on = JA , off = NEIN . </li>
2019-05-24 17:56:38 +00:00
<li> <strong> ASC_Roommate_Device </strong> - mit Komma getrennte Namen des /der Roommate Device/s , welche den /die Bewohner des Raumes vom Rollladen wiedergibt. Es macht nur Sinn in Schlaf- oder Kinderzimmern (default: none)</ li >
2019-11-11 18:16:47 +00:00
<li> <strong> ASC_Adv - on /off</s trong > bei on wird das runterfahren des Rollos w & auml ; hrend der Weihnachtszeit ( 1 . Advent bis 6 . Januar ) ausgesetzt ! Durch set advDriveDown wird die ausgesetzte Fahrt nachgeholt .
2019-05-24 17:56:38 +00:00
<li> <strong> ASC_Roommate_Reading </strong> - das Reading zum Roommate Device , welches den Status wieder gibt ( default: state ) </li>
2019-09-17 09:37:58 +00:00
<li> <strong> ASC_Self_Defense_Mode - absent /gone/o ff </strong> - ab welchen Residents Status soll Selfdefense aktiv werden ohne das Fenster auf sind . ( default: gone ) </li>
2019-07-10 15:06:04 +00:00
<li> <strong> ASC_Self_Defense_AbsentDelay </strong> - um wie viele Sekunden soll das fahren in Selfdefense bei Residents absent verz & ouml ; gert werden . ( default: 300 ) </li>
2019-09-17 09:37:58 +00:00
<li> <strong> ASC_Self_Defense_Exclude - on /off</s trong > - bei on Wert wird dieser Rollladen bei aktiven Self Defense und offenen Fenster nicht runter gefahren , wenn Residents absent ist . ( default: off ) , off bedeutet das es ausgeschlossen ist vom Self Defense </li> </p>
2019-05-24 17:56:38 +00:00
<ul>
<strong> <u> Beschreibung der Beschattungsfunktion </u> </strong>
</br> Damit die Beschattung Funktion hat , m & uuml ; ssen folgende Anforderungen erf & uuml ; llt sein .
2019-06-14 12:02:05 +00:00
</br> <strong> Im ASC Device </strong> das Reading "controlShading" mit dem Wert on , sowie ein Astro / Twilight Device im Attribut "ASC_twilightDevice" und das Attribut "ASC_tempSensor" .
2019-05-24 17:56:38 +00:00
</br> <strong> In den Rollladendevices </strong> ben & ouml ; tigt ihr ein Helligkeitssensor als Attribut "ASC_BrightnessSensor" , sofern noch nicht vorhanden . Findet der Sensor nur f & uuml ; r die Beschattung Verwendung ist der Wert DEVICENAME [ : READING ] ausreichend .
</br> Alle weiteren Attribute sind optional und wenn nicht gesetzt mit Default - Werten belegt . Ihr solltet sie dennoch einmal anschauen und entsprechend Euren Gegebenheiten setzen . Die Werte f & uumlr ; die Fensterposition und den Vor - Nachlaufwinkel sowie die Grenzwerte f & uuml ; r die StateChange_Cloudy und StateChange_Sunny solltet ihr besondere Beachtung dabei schenken .
2019-09-19 11:46:42 +00:00
<li> <strong> ASC_Shading_InOutAzimuth </strong> - Azimut Wert ab dem bei & Uuml ; berschreiten Beschattet und bei Unterschreiten Endschattet werden soll . ( default: 95 : 265 ) </li>
2019-06-10 11:41:46 +00:00
<li> <strong> ASC_Shading_MinMax_Elevation </strong> - ab welcher min H & ouml ; he des Sonnenstandes soll beschattet und ab welcher max H & ouml ; he wieder beendet werden , immer in Abh & auml ; ngigkeit der anderen einbezogenen Sensorwerte ( default: 25.0 : 100.0 ) </li>
2019-05-24 17:56:38 +00:00
<li> <strong> ASC_Shading_Min_OutsideTemperature </strong> - ab welcher Temperatur soll Beschattet werden , immer in Abh & auml ; ngigkeit der anderen einbezogenen Sensorwerte ( default: 18 ) </li>
<li> <strong> ASC_Shading_Mode - absent , always , off , home </strong> / wann soll die Beschattung nur stattfinden. (default: off)</ li >
2019-09-18 12:55:17 +00:00
<li> <strong> ASC_Shading_Pos </strong> - Position des Rollladens f & uuml ; r die Beschattung ( Default: ist abh & auml ; ngig vom Attribut <em> ASC </em> 80 /20) !!!Verwendung von Perlcode ist möglich, dieser muss in {} eingeschlossen sein. Rückgabewert muss eine positive Zahl/ Dezimalzahl sein ! ! ! </li>
2019-09-19 11:46:42 +00:00
<li> <strong> ASC_Shading_StateChange_SunnyCloudy </strong> - Brightness Wert ab welchen die Beschattung stattfinden und aufgehoben werden soll , immer in Abh & auml ; ngigkeit der anderen einbezogenen Sensorwerte ( default: 35000 : 20000 ) </li>
2019-05-24 17:56:38 +00:00
<li> <strong> ASC_Shading_WaitingPeriod </strong> - wie viele Sekunden soll gewartet werden bevor eine weitere Auswertung der Sensordaten f & uuml ; r die Beschattung stattfinden soll ( default: 1200 ) </li>
2019-11-05 13:00:40 +00:00
</ul> </p>
2019-05-24 17:56:38 +00:00
<li> <strong> ASC_ShuttersPlace - window /terrace</s trong > - Wenn dieses Attribut auf terrace gesetzt ist , das Residence Device in den Status "gone" geht und SelfDefense aktiv ist ( ohne das das Reading selfDefense gesetzt sein muss ) , wird das Rollo geschlossen ( default: window ) </li>
2019-09-18 12:55:17 +00:00
<li> <strong> ASC_Time_Down_Early </strong> - Sonnenuntergang fr & uuml ; hste Zeit zum Runterfahren ( default: 16 : 00 ) ! ! ! Verwendung von Perlcode ist möglich , dieser muss in { } eingeschlossen sein . Rückgabewert muss ein Zeitformat in Form HH:MM [ : SS ] sein ! ! ! </li>
<li> <strong> ASC_Time_Down_Late </strong> - Sonnenuntergang sp & auml ; teste Zeit zum Runterfahren ( default: 22 : 00 ) ! ! ! Verwendung von Perlcode ist möglich , dieser muss in { } eingeschlossen sein . Rückgabewert muss ein Zeitformat in Form HH:MM [ : SS ] sein ! ! ! </li>
<li> <strong> ASC_Time_Up_Early </strong> - Sonnenaufgang fr & uuml ; hste Zeit zum Hochfahren ( default: 05 : 00 ) ! ! ! Verwendung von Perlcode ist möglich , dieser muss in { } eingeschlossen sein . Rückgabewert muss ein Zeitformat in Form HH:MM [ : SS ] sein ! ! ! </li>
<li> <strong> ASC_Time_Up_Late </strong> - Sonnenaufgang sp & auml ; teste Zeit zum Hochfahren ( default: 08 : 30 ) ! ! ! Verwendung von Perlcode ist möglich , dieser muss in { } eingeschlossen sein . Rückgabewert muss ein Zeitformat in Form HH:MM [ : SS ] sein ! ! ! </li>
<li> <strong> ASC_Time_Up_WE_Holiday </strong> - Sonnenaufgang fr & uuml ; hste Zeit zum Hochfahren am Wochenende und /oder Urlaub (holiday2we wird beachtet). (default: 08:00) ACHTUNG!!! in Verbindung mit Brightness für <em>ASC_Up</ em > muss die Uhrzeit kleiner sein wie die Uhrzeit aus <em> ASC_Time_Up_Late </em> ! ! ! Verwendung von Perlcode ist möglich , dieser muss in { } eingeschlossen sein . Rückgabewert muss ein Zeitformat in Form HH:MM [ : SS ] sein ! ! ! </li>
2019-06-03 09:32:50 +00:00
<li> <strong> ASC_Up - astro /time/ brightness </strong> - bei astro wird Sonnenaufgang berechnet , bei time wird der Wert aus ASC_Time_Up_Early als Fahrzeit verwendet und bei brightness muss ASC_Time_Up_Early und ASC_Time_Up_Late korrekt gesetzt werden . Der Timer l & auml ; uft dann nach ASC_Time_Up_Late Zeit , es wird aber in der Zeit zwischen ASC_Time_Up_Early und ASC_Time_Up_Late geschaut , ob die als Attribut im Moduldevice hinterlegte Down Wert von ASC_brightnessDriveUpDown erreicht wurde . Wenn ja , wird der Rollladen hoch gefahren ( default: astro ) </li>
2019-09-18 12:55:17 +00:00
<li> <strong> ASC_Ventilate_Pos </strong> - in 10 Schritten von 0 bis 100 ( default: ist abh & auml ; ngig vom Attribut <em> ASC </em> 70 /30) !!!Verwendung von Perlcode ist möglich, dieser muss in {} eingeschlossen sein. Rückgabewert muss eine positive Zahl/ Dezimalzahl sein ! ! ! </li>
2019-05-24 17:56:38 +00:00
<li> <strong> ASC_Ventilate_Window_Open </strong> - auf l & uuml ; ften , wenn das Fenster gekippt /geöffnet wird und aktuelle Position unterhalb der Lüften-Position ist (default: on)</ li >
<li> <strong> ASC_WiggleValue </strong> - Wert um welchen sich die Position des Rollladens & auml ; ndern soll ( default: 5 ) </li>
<li> <strong> ASC_WindParameters - TRIGGERMAX [ : HYSTERESE ] [ DRIVEPOSITION ] </strong> / Angabe von Max Wert ab dem für Wind getriggert werden soll, Hytsrese Wert ab dem der Windschutz aufgehoben werden soll TRIGGERMAX - HYSTERESE / Ist es bei einigen Rolll & auml ; den nicht gew & uuml ; nscht das gefahren werden soll , so ist der TRIGGERMAX Wert mit - 1 an zu geben . ( default: '50:20 ClosedPosition' ) </li>
2019-07-30 06:51:46 +00:00
<li> <strong> ASC_WindowRec_PosAfterDayClosed </strong> - open , lastManual / auf welche Position soll das Rollo nach dem schließen am Tag fahren. Open Position oder letzte gespeicherte manuelle Position (default: open)</ li >
2019-11-08 08:31:41 +00:00
<li> <strong> ASC_WindowRec </strong> - WINDOWREC: [ READING ] , Name des Fensterkontaktes , an dessen Fenster der Rollladen angebracht ist ( default: none ) . Reading ist optional </li>
2019-05-24 17:56:38 +00:00
<li> <strong> ASC_WindowRec_subType </strong> - Typ des verwendeten Fensterkontaktes: twostate ( optisch oder magnetisch ) oder threestate ( Drehgriffkontakt ) ( default: twostate ) </li>
</ul>
</ul>
</p>
<strong> <u> Beschreibung der AutoShuttersControl API </u> </strong>
</br> Mit dem Aufruf der API Funktion und & Uuml ; bergabe der entsprechenden Parameter ist es m & ouml ; glich auf interne Daten zu zu greifen .
2019-05-20 12:23:11 +00:00
</p>
2019-05-24 17:56:38 +00:00
<u> & Uuml ; bersicht f & uuml ; r das Rollladen - Device </u>
2019-05-20 12:23:11 +00:00
<ul>
2019-05-24 17:56:38 +00:00
<code> { ascAPIget ( 'Getter' , 'ROLLODEVICENAME' ) } </code> <br>
2019-05-20 12:23:11 +00:00
</ul>
< table border = "1" >
2019-05-24 17:56:38 +00:00
<tr> <th> Getter </th> <th> Erl & auml ; uterung </th> </tr>
<tr> <td> FreezeStatus </td> <td> 1 = soft , 2 = Daytime , 3 = hard </td> </tr>
2019-09-17 14:52:19 +00:00
<tr> <td> NoDelay </td> <td> Wurde die Behandlung von Offset deaktiviert ( Beispiel bei Fahrten & uuml ; ber Fensterevents ) </td> </tr>
2019-05-24 17:56:38 +00:00
<tr> <td> LastDrive </td> <td> Grund des letzten Fahrens </td> </tr>
<tr> <td> LastPos </td> <td> die letzte Position des Rollladens </td> </tr>
<tr> <td> LastPosTimestamp </td> <td> Timestamp der letzten festgestellten Position </td> </tr>
<tr> <td> LastManPos </td> <td> Position der letzten manuellen Fahrt </td> </tr>
<tr> <td> LastManPosTimestamp </td> <td> Timestamp der letzten manuellen Position </td> </tr>
<tr> <td> SunsetUnixTime </td> <td> berechnete Unixzeit f & uuml ; r Abends ( Sonnenuntergang ) </td> </tr>
<tr> <td> Sunset </td> <td> 1 = Abendfahrt wurde durchgef & uuml ; hrt , 0 = noch keine Abendfahrt durchgef & uuml ; hrt </td> </tr>
<tr> <td> SunriseUnixTime </td> <td> berechnete Unixzeit f & uuml ; r Morgens ( Sonnenaufgang ) </td> </tr>
<tr> <td> Sunrise </td> <td> 1 = Morgenfahrt wurde durchgef & uuml ; hrt , 0 = noch keine Morgenfahrt durchgef & uuml ; hrt </td> </tr>
<tr> <td> RoommatesStatus </td> <td> aktueller Status der /des Roommate/s f & uuml ; r den Rollladen </td> </tr>
<tr> <td> RoommatesLastStatus </td> <td> letzter Status der /des Roommate/s f & uuml ; r den Rollladen </td> </tr>
<tr> <td> ShadingStatus </td> <td> Ausgabe des aktuellen Shading Status , „ in “ , „ out “ , „ in reserved “ , „ out reserved “ </td> </tr>
<tr> <td> ShadingStatusTimestamp </td> <td> Timestamp des letzten Beschattungsstatus </td> </tr>
<tr> <td> IfInShading </td> <td> Befindet sich der Rollladen , in Abh & auml ; ngigkeit des Shading Mode , in der Beschattung </td> </tr>
2019-06-03 05:44:35 +00:00
<tr> <td> WindProtectionStatus </td> <td> aktueller Status der Wind Protection „ protected “ oder „ unprotected “ </td> </tr>
<tr> <td> RainProtectionStatus </td> <td> aktueller Status der Regen Protection „ unprotected “ oder „ unprotected “ </td> </tr>
2019-05-24 17:56:38 +00:00
<tr> <td> DelayCmd </td> <td> letzter Fahrbefehl welcher in die Warteschlange kam . Grund z . B . Partymodus . </td> </tr>
<tr> <td> Status </td> <td> Position des Rollladens </td> </tr>
<tr> <td> ASCenable </td> <td> Abfrage ob f & uuml ; r den Rollladen die ASC Steuerung aktiv ist . </td> </tr>
2019-06-04 08:53:28 +00:00
<tr> <td> IsDay </td> <td> Abfrage ob das Rollo im Tag oder Nachtmodus ist . Also nach Sunset oder nach Sunrise </td> </tr>
2019-06-21 07:58:41 +00:00
<tr> <td> PrivacyDownStatus </td> <td> Abfrage ob das Rollo aktuell im PrivacyDown Status steht </td> </tr>
2019-06-21 12:20:08 +00:00
<tr> <td> OutTemp </td> <td> aktuelle Au & szlig ; entemperatur sofern ein Sensor definiert ist , wenn nicht kommt - 100 als Wert zur & uuml ; ck </td> </tr>
2019-07-29 09:28:53 +00:00
<table/>
</p>
<u> & Uuml ; bersicht f & uuml ; r das Rollladen - Device mit Parameter & uuml ; bergabe </u>
<ul>
<code> { ascAPIget ( 'Getter' , 'ROLLODEVICENAME' , VALUE ) } </code> <br>
</ul>
< table border = "1" >
<tr> <th> Getter </th> <th> Erl & auml ; uterung </th> </tr>
<tr> <td> QueryShuttersPos </td> <td> R & uuml ; ckgabewert 1 bedeutet das die aktuelle Position des Rollos unterhalb der Valueposition ist . 0 oder nichts bedeutet oberhalb der Valueposition . </td> </tr>
2019-05-29 20:35:33 +00:00
<table/>
2019-05-24 17:56:38 +00:00
</p>
<u> & Uuml ; bersicht f & uuml ; r das ASC Device </u>
<ul>
<code> { ascAPIget ( 'Getter' ) } </code> <br>
</ul>
< table border = "1" >
<tr> <th> Getter </th> <th> Erl & auml ; uterung </th> </tr>
2019-07-29 09:28:53 +00:00
<tr> <td> OutTemp </td> <td> aktuelle Au & szlig ; entemperatur sofern ein Sensor definiert ist , wenn nicht kommt - 100 als Wert zur & uuml ; ck </td> </tr>
2019-05-24 17:56:38 +00:00
<tr> <td> ResidentsStatus </td> <td> aktueller Status des Residents Devices </td> </tr>
<tr> <td> ResidentsLastStatus </td> <td> letzter Status des Residents Devices </td> </tr>
<tr> <td> Azimuth </td> <td> Azimut Wert </td> </tr>
<tr> <td> Elevation </td> <td> Elevation Wert </td> </tr>
<tr> <td> ASCenable </td> <td> ist die ASC Steuerung global aktiv ? </td> </tr>
2019-07-29 09:28:53 +00:00
<table/>
2019-05-07 14:45:39 +00:00
</ul>
2018-08-15 08:27:53 +00:00
= end html_DE
2019-03-27 07:41:15 +00:00
= for : application / json ; q = META . json 73 _AutoShuttersControl . pm
{
"abstract" : "Module for controlling shutters depending on various conditions" ,
"x_lang" : {
"de" : {
"abstract" : "Modul zur Automatischen Rolladensteuerung auf Basis bestimmter Ereignisse"
}
} ,
"keywords" : [
"fhem-mod-device" ,
"fhem-core" ,
"Shutter" ,
"Automation" ,
"Rollladen" ,
"Rollo" ,
"Control"
] ,
"release_status" : "under develop" ,
"license" : "GPL_2" ,
2019-11-15 10:16:48 +00:00
"version" : "v0.8.0" ,
2019-03-27 07:41:15 +00:00
"author" : [
"Marko Oldenburg <leongaultier@gmail.com>"
] ,
"x_fhem_maintainer" : [
"CoolTux"
] ,
"x_fhem_maintainer_github" : [
"LeonGaultier"
] ,
"prereqs" : {
"runtime" : {
"requires" : {
"FHEM" : 5.00918799 ,
"perl" : 5.016 ,
"Meta" : 0 ,
2019-06-07 17:49:33 +00:00
"JSON" : 0 ,
"Date::Parse" : 0
2019-03-27 07:41:15 +00:00
} ,
"recommends" : {
} ,
"suggests" : {
}
}
}
}
= end : application / json ; q = META . json
2018-08-15 08:27:53 +00:00
= cut