def update_history(self):
logger.debug("Updating history")
mode = self.mode
if mode in (WINTER, SUMMER):
with db.session_scope() as session:
parameters = db.History(
outside_temp=self.outside_temp,
effective_setpoint=self.effective_setpoint,
water_out_temp=self.water_out_temp,
return_temp=self.return_temp,
boiler_status=self.boiler.status,
cascade_fire_rate=self.boiler.cascade_current_power,
lead_fire_rate=self.boiler.lead_firing_rate,
chiller1_status=self.chiller1.status,
chiller2_status=self.chiller2.status,
chiller3_status=self.chiller3.status,
chiller4_status=self.chiller4.status,
tha_setpoint=self.tha_setpoint,
setpoint_offset_winter=self.setpoint_offset_winter,
setpoint_offset_summer=self.setpoint_offset_summer,
tolerance=self.tolerance,
boiler_manual_override=self.boiler.manual_override,
chiller1_manual_override=self.chiller1.manual_override,
chiller2_manual_override=self.chiller2.manual_override,
chiller3_manual_override=self.chiller3.manual_override,
chiller4_manual_override=self.chiller4.manual_override,
mode=mode,
cascade_time=self.cascade_time,
wind_speed=self.wind_speed,
avg_outside_temp=self.wind_chill_avg,
avg_cascade_fire_rate=self.cascade_fire_rate_avg,
delta=self.current_delta)
session.add(parameters)
def chillers_cascade_switcher(self):
logger.debug("Chiller cascade switcher")
max_chillers_timestamp = max(chiller.switched_timestamp
for chiller in self.devices[1:])
time_gap = (datetime.now() - max_chillers_timestamp).total_seconds()
db_delta = db_queries.three_minute_avg_delta()
db_return_temp = self.previous_return_temp
logger.debug(
("time_gap: {}; three_minute_avg_delta: {}, last_return_temp: {}"
).format(time_gap, db_delta, db_return_temp))
# Turn on chillers
if (self.return_temp >= (self.effective_setpoint + self.tolerance)
and db_delta > 0.1 and time_gap >= self.cascade_time * 60):
turn_on_index = self._find_chiller_index_to_switch(OFF)
try:
self.devices[turn_on_index].turn_on()
except TypeError:
pass
# Turn off chillers
elif (db_return_temp < (self.effective_setpoint - self.tolerance)
and self.current_delta < 0
and time_gap >= self.cascade_time * 60 / 1.5):
turn_off_index = self._find_chiller_index_to_switch(ON)
try:
self.devices[turn_off_index].turn_off()
except TypeError:
pass
def get_data_from_web(self):
logger.debug("Retrieve data from web.")
try:
content = urllib2.urlopen(WEATHER_URL, timeout=5)
last_line = content.readlines()[-1].split()
wind_speed = float(last_line[7])
outside_temp = float(last_line[2])
except (ValueError, IOError, urllib2.HTTPError, urllib2.URLError):
logger.error(
"Unable to get data from the website. Reading previous value from the DB."
)
with db.session_scope() as session:
wind_speed, outside_temp = session.query(
db.History.wind_speed, db.History.outside_temp).order_by(
desc(db.History.id)).first()
if outside_temp != self._outside_temp:
socketio_client.send({
"event": "misc",
"message": {
"outside_temp": outside_temp
}
})
self._outside_temp = outside_temp
self._wind_speed = wind_speed
return {"outside_temp": outside_temp, "wind_speed": wind_speed}
def boiler_switcher(self):
logger.debug("Starting boiler switcher")
if self.boiler.manual_override == MANUAL_AUTO:
if ((self.boiler.status == OFF and self.return_temp) <=
(self.effective_setpoint - self.tolerance)):
self.boiler.turn_on()
elif ((self.boiler.status == ON and self.return_temp) >
(self.effective_setpoint + self.tolerance)):
self.boiler.turn_off()
logger.debug("Boiler: {}; mode: {}".format(self.boiler.status,
self.mode))
def _switch_state(self, command, relay_only=False):
try:
with serial.Serial(cfg.serial.portname,
cfg.serial.baudr,
timeout=1) as ser_port:
ser_port.write("relay {} {}\n\r".format(
command, self.relay_number))
except serial.SerialException as e:
logger.error("Serial port error: {}".format(e))
sys.exit(1)
else:
logger.debug("Relay {} has been turned {}. Relay only: {}".format(
self.relay_number, command, relay_only))
if command == "on" and not relay_only:
self._update_value_in_db(status=ON)
elif command == "off" and not relay_only:
self._update_value_in_db(status=OFF)
def switch_season(self, mode):
if mode == TO_SUMMER:
logger.debug("Switching to summer mode")
self.mode = TO_SUMMER
self._save_devices_states(mode)
self.turn_off_devices()
self.summer_valve.turn_on()
self.winter_valve.turn_off()
self.scheduler.add_job(self.switch_season,
"date",
run_date=datetime.now() +
timedelta(minutes=VALVES_SWITCH_TIME),
args=[FROM_WINTER])
elif mode == TO_WINTER:
logger.debug("Switching to winter mode")
self.mode = TO_WINTER
self._save_devices_states(mode)
self.turn_off_devices()
self.summer_valve.turn_off()
self.winter_valve.turn_on()
self.scheduler.add_job(self.switch_season,
"date",
run_date=datetime.now() +
timedelta(minutes=VALVES_SWITCH_TIME),
args=[FROM_SUMMER])
elif mode == FROM_SUMMER:
logger.debug("Switched to winter mode")
self._restore_devices_states(mode)
self._switch_devices()
self.mode = WINTER
self.mode_switch_timestamp = datetime.now()
elif mode == FROM_WINTER:
logger.debug("Switched to summer mode")
self._restore_devices_states(mode)
self._switch_devices()
self.mode = SUMMER
self.mode_switch_timestamp = datetime.now()