def execute(self):
'''
This method is execute in an interval
:return:
'''
# Check if Target Temp is reached
if self.mode == "Timer":
if cbpi.get_sensor_value(int(self.sensor)) >= float(
self.mash_temp):
if self.is_timer_finished() is None:
self.start_timer(int(self.timer) * 60)
# Check if timer finished and go to next step
if self.is_timer_finished() == True:
self.notify("Mash Step Completed!",
"Starting the next step",
timeout=None)
self.next()
if self.mode == "User input":
if cbpi.get_sensor_value(int(self.sensor)) >= float(
self.mash_temp):
self.notify("Mash Temp reached!",
"User input needed to proceed to next step",
timeout=None)
self.mode = "All done. Wait for user"
def show_singlemode(id1):
cbpi.app.logger.info("LCDDisplay - id1 an Funktion übergeben %s" % (id1))
s = cbpi.cache.get("active_step")
#read the current temperature of kettle with id1 from parameters
current_sensor_value_id1 = (cbpi.get_sensor_value(
int(cbpi.cache.get("kettle").get(id1).sensor)))
#get the state of the heater of the current kettle
heater_of_kettle = int(cbpi.cache.get("kettle").get(id1).heater)
#cbpi.app.logger.info("LCDDisplay - heater id %s" % (heater_of_kettle))
heater_status = cbpi.cache.get("actors").get(heater_of_kettle).state
#cbpi.app.logger.info("LCDDisplay - heater status (0=off, 1=on) %s" % (heater_status))
#line1 the stepname
line1 = (u'%s' % (s.name, )).ljust(20)[:20]
#line2 when steptimer is runnig show remaining time and kettlename
if s.timer_end is not None:
time_remaining = time.strftime(u"%H:%M:%S",
time.gmtime(s.timer_end - time.time()))
line2 = ((u"%s %s" %
((cbpi.cache.get("kettle")[id1].name).ljust(12)[:11],
time_remaining)).ljust(20)[:20])
else:
line2 = ((u'%s' % (cbpi.cache.get("kettle")[id1].name)).ljust(20)[:20])
#line3
line3 = (u"Targ. Temp:%6.2f%s" %
(float(cbpi.cache.get("kettle")[id1].target_temp),
(u"°C"))).ljust(20)[:20]
#line4 needs errorhandling because there may be tempvalue without sensordates and so it is none and than an error is thrown
try:
line4 = (u"Curr. Temp:%6.2f%s" % (float(current_sensor_value_id1),
(u"°C"))).ljust(20)[:20]
except:
cbpi.app.logger.info(
"LCDDisplay - singlemode current_sensor_value_id1 exception %s" %
(current_sensor_value_id1))
line4 = (u"Curr. Temp: %s" % (("No Data")))[:20]
lcd.cursor_pos = (0, 0)
lcd.write_string(line1)
lcd.cursor_pos = (0, 19)
if bk == 0 and heater_status != 0:
lcd.write_string(u"\x00")
global bk
bk = 1
else:
lcd.write_string(u" ")
global bk
bk = 0
lcd.cursor_pos = (1, 0)
lcd.write_string(line2)
lcd.cursor_pos = (2, 0)
lcd.write_string(line3)
lcd.cursor_pos = (3, 0)
lcd.write_string(line4)
def trigger_eval(self):
#print "trigger"
if self.trig["s1"]:
sensor = tryfloat(cbpi.get_sensor_value(tryint(self.trig["s1"])))
else:
sensor = 0
s1 = sensor
if self.trig["s2"]:
s2 = tryfloat(cbpi.get_sensor_value(tryint(self.trig["s2"])))
else:
s2 = 0
on = self.out["active"]
state = self.out["on"]
off = not self.out["active"]
trig_sig = bool(eval(self.trig["text"]))
#based on trigger and immediate settings, enable or disable actor
if trig_sig == True:
if self.trig["last"] is False:
if self.trig["type"] == "Tog":
pass #toggle actor
self.update_self(self.power, "Tog")
elif self.trig["type"] == "Sw":
pass # switch actor on
self.update_self(self.power, True)
if not self.trig["im_on"]:
self.times["onoff"] = datetime.utcnow() + self.delay["on"]
self.trig["last"] = True
return self.out["req"]
else:
if self.trig["last"] is True:
if self.trig["type"] == "NTog":
pass #toggle actor on negative switch
elif self.trig["type"] == "Sw":
pass # switch actor off
self.update_self(self.power, False)
if not self.trig["im_off"]:
self.times["onoff"] = datetime.utcnow() + self.delay["off"]
self.trig["last"] = False
if self.trig["type"] is False:
return False
else:
return self.out["req"]
#should not get here
print "Failure: should not be here"
return False
def brewfather_background_task(api):
api_id = bf_api_id()
if api_id == "":
cbpi.notify(
"Brewfather Error",
"Id not set. Update brewfather_api_id parameter within System > Parameters.",
type="danger",
timeout=None)
return
for i, fermenter in cbpi.cache.get("fermenter").iteritems():
# if we have a beer name, we will log the temperatures
if fermenter.brewname and fermenter.brewname.strip():
try:
queryString = {"id": api_id}
data = {
"name": fermenter.name,
"beer": fermenter.brewname,
"temp": cbpi.get_sensor_value(fermenter.sensor),
"aux_temp": cbpi.get_sensor_value(fermenter.sensor2),
"ext_temp": cbpi.get_sensor_value(fermenter.sensor3),
"temp_unit": cbpi.get_config_parameter("unit", "C")
}
response = requests.post(bf_uri, params=queryString, json=data)
if response.status_code != 200:
cbpi.notify(
"Brewfather Error",
"Received unsuccessful response. Ensure API Id is correct. HTTP Error Code: "
+ str(response.status_code),
type="danger",
timeout=None)
except BaseException as error:
cbpi.notify("Brewfather Error",
"Unable to send message." + str(error),
type="danger",
timeout=None)
pass
def sensor_value(sensor):
print "SENSOR", sensor
for idx, value in cbpi.cache["sensors"].iteritems():
print value.__dict__
if value.name.lower() == sensor:
v = cbpi.get_sensor_value(value.id)
speech_text = 'The sensor temperature is %s %s' % (
v, value.instance.get_unit())
return question(speech_text).reprompt(speech_text).simple_card(
'Value Name', speech_text)
speech_text = "I have notf found the sensor %s. Any further question?" % sensor
return question(speech_text).reprompt(speech_text).simple_card(
'Sensor Value', speech_text)
def show_multidisplay(refresh):
s = cbpi.cache.get("active_step")
for idx, value in cbpi.cache["kettle"].iteritems():
current_sensor_value = (cbpi.get_sensor_value(value.sensor))
heater_of_kettle = int(cbpi.cache.get("kettle").get(value.id).heater)
heater_status = int(
cbpi.cache.get("actors").get(heater_of_kettle).state)
line1 = (u'%s' % (s.name, ))[:20]
#line2 when steptimer is runnig show remaining time and kettlename
if s.timer_end is not None:
time_remaining = time.strftime(
u"%H:%M:%S", time.gmtime(s.timer_end - time.time()))
line2 = ((u"%s %s" % (
(value.name).ljust(12)[:11], time_remaining)).ljust(20)[:20])
else:
line2 = ((u'%s' % (value.name, ))[:20])
#line3
line3 = (u"Targ. Temp:%6.2f%s" % (float(value.target_temp),
(u"°C")))[:20]
#line4 needs errorhandling because there may be tempvalue without sensordates and so it is none and than an error is thrown
try:
line4 = (u"Curr. Temp:%6.2f%s" % (float(current_sensor_value),
(u"°C")))[:20]
except:
cbpi.app.logger.info(
"LCDDisplay - current_sensor_value exception %s" %
(current_sensor_value))
line4 = (u"Curr. Temp: %s" % (("No Data")))[:20]
lcd.clear()
lcd.cursor_pos = (0, 0)
lcd.write_string(line1)
lcd.cursor_pos = (0, 19)
if heater_status != 0:
lcd.write_string(u"\x00")
lcd.cursor_pos = (1, 0)
lcd.write_string(line2)
lcd.cursor_pos = (2, 0)
lcd.write_string(line3)
lcd.cursor_pos = (3, 0)
lcd.write_string(line4)
time.sleep(refresh)
pass
def kettle_value(kettle):
print "KETTLE", kettle
for idx, value in cbpi.cache["kettle"].iteritems():
if value.name.lower() == kettle:
v = cbpi.get_sensor_value(value.sensor)
s = cbpi.cache["sensors"].get(int(value.sensor))
speech_text = 'The Kettle Temperature of %s is %s %s' % (
str(kettle), v, s.instance.get_unit())
return question(speech_text).reprompt(speech_text).simple_card(
'Kettle Value', speech_text)
#return statement(speech_text).simple_card('Kettle Value', speech_text)
speech_text = "I have not found the kettle %s. Any further question?" % kettle
return question(speech_text).reprompt(speech_text).simple_card(
'Kettle Value', speech_text)
def start_fermentation(self, id):
#print "start_fermentation"
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()
if fermenter.cooler != '' and fermenter.heater != '':
inactive.direction = "C" if current_temp >= inactive.temp else "H"
elif fermenter.heater != '':
inactive.direction = "H"
elif fermenter.cooler != '':
inactive.direction = "C"
else:
inactive.direction = "C" if current_temp >= inactive.temp else "H"
FermenterStep.update(**inactive.__dict__)
self.postTargetTemp(id, inactive.temp, inactive.start_temp,
inactive.stop_temp)
#print "fermenter_task"
cbpi.cache["fermenter_task"][id] = inactive
cbpi.emit("UPDATE_FERMENTER", cbpi.cache.get(self.cache_key)[id])
return ('', 204)
def execute(self):
'''
This method is execute in an interval
:return:
'''
# Check if Target Temp is reached
if cbpi.get_sensor_value(int(self.sensor)) >= float(self.temp):
if self.is_timer_finished() is None:
self.start_timer(int(self.timer) * 60)
# Check if timer finished and go to next step
if self.is_timer_finished() == True:
self.notify("Mash Step Completed!",
"Starting the next step",
timeout=None)
next(self)
def update():
s = cbpi.cache.get("active_step")
text = "Here is your update. "
if s is not None:
text = text + 'The current step is %s . ' % (s.name, )
else:
text = text + 'There is no brewing process running .'
text = text + "Now to the brewing kettles. "
for idx, value in cbpi.cache["kettle"].iteritems():
current_sensor_value = cbpi.get_sensor_value(value.sensor)
text = text + "%s has set target temperature to %s and a current temperature of %s. " % (
value.name, value.target_temp, current_sensor_value)
text = text + "Any further question?"
return question(text).reprompt(text).simple_card('CBP Update', text)
def mqtt_pub(api):
"""
background process that reads all passive sensors in interval of 5 second
:return: None
"""
for i, value in cbpi.cache['kettle'].items():
topic = 'MQTTDevice/kettle/' + str(i)
data = {
'id': i,
'he':
cbpi.cache.get("actors").get(int(value.heater)).config["topic"],
'te': cbpi.get_sensor_value(value.sensor),
'tt': value.target_temp
}
api.cache["mqtt"].client.publish(topic,
payload=json.dumps(
data, ensure_ascii=False),
qos=0,
retain=False)
def check_step(self):
for key, value in cbpi.cache["fermenter_task"].iteritems():
try:
fermenter = self.get_fermenter(key)
current_temp = cbpi.get_sensor_value(int(fermenter.sensor))
if value.timer_start is None:
#print "1 ....%s key %s %s" % (fermenter.id,key,value.direction)
if value.direction == "H":
if current_temp >= value.temp:
if fermenter.shake == 0 or fermenter.shake is None:
fermenter.shake = fermenter.time()
else:
sub = time.time() - fermenter.shake
if int(sub) > 4:
self.target_temp_reached(key, value)
fermenter.shake = None
elif fermenter.shake is not None:
fermenter.shake = None
else:
if current_temp <= value.temp:
if fermenter.shake == 0 or fermenter.shake is None:
fermenter.shake = time.time()
else:
sub = time.time() - fermenter.shake
if int(sub) > 4:
self.target_temp_reached(key, value)
fermenter.shake = None
elif fermenter.shake is not None:
fermenter.shake = None
else:
if time.time() >= value.timer_start:
if fermenter.shake is not None:
fermenter.shake = None
self.start_fermentation(key)
else:
pass
except Exception as e:
pass
def check_step(self):
for key, value in cbpi.cache["fermenter_task"].iteritems():
try:
fermenter = self.get_fermenter(key)
current_temp = current_temp = cbpi.get_sensor_value(int(fermenter.sensor))
if value.timer_start is None:
if value.direction == "H" :
if current_temp >= value.temp:
self.target_temp_reached(key,value)
else:
if current_temp <= value.temp:
self.target_temp_reached(key, value)
else:
if time.time() >= value.timer_start:
self.start_fermentation(key)
else:
pass
except Exception as e:
pass
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 = self.calculate_direction(fermenter, current_temp, inactive.temp)
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 show_fermentation_multidisplay(refresh):
for idx, value in cbpi.cache["fermenter"].iteritems():
current_sensor_value = (cbpi.get_sensor_value(value.sensor))
#INFO value = modules.fermenter.Fermenter
#INFO FermenterId = modules.fermenter.Fermenter.id
#get the state of the heater of the current fermenter, if there is none, except takes place
try:
heater_of_fermenter = int(cbpi.cache.get("fermenter").get(value.id).heater)
#cbpi.app.logger.info("LCDDisplay - fheater id %s" % (heater_of_fermenter))
fheater_status = int(cbpi.cache.get("actors").get(heater_of_fermenter).state)
#cbpi.app.logger.info("LCDDisplay - fheater status (0=off, 1=on) %s" % (fheater_status))
except:
fheater_status = 0
#get the state of the cooler of the current fermenter, if there is none, except takes place
try:
cooler_of_fermenter = int(cbpi.cache.get("fermenter").get(value.id).cooler)
#cbpi.app.logger.info("LCDDisplay - fcooler id %s" % (cooler_of_fermenter))
fcooler_status = int(cbpi.cache.get("actors").get(cooler_of_fermenter).state)
#cbpi.app.logger.info("LCDDisplay - fcooler status (0=off, 1=on) %s" % (fcooler_status))
except:
fcooler_status = 0
pass
line1 = (u'%s' % (value.brewname,))[:20]
#line2
z = 0
for key, value1 in cbpi.cache["fermenter_task"].iteritems():
#INFO value1 = modules.fermenter.FermenterStep
#cbpi.app.logger.info("LCDDisplay - value1 %s" % (value1.fermenter_id))
if value1.timer_start is not None and value1.fermenter_id == value.id:
line2 = interval(value.name,(value1.timer_start- time.time()))
z = 1
elif z == 0:
line2 = (u'%s' % (value.name,))[:20]
pass
#line3
line3 = (u"Targ. Temp:%6.2f%s" % (float(value.target_temp),(u"°C")))[:20]
#line4 needs errorhandling because there may be tempvalue without sensordates and so it is none and than an error is thrown
try:
line4 = (u"Curr. Temp:%6.2f%s" % (float(current_sensor_value),(u"°C")))[:20]
except:
cbpi.app.logger.info("LCDDisplay - fermentmode current_sensor_value exception %s" % (current_sensor_value))
line4 = (u"Curr. Temp: %s" % (("No Data")))[:20]
pass
lcd.clear()
lcd.cursor_pos = (0, 0)
lcd.write_string(line1)
lcd.cursor_pos = (0,19)
if fheater_status != 0:
lcd.write_string(u"\x00")
if fcooler_status != 0:
lcd.write_string(u"\x01")
lcd.cursor_pos = (1, 0)
lcd.write_string(line2)
lcd.cursor_pos = (2, 0)
lcd.write_string(line3)
lcd.cursor_pos = (3, 0)
lcd.write_string(line4)
time.sleep(refresh)
def get_kettle_temp(self, id=None):
id = int(id)
if id is None:
id = self.kettle_id
return cbpi.get_sensor_value(
int(self.api.cache.get("kettle").get(id).sensor))
def get_sensor_value(self, id):
return cbpi.get_sensor_value(id)
def get_sensor_value(self, id=None):
if id is None:
id = self.sensor
return cbpi.get_sensor_value(id)
def execute(self):
'''
This method is execute in an interval
:return:
'''
sensorValue1 = cbpi.get_sensor_value(int(self.sensor1))
sensorValue2 = cbpi.get_sensor_value(int(self.sensor2))
volumeChange1 = float(sensorValue1) - float(self.volumeState1)
volumeChange2 = float(self.volumeState2) - float(sensorValue2)
kettle1_state = cbpi.cache.get("kettle")[int(self.kettle1)].state
kettle2_state = cbpi.cache.get("kettle")[int(self.kettle2)].state
for key, value in cbpi.cache["actors"].iteritems():
if key == int(self.actor1):
actorState1 = value.state
if key == int(self.actor2):
actorState2 = value.state
if float(sensorValue1) >= float(
self.volumeBoil) and kettle1_state is False:
Kettle2View().toggle(int(self.kettle1))
self.notify("Kettle Update", "Kettle 1 Auto is on.", timeout=None)
self.set_target_temp(self.temp, self.kettle1)
# Check if kettle2 volume limit reached
if float(sensorValue2) <= float(self.volume2):
if kettle2_state is True:
self.set_target_temp(0, self.kettle2)
Kettle2View().toggle(int(self.kettle2))
self.notify("Kettle Update",
"Kettle 2 Auto is off.",
timeout=None)
if self.is_timer_finished() is None:
self.start_timer(int(self.timer) * 60)
# Make sure kettle1 hasn't reached target
if float(sensorValue1) < float(self.volume1):
self.actor_on(int(self.actor1))
if self.is_timer_finished() == True:
self.actor_off(int(self.actor2))
else:
self.actor_on(int(self.actor2))
else:
if self.volumeState1 > 0:
totalDiff = float(volumeChange2) - float(volumeChange1)
if totalDiff > 0:
if abs(totalDiff) > float(self.volumeDiff):
self.actor_off(int(self.actor2))
self.actor_on(int(self.actor1))
else:
self.actor_on(int(self.actor2))
else:
if abs(totalDiff) > float(self.volumeDiff):
self.actor_off(int(self.actor1))
self.actor_on(int(self.actor2))
else:
self.actor_on(int(self.actor1))
else:
if volumeChange >= 10:
self.volumeState2 = sensorValue2
self.volumeState1 = sensorValue1
# Check if kettle1 target volume has been reached
if float(sensorValue1) >= float(self.volume1):
self.set_target_temp(0, self.kettle2)
self.stop_timer()
self.start_timer(0)
self.notify("Sparge Complete!",
"Starting the next step.",
timeout=None)
self.next()
def currentfermtemp(fermid):
# read the current temperature of fermenter with fermenter ID from parameters
current_sensor_value_ferm = (cbpi.get_sensor_value(int(cbpi.cache.get("fermenter").get(fermid).sensor)))
if DEBUG: cbpi.app.logger.info('NextionDisplay - currentfermtemp.txt:%s' % current_sensor_value_ferm)
return current_sensor_value_ferm
def Temp(kkid):
# if DEBUG: cbpi.app.logger.info("NEXTIONDisplay - Temp detect")
current_sensor_value_id3 = (cbpi.get_sensor_value(int(cbpi.cache.get("kettle").get(int(kkid)).sensor)))
curTemp = ("%6.2f" % (float(current_sensor_value_id3)))
# if DEBUG: cbpi.app.logger.info("NEXTIONDisplay - Temp: %s" % (curTemp))
return curTemp
def femTemp(femid):
# cbpi.app.logger.info("TFTDisplay - ferm Temp ermitteln")
current_sensor_value_femid = (cbpi.get_sensor_value(int(cbpi.cache.get("fermenter").get(int(femid)).sensor)))
curfemTemp = ("%6.2f" % (float(current_sensor_value_femid)))
# cbpi.app.logger.info("TFTDisplay - FermTemp: %s" % (curfemTemp))
return curfemTemp
def Temp(kkid):
# cbpi.app.logger.info("TFTDisplay - Temp ermitteln")
current_sensor_value_id3 = (cbpi.get_sensor_value(int(cbpi.cache.get("kettle").get(int(kkid)).sensor)))
curTemp = ("%6.2f" % (float(current_sensor_value_id3)))
# cbpi.app.logger.info("TFTDisplay - Temp: %s" % (curTemp))
return curTemp
