ctrl_panel: Explain "SPS" in Postfilter tooltip

The Thermostat PID gains are actually in units relative to the sampling
interval of the Thermostat, and not SI seconds. Reflect that accordingly
in the units of PIDs.

See https://hackmd.io/IACbwcOTSt6Adj3_F9bKuw#Units for more details.

.gitignore

@@ -1,2 +1,3 @@
 target/
 result
+*.pyc

README.md

@@ -67,7 +67,19 @@ On a Windows machine install [st.com](https://st.com) DfuSe USB device firmware
 openocd -f interface/stlink.cfg -f target/stm32f4x.cfg -c "program target/thumbv7em-none-eabihf/release/thermostat verify reset;exit"
 ```
 
-## Network
+## GUI Usage
+
+A GUI has been developed for easy configuration and plotting of key parameters.
+
+The Python GUI program is located at pytec/tec_qt.py.
+
+The GUI is developed based on the Python library pyqtgraph. The GUI can be configured and launched automatically by running:
+
+```
+nix run .#thermostat_gui
+```
+
+## Command Line Usage
 
 ### Connecting
 

flake.nix

@@ -55,9 +55,64 @@
 
         dontFixup = true;
       };
+
+      qasync = pkgs.python3Packages.buildPythonPackage rec {
+        pname = "qasync";
+        version = "0.27.1";
+        format = "pyproject";
+        src = pkgs.fetchPypi {
+          inherit pname version;
+          hash = "sha256-jcdo/R7l3hBEx8MF7M8tOdJNh4A+pxGJ1AJPtHX0mF8=";
+        };
+        buildInputs = [ pkgs.python3Packages.poetry-core ];
+        propagatedBuildInputs = [ pkgs.python3Packages.pyqt6 ];
+      };
+
+      pyqtgraph = pkgs.python3Packages.buildPythonPackage rec {
+        pname = "pyqtgraph";
+        version = "0.13.3";
+        format = "pyproject";
+        src = pkgs.fetchPypi {
+          inherit pname version;
+          hash = "sha256-WBCNhBHHBU4IQdi3ke6F4QH8KWubNZwOAd3jipj/Ks4=";
+        };
+        propagatedBuildInputs = with pkgs.python3Packages; [ numpy pyqt6 ];
+      };
+
+      pglive = pkgs.python3Packages.buildPythonPackage rec {
+        pname = "pglive";
+        version = "0.7.2";
+        format = "pyproject";
+        src = pkgs.fetchPypi {
+          inherit pname version;
+          hash = "sha256-jqj8X6H1N5mJQ4OrY5ANqRB0YJByqg/bNneEALWmH1A=";
+        };
+        buildInputs = [ pkgs.python3Packages.poetry-core ];
+        propagatedBuildInputs = [ pyqtgraph pkgs.python3Packages.numpy ];
+      };
+
+      thermostat_gui = pkgs.python3Packages.buildPythonPackage {
+        pname = "thermostat_gui";
+        version = "0.0.0";
+        format = "pyproject";
+        src = "${self}/pytec";
+
+        nativeBuildInputs = [ pkgs.qt6.wrapQtAppsHook ];
+        propagatedBuildInputs = [ pkgs.qt6.qtbase ] ++ (with pkgs.python3Packages; [ pyqtgraph pyqt6 qasync pglive ]);
+
+        dontWrapQtApps = true;
+        postFixup = ''
+          wrapQtApp "$out/bin/tec_qt"
+        '';
+      };
     in {
       packages.x86_64-linux = {
-        inherit thermostat;
+        inherit thermostat thermostat_gui;
+      };
+
+      apps.x86_64-linux.thermostat_gui = {
+        type = "app";
+        program = "${self.packages.x86_64-linux.thermostat_gui}/bin/tec_qt";
       };
 
       hydraJobs = {
@@ -69,7 +124,7 @@
         buildInputs = with pkgs; [
           rust openocd dfu-util
           ] ++ (with python3Packages; [
-            numpy matplotlib
+            numpy matplotlib pyqtgraph setuptools pyqt6 qasync pglive
           ]);
       };
       defaultPackage.x86_64-linux = thermostat;

pytec/MANIFEST.in

@@ -0,0 +1,4 @@
+graft examples
+include pytec/gui/resources/artiq.ico
+include pytec/gui/view/param_tree.json
+include pytec/gui/view/tec_qt.ui

pytec/autotune.py

@@ -17,6 +17,7 @@ class PIDAutotuneState(Enum):
     STATE_RELAY_STEP_DOWN = 'relay step down'
     STATE_SUCCEEDED = 'succeeded'
     STATE_FAILED = 'failed'
+    STATE_READY = 'ready'
 
 
 class PIDAutotune:
@@ -56,6 +57,21 @@ class PIDAutotune:
         self._Ku = 0
         self._Pu = 0
 
+    def setParam(self, target, step, noiseband, sampletime, lookback):
+        self._setpoint = target
+        self._outputstep = step
+        self._out_max = step
+        self._out_min = -step
+        self._noiseband = noiseband
+        self._inputs = deque(maxlen=round(lookback / sampletime))
+
+    def setReady(self):
+        self._state = PIDAutotuneState.STATE_READY
+        self._peak_count = 0
+
+    def setOff(self):
+        self._state = PIDAutotuneState.STATE_OFF
+
     def state(self):
         """Get the current state."""
         return self._state
@@ -81,6 +97,13 @@ class PIDAutotune:
         kd = divisors[2] * self._Ku * self._Pu
         return PIDAutotune.PIDParams(kp, ki, kd)
 
+    def get_tec_pid (self):
+        divisors = self._tuning_rules["tyreus-luyben"]
+        kp = self._Ku * divisors[0]
+        ki = divisors[1] * self._Ku / self._Pu
+        kd = divisors[2] * self._Ku * self._Pu
+        return kp, ki, kd
+
     def run(self, input_val, time_input):
         """To autotune a system, this method must be called periodically.
 
@@ -95,7 +118,8 @@ class PIDAutotune:
 
         if (self._state == PIDAutotuneState.STATE_OFF
                 or self._state == PIDAutotuneState.STATE_SUCCEEDED
-                or self._state == PIDAutotuneState.STATE_FAILED):
+                or self._state == PIDAutotuneState.STATE_FAILED
+                or self._state == PIDAutotuneState.STATE_READY):
             self._state = PIDAutotuneState.STATE_RELAY_STEP_UP
 
         self._last_run_timestamp = now
@@ -199,20 +223,20 @@ class PIDAutotune:
             # calculate ultimate gain
             self._Ku = 4.0 * self._outputstep / \
                 (self._induced_amplitude * math.pi)
-            print('Ku: {0}'.format(self._Ku))
+            logging.debug('Ku: {0}'.format(self._Ku))
 
             # calculate ultimate period in seconds
             period1 = self._peak_timestamps[3] - self._peak_timestamps[1]
             period2 = self._peak_timestamps[4] - self._peak_timestamps[2]
             self._Pu = 0.5 * (period1 + period2) / 1000.0
-            print('Pu: {0}'.format(self._Pu))
+            logging.debug('Pu: {0}'.format(self._Pu))
 
             for rule in self._tuning_rules:
                 params = self.get_pid_parameters(rule)
-                print('rule: {0}'.format(rule))
+                logging.debug('rule: {0}'.format(rule))
-                print('Kp: {0}'.format(params.Kp))
+                logging.debug('Kp: {0}'.format(params.Kp))
-                print('Ki: {0}'.format(params.Ki))
+                logging.debug('Ki: {0}'.format(params.Ki))
-                print('Kd: {0}'.format(params.Kd))
+                logging.debug('Kd: {0}'.format(params.Kd))
 
             return True
         return False

pytec/examples/aioexample.py

@@ -0,0 +1,16 @@
+import asyncio
+from pytec.aioclient import Client
+
+async def main():
+    tec = Client()
+    await tec.start_session() #(host="192.168.1.26", port=23)
+    await tec.set_param("s-h", 1, "t0", 20)
+    print(await tec.get_pwm())
+    print(await tec.get_pid())
+    print(await tec.get_pwm())
+    print(await tec.get_postfilter())
+    print(await tec.get_steinhart_hart())
+    async for data in tec.report_mode():
+        print(data)
+
+asyncio.run(main())

pytec/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pytec"
+version = "0.0"
+authors = [{name = "M-Labs"}]
+description = "Control TEC"
+urls.Repository = "https://git.m-labs.hk/M-Labs/thermostat"
+license = {text = "GPLv3"}
+
+[project.gui-scripts]
+tec_qt = "tec_qt:main"
+
+[tool.setuptools]
+packages.find = {}
+py-modules = ["autotune", "plot", "tec_qt"]

pytec/pytec/aioclient.py

@@ -0,0 +1,279 @@
+import asyncio
+import json
+import logging
+
+class CommandError(Exception):
+    pass
+
+class StoppedConnecting(Exception):
+    pass
+
+class Client:
+    def __init__(self):
+        self._reader = None
+        self._writer = None
+        self._connecting_task = None
+        self._command_lock = asyncio.Lock()
+        self._report_mode_on = False
+        self.timeout = None
+
+    async def start_session(self, host='192.168.1.26', port=23, timeout=None):
+        """Start session to Thermostat at specified host and port.
+        Throws StoppedConnecting if disconnect was called while connecting.
+        Throws asyncio.TimeoutError if timeout was exceeded.
+
+        Example::
+            client = Client()
+            try:
+                await client.start_session()
+            except StoppedConnecting:
+                print("Stopped connecting")
+        """
+        self._connecting_task = asyncio.create_task(
+            asyncio.wait_for(asyncio.open_connection(host, port), timeout)
+        )
+        self.timeout = timeout
+        try:
+            self._reader, self._writer = await self._connecting_task
+        except asyncio.CancelledError:
+            raise StoppedConnecting
+        finally:
+            self._connecting_task = None
+
+        await self._check_zero_limits()
+
+    def connecting(self):
+        """Returns True if client is connecting"""
+        return self._connecting_task is not None
+
+    def connected(self):
+        """Returns True if client is connected"""
+        return self._writer is not None
+
+    async def end_session(self):
+        """End session to Thermostat if connected, cancel connection if connecting"""
+        if self._connecting_task is not None:
+            self._connecting_task.cancel()
+
+        if self._writer is None:
+            return
+
+        # Reader needn't be closed
+        self._writer.close()
+        await self._writer.wait_closed()
+        self._reader = None
+        self._writer = None
+
+    async def _check_zero_limits(self):
+        pwm_report = await self.get_pwm()
+        for pwm_channel in pwm_report:
+            for limit in ["max_i_neg", "max_i_pos", "max_v"]:
+                if pwm_channel[limit]["value"] == 0.0:
+                    logging.warning("`{}` limit is set to zero on channel {}".format(limit, pwm_channel["channel"]))
+
+    async def _read_line(self):
+        # read 1 line
+        chunk = await asyncio.wait_for(self._reader.readline(), self.timeout) # Only wait for response until timeout
+        return chunk.decode('utf-8', errors='ignore')
+
+    async def _read_write(self, command):
+        self._writer.write(((" ".join(command)).strip() + "\n").encode('utf-8'))
+        await self._writer.drain()
+
+        return await self._read_line()
+
+    async def _command(self, *command):
+        async with self._command_lock:
+            # protect the read-write process from being cancelled midway
+            line = await asyncio.shield(self._read_write(command))
+
+        response = json.loads(line)
+        logging.debug(f"{command}: {response}")
+        if "error" in response:
+            raise CommandError(response["error"])
+        return response
+
+    async def _get_conf(self, topic):
+        result = [None, None]
+        for item in await self._command(topic):
+            result[int(item["channel"])] = item
+        return result
+
+    async def get_pwm(self):
+        """Retrieve PWM limits for the TEC
+
+        Example::
+            [{'channel': 0,
+              'center': 'vref',
+              'i_set': {'max': 2.9802790335151985, 'value': -0.02002179650216762},
+              'max_i_neg': {'max': 3.0, 'value': 3.0},
+              'max_v': {'max': 5.988, 'value': 5.988},
+              'max_i_pos': {'max': 3.0, 'value': 3.0}},
+             {'channel': 1,
+              'center': 'vref',
+              'i_set': {'max': 2.9802790335151985, 'value': -0.02002179650216762},
+              'max_i_neg': {'max': 3.0, 'value': 3.0},
+              'max_v': {'max': 5.988, 'value': 5.988},
+              'max_i_pos': {'max': 3.0, 'value': 3.0}}
+            ]
+        """
+        return await self._get_conf("pwm")
+
+    async def get_pid(self):
+        """Retrieve PID control state
+
+        Example::
+            [{'channel': 0,
+              'parameters': {
+                  'kp': 10.0,
+                  'ki': 0.02,
+                  'kd': 0.0,
+                  'output_min': 0.0,
+                  'output_max': 3.0},
+              'target': 37.0},
+             {'channel': 1,
+              'parameters': {
+                  'kp': 10.0,
+                  'ki': 0.02,
+                  'kd': 0.0,
+                  'output_min': 0.0,
+                  'output_max': 3.0},
+              'target': 36.5}]
+        """
+        return await self._get_conf("pid")
+
+    async def get_steinhart_hart(self):
+        """Retrieve Steinhart-Hart parameters for resistance to temperature conversion
+
+        Example::
+            [{'params': {'b': 3800.0, 'r0': 10000.0, 't0': 298.15}, 'channel': 0},
+             {'params': {'b': 3800.0, 'r0': 10000.0, 't0': 298.15}, 'channel': 1}]
+        """
+        return await self._get_conf("s-h")
+
+    async def get_postfilter(self):
+        """Retrieve DAC postfilter configuration
+
+        Example::
+            [{'rate': None, 'channel': 0},
+             {'rate': 21.25, 'channel': 1}]
+        """
+        return await self._get_conf("postfilter")
+
+    async def get_fan(self):
+        """Get Thermostat current fan settings"""
+        return await self._command("fan")
+
+    async def report(self):
+        """Obtain one-time report on measurement values"""
+        return await self._command("report")
+
+    async def report_mode(self):
+        """Start reporting measurement values
+
+        Example of yielded data::
+            {'channel': 0,
+             'time': 2302524,
+             'adc': 0.6199188965423515,
+             'sens': 6138.519310282602,
+             'temperature': 36.87032392655527,
+             'pid_engaged': True,
+             'i_set': 2.0635816680889123,
+             'vref': 1.494,
+             'dac_value': 2.527790834044456,
+             'dac_feedback': 2.523,
+             'i_tec': 2.331,
+             'tec_i': 2.0925,
+             'tec_u_meas': 2.5340000000000003,
+             'pid_output': 2.067581958092247}
+        """
+        await self._command("report mode", "on")
+        self._report_mode_on = True
+
+        while self._report_mode_on:
+            async with self._command_lock:
+                line = await self._read_line()
+            if not line:
+                break
+            try:
+                yield json.loads(line)
+            except json.decoder.JSONDecodeError:
+                pass
+
+        await self._command("report mode", "off")
+
+    def stop_report_mode(self):
+        self._report_mode_on = False
+
+    async def set_param(self, topic, channel, field="", value=""):
+        """Set configuration parameters
+
+        Examples::
+            await tec.set_param("pwm", 0, "max_v", 2.0)
+            await tec.set_param("pid", 1, "output_max", 2.5)
+            await tec.set_param("s-h", 0, "t0", 20.0)
+            await tec.set_param("center", 0, "vref")
+            await tec.set_param("postfilter", 1, 21)
+
+        See the firmware's README.md for a full list.
+        """
+        if type(value) is float:
+            value = "{:f}".format(value)
+        if type(value) is not str:
+            value = str(value)
+        await self._command(topic, str(channel), field, value)
+
+    async def set_fan(self, power="auto"):
+        """Set fan power"""
+        await self._command("fan", str(power))
+
+    async def set_fcurve(self, a=1.0, b=0.0, c=0.0):
+        """Set fan curve"""
+        await self._command("fcurve", str(a), str(b), str(c))
+
+    async def power_up(self, channel, target):
+        """Start closed-loop mode"""
+        await self.set_param("pid", channel, "target", value=target)
+        await self.set_param("pwm", channel, "pid")
+
+    async def save_config(self, channel=""):
+        """Save current configuration to EEPROM"""
+        await self._command("save", str(channel))
+
+    async def load_config(self, channel=""):
+        """Load current configuration from EEPROM"""
+        await self._command("load", str(channel))
+        if channel == "":
+            await self._read_line() # Read the extra {}
+
+    async def hw_rev(self):
+        """Get Thermostat hardware revision"""
+        return await self._command("hwrev")
+
+    async def reset(self):
+        """Reset the Thermostat
+        
+        The client is disconnected as the TCP session is terminated.
+        """
+        async with self._command_lock:
+            self._writer.write("reset\n".encode('utf-8'))
+            await self._writer.drain()
+
+        await self.end_session()
+
+    async def dfu(self):
+        """Put the Thermostat in DFU update mode
+        
+        The client is disconnected as the Thermostat stops responding to
+        TCP commands in DFU update mode. The only way to exit it is by
+        power-cycling.
+        """
+        async with self._command_lock:
+            self._writer.write("dfu\n".encode('utf-8'))
+            await self._writer.drain()
+
+        await self.end_session()
+
+    async def ipv4(self):
+        """Get the IPv4 settings of the Thermostat"""
+        return await self._command('ipv4')

pytec/pytec/client.py

@@ -11,6 +11,10 @@ class Client:
         self._lines = [""]
         self._check_zero_limits()
 
+    def disconnect(self):
+        self._socket.shutdown(socket.SHUT_RDWR)
+        self._socket.close()
+
     def _check_zero_limits(self):
         pwm_report = self.get_pwm()
         for pwm_channel in pwm_report:
@@ -36,6 +40,7 @@ class Client:
 
         line = self._read_line()
         response = json.loads(line)
+        logging.debug(f"{command}: {response}")
         if "error" in response:
             raise CommandError(response["error"])
         return response
@@ -167,3 +172,11 @@ class Client:
     def load_config(self):
         """Load current configuration from EEPROM"""
         self._command("load")
+
+    def hw_rev(self):
+        """Get Thermostat hardware revision"""
+        return self._command("hwrev")
+
+    def fan(self):
+        """Get Thermostat current fan settings"""
+        return self._command("fan")

pytec/pytec/gui/model/pid_autotuner.py

@@ -0,0 +1,72 @@
+from PyQt6.QtCore import QObject, pyqtSlot
+from qasync import asyncSlot
+from autotune import PIDAutotuneState, PIDAutotune
+
+
+class PIDAutoTuner(QObject):
+    def __init__(self, parent, client, num_of_channel):
+        super().__init__()
+
+        self._client = client
+        self.autotuners = [PIDAutotune(25) for _ in range(num_of_channel)]
+        self.target_temp = [20.0 for _ in range(num_of_channel)]
+        self.test_current = [1.0 for _ in range(num_of_channel)]
+        self.temp_swing = [1.5 for _ in range(num_of_channel)]
+        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
+
+    def get_state(self, ch):
+        return self.autotuners[ch].state()
+
+    def load_params_and_set_ready(self, ch):
+        self.autotuners[ch].setParam(
+            self.target_temp[ch],
+            self.test_current[ch],
+            self.temp_swing[ch],
+            1 / self.sampling_interval[ch],
+            self.lookback[ch],
+        )
+        self.autotuners[ch].setReady()
+
+    async def stop_pid_from_running(self, ch):
+        self.autotuners[ch].setOff()
+        await self._client.set_param("pwm", ch, "i_set", 0)
+
+    @asyncSlot(list)
+    async def tick(self, report):
+        for channel_report in report:
+            # 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 | PIDAutotuneState.STATE_RELAY_STEP_UP | PIDAutotuneState.STATE_RELAY_STEP_DOWN:
+                    self.autotuners[ch].run(
+                        channel_report["temperature"], channel_report["time"]
+                    )
+                    await self._client.set_param(
+                        "pwm", ch, "i_set", self.autotuners[ch].output()
+                    )
+                case PIDAutotuneState.STATE_SUCCEEDED:
+                    kp, ki, kd = self.autotuners[ch].get_tec_pid()
+                    self.autotuners[ch].setOff()
+
+                    await self._client.set_param("pid", ch, "kp", kp)
+                    await self._client.set_param("pid", ch, "ki", ki)
+                    await self._client.set_param("pid", ch, "kd", kd)
+                    await self._client.set_param("pwm", ch, "pid")
+
+                    await self._client.set_param(
+                        "pid", ch, "target", self.target_temp[ch]
+                    )
+                case PIDAutotuneState.STATE_FAILED:
+                    self.autotuners[ch].setOff()
+                    await self._client.set_param("pwm", ch, "i_set", 0)

pytec/pytec/gui/model/property.py

@@ -0,0 +1,126 @@
+# A Custom Class that allows defining a QObject Property Dynamically
+# Adapted from: https://stackoverflow.com/questions/48425316/how-to-create-pyqt-properties-dynamically
+
+from functools import wraps
+
+from PyQt6.QtCore import QObject, pyqtProperty, pyqtSignal
+
+
+class PropertyMeta(type(QObject)):
+    """Lets a class succinctly define Qt properties."""
+
+    def __new__(cls, name, bases, attrs):
+        for key in list(attrs.keys()):
+            attr = attrs[key]
+            if not isinstance(attr, Property):
+                continue
+
+            types = {list: "QVariantList", dict: "QVariantMap"}
+            type_ = types.get(attr.type_, attr.type_)
+
+            notifier = pyqtSignal(type_)
+            attrs[f"{key}_update"] = notifier
+            attrs[key] = PropertyImpl(type_=type_, name=key, notify=notifier)
+
+        return super().__new__(cls, name, bases, attrs)
+
+
+class Property:
+    """Property definition.
+
+    Instances of this class will be replaced with their full
+    implementation by the PropertyMeta metaclass.
+    """
+
+    def __init__(self, type_):
+        self.type_ = type_
+
+
+class PropertyImpl(pyqtProperty):
+    """Property implementation: gets, sets, and notifies of change."""
+
+    def __init__(self, type_, name, notify):
+        super().__init__(type_, self.getter, self.setter, notify=notify)
+        self.name = name
+
+    def getter(self, instance):
+        return getattr(instance, f"_{self.name}")
+
+    def setter(self, instance, value):
+        signal = getattr(instance, f"{self.name}_update")
+
+        if type(value) in {list, dict}:
+            value = make_notified(value, signal)
+
+        setattr(instance, f"_{self.name}", value)
+        signal.emit(value)
+
+
+class MakeNotified:
+    """Adds notifying signals to lists and dictionaries.
+
+    Creates the modified classes just once, on initialization.
+    """
+
+    change_methods = {
+        list: [
+            "__delitem__",
+            "__iadd__",
+            "__imul__",
+            "__setitem__",
+            "append",
+            "extend",
+            "insert",
+            "pop",
+            "remove",
+            "reverse",
+            "sort",
+        ],
+        dict: [
+            "__delitem__",
+            "__ior__",
+            "__setitem__",
+            "clear",
+            "pop",
+            "popitem",
+            "setdefault",
+            "update",
+        ],
+    }
+
+    def __init__(self):
+        if not hasattr(dict, "__ior__"):
+            # Dictionaries don't have | operator in Python < 3.9.
+            self.change_methods[dict].remove("__ior__")
+        self.notified_class = {
+            type_: self.make_notified_class(type_) for type_ in [list, dict]
+        }
+
+    def __call__(self, seq, signal):
+        """Returns a notifying version of the supplied list or dict."""
+        notified_class = self.notified_class[type(seq)]
+        notified_seq = notified_class(seq)
+        notified_seq.signal = signal
+        return notified_seq
+
+    @classmethod
+    def make_notified_class(cls, parent):
+        notified_class = type(f"notified_{parent.__name__}", (parent,), {})
+        for method_name in cls.change_methods[parent]:
+            original = getattr(notified_class, method_name)
+            notified_method = cls.make_notified_method(original, parent)
+            setattr(notified_class, method_name, notified_method)
+        return notified_class
+
+    @staticmethod
+    def make_notified_method(method, parent):
+        @wraps(method)
+        def notified_method(self, *args, **kwargs):
+            result = getattr(parent, method.__name__)(self, *args, **kwargs)
+            self.signal.emit(self)
+            return result
+
+        return notified_method
+
+
+make_notified = MakeNotified()

pytec/pytec/gui/model/thermostat.py

@@ -0,0 +1,138 @@
+from pytec.aioclient import Client
+from PyQt6.QtCore import pyqtSignal, QObject, pyqtSlot
+from qasync import asyncSlot
+from pytec.gui.model.property import Property, PropertyMeta
+import asyncio
+import logging
+
+
+class WrappedClient(QObject, Client):
+    connection_error = pyqtSignal()
+
+    async def _read_line(self):
+        try:
+            return await super()._read_line()
+        except (Exception, TimeoutError, asyncio.exceptions.TimeoutError):
+            logging.error("Client connection error, disconnecting", exc_info=True)
+            self.connection_error.emit()
+
+
+class Thermostat(QObject, metaclass=PropertyMeta):
+    hw_rev = Property(dict)
+    fan = Property(dict)
+    thermistor = Property(list)
+    pid = Property(list)
+    pwm = Property(list)
+    postfilter = Property(list)
+    interval = Property(list)
+    report = Property(list)
+    info_box_trigger = pyqtSignal(str, str)
+
+    def __init__(self, parent, client, update_s):
+        self._update_s = update_s
+        self._client = client
+        self._watch_task = None
+        self._report_mode_task = None
+        self._poll_for_report = True
+        super().__init__(parent)
+
+    async def run(self):
+        self.task = asyncio.create_task(self.update_params())
+        while True:
+            if self.task.done():
+                if self.task.exception() is not None:
+                    try:
+                        raise self.task.exception()
+                    except (
+                        Exception,
+                        TimeoutError,
+                        asyncio.exceptions.TimeoutError,
+                    ):
+                        logging.error(
+                            "Encountered an error while updating parameter tree.",
+                            exc_info=True,
+                        )
+                _ = self.task.result()
+                self.task = asyncio.create_task(self.update_params())
+            await asyncio.sleep(self._update_s)
+
+    async def get_hw_rev(self):
+        self.hw_rev = await self._client.hw_rev()
+        return self.hw_rev
+
+    async def update_params(self):
+        self.fan = await self._client.get_fan()
+        self.pwm = await self._client.get_pwm()
+        if self._poll_for_report:
+            self.report = await self._client.report()
+            self.interval = [
+                self.report[i]["interval"] for i in range(len(self.report))
+            ]
+        self.pid = await self._client.get_pid()
+        self.thermistor = await self._client.get_steinhart_hart()
+        self.postfilter = await self._client.get_postfilter()
+
+    def connected(self):
+        return self._client.connected
+
+    def connecting(self):
+        return self._client.connecting
+
+    def start_watching(self):
+        self._watch_task = asyncio.create_task(self.run())
+
+    @asyncSlot()
+    async def stop_watching(self):
+        if self._watch_task is not None:
+            await self.set_report_mode(False)
+            self._watch_task.cancel()
+            self._watch_task = None
+            self.task.cancel()
+            self.task = None
+
+    async def set_report_mode(self, enabled: bool):
+        self._poll_for_report = not enabled
+        if enabled:
+            self._report_mode_task = asyncio.create_task(self.report_mode())
+        else:
+            self._client.stop_report_mode()
+
+    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))
+            ]
+
+    async def end_session(self):
+        await self._client.end_session()
+
+    async def set_ipv4(self, ipv4):
+        await self._client.set_param("ipv4", ipv4)
+
+    async def get_ipv4(self):
+        return await self._client.ipv4()
+
+    @asyncSlot()
+    async def save_cfg(self, ch):
+        await self._client.save_config(ch)
+        self.info_box_trigger.emit(
+            "Settings saved", f"Channel {ch} Settings has been saved to flash."
+        )
+
+    @asyncSlot()
+    async def load_cfg(self, ch):
+        await self._client.load_config(ch)
+        self.info_box_trigger.emit(
+            "Settings loaded", f"Channel {ch} Settings has been loaded from flash."
+        )
+
+    async def dfu(self):
+        await self._client.dfu()
+
+    async def reset(self):
+        await self._client.reset()
+
+    @pyqtSlot(float)
+    def set_update_s(self, update_s):
+        self._update_s = update_s

pytec/pytec/gui/view/conn_menu.py

@@ -0,0 +1,56 @@
+from PyQt6 import QtWidgets, QtCore
+
+
+class ConnMenu(QtWidgets.QMenu):
+    def __init__(self):
+        super().__init__()
+        self.setTitle("Connection Settings")
+
+        self.host_set_line = QtWidgets.QLineEdit()
+        self.host_set_line.setMinimumSize(QtCore.QSize(160, 0))
+        self.host_set_line.setMaximumSize(QtCore.QSize(160, 16777215))
+        self.host_set_line.setMaxLength(15)
+        self.host_set_line.setClearButtonEnabled(True)
+
+        def connect_on_enter_press():
+            self.connect_btn.click()
+            self.hide()
+
+        self.host_set_line.returnPressed.connect(connect_on_enter_press)
+
+        self.host_set_line.setText("192.168.1.26")
+        self.host_set_line.setPlaceholderText("IP for the Thermostat")
+
+        host = QtWidgets.QWidgetAction(self)
+        host.setDefaultWidget(self.host_set_line)
+        self.addAction(host)
+        self.host = host
+
+        self.port_set_spin = QtWidgets.QSpinBox()
+        self.port_set_spin.setMinimumSize(QtCore.QSize(70, 0))
+        self.port_set_spin.setMaximumSize(QtCore.QSize(70, 16777215))
+        self.port_set_spin.setMaximum(65535)
+        self.port_set_spin.setValue(23)
+
+        def connect_only_if_enter_pressed():
+            if (
+                not self.port_set_spin.hasFocus()
+            ):  # Don't connect if the spinbox only lost focus
+                return
+            connect_on_enter_press()
+
+        self.port_set_spin.editingFinished.connect(connect_only_if_enter_pressed)
+
+        port = QtWidgets.QWidgetAction(self)
+        port.setDefaultWidget(self.port_set_spin)
+        self.addAction(port)
+        self.port = port
+
+        self.exit_button = QtWidgets.QPushButton()
+        self.exit_button.setText("Exit GUI")
+        self.exit_button.pressed.connect(QtWidgets.QApplication.instance().quit)
+
+        exit_action = QtWidgets.QWidgetAction(self.exit_button)
+        exit_action.setDefaultWidget(self.exit_button)
+        self.addAction(exit_action)
+        self.exit_action = exit_action

pytec/pytec/gui/view/ctrl_panel.py

@@ -0,0 +1,177 @@
+from PyQt6.QtCore import pyqtSignal, QObject, QSignalBlocker, pyqtSlot
+import pyqtgraph.parametertree.parameterTypes as pTypes
+from pyqtgraph.parametertree import (
+    Parameter,
+    registerParameterType,
+)
+import pytec.gui.view.lockable_unit
+
+
+def set_tree_label_tips(tree):
+    for item in tree.listAllItems():
+        p = item.param
+        if "tip" in p.opts:
+            item.setToolTip(0, p.opts["tip"])
+
+
+class CtrlPanel(QObject):
+    set_zero_limits_warning_sig = pyqtSignal(list)
+
+    def __init__(
+        self,
+        trees_ui,
+        param_tree,
+        sigTreeStateChanged_handle,
+        sigActivated_handles,
+        parent=None,
+    ):
+        super().__init__(parent)
+
+        self.trees_ui = trees_ui
+        self.NUM_CHANNELS = len(trees_ui)
+
+        def _set_value_with_lock(self, value):
+            if not self.opts.get("lock"):
+                self.setValue(value)
+        Parameter.set_value_with_lock = _set_value_with_lock
+
+        self.params = [
+            Parameter.create(
+                name=f"Thermostat Channel {ch} Parameters",
+                type="group",
+                value=ch,
+                children=param_tree,
+            )
+            for ch in range(self.NUM_CHANNELS)
+        ]
+
+        for ch, tree in enumerate(self.trees_ui):
+            tree.setHeaderHidden(True)
+            tree.setParameters(self.params[ch], showTop=False)
+
+            set_tree_label_tips(tree)
+
+        for ch, param in enumerate(self.params):
+            param.sigTreeStateChanged.connect(sigTreeStateChanged_handle)
+
+            for handle in sigActivated_handles[ch]:
+                param.child(*handle[0]).sigActivated.connect(handle[1])
+
+            def _indicate_usage(param, control_method="constant_current"):
+                for item in param.child("i_set").items:
+                    is_constant_current = control_method == "constant_current"
+                    font = item.font(0)
+                    font.setUnderline(is_constant_current)
+                    font.setBold(is_constant_current)
+                    item.setFont(0, font)
+                for item in param.child("target").items:
+                    is_temperature_pid = control_method == "temperature_pid"
+                    font = item.font(0)
+                    font.setUnderline(is_temperature_pid)
+                    font.setBold(is_temperature_pid)
+                    item.setFont(0, font)
+
+            param.child("output", "control_method").sigValueChanged.connect(
+                _indicate_usage
+            )
+            _indicate_usage(param.child("output", "control_method"))
+
+            for item in param.child("output", "control_method").items:
+                font = item.font(0)
+                font.setBold(True)
+                item.setFont(0, font)
+
+    def change_params_title(self, channel, path, title):
+        self.params[channel].child(*path).setOpts(title=title)
+
+    @pyqtSlot("QVariantList")
+    def update_pid(self, pid_settings):
+        for settings in pid_settings:
+            channel = settings["channel"]
+            with QSignalBlocker(self.params[channel]):
+                self.params[channel].child("pid", "kp").set_value_with_lock(
+                    settings["parameters"]["kp"]
+                )
+                self.params[channel].child("pid", "ki").set_value_with_lock(
+                    settings["parameters"]["ki"]
+                )
+                self.params[channel].child("pid", "kd").set_value_with_lock(
+                    settings["parameters"]["kd"]
+                )
+                self.params[channel].child(
+                    "pid", "pid_output_clamping", "output_min"
+                ).set_value_with_lock(settings["parameters"]["output_min"])
+                self.params[channel].child(
+                    "pid", "pid_output_clamping", "output_max"
+                ).set_value_with_lock(settings["parameters"]["output_max"])
+                self.params[channel].child(
+                    "output", "control_method", "target"
+                ).set_value_with_lock(settings["target"])
+
+    @pyqtSlot("QVariantList")
+    def update_report(self, report_data):
+        for settings in report_data:
+            channel = settings["channel"]
+            with QSignalBlocker(self.params[channel]):
+                self.params[channel].child(
+                    "output", "control_method"
+                ).set_value_with_lock(
+                    "temperature_pid" if settings["pid_engaged"] else "constant_current"
+                )
+                self.params[channel].child(
+                    "output", "control_method", "i_set"
+                ).set_value_with_lock(settings["i_set"])
+                if settings["temperature"] is not None:
+                    self.params[channel].child(
+                        "readings", "temperature"
+                    ).set_value_with_lock(settings["temperature"])
+                    if settings["tec_i"] is not None:
+                        self.params[channel].child(
+                            "readings", "tec_i"
+                        ).set_value_with_lock(settings["tec_i"])
+
+    @pyqtSlot("QVariantList")
+    def update_thermistor(self, sh_data):
+        for sh_param in sh_data:
+            channel = sh_param["channel"]
+            with QSignalBlocker(self.params[channel]):
+                self.params[channel].child("thermistor", "t0").set_value_with_lock(
+                    sh_param["params"]["t0"] - 273.15
+                )
+                self.params[channel].child("thermistor", "r0").set_value_with_lock(
+                    sh_param["params"]["r0"]
+                )
+                self.params[channel].child("thermistor", "b").set_value_with_lock(
+                    sh_param["params"]["b"]
+                )
+
+    @pyqtSlot("QVariantList")
+    def update_pwm(self, pwm_data):
+        channels_zeroed_limits = [set() for i in range(self.NUM_CHANNELS)]
+
+        for pwm_params in pwm_data:
+            channel = pwm_params["channel"]
+            with QSignalBlocker(self.params[channel]):
+                self.params[channel].child(
+                    "output", "limits", "max_v"
+                ).set_value_with_lock(pwm_params["max_v"]["value"])
+                self.params[channel].child(
+                    "output", "limits", "max_i_pos"
+                ).set_value_with_lock(pwm_params["max_i_pos"]["value"])
+                self.params[channel].child(
+                    "output", "limits", "max_i_neg"
+                ).set_value_with_lock(pwm_params["max_i_neg"]["value"])
+
+            for limit in "max_i_pos", "max_i_neg", "max_v":
+                if pwm_params[limit]["value"] == 0.0:
+                    channels_zeroed_limits[channel].add(limit)
+        self.set_zero_limits_warning_sig.emit(channels_zeroed_limits)
+
+    @pyqtSlot("QVariantList")
+    def update_postfilter(self, postfilter_data):
+        for postfilter_params in postfilter_data:
+            channel = postfilter_params["channel"]
+            with QSignalBlocker(self.params[channel]):
+                self.params[channel].child("postfilter", "rate").set_value_with_lock(
+                    postfilter_params["rate"]
+                )

pytec/pytec/gui/view/info_box.py

@@ -0,0 +1,14 @@
+from PyQt6 import QtWidgets
+from PyQt6.QtCore import pyqtSlot
+
+
+class InfoBox(QtWidgets.QMessageBox):
+    def __init__(self):
+        super().__init__()
+        self.setIcon(QtWidgets.QMessageBox.Icon.Information)
+    
+    @pyqtSlot(str, str)
+    def display_info_box(self, title, text):
+        self.setWindowTitle(title)
+        self.setText(text)
+        self.show()

pytec/pytec/gui/view/live_plot_view.py

@@ -0,0 +1,169 @@
+from PyQt6.QtCore import QObject, pyqtSlot
+from pglive.sources.data_connector import DataConnector
+from pglive.kwargs import Axis
+from pglive.sources.live_plot import LiveLinePlot
+from pglive.sources.live_axis import LiveAxis
+from collections import deque
+import pyqtgraph as pg
+
+pg.setConfigOptions(antialias=True)
+
+
+class LiveDataPlotter(QObject):
+    def __init__(self, live_plots):
+        super().__init__()
+
+        self.NUM_CHANNELS = len(live_plots)
+        self.graphs = []
+
+        for i, live_plot in enumerate(live_plots):
+            live_plot[0].setTitle(f"Channel {i} Temperature")
+            live_plot[1].setTitle(f"Channel {i} Current")
+            self.graphs.append(_TecGraphs(live_plot[0], live_plot[1]))
+
+    def _config_connector_max_pts(self, connector, samples):
+        connector.max_points = samples
+        connector.x = deque(maxlen=int(connector.max_points))
+        connector.y = deque(maxlen=int(connector.max_points))
+
+    @pyqtSlot(int)
+    def set_max_samples(self, samples: int):
+        for graph in self.graphs:
+            self._config_connector_max_pts(graph.t_connector, samples)
+            self._config_connector_max_pts(graph.i_connector, samples)
+            self._config_connector_max_pts(graph.iset_connector, samples)
+
+    @pyqtSlot()
+    def clear_graphs(self):
+        for graph in self.graphs:
+            graph.clear()
+
+    @pyqtSlot(list)
+    def update_pid(self, pid_settings):
+        for settings in pid_settings:
+            channel = settings["channel"]
+            self.graphs[channel].update_pid(settings)
+
+    @pyqtSlot(list)
+    def update_report(self, report_data):
+        for settings in report_data:
+            channel = settings["channel"]
+            self.graphs[channel].update_report(settings)
+
+
+class _TecGraphs:
+    """The maximum number of sample points to store."""
+
+    DEFAULT_MAX_SAMPLES = 1000
+
+    def __init__(self, t_widget, i_widget):
+        self._t_widget = t_widget
+        self._i_widget = i_widget
+
+        self._t_plot = LiveLinePlot()
+        self._i_plot = LiveLinePlot(name="Measured")
+        self._iset_plot = LiveLinePlot(name="Set", pen=pg.mkPen("r"))
+
+        self._t_line = self._t_widget.getPlotItem().addLine(label="{value} °C")
+        self._t_line.setVisible(False)
+        # Hack for keeping setpoint line in plot range
+        self._t_setpoint_plot = (
+            LiveLinePlot()
+        )
+
+        for graph in t_widget, i_widget:
+            time_axis = LiveAxis(
+                "bottom",
+                text="Time since Thermostat reset",
+                **{Axis.TICK_FORMAT: Axis.DURATION},
+            )
+            time_axis.showLabel()
+            graph.setAxisItems({"bottom": time_axis})
+
+            graph.add_crosshair(pg.mkPen(color="red", width=1), {"color": "green"})
+
+            # Enable linking of axes in the graph widget's context menu
+            graph.register(
+                graph.getPlotItem().titleLabel.text  # Slight hack getting the title
+            )
+
+        temperature_axis = LiveAxis("left", text="Temperature", units="°C")
+        temperature_axis.showLabel()
+        t_widget.setAxisItems({"left": temperature_axis})
+
+        current_axis = LiveAxis("left", text="Current", units="A")
+        current_axis.showLabel()
+        i_widget.setAxisItems({"left": current_axis})
+        i_widget.addLegend(brush=(50, 50, 200, 150))
+
+        t_widget.addItem(self._t_plot)
+        t_widget.addItem(self._t_setpoint_plot)
+        i_widget.addItem(self._i_plot)
+        i_widget.addItem(self._iset_plot)
+
+        self.t_connector = DataConnector(
+            self._t_plot, max_points=self.DEFAULT_MAX_SAMPLES
+        )
+        self.t_setpoint_connector = DataConnector(self._t_setpoint_plot, max_points=1)
+        self.i_connector = DataConnector(
+            self._i_plot, max_points=self.DEFAULT_MAX_SAMPLES
+        )
+        self.iset_connector = DataConnector(
+            self._iset_plot, max_points=self.DEFAULT_MAX_SAMPLES
+        )
+
+        self.max_samples = self.DEFAULT_MAX_SAMPLES
+
+    def plot_append(self, report):
+        temperature = report["temperature"]
+        current = report["tec_i"]
+        iset = report["i_set"]
+        time = report["time"]
+
+        if temperature is not None:
+            self.t_connector.cb_append_data_point(temperature, time)
+            if self._t_line.isVisible():
+                self.t_setpoint_connector.cb_append_data_point(
+                    self._t_line.value(), time
+                )
+            else:
+                self.t_setpoint_connector.cb_append_data_point(temperature, time)
+            if current is not None:
+                self.i_connector.cb_append_data_point(current, time)
+            self.iset_connector.cb_append_data_point(iset, time)
+
+    def set_max_sample(self, samples: int):
+        for connector in self.t_connector, self.i_connector, self.iset_connector:
+            connector.max_points(samples)
+
+    def clear(self):
+        for connector in self.t_connector, self.i_connector, self.iset_connector:
+            connector.clear()
+
+    def set_t_line(self, temp=None, visible=None):
+        if visible is not None:
+            self._t_line.setVisible(visible)
+        if temp is not None:
+            self._t_line.setValue(temp)
+
+            # PyQtGraph normally does not update this text when the line
+            # is not visible, so make sure that the temperature label
+            # gets updated always, and doesn't stay at an old value.
+            self._t_line.label.setText(f"{temp} °C")
+
+    def set_max_samples(self, samples: int):
+        for graph in self.graphs:
+            graph.t_connector.max_points = samples
+            graph.i_connector.max_points = samples
+            graph.iset_connector.max_points = samples
+
+    def clear_graphs(self):
+        for graph in self.graphs:
+            graph.clear()
+
+    def update_pid(self, pid_settings):
+        self.set_t_line(temp=round(pid_settings["target"], 6))
+
+    def update_report(self, report_data):
+        self.plot_append(report_data)
+        self.set_t_line(visible=report_data["pid_engaged"])

pytec/pytec/gui/view/lockable_unit.py

@@ -0,0 +1,185 @@
+import re
+
+from PyQt6.QtCore import QSignalBlocker
+from PyQt6.QtGui import QValidator
+
+from pyqtgraph import SpinBox
+import pyqtgraph.functions as fn
+from pyqtgraph.parametertree import registerParameterItemType
+from pyqtgraph.parametertree.parameterTypes import SimpleParameter, NumericParameterItem
+
+
+# See https://github.com/pyqtgraph/pyqtgraph/issues/3115
+fn.FLOAT_REGEX = re.compile(
+    r"(?P<number>[+-]?((((\d+(\.\d*)?)|(\d*\.\d+))([eE][+-]?\d+)?)|((?i:nan)|(inf))))\s*"
+    + r"((?P<siPrefix>[u" + fn.SI_PREFIXES + r"]?)(?P<suffix>.*))?$"
+)
+
+
+class LockableUnitSpinBox(SpinBox):
+    """
+    Extension of PyQtGraph's SpinBox widget.
+    Adds:
+
+      * The "pinSiPrefix" option, where the siPrefix could be fixed to a
+        particular scale instead of as determined by its value.
+      * The "noUnitEditing" option, where the suffix and pinned siPrefix
+        of the SpinBox text is fixed and uneditable.
+    """
+
+    def __init__(self, parent=None, value=0.0, **kwargs):
+        super().__init__(parent, value, **kwargs)
+
+        self.lineEdit().cursorPositionChanged.connect(
+            self._editor_cursor_position_changed
+        )
+
+    def validate(self, strn, pos):
+        ret, strn, pos = super().validate(strn, pos)
+
+        if self.opts.get("noUnitEditing") is True:
+            suffix = self.opts["suffix"]
+            pinned_si_prefix = self.opts.get("pinSiPrefix")
+
+            suffix_edited = not strn.endswith(suffix)
+            pinned_si_prefix_edited = (
+                pinned_si_prefix is not None
+                and not strn.removesuffix(suffix).endswith(pinned_si_prefix)
+            )
+
+            if suffix_edited or pinned_si_prefix_edited:
+                ret = QValidator.State.Invalid
+
+        return ret, strn, pos
+
+    def _editor_cursor_position_changed(self, oldpos, newpos):
+        # Called on cursor position change
+        # Skips over the suffix and pinned SI prefix on cursor navigation if option
+        # noUnitEditing is enabled.
+
+        # Modified from the original Qt C++ source,
+        # QAbstractSpinBox::editorCursorPositionChanged.
+        # Their suffix is different than our suffix; there's no obvious way to set
+        # theirs here in the derived class since it is private.
+
+        if self.opts.get("noUnitEditing") is True:
+            edit = self.lineEdit()
+            if edit.hasSelectedText():
+                return  # Allow for selecting units, for copy-and-paste
+
+            pinned_si_prefix = self.opts.get("pinSiPrefix") or ""
+            unit_len = len(pinned_si_prefix) + len(self.opts["suffix"])
+            text_len = len(edit.text())
+
+            pos = -1
+            # Cursor in unit
+            if text_len - unit_len < newpos < text_len:
+                if oldpos == text_len:
+                    pos = text_len - unit_len
+                else:
+                    pos = text_len
+
+            if pos != -1:
+                with QSignalBlocker(edit):
+                    edit.setCursorPosition(pos)
+
+    def setOpts(self, **opts):
+        if "pinSiPrefix" in opts:
+            self.opts["pinSiPrefix"] = opts.pop("pinSiPrefix")
+        if "noUnitEditing" in opts:
+            self.opts["noUnitEditing"] = opts.pop("noUnitEditing")
+
+        super().setOpts(**opts)
+
+    def editingFinishedEvent(self):
+        # Modified from pyqtgraph.SpinBox.editingFinishedEvent source
+
+        new_text = self.lineEdit().text()
+        if new_text == self.lastText:
+            return
+        try:
+            val = self.interpret()
+        except Exception:
+            return
+
+        if val is False:
+            return
+        if val == self.val:
+            self.updateText()  # still update text so that values are reformatted pretty-like
+            return
+        self.setValue(val, delaySignal=False)  ## allow text update so that values are reformatted pretty-like
+
+    def formatText(self, prev=None):
+        """
+        In addition to pyqtgraph.SpinBox's formatting, incorporate the
+        'pinSiPrefix' mechanism, where SI prefixes could be fixed.
+        """
+        # Code modified from the PyQtGraph source
+
+        # get the number of decimal places to print
+        decimals = self.opts['decimals']
+        suffix = self.opts['suffix']
+        prefix = self.opts['prefix']
+        pin_si_prefix = self.opts.get("pinSiPrefix")
+
+        # format the string
+        val = self.value()
+        if self.opts['siPrefix'] is True:
+            # SI prefix was requested, so scale the value accordingly
+            if pin_si_prefix is not None and pin_si_prefix in fn.SI_PREFIX_EXPONENTS:
+                # fixed scale
+                s = 10**-fn.SI_PREFIX_EXPONENTS[pin_si_prefix]
+                p = pin_si_prefix
+            elif self.val == 0 and prev is not None:
+                # special case: if it's zero use the previous prefix
+                (s, p) = fn.siScale(prev)
+            else:
+                (s, p) = fn.siScale(val)
+            parts = {'value': val, 'suffix': suffix, 'decimals': decimals, 'siPrefix': p, 'scaledValue': s*val, 'prefix':prefix}
+
+        else:
+            # no SI prefix /suffix requested; scale is 1
+            parts = {'value': val, 'suffix': suffix, 'decimals': decimals, 'siPrefix': '', 'scaledValue': val, 'prefix':prefix}
+
+        parts['prefixGap'] = '' if parts['prefix'] == '' else ' '
+        parts['suffixGap'] = '' if (parts['suffix'] == '' and parts['siPrefix'] == '') else ' '
+
+        return self.opts['format'].format(**parts)
+
+
+class UnitfulNumericParameterItem(NumericParameterItem):
+    """
+    Subclasses PyQtGraph's `NumericParameterItem` and uses
+    UnitfulSpinBox for editing.
+    """
+
+    def makeWidget(self):
+        opts = self.param.opts
+        t = opts['type']
+        defs = {
+            'value': 0, 'min': None, 'max': None,
+            'step': 1.0, 'dec': False,
+            'siPrefix': False, 'suffix': '', 'decimals': 3,
+            'pinSiPrefix': None, 'noUnitEditing': False,
+        }
+        if t == 'int':
+            defs['int'] = True
+            defs['minStep'] = 1.0
+        for k in defs:
+            if k in opts:
+                defs[k] = opts[k]
+        if 'limits' in opts:
+            defs['min'], defs['max'] = opts['limits']
+        w = LockableUnitSpinBox()
+        w.setOpts(**defs)
+        w.sigChanged = w.sigValueChanged
+        w.sigChanging = w.sigValueChanging
+        return w
+
+
+registerParameterItemType(
+    "float", UnitfulNumericParameterItem, SimpleParameter, override=True
+)
+registerParameterItemType(
+    "int", UnitfulNumericParameterItem, SimpleParameter, override=True
+)

pytec/pytec/gui/view/net_settings_input_diag.py

@@ -0,0 +1,36 @@
+from PyQt6 import QtWidgets
+from PyQt6.QtWidgets import QAbstractButton
+from PyQt6.QtCore import pyqtSignal, pyqtSlot
+
+
+class NetSettingsInputDiag(QtWidgets.QInputDialog):
+    set_ipv4_act = pyqtSignal(str)
+
+    def __init__(self, current_ipv4_settings):
+        super().__init__()
+        self.setWindowTitle("Network Settings")
+        self.setLabelText(
+            "Set the Thermostat's IPv4 address, netmask and gateway (optional)"
+        )
+        self.setTextValue(current_ipv4_settings)
+        self._new_ipv4 = ""
+
+        @pyqtSlot(str)
+        def set_ipv4(ipv4_settings):
+            self._new_ipv4 = ipv4_settings
+
+            sure = QtWidgets.QMessageBox(self)
+            sure.setWindowTitle("Set network?")
+            sure.setText(
+                f"Setting this as network and disconnecting:<br>{ipv4_settings}"
+            )
+
+            sure.buttonClicked.connect(self._emit_sig)
+            sure.show()
+
+        self.textValueSelected.connect(set_ipv4)
+        self.show()
+
+    @pyqtSlot(QAbstractButton)
+    def _emit_sig(self, _):
+        self.set_ipv4_act.emit(self._new_ipv4)

pytec/pytec/gui/view/param_tree.json

@@ -0,0 +1,459 @@
+{
+   "ctrl_panel": [
+      {
+         "name": "readings",
+         "title": "Readings",
+         "type": "group",
+         "tip": "Thermostat readings",
+         "children": [
+            {
+               "name": "temperature",
+               "title": "Temperature",
+               "type": "float",
+               "format": "{value:.4f} {suffix}",
+               "suffix": "°C",
+               "readonly": true,
+               "tip": "The measured temperature at the thermistor"
+            },
+            {
+               "name": "tec_i",
+               "title": "Current through TEC",
+               "type": "float",
+               "siPrefix": true,
+               "suffix": "A",
+               "decimals": 6,
+               "readonly": true,
+               "tip": "The measured current through the TEC"
+            }
+         ]
+      },
+      {
+         "name": "output",
+         "title": "Output Settings",
+         "expanded": true,
+         "type": "group",
+         "tip": "Settings of the output to the TEC",
+         "children": [
+            {
+               "name": "control_method",
+               "title": "Control Method",
+               "type": "list",
+               "limits": {
+                  "Constant Current": "constant_current",
+                  "Temperature PID": "temperature_pid"
+               },
+               "thermostat:set_param": {
+                  "topic": "pwm",
+                  "field": "pid"
+               },
+               "tip": "Select control method of output",
+               "children": [
+                  {
+                     "name": "i_set",
+                     "title": "Set Current",
+                     "type": "float",
+                     "value": 0,
+                     "step": 0.1,
+                     "limits": [
+                        -2,
+                        2
+                     ],
+                     "decimals": 6,
+                     "pinSiPrefix": "m",
+                     "suffix": "A",
+                     "siPrefix": true,
+                     "noUnitEditing": true,
+                     "compactHeight": false,
+                     "thermostat:set_param": {
+                        "topic": "pwm",
+                        "field": "i_set"
+                     },
+                     "tip": "The set current through TEC",
+                     "lock": false
+                  },
+                  {
+                     "name": "target",
+                     "title": "Setpoint",
+                     "type": "float",
+                     "value": 25,
+                     "step": 0.1,
+                     "limits": [
+                        -273,
+                        300
+                     ],
+                     "format": "{value:.4f} {suffix}",
+                     "suffix": "°C",
+                     "noUnitEditing": true,
+                     "compactHeight": false,
+                     "thermostat:set_param": {
+                        "topic": "pid",
+                        "field": "target"
+                     },
+                     "tip": "The temperature setpoint of the TEC",
+                     "lock": false
+                  }
+               ]
+            },
+            {
+               "name": "limits",
+               "title": "Limits",
+               "expanded": true,
+               "type": "group",
+               "tip": "The limits of output, with the polarity at the front panel as reference",
+               "children": [
+                  {
+                     "name": "max_i_pos",
+                     "title": "Max Cooling Current",
+                     "type": "float",
+                     "value": 0,
+                     "step": 0.1,
+                     "decimals": 6,
+                     "limits": [
+                        0,
+                        2
+                     ],
+                     "siPrefix": true,
+                     "pinSiPrefix": "m",
+                     "suffix": "A",
+                     "noUnitEditing": true,
+                     "compactHeight": false,
+                     "thermostat:set_param": {
+                        "topic": "pwm",
+                        "field": "max_i_pos"
+                     },
+                     "tip": "The maximum cooling (+ve) current through the output pins",
+                     "lock": false
+                  },
+                  {
+                     "name": "max_i_neg",
+                     "title": "Max Heating Current",
+                     "type": "float",
+                     "value": 0,
+                     "step": 0.1,
+                     "decimals": 6,
+                     "siPrefix": true,
+                     "pinSiPrefix": "m",
+                     "suffix": "A",
+                     "noUnitEditing": true,
+                     "limits": [
+                        0,
+                        2
+                     ],
+                     "compactHeight": false,
+                     "thermostat:set_param": {
+                        "topic": "pwm",
+                        "field": "max_i_neg"
+                     },
+                     "tip": "The maximum heating (-ve) current through the output pins",
+                     "lock": false
+                  },
+                  {
+                     "name": "max_v",
+                     "title": "Max Absolute Voltage",
+                     "type": "float",
+                     "value": 0,
+                     "step": 0.1,
+                     "decimals": 3,
+                     "limits": [
+                        0,
+                        4
+                     ],
+                     "suffix": "V",
+                     "noUnitEditing": true,
+                     "compactHeight": false,
+                     "thermostat:set_param": {
+                        "topic": "pwm",
+                        "field": "max_v"
+                     },
+                     "tip": "The maximum voltage (in both directions) across the output pins",
+                     "lock": false
+                  }
+               ]
+            }
+         ]
+      },
+      {
+         "name": "thermistor",
+         "title": "Thermistor Settings",
+         "expanded": true,
+         "type": "group",
+         "tip": "Parameters for the resistance to temperature conversion with the B-Parameter equation",
+         "children": [
+            {
+               "name": "t0",
+               "title": "T₀",
+               "type": "float",
+               "value": 25,
+               "step": 0.1,
+               "limits": [
+                  -100,
+                  100
+               ],
+               "format": "{value:.4f} {suffix}",
+               "suffix": "°C",
+               "noUnitEditing": true,
+               "compactHeight": false,
+               "thermostat:set_param": {
+                  "topic": "s-h",
+                  "field": "t0"
+               },
+               "tip": "The base temperature",
+               "lock": false
+            },
+            {
+               "name": "r0",
+               "title": "R₀",
+               "type": "float",
+               "value": 10000,
+               "step": 100,
+               "min": 0,
+               "siPrefix": true,
+               "pinSiPrefix": "k",
+               "suffix": "Ω",
+               "noUnitEditing": true,
+               "compactHeight": false,
+               "thermostat:set_param": {
+                  "topic": "s-h",
+                  "field": "r0"
+               },
+               "tip": "The resistance of the thermistor at base temperature T₀",
+               "lock": false
+            },
+            {
+               "name": "b",
+               "title": "B",
+               "type": "float",
+               "value": 3950,
+               "step": 10,
+               "suffix": "K",
+               "noUnitEditing": true,
+               "decimals": 4,
+               "compactHeight": false,
+               "thermostat:set_param": {
+                  "topic": "s-h",
+                  "field": "b"
+               },
+               "tip": "The Beta Parameter",
+               "lock": false
+            }
+         ]
+      },
+      {
+         "name": "postfilter",
+         "title": "ADC Settings",
+         "type": "group",
+         "tip": "Settings of the ADC on the SENS input",
+         "children": [
+            {
+               "name": "rate",
+               "title": "50/60 Hz Rejection Filter",
+               "type": "list",
+               "value": 16.67,
+               "thermostat:set_param": {
+                  "topic": "postfilter",
+                  "field": "rate"
+               },
+               "limits": {
+                  "16.67 SPS": 16.67,
+                  "20 SPS": 20.0,
+                  "21.25 SPS": 21.25,
+                  "27 SPS": 27.0,
+                  "Off": null
+               },
+               "tip": "Adjust the output data rate (in samples per second) of the enhanced 50 Hz & 60 Hz rejection filter\n(Helps avoid mains interference)",
+               "lock": false
+            }
+         ]
+      },
+      {
+         "name": "pid",
+         "title": "PID Settings",
+         "expanded": true,
+         "type": "group",
+         "tip": "Settings of PID parameters and clamping",
+         "children": [
+            {
+               "name": "kp",
+               "title": "Kp",
+               "type": "float",
+               "step": 0.1,
+               "compactHeight": false,
+               "thermostat:set_param": {
+                  "topic": "pid",
+                  "field": "kp"
+               },
+               "tip": "Proportional gain",
+               "lock": false
+            },
+            {
+               "name": "ki",
+               "title": "Ki",
+               "type": "float",
+               "step": 0.1,
+               "suffix": "τ⁻¹",
+               "noUnitEditing": true,
+               "compactHeight": false,
+               "thermostat:set_param": {
+                  "topic": "pid",
+                  "field": "ki"
+               },
+               "tip": "Integral gain",
+               "lock": false
+            },
+            {
+               "name": "kd",
+               "title": "Kd",
+               "type": "float",
+               "step": 0.1,
+               "suffix": "τ",
+               "noUnitEditing": true,
+               "compactHeight": false,
+               "thermostat:set_param": {
+                  "topic": "pid",
+                  "field": "kd"
+               },
+               "tip": "Differential gain",
+               "lock": false
+            },
+            {
+               "name": "pid_output_clamping",
+               "title": "PID Output Clamping",
+               "expanded": true,
+               "type": "group",
+               "tip": "Clamps PID outputs to specified range\nCould be different than output limits",
+               "children": [
+                  {
+                     "name": "output_min",
+                     "title": "Minimum",
+                     "type": "float",
+                     "step": 0.1,
+                     "limits": [
+                        -2,
+                        2
+                     ],
+                     "decimals": 6,
+                     "siPrefix": true,
+                     "pinSiPrefix": "m",
+                     "suffix": "A",
+                     "noUnitEditing": true,
+                     "compactHeight": false,
+                     "thermostat:set_param": {
+                        "topic": "pid",
+                        "field": "output_min"
+                     },
+                     "tip": "Minimum PID output",
+                     "lock": false
+                  },
+                  {
+                     "name": "output_max",
+                     "title": "Maximum",
+                     "type": "float",
+                     "step": 0.1,
+                     "limits": [
+                        -2,
+                        2
+                     ],
+                     "decimals": 6,
+                     "siPrefix": true,
+                     "pinSiPrefix": "m",
+                     "suffix": "A",
+                     "noUnitEditing": true,
+                     "compactHeight": false,
+                     "thermostat:set_param": {
+                        "topic": "pid",
+                        "field": "output_max"
+                     },
+                     "tip": "Maximum PID output",
+                     "lock": false
+                  }
+               ]
+            },
+            {
+               "name": "pid_autotune",
+               "title": "PID Autotune",
+               "expanded": false,
+               "type": "group",
+               "tip": "Automatically tune PID parameters",
+               "children": [
+                  {
+                     "name": "target_temp",
+                     "title": "Target Temperature",
+                     "type": "float",
+                     "value": 20,
+                     "step": 0.1,
+                     "format": "{value:.4f} {suffix}",
+                     "suffix": "°C",
+                     "noUnitEditing": true,
+                     "compactHeight": false,
+                     "pid_autotune": "target_temp",
+                     "tip": "The target temperature to autotune for"
+                  },
+                  {
+                     "name": "test_current",
+                     "title": "Test Current",
+                     "type": "float",
+                     "value": 0,
+                     "decimals": 6,
+                     "step": 0.1,
+                     "limits": [
+                        0,
+                        2
+                     ],
+                     "siPrefix": true,
+                     "pinSiPrefix": "m",
+                     "suffix": "A",
+                     "noUnitEditing": true,
+                     "compactHeight": false,
+                     "pid_autotune": "test_current",
+                     "tip": "The testing current when autotuning"
+                  },
+                  {
+                     "name": "temp_swing",
+                     "title": "Temperature Swing",
+                     "type": "float",
+                     "value": 1.5,
+                     "step": 0.1,
+                     "format": "{value:.4f} {suffix}",
+                     "suffix": "K",
+                     "noUnitEditing": true,
+                     "compactHeight": false,
+                     "pid_autotune": "temp_swing",
+                     "tip": "The temperature swing around the target"
+                  },
+                  {
+                     "name": "lookback",
+                     "title": "Lookback",
+                     "type": "float",
+                     "value": 3.0,
+                     "step": 0.1,
+                     "format": "{value:.4f} {suffix}",
+                     "noUnitEditing": true,
+                     "suffix": "s",
+                     "compactHeight": false,
+                     "pid_autotune": "lookback",
+                     "tip": "Amount of time referenced for tuning"
+                  },
+                  {
+                     "name": "run_pid",
+                     "title": "Run",
+                     "type": "action",
+                     "tip": "Run PID Autotune with above settings"
+                  }
+               ]
+            }
+         ]
+      },
+      {
+         "name": "save",
+         "title": "Save to flash",
+         "type": "action",
+         "tip": "Save settings to thermostat, applies on reset"
+      },
+      {
+         "name": "load",
+         "title": "Load from flash",
+         "type": "action",
+         "tip": "Load settings from thermostat"
+      }
+   ]
+}

pytec/pytec/gui/view/plot_options_menu.py

@@ -0,0 +1,21 @@
+from PyQt6 import QtWidgets, QtGui
+
+
+class PlotOptionsMenu(QtWidgets.QMenu):
+    def __init__(self, max_samples=1000):
+        super().__init__()
+        self.setTitle("Plot Settings")
+
+        clear = QtGui.QAction("Clear graphs", self)
+        self.addAction(clear)
+        self.clear = clear
+
+        self.samples_spinbox = QtWidgets.QSpinBox()
+        self.samples_spinbox.setRange(2, 100000)
+        self.samples_spinbox.setSuffix(" samples")
+        self.samples_spinbox.setValue(max_samples)
+
+        limit_samples = QtWidgets.QWidgetAction(self)
+        limit_samples.setDefaultWidget(self.samples_spinbox)
+        self.addAction(limit_samples)
+        self.limit_samples = limit_samples

pytec/pytec/gui/view/tec_qt.ui

@@ -0,0 +1,597 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>1280</width>
+    <height>720</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>1280</width>
+    <height>720</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>3840</width>
+    <height>2160</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Thermostat Control Panel</string>
+  </property>
+  <property name="windowIcon">
+   <iconset>
+    <normaloff>../resources/artiq.ico</normaloff>../resources/artiq.ico</iconset>
+  </property>
+  <widget class="QWidget" name="main_widget">
+   <property name="sizePolicy">
+    <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+     <horstretch>1</horstretch>
+     <verstretch>1</verstretch>
+    </sizepolicy>
+   </property>
+   <layout class="QGridLayout" name="gridLayout_2">
+    <property name="leftMargin">
+     <number>3</number>
+    </property>
+    <property name="topMargin">
+     <number>3</number>
+    </property>
+    <property name="rightMargin">
+     <number>3</number>
+    </property>
+    <property name="bottomMargin">
+     <number>3</number>
+    </property>
+    <property name="spacing">
+     <number>3</number>
+    </property>
+    <item row="0" column="1">
+     <layout class="QVBoxLayout" name="main_layout">
+      <property name="spacing">
+       <number>0</number>
+      </property>
+      <item>
+       <widget class="QFrame" name="graph_group">
+        <property name="enabled">
+         <bool>false</bool>
+        </property>
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+          <horstretch>1</horstretch>
+          <verstretch>1</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="frameShape">
+         <enum>QFrame::Shape::StyledPanel</enum>
+        </property>
+        <property name="frameShadow">
+         <enum>QFrame::Shadow::Raised</enum>
+        </property>
+        <layout class="QGridLayout" name="graphs_layout" rowstretch="1,1" columnstretch="1,1,1" rowminimumheight="100,100" columnminimumwidth="100,100,100">
+         <property name="sizeConstraint">
+          <enum>QLayout::SizeConstraint::SetDefaultConstraint</enum>
+         </property>
+         <property name="leftMargin">
+          <number>3</number>
+         </property>
+         <property name="topMargin">
+          <number>3</number>
+         </property>
+         <property name="rightMargin">
+          <number>3</number>
+         </property>
+         <property name="bottomMargin">
+          <number>3</number>
+         </property>
+         <property name="spacing">
+          <number>2</number>
+         </property>
+         <item row="1" column="1">
+          <widget class="LivePlotWidget" name="ch1_t_graph" native="true"/>
+         </item>
+         <item row="0" column="1">
+          <widget class="LivePlotWidget" name="ch0_t_graph" native="true"/>
+         </item>
+         <item row="0" column="2">
+          <widget class="LivePlotWidget" name="ch0_i_graph" native="true"/>
+         </item>
+         <item row="1" column="2">
+          <widget class="LivePlotWidget" name="ch1_i_graph" native="true"/>
+         </item>
+         <item row="0" column="0" rowspan="2">
+          <widget class="QTabWidget" name="tabWidget">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+           <property name="currentIndex">
+            <number>0</number>
+           </property>
+           <widget class="QWidget" name="ch0_tab">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <attribute name="title">
+             <string>Channel 0</string>
+            </attribute>
+            <layout class="QVBoxLayout" name="verticalLayout_2">
+             <item>
+              <widget class="ParameterTree" name="ch0_tree" native="true">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
+              </widget>
+             </item>
+            </layout>
+           </widget>
+           <widget class="QWidget" name="ch1_tab">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <attribute name="title">
+             <string>Channel 1</string>
+            </attribute>
+            <layout class="QVBoxLayout" name="verticalLayout">
+             <item>
+              <widget class="ParameterTree" name="ch1_tree" native="true">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
+              </widget>
+             </item>
+            </layout>
+           </widget>
+          </widget>
+         </item>
+        </layout>
+       </widget>
+      </item>
+      <item>
+       <widget class="QFrame" name="bottom_settings_group">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="minimumSize">
+         <size>
+          <width>0</width>
+          <height>40</height>
+         </size>
+        </property>
+        <property name="maximumSize">
+         <size>
+          <width>16777215</width>
+          <height>40</height>
+         </size>
+        </property>
+        <property name="frameShape">
+         <enum>QFrame::Shape::StyledPanel</enum>
+        </property>
+        <property name="frameShadow">
+         <enum>QFrame::Shadow::Raised</enum>
+        </property>
+        <layout class="QHBoxLayout" name="horizontalLayout_2">
+         <property name="spacing">
+          <number>3</number>
+         </property>
+         <property name="leftMargin">
+          <number>3</number>
+         </property>
+         <property name="topMargin">
+          <number>3</number>
+         </property>
+         <property name="rightMargin">
+          <number>3</number>
+         </property>
+         <property name="bottomMargin">
+          <number>3</number>
+         </property>
+         <item>
+          <layout class="QHBoxLayout" name="settings_layout">
+           <item>
+            <widget class="QToolButton" name="connect_btn">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="minimumSize">
+              <size>
+               <width>100</width>
+               <height>0</height>
+              </size>
+             </property>
+             <property name="maximumSize">
+              <size>
+               <width>100</width>
+               <height>16777215</height>
+              </size>
+             </property>
+             <property name="baseSize">
+              <size>
+               <width>100</width>
+               <height>0</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>Connect</string>
+             </property>
+             <property name="popupMode">
+              <enum>QToolButton::ToolButtonPopupMode::MenuButtonPopup</enum>
+             </property>
+             <property name="toolButtonStyle">
+              <enum>Qt::ToolButtonStyle::ToolButtonFollowStyle</enum>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="status_lbl">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="minimumSize">
+              <size>
+               <width>240</width>
+               <height>0</height>
+              </size>
+             </property>
+             <property name="maximumSize">
+              <size>
+               <width>120</width>
+               <height>16777215</height>
+              </size>
+             </property>
+             <property name="baseSize">
+              <size>
+               <width>120</width>
+               <height>50</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>Disconnected</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QToolButton" name="thermostat_settings">
+             <property name="enabled">
+              <bool>false</bool>
+             </property>
+             <property name="text">
+              <string notr="true">⚙</string>
+             </property>
+             <property name="popupMode">
+              <enum>QToolButton::ToolButtonPopupMode::InstantPopup</enum>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QToolButton" name="plot_settings">
+             <property name="toolTip">
+              <string>Plot Settings</string>
+             </property>
+             <property name="text">
+              <string>📉</string>
+             </property>
+             <property name="popupMode">
+              <enum>QToolButton::ToolButtonPopupMode::InstantPopup</enum>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="limits_warning">
+             <property name="toolTipDuration">
+              <number>1000000000</number>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="background_task_lbl">
+             <property name="text">
+              <string>Ready.</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QtWaitingSpinner" name="loading_spinner" native="true"/>
+           </item>
+           <item>
+            <spacer name="horizontalSpacer">
+             <property name="orientation">
+              <enum>Qt::Orientation::Horizontal</enum>
+             </property>
+             <property name="sizeHint" stdset="0">
+              <size>
+               <width>40</width>
+               <height>20</height>
+              </size>
+             </property>
+            </spacer>
+           </item>
+           <item>
+            <widget class="QWidget" name="report_group" native="true">
+             <property name="enabled">
+              <bool>false</bool>
+             </property>
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Minimum" vsizetype="Expanding">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="minimumSize">
+              <size>
+               <width>40</width>
+               <height>0</height>
+              </size>
+             </property>
+             <layout class="QHBoxLayout" name="horizontalLayout_4">
+              <property name="spacing">
+               <number>0</number>
+              </property>
+              <property name="leftMargin">
+               <number>0</number>
+              </property>
+              <property name="topMargin">
+               <number>0</number>
+              </property>
+              <property name="rightMargin">
+               <number>0</number>
+              </property>
+              <property name="bottomMargin">
+               <number>0</number>
+              </property>
+              <item>
+               <layout class="QHBoxLayout" name="report_layout" stretch="0,1,1,1">
+                <property name="spacing">
+                 <number>6</number>
+                </property>
+                <property name="sizeConstraint">
+                 <enum>QLayout::SizeConstraint::SetDefaultConstraint</enum>
+                </property>
+                <property name="leftMargin">
+                 <number>0</number>
+                </property>
+                <item>
+                 <widget class="QLabel" name="report_lbl">
+                  <property name="text">
+                   <string>Poll every: </string>
+                  </property>
+                  <property name="alignment">
+                   <set>Qt::AlignmentFlag::AlignRight|Qt::AlignmentFlag::AlignTrailing|Qt::AlignmentFlag::AlignVCenter</set>
+                  </property>
+                 </widget>
+                </item>
+                <item>
+                 <widget class="QDoubleSpinBox" name="report_refresh_spin">
+                  <property name="sizePolicy">
+                   <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+                    <horstretch>0</horstretch>
+                    <verstretch>0</verstretch>
+                   </sizepolicy>
+                  </property>
+                  <property name="minimumSize">
+                   <size>
+                    <width>70</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="maximumSize">
+                   <size>
+                    <width>70</width>
+                    <height>16777215</height>
+                   </size>
+                  </property>
+                  <property name="baseSize">
+                   <size>
+                    <width>70</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="suffix">
+                   <string> s</string>
+                  </property>
+                  <property name="decimals">
+                   <number>1</number>
+                  </property>
+                  <property name="minimum">
+                   <double>0.100000000000000</double>
+                  </property>
+                  <property name="singleStep">
+                   <double>0.100000000000000</double>
+                  </property>
+                  <property name="stepType">
+                   <enum>QAbstractSpinBox::StepType::AdaptiveDecimalStepType</enum>
+                  </property>
+                  <property name="value">
+                   <double>1.000000000000000</double>
+                  </property>
+                 </widget>
+                </item>
+                <item>
+                 <widget class="QCheckBox" name="report_box">
+                  <property name="sizePolicy">
+                   <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+                    <horstretch>0</horstretch>
+                    <verstretch>0</verstretch>
+                   </sizepolicy>
+                  </property>
+                  <property name="maximumSize">
+                   <size>
+                    <width>80</width>
+                    <height>16777215</height>
+                   </size>
+                  </property>
+                  <property name="baseSize">
+                   <size>
+                    <width>80</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="text">
+                   <string>Report</string>
+                  </property>
+                 </widget>
+                </item>
+                <item>
+                 <widget class="QPushButton" name="report_apply_btn">
+                  <property name="sizePolicy">
+                   <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+                    <horstretch>0</horstretch>
+                    <verstretch>0</verstretch>
+                   </sizepolicy>
+                  </property>
+                  <property name="minimumSize">
+                   <size>
+                    <width>80</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="maximumSize">
+                   <size>
+                    <width>80</width>
+                    <height>16777215</height>
+                   </size>
+                  </property>
+                  <property name="baseSize">
+                   <size>
+                    <width>80</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="text">
+                   <string>Apply</string>
+                  </property>
+                 </widget>
+                </item>
+               </layout>
+              </item>
+             </layout>
+            </widget>
+           </item>
+          </layout>
+         </item>
+        </layout>
+       </widget>
+      </item>
+     </layout>
+    </item>
+   </layout>
+  </widget>
+  <action name="actionReset">
+   <property name="text">
+    <string>Reset</string>
+   </property>
+   <property name="toolTip">
+    <string>Reset the Thermostat</string>
+   </property>
+   <property name="menuRole">
+    <enum>QAction::MenuRole::NoRole</enum>
+   </property>
+  </action>
+  <action name="actionEnter_DFU_Mode">
+   <property name="text">
+    <string>Enter DFU Mode</string>
+   </property>
+   <property name="toolTip">
+    <string>Reset thermostat and enter USB device firmware update (DFU) mode</string>
+   </property>
+   <property name="menuRole">
+    <enum>QAction::MenuRole::NoRole</enum>
+   </property>
+  </action>
+  <action name="actionNetwork_Settings">
+   <property name="text">
+    <string>Network Settings</string>
+   </property>
+   <property name="toolTip">
+    <string>Configure IPv4 address, netmask length, and optional default gateway</string>
+   </property>
+   <property name="menuRole">
+    <enum>QAction::MenuRole::NoRole</enum>
+   </property>
+  </action>
+  <action name="actionAbout_Thermostat">
+   <property name="text">
+    <string>About Thermostat</string>
+   </property>
+   <property name="toolTip">
+    <string>Show Thermostat hardware revision, and settings related to i</string>
+   </property>
+   <property name="menuRole">
+    <enum>QAction::MenuRole::NoRole</enum>
+   </property>
+  </action>
+  <action name="actionLoad_all_configs">
+   <property name="text">
+    <string>Load all channel configs from flash</string>
+   </property>
+   <property name="toolTip">
+    <string>Restore configuration for all channels from flash</string>
+   </property>
+   <property name="menuRole">
+    <enum>QAction::MenuRole::NoRole</enum>
+   </property>
+  </action>
+  <action name="actionSave_all_configs">
+   <property name="text">
+    <string>Save all channel configs to flash</string>
+   </property>
+   <property name="toolTip">
+    <string>Save configuration for all channels to flash</string>
+   </property>
+   <property name="menuRole">
+    <enum>QAction::MenuRole::NoRole</enum>
+   </property>
+  </action>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>ParameterTree</class>
+   <extends>QWidget</extends>
+   <header>pyqtgraph.parametertree</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>LivePlotWidget</class>
+   <extends>QWidget</extends>
+   <header>pglive.sources.live_plot_widget</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>QtWaitingSpinner</class>
+   <extends>QWidget</extends>
+   <header>pytec.gui.view.waitingspinnerwidget</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

pytec/pytec/gui/view/thermostat_ctrl_menu.py

@@ -0,0 +1,145 @@
+from PyQt6 import QtWidgets, QtGui, QtCore
+from PyQt6.QtCore import pyqtSignal, pyqtSlot
+
+
+class ThermostatCtrlMenu(QtWidgets.QMenu):
+    fan_set_act = pyqtSignal(int)
+    fan_auto_set_act = pyqtSignal(int)
+
+    connect_act = pyqtSignal()
+    reset_act = pyqtSignal(bool)
+    dfu_act = pyqtSignal(bool)
+    load_cfg_act = pyqtSignal(int)
+    save_cfg_act = pyqtSignal(int)
+    net_cfg_act = pyqtSignal(bool)
+
+    def __init__(self, style):
+        super().__init__()
+        self._style = style
+        self.setTitle("Thermostat settings")
+
+        self.hw_rev_data = dict()
+
+        self.fan_group = QtWidgets.QWidget()
+        self.fan_group.setEnabled(False)
+        self.fan_group.setMinimumSize(QtCore.QSize(40, 0))
+        self.fan_layout = QtWidgets.QHBoxLayout(self.fan_group)
+        self.fan_layout.setSpacing(9)
+        self.fan_lbl = QtWidgets.QLabel(parent=self.fan_group)
+        self.fan_lbl.setMinimumSize(QtCore.QSize(40, 0))
+        self.fan_lbl.setMaximumSize(QtCore.QSize(40, 16777215))
+        self.fan_lbl.setBaseSize(QtCore.QSize(40, 0))
+        self.fan_layout.addWidget(self.fan_lbl)
+        self.fan_power_slider = QtWidgets.QSlider(parent=self.fan_group)
+        self.fan_power_slider.setMinimumSize(QtCore.QSize(200, 0))
+        self.fan_power_slider.setMaximumSize(QtCore.QSize(200, 16777215))
+        self.fan_power_slider.setBaseSize(QtCore.QSize(200, 0))
+        self.fan_power_slider.setRange(1, 100)
+        self.fan_power_slider.setOrientation(QtCore.Qt.Orientation.Horizontal)
+        self.fan_layout.addWidget(self.fan_power_slider)
+        self.fan_auto_box = QtWidgets.QCheckBox(parent=self.fan_group)
+        self.fan_auto_box.setMinimumSize(QtCore.QSize(70, 0))
+        self.fan_auto_box.setMaximumSize(QtCore.QSize(70, 16777215))
+        self.fan_layout.addWidget(self.fan_auto_box)
+        self.fan_pwm_warning = QtWidgets.QLabel(parent=self.fan_group)
+        self.fan_pwm_warning.setMinimumSize(QtCore.QSize(16, 0))
+        self.fan_layout.addWidget(self.fan_pwm_warning)
+
+        self.fan_power_slider.valueChanged.connect(self.fan_set_act)
+        self.fan_auto_box.stateChanged.connect(self.fan_auto_set_act)
+
+        self.fan_lbl.setToolTip("Adjust the fan")
+        self.fan_lbl.setText("Fan:")
+        self.fan_auto_box.setText("Auto")
+
+        fan = QtWidgets.QWidgetAction(self)
+        fan.setDefaultWidget(self.fan_group)
+        self.addAction(fan)
+        self.fan = fan
+
+        self.actionReset = QtGui.QAction("Reset Thermostat", self)
+        self.actionReset.triggered.connect(self.reset_act)
+        self.addAction(self.actionReset)
+
+        self.actionEnter_DFU_Mode = QtGui.QAction("Enter DFU Mode", self)
+        self.actionEnter_DFU_Mode.triggered.connect(self.dfu_act)
+        self.addAction(self.actionEnter_DFU_Mode)
+
+        self.actionnet_settings_input_diag = QtGui.QAction("Set IPV4 Settings", self)
+        self.actionnet_settings_input_diag.triggered.connect(self.net_cfg_act)
+        self.addAction(self.actionnet_settings_input_diag)
+
+        @pyqtSlot(bool)
+        def load(_):
+            self.load_cfg_act.emit(0)
+            self.load_cfg_act.emit(1)
+            loaded = QtWidgets.QMessageBox(self)
+            loaded.setWindowTitle("Config loaded")
+            loaded.setText("All channel configs have been loaded from flash.")
+            loaded.setIcon(QtWidgets.QMessageBox.Icon.Information)
+            loaded.show()
+
+        self.actionLoad_all_configs = QtGui.QAction("Load Config", self)
+        self.actionLoad_all_configs.triggered.connect(load)
+        self.addAction(self.actionLoad_all_configs)
+
+        @pyqtSlot(bool)
+        def save(_):
+            self.save_cfg_act.emit(0)
+            self.save_cfg_act.emit(1)
+            saved = QtWidgets.QMessageBox(self)
+            saved.setWindowTitle("Config saved")
+            saved.setText("All channel configs have been saved to flash.")
+            saved.setIcon(QtWidgets.QMessageBox.Icon.Information)
+            saved.show()
+
+        self.actionSave_all_configs = QtGui.QAction("Save Config", self)
+        self.actionSave_all_configs.triggered.connect(save)
+        self.addAction(self.actionSave_all_configs)
+
+        def about_thermostat():
+            QtWidgets.QMessageBox.about(
+                self,
+                "About Thermostat",
+                f"""
+                <h1>Sinara 8451 Thermostat v{self.hw_rev_data['rev']['major']}.{self.hw_rev_data['rev']['minor']}</h1>
+
+                <br>
+
+                <h2>Settings:</h2>
+                Default fan curve:
+                    a = {self.hw_rev_data['settings']['fan_k_a']},
+                    b = {self.hw_rev_data['settings']['fan_k_b']},
+                    c = {self.hw_rev_data['settings']['fan_k_c']}
+                <br>
+                Fan PWM range:
+                    {self.hw_rev_data['settings']['min_fan_pwm']} \u2013 {self.hw_rev_data['settings']['max_fan_pwm']}
+                <br>
+                Fan PWM frequency: {self.hw_rev_data['settings']['fan_pwm_freq_hz']} Hz
+                <br>
+                Fan available: {self.hw_rev_data['settings']['fan_available']}
+                <br>
+                Fan PWM recommended: {self.hw_rev_data['settings']['fan_pwm_recommended']}
+                """,
+            )
+
+        self.actionAbout_Thermostat = QtGui.QAction("About Thermostat", self)
+        self.actionAbout_Thermostat.triggered.connect(about_thermostat)
+        self.addAction(self.actionAbout_Thermostat)
+
+    def set_fan_pwm_warning(self):
+        if self.fan_power_slider.value() != 100:
+            pixmapi = getattr(QtWidgets.QStyle.StandardPixmap, "SP_MessageBoxWarning")
+            icon = self._style.standardIcon(pixmapi)
+            self.fan_pwm_warning.setPixmap(icon.pixmap(16, 16))
+            self.fan_pwm_warning.setToolTip(
+                "Throttling the fan (not recommended on this hardware rev)"
+            )
+        else:
+            self.fan_pwm_warning.setPixmap(QtGui.QPixmap())
+            self.fan_pwm_warning.setToolTip("")
+
+    @pyqtSlot("QVariantMap")
+    def hw_rev(self, hw_rev):
+        self.hw_rev_data = hw_rev
+        self.fan_group.setEnabled(self.hw_rev_data["settings"]["fan_available"])

pytec/pytec/gui/view/waitingspinnerwidget.py

@@ -0,0 +1,194 @@
+"""
+The MIT License (MIT)
+
+Copyright (c) 2012-2014 Alexander Turkin
+Copyright (c) 2014 William Hallatt
+Copyright (c) 2015 Jacob Dawid
+Copyright (c) 2016 Luca Weiss
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import math
+
+from PyQt6.QtCore import *
+from PyQt6.QtGui import *
+from PyQt6.QtWidgets import *
+
+
+class QtWaitingSpinner(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        # WAS IN initialize()
+        self._color = QColor(Qt.GlobalColor.black)
+        self._roundness = 100.0
+        self._minimumTrailOpacity = 3.14159265358979323846
+        self._trailFadePercentage = 80.0
+        self._revolutionsPerSecond = 1.57079632679489661923
+        self._numberOfLines = 20
+        self._lineLength = 5
+        self._lineWidth = 2
+        self._innerRadius = 5
+        self._currentCounter = 0
+
+        self._timer = QTimer(self)
+        self._timer.timeout.connect(self.rotate)
+        self.updateSize()
+        self.updateTimer()
+        # END initialize()
+
+        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+
+    def paintEvent(self, QPaintEvent):
+        painter = QPainter(self)
+        painter.fillRect(self.rect(), Qt.GlobalColor.transparent)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
+
+        if self._currentCounter >= self._numberOfLines:
+            self._currentCounter = 0
+
+        painter.setPen(Qt.PenStyle.NoPen)
+        for i in range(0, self._numberOfLines):
+            painter.save()
+            painter.translate(self._innerRadius + self._lineLength, self._innerRadius + self._lineLength)
+            rotateAngle = float(360 * i) / float(self._numberOfLines)
+            painter.rotate(rotateAngle)
+            painter.translate(self._innerRadius, 0)
+            distance = self.lineCountDistanceFromPrimary(i, self._currentCounter, self._numberOfLines)
+            color = self.currentLineColor(distance, self._numberOfLines, self._trailFadePercentage,
+                                          self._minimumTrailOpacity, self._color)
+            painter.setBrush(color)
+            painter.drawRoundedRect(QRect(0, int(-self._lineWidth / 2), self._lineLength, self._lineWidth), self._roundness,
+                                    self._roundness, Qt.SizeMode.RelativeSize)
+            painter.restore()
+
+    def start(self):
+        if not self._timer.isActive():
+            self._timer.start()
+            self._currentCounter = 0
+
+    def stop(self):
+        if self._timer.isActive():
+            self._timer.stop()
+            self._currentCounter = 0
+
+    def setNumberOfLines(self, lines):
+        self._numberOfLines = lines
+        self._currentCounter = 0
+        self.updateTimer()
+
+    def setLineLength(self, length):
+        self._lineLength = length
+        self.updateSize()
+
+    def setLineWidth(self, width):
+        self._lineWidth = width
+        self.updateSize()
+
+    def setInnerRadius(self, radius):
+        self._innerRadius = radius
+        self.updateSize()
+
+    def color(self):
+        return self._color
+
+    def roundness(self):
+        return self._roundness
+
+    def minimumTrailOpacity(self):
+        return self._minimumTrailOpacity
+
+    def trailFadePercentage(self):
+        return self._trailFadePercentage
+
+    def revolutionsPersSecond(self):
+        return self._revolutionsPerSecond
+
+    def numberOfLines(self):
+        return self._numberOfLines
+
+    def lineLength(self):
+        return self._lineLength
+
+    def lineWidth(self):
+        return self._lineWidth
+
+    def innerRadius(self):
+        return self._innerRadius
+
+    def setRoundness(self, roundness):
+        self._roundness = max(0.0, min(100.0, roundness))
+
+    def setColor(self, color=Qt.GlobalColor.black):
+        self._color = QColor(color)
+
+    def setRevolutionsPerSecond(self, revolutionsPerSecond):
+        self._revolutionsPerSecond = revolutionsPerSecond
+        self.updateTimer()
+
+    def setTrailFadePercentage(self, trail):
+        self._trailFadePercentage = trail
+
+    def setMinimumTrailOpacity(self, minimumTrailOpacity):
+        self._minimumTrailOpacity = minimumTrailOpacity
+
+    def rotate(self):
+        self._currentCounter += 1
+        if self._currentCounter >= self._numberOfLines:
+            self._currentCounter = 0
+        self.update()
+
+    def updateSize(self):
+        self.size = (self._innerRadius + self._lineLength) * 2
+        self.setFixedSize(self.size, self.size)
+
+    def updateTimer(self):
+        self._timer.setInterval(int(1000 / (self._numberOfLines * self._revolutionsPerSecond)))
+
+    def lineCountDistanceFromPrimary(self, current, primary, totalNrOfLines):
+        distance = primary - current
+        if distance < 0:
+            distance += totalNrOfLines
+        return distance
+
+    def currentLineColor(self, countDistance, totalNrOfLines, trailFadePerc, minOpacity, colorinput):
+        color = QColor(colorinput)
+        if countDistance == 0:
+            return color
+        minAlphaF = minOpacity / 100.0
+        distanceThreshold = int(math.ceil((totalNrOfLines - 1) * trailFadePerc / 100.0))
+        if countDistance > distanceThreshold:
+            color.setAlphaF(minAlphaF)
+        else:
+            alphaDiff = color.alphaF() - minAlphaF
+            gradient = alphaDiff / float(distanceThreshold + 1)
+            resultAlpha = color.alphaF() - gradient * countDistance
+            # If alpha is out of bounds, clip it.
+            resultAlpha = min(1.0, max(0.0, resultAlpha))
+            color.setAlphaF(resultAlpha)
+        return color
+
+
+if __name__ == '__main__':
+    app = QApplication([])
+    waiting_spinner = QtWaitingSpinner()
+    waiting_spinner.show()
+    waiting_spinner.start()
+    app.exec()

pytec/pytec/gui/view/zero_limits_warning.py

@@ -0,0 +1,41 @@
+from PyQt6.QtCore import pyqtSlot, QObject
+from PyQt6 import QtWidgets, QtGui
+
+
+class ZeroLimitsWarningView(QObject):
+    def __init__(self, style, limit_warning):
+        super().__init__()
+        self._lbl = limit_warning
+        self._style = style
+
+    @pyqtSlot("QVariantList")
+    def set_limits_warning(self, channels_zeroed_limits: list):
+        channel_disabled = [False, False]
+
+        report_str = "The following output limit(s) are set to zero:\n"
+        for ch, zeroed_limits in enumerate(channels_zeroed_limits):
+            if {"max_i_pos", "max_i_neg"}.issubset(zeroed_limits):
+                report_str += "Max Cooling Current, Max Heating Current"
+                channel_disabled[ch] = True
+
+            if "max_v" in zeroed_limits:
+                if channel_disabled[ch]:
+                    report_str += ", "
+                report_str += "Max Voltage Difference"
+                channel_disabled[ch] = True
+
+            if channel_disabled[ch]:
+                report_str += f" for Channel {ch}\n"
+
+        report_str += (
+            "\nThese limit(s) are restricting the channel(s) from producing current."
+        )
+
+        if True in channel_disabled:
+            pixmapi = getattr(QtWidgets.QStyle.StandardPixmap, "SP_MessageBoxWarning")
+            icon = self._style.standardIcon(pixmapi)
+            self._lbl.setPixmap(icon.pixmap(16, 16))
+            self._lbl.setToolTip(report_str)
+        else:
+            self._lbl.setPixmap(QtGui.QPixmap())
+            self._lbl.setToolTip(None)

pytec/setup.py

@@ -9,4 +9,10 @@ setup(
     license="GPLv3",
     install_requires=["setuptools"],
     packages=find_packages(),
+    entry_points={
+        "gui_scripts": [
+            "tec_qt = tec_qt:main",
+        ]
+    },
+    py_modules=['autotune', 'plot', 'tec_qt'],
 )

pytec/tec_qt.py

@@ -0,0 +1,427 @@
+from pytec.gui.view.zero_limits_warning import ZeroLimitsWarningView
+from pytec.gui.view.net_settings_input_diag import NetSettingsInputDiag
+from pytec.gui.view.thermostat_ctrl_menu import ThermostatCtrlMenu
+from pytec.gui.view.conn_menu import ConnMenu
+from pytec.gui.view.plot_options_menu import PlotOptionsMenu
+from pytec.gui.view.live_plot_view import LiveDataPlotter
+from pytec.gui.view.ctrl_panel import CtrlPanel
+from pytec.gui.view.info_box import InfoBox
+from pytec.gui.model.pid_autotuner import PIDAutoTuner
+from pytec.gui.model.thermostat import WrappedClient, Thermostat
+import json
+from autotune import PIDAutotuneState
+from qasync import asyncSlot, asyncClose
+import qasync
+from pytec.aioclient import StoppedConnecting
+import asyncio
+import logging
+import argparse
+from PyQt6 import QtWidgets, QtGui, uic
+from PyQt6.QtCore import QSignalBlocker, pyqtSlot
+import pyqtgraph as pg
+from functools import partial
+import importlib.resources
+
+
+def get_argparser():
+    parser = argparse.ArgumentParser(description="Thermostat Control Panel")
+
+    parser.add_argument(
+        "--connect",
+        default=None,
+        action="store_true",
+        help="Automatically connect to the specified Thermostat in IP:port format",
+    )
+    parser.add_argument("IP", metavar="ip", default=None, nargs="?")
+    parser.add_argument("PORT", metavar="port", default=None, nargs="?")
+    parser.add_argument(
+        "-l",
+        "--log",
+        dest="logLevel",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        help="Set the logging level",
+    )
+    parser.add_argument(
+        "-p",
+        "--param_tree",
+        default=importlib.resources.files("pytec.gui.view").joinpath("param_tree.json"),
+        help="Param Tree Description JSON File",
+    )
+
+    return parser
+
+
+class MainWindow(QtWidgets.QMainWindow):
+    NUM_CHANNELS = 2
+
+    def __init__(self, args):
+        super(MainWindow, self).__init__()
+
+        ui_file_path = importlib.resources.files("pytec.gui.view").joinpath("tec_qt.ui")
+        uic.loadUi(ui_file_path, self)
+
+        self.hw_rev_data = None
+        self.info_box = InfoBox()
+
+        self.client = WrappedClient(self)
+        self.client.connection_error.connect(self.bail)
+
+        self.thermostat = Thermostat(
+            self, self.client, self.report_refresh_spin.value()
+        )
+
+        self.autotuners = PIDAutoTuner(self, self.client, 2)
+
+        def get_ctrl_panel_config(args):
+            with open(args.param_tree, "r") as f:
+                return json.load(f)["ctrl_panel"]
+
+        param_tree_sigActivated_handles = [
+            [
+                [["save"], partial(self.thermostat.save_cfg, ch)],
+                [["load"], partial(self.thermostat.load_cfg, ch)],
+                [
+                    ["pid", "pid_autotune", "run_pid"],
+                    partial(self.pid_autotune_request, ch),
+                ],
+            ]
+            for ch in range(self.NUM_CHANNELS)
+        ]
+        self.thermostat.info_box_trigger.connect(self.info_box.display_info_box)
+
+        self.zero_limits_warning = ZeroLimitsWarningView(
+            self.style(), self.limits_warning
+        )
+        self.ctrl_panel_view = CtrlPanel(
+            [self.ch0_tree, self.ch1_tree],
+            get_ctrl_panel_config(args),
+            self.send_command,
+            param_tree_sigActivated_handles,
+        )
+        self.ctrl_panel_view.set_zero_limits_warning_sig.connect(
+            self.zero_limits_warning.set_limits_warning
+        )
+
+        self.thermostat.fan_update.connect(self.fan_update)
+        self.thermostat.report_update.connect(self.ctrl_panel_view.update_report)
+        self.thermostat.report_update.connect(self.autotuners.tick)
+        self.thermostat.report_update.connect(self.pid_autotune_handler)
+        self.thermostat.pid_update.connect(self.ctrl_panel_view.update_pid)
+        self.thermostat.pwm_update.connect(self.ctrl_panel_view.update_pwm)
+        self.thermostat.thermistor_update.connect(
+            self.ctrl_panel_view.update_thermistor
+        )
+        self.thermostat.postfilter_update.connect(
+            self.ctrl_panel_view.update_postfilter
+        )
+        self.thermostat.interval_update.connect(
+            self.autotuners.update_sampling_interval
+        )
+        self.report_apply_btn.clicked.connect(
+            lambda: self.thermostat.set_update_s(self.report_refresh_spin.value())
+        )
+
+        self.channel_graphs = LiveDataPlotter(
+            [
+                [getattr(self, f"ch{ch}_t_graph"), getattr(self, f"ch{ch}_i_graph")]
+                for ch in range(self.NUM_CHANNELS)
+            ]
+        )
+
+        self.thermostat.report_update.connect(self.channel_graphs.update_report)
+        self.thermostat.pid_update.connect(self.channel_graphs.update_pid)
+
+        self.plot_options_menu = PlotOptionsMenu()
+        self.plot_options_menu.clear.triggered.connect(self.clear_graphs)
+        self.plot_options_menu.samples_spinbox.valueChanged.connect(
+            self.channel_graphs.set_max_samples
+        )
+        self.plot_settings.setMenu(self.plot_options_menu)
+
+        self.conn_menu = ConnMenu()
+        self.connect_btn.setMenu(self.conn_menu)
+
+        self.thermostat_ctrl_menu = ThermostatCtrlMenu(self.style())
+        self.thermostat_ctrl_menu.fan_set_act.connect(self.fan_set_request)
+        self.thermostat_ctrl_menu.fan_auto_set_act.connect(self.fan_auto_set_request)
+        self.thermostat_ctrl_menu.reset_act.connect(self.reset_request)
+        self.thermostat_ctrl_menu.dfu_act.connect(self.dfu_request)
+        self.thermostat_ctrl_menu.save_cfg_act.connect(self.save_cfg_request)
+        self.thermostat_ctrl_menu.load_cfg_act.connect(self.load_cfg_request)
+        self.thermostat_ctrl_menu.net_cfg_act.connect(self.net_settings_request)
+
+        self.thermostat.hw_rev_update.connect(self.thermostat_ctrl_menu.hw_rev)
+        self.thermostat_settings.setMenu(self.thermostat_ctrl_menu)
+
+        self.loading_spinner.hide()
+
+        if args.connect:
+            if args.IP:
+                self.host_set_line.setText(args.IP)
+            if args.PORT:
+                self.port_set_spin.setValue(int(args.PORT))
+            self.connect_btn.click()
+
+    def clear_graphs(self):
+        self.channel_graphs.clear_graphs()
+
+    async def _on_connection_changed(self, result):
+        self.graph_group.setEnabled(result)
+        self.report_group.setEnabled(result)
+        self.thermostat_settings.setEnabled(result)
+
+        self.conn_menu.host_set_line.setEnabled(not result)
+        self.conn_menu.port_set_spin.setEnabled(not result)
+        self.connect_btn.setText("Disconnect" if result else "Connect")
+        if result:
+            self.hw_rev_data = await self.thermostat.get_hw_rev()
+            logging.debug(self.hw_rev_data)
+
+            self._status(self.hw_rev_data)
+            self.thermostat.start_watching()
+        else:
+            self.status_lbl.setText("Disconnected")
+            self.background_task_lbl.setText("Ready.")
+            self.loading_spinner.hide()
+            self.loading_spinner.stop()
+            self.thermostat_ctrl_menu.fan_pwm_warning.setPixmap(QtGui.QPixmap())
+            self.thermostat_ctrl_menu.fan_pwm_warning.setToolTip("")
+            self.clear_graphs()
+            self.report_box.setChecked(False)
+            if not Thermostat.connecting or Thermostat.connected:
+                for ch in range(self.NUM_CHANNELS):
+                    if self.autotuners.get_state(ch) != PIDAutotuneState.STATE_OFF:
+                        await self.autotuners.stop_pid_from_running(ch)
+            await self.thermostat.set_report_mode(False)
+            self.thermostat.stop_watching()
+
+    def _status(self, hw_rev_d: dict):
+        logging.debug(hw_rev_d)
+        self.status_lbl.setText(
+            f"Connected to Thermostat v{hw_rev_d['rev']['major']}.{hw_rev_d['rev']['minor']}"
+        )
+
+    @pyqtSlot("QVariantMap")
+    def fan_update(self, fan_settings):
+        logging.debug(fan_settings)
+        if fan_settings is None:
+            return
+        with QSignalBlocker(self.thermostat_ctrl_menu.fan_power_slider):
+            self.thermostat_ctrl_menu.fan_power_slider.setValue(
+                fan_settings["fan_pwm"] or 100  # 0 = PWM off = full strength
+            )
+        with QSignalBlocker(self.thermostat_ctrl_menu.fan_auto_box):
+            self.thermostat_ctrl_menu.fan_auto_box.setChecked(fan_settings["auto_mode"])
+        if not self.hw_rev_data["settings"]["fan_pwm_recommended"]:
+            self.thermostat_ctrl_menu.set_fan_pwm_warning()
+
+    @asyncSlot(int)
+    async def on_report_box_stateChanged(self, enabled):
+        await self.thermostat.set_report_mode(enabled)
+
+    @asyncClose
+    async def closeEvent(self, event):
+        try:
+            await self.bail()
+        except:
+            pass
+
+    @asyncSlot()
+    async def on_connect_btn_clicked(self):
+        host, port = (
+            self.conn_menu.host_set_line.text(),
+            self.conn_menu.port_set_spin.value(),
+        )
+        try:
+            if not (self.client.connecting() or self.client.connected()):
+                self.status_lbl.setText("Connecting...")
+                self.connect_btn.setText("Stop")
+                self.conn_menu.host_set_line.setEnabled(False)
+                self.conn_menu.port_set_spin.setEnabled(False)
+
+                try:
+                    await self.client.start_session(host=host, port=port, timeout=5)
+                except StoppedConnecting:
+                    return
+                await self._on_connection_changed(True)
+            else:
+                await self.bail()
+
+        # TODO: Remove asyncio.TimeoutError in Python 3.11
+        except (OSError, TimeoutError, asyncio.TimeoutError):
+            try:
+                await self.bail()
+            except ConnectionResetError:
+                pass
+
+    @asyncSlot()
+    async def bail(self):
+        await self._on_connection_changed(False)
+        await self.client.end_session()
+
+    @asyncSlot(object, object)
+    async def send_command(self, param, changes):
+        """Translates parameter tree changes into thermostat set_param calls"""
+        ch = param.value()
+
+        for inner_param, change, data in changes:
+            if change == "value":
+                new_value = data
+                if "thermostat:set_param" in inner_param.opts:
+                    thermostat_param = inner_param.opts["thermostat:set_param"]
+
+                    # Handle thermostat command irregularities
+                    match inner_param.name(), new_value:
+                        case "rate", None:
+                            thermostat_param = thermostat_param.copy()
+                            thermostat_param["field"] = "off"
+                            new_value = ""
+                        case "control_method", "constant_current":
+                            thermostat_param = thermostat_param.copy()
+                            thermostat_param["field"] = "i_set"
+                            new_value = inner_param.child("i_set").value()
+                        case "control_method", "temperature_pid":
+                            new_value = ""
+
+                    inner_param.setOpts(lock=True)
+                    await self.client.set_param(
+                        channel=ch, value=new_value, **thermostat_param
+                    )
+                    inner_param.setOpts(lock=False)
+
+                if "pid_autotune" in inner_param.opts:
+                    auto_tuner_param = inner_param.opts["pid_autotune"]
+                    self.autotuners.set_params(auto_tuner_param, ch, new_value)
+
+    @asyncSlot()
+    async def pid_autotune_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)
+                # To Update the UI elements
+                self.pid_autotune_handler([])
+
+    @asyncSlot(list)
+    async def pid_autotune_handler(self, _):
+        ch_tuning = []
+        for ch in range(self.NUM_CHANNELS):
+            match self.autotuners.get_state(ch):
+                case PIDAutotuneState.STATE_OFF:
+                    self.ctrl_panel_view.change_params_title(
+                        ch, ("pid", "pid_autotune", "run_pid"), "Run"
+                    )
+                case PIDAutotuneState.STATE_READY | PIDAutotuneState.STATE_RELAY_STEP_UP | PIDAutotuneState.STATE_RELAY_STEP_DOWN:
+                    self.ctrl_panel_view.change_params_title(
+                        ch, ("pid", "pid_autotune", "run_pid"), "Stop"
+                    )
+                    ch_tuning.append(ch)
+
+                case PIDAutotuneState.STATE_SUCCEEDED:
+                    self.info_box.display_info_box(
+                        "PID Autotune Success",
+                        f"Channel {ch} PID Settings has been loaded to Thermostat. Regulating temperature.",
+                    )
+                    self.info_box.show()
+
+                case PIDAutotuneState.STATE_FAILED:
+                    self.info_box.display_info_box(
+                        "PID Autotune Failed", f"Channel {ch} PID Autotune has failed."
+                    )
+                    self.info_box.show()
+
+        if len(ch_tuning) == 0:
+            self.background_task_lbl.setText("Ready.")
+            self.loading_spinner.hide()
+            self.loading_spinner.stop()
+        else:
+            self.background_task_lbl.setText(
+                "Autotuning channel {ch}...".format(ch=ch_tuning)
+            )
+            self.loading_spinner.start()
+            self.loading_spinner.show()
+
+    @asyncSlot(int)
+    async def fan_set_request(self, value):
+        if not self.client.connected():
+            return
+        if self.thermostat_ctrl_menu.fan_auto_box.isChecked():
+            with QSignalBlocker(self.thermostat_ctrl_menu.fan_auto_box):
+                self.thermostat_ctrl_menu.fan_auto_box.setChecked(False)
+        await self.client.set_fan(value)
+        if not self.hw_rev_data["settings"]["fan_pwm_recommended"]:
+            self.thermostat_ctrl_menu.set_fan_pwm_warning()
+
+    @asyncSlot(int)
+    async def fan_auto_set_request(self, enabled):
+        if not self.client.connected():
+            return
+        if enabled:
+            await self.client.set_fan("auto")
+            self.fan_update(await self.client.get_fan())
+        else:
+            await self.client.set_fan(
+                self.thermostat_ctrl_menu.fan_power_slider.value()
+            )
+
+    @asyncSlot(int)
+    async def save_cfg_request(self, ch):
+        await self.thermostat.save_cfg(str(ch))
+
+    @asyncSlot(int)
+    async def load_cfg_request(self, ch):
+        await self.thermostat.load_cfg(str(ch))
+
+    @asyncSlot(bool)
+    async def dfu_request(self, _):
+        await self._on_connection_changed(False)
+        await self.thermostat.dfu()
+
+    @asyncSlot(bool)
+    async def reset_request(self, _):
+        await self._on_connection_changed(False)
+        await self.thermostat.reset()
+        await asyncio.sleep(0.1)  # Wait for the reset to start
+
+        self.connect_btn.click()  # Reconnect
+
+    @asyncSlot(bool)
+    async def net_settings_request(self, _):
+        ipv4 = await self.thermostat.get_ipv4()
+        self.net_settings_input_diag = NetSettingsInputDiag(ipv4["addr"])
+        self.net_settings_input_diag.set_ipv4_act.connect(self.set_net_settings_request)
+
+    @asyncSlot(str)
+    async def set_net_settings_request(self, ipv4_settings):
+        await self.thermostat.set_ipv4(ipv4_settings)
+        await self.thermostat._client.end_session()
+        await self._on_connection_changed(False)
+
+
+async def coro_main():
+    args = get_argparser().parse_args()
+    if args.logLevel:
+        logging.basicConfig(level=getattr(logging, args.logLevel))
+
+    app_quit_event = asyncio.Event()
+
+    app = QtWidgets.QApplication.instance()
+    app.aboutToQuit.connect(app_quit_event.set)
+    app.setWindowIcon(
+        QtGui.QIcon(str(importlib.resources.files("pytec.gui.resources").joinpath("artiq.ico")))
+    )
+
+    main_window = MainWindow(args)
+    main_window.show()
+
+    await app_quit_event.wait()
+
+
+def main():
+    qasync.run(coro_main())
+
+
+if __name__ == "__main__":
+    main()