def start(self):
active = Step.get_by_state("A")
inactive = Step.get_by_state('I')
if (active is not None):
active.state = 'D'
active.end = int(time.time())
self.stop_step()
Step.update(**active.__dict__)
if (inactive is not None):
self.init_step(inactive)
inactive.state = 'A'
inactive.stepstate = inactive.config
inactive.start = int(time.time())
Step.update(**inactive.__dict__)
else:
cbpi.log_action("Brewing Finished")
cbpi.notify("Brewing Finished", "You are done!", timeout=None)
cbpi.emit("UPDATE_ALL_STEPS", Step.get_all())
return ('', 204)
def toggle(self, id):
kettle = cbpi.cache.get("kettle")[id]
if kettle.state is False:
# Start controller
if kettle.logic is not None:
cfg = kettle.config.copy()
cfg.update(dict(api=cbpi, kettle_id=kettle.id, heater=kettle.heater, sensor=kettle.sensor))
instance = cbpi.get_controller(kettle.logic).get("class")(**cfg)
instance.init()
kettle.instance = instance
def run(instance):
instance.run()
t = self.api.socketio.start_background_task(target=run, instance=instance)
kettle.state = not kettle.state
cbpi.emit("UPDATE_KETTLE", cbpi.cache.get("kettle").get(id))
else:
# Stop controller
kettle.instance.stop()
kettle.state = not kettle.state
cbpi.emit("UPDATE_KETTLE", cbpi.cache.get("kettle").get(id))
return ('', 204)
def setAutoMode(self, auto_state):
try:
kettle = cbpi.cache.get("kettle")[int(self.kettle)]
if (kettle.state is False) and (auto_state is True):
# turn on
if kettle.logic is not None:
cfg = kettle.config.copy()
cfg.update(
dict(api=cbpi,
kettle_id=kettle.id,
heater=kettle.heater,
sensor=kettle.sensor))
instance = cbpi.get_controller(
kettle.logic).get("class")(**cfg)
instance.init()
kettle.instance = instance
def run(instance):
instance.run()
t = cbpi.socketio.start_background_task(target=run,
instance=instance)
kettle.state = not kettle.state
cbpi.emit("UPDATE_KETTLE",
cbpi.cache.get("kettle")[int(self.kettle)])
elif (kettle.state is True) and (auto_state is False):
# turn off
kettle.instance.stop()
kettle.state = not kettle.state
cbpi.emit("UPDATE_KETTLE",
cbpi.cache.get("kettle")[int(self.kettle)])
except Exception as e:
cbpi.notify("Error",
"Failed to set Auto mode {}".format(["OFF", "ON"
][auto_state]),
type="danger",
timeout=None)
cbpi.app.logger.error(e)
def postStep(self, id):
data = request.json
#print "postStep %s" %(data)
order_max = FermenterStep.get_max_order(id)
order = order_max + 1 if order_max is not None else 1
data["order"] = order
data["days"] = 0 if data["days"] == "" else data["days"]
data["hours"] = 0 if data["hours"] == "" else data["hours"]
data["minutes"] = 0 if data["minutes"] == "" else data["minutes"]
data["temp"] = 0 if data["temp"] == "" else data["temp"]
data["start_temp"] = None if data["start_temp"] == "" else data[
"start_temp"]
data["stop_temp"] = None if data["stop_temp"] == "" else data[
"stop_temp"]
data["state"] = "I"
data["name"] = "NO NAME" if data["name"] == "" else data["name"]
f = FermenterStep.insert(**data)
cbpi.cache.get(self.cache_key)[id].steps.append(f)
cbpi.emit("UPDATE_FERMENTER", cbpi.cache.get(self.cache_key)[id])
return ('', 204)
def postTargetTemp(self, id, temp, start_temp=None, stop_temp=None):
if temp is None or not temp:
return ('', 500)
id = int(id)
temp = float(temp)
#print "temp %s %s" %(start_temp,stop_temp)
cbpi.cache.get(self.cache_key)[id].target_temp = float(temp)
if start_temp is None or start_temp == '':
cbpi.cache.get(self.cache_key)[id].start_temp = None
else:
cbpi.cache.get(self.cache_key)[id].start_temp = float(start_temp)
if stop_temp is None or stop_temp == '':
cbpi.cache.get(self.cache_key)[id].stop_temp = None
else:
cbpi.cache.get(self.cache_key)[id].stop_temp = float(stop_temp)
self.model.update(**self.api.cache.get(self.cache_key)[id].__dict__)
cbpi.emit("UPDATE_FERMENTER_TARGET_TEMP", {
"id": id,
"target_temp": temp
})
return ('', 204)
def execute_step():
'''
Background job which executes the step
:return:
'''
with cbpi.app.app_context():
step = cbpi.cache.get("active_step")
if step is not None:
step.execute()
if step.is_dirty():
state = {}
for field in step.managed_fields:
state[field] = step.__getattribute__(field)
Step.update_step_state(step.id, state)
step.reset_dirty()
cbpi.emit("UPDATE_ALL_STEPS", Step.get_all())
if step.n is True:
StepView().start()
cbpi.emit("UPDATE_ALL_STEPS", Step.get_all())
def start_fermentation(self, id):
active = None
for idx, s in enumerate(cbpi.cache.get(self.cache_key)[id].steps):
if s.state == 'A':
active = s
break
inactive = None
for idx, s in enumerate(cbpi.cache.get(self.cache_key)[id].steps):
if s.state == 'I':
inactive = s
break
if active is not None:
active.state = 'D'
active.end = time.time()
FermenterStep.update(**active.__dict__)
del cbpi.cache["fermenter_task"][id]
if inactive is not None:
fermenter = self.get_fermenter(inactive.fermenter_id)
current_temp = cbpi.get_sensor_value(int(fermenter.sensor))
inactive.state = 'A'
inactive.start = time.time()
inactive.direction = "C" if float(current_temp) >= float(
inactive.temp) else "H"
FermenterStep.update(**inactive.__dict__)
self.postTargetTemp(id, inactive.temp)
cbpi.cache["fermenter_task"][id] = inactive
cbpi.emit("UPDATE_FERMENTER", cbpi.cache.get(self.cache_key)[id])
return ('', 204)
def init_smart_agitator(cbpi):
"""
background process that checks (in interval of 1 seconds) if the kettle-assigned heater is on.
If so, switches on the kettle-assigned agitator.
:return: None
"""
config = get_config()
enabled = config['smart_agitator_enabled']
kettle_id = int(config['smart_agitator_kettle_id'])
kettle = cbpi.cache['kettle'][kettle_id]
try:
curr_agi = cbpi.cache.get("actors").get(int(kettle.agitator))
except:
curr_agi = None
timed_actor = get_timed_actor(config['smart_agitator_override'])
if not curr_agi:
log('Smart agitator plugin is installed but kettle \#' +
str(kettle_id) +
' has no agitator attached! Please choose an agitator in the kettle settings.'
)
msg = {
"id":
len(cbpi.cache["messages"]),
"type":
"info",
"headline":
"SmartAgitator Warning",
"message":
"Smart agitator plugin is installed but kettle \#" +
str(kettle_id) +
" has no agitator attached! Please choose an agitator in the kettle settings.",
"read":
False
}
cbpi.cache["messages"].append(msg)
else:
if enabled == 'YES' and not timed_actor:
if cbpi.cache.get("actors").get(int(
kettle.heater)).state == True and cbpi.cache.get(
"actors").get(int(kettle.heater)).power > 0:
curr_agi.instance.on(100)
cbpi.cache.get("actors").get(int(kettle.agitator)).state = True
cbpi.emit("SWITCH_ACTOR", curr_agi)
elif cbpi.cache.get("actors").get(int(
kettle.heater)).state == False or cbpi.cache.get(
"actors").get(int(kettle.heater)).power < 1:
curr_agi.instance.off()
cbpi.emit("SWITCH_ACTOR", curr_agi)
cbpi.cache.get("actors").get(int(
kettle.agitator)).state = False
elif enabled == 'YES' and timed_actor:
if cbpi.cache.get("actors").get(int(
kettle.heater)).state == True and cbpi.cache.get(
"actors").get(int(kettle.heater)).power > 0:
curr_agi.instance.on(100)
cbpi.cache.get("actors").get(int(kettle.agitator)).state = True
cbpi.emit("SWITCH_ACTOR", curr_agi)
elif cbpi.cache.get("actors").get(
int(kettle.heater)
).state == False or cbpi.cache.get("actors").get(int(
kettle.heater)).power < 1 and timed_actor.state == False:
curr_agi.instance.off()
cbpi.emit("SWITCH_ACTOR", curr_agi)
cbpi.cache.get("actors").get(int(
kettle.agitator)).state = False
def ferm_supervisor_background_task(a):
auto_start = cbpi.cache['config']["auto_start"].value
for key, value in cbpi.cache.get("fermenter").iteritems():
#print key, " ", value.name
if hasattr(value, 'instance'):
#print value.instance.alarmed
if value.instance.alarmed == 1 and value.instance.alarm_time < time.time(
):
# set time for next notificacion
if value.instance.rep_time > 0:
value.instance.alarm_time = time.time() + float(
value.instance.rep_time) * 60
else:
# or never notify again
value.instance.rep_time = 999999999999
stemp = cbpi.cache['sensors'][int(
value.sensor)].instance.last_value
server = smtplib.SMTP(
cbpi.cache['config']['mail_server'].value,
int(cbpi.cache['config']['mail_port'].value))
server.starttls()
server.login(cbpi.cache['config']['mail_user'].value,
cbpi.cache['config']['mail_psw'].value)
msg = "Subject: CraftBeerPi Alarm \r\n\r\n Alarm on " + value.name + " temp " + stemp.__str__(
) + " set point " + value.target_temp.__str__(
) + " at " + strftime("%H:%M:%S on %Y %b %d ", localtime())
server.sendmail(cbpi.cache['config']['mail_user'].value,
cbpi.cache['config']['mail_dest'].value, msg)
server.quit()
if auto_start == 'Yes' and (not value.state) and len(value.steps) > 0:
for step in value.steps:
if step.state == "A":
print "Starting ", key, step.state
try:
print value.state
# Start controller
if value.logic is not None:
cfg = value.config.copy()
cfg.update(
dict(api=cbpi,
fermenter_id=value.id,
heater=value.heater,
sensor=value.sensor))
instance = cbpi.get_fermentation_controller(
value.logic).get("class")(**cfg)
instance.init()
value.instance = instance
def run(instance):
instance.run()
t = cbpi.socketio.start_background_task(
target=run, instance=instance)
value.state = not value.state
cbpi.emit("UPDATE_FERMENTER", value)
except Exception as e:
print e
cbpi.notify("Toogle Fementer Controller failed",
"Pleae check the %s configuration" %
value.name,
type="danger",
timeout=None)
pass
pass
def autoOff(self):
cbpi.cache.get("kettle")[self.kettle_id].state = False
super(KettleController, self).stop()
cbpi.emit("UPDATE_KETTLE",
cbpi.cache.get("kettle").get(self.kettle_id))
def reset(self):
self.model.reset_all_steps()
self.stop_step()
cbpi.emit("UPDATE_ALL_STEPS", self.model.get_all())
return ('', 204)
def deleteAll(self):
self.model.delete_all()
cbpi.emit("UPDATE_ALL_STEPS", self.model.get_all())
return ('', 204)
def sort_steps(self):
Step.sort(request.json)
cbpi.emit("UPDATE_ALL_STEPS", self.model.get_all())
return ('', 204)
def reset(self):
self.model.reset_all_steps()
self.stop_step()
cbpi.emit("UPDATE_ALL_STEPS", self.model.get_all())
cbpi.cache["active_brew"] = "none"
return ('', 204)
def run(instance):
instance.run()
fermenter.state = not fermenter.state
cbpi.emit("UPDATE_FERMENTER",
cbpi.cache.get(self.cache_key).get(id))
def display_power(self, pwr):
actor = cbpi.cache.get("actors").get(int(self.id))
actor.power = pwr
cbpi.emit("SWITCH_ACTOR", actor)
