jens
a1864a5257
AttributeChange (the common base of every ATask and component ABC) now sets self.log = logging.getLogger(type(self).__name__), so components no longer need to hand-type their own name into each message. Wired logging.basicConfig() in server/brewpi.py with a bare "%(name)s: %(message)s" formatter - Tee (see prior commit) still supplies the "<date>T<time>:" prefix, so lines read "<date>T<time>:<component>: <message>" without double-stamping, and third-party loggers (websockets, asyncio) now get the same formatting for free. Converted the print() call sites that were standing in for this in tasks/ and components/ (leaving __main__ demo blocks and explicit debug-dump helpers alone).
194 lines
6.9 KiB
Python
Executable File
194 lines
6.9 KiB
Python
Executable File
import asyncio
|
|
from tasks import ATask, fire_and_forget
|
|
from components import AHeater
|
|
from ws.message import MsgIo
|
|
from utils.value import ChangedInteger
|
|
|
|
|
|
class HeaterTask(ATask):
|
|
def __init__(self, device: AHeater, interval, msg_handler: MsgIo):
|
|
ATask.__init__(self, interval)
|
|
|
|
self.device = device
|
|
self.interval = interval
|
|
self.msg_handler = msg_handler
|
|
msg_handler.set_recv_handler(self.recv)
|
|
self.power_soll = 0
|
|
self.power_actor = 0
|
|
self.closed_loop = True
|
|
self._on_closed_loop_changed = None
|
|
self.pulse_counter = 0
|
|
self._on_connected_changed = None
|
|
device.set_on_changed('power_eff', ChangedInteger(self.on_changed_power).set)
|
|
device.set_on_changed('connected', self.on_connected_changed)
|
|
self.power_set_changed = ChangedInteger(self.on_changed_power_set).set
|
|
|
|
def set_on_closed_loop_changed(self, callback):
|
|
self._on_closed_loop_changed = callback
|
|
|
|
def set_on_connected_changed(self, callback):
|
|
"""Registers a callback(connected: bool) invoked whenever the
|
|
device's connection state changes - lets server/brewpi.py wire this
|
|
into SudTask's start-gating/mid-brew auto-stop."""
|
|
self._on_connected_changed = callback
|
|
|
|
def on_connected_changed(self, value):
|
|
fire_and_forget(self.send({'Connected': value}))
|
|
if self._on_connected_changed:
|
|
self._on_connected_changed(value)
|
|
|
|
def shutdown(self):
|
|
"""Called when the brew ends (DONE/IDLE). Switches to open-loop at
|
|
power 0 and disables TC, mirroring what a Stop press should do."""
|
|
self.closed_loop = False
|
|
self.power_soll = 0
|
|
if self._on_closed_loop_changed:
|
|
self._on_closed_loop_changed(False)
|
|
asyncio.create_task(self.send({'ClosedLoop': False}))
|
|
self.power_set_changed(0)
|
|
|
|
def start_closed_loop(self):
|
|
"""Called when a Sud starts. Re-enables closed-loop so the TC drives
|
|
the heater regardless of which client started the brew."""
|
|
self.closed_loop = True
|
|
if self._on_closed_loop_changed:
|
|
self._on_closed_loop_changed(True)
|
|
asyncio.create_task(self.send({'ClosedLoop': True}))
|
|
|
|
def disconnect(self):
|
|
"""Disconnects the device and zeroes its setpoint, so a later
|
|
reconnect (whether from an explicit Connect or an auto-reconnect)
|
|
never resumes at a stale power. Used for every disconnect - a
|
|
user-requested Disconnect, a comm-error timeout, and the
|
|
unexpected-exception recovery path alike - not just the explicit
|
|
one, since power_actor otherwise keeps whatever the TC last
|
|
computed (which can be stale/wound-up from before the outage) and
|
|
would be re-applied on the very next tick after reconnecting."""
|
|
self.device.disconnect()
|
|
self.power_soll = 0
|
|
self.power_actor = 0
|
|
self.power_set_changed(0)
|
|
|
|
def actor(self, y):
|
|
self.power_actor = max(0, self.device.get_power_max() * y)
|
|
|
|
def on_changed_power(self, power):
|
|
asyncio.create_task(self.send({'Power': power}))
|
|
|
|
def on_changed_power_set(self, power):
|
|
asyncio.create_task(self.send({'PowerSet': power}))
|
|
|
|
async def recv(self, data):
|
|
for pair in data.items():
|
|
if pair[0] == 'ClosedLoop':
|
|
self.closed_loop = pair[1]
|
|
if self.closed_loop:
|
|
self.power_soll = 0
|
|
if self._on_closed_loop_changed:
|
|
self._on_closed_loop_changed(self.closed_loop)
|
|
await self.send({'ClosedLoop': self.closed_loop})
|
|
elif pair[0] == 'Connect':
|
|
if self.device.connect():
|
|
self.device.activate(True)
|
|
elif pair[0] == 'Disconnect':
|
|
self.device.activate(False)
|
|
self.disconnect()
|
|
elif 'Power' in pair[0]:
|
|
self.power_soll = pair[1]
|
|
|
|
async def send(self, data):
|
|
await self.msg_handler.send(data)
|
|
|
|
def get_next_smaller_power(self, power):
|
|
result = self.device.get_power_min()
|
|
p_list = [p for p in self.device.get_powers() if p <= power]
|
|
if len(p_list) > 0:
|
|
result = p_list[-1]
|
|
return result
|
|
|
|
def get_next_greater_power(self, power):
|
|
result = self.device.get_power_min()
|
|
p_list = [p for p in self.device.get_powers() if p > power]
|
|
if len(p_list) > 0:
|
|
result = p_list[0]
|
|
return result
|
|
|
|
async def on_process(self):
|
|
await self.send({'Capabilities': {'Power': {'Min': 0, 'Max': self.device.get_power_max()}}})
|
|
await self.send({'Simulated': self.device.simulated})
|
|
await self.send({'ClosedLoop': self.closed_loop})
|
|
if self._on_closed_loop_changed:
|
|
self._on_closed_loop_changed(self.closed_loop)
|
|
|
|
pulse_period_s = 10
|
|
pulse_period_count = pulse_period_s/self.interval
|
|
|
|
# Auto-connect on startup - replaces what used to happen implicitly
|
|
# in the device's own constructor; a missing/unplugged device just
|
|
# stays disconnected instead of crashing the server (see
|
|
# components/actor/heater_hendi.py's connect()).
|
|
self.device.connect()
|
|
# Explicit initial push, same as Capabilities/Simulated/ClosedLoop
|
|
# above - a simulated device's connect() is a no-op that never
|
|
# reassigns self.connected (see components/connectable.py), so its
|
|
# set_on_changed('connected', ...) observer would otherwise never
|
|
# fire and a freshly-subscribed client would never learn it's
|
|
# connected.
|
|
await self.send({'Connected': self.device.connected})
|
|
|
|
# Outer retry loop - belt-and-suspenders around the tick loop's own
|
|
# per-call guards below. A comm failure a device-level guard didn't
|
|
# anticipate (e.g. a raw pyserial/termios exception escaping from
|
|
# somewhere other than device.process(), the one call already
|
|
# wrapped below) must never be allowed to fall out of this
|
|
# coroutine entirely: nothing restarts a dead ATask, so a single
|
|
# uncaught exception here would permanently stop this device from
|
|
# ever being process()'d again - even after a later, otherwise-
|
|
# successful reconnect. See the incident this was added for: a
|
|
# mid-brew unplug raised termios.error from deep inside
|
|
# HendiCtrl.disconnect() itself (fixed there too), which escaped
|
|
# all the way out of this loop and killed it for the rest of the
|
|
# process's life.
|
|
while True:
|
|
try:
|
|
with self.device.open():
|
|
while True:
|
|
# Closed-loop: TC has full control. Open-loop: direct manual power only.
|
|
power_soll = self.power_actor if self.closed_loop else self.power_soll
|
|
self.power_set_changed(power_soll)
|
|
|
|
# Calculate duty cycle
|
|
power_low = self.get_next_smaller_power(power_soll)
|
|
power_high = self.get_next_greater_power(power_soll)
|
|
power_step = power_high - power_low
|
|
power_diff = power_soll - power_low
|
|
duty = power_diff / power_step
|
|
|
|
on_count = pulse_period_count*duty
|
|
|
|
self.pulse_counter += 1
|
|
if self.pulse_counter >= pulse_period_count:
|
|
self.pulse_counter = 0
|
|
|
|
if power_soll == 0 or self.pulse_counter >= on_count:
|
|
self.device.set_power(power_low)
|
|
elif self.pulse_counter < on_count:
|
|
self.device.set_power(power_high)
|
|
|
|
try:
|
|
self.device.process()
|
|
except Exception as e:
|
|
self.log.error(f"comm error, marking disconnected: {e}")
|
|
self.disconnect()
|
|
await asyncio.sleep(self.interval)
|
|
except Exception as e:
|
|
self.log.error(f"unexpected error, recovering: {e}")
|
|
try:
|
|
self.disconnect()
|
|
except Exception:
|
|
pass
|
|
await asyncio.sleep(self.interval)
|
|
|
|
|
|
|