async def on_start(self):
if self.timer is None:
self.timer = Timer(int(self.props.Timer) * 60,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
self.summary = "Waiting for Target Temp"
await self.push_update()
async def on_start(self):
self.lid_temp = 95 if self.get_config_value("TEMP_UNIT", "C") == "C" else 203
self.lid_flag = True if self.props.get("LidAlert", "No") == "Yes" else False
self.AutoMode = True if self.props.get("AutoMode", "No") == "Yes" else False
self.first_wort_hop_flag = False
self.first_wort_hop=self.props.get("First_Wort", "No")
self.hops_added=["","","","","",""]
self.remaining_seconds = None
self.kettle=self.get_kettle(self.props.get("Kettle", None))
if self.kettle is not None:
self.kettle.target_temp = int(self.props.get("Temp", 0))
if self.cbpi.kettle is not None and self.timer is None:
self.timer = Timer(int(self.props.get("Timer", 0)) *60 ,on_update=self.on_timer_update, on_done=self.on_timer_done)
elif self.cbpi.kettle is not None:
try:
if self.timer.is_running == True:
self.timer.start()
except:
pass
self.summary = "Waiting for Target Temp"
if self.AutoMode == True:
await self.setAutoMode(True)
await self.push_update()
async def on_start(self):
if self.timer is None:
self.timer = Timer(int(self.props.Timer) * 60,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
self.timer.start()
await self.actor_on(self.props.Actor)
async def on_start(self):
self.shutdown = False
self.AutoMode = True if self.props.get("AutoMode",
"No") == "Yes" else False
self.rate = float(self.props.get("RampRate", 1))
logging.info(self.rate)
self.target_temp = round(float(self.props.get("Temp", 0)) * 10) / 10
logging.info(self.target_temp)
self.fermenter.target_pressure = float(self.props.get("Pressure", 0))
while self.get_sensor_value(self.props.get("Sensor",
None)).get("value") > 900:
await asyncio.sleep(1)
self.starttemp = self.get_sensor_value(self.props.get(
"Sensor", None)).get("value")
self.current_target_temp = self.starttemp
if self.fermenter is not None:
await self.set_fermenter_target_temp(self.fermenter.id,
self.current_target_temp)
if self.AutoMode == True:
await self.setAutoMode(True)
self.summary = "Ramping to {}° with {}° per day".format(
self.target_temp, self.rate)
if self.fermenter is not None and self.timer is None:
self.timer = Timer(1,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
await self.push_update()
class ActorStep(CBPiStep):
async def on_timer_done(self,timer):
self.summary = ""
await self.next()
async def on_timer_update(self,timer, seconds):
self.summary = Timer.format_time(seconds)
await self.push_update()
async def on_start(self):
if self.timer is None:
self.timer = Timer(int(self.props.Timer) * 60,on_update=self.on_timer_update, on_done=self.on_timer_done)
self.timer.start()
await self.actor_on(self.props.Actor)
async def on_stop(self):
await self.actor_off(self.props.Actor)
await self.timer.stop()
self.summary = ""
await self.push_update()
async def reset(self):
self.timer = Timer(int(self.props.Timer) *60 ,on_update=self.on_timer_update, on_done=self.on_timer_done)
async def run(self):
while self.running == True:
await asyncio.sleep(1)
return StepResult.DONE
class ToggleStep(CBPiStep):
async def on_timer_done(self, timer):
self.summary = ""
await self.next()
async def on_timer_update(self, timer, seconds):
self.summary = Timer.format_time(seconds)
await self.push_update()
async def on_start(self):
if self.timer is None:
self.timer = Timer(1, on_update=self.on_timer_update, on_done=self.on_timer_done)
self.timer.start()
self.type=self.props.get("toggle_type","Off")
self.Actor=self.props.get("Actor", None)
if self.Actor is not None and self.type == "On":
await self.actor_on(self.Actor)
if self.Actor is not None and self.type == "Off":
await self.actor_off(self.Actor)
async def on_stop(self):
await self.timer.stop()
self.summary = ""
await self.push_update()
async def reset(self):
self.timer = Timer(1, on_update=self.on_timer_update, on_done=self.on_timer_done)
async def run(self):
while self.running == True:
await asyncio.sleep(1)
return StepResult.DONE
class MashInStep(CBPiStep):
async def NextStep(self, **kwargs):
await self.next()
async def on_timer_done(self,timer):
self.summary = ""
self.kettle.target_temp = 0
await self.push_update()
if self.AutoMode == True:
await self.setAutoMode(False)
self.cbpi.notify(self.name, self.props.get("Notification","Target Temp reached. Please add malt and klick next to move on."), action=[NotificationAction("Next Step", self.NextStep)])
async def on_timer_update(self,timer, seconds):
await self.push_update()
async def on_start(self):
self.AutoMode = True if self.props.get("AutoMode","No") == "Yes" else False
self.kettle=self.get_kettle(self.props.get("Kettle", None))
if self.kettle is not None:
self.kettle.target_temp = int(self.props.get("Temp", 0))
if self.AutoMode == True:
await self.setAutoMode(True)
self.summary = "Waiting for Target Temp"
if self.cbpi.kettle is not None and self.timer is None:
self.timer = Timer(1 ,on_update=self.on_timer_update, on_done=self.on_timer_done)
await self.push_update()
async def on_stop(self):
await self.timer.stop()
self.summary = ""
if self.AutoMode == True:
await self.setAutoMode(False)
await self.push_update()
async def run(self):
while self.running == True:
await asyncio.sleep(1)
sensor_value = self.get_sensor_value(self.props.get("Sensor", None)).get("value")
if sensor_value >= int(self.props.get("Temp",0)) and self.timer.is_running is not True:
self.timer.start()
self.timer.is_running = True
await self.push_update()
return StepResult.DONE
async def reset(self):
self.timer = Timer(1 ,on_update=self.on_timer_update, on_done=self.on_timer_done)
async def setAutoMode(self, auto_state):
try:
if (self.kettle.instance is None or self.kettle.instance.state == False) and (auto_state is True):
await self.cbpi.kettle.toggle(self.kettle.id)
elif (self.kettle.instance.state == True) and (auto_state is False):
await self.cbpi.kettle.stop(self.kettle.id)
await self.push_update()
except Exception as e:
logging.error("Failed to switch on KettleLogic {} {}".format(self.kettle.id, e))
async def on_start(self):
self.summary = ""
self.AutoNext = False if self.props.get("AutoNext",
"No") == "No" else True
if self.timer is None:
self.timer = Timer(1,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
await self.push_update()
async def on_start(self):
if self.timer is None:
self.timer = Timer(1, on_update=self.on_timer_update, on_done=self.on_timer_done)
self.timer.start()
self.type=self.props.get("toggle_type","Off")
self.Actor=self.props.get("Actor", None)
if self.Actor is not None and self.type == "On":
await self.actor_on(self.Actor)
if self.Actor is not None and self.type == "Off":
await self.actor_off(self.Actor)
async def reset(self):
timeD = int(self.props.get("TimerD", 0))
timeH = int(self.props.get("TimerH", 0))
timeM = int(self.props.get("TimerM", 0))
self.fermentationtime = (timeM + (60 * timeH) + (1440 * timeD)) * 60
self.timer = Timer(self.fermentationtime,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
self.endtime = 0
self.timer.is_running == False
async def on_start(self):
if self.timer is None:
self.timer = Timer(int(self.props.Timer) * 60,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
if self.cbpi.kettle is not None:
await self.cbpi.kettle.set_target_temp(self.props.Kettle,
int(self.props.Temp))
self.summary = "Waiting for Target Temp"
await self.push_update()
class Cooldown(CBPiStep):
def __init__(self, cbpi, id, name, props, on_done):
super().__init__(cbpi, id, name, props, on_done)
self._samp_count = 0
@action("Add 5 Minutes to Timer", [])
async def add_timer(self):
if self.timer._task != None:
self.cbpi.notify(self.name, '5 Minutes added', NotificationType.INFO)
await self.timer.add(300)
else:
self.cbpi.notify(self.name, 'Timer must be running to add time', NotificationType.WARNING)
async def on_timer_done(self, timer):
self.summary = ""
self.cbpi.notify('CoolDown', 'Step finished', NotificationType.INFO)
await self.next()
async def on_timer_update(self, timer, seconds):
self.summary = Timer.format_time(seconds)
await self.push_update()
async def on_start(self):
if self.timer is None:
self.timer = Timer(int(self.props.Timer) * 60, on_update=self.on_timer_update, on_done=self.on_timer_done)
self.timer.start()
async def on_stop(self):
await self.timer.stop()
self.summary = ""
if self.props.Actor is not None:
await self.actor_off(self.props.Actor)
if self.props.Secondary_Actor is not None:
await self.actor_off(self.props.Secondary_Actor)
await self.push_update()
async def reset(self):
self.timer = Timer(int(self.props.Timer) * 60, on_update=self.on_timer_update, on_done=self.on_timer_done)
self.cbpi.notify('CoolDown', "Timer was reset", NotificationType.INFO)
async def run(self):
if self.props.Actor is not None:
await self.actor_on(self.props.Actor)
if self.props.Secondary_Actor is not None:
await self.actor_on(self.props.Secondary_Actor)
self.cbpi.notify('CoolDown', "Step started", NotificationType.INFO)
while True:
await asyncio.sleep(1)
if self.get_sensor_value(self.props.Sensor).get("value") <= float(self.props.Temp):
self._samp_count += 1
if self._samp_count >= int(self.props.Samples):
self.cbpi.notify('CoolDown', "Desired temp was reached", NotificationType.INFO)
break
return StepResult.DONE
async def on_start(self):
self.port = str(self.cbpi.static_config.get('port',8000))
self.AutoMode = True if self.props.AutoMode == "Yes" else False
self.kettle=self.get_kettle(self.props.Kettle)
self.kettle.target_temp = int(self.props.Temp)
if self.AutoMode == True:
await self.setAutoMode(True)
self.summary = "Waiting for Target Temp"
if self.timer is None:
self.timer = Timer(1 ,on_update=self.on_timer_update, on_done=self.on_timer_done)
await self.push_update()
async def on_start(self):
self.AutoMode = True if self.props.get("AutoMode","No") == "Yes" else False
self.kettle=self.get_kettle(self.props.get("Kettle", None))
if self.kettle is not None:
self.kettle.target_temp = int(self.props.get("Temp", 0))
if self.AutoMode == True:
await self.setAutoMode(True)
self.summary = "Waiting for Target Temp"
if self.cbpi.kettle is not None and self.timer is None:
self.timer = Timer(1 ,on_update=self.on_timer_update, on_done=self.on_timer_done)
await self.push_update()
async def on_start(self):
if self.timer is None:
self.timer = Timer(int(self.props.Timer) * 60,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
if self.cbpi.kettle is not None:
await self.cbpi.kettle.set_target_temp(self.props.Kettle,
int(self.props.Temp))
self.summary = "Waiting for Target Temp"
await self.push_update()
self.first_wort_hop_flag = False
self.first_wort_hop = self.props.First_Wort
self.hops_added = ["", "", "", "", "", ""]
self.remaining_seconds = None
class FermenterNotificationStep(CBPiFermentationStep):
async def NextStep(self, **kwargs):
await self.next(self.fermenter.id)
return StepResult.DONE
async def on_timer_done(self, timer):
self.summary = self.props.get("Notification", "")
if self.AutoNext == True:
self.cbpi.notify(self.name, self.props.get("Notification", ""),
NotificationType.INFO)
if self.shutdown != True:
await self.next(self.fermenter.id)
return StepResult.DONE
else:
self.cbpi.notify(
self.name,
self.props.get("Notification", ""),
NotificationType.INFO,
action=[NotificationAction("Next Step", self.NextStep)])
await self.push_update()
async def on_timer_update(self, timer, seconds):
await self.push_update()
async def on_start(self):
self.shutdown = False
self.summary = ""
self.AutoNext = False if self.props.get("AutoNext",
"No") == "No" else True
if self.timer is None:
self.timer = Timer(1,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
await self.push_update()
async def on_stop(self):
await self.timer.stop()
self.summary = ""
await self.push_update()
async def run(self):
while self.running == True:
await asyncio.sleep(1)
if self.timer.is_running is not True:
self.timer.start()
self.timer.is_running = True
return StepResult.DONE
async def on_start(self):
self.shutdown = False
self.AutoMode = True if self.props.get("AutoMode",
"No") == "Yes" else False
if self.fermenter is not None:
self.fermenter.target_temp = float(self.props.get("Temp", 0))
self.fermenter.target_pressure = 0
if self.AutoMode == True:
await self.setAutoMode(True)
self.summary = "Waiting for Target Temp"
if self.fermenter is not None and self.timer is None:
self.timer = Timer(1,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
await self.push_update()
class MashStep(CBPiStep):
@action(key="Custom RESET", parameters=[])
async def custom_reset(self, **kwargs):
self.summary = ""
await self.push_update()
@action(key="Custom Action",
parameters=[Property.Number(label="Value", configurable=True)])
async def custom_action(self, Value, **kwargs):
self.summary = "VALUE FROM ACTION {}".format(Value)
await self.push_update()
self.cbpi.notify("ACTION 2 CALLED".format(Value))
async def on_timer_done(self, timer):
self.summary = ""
await self.next()
async def on_timer_update(self, timer, seconds):
self.summary = Timer.format_time(seconds)
await self.push_update()
async def on_start(self):
if self.timer is None:
self.timer = Timer(int(self.props.Timer) * 60,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
self.summary = "Waiting for Target Temp"
await self.push_update()
async def on_stop(self):
await self.timer.stop()
self.summary = ""
await self.push_update()
async def reset(self):
self.summary = ""
self.timer = Timer(int(self.props.Timer) * 60,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
async def run(self):
while True:
await asyncio.sleep(1)
sensor_value = self.get_sensor_value(self.props.Sensor)
if sensor_value.get("value") >= int(
self.props.Temp) and self.timer == None:
self.timer.start()
return StepResult.DONE
async def on_start(self):
self.shutdown = False
if self.endtime == 0:
timeD = int(self.props.get("TimerD", 0))
timeH = int(self.props.get("TimerH", 0))
timeM = int(self.props.get("TimerM", 0))
self.fermentationtime = (timeM + (60 * timeH) +
(1440 * timeD)) * 60
else:
self.fermentationtime = self.endtime - time.time()
self.AutoMode = True if self.props.get("AutoMode",
"No") == "Yes" else False
if self.fermenter is not None:
self.fermenter.target_temp = float(self.props.get("Temp", 0))
self.fermenter.target_pressure = float(
self.props.get("Pressure", 0))
if self.AutoMode == True:
await self.setAutoMode(True)
await self.push_update()
if self.fermenter is not None and self.timer is None:
logging.info("Set Timer")
self.timer = Timer(self.fermentationtime,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
self.timer.is_running = False
elif self.fermenter is not None:
try:
if self.timer.is_running == True:
self.timer.start()
self.endtime = time.time() + self.fermentationtime
await self.update_endtime()
except:
pass
if self.endtime != 0 and self.timer is not None and self.timer.is_running == False:
self.timer.start()
self.timer.is_running = True
estimated_completion_time = datetime.fromtimestamp(
time.time() + self.fermentationtime)
self.cbpi.notify(
self.name, 'Timer restarted. Estimated completion: {}'.format(
estimated_completion_time.strftime("%d.%m, %H:%M")),
NotificationType.INFO)
self.summary = "Waiting for Target Temp"
await self.push_update()
async def on_start(self):
warnings.simplefilter('ignore', np.RankWarning)
self.temp_array = []
self.time_array = []
self.kettle = self.get_kettle(self.props.get("Kettle", None))
self.actor = self.props.get("Actor", None)
self.target_temp = int(self.props.get("Temp",0))
self.Interval = 15 # Interval in minutes on how often cooldwon end time is calculated
self.cbpi.notify(self.name, 'Cool down to {}°'.format(self.target_temp), NotificationType.INFO)
if self.timer is None:
self.timer = Timer(1,on_update=self.on_timer_update, on_done=self.on_timer_done)
self.start_time=time.time()
self.temp_array.append(self.get_sensor_value(self.props.get("Sensor", None)).get("value"))
self.time_array.append(time.time())
self.next_check = self.start_time + self.Interval * 60
self.count = 0
self.initial_date = None
async def on_start(self):
self.AutoMode = True if self.props.get("AutoMode", "No") == "Yes" else False
self.kettle=self.get_kettle(self.props.Kettle)
if self.kettle is not None:
self.kettle.target_temp = int(self.props.get("Temp", 0))
if self.AutoMode == True:
await self.setAutoMode(True)
await self.push_update()
if self.cbpi.kettle is not None and self.timer is None:
self.timer = Timer(int(self.props.get("Timer",0)) *60 ,on_update=self.on_timer_update, on_done=self.on_timer_done)
elif self.cbpi.kettle is not None:
try:
if self.timer.is_running == True:
self.timer.start()
except:
pass
self.summary = "Waiting for Target Temp"
await self.push_update()
async def on_start(self):
self.lid_temp = 95 if self.get_config_value("TEMP_UNIT", "C") == "C" else 203
self.lid_flag = False
self.port = str(self.cbpi.static_config.get('port',8000))
self.AutoMode = True if self.props.AutoMode == "Yes" else False
self.first_wort_hop_flag = False
self.first_wort_hop=self.props.First_Wort
self.hops_added=["","","","","",""]
self.remaining_seconds = None
self.kettle=self.get_kettle(self.props.Kettle)
self.kettle.target_temp = int(self.props.Temp)
if self.timer is None:
self.timer = Timer(int(self.props.Timer) *60 ,on_update=self.on_timer_update, on_done=self.on_timer_done)
self.summary = "Waiting for Target Temp"
if self.AutoMode == True:
await self.setAutoMode(True)
await self.push_update()
class BoilStep(CBPiStep):
async def on_timer_done(self, timer):
self.summary = ""
await self.next()
async def on_timer_update(self, timer, seconds):
self.summary = Timer.format_time(seconds)
await self.push_update()
async def on_start(self):
if self.timer is None:
self.timer = Timer(int(self.props.Timer) * 60,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
self.summary = "Waiting for Target Temp"
await self.push_update()
async def on_stop(self):
await self.timer.stop()
self.summary = ""
await self.push_update()
async def reset(self):
self.timer = Timer(int(self.props.Timer) * 60,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
@action("Start Timer", [])
async def star_timer(self):
self.cbpi.notify("Timer started")
self.timer.start()
async def run(self):
while True:
await asyncio.sleep(1)
sensor_value = self.get_sensor_value(self.props.Sensor)
if sensor_value is not None and sensor_value.get("value") >= int(
self.props.Temp) and self.timer == None:
self.timer.start()
return StepResult.DONE
class WaitStep(CBPiStep):
@action(key="Custom Step Action", parameters=[])
async def hello(self, **kwargs):
print("ACTION")
self.cbpi.notify("ACTION 1 CALLED")
@action(key="Custom Step Action 2", parameters=[])
async def hello2(self, **kwargs):
print("ACTION2")
self.cbpi.notify("ACTION 2 CALLED")
async def on_timer_done(self, timer):
self.summary = ""
await self.next()
async def on_timer_update(self, timer, seconds):
self.summary = Timer.format_time(seconds)
await self.push_update()
async def on_start(self):
if self.timer is None:
self.timer = Timer(int(self.props.Timer) * 60,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
self.timer.start()
async def on_stop(self):
await self.timer.stop()
self.summary = ""
await self.push_update()
async def reset(self):
self.timer = Timer(int(self.props.Timer) * 60,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
async def run(self):
while True:
await asyncio.sleep(1)
return StepResult.DONE
class MashStep(CBPiStep):
async def on_timer_done(self, timer):
self.summary = ""
await self.next()
async def on_timer_update(self, timer, seconds):
self.summary = Timer.format_time(seconds)
await self.push_update()
async def on_start(self):
if self.timer is None:
self.timer = Timer(int(self.props.Timer) * 60,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
if self.cbpi.kettle is not None:
await self.cbpi.kettle.set_target_temp(self.props.Kettle,
int(self.props.Temp))
self.summary = "Waiting for Target Temp"
await self.push_update()
async def on_stop(self):
await self.timer.stop()
self.summary = ""
await self.push_update()
async def reset(self):
self.summary = ""
self.timer = Timer(int(self.props.Timer) * 60,
on_update=self.on_timer_update,
on_done=self.on_timer_done)
async def run(self):
while self.running == True:
await asyncio.sleep(1)
sensor_value = self.get_sensor_value(self.props.Sensor)
if sensor_value.get("value") >= int(
self.props.Temp) and self.timer.is_running is not True:
self.timer.start()
self.timer.is_running = True
return StepResult.DONE
class BM_SimpleStep(CBPiStep):
async def NextStep(self, **kwargs):
await self.next()
async def on_timer_done(self,timer):
self.summary = self.props.Notification
if self.AutoNext == True:
self.cbpi.notify(self.name, self.props.Notification, NotificationType.INFO)
await self.next()
else:
self.cbpi.notify(self.name, self.props.Notification, NotificationType.INFO, action=[NotificationAction("Next Step", self.NextStep)])
await self.push_update()
async def on_timer_update(self,timer, seconds):
await self.push_update()
async def on_start(self):
self.summary=""
self.AutoNext = False if self.props.AutoNext == "No" else True
if self.timer is None:
self.timer = Timer(1 ,on_update=self.on_timer_update, on_done=self.on_timer_done)
await self.push_update()
async def on_stop(self):
await self.timer.stop()
self.summary = ""
await self.push_update()
async def run(self):
while self.running == True:
await asyncio.sleep(1)
if self.timer.is_running is not True:
self.timer.start()
self.timer.is_running = True
return StepResult.DONE
async def on_start(self):
warnings.simplefilter('ignore', np.RankWarning)
self.temp_array = []
self.time_array = []
self.kettle = self.get_kettle(self.props.Kettle)
self.actor= None
if self.props.Actor or self.props.Actor is not None or self.props.Actor !="":
self.actor = self.props.Actor
self.target_temp = int(self.props.Temp)
try:
self.Interval = int(self.props.Interval) # Interval on how often cooldwon end time is calculated
except:
self.Interval = 10
self.cbpi.notify(self.name, 'Cool down to {}°'.format(self.target_temp), NotificationType.INFO)
if self.timer is None:
self.timer = Timer(1,on_update=self.on_timer_update, on_done=self.on_timer_done)
self.start_time=time.time()
self.temp_array.append(self.get_sensor_value(self.props.Sensor).get("value"))
self.time_array.append(time.time())
self.next_check = self.start_time + self.Interval * 60
self.count = 0
class BM_MashInStep(CBPiStep):
async def NextStep(self, **kwargs):
await self.next()
async def on_timer_done(self,timer):
self.summary = "MashIn Temp reached. Please add Malt Pipe."
await self.push_update()
if self.AutoMode == True:
await self.setAutoMode(False)
self.cbpi.notify(self.name, 'MashIn Temp reached. Please add malt pipe and malt. Move to next step', action=[NotificationAction("Next Step", self.NextStep)])
async def on_timer_update(self,timer, seconds):
await self.push_update()
async def on_start(self):
self.port = str(self.cbpi.static_config.get('port',8000))
self.AutoMode = True if self.props.AutoMode == "Yes" else False
self.kettle=self.get_kettle(self.props.Kettle)
self.kettle.target_temp = int(self.props.Temp)
if self.AutoMode == True:
await self.setAutoMode(True)
self.summary = "Waiting for Target Temp"
if self.timer is None:
self.timer = Timer(1 ,on_update=self.on_timer_update, on_done=self.on_timer_done)
await self.push_update()
async def on_stop(self):
await self.timer.stop()
self.summary = ""
if self.AutoMode == True:
await self.setAutoMode(False)
await self.push_update()
async def run(self):
while self.running == True:
await asyncio.sleep(1)
sensor_value = self.get_sensor_value(self.props.Sensor).get("value")
if sensor_value >= int(self.props.Temp) and self.timer.is_running is not True:
self.timer.start()
self.timer.is_running = True
await self.push_update()
return StepResult.DONE
async def reset(self):
self.timer = Timer(1 ,on_update=self.on_timer_update, on_done=self.on_timer_done)
async def setAutoMode(self, auto_state):
try:
if (self.kettle.instance is None or self.kettle.instance.state == False) and (auto_state is True):
url="http://127.0.0.1:" + self.port + "/kettle/"+ self.kettle.id+"/toggle"
async with aiohttp.ClientSession() as session:
async with session.post(url) as response:
return await response.text()
await self.push_update()
elif (self.kettle.instance.state == True) and (auto_state is False):
await self.kettle.instance.stop()
await self.push_update()
except Exception as e:
logging.error("Failed to switch on KettleLogic {} {}".format(self.kettle.id, e))
async def reset(self):
self.timer = Timer(int(self.props.Timer) *60 ,on_update=self.on_timer_update, on_done=self.on_timer_done)
async def on_timer_update(self,timer, seconds):
self.summary = Timer.format_time(seconds)
self.remaining_seconds = seconds
await self.push_update()
