def execute(self, module, input):
if self.fallbackTimer != None:
self.fallbackTimer.cancel()
self.fallbackTimer = None
presenceState = getItemState("pOther_Presence_State").intValue()
if input['event'].getItemName(
) == "pGF_Corridor_Openingcontact_Door_State":
if self.confirmTimer != None:
self.confirmTimer.cancel()
self.confirmTimer = None
self.isConfirmed = False
if input['event'].getItemState() == OPEN:
if presenceState == PresenceHelper.STATE_AWAY:
postUpdate("pOther_Presence_State",
PresenceHelper.STATE_MAYBE_PRESENT)
sendNotification(u"System", u"Unbekannter Gast gekommen")
else:
if presenceState == PresenceHelper.STATE_MAYBE_PRESENT:
# check in 15 seconds again if there was any move events
self.confirmTimer = startTimer(self.log, 15,
self.confirmArriving)
else:
# move events during sleep, check function will be called during presence state update cycle
if presenceState == PresenceHelper.STATE_SLEEPING:
postUpdate("pOther_Presence_State",
PresenceHelper.STATE_MAYBE_SLEEPING)
elif presenceState == PresenceHelper.STATE_MAYBE_SLEEPING:
self.delayedSleepingCheck()
elif presenceState == PresenceHelper.STATE_MAYBE_PRESENT and self.isConfirmed:
self.delayedAwayCheck()
def execute(self, module, input):
moverStatus = getItemState("pOutdoor_Mower_Status").toString()
if itemLastUpdateOlderThen("pOutdoor_Mower_WlanSignal",
ZonedDateTime.now().minusMinutes(60)):
if moverStatus != "98":
postUpdate("pOutdoor_Mower_Status", 98)
postUpdate(
"pOutdoor_Mower_StatusFormatted",
Transformation.transform("MAP", "robonect_status.map",
"98"))
else:
seconds = getItemState("pOutdoor_Mower_Duration").intValue()
hours = seconds / (60 * 60)
seconds = seconds % (60 * 60)
minutes = seconds / 60
#seconds = seconds % 60
msg = u"{} seit ".format(
Transformation.transform("MAP", "robonect_status.map",
moverStatus))
if hours < 10: msg = u"{}0".format(msg)
msg = u"{}{}:".format(msg, hours)
if minutes < 10: msg = u"{}0".format(msg)
msg = u"{}{}:".format(msg, minutes)
postUpdateIfChanged("pOutdoor_Mower_StatusFormatted", msg)
def callbackProgress(self):
if self.progressTimer is not None and self.currentProgressMsg != getItemState(
"pOutdoor_Watering_Logic_Program_State").toString():
self.log.info("Cancel Watering Progress Zombie Timer")
self.cleanProgressTimer()
return
msg, remaining = self.findStep()
if remaining <= 0:
self.cleanProgressTimer()
return
remainingInMinutes = int(math.floor(remaining / 60.0))
if remainingInMinutes > 0:
msg = u"{} noch {} min".format(msg, remainingInMinutes)
else:
msg = u"{} gleich fertig".format(msg)
self.currentProgressMsg = msg
postUpdate("pOutdoor_Watering_Logic_Program_State",
self.currentProgressMsg)
self.progressTimer = startTimer(self.log, 60.0, self.callbackProgress)
def execute(self, module, input):
sendCommand("pGF_Corridor_Light_Ceiling_Powered", ON)
sendCommand("pFF_Bathroom_Light_Ceiling_Powered", ON)
sendCommand("pFF_Bathroom_Light_Mirror_Powered", ON)
sendCommand("pFF_Bedroom_Light_Ceiling_Powered", ON)
postUpdate("pOther_Scene2", OFF)
def execute(self, module, input):
sendCommand("pOutdoor_Carport_Automatic_Switch", OFF)
sendCommand("pOutdoor_Streedside_Frontdoor_Automatic_Switch", OFF)
sendCommand("pOutdoor_Terrace_Automatic_Switch", OFF)
sendCommand("pOutdoor_Streedside_Garage_Automatic_Switch", OFF)
sendCommand("pOutdoor_Garden_Garage_Automatic_Switch", ON)
postUpdate("pOther_Scene5", OFF)
def execute(self, module, input):
global ruleTimeouts
now = ZonedDateTime.now()
last = ruleTimeouts.get("Livingroom_Hue_Color_Backward", now)
if ChronoUnit.SECONDS.between(last, now) > 1:
postUpdate("pGF_Livingroom_Light_Hue_Scene", "")
sendCommand("pOther_Manual_State_Lightprogram", 0)
def execute(self, module, input):
if itemStateOlderThen(
"pOutdoor_Streedside_Gardendoor_Bell_Last_Change",
ZonedDateTime.now().minusSeconds(30)):
sendNotification("Klingel", "Es klingelt",
"https://smartmarvin.de/cameraStrasseImage")
postUpdate("pOutdoor_Streedside_Gardendoor_Bell_Last_Change",
DateTimeType())
def execute(self, module, input):
if getItemState("TV_Online") == ON:
if input["command"] == OFF:
sendCommand("TV_Online", OFF)
else:
if input["command"] == ON:
sendCommand("TV_Online", ON)
postUpdate("pOther_Scene6", OFF)
def execute(self, module, input):
# only possible if we are present
if getItemState("pOther_Presence_State").intValue() in [
PresenceHelper.STATE_MAYBE_PRESENT,
PresenceHelper.STATE_PRESENT,
PresenceHelper.STATE_MAYBE_SLEEPING
]:
postUpdate("pOther_Presence_State", PresenceHelper.STATE_SLEEPING)
postUpdate("pOther_Scene4", OFF)
def execute(self, module, input):
state = input['event'].getItemState()
# self.log.info(u"tel 0: {}".format(state.getValue(0)))
# self.log.info(u"tel 1: {}".format(state.getValue(1)))
if type(state) is StringListType and itemStateOlderThen(
"Gardendoor_Bell_Last_Change",
getNow().minusSeconds(30)) and state.getValue(1) == '99999999':
sendNotification("Klingel", "Es klingelt",
"https://bolle.haus/cameraStrasseImage")
postUpdate("Gardendoor_Bell_Last_Change", DateTimeType())
def findStep(self):
duration = getItemState(
"pOutdoor_Watering_Logic_Program_Duration").intValue() * 60.0
remaining = 0
info = u""
# detect current active index
activeIndex = -1
for i in range(len(circuits)):
group = circuits[i]
if getItemState(group[2][0] + "_Powered") == ON:
activeIndex = i
runtime = ChronoUnit.SECONDS.between(
getItemLastChange(group[2][0] + "_Powered"),
ZonedDateTime.now())
remaining = (duration * group[0]) - runtime
break
if remaining <= 0:
nextIndex = -1
# detect next index
for i in range(len(circuits)):
if activeIndex != -1 and i <= activeIndex:
continue
group = circuits[i]
for circuit in group[2]:
if getItemState(circuit + "_Auto") == ON:
nextIndex = i
break
if nextIndex != -1:
break
if nextIndex == -1:
self.disableAllCircuits()
postUpdate("pOutdoor_Watering_Logic_Program_Start", OFF)
else:
for circuit in circuits[nextIndex][2]:
if getItemState(circuit + "_Auto") == ON:
sendCommand(circuit + "_Powered", ON)
nextGroup = circuits[nextIndex]
remaining = (duration * nextGroup[0])
info = nextGroup[1]
# deactivate current index
if activeIndex != -1:
for circuit in circuits[activeIndex][2]:
sendCommand(circuit + "_Powered", OFF)
else:
info = circuits[activeIndex][1]
return [info, remaining]
def execute(self, module, input):
now = ZonedDateTime.now()
supplyCurrent = getItemState(
"pGF_Utilityroom_Energy_Supply_Active").intValue() / 1000.0
zaehlerStandCurrent = (startEnergyTotalSupplyValue + supplyCurrent)
postUpdateIfChanged("pGF_Utilityroom_Electricity_Total_Supply",
zaehlerStandCurrent)
postUpdateIfChanged(
"pGF_Utilityroom_Electricity_Meter_Supply",
zaehlerStandCurrent - startElectricityMeterSupplyValue)
# *** Tageslieferung ***
zaehlerStandOld = getHistoricItemState(
"pGF_Utilityroom_Electricity_Total_Supply",
now.toLocalDate().atStartOfDay(now.getZone())).doubleValue()
currentSupply = zaehlerStandCurrent - zaehlerStandOld
postUpdateIfChanged("pGF_Utilityroom_Electricity_Current_Daily_Supply",
currentSupply)
# *** Jahreslieferung ***
refDay = now.withYear(now.getYear()).withMonth(1).withDayOfMonth(1)
zaehlerStandOld = getHistoricItemState(
"pGF_Utilityroom_Electricity_Total_Supply",
refDay.toLocalDate().atStartOfDay(refDay.getZone())).doubleValue()
currentSupply = zaehlerStandCurrent - zaehlerStandOld
if postUpdateIfChanged(
"pGF_Utilityroom_Electricity_Current_Annual_Supply",
currentSupply):
# Hochrechnung
zaehlerStandCurrentOneYearBefore = getHistoricItemState(
"pGF_Utilityroom_Electricity_Total_Supply",
now.minusYears(1)).doubleValue()
forecastSupply = zaehlerStandOld - zaehlerStandCurrentOneYearBefore
refDay = now.withYear(now.getYear() -
1).withMonth(1).withDayOfMonth(1)
zaehlerStandOldOneYearBefore = getHistoricItemState(
"pGF_Utilityroom_Electricity_Total_Supply",
refDay.toLocalDate().atStartOfDay(
refDay.getZone())).doubleValue()
hochrechnungSupply = int(round(currentSupply + forecastSupply))
vorjahresSupply = int(
round(zaehlerStandOld - zaehlerStandOldOneYearBefore))
msg = u"{}kWh, {} kWh".format(hochrechnungSupply, vorjahresSupply)
postUpdate(
"pGF_Utilityroom_Electricity_Current_Annual_Supply_Forecast",
msg)
def execute(self, module, input):
reference_duration = getItemState(
"pOutdoor_Watering_Logic_Program_Duration").intValue()
for i in range(len(circuits)):
for circuit in circuits[i][2]:
if getItemState(circuit + "_Auto") == ON:
duration = (circuits[i][0] * reference_duration)
duration = int(math.floor(duration))
postUpdate(circuit + "_Info", u"{} min.".format(duration))
else:
postUpdate(circuit + "_Info", u"inaktiv")
def execute(self, module, input):
refDay = ZonedDateTime.now()
start = getHistoricItemState(
"pGF_Utilityroom_Heating_Solar_Power",
refDay.toLocalDate().atStartOfDay(refDay.getZone())).intValue()
aktuell = getItemState(
"pGF_Utilityroom_Heating_Solar_Power").intValue()
if start > 0 and aktuell > 0:
differenz = aktuell - start
postUpdate("pGF_Utilityroom_Heating_Solar_Power_Current_Daily",
differenz)
msg = u"{} KW, {} KW".format(differenz, aktuell)
postUpdateIfChanged("pGF_Utilityroom_Heating_Solar_Power_Message",
msg)
def execute(self, module, input):
sendCommand("gGF_Livingroom_Light_Hue_Color", 60)
states = [OFF, PercentType.ZERO]
for child in getItem("gGF_Lights").getAllMembers():
if child.getState() not in states and child.getName(
) != "gGF_Livingroom_Light_Hue_Color":
sendCommand(child, OFF)
for child in getItem("gFF_Lights").getAllMembers():
if child.getState() not in states:
sendCommand(child, OFF)
postUpdate("pOther_Scene1", OFF)
def process(self, itemName, itemState):
presenceState = getItemState("pOther_Presence_State").intValue()
#sendNotificationToAllAdmins(u"{}".format(itemName), u"{}".format(itemState))
holgerPhone = itemState if itemName == "pOther_Presence_Holger_State" else getItemState(
"pOther_Presence_Holger_State")
sandraPhone = itemState if itemName == "pOther_Presence_Sandra_State" else getItemState(
"pOther_Presence_Sandra_State")
bot = PresenceHelper.getRecipientByStateItem(itemName)
if holgerPhone == ON or sandraPhone == ON:
# only possible if we are away
if presenceState in [
PresenceHelper.STATE_AWAY,
PresenceHelper.STATE_MAYBE_PRESENT
]:
postUpdate("pOther_Presence_State",
PresenceHelper.STATE_PRESENT)
else:
# only possible if we are present and not sleeping
if presenceState in [
PresenceHelper.STATE_MAYBE_PRESENT,
PresenceHelper.STATE_PRESENT
]:
postUpdate("pOther_Presence_State", PresenceHelper.STATE_AWAY)
if itemState == ON:
sendNotification(u"System", u"Willkommen", recipients=[bot])
else:
if holgerPhone == OFF and sandraPhone == OFF:
lightMsg = u" - LICHT an" if getItemState(
"gIndoor_Lights") != OFF else u""
windowMsg = u" - FENSTER offen" if getItemState(
"gOpeningcontacts") != CLOSED else u""
sendNotification(u"System",
u"Auf Wiedersehen{}{}".format(
lightMsg, windowMsg),
recipients=[bot])
else:
sendNotification(u"System",
u"Auf Wiedersehen",
recipients=[bot])
def execute(self, module, input):
sendCommand("pGF_Corridor_Light_Hue_Color", 60)
sendCommand("pFF_Bathroom_Light_Ceiling_Powered", ON)
sendCommand("pFF_Bathroom_Light_Mirror_Powered", ON)
sendCommand("pFF_Bedroom_Light_Hue_Right_Switch", ON)
states = [OFF, PercentType.ZERO]
for child in getItem("gGF_Lights").getAllMembers():
if child.getState() not in states and child.getName(
) != "pGF_Corridor_Light_Hue_Color":
sendCommand(child, OFF)
#for child in getItem("gFF_Lights").getAllMembers():
# if child.getState() not in states and child.getName() not in ["pFF_Bathroom_Light_Mirror_Powered", "pFF_Bedroom_Light_Hue_Right_Switch"]:
# sendCommand(child, OFF)
sendCommand("pOther_Scene6", ON)
postUpdate("pOther_Scene3", OFF)
def execute(self, module, input):
global ruleTimeouts
ruleTimeouts["Livingroom_Hue_Color_Backward"] = ZonedDateTime.now()
command = input['event'].getItemCommand()
#colors = command.toString().split(",")
#red = round(float(colors[0]))
#green = round(float(colors[1]))
#blue = round(float(colors[1]))
#command = u"{},{},{}".format(red,green,blue)
sendCommand("pGF_Livingroom_Light_Hue1_Color", command)
sendCommand("pGF_Livingroom_Light_Hue2_Color", command)
sendCommand("pGF_Livingroom_Light_Hue3_Color", command)
sendCommand("pGF_Livingroom_Light_Hue4_Color", command)
sendCommand("pGF_Livingroom_Light_Hue5_Color", command)
postUpdate("pGF_Livingroom_Light_Hue_Scene", "")
sendCommand("pOther_Manual_State_Lightprogram", 0)
def execute(self, module, input):
if 'event' not in input:
self.processor = CommandProcessor(self.log, ir)
Tests.process(self.processor, self.log, ir)
#self.log.info(u"{}".format(input))
else:
postUpdate("VoiceMessage", "")
voice_command, client_id = self.processor.parseData(
input['event'].getItemState().toString())
fallback_location_name = AlexaDevices[
client_id] if client_id in AlexaDevices else None
self.log.info(u"Process: '{}', Location: '{}'".format(
voice_command, client_id
if fallback_location_name is None else fallback_location_name))
actions = self.processor.process(voice_command,
fallback_location_name)
msg, is_valid = self.processor.applyActions(
actions, voice_command, False)
postUpdate("VoiceMessage", msg)
def disableAllCircuits(self):
for child in getGroupMember("gOutdoor_Watering_Circuits"):
sendCommand(child, OFF)
postUpdate("pOutdoor_Watering_Logic_Program_State", u"läuft nicht")
def execute(self, module, input):
#sendCommand("pOther_Helper_HabpanelViewer_Control_Cmd", "RELOAD")
urllib2.urlopen("http://192.168.0.40:5000/reload").read()
postUpdate("pOther_Scene7", OFF)
def wakeup(self):
postUpdate("pOther_Presence_State", PresenceHelper.STATE_PRESENT)
sendNotification(u"System", u"Guten Morgen")
def execute(self, module, input):
postUpdate("pGF_Livingroom_Television_KeyPOWER", ON if input["event"].getStatusInfo().getStatus().toString() == "ONLINE" else OFF )
def execute(self, module, input):
now = ZonedDateTime.now()
currentACPower = getItemState(
"pGF_Garage_Solar_Inverter_AC_Power").intValue()
currentPowerLimitation = getItemStateWithFallback(
"pGF_Garage_Solar_Inverter_Power_Limitation",
DecimalType(0)).intValue()
currentConsumptionValue = getItemState(
"pGF_Utilityroom_Electricity_Current_Consumption").intValue()
# must be called to fill history stack
avgConsumptionValue = self.getAvgConsumption(now,
currentConsumptionValue)
if currentACPower > 0:
possiblePowerLimitation = self.getPossibleLimitation(
currentConsumptionValue)
possibleAvgPowerLimitation = self.getPossibleLimitation(
avgConsumptionValue)
self.log.info(
u"currentLimit: {}%, currentConsumption: {}W, avgConsumption: {}W, possibleLimit: {}%, possibleAvgLimit: {}%, stack: {}, li: {}"
.format(
currentPowerLimitation, currentConsumptionValue,
avgConsumptionValue, possiblePowerLimitation,
possibleAvgPowerLimitation, len(self.stack),
ChronoUnit.MILLIS.between(self.lastLimitationIncrease,
now)))
if possiblePowerLimitation >= currentPowerLimitation:
self.lastLimitationIncrease = now
if possiblePowerLimitation > currentPowerLimitation:
sendCommand("pGF_Garage_Solar_Inverter_Power_Limitation",
possiblePowerLimitation)
self.log.info(
u"Increase power limitation from {}% to {}%".format(
currentPowerLimitation, possiblePowerLimitation))
return
elif ChronoUnit.MILLIS.between(self.lastLimitationIncrease,
now) > maxTimeSlot:
if possibleAvgPowerLimitation < currentPowerLimitation:
sendCommand("pGF_Garage_Solar_Inverter_Power_Limitation",
possibleAvgPowerLimitation)
self.log.info(
u"Decrease power limitation from {}% to {}%".format(
currentPowerLimitation,
possibleAvgPowerLimitation))
return
if len(input) == 0 and itemLastChangeOlderThen(
"pGF_Garage_Solar_Inverter_Power_Limitation",
ZonedDateTime.now().minusMinutes(4)):
sendCommand("pGF_Garage_Solar_Inverter_Power_Limitation",
currentPowerLimitation)
self.log.info(u"Refresh power limitation of {}%".format(
currentPowerLimitation))
elif currentPowerLimitation != 100:
postUpdate("pGF_Garage_Solar_Inverter_Power_Limitation", 100)
self.log.info(u"Shutdown power limitation")
def execute(self, module, input):
if 'event' in input.keys() and input['event'].getItemName(
) == "pGF_Utilityroom_Ventilation_Fan_Level":
if self.autoChangeInProgress:
self.autoChangeInProgress = False
else:
postUpdate("pGF_Utilityroom_Ventilation_Auto_Mode", OFF)
return
if getItemState("pGF_Utilityroom_Ventilation_Auto_Mode") == OFF:
return
if isinstance(
getItemState("pGF_Utilityroom_Ventilation_Fan_Level"),
UnDefType) or isinstance(
getItemState(
"pGF_Utilityroom_Ventilation_Comfort_Temperature"),
UnDefType):
return
currentLevel = getItemState(
"pGF_Utilityroom_Ventilation_Fan_Level").intValue()
if self.activeLevel == -1:
self.activeLevel = currentLevel
raumTemperatur = getItemState(
"pGF_Livingroom_Air_Sensor_Temperature_Value").doubleValue()
zielTemperatur = getItemState(
"pGF_Utilityroom_Ventilation_Comfort_Temperature").doubleValue
presenceState = getItemState("pOther_Presence_State").intValue()
isTooWarm = raumTemperatur >= zielTemperatur
outdoorTemperatureItemName = getItemState(
"pOutdoor_WeatherStation_Temperature_Item_Name").toString()
coolingPossible = getItemState(
outdoorTemperatureItemName).doubleValue() < raumTemperatur
# Sleep
if presenceState in [
PresenceHelper.STATE_MAYBE_SLEEPING,
PresenceHelper.STATE_SLEEPING
]:
reducedLevel = 2 # Level 1
defaultLevel = 2 # Level 1
coolingLevel = 2 # Level 1
# Away since 60 minutes
elif presenceState == [
PresenceHelper.STATE_AWAY, PresenceHelper.STATE_MAYBE_PRESENT
] and itemLastChangeOlderThen("pOther_Presence_State",
ZonedDateTime.now().minusMinutes(60)):
reducedLevel = 1 # Level A
defaultLevel = 2 # Level 1
coolingLevel = 3 # Level 2
else:
reducedLevel = 2 # Level 1
defaultLevel = 3 # Level 2
coolingLevel = 3 # Level 2
# reducedLevel if it is too warm inside and also outside
# coolingLevel if it is too warm inside but outside colder then inside
newLevel = (coolingLevel if coolingPossible else
reducedLevel) if isTooWarm else defaultLevel
if newLevel != currentLevel:
# Wenn der aktuelle Level Stufe 'A' (also 1) ist, sollte vor einem erneuten umschalten gewartet werden damit ein
# hin und herschalten vermieden wird. z.B. bei kurzzeitigen Temperaturschwankungen
if currentLevel == 1:
waitBeforeChange = 15
else:
# must be > 1. Otherwise changedSince does not work properly
waitBeforeChange = 2
# 1. self.activeLevel != currentLevel means last try was not successful
# 2. 'event' in input.keys() is an presence or auto mode change
# 3. is cron triggered event
if self.activeLevel != currentLevel or 'event' in input.keys(
) or itemLastChangeOlderThen(
"pGF_Utilityroom_Ventilation_Fan_Level",
ZonedDateTime.now().minusMinutes(waitBeforeChange)):
self.autoChangeInProgress = True
sendCommand("pGF_Utilityroom_Ventilation_Fan_Level", newLevel)
self.activeLevel = newLevel
def callback(self):
self.timer = None
postUpdate("pOutdoor_Streedside_Gardendoor_Opener_Timer", OFF)
sendCommandIfChanged("pOutdoor_Streedside_Gardendoor_Opener_Powered",
OFF)
def execute(self, module, input):
postUpdate("pOther_Manual_State_Auto_Sunprotection", OFF)
def execute(self, module, input):
now = ZonedDateTime.now()
# pOutdoor_Astro_Dawn_Time
# pOutdoor_Astro_Sunrise_Time
# pOutdoor_Astro_Sunset_Time
# pOutdoor_Astro_Dusk_Time
cloudCover = getItemState(
"pOutdoor_Weather_Current_Cloud_Cover").intValue()
lightLevel = getItemState(
"pOutdoor_WeatherStation_Light_Level").intValue() if getItemState(
"pOutdoor_WeatherStation_Is_Working") == ON else 1000
#self.log.info(str(cloudCover))
automaticRollershutterState = getItemState(
"pOther_Automatic_State_Rollershutter").intValue()
if automaticRollershutterState != SunProtectionHelper.STATE_ROLLERSHUTTER_UP:
_upTime = getItemState(
"pOutdoor_Astro_Sunrise_Time").getZonedDateTime()
_upTime = _upTime.plusSeconds(int((cloudCover * 30.0 / 9.0) * 60))
if now.getHour() < 12 and now.toLocalDate().isEqual(
_upTime.toLocalDate()):
if now.isAfter(_upTime) or now.isEqual(_upTime):
postUpdate("pOther_Automatic_State_Rollershutter",
SunProtectionHelper.STATE_ROLLERSHUTTER_UP)
elif lightLevel > 0 and automaticRollershutterState != SunProtectionHelper.STATE_ROLLERSHUTTER_MAYBE_UP:
_upTime = getItemState(
"pOutdoor_Astro_Dawn_Time").getZonedDateTime()
if now.isAfter(_upTime) or now.isEqual(_upTime):
postUpdate(
"pOther_Automatic_State_Rollershutter",
SunProtectionHelper.STATE_ROLLERSHUTTER_MAYBE_UP)
postUpdateIfChanged("pOther_Automatic_State_Rollershutter_Up",
_upTime.toString())
else:
_downTime = getItemState(
"pOutdoor_Astro_Dusk_Time").getZonedDateTime()
_downTime = _downTime.minusSeconds(
int((cloudCover * 30.0 / 9.0) * 60))
if now.isAfter(_downTime) or now.isEqual(_downTime):
postUpdate("pOther_Automatic_State_Rollershutter",
SunProtectionHelper.STATE_ROLLERSHUTTER_DOWN)
elif lightLevel <= 0:
_downTime = getItemState(
"pOutdoor_Astro_Sunset_Time").getZonedDateTime()
if now.isAfter(_downTime) or now.isEqual(_downTime):
postUpdate("pOther_Automatic_State_Rollershutter",
SunProtectionHelper.STATE_ROLLERSHUTTER_DOWN)
postUpdateIfChanged("pOther_Automatic_State_Rollershutter_Down",
_downTime.toString())
if lightLevel <= 0 or itemStateOlderThen(
"pOutdoor_Astro_Sunset_Time", now) or itemStateNewerThen(
"pOutdoor_Astro_Sunrise_Time", now):
postUpdateIfChanged("pOther_Automatic_State_Outdoorlights", ON)
else:
postUpdateIfChanged("pOther_Automatic_State_Outdoorlights", OFF)
if itemStateOlderThen("pOutdoor_Astro_Dusk_Time",
now) or itemStateNewerThen(
"pOutdoor_Astro_Dawn_Time", now):
postUpdateIfChanged("pOther_Automatic_State_Solar", OFF)
else:
postUpdateIfChanged("pOther_Automatic_State_Solar", ON)
def execute(self, module, input):
if input["event"].getItemName(
) == "pGF_Garage_Solar_Inverter_AC_Power":
self.updateConsumption(input['event'].getItemState().intValue())
else:
if input["event"].getItemName(
) == "pGF_Utilityroom_Power_Demand_Active":
self.powerDemand = input["event"].getItemState().intValue()
self.powerSupply = getItemState(
"pGF_Utilityroom_Power_Supply_Active").intValue()
if self.powerDemand != getItemState(
"pGF_Utilityroom_Power_Demand_Active").intValue():
self.log.error(
"Item demand state differences: {}, item state: {}".
format(
self.powerDemand,
getItemState("pGF_Utilityroom_Power_Demand_Active"
).intValue()))
else:
self.powerDemand = getItemState(
"pGF_Utilityroom_Power_Demand_Active").intValue()
self.powerSupply = input["event"].getItemState().intValue()
if self.powerSupply != getItemState(
"pGF_Utilityroom_Power_Supply_Active").intValue():
self.log.error(
"Item supply state differences: {}, item state: {}".
format(
self.powerSupply,
getItemState("pGF_Utilityroom_Power_Supply_Active"
).intValue()))
self.currentDemand = self.powerDemand - self.powerSupply
#self.log.info(u"{}".format(itemLastUpdateOlderThen("pGF_Garage_Solar_Inverter_Total_Yield", ZonedDateTime.now().minusMinutes(15))))
if getItemState("pOther_Automatic_State_Solar") == ON:
if itemLastUpdateOlderThen(
"pOther_Automatic_State_Solar",
ZonedDateTime.now().minusMinutes(60)):
# solar value update was not successful for a while
#solarActive = getItemState("pOther_Automatic_State_Solar") == ON
#if itemLastUpdateOlderThen("pGF_Garage_Solar_Inverter_Total_Yield", ZonedDateTime.now().minusHours(5) if solarActive else ZonedDateTime.now().minusHours(14)):
if (itemLastUpdateOlderThen(
"pGF_Garage_Solar_Inverter_Total_Yield",
ZonedDateTime.now().minusMinutes(15)) or
(itemLastUpdateOlderThen(
"pGF_Garage_Solar_Inverter_AC_Power",
ZonedDateTime.now().minusMinutes(60))
and getItemState("pGF_Garage_Solar_Inverter_AC_Power"
).intValue() > 0)):
# and
#(itemLastUpdateOlderThen("pGF_Garage_Solar_Inverter_AC_Power", ZonedDateTime.now().minusMinutes(15)) or getItemState("pGF_Garage_Solar_Inverter_AC_Power").intValue() == 0)):
if postUpdateIfChanged(
"pGF_Garage_Solar_Inverter_Is_Working", OFF):
postUpdate("pGF_Garage_Solar_Inverter_AC_Power", 0)
postUpdateIfChanged(
"pGF_Garage_Solar_Inverter_DC_Power", 0)
postUpdateIfChanged(
"pGF_Garage_Solar_Inverter_DC_Current", 0)
postUpdateIfChanged(
"pGF_Garage_Solar_Inverter_DC_Voltage", 0)
postUpdateIfChanged(
"pGF_Garage_Solar_Inverter_Daily_Yield", 0)
else:
postUpdateIfChanged(
"pGF_Garage_Solar_Inverter_Is_Working", ON)
# triggers solar value update
sendCommand("pGF_Garage_Solar_Inverter_AC_Power", REFRESH)
else:
self.updateConsumption(0)
postUpdateIfChanged("pGF_Garage_Solar_Inverter_Is_Working", ON)
postUpdateIfChanged("pGF_Utilityroom_Electricity_Current_Demand",
self.currentDemand)
def execute(self, module, input):
now = ZonedDateTime.now()
Aktuell_End = getItemState(
"pGF_Utilityroom_Gas_Meter_Pulse_Counter").doubleValue()
# Aktueller Zählerstand
zaehlerStandCurrent = startGasMeterValue + (
(Aktuell_End - startGasImpulseCounter) * 0.01)
zaehlerStandSaved = getItemStateWithFallback(
"pGF_Utilityroom_Gas_Meter_Current_Count",
DecimalType(0.0)).doubleValue()
#self.log.info("{}".format(zaehlerStandCurrent))
if zaehlerStandCurrent < zaehlerStandSaved:
self.log.error("Consumption: Calculation is wrong {} {}".format(
zaehlerStandCurrent, zaehlerStandSaved))
return
if zaehlerStandCurrent > zaehlerStandSaved:
# Aktueller Zählerstand
postUpdate("pGF_Utilityroom_Gas_Meter_Current_Count",
zaehlerStandCurrent)
# *** Aktueller Tagesverbrauch ***
zaehlerStandOld = getHistoricItemState(
"pGF_Utilityroom_Gas_Meter_Current_Count",
now.toLocalDate().atStartOfDay(now.getZone())).doubleValue()
currentConsumption = zaehlerStandCurrent - zaehlerStandOld
if currentConsumption < 0:
currentConsumption = 0
postUpdateIfChanged("pGF_Utilityroom_Gas_Current_Daily_Consumption",
currentConsumption)
# *** Jahresverbrauch ***
refDay = now.withYear(now.getYear()).withMonth(1).withDayOfMonth(1)
zaehlerStandOld = getHistoricItemState(
"pGF_Utilityroom_Gas_Meter_Current_Count",
refDay.toLocalDate().atStartOfDay(refDay.getZone())).doubleValue()
currentConsumption = zaehlerStandCurrent - zaehlerStandOld
if currentConsumption < 0:
currentConsumption = 0
if postUpdateIfChanged("pGF_Utilityroom_Gas_Annual_Consumption",
currentConsumption):
# Hochrechnung
zaehlerStandCurrentOneYearBefore = getHistoricItemState(
"pGF_Utilityroom_Gas_Meter_Current_Count",
now.minusYears(1)).doubleValue()
forecastConsumtion = zaehlerStandOld - zaehlerStandCurrentOneYearBefore
refDay = now.withYear(now.getYear() -
1).withMonth(1).withDayOfMonth(1)
zaehlerStandOldOneYearBefore = getHistoricItemState(
"pGF_Utilityroom_Gas_Meter_Current_Count",
refDay.toLocalDate().atStartOfDay(
refDay.getZone())).doubleValue()
hochrechnungVerbrauch = round(currentConsumption +
forecastConsumtion)
msg = u"{} m³, {} m³".format(
hochrechnungVerbrauch,
int(round(zaehlerStandOld - zaehlerStandOldOneYearBefore)))
postUpdate("pGF_Utilityroom_Gas_Forecast", msg)
