From 175f053f9d04b6b019606cff6d841745f2932dd4 Mon Sep 17 00:00:00 2001 From: avollkopf <43980694+avollkopf@users.noreply.github.com> Date: Tue, 20 Apr 2021 21:20:03 +0200 Subject: [PATCH] Added Steps and Step Functions --- cbpi/extension/mashstep/__init__.py | 319 +++++++++++++++++++++++++--- 1 file changed, 285 insertions(+), 34 deletions(-) diff --git a/cbpi/extension/mashstep/__init__.py b/cbpi/extension/mashstep/__init__.py index cd06e92..c1d715b 100644 --- a/cbpi/extension/mashstep/__init__.py +++ b/cbpi/extension/mashstep/__init__.py @@ -7,12 +7,127 @@ from datetime import datetime import time from voluptuous.schema_builder import message from cbpi.api.dataclasses import NotificationAction, NotificationType +from cbpi.api.dataclasses import Kettle, Props +from cbpi.api import * +import logging +from socket import timeout +from typing import KeysView +from cbpi.api.config import ConfigType +from cbpi.api.base import CBPiBase +import numpy as np +import warnings -@parameters([Property.Number(label="Timer", description="Time in Minutes", configurable=True), +@parameters([Property.Text(label="Notification",configurable = True, description = "Text for notification"), + Property.Select(label="AutoNext",options=["Yes","No"], description="Automatically move to next step (Yes) or pause after Notification (No)")]) +class NotificationStep(CBPiStep): + + async def NextStep(self, **kwargs): + await self.next() + + 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) + await self.next() + 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.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 + +@parameters([Property.Number(label="Temp", configurable=True), + Property.Sensor(label="Sensor"), + Property.Kettle(label="Kettle"), + Property.Text(label="Notification",configurable = True, description = "Text for notification hen Temp is reached"), + Property.Select(label="AutoMode",options=["Yes","No"], description="Switch Kettlelogic automatically on and off -> Yes")]) +class 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, self.props.get("Notification","Target Temp reached. Please 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.kettle.instance.stop() + await self.push_update() + + except Exception as e: + logging.error("Failed to switch on KettleLogic {} {}".format(self.kettle.id, e)) + + +@parameters([Property.Number(label="Timer", description="Time in Minutes", configurable=True), Property.Number(label="Temp", configurable=True), Property.Sensor(label="Sensor"), - Property.Kettle(label="Kettle")]) + Property.Kettle(label="Kettle"), + Property.Select(label="AutoMode",options=["Yes","No"], description="Switch Kettlelogic automatically on and off -> Yes")]) class MashStep(CBPiStep): @action("Start Timer", []) @@ -32,40 +147,65 @@ class MashStep(CBPiStep): else: self.cbpi.notify(self.name, 'Timer must be running to add time', NotificationType.WARNING) - async def on_timer_done(self, timer): + + async def on_timer_done(self,timer): self.summary = "" + if self.AutoMode == True: + await self.setAutoMode(False) + self.cbpi.notify(self.name, 'Step finished', NotificationType.SUCCESS) + await self.next() - async def on_timer_update(self, timer, seconds): + 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.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) self.summary = "Waiting for Target Temp" 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 reset(self): - self.summary = "" - self.timer = Timer(int(self.props.Timer) * 60, on_update=self.on_timer_update, on_done=self.on_timer_done) + self.timer = Timer(int(self.props.get("Timer",0)) *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: + 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 + estimated_completion_time = datetime.fromtimestamp(time.time()+ (int(self.props.get("Timer",0)))*60) + self.cbpi.notify(self.name, 'Timer started. Estimated completion: {}'.format(estimated_completion_time.strftime("%H:%M")), NotificationType.INFO) return StepResult.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.kettle.instance.stop() + await self.push_update() + + except Exception as e: + logging.error("Failed to switch on KettleLogic {} {}".format(self.kettle.id, e)) + @parameters([Property.Number(label="Timer", description="Time in Minutes", configurable=True)]) class WaitStep(CBPiStep): @@ -141,6 +281,8 @@ class ActorStep(CBPiStep): Property.Number(label="Temp", description="Boil temperature", configurable=True), Property.Sensor(label="Sensor"), Property.Kettle(label="Kettle"), + Property.Select(label="LidAlert",options=["Yes","No"], description="Trigger Alert to remove id if temp is close to boil"), + Property.Select(label="AutoMode",options=["Yes","No"], description="Switch Kettlelogic automatically on and off -> Yes"), Property.Select("First_Wort", options=["Yes","No"], description="First Wort Hop alert if set to Yes"), Property.Number("Hop_1", configurable = True, description="First Hop alert (minutes before finish)"), Property.Number("Hop_2", configurable=True, description="Second Hop alert (minutes before finish)"), @@ -167,41 +309,57 @@ class BoilStep(CBPiStep): else: self.cbpi.notify(self.name, 'Timer must be running to add time', NotificationType.WARNING) - - async def on_timer_done(self, timer): + async def on_timer_done(self,timer): self.summary = "" + self.kettle.target_temp = 0 + if self.AutoMode == True: + await self.setAutoMode(False) + self.cbpi.notify(self.name, 'Boiling completed', NotificationType.SUCCESS) await self.next() - async def on_timer_update(self, timer, seconds): + async def on_timer_update(self,timer, seconds): self.summary = Timer.format_time(seconds) self.remaining_seconds = seconds await self.push_update() - async def check_hop_timer(self, number, value): - if value is not None and value != '' and self.hops_added[number-1] is not True: - if self.remaining_seconds != None and self.remaining_seconds <= (int(value) * 60 + 1): - self.hops_added[number-1]= True - self.cbpi.notify('Hop Alert', "Please add Hop %s" % number, NotificationType.INFO) - async def on_start(self): - if 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) - if self.cbpi.kettle is not None: - await self.cbpi.kettle.set_target_temp(self.props.get("Kettle", None), int(self.props.get("Temp",0))) - self.summary = "Waiting for Target Temp" - await self.push_update() + + 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) + + self.summary = "Waiting for Target Temp" + if self.AutoMode == True: + await self.setAutoMode(True) + await self.push_update() + + async def check_hop_timer(self, number, value): + if value is not None and self.hops_added[number-1] is not True: + if self.remaining_seconds != None and self.remaining_seconds <= (int(value) * 60 + 1): + self.hops_added[number-1]= True + self.cbpi.notify('Hop Alert', "Please add Hop %s" % number, NotificationType.INFO) + async def on_stop(self): await self.timer.stop() self.summary = "" + self.kettle.target_temp = 0 + if self.AutoMode == True: + await self.setAutoMode(False) await self.push_update() async def reset(self): - self.timer = Timer(int(self.props.get("Timer",0)) * 60, on_update=self.on_timer_update, on_done=self.on_timer_done) + self.timer = Timer(int(self.props.get("Timer", 0)) *60 ,on_update=self.on_timer_update, on_done=self.on_timer_done) async def run(self): if self.first_wort_hop_flag == False and self.first_wort_hop == "Yes": @@ -210,19 +368,109 @@ class BoilStep(CBPiStep): while self.running == True: await asyncio.sleep(1) - sensor_value = self.get_sensor_value(self.props.get("Sensor", None)) + sensor_value = self.get_sensor_value(self.props.get("Sensor", None)).get("value") - if sensor_value.get("value") >= int(self.props.get("Temp",0)) and self.timer.is_running is not True: + if self.lid_flag == True and sensor_value >= self.lid_temp: + self.cbpi.notify("Please remove lid!", "Reached temp close to boiling", NotificationType.INFO) + self.lid_flag = False + + if sensor_value >= int(self.props.get("Temp", 0)) and self.timer.is_running is not True: self.timer.start() - estimated_completion_time = datetime.fromtimestamp(time.time()+ (int(self.props.get("Timer",0)))*60) - self.cbpi.notify(self.name, 'Timer started. Estimated completion: {}'.format(estimated_completion_time.strftime("%H:%M")), NotificationType.INFO) self.timer.is_running = True + estimated_completion_time = datetime.fromtimestamp(time.time()+ (int(self.props.get("Timer", 0)))*60) + self.cbpi.notify(self.name, 'Timer started. Estimated completion: {}'.format(estimated_completion_time.strftime("%H:%M")), NotificationType.INFO) else: for x in range(1, 6): await self.check_hop_timer(x, self.props.get("Hop_%s" % x, None)) return StepResult.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.kettle.instance.stop() + await self.push_update() + + except Exception as e: + logging.error("Failed to switch on KettleLogic {} {}".format(self.kettle.id, e)) + + +@parameters([Property.Number(label="Temp", configurable=True, description="Target temperature for cooldown. Notification will be send when temp is reached and Actor can be triggered"), + Property.Number(label="Interval", configurable=True, description="Interval [min] for Notification and caclulate predicted End time"), + Property.Sensor(label="Sensor", description="Sensor that is used during cooldown"), + Property.Actor(label="Actor", description="Actor can trigger a valve for the cooldwon to target temperature"), + Property.Kettle(label="Kettle")]) +class CooldownStep(CBPiStep): + + async def on_timer_done(self,timer): + self.summary = "" + if self.actor is not None: + await self.actor_off(self.actor) + self.cbpi.notify('CoolDown', 'Wort cooled down. Please transfer to Fermenter.', NotificationType.INFO) + await self.next() + + async def on_timer_update(self,timer, seconds): + 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 = int(self.props.get("Interval",10)) # 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 + + async def on_stop(self): + await self.timer.stop() + self.summary = "" + if self.actor is not None: + await self.actor_off(self.actor) + 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): + timestring = datetime.fromtimestamp(self.start_time) + if self.actor is not None: + await self.actor_on(self.actor) + self.summary="Started: {}".format(timestring.strftime("%H:%M")) + await self.push_update() + while self.running == True: + current_temp = self.get_sensor_value(self.props.get("Sensor", None)).get("value") + if self.count == 19: + self.temp_array.append(current_temp) + self.time_array.append(time.time()) + self.count = 0 + if time.time() >= self.next_check: + self.next_check = time.time() + (self.Interval * 60) + cooldown_model = np.poly1d(np.polyfit(self.temp_array, self.time_array, 4)) + target_time=cooldown_model(self.target_temp) + target_timestring= datetime.fromtimestamp(target_time) + self.summary="ECT: {}".format(target_timestring.strftime("%H:%M")) + self.cbpi.notify("Cooldown Step","Current: {}°, reaching {}° at {}".format(round(current_temp,1), self.target_temp, target_timestring.strftime("%d.%m %H:%M")), NotificationType.INFO) + await self.push_update() + + if current_temp <= self.target_temp and self.timer.is_running is not True: + self.timer.start() + self.timer.is_running = True + + self.count +=1 + await asyncio.sleep(1) + + return StepResult.DONE def setup(cbpi): ''' @@ -233,7 +481,10 @@ def setup(cbpi): :return: ''' - cbpi.plugin.register("BoilStep", BoilStep) - cbpi.plugin.register("WaitStep", WaitStep) + cbpi.plugin.register("MashInStep", MashInStep) cbpi.plugin.register("MashStep", MashStep) + cbpi.plugin.register("BoilStep", BoilStep) + cbpi.plugin.register("CooldownStep", CooldownStep) + cbpi.plugin.register("WaitStep", WaitStep) cbpi.plugin.register("ActorStep", ActorStep) + cbpi.plugin.register("NotificationStep", NotificationStep)