def generated_triggers(function):
global logTitle
for k in keyThingsDict.keys():
logPrefix = u"generated_triggers(): adding @when(\"Thing {} changed\") trigger for {}".format(k, unicode(keyThingsDict.get(k).get("thing_name")))
LogAction.logInfo(logTitle, logPrefix)
when("Thing {} changed".format(k))(function)
return function
def Scene_Goodnight(event):
# Scene_Goodnight.log.info("::Boiler_Control rule -> A Heater recieved a command - updating boiler state::")
LogAction.logError("Scene_Goodnight", "goodnight going to bed")
global tgoodnight
global CT_HPSP_Night
events.sendCommand("CT_FairyLights433Socket", "OFF")
events.sendCommand("ZbColourBulb01Switch", "OFF")
events.sendCommand("ZbColourBulb02Switch", "OFF")
events.sendCommand("radio", "OFF")
events.sendCommand("vCT_TVKodiSpeakers", "OFF")
events.postUpdate("CT_Heating_PresetTempNormal",
items["CT_HPSP_Night"].toString())
events.postUpdate("FR_Heating_PresetTempNormal",
items["FR_HPSP_Night"].toString())
events.postUpdate("ER_Heating_PresetTempNormal",
items["ER_HPSP_Night"].toString())
events.postUpdate("AT_Heating_PresetTempNormal",
items["AT_HPSP_Night"].toString())
events.postUpdate("BR_Heating_PresetTempNormal",
items["BR_HPSP_Night"].toString())
events.postUpdate("OF_Heating_PresetTempNormal",
items["OF_HPSP_Night"].toString())
events.postUpdate("HL_Heating_PresetTempNormal",
items["HL_HPSP_Night"].toString())
events.sendCommand("Heating_UpdateHeaters", "ON")
events.postUpdate("Scene_Goodnight", "OFF")
events.sendCommand("workLightsPowerSocket", "OFF")
events.sendCommand("workLightsPowerSocket", "OFF")
# events.sendCommand("Heating_UpdateHeaters", "ON") #trigger updating of heaters and boiler etc
tgoodnight = ScriptExecution.createTimer(
DateTime.now().plusSeconds(300),
lambda: events.sendCommand("ZbWhiteBulb01Switch", "OFF"))
def DimNow(Item):
try:
global iteration
interval = dimmertimers[Item]['FadeStepMS']
if iteration >= (int(dimmertimers[Item]['loops'])):
events.sendCommand(Item, str(dimmertimers[Item]['TargetValue']))
dimmertimers[Item]['timer'].cancel()
iteration = 0
dimmertimers[Item]['timer'] = None
del dimmertimers[Item]
return
else:
NewPercent = round(
float(str(items[Item])) -
float(dimmertimers[Item]['PercentPerStep']), 2)
events.sendCommand(Item, str(NewPercent))
dimmertimers[Item]['timer'].reschedule(
DateTime.now().plusMillis(interval))
iteration += 1
dimmertimers[Item]['iteration'] = iteration
except:
LogAction.logInfo("DimNow Routine", u"CleanUp")
dimmertimers[Item]['timer'].cancel()
dimmertimers[Item]['timer'] = None
del dimmertimers[Item]
def scene_Goodnight_init(event):
LogAction.logInfo("StartUp - set up Item Scene_Goodnight",
"StartUp - set up Item Scene_Goodnight")
# events.postUpdate("BridgeLightSensorState", "OFF")
global tsceneStartup
if tsceneStartup is None:
tsceneStartup = ScriptExecution.createTimer(
DateTime.now().plusSeconds(45),
lambda: events.postUpdate("Scene_Goodnight", "OFF"))
def zbAvail(event):
LogAction.logInfo("gTHSensorTemperatures", "== gTHSensorTemperatures Item {} received update: {}", event.itemName, event.itemState)
newname = event.itemName[:event.itemName.rfind('_')+1] + "reachable"
events.postUpdate(newname, "Online") # use reachable not triggering event cos its temp
zbAvail.log.info("== ZB temp sensor availability marked ONLINE::")
if event.itemName not in timers or timers[event.itemName].hasTerminated():
timers[event.itemName] = ScriptExecution.createTimer(DateTime.now().plusMinutes(timeoutMinutes), lambda: events.postUpdate(newname, "Offline"))
else:
timers[event.itemName].reschedule(DateTime.now().plusMinutes(timeoutMinutes))
def heating_cron9(event):
for item in ir.getItem("gHeating_PresetTempNormal").members:
item.state = ir.getItem(
item.name[:item.name.find('_')] +
"_HPSP_Evening").state # prefix = # get prefix eg FR, CT etc
LogAction.logWarn("CRON set setpoints",
"===> _HPSP_Evening setpoint Item : {}, is now: {}",
item.name, item.state)
events.sendCommand("Heating_UpdateHeaters",
"ON") #trigger updating of heaters and boiler etc
def zbRouterAvail(event):
zbRouterAvail.log.debug("== zbRouterAvail::")
LogAction.logDebug("zbRouterAvail", "==xxxccc Item {} received update: {}",
event.itemName, event.itemState)
events.postUpdate("ZbRouter_01_Reachable", "Online")
#log.debug("Battery charging monitor: {}: start".format(event.itemState))
global zbRouterTimer
if zbRouterTimer is not None and not zbRouterTimer.hasTerminated():
zbRouterTimer.cancel()
zbRouterTimer = ScriptExecution.createTimer(
DateTime.now().plusSeconds(routerTimeout),
lambda: events.postUpdate("ZbRouter_01_Reachable", "Offline"))
zbRouterAvail.log.debug("==== zbRouterAvail timer started!!!!!!!!!!!::")
def conservatory_tv_off(event):
conservatory_tv_off.log.info("conservatory_tv_off")
global t_CTtvPowerOff
Voice.say("Turning off Conservatory TV", "voicerss:enGB", "chromecast:chromecast:GHM_Conservatory", PercentType(50))
# events.postUpdate("shutdownKodiConservatoryProxy", "OFF") - this routine can be removed if this works
LogAction.logError("Shutdown Conservatory Kodi","Shutdown Conservatory Kodi: {}", event.itemName)
events.sendCommand("kodiConservatory_systemcommand","Shutdown")
events.sendCommand("amplifierStandby", "OFF")
if t_CTtvPowerOff is None:
t_CTtvPowerOff = ScriptExecution.createTimer(DateTime.now().plusSeconds(30), lambda: tvoffbody())
def kodi_startup(event):
LogAction.logError("System started - INIT all KODI PROXY ITEMS",
"System started - INIT all KODI PROXY ITEMS")
if ir.getItem("shutdownKodiFrontRoomProxy").state == NULL:
events.postUpdate(ir.getItem("shutdownKodiFrontRoomProxy"), "OFF")
LogAction.logError(
"INIT KODI PROXY",
"System started rule - change front room KodiPi proxy from NULL to OFF"
)
# if ir.getItem("shutdownKodiConservatoryProxy").state == NULL:
# events.postUpdate(ir.getItem("shutdownKodiConservatoryProxy"), "OFF")
# LogAction.logError("INIT KODI PROXY", "System started rule - change Conservatory KodiPi proxy from NULL to OFF")
if ir.getItem("shutdownKodiBedroomProxy").state == NULL:
events.postUpdate(ir.getItem("shutdownKodiBedroomProxy"), "OFF")
LogAction.logError(
"INIT KODI PROXY",
"System started rule - change Bed room KodiPi proxy from NULL to OFF"
)
if ir.getItem("shutdownKodiAtticProxy").state == NULL:
events.postUpdate(ir.getItem("shutdownKodiAtticProxy"), "OFF")
LogAction.logError(
"INIT KODI PROXY",
"System started rule - change attic KodiPi proxy from NULL to OFF"
) # end
def dimmer(event):
global iteration
interval = 250
Loops = 0
Befehl = str(event.getItemCommand()).split(",")
try: #Fehlerbehebung bei fehlenden FadeStep
FadeStepMS = int(Befehl[4])
except (IndexError, ValueError):
FadeStepMS = interval
TargetValue = int(Befehl[1])
FadePeriodMs = int(Befehl[2])
Item = Befehl[3]
try:
StartValue = items[Item]
except (KeyError):
return
if items[Item] == NULL:
LogAction.logInfo("Timer Test", u"Abbruch")
return
LogAction.logInfo("Timer Test", u"Item = " + Item)
if Item in dimmertimers:
LogAction.logInfo("Timer Test", u"Item existiert")
dimmertimers[Item]['timer'].cancel()
dimmertimers[Item]['timer'] = None
del dimmertimers[Item]
PercentPerStep = ((float(str(StartValue))) -
float(str(TargetValue))) / (FadePeriodMs / FadeStepMS)
if PercentPerStep == 0:
LogAction.logInfo("Dimmer Routine", u"Nichts zu tun!")
return
Loops = FadePeriodMs / FadeStepMS
dimmertimers[Item] = {
'item':
Item,
'timer':
ScriptExecution.createTimer(DateTime.now().plusMillis(interval),
lambda: DimNow(Item)),
'loops':
Loops,
'TargetValue':
TargetValue,
'FadePeriod':
FadePeriodMs,
'PercentPerStep':
PercentPerStep,
'FadeStepMS':
FadeStepMS
}
dimmertimers[Item]['timer'].reschedule(DateTime.now().plusMillis(interval))
def bgAvail(event):
LogAction.logDebug(
"gBG_socket_maxworktime_updates",
"!!!! gBG_socket_maxworktime_updates Item {} received update: {}",
event.itemName, event.itemState)
# create the 'reachable' item name e.g bg_wifisocket_4_maxworktime to bg_wifisocket_4_reachable
newname = event.itemName[:event.itemName.rfind('_') + 1] + "reachable"
events.postUpdate(
newname, "Online") # use reachable not triggering event cos its temp
bgAvail.log.debug("== BG sockets Online/Offline status marked ONLINE::")
if event.itemName not in timers or timers[event.itemName].hasTerminated():
timers[event.itemName] = ScriptExecution.createTimer(
DateTime.now().plusSeconds(timeoutSeconds),
lambda: events.postUpdate(newname, "Offline"))
else:
timers[event.itemName].reschedule(
DateTime.now().plusSeconds(timeoutSeconds))
def cb():
global logTitle
current_state = str(things.get(ThingUID(binding_thing_name)).status)
if current_state == "ONLINE":
LogAction.logInfo(logTitle, u"No need to restart {} (status={})".format(binding_name, current_state))
if notify_restart is True:
NotificationAction.sendBroadcastNotification(u"Auto restart canceled for {} (status={})".format(binding_name, current_state))
else:
LogAction.logInfo(logTitle, u"Will now restart {} (status={})".format(binding_name, current_state))
# Keep track of binding restarts
restart_counter = binding_restarts.get(binding_id)
if restart_counter is None:
binding_restarts[binding_id] = 1
else:
binding_restarts[binding_id] = int(restart_counter) + 1
if notify_restart is True:
NotificationAction.sendBroadcastNotification(u"Auto restart of {} (status={})".format(binding_name, current_state))
# Restart the binding (use the 'openhab-karaf' entry in ssh config file)
Exec.executeCommandLine("/bin/sh@@-c@@ssh openhab-karaf bundle:restart {}".format(binding_id))
timers[binding_id] = None
def monitor_master_heating_mode(event):
LogAction.logError("monitoR", "handle MasterHeatingMode updated {}",
ir.getItem("masterHeatingMode").state.toString())
global offTemp
if ir.getItem("masterHeatingMode").state.toString() == "auto":
LogAction.logError(
"monitor_heating_mode",
"HMH .. make all rooms - AUTO - MASTER Heating Mode : {}",
ir.getItem("masterHeatingMode").state.toString())
for item in ir.getItem("gHeatingModes").members:
events.postUpdate(item, "auto")
elif ir.getItem("masterHeatingMode").state.toString() == "off":
LogAction.logError(
"monitor_heating_mode",
"HMH .. processing case OFF MASTER Heating Mode: : {}",
ir.getItem("masterHeatingMode").state.toString())
for item in ir.getItem("gHeatingModes").members:
events.postUpdate(item, "off")
# for item in ir.getItem("gTemperatureSetpoints").members:
# events.postUpdate(item, offTemp)
elif ir.getItem("masterHeatingMode").state.toString() == "manual":
LogAction.logError(
"monitor_heating_mode",
"HMH .. processing case MANUAL MASTER Heating Mode: : {}",
ir.getItem("masterHeatingMode").state.toString())
for item in ir.getItem("gHeatingModes").members:
events.postUpdate(item, "manual")
else:
LogAction.logError("monitor_heating_mode",
"HMH .. Heating Mode unknown: {}",
ir.getItem("masterHeatingMode").state.toString())
events.sendCommand("Heating_UpdateHeaters",
"ON") #trigger updating of heaters and boiler etc
def addWatchdogItems():
"""
Create the Watchdog Items and Group if they don't exist yet.
"""
global logTitle
# Add Watchdog Group if it doesn't exist
if ir.getItems(WATCHDOG_GROUP) == []:
LogAction.logInfo(logTitle, u"Create Group [{}]".format(WATCHDOG_GROUP))
add_item(WATCHDOG_GROUP, item_type="Group", label="Watchdog Items Group", tags=["Watchdog"])
try:
for entry in keyThingsDict.values():
wdItemName = entry.get("status_item")
if ir.getItems(wdItemName) == []:
add_item(wdItemName, item_type="String", groups=[WATCHDOG_GROUP], label=entry.get("thing_name"), tags=["Watchdog"])
LogAction.logInfo(logTitle, u"Created item [{}] in Group [{}]".format(wdItemName, WATCHDOG_GROUP))
except:
import traceback
LogAction.logError(logTitle, u"{}".format(traceback.format_exc()))
def Rule_KeyThingStatusUpdate(event):
global logTitle
global keyThingsDict
logPrefix = "Rule_KeyThingStatusUpdate(): "
LogAction.logDebug(logTitle, logPrefix + "event = " + pp.pformat(event))
keyThings = []
if event:
keyThings.append(str(event.thingUID))
else:
for k in keyThingsDict.keys():
keyThings.append(k)
for k in keyThings:
keyItemInfo = keyThingsDict[k]
keyStatusItem = keyItemInfo.get("status_item")
keyStatusItemThingName = keyItemInfo.get("thing_name")
bindingRestartInfo = keyItemInfo.get("restart_info")
nodeName = k.split(":")[-1]
# thing state is not available in event if rule triggered by cron:
if event:
nodeState = str(event.statusInfo)
LogAction.logInfo(logTitle, logPrefix+"Thing {} ({}, status item {}) status changed to {}".format(nodeName, keyStatusItemThingName, keyStatusItem, nodeState))
else:
nodeState = things.get(ThingUID(k)).status
events.postUpdate(keyStatusItem, str(nodeState))
# Restart some bindings if needed
if bindingRestartInfo:
LogAction.logDebug(logTitle, logPrefix+u"Restart {} (URI {}) if offline; current status is {}".format(keyStatusItemThingName, bindingRestartInfo.get("binding_uri"), nodeState))
# Note: schedule_binding_restart() takes care of managing the Thing status
schedule_binding_restart(
bindingRestartInfo.get("binding_uri"),
keyStatusItemThingName,
k,
bindingRestartInfo.get("wait_time"),
reschedule_timer_on_update=bindingRestartInfo.get("reschedule_timer_on_update", False),
notify_restart=bindingRestartInfo.get("notify_restart", False)
)
def checkIfHeatersNeedUpdating(event):
checkIfHeatersNeedUpdating.log.debug(
"HHH HeatingMode, Setpoint or Temperature updated")
# get prefix eg FR, CT etc
prefix = event.itemName[:event.itemName.rfind('_')]
LogAction.logDebug(
"Check if Heaters need changing",
"HHH Check if Heaters need changing etc due to Item: {}, received update: {}",
event.itemName, event.itemState)
HeatingMode = ir.getItem(prefix + "_HeatingMode")
LogAction.logDebug("Check if Heaters need changing",
"HHH HeatingMode {} : {}", prefix, HeatingMode.state)
TSetpoint = ir.getItem(prefix + "_TemperatureSetpoint")
LogAction.logDebug("Check if Heaters need changing",
"HHH Setpoint {} : {}", prefix, TSetpoint.state)
Temperature = ir.getItem(prefix + "_Temperature")
LogAction.logDebug("Check if Heaters need changing",
"HHH Temperature {} : {}", prefix, Temperature.state)
Heater = ir.getItem(prefix + "_Heater")
LogAction.logDebug("Check if Heaters need changing",
"HHH Heater {} : {}", prefix, Heater.state)
Reachable = ir.getItem(prefix + "_RTVReachable")
LogAction.logDebug("Check if Heaters need changing",
"HHH Reachable {} : {}", prefix, Reachable.state)
#!handle an offline TRV
if Reachable.state.toString() != "Online": # is the trv actually online??
LogAction.logError(
"Check if Heaters need changing",
"HHH ZZZZ---ZZZZ Reachable-Offline - sending OFF, leaving!!!!! prefix: {} ",
prefix)
#turn this one off
events.sendCommand(Heater, "OFF")
return #dont continue on and update the bolier control if this RTV is Offline
LogAction.logDebug(
"Check if Heaters need changing",
"HHH current HeatingMode.state: {} masterHeatingMode.state: {}",
HeatingMode.state,
ir.getItem("masterHeatingMode").state)
if (HeatingMode.state.toString()
== "off") or (ir.getItem("masterHeatingMode").state.toString()
== "off"):
if (ir.getItem("masterHeatingMode").state.toString() == "off"):
LogAction.logDebug("Check if Heaters need changing",
"HHH Master Heating Mode is OFF")
LogAction.logDebug(
"Check if Heaters need changing",
"HHH Turn heater OFF for {} cos its Heating Mode is {}", prefix,
HeatingMode.state)
events.sendCommand(Heater, "OFF")
elif (HeatingMode.state.toString()
== "auto") or (HeatingMode.state.toString() == "manual"):
LogAction.logDebug("Check if Heaters need changing",
"HHH mode is auto or manual")
LogAction.logDebug("Check if Heaters need changing",
"HHH Heater.itemName: {}", Heater)
setpoint = TSetpoint.state
turnOnTemp = setpoint # - 0.2// calculate the turn on/off temperatures
turnOffTemp = setpoint # + 0.1
temp = Temperature.state # get the current temperature
if temp >= turnOffTemp: # { // determine whether we need to turn on/off the heater
LogAction.logDebug("Check if Heaters need changing",
"HHH SendCommand to {}, Heater OFF", prefix)
events.sendCommand(Heater, "OFF")
elif temp < turnOnTemp:
LogAction.logDebug("Check if Heaters need changing",
"HHH SendCommand to {}, Heater ON", prefix)
events.sendCommand(Heater, "ON")
def pReloadCRON(event):
LogAction.logWarn("force a reload of this file when triggered",
"force vit")
import personal.heating_cron_normal_setpoints
reload(personal.heating_cron_normal_setpoints)
import personal.heating_cron_normal_setpoints
def kodi_pause_FR(event):
LogAction.logError("Pause FrontRoom Kodi", "Pause FrontRoom Kodi: {}",
event.itemName)
events.sendCommand("kodiFrontRoom_control", "PAUSE")
def heating_cron_morning_2(event):
temp = ir.getItem("Outside_Temperature").getState().floatValue()
LogAction.logWarn("PRE check if cold enough to start heating",
"PRE outside temp = {}", temp)
if (temp < 7.0):
morning_heating()
def kodi_shutdown_BR(event):
LogAction.logError("Shutdown bedroom Kodi", "Shutdown bedroom Kodi: {}",
event.itemName)
events.sendCommand("kodiBedroom_systemcommand", "Shutdown")
def kodi_shutdown_AT(event):
LogAction.logError("Shutdown Attic Kodi", "Shutdown Attic Kodi: {}",
event.itemName)
events.sendCommand("kodiAttic_systemcommand", "Shutdown")
def schedule_binding_restart(
binding_id,
binding_name,
binding_thing_name,
delay_seconds,
reschedule_timer_on_update=False,
notify_restart=False
):
"""
Schedule a binding restart if needed (if Thing status is not 'ONLINE')
Arguments:
binding_id {String} - The binding identifier (e.g. 'org.openhab.binding.xyzzy')
binding_name {String} - The name of the binding, e.g. 'XYZZY'
binding_thing_name {String} - The Thing name linked to the binding (e.g. binding:id:x:y:z)
delay_seconds {Integer} - # seconds to wait before restarting the binding
Keyword Arguments:
reschedule_timer_on_update {bool} - Reschedule restart if update received
notify_restart {bool} - Notify if the binding is scheduled for restarting
"""
global timers
global binding_restarts
if delay_seconds < 0:
delay_seconds = 0
# First, check if Thing is already back online
current_state = str(things.get(ThingUID(binding_thing_name)).status)
if current_state == "ONLINE":
if timers.get(binding_id):
timers[binding_id].cancel()
timers[binding_id] = None
LogAction.logInfo(logTitle, u"No need to restart {} ({} back online)".format(binding_name, binding_thing_name))
return
if timers.get(binding_id) is None:
if notify_restart is True:
NotificationAction.sendBroadcastNotification(u"Restart scheduled for {} in {}s (status={})".format(binding_name, delay_seconds, current_state))
# Define the call-back that will be executed when the timer expires.
def cb():
global logTitle
current_state = str(things.get(ThingUID(binding_thing_name)).status)
if current_state == "ONLINE":
LogAction.logInfo(logTitle, u"No need to restart {} (status={})".format(binding_name, current_state))
if notify_restart is True:
NotificationAction.sendBroadcastNotification(u"Auto restart canceled for {} (status={})".format(binding_name, current_state))
else:
LogAction.logInfo(logTitle, u"Will now restart {} (status={})".format(binding_name, current_state))
# Keep track of binding restarts
restart_counter = binding_restarts.get(binding_id)
if restart_counter is None:
binding_restarts[binding_id] = 1
else:
binding_restarts[binding_id] = int(restart_counter) + 1
if notify_restart is True:
NotificationAction.sendBroadcastNotification(u"Auto restart of {} (status={})".format(binding_name, current_state))
# Restart the binding (use the 'openhab-karaf' entry in ssh config file)
Exec.executeCommandLine("/bin/sh@@-c@@ssh openhab-karaf bundle:restart {}".format(binding_id))
timers[binding_id] = None
timers[binding_id] = ScriptExecution.createTimer(DateTime.now().plusSeconds(delay_seconds), cb)
else:
if reschedule_timer_on_update is True:
LogAction.logInfo(logTitle, u"Reschedule '{}' binding restart (status='{}').".format(binding_name, current_state))
timers.get(binding_id).reschedule(DateTime.now().plusSeconds(delay_seconds))
def removeWatchdogItems():
for item in ir.getItemsByTag("Watchdog"):
LogAction.logInfo(logTitle, u"Remove Watchdog Item [{}]".format(item.name))
remove_item(item)
remove_item(WATCHDOG_GROUP)
def scriptLoaded(*args):
log.info(RULE_NAME + " loaded.")
LogAction.logInfo("Timer Test", u" " + RULE_NAME + " geladen")
def send_heating_presets(event):
LogAction.logError(
"monitor_heating_mode",
"React on message to send target temperatures to zone setpoints: {}",
event.itemName)
global offTemp
events.postUpdate(
"Heating_UpdateHeaters",
"OFF") #! reset update heaters flag ready for next trigger (OFF-ON)
LogAction.logError("monitor_heating_mode", "MASTER Heating Mode: {}",
ir.getItem("masterHeatingMode").state)
# ! Whats the current MASTER heating mode?
if ir.getItem("masterHeatingMode").state.toString(
) == "auto": # normal mode is under master control and folows 'normal' rules
LogAction.logError(
"monitor_heating_mode",
"PPPPPPPPPPPP processing case AUTO MASTER Heating Mode: : {}",
ir.getItem("masterHeatingMode").state.toString())
# prefix eg FR_, CT_ etc
for heatingModeItem in ir.getItem("gHeatingModes").members:
if ir.getItem(heatingModeItem.name).state.toString() == "auto":
heaterPrefix = heatingModeItem.name[0:heatingModeItem.name.
rfind('_') + 1]
ir.getItem(heaterPrefix +
"TemperatureSetpoint").state = ir.getItem(
heaterPrefix + "Heating_PresetTempNormal").state
# LogAction.logError("monitor_heating_mode", "TemperatureSetpoint prefix:{}", heaterPrefix)
elif ir.getItem("masterHeatingMode").state.toString() == "off":
LogAction.logError(
"monitor_heating_mode",
"PPPPPPPPPP processing case OFF MASTER Heating Mode: :{}",
ir.getItem("masterHeatingMode").state.toString())
for item in ir.getItem("gHeatingModes").members:
events.postUpdate(item, "off")
for item in ir.getItem("gTemperatureSetpoints").members:
events.postUpdate(item, offTemp)
elif ir.getItem("masterHeatingMode").state == "manual":
LogAction.logError(
"monitor_heating_mode",
"PPPPPPPPP processing case MANUAL MASTER Heating Mode: :{}",
ir.getItem("masterHeatingMode").state.toString())
else:
LogAction.logError("monitor_heating_mode", "Heating Mode unknown:{}",
ir.getItem("masterHeatingMode").state.toString())
def pir02_off_body():
# pir_light_off.log.error("pir02_occupancy_off body : KT_light_2_Power: OFF ")
LogAction.logDebug("pir02_occupancy_off",
"pir02_occupancy_off body : KT_light_2_Power: OFF ")
events.sendCommand("KT_light_2_Power", "OFF")
events.sendCommand("KT_light_3_Power", "OFF")
def outside_startup(event):
LogAction.logError("outside sensor startup", "outside sensor startup")
if items["outsideReboots"] == NULL:
# items["ousideReboots"] = DecimalType(0)
events.postUpdate(ir.getItem("outsideReboots"), 0)