jensandClaude Sonnet 5
671e0c2474
Root cause (from the brewpi Pi's log): HendiCtrl.disconnect() only caught HendiException (a protocol-level NAK), but a genuine unplug fails deep inside pyserial itself - flushInput()/readline() raise termios.error/OSError on the now-dead fd. That escaped disconnect() uncaught (skipping self.ser.close() too), then kept propagating up through every caller that invoked disconnect() from its own except handler (HeaterHendi.process()/activate(), AHeater.open()'s context-manager exit), all the way out of HeaterTask.on_process()'s coroutine entirely. Nothing restarts a dead ATask, so the heater's process()/duty-cycle loop was gone for the rest of the process's life - reconnecting afterward changed `connected` back to True but nothing was left running to ever call process() again. Fixes: - HendiCtrl.disconnect() now catches broadly and always closes the port, matching Pololu1376.disconnect()'s already-correct pattern. - HeaterTask/StirrerTask.on_process() gain an outer retry loop as a safety net: even an unanticipated exception now logs, marks disconnected, and re-enters rather than permanently killing the task. Verified by reproducing the exact failure (comm error raising a raw OSError, not HendiException) against a fake device - the task now survives and resumes process()ing once reconnected. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01YaPLuRPpyjWcwhMvCvpHCL
90 lines
3.0 KiB
Python
90 lines
3.0 KiB
Python
import asyncio
|
|
from tasks import ATask, fire_and_forget
|
|
from ws.message import MsgIo
|
|
from components import AStirrer
|
|
from utils.value import ChangedInteger
|
|
|
|
|
|
class StirrerTask(ATask):
|
|
def __init__(self, stirrer_device: AStirrer, interval, msg_handler: MsgIo):
|
|
ATask.__init__(self, interval)
|
|
self.msg_handler = msg_handler
|
|
msg_handler.set_recv_handler(self.recv)
|
|
self.device = stirrer_device
|
|
self._on_connected_changed = None
|
|
stirrer_device.set_on_changed("speed", self.on_speed_changed)
|
|
stirrer_device.set_on_changed("dutyCycle", self.on_dutycycle_changed)
|
|
stirrer_device.set_on_changed("cycleTime", self.on_cycletime_changed)
|
|
stirrer_device.set_on_changed("connected", self.on_connected_changed)
|
|
|
|
def on_speed_changed(self, value):
|
|
asyncio.create_task(self.send({'Speed': value}))
|
|
|
|
def on_dutycycle_changed(self, value):
|
|
asyncio.create_task(self.send({'DutyCycle': value}))
|
|
|
|
def on_cycletime_changed(self, value):
|
|
asyncio.create_task(self.send({'CycleTime': value}))
|
|
|
|
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)
|
|
|
|
async def recv(self, data):
|
|
for pair in data.items():
|
|
if pair[0] == 'Connect':
|
|
if self.device.connect():
|
|
self.device.activate(True)
|
|
elif pair[0] == 'Disconnect':
|
|
self.device.activate(False)
|
|
self.device.disconnect()
|
|
elif 'Speed' in pair[0]:
|
|
self.device.set_speed(pair[1])
|
|
|
|
async def send(self, data):
|
|
await self.msg_handler.send(data)
|
|
|
|
async def on_process(self):
|
|
await self.send({'Simulated': self.device.simulated})
|
|
|
|
self.device.set_speed(0.0)
|
|
self.device.set_cycle_time(10.0)
|
|
self.device.set_duty_cycle(1.0)
|
|
|
|
# Auto-connect on startup - see HeaterTask.on_process()'s own
|
|
# comment for why this replaces the old constructor-side connect.
|
|
self.device.connect()
|
|
# Explicit initial push - see HeaterTask.on_process()'s own comment
|
|
# for why a simulated device's connect() alone doesn't fire the
|
|
# observer.
|
|
await self.send({'Connected': self.device.connected})
|
|
|
|
# Outer retry loop - see HeaterTask.on_process()'s own comment for
|
|
# why: nothing restarts a dead ATask, so an exception escaping this
|
|
# coroutine entirely would permanently stop this device from ever
|
|
# being process()'d again, even after a later successful reconnect.
|
|
while True:
|
|
try:
|
|
with self.device.open():
|
|
while True:
|
|
try:
|
|
self.device.process()
|
|
except Exception as e:
|
|
print(f"StirrerTask: comm error, marking disconnected: {e}")
|
|
self.device.disconnect()
|
|
await asyncio.sleep(self.interval)
|
|
except Exception as e:
|
|
print(f"StirrerTask: unexpected error, recovering: {e}")
|
|
try:
|
|
self.device.disconnect()
|
|
except Exception:
|
|
pass
|
|
await asyncio.sleep(self.interval)
|