def execute(self, module, input):
msg = u"Nicht aktiv"
if getItemState(
"pOther_Manual_State_Auto_Attic_Light").intValue() != 1:
soilMoistSensor1 = getItemState(
"pIndoor_Plant_Sensor_Device_State1").intValue(
) if getItemState(
"pIndoor_Plant_Sensor_Device_Enabled1") == ON else 1000
soilMoistSensor2 = getItemState(
"pIndoor_Plant_Sensor_Device_State2").intValue(
) if getItemState(
"pIndoor_Plant_Sensor_Device_Enabled2") == ON else 1000
soilMoistSensor3 = getItemState(
"pIndoor_Plant_Sensor_Device_State3").intValue(
) if getItemState(
"pIndoor_Plant_Sensor_Device_Enabled3") == ON else 1000
soilMoistSensor4 = getItemState(
"pIndoor_Plant_Sensor_Device_State4").intValue(
) if getItemState(
"pIndoor_Plant_Sensor_Device_Enabled4") == ON else 1000
if soilMoistSensor1 < 380 or soilMoistSensor2 < 380 or soilMoistSensor3 < 380 or soilMoistSensor4 < 380:
msg = u"Jetzt Giessen"
elif soilMoistSensor1 < 400 or soilMoistSensor2 < 400 or soilMoistSensor3 < 400 or soilMoistSensor4 < 400:
msg = u"Giessen"
else:
msg = u"Feucht genug"
postUpdateIfChanged("pIndoor_Plant_Sensor_Watering_Info", msg)
def delayUpdate(self):
efficiency = 0
if getItemState("pGF_Utilityroom_Ventilation_Bypass") == OFF:
if isinstance(getItemState("pGF_Utilityroom_Ventilation_Outdoor_Incoming_Temperature"), UnDefType) \
or isinstance(getItemState("pGF_Utilityroom_Ventilation_Indoor_Outgoing_Temperature"), UnDefType) \
or isinstance(getItemState("pGF_Utilityroom_Ventilation_Indoor_Incoming_Temperature"), UnDefType):
return
tempOutIn = getItemState(
"pGF_Utilityroom_Ventilation_Outdoor_Incoming_Temperature"
).doubleValue()
tempInOut = getItemState(
"pGF_Utilityroom_Ventilation_Indoor_Outgoing_Temperature"
).doubleValue()
tempInIn = getItemState(
"pGF_Utilityroom_Ventilation_Indoor_Incoming_Temperature"
).doubleValue()
if tempInOut != tempOutIn:
efficiency = (tempInIn - tempOutIn) / (tempInOut -
tempOutIn) * 100
efficiency = round(efficiency)
else:
efficiency = 100
else:
efficiency = 0
postUpdateIfChanged("pGF_Utilityroom_Ventilation_Bypass_Efficiency",
efficiency)
self.updateTimer = None
def updateInfoMessage(self,
infoItem,
temperatureItem,
humidityItem,
co2Item=None,
temperatureTargetItem=None):
#self.log.info(u">>>delay: {}".format(infoItem))
msg = u""
if temperatureTargetItem is not None:
msg = u"{}({}) ".format(
msg,
getItemState(temperatureTargetItem).format("%.1f"))
#self.log.info(temperatureItem)
msg = u"{}{} °C, ".format(msg,
getItemState(temperatureItem).format("%.1f"))
#self.log.info(humidityItem)
msg = u"{}{} %".format(msg, getItemState(humidityItem).format("%.1f"))
if co2Item is not None:
msg = u"{}, {} ppm".format(msg, getItemState(co2Item).format("%d"))
postUpdateIfChanged(infoItem, msg)
self.updateTimer[infoItem] = None
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 delayUpdate(self):
active = []
if isinstance(getItemState("pGF_Utilityroom_Ventilation_Filter_Error"), UnDefType) \
or isinstance(getItemState("pGF_Utilityroom_Ventilation_Error_Message"), UnDefType):
return
if getItemState("pGF_Utilityroom_Ventilation_Filter_Error") == ON:
active.append(u"Filter")
if getItemState("pGF_Utilityroom_Ventilation_Error_Message").toString(
) != "No Errors":
active.append(u"Error: {}".format(
getItemState(
"pGF_Utilityroom_Ventilation_Error_Message").toString()))
if getItemState("pGF_Utilityroom_Ventilation_Thing_State").toString(
) != "Alles ok":
active.append(u"Error: {}".format(
getItemState(
"pGF_Utilityroom_Ventilation_Thing_State").toString()))
if len(active) == 0:
active.append(u"Alles ok")
msg = ", ".join(active)
postUpdateIfChanged("pGF_Utilityroom_Ventilation_State_Message", msg)
self.updateTimer = None
def execute(self, module, input):
global ruleTimeouts
now = ZonedDateTime.now()
last = ruleTimeouts.get("Motiondetector_Outdoor_Main_Switch",
now.minusHours(1))
if ChronoUnit.SECONDS.between(last, now) > 1:
itemState = input["event"].getItemState()
self.log.info(
"MotiondetectorOutdoorSwitchRule => last: {}, now: {}, state: {}"
.format(last, now, itemState))
if itemState == ON:
ruleTimeouts["Light_Outdoor"] = now
sendCommandIfChanged(
"pOutdoor_Streedside_Garage_Light_Powered", OFF)
sendCommandIfChanged(
"pOutdoor_Streedside_Frontdoor_Light_Powered", OFF)
sendCommandIfChanged("pOutdoor_Carport_Light_Powered", OFF)
sendCommandIfChanged("pOutdoor_Terrace_Light_Brightness", 0)
sendCommandIfChanged("pOutdoor_Garden_Garage_Light_Powered",
OFF)
#ruleTimeouts["Motiondetector_Outdoor_Individual_Switches"] = now
postUpdateIfChanged("pOutdoor_Streedside_Garage_Automatic_Switch",
itemState)
postUpdateIfChanged(
"pOutdoor_Streedside_Frontdoor_Automatic_Switch", itemState)
postUpdateIfChanged("pOutdoor_Carport_Automatic_Switch", itemState)
postUpdateIfChanged("pOutdoor_Terrace_Automatic_Switch", itemState)
postUpdateIfChanged("pOutdoor_Garden_Garage_Automatic_Switch",
itemState)
def execute(self, module, input):
#self.log.info(u"{}".format(input))
now = ZonedDateTime.now().toInstant().toEpochMilli()
if self.lastUpdate != -1:
currentValue = input['event'].getItemState().longValue()
prevValue = input['event'].getOldItemState().longValue()
# binding is uint (32)
# => max value can be 4294967295
# => is also reseted on dsl reconnection
if currentValue > prevValue:
diffValue = (currentValue - prevValue) * 8
diffTime = (now - self.lastUpdate) / 1000.0
speed = round(diffValue / diffTime)
postUpdateIfChanged("FritzboxWanDownstreamCurrRate", speed)
else:
self.log.info(
u"wan traffic overflow - prev: {}, current: {}".format(
prevValue, currentValue))
#self.log.info(u"Downstream {} MBit".format(speed))
self.lastUpdate = now
def execute(self, module, input):
now = ZonedDateTime.now()
if itemStateOlderThen("Dawn_Time", now) and itemStateNewerThen(
"Dusk_Time", now):
# triggers solar value update
sendCommand("Solar_Total_Yield", REFRESH)
sendCommand("Solar_AC_Power", REFRESH)
acPower = getItemState('Solar_AC_Power').intValue()
dailyConsumption = getItemState("Solar_Daily_Yield").doubleValue()
msg = "{} W, {:.2f} kWh".format(acPower, dailyConsumption)
if itemLastUpdateOlderThen(
"Solar_Total_Yield",
now.minusMinutes(15)) and itemStateOlderThen(
"Dawn_Time", now.minusMinutes(60)):
self.log.error("Solar values not updated")
else:
msg = "Inaktiv"
postUpdateIfChanged("Solar_Message", msg)
def execute(self, module, input):
if isinstance(input['event'].getItemState(), UnDefType):
return
laufzeit = input['event'].getItemState().doubleValue()
weeks = int(math.floor(laufzeit / 168.0))
days = int(math.floor((laufzeit - (weeks * 168.0)) / 24))
active = []
if weeks > 0:
if weeks == 1:
active.append(u"1 Woche")
else:
active.append(u"{} Wochen".format(weeks))
if days > 0:
if days == 1:
active.append(u"1 Tag")
else:
active.append(u"{} Tage".format(days))
msg = u", ".join(active)
postUpdateIfChanged(
"pGF_Utilityroom_Ventilation_Filter_Runtime_Message", msg)
def delayUpdate(self):
msg = u"{}%, {}%".format(
getItemState("pGF_Utilityroom_Heating_Power").format("%.0f"),
getItemState("pGF_Utilityroom_Heating_Circuit_Pump_Speed").format(
"%.0f"))
postUpdateIfChanged("pGF_Utilityroom_Heating_Power_Message", msg)
self.updateTimer = None
def execute(self, module, input):
state = getItemState("pIndoor_Plant_Sensor_Watering_Info").toString()
if state != "Feucht genug" and state != "Nicht aktiv":
msg = state
else:
msg = u"Alles ok"
postUpdateIfChanged("pIndoor_Plant_Sensor_Main_Info", msg)
def execute(self, module, input):
now = ZonedDateTime.now()
currentErtrag = getItemState("Solar_Annual_Yield").doubleValue()
currentEinspeisung = getItemState(
"Electric_VZ_Jahreseinspeisung").doubleValue()
postUpdateIfChanged("Solar_Annual_Consumption",
currentErtrag - currentEinspeisung)
def delayUpdate(self):
msg = u"{}°C, {}°C".format(
getItemState("pGF_Utilityroom_Heating_Temperature_Offset").format(
"%.1f"),
getItemState("pGF_Utilityroom_Heating_Temperature_Offset_Target").
format("%.1f"))
postUpdateIfChanged(
"pGF_Utilityroom_Heating_Temperature_Offset_Message", msg)
self.updateTimer = None
def updateConsumption(self, solarPower):
consumption = self.currentDemand + solarPower
if consumption > 0:
postUpdateIfChanged(
"pGF_Utilityroom_Electricity_Current_Consumption", consumption)
else:
self.log.info(
u"Skip consumption update. powerDemand: {}, powerSupply: {}, solarPower: {}"
.format(self.powerDemand, self.powerSupply, solarPower))
def delayUpdate(self):
if isinstance(getItemState("pGF_Utilityroom_Ventilation_Incoming"), UnDefType) \
or isinstance(getItemState("pGF_Utilityroom_Ventilation_Outgoing"), UnDefType):
return
msg = u"→ {}%, ← {}%".format(
getItemState("pGF_Utilityroom_Ventilation_Incoming").toString(),
getItemState("pGF_Utilityroom_Ventilation_Outgoing").toString())
postUpdateIfChanged("pGF_Utilityroom_Ventilation_Fan_Message", msg)
self.updateTimer = None
def execute(self, module, input):
dailyEnergyDemand = getItemState(
"pGF_Utilityroom_Electricity_Current_Daily_Demand").doubleValue()
dailyEnergySupply = getItemState(
"pGF_Utilityroom_Electricity_Current_Daily_Supply").doubleValue()
dailySolarSupply = getItemState(
"pGF_Garage_Solar_Inverter_Daily_Yield").doubleValue()
postUpdateIfChanged(
"pGF_Utilityroom_Electricity_Current_Daily_Consumption",
dailyEnergyDemand - dailyEnergySupply + dailySolarSupply)
def delayUpdate(self):
solarCollector = getItemState(
"pGF_Utilityroom_Heating_Temperature_Solar_Collector")
solarStorage = getItemState(
"pGF_Utilityroom_Heating_Temperature_Solar_Storage")
msg = u"{}°C, {}°C".format(solarCollector.format("%.1f"),
solarStorage.format("%.1f"))
postUpdateIfChanged(
"pGF_Utilityroom_Heating_Temperature_Solar_Message", msg)
self.updateTimer = None
def delayUpdate(self):
msg = u"({}°C) {}°C, {}°C".format(
getItemState("pOutdoor_Weather_Forecast_Temperature_4h").format(
"%.1f"),
getItemState("pGF_Utilityroom_Heating_Temperature_Outdoor").format(
"%.1f"),
getItemState("pGF_Utilityroom_Heating_Temperature_Outdoor_Subdued"
).format("%.1f"))
postUpdateIfChanged(
"pGF_Utilityroom_Heating_Temperature_Outdoor_Message", msg)
self.updateTimer = None
def execute(self, module, input):
refDay = ZonedDateTime.now()
start = getHistoricItemState(
"pGF_Utilityroom_Heating_Solar_Hours",
refDay.toLocalDate().atStartOfDay(refDay.getZone())).intValue()
aktuell = getItemState(
"pGF_Utilityroom_Heating_Solar_Hours").intValue()
if start > 0 and aktuell > 0:
differenz = aktuell - start
msg = u"{} h, {} h".format(differenz, aktuell)
postUpdateIfChanged("pGF_Utilityroom_Heating_Solar_Hours_Message",
msg)
def check(self):
thing = getThing("homeconnect:api_bridge:default")
status = thing.getStatus()
info = thing.getStatusInfo()
if status is not None and info is not None:
#self.log.info(u"Home Connect bridge status: '{}', detail: '{}'".format(status.toString(),info.toString()))
if status.toString() != "ONLINE":
postUpdateIfChanged("pOther_State_Message_Homeconnect",
info.toString())
else:
postUpdateIfChanged("pOther_State_Message_Homeconnect",
"Alles ok")
def check(self):
thing = getThing("comfoair:comfoair:default")
status = thing.getStatus()
info = thing.getStatusInfo()
#self.log.info(u"{}".format(status))
if status is not None and info is not None:
if status.toString() != 'ONLINE':
postUpdateIfChanged("pGF_Utilityroom_Ventilation_Thing_State",
info.toString())
else:
postUpdateIfChanged("pGF_Utilityroom_Ventilation_Thing_State",
"Alles ok")
def execute(self, module, input):
active = []
if getItemState("gOutdoor_Watering_Circuits") == ON:
active.append(u"Bewässerung")
if getItemState("pOutdoor_Light_Automatic_Main_Switch") != ON:
active.append(u"Beleuchtung")
if len(active) == 0:
active.append(u"Alles ok")
msg = ", ".join(active)
postUpdateIfChanged("pOther_State_Message_Garden", msg)
def execute(self, module, input):
now = ZonedDateTime.now()
currentTotal = getItemState("Solar_Total_Yield").doubleValue()
startTotal = getHistoricItemState(
"Solar_Total_Yield",
now.toLocalDate().atStartOfDay(now.getZone())).doubleValue()
postUpdateIfChanged("Solar_Daily_Yield", currentTotal - startTotal)
refDay = now.withYear(now.getYear()).withMonth(1).withDayOfMonth(1)
startTotal = getHistoricItemState(
"Solar_Total_Yield",
refDay.toLocalDate().atStartOfDay(refDay.getZone())).doubleValue()
postUpdateIfChanged("Solar_Annual_Yield", currentTotal - startTotal)
def execute(self, module, input):
active = []
if getItemState("pIndoor_Plant_Sensor_Device_Enabled1") == ON:
active.append("1")
if getItemState("pIndoor_Plant_Sensor_Device_Enabled2") == ON:
active.append("2")
if getItemState("pIndoor_Plant_Sensor_Device_Enabled3") == ON:
active.append("3")
if getItemState("pIndoor_Plant_Sensor_Device_Enabled4") == ON:
active.append("4")
if getItemState("pIndoor_Plant_Sensor_Device_Enabled5") == ON:
active.append("5")
if getItemState("pIndoor_Plant_Sensor_Device_Enabled6") == ON:
active.append("6")
postUpdateIfChanged("pIndoor_Plant_Sensor_Activation_Info",
u", ".join(active))
def execute(self, module, input):
active = []
group = "Fehler"
ventilation_state = getItemState(
"pGF_Utilityroom_Ventilation_State_Message").toString()
if ventilation_state != "Alles ok":
if ventilation_state == "Filter":
active.append(u"Filter")
else:
active.append(u"Lüftung")
if getItemState("pGF_Utilityroom_Heating_State_Message").toString(
) != "Alles ok":
active.append(u"Heizung")
if getItemState("pGF_Garage_Solar_Inverter_Is_Working") == OFF:
active.append(u"Solar")
if getItemState("State_Server").intValue() > 1:
active.append(u"Server")
if len(active) == 0:
active.append(u"Alles ok")
group = "Info"
msg = u", ".join(active)
if postUpdateIfChanged("pOther_State_Message_Main", msg):
sendNotificationToAllAdmins("Main " + group, msg)
def execute(self, module, input):
#self.log.info(u"{}".format(input))
global ruleTimeouts
now = ZonedDateTime.now()
last = ruleTimeouts.get("Light_Outdoor", now.minusHours(1))
# No Motion Detector related events
if ChronoUnit.SECONDS.between(last, now) > 1:
itemName = input['event'].getItemName()
self.log.info(
"LightOutdoorControlRule => Automatic_Switches => OFF, last: {}, now: {}"
.format(last, now))
global timerMappings
timer = timerMappings.get(itemName)
if timer is not None:
timer.cancel()
for i, entry in enumerate(manualMappings):
if entry[0] == itemName:
#ruleTimeouts["Motiondetector_Outdoor_Individual_Switches"] = now
# just an update to avoid triggering => MotiondetectorOutdoorIndividualSwitchRule
if postUpdateIfChanged(entry[1], OFF):
ruleTimeouts[
"Motiondetector_Outdoor_Main_Switch"] = now
# must be a command to inform physical knx switch
sendCommandIfChanged(
"pOutdoor_Light_Automatic_Main_Switch", OFF)
#self.log.info(u"{} {}".format(itemName,now-last))
break
def delayUpdate(self):
if isinstance(getItemState("pGF_Utilityroom_Ventilation_Indoor_Incoming_Temperature"), UnDefType) \
or isinstance(getItemState("pGF_Utilityroom_Ventilation_Indoor_Outgoing_Temperature"), UnDefType):
return
msg = u"→ {}°C, ← {}°C".format(
getItemState(
"pGF_Utilityroom_Ventilation_Indoor_Incoming_Temperature").
format("%.1f"),
getItemState(
"pGF_Utilityroom_Ventilation_Indoor_Outgoing_Temperature").
format("%.1f"))
postUpdateIfChanged(
"pGF_Utilityroom_Ventilation_Indoor_Temperature_Message", msg)
self.updateTimer = None
def execute(self, module, input):
operation = getItemState("pGF_Utilityroom_Washer_OperationState")
if operation != NULL and operation != UNDEF:
mode = Transformation.transform("MAP", "homeconnect_operation.map",
operation.toString())
msg = u"{}".format(mode)
runtime = getItemState(
"pGF_Utilityroom_Washer_RemainingProgramTimeState")
if runtime != NULL and runtime != UNDEF and runtime.intValue(
) > 0 and operation.toString() in ['Paused', 'Delayed', 'Run']:
runtime = Transformation.transform(
"JS", "homeconnect_runtime.js",
u"{}".format(runtime.intValue()))
msg = u"{}, {}".format(msg, runtime)
postUpdateIfChanged("pGF_Utilityroom_Washer_Message", msg)
def delayUpdate(self):
if getItemState(
"pGF_Utilityroom_Heating_Solar_Pump_State").intValue() == 1:
msg = "an"
else:
msg = "aus"
msg = msg + ", "
if getItemState("pGF_Utilityroom_Heating_Solar_Reheating_State"
).intValue() == 1:
msg = msg + "an"
else:
msg = msg + "aus"
postUpdateIfChanged("pGF_Utilityroom_Heating_Solar_State_Message", msg)
self.updateTimer = None
def execute(self, module, input):
power_state = getItemState("pGF_Kitchen_Coffeemaker_Power_State")
if power_state == ON:
mode = getItemState(
"pGF_Kitchen_Coffeemaker_Operation_State").toString()
msg = u"{}".format(mode)
if mode != "Inactive":
runtime = getItemState(
"pGF_Kitchen_Coffeemaker_Program_Progress_State")
if runtime != NULL and runtime != UNDEF and runtime.intValue(
) > 0:
msg = u"{}, {} %".format(msg, runtime)
else:
msg = u"Aus"
postUpdateIfChanged("pGF_Kitchen_Coffeemaker_Message", msg)
