Real concurrently

WIP: handle KeyboardInterrupt

pytec/examples/aioexample.py

@@ -1,7 +1,19 @@
 import asyncio
+from contextlib import suppress
 from pytec.aioclient import AsyncioClient
 
 
+async def poll_for_info(tec):
+    while True:
+        print(tec.get_pwm())
+        print(tec.get_steinhart_hart())
+        print(tec.get_pid())
+        print(tec.get_postfilter())
+        print(tec.get_fan())
+
+        await asyncio.sleep(1)
+
+
 async def main():
     tec = AsyncioClient()
     await tec.connect()  # (host="192.168.1.26", port=23)
@@ -11,8 +23,14 @@ async def main():
     print(await tec.get_pwm())
     print(await tec.get_postfilter())
     print(await tec.get_steinhart_hart())
+
+    polling_task = asyncio.create_task(poll_for_info(tec))
+
     async for data in tec.report_mode():
         print(data)
 
+    polling_task.cancel()
+    with suppress(asyncio.CancelledError):
+        await polling_task
 
 asyncio.run(main())

pytec/pytec/gui/model/pid_autotuner.py

@@ -11,7 +11,6 @@ class PIDAutoTuner(QObject):
 
         self._thermostat = thermostat
         self._thermostat.report_update.connect(self.tick)
-        self._thermostat.interval_update.connect(self.update_sampling_interval)
 
         self.autotuners = [PIDAutotune(25) for _ in range(num_of_channel)]
         self.target_temp = [20.0 for _ in range(num_of_channel)]
@@ -20,10 +19,6 @@ class PIDAutoTuner(QObject):
         self.lookback = [3.0 for _ in range(num_of_channel)]
         self.sampling_interval = [1 / 16.67 for _ in range(num_of_channel)]
 
-    @pyqtSlot(list)
-    def update_sampling_interval(self, interval):
-        self.sampling_interval = interval
-
     def set_params(self, params_name, ch, val):
         getattr(self, params_name)[ch] = val
 
@@ -50,11 +45,14 @@ class PIDAutoTuner(QObject):
     @asyncSlot(list)
     async def tick(self, report):
         for channel_report in report:
+            ch = channel_report["channel"]
+
+            self.sampling_interval[ch] = channel_report["interval"]
+
             # TODO: Skip when PID Autotune or emit error message if NTC is not connected
             if channel_report["temperature"] is None:
                 continue
 
-            ch = channel_report["channel"]
             match self.autotuners[ch].state():
                 case (
                     PIDAutotuneState.STATE_READY

pytec/pytec/gui/model/thermostat.py

@@ -20,7 +20,6 @@ class Thermostat(QObject, metaclass=PropertyMeta):
     pid = Property(list)
     pwm = Property(list)
     postfilter = Property(list)
-    interval = Property(list)
     report = Property(list)
 
     connection_error = pyqtSignal()
@@ -54,36 +53,45 @@ class Thermostat(QObject, metaclass=PropertyMeta):
                         "Encountered an error while polling for information from Thermostat.",
                         exc_info=True,
                     )
-                    self.handle_connection_error()
+                    await self.handle_connection_error()
                     return
                 self._update_params_task = asyncio.create_task(self.update_params())
             await asyncio.sleep(self._update_s)
 
-    def handle_connection_error(self):
+    async def handle_connection_error(self):
-        self.end_session()
+        await self.end_session()
         self.connection_error.emit()
 
     async def get_hw_rev(self):
         return await self._client.hw_rev()
 
     async def update_params(self):
-        fan_task = asyncio.create_task(self._client.get_fan())
-        pwm_task = asyncio.create_task(self._client.get_pwm())
-        pid_task = asyncio.create_task(self._client.get_pid())
-        report_task = asyncio.create_task(self._client.report())
-        thermistor_task = asyncio.create_task(self._client.get_steinhart_hart())
-        postfilter_task = asyncio.create_task(self._client.get_postfilter())
-
-        self.fan = await fan_task
-        self.pwm = await pwm_task
         if self._poll_for_report:
-            self.report = await report_task
+            (
-            self.interval = [
+                self.fan,
-                self.report[i]["interval"] for i in range(len(self.report))
+                self.pwm,
-            ]
+                self.report,
-        self.pid = await pid_task
+                self.pid,
-        self.thermistor = await thermistor_task
+                self.thermistor,
-        self.postfilter = await postfilter_task
+                self.postfilter,
+            ) = await asyncio.gather(
+                self._client.get_fan(),
+                self._client.get_pwm(),
+                self._client.report(),
+                self._client.get_pid(),
+                self._client.get_steinhart_hart(),
+                self._client.get_postfilter(),
+            )
+        else:
+            self.fan, self.pwm, self.pid, self.thermistor, self.postfilter = (
+                await asyncio.gather(
+                    self._client.get_fan(),
+                    self._client.get_pwm(),
+                    self._client.get_pid(),
+                    self._client.get_steinhart_hart(),
+                    self._client.get_postfilter(),
+                )
+            )
 
     def connected(self):
         return self._client.connected()
@@ -110,9 +118,6 @@ class Thermostat(QObject, metaclass=PropertyMeta):
     async def report_mode(self):
         async for report in self._client.report_mode():
             self.report_update.emit(report)
-            self.interval = [
-                self.report[i]["interval"] for i in range(len(self.report))
-            ]
 
     @asyncSlot()
     async def end_session(self):

pytec/pytec/gui/view/ctrl_panel.py

@@ -285,19 +285,6 @@ class CtrlPanel(QObject):
                     f"Channel {ch} PID Autotune has failed.",
                 )
 
-    @asyncSlot()
-    async def pid_auto_tune_request(self, ch):
-        match self.autotuners.get_state(ch):
-            case PIDAutotuneState.STATE_OFF | PIDAutotuneState.STATE_FAILED:
-                self.autotuners.load_params_and_set_ready(ch)
-
-            case (
-                PIDAutotuneState.STATE_READY
-                | PIDAutotuneState.STATE_RELAY_STEP_UP
-                | PIDAutotuneState.STATE_RELAY_STEP_DOWN
-            ):
-                await self.autotuners.stop_pid_from_running(ch)
-
     @asyncSlot(int)
     async def load_settings(self, ch):
         await self.thermostat.load_cfg(ch)
@@ -316,3 +303,17 @@ class CtrlPanel(QObject):
             f"Channel {ch} settings has been saved to flash.\n"
             "It will be loaded on Thermostat reset, or when settings are explicitly loaded.",
         )
+
+    @asyncSlot()
+    async def pid_auto_tune_request(self, ch=0):
+        match self.autotuners.get_state(ch):
+            case PIDAutotuneState.STATE_OFF | PIDAutotuneState.STATE_FAILED:
+                self.autotuners.load_params_and_set_ready(ch)
+
+            case (
+                PIDAutotuneState.STATE_READY
+                | PIDAutotuneState.STATE_RELAY_STEP_UP
+                | PIDAutotuneState.STATE_RELAY_STEP_DOWN
+            ):
+                await self.autotuners.stop_pid_from_running(ch)
+

pytec/tec_qt.py

@@ -59,9 +59,7 @@ class MainWindow(QtWidgets.QMainWindow):
         self.info_box = InfoBox()
 
         # Models
-        self.thermostat = Thermostat(
+        self.thermostat = Thermostat(self, self.report_refresh_spin.value())
-            self, self.report_refresh_spin.value()
-        )
         self._connecting_task = None
         self.thermostat.connection_state_changed.connect(self._on_connection_changed)