State

All calls to the Thermostat should be forwarded by the medium.

pytec/pytec/gui/model/pid_autotuner.py

@@ -28,7 +28,7 @@ class PIDAutoTuner(QObject):
     def load_params_and_set_ready(self, ch):
         self.autotuners[ch].setParam(
             self.target_temp[ch],
-            self.test_current[ch],
+            self.test_current[ch] / 1000,
             self.temp_swing[ch],
             1 / self.sampling_interval[ch],
             self.lookback[ch],

pytec/pytec/gui/model/thermostat.py

@@ -3,9 +3,16 @@ from qasync import asyncSlot
 from pytec.gui.model.property import Property, PropertyMeta
 import asyncio
 import logging
+from enum import Enum
 from pytec.aioclient import AsyncioClient
 
 
+class ThermostatConnectionState(Enum):
+    STATE_DISCONNECTED = "disconnected"
+    STATE_CONNECTING = "connecting"
+    STATE_CONNECTED = "connected"
+
+
 class Thermostat(QObject, metaclass=PropertyMeta):
     hw_rev = Property(dict)
     fan = Property(dict)
@@ -109,14 +116,14 @@ class Thermostat(QObject, metaclass=PropertyMeta):
     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."
+            "Config saved", f"Channel {ch} Config has been saved from 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."
+            "Config loaded", f"Channel {ch} Config has been loaded from flash."
         )
 
     async def dfu(self):

pytec/pytec/gui/view/ctrl_panel.py

@@ -4,14 +4,42 @@ from pyqtgraph.parametertree import (
     Parameter,
     registerParameterType,
 )
-import pytec.gui.view.lockable_unit
 
 
-def set_tree_label_tips(tree):
+class MutexParameter(pTypes.ListParameter):
-    for item in tree.listAllItems():
+    """
-        p = item.param
+    Mutually exclusive parameter where only one of its children is visible at a time, list selectable.
-        if "tip" in p.opts:
+
-            item.setToolTip(0, p.opts["tip"])
+    The ordering of the list items determines which children will be visible.
+    """
+
+    def __init__(self, **opts):
+        super().__init__(**opts)
+
+        self.sigValueChanged.connect(self.show_chosen_child)
+        self.sigValueChanged.emit(self, self.opts["value"])
+
+    def _get_param_from_value(self, value):
+        if isinstance(self.opts["limits"], dict):
+            values_list = list(self.opts["limits"].values())
+        else:
+            values_list = self.opts["limits"]
+
+        return self.children()[values_list.index(value)]
+
+    @pyqtSlot(object, object)
+    def show_chosen_child(self, value):
+        for param in self.children():
+            param.hide()
+
+        child_to_show = self._get_param_from_value(value.value())
+        child_to_show.show()
+
+        if child_to_show.opts.get("triggerOnShow", None):
+            child_to_show.sigValueChanged.emit(child_to_show, child_to_show.value())
+
+
+registerParameterType("mutex", MutexParameter)
 
 
 class CtrlPanel(QObject):
@@ -30,63 +58,55 @@ class CtrlPanel(QObject):
         self.trees_ui = trees_ui
         self.NUM_CHANNELS = len(trees_ui)
 
-        def _set_value_with_lock(self, value):
+        self.THERMOSTAT_PARAMETERS = [param_tree for i in range(self.NUM_CHANNELS)]
-            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,
+                children=self.THERMOSTAT_PARAMETERS[ch],
             )
             for ch in range(self.NUM_CHANNELS)
         ]
 
-        for ch, tree in enumerate(self.trees_ui):
+        for i, param in enumerate(self.params):
+            param.channel = i
+
+        for i, tree in enumerate(self.trees_ui):
             tree.setHeaderHidden(True)
-            tree.setParameters(self.params[ch], showTop=False)
+            tree.setParameters(self.params[i], showTop=False)
+            self.params[i].setValue = self._setValue
+            self.params[i].sigTreeStateChanged.connect(sigTreeStateChanged_handle)
 
-            set_tree_label_tips(tree)
+            for handle in sigActivated_handles[i]:
+                self.params[i].child(*handle[0]).sigActivated.connect(handle[1])
 
-        for ch, param in enumerate(self.params):
+    def _setValue(self, value, blockSignal=None):
-            param.sigTreeStateChanged.connect(sigTreeStateChanged_handle)
+        """
+        Implement 'lock' mechanism for Parameter Type
 
-            for handle in sigActivated_handles[ch]:
+        Modified from the source
-                param.child(*handle[0]).sigActivated.connect(handle[1])
+        """
+        try:
+            if blockSignal is not None:
+                self.sigValueChanged.disconnect(blockSignal)
+            value = self._interpretValue(value)
+            if fn.eq(self.opts["value"], value):
+                return value
 
-            self.params[ch].child("output", "control_method").sigValueChanged.connect(
+            if "lock" in self.opts.keys():
-                lambda param, value: param.parent()
+                if self.opts["lock"]:
-                .parent()
+                    return value
-                .child("pid")
+            self.opts["value"] = value
-                .setOpts(expanded=(value == "temperature_pid"))
+            self.sigValueChanged.emit(
-            )
+                self, value
+            )  # value might change after signal is received by tree item
+        finally:
+            if blockSignal is not None:
+                self.sigValueChanged.connect(blockSignal)
 
-            def _indicate_usage(param, control_method="constant_current"):
+        return self.opts["value"]
-                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)
@@ -96,59 +116,57 @@ class CtrlPanel(QObject):
         for settings in pid_settings:
             channel = settings["channel"]
             with QSignalBlocker(self.params[channel]):
-                self.params[channel].child("pid", "kp").set_value_with_lock(
+                self.params[channel].child("PID Config", "Kp").setValue(
                     settings["parameters"]["kp"]
                 )
-                self.params[channel].child("pid", "ki").set_value_with_lock(
+                self.params[channel].child("PID Config", "Ki").setValue(
                     settings["parameters"]["ki"]
                 )
-                self.params[channel].child("pid", "kd").set_value_with_lock(
+                self.params[channel].child("PID Config", "Kd").setValue(
                     settings["parameters"]["kd"]
                 )
                 self.params[channel].child(
-                    "pid", "pid_output_clamping", "output_min"
+                    "PID Config", "PID Output Clamping", "Minimum"
-                ).set_value_with_lock(settings["parameters"]["output_min"])
+                ).setValue(settings["parameters"]["output_min"] * 1000)
                 self.params[channel].child(
-                    "pid", "pid_output_clamping", "output_max"
+                    "PID Config", "PID Output Clamping", "Maximum"
-                ).set_value_with_lock(settings["parameters"]["output_max"])
+                ).setValue(settings["parameters"]["output_max"] * 1000)
                 self.params[channel].child(
-                    "output", "control_method", "target"
+                    "Output Config", "Control Method", "Set Temperature"
-                ).set_value_with_lock(settings["target"])
+                ).setValue(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(
+                self.params[channel].child("Output Config", "Control Method").setValue(
-                    "output", "control_method"
+                    "Temperature PID" if settings["pid_engaged"] else "Constant Current"
-                ).set_value_with_lock(
-                    "temperature_pid" if settings["pid_engaged"] else "constant_current"
                 )
                 self.params[channel].child(
-                    "output", "control_method", "i_set"
+                    "Output Config", "Control Method", "Set Current"
-                ).set_value_with_lock(settings["i_set"])
+                ).setValue(settings["i_set"] * 1000)
                 if settings["temperature"] is not None:
-                    self.params[channel].child(
+                    self.params[channel].child("Temperature").setValue(
-                        "readings", "temperature"
+                        settings["temperature"]
-                    ).set_value_with_lock(settings["temperature"])
+                    )
                     if settings["tec_i"] is not None:
-                        self.params[channel].child(
+                        self.params[channel].child("Current through TEC").setValue(
-                            "readings", "tec_i"
+                            settings["tec_i"] * 1000
-                        ).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(
+                self.params[channel].child("Thermistor Config", "T₀").setValue(
                     sh_param["params"]["t0"] - 273.15
                 )
-                self.params[channel].child("thermistor", "r0").set_value_with_lock(
+                self.params[channel].child("Thermistor Config", "R₀").setValue(
                     sh_param["params"]["r0"]
                 )
-                self.params[channel].child("thermistor", "b").set_value_with_lock(
+                self.params[channel].child("Thermistor Config", "B").setValue(
                     sh_param["params"]["b"]
                 )
 
@@ -160,14 +178,14 @@ class CtrlPanel(QObject):
             channel = pwm_params["channel"]
             with QSignalBlocker(self.params[channel]):
                 self.params[channel].child(
-                    "output", "limits", "max_v"
+                    "Output Config", "Limits", "Max Voltage Difference"
-                ).set_value_with_lock(pwm_params["max_v"]["value"])
+                ).setValue(pwm_params["max_v"]["value"])
                 self.params[channel].child(
-                    "output", "limits", "max_i_pos"
+                    "Output Config", "Limits", "Max Cooling Current"
-                ).set_value_with_lock(pwm_params["max_i_pos"]["value"])
+                ).setValue(pwm_params["max_i_pos"]["value"] * 1000)
                 self.params[channel].child(
-                    "output", "limits", "max_i_neg"
+                    "Output Config", "Limits", "Max Heating Current"
-                ).set_value_with_lock(pwm_params["max_i_neg"]["value"])
+                ).setValue(pwm_params["max_i_neg"]["value"] * 1000)
 
             for limit in "max_i_pos", "max_i_neg", "max_v":
                 if pwm_params[limit]["value"] == 0.0:
@@ -179,6 +197,6 @@ class CtrlPanel(QObject):
         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(
+                self.params[channel].child(
-                    postfilter_params["rate"]
+                    "Thermistor Config", "Postfilter Rate"
-                )
+                ).setValue(postfilter_params["rate"])

pytec/pytec/gui/view/lockable_unit.py

@@ -1,185 +0,0 @@
-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/param_tree.json

@@ -1,47 +1,30 @@
 {
     "ctrl_panel":[
        {
-         "name": "readings",
+          "name":"Temperature",
-         "title": "Readings",
-         "type": "group",
-         "tip": "Thermostat readings",
-         "children": [
-            {
-               "name": "temperature",
-               "title": "Temperature",
           "type":"float",
-               "format": "{value:.4f} {suffix}",
+          "format":"{value:.4f} °C",
-               "suffix": "°C",
+          "readonly":true
-               "readonly": true,
-               "tip": "The measured temperature at the thermistor"
        },
        {
-               "name": "tec_i",
+          "name":"Current through TEC",
-               "title": "Current through TEC",
           "type":"float",
-               "siPrefix": true,
+          "suffix":"mA",
-               "suffix": "A",
           "decimals":6,
-               "readonly": true,
+          "readonly":true
-               "tip": "The measured current through the TEC"
-            }
-         ]
        },
        {
-         "name": "output",
+          "name":"Output Config",
-         "title": "Output Settings",
           "expanded":true,
           "type":"group",
-         "tip": "Settings of the output to the TEC",
           "children":[
              {
-               "name": "control_method",
+                "name":"Control Method",
-               "title": "Control Method",
+                "type":"mutex",
-               "type": "list",
+                "limits":[
-               "limits": {
+                   "Constant Current",
-                  "Constant Current": "constant_current",
+                   "Temperature PID"
-                  "Temperature PID": "temperature_pid"
+                ],
-               },
                 "activaters":[
                    null,
                    [
@@ -50,35 +33,28 @@
                       "pid"
                    ]
                 ],
-               "tip": "Select control method of output",
                 "children":[
                    {
-                     "name": "i_set",
+                      "name":"Set Current",
-                     "title": "Set Current",
                       "type":"float",
                       "value":0,
-                     "step": 0.1,
+                      "step":100,
                       "limits":[
-                        -2,
+                         -2000,
-                        2
+                         2000
                       ],
+                      "triggerOnShow":true,
                       "decimals":6,
-                     "pinSiPrefix": "m",
+                      "suffix":"mA",
-                     "suffix": "A",
-                     "siPrefix": true,
-                     "noUnitEditing": true,
-                     "compactHeight": false,
                       "param":[
                          "pwm",
                          "ch",
                          "i_set"
                       ],
-                     "tip": "The set current through TEC",
                       "lock":false
                    },
                    {
-                     "name": "target",
+                      "name":"Set Temperature",
-                     "title": "Setpoint",
                       "type":"float",
                       "value":25,
                       "step":0.1,
@@ -86,95 +62,73 @@
                          -273,
                          300
                       ],
-                     "format": "{value:.4f} {suffix}",
+                      "format":"{value:.4f} °C",
-                     "suffix": "°C",
-                     "noUnitEditing": true,
-                     "compactHeight": false,
                       "param":[
                          "pid",
                          "ch",
                          "target"
                       ],
-                     "tip": "The temperature setpoint of the TEC",
                       "lock":false
                    }
                 ]
              },
              {
-               "name": "limits",
+                "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",
+                      "name":"Max Cooling Current",
-                     "title": "Max Cooling Current",
                       "type":"float",
                       "value":0,
-                     "step": 0.1,
+                      "step":100,
                       "decimals":6,
                       "limits":[
                          0,
-                        2
+                         2000
                       ],
-                     "siPrefix": true,
+                      "suffix":"mA",
-                     "pinSiPrefix": "m",
-                     "suffix": "A",
-                     "noUnitEditing": true,
-                     "compactHeight": false,
                       "param":[
                          "pwm",
                          "ch",
                          "max_i_pos"
                       ],
-                     "tip": "The maximum cooling (+ve) current through the output pins",
                       "lock":false
                    },
                    {
-                     "name": "max_i_neg",
+                      "name":"Max Heating Current",
-                     "title": "Max Heating Current",
                       "type":"float",
                       "value":0,
-                     "step": 0.1,
+                      "step":100,
                       "decimals":6,
-                     "siPrefix": true,
-                     "pinSiPrefix": "m",
-                     "suffix": "A",
-                     "noUnitEditing": true,
                       "limits":[
                          0,
-                        2
+                         2000
                       ],
-                     "compactHeight": false,
+                      "suffix":"mA",
                       "param":[
                          "pwm",
                          "ch",
                          "max_i_neg"
                       ],
-                     "tip": "The maximum heating (-ve) current through the output pins",
                       "lock":false
                    },
                    {
-                     "name": "max_v",
+                      "name":"Max Voltage Difference",
-                     "title": "Max Absolute Voltage",
                       "type":"float",
                       "value":0,
                       "step":0.1,
-                     "decimals": 3,
                       "limits":[
                          0,
-                        4
+                         5
                       ],
+                      "siPrefix":true,
                       "suffix":"V",
-                     "noUnitEditing": true,
-                     "compactHeight": false,
                       "param":[
                          "pwm",
                          "ch",
                          "max_v"
                       ],
-                     "tip": "The maximum voltage (in both directions) across the output pins",
                       "lock":false
                    }
                 ]
@@ -182,15 +136,12 @@
           ]
        },
        {
-         "name": "thermistor",
+          "name":"Thermistor Config",
-         "title": "Thermistor Settings",
           "expanded":true,
           "type":"group",
-         "tip": "Parameters for the resistance to temperature conversion with the B-Parameter equation",
           "children":[
              {
-               "name": "t0",
+                "name":"T₀",
-               "title": "T₀",
                 "type":"float",
                 "value":25,
                 "step":0.1,
@@ -198,67 +149,44 @@
                    -100,
                    100
                 ],
-               "format": "{value:.4f} {suffix}",
+                "format":"{value:.4f} °C",
-               "suffix": "°C",
-               "noUnitEditing": true,
-               "compactHeight": false,
                 "param":[
                    "s-h",
                    "ch",
                    "t0"
                 ],
-               "tip": "The base temperature",
                 "lock":false
              },
              {
-               "name": "r0",
+                "name":"R₀",
-               "title": "R₀",
                 "type":"float",
                 "value":10000,
-               "step": 100,
+                "step":1,
-               "min": 0,
                 "siPrefix":true,
-               "pinSiPrefix": "k",
                 "suffix":"Ω",
-               "noUnitEditing": true,
-               "compactHeight": false,
                 "param":[
                    "s-h",
                    "ch",
                    "r0"
                 ],
-               "tip": "The resistance of the thermistor at base temperature T₀",
                 "lock":false
              },
              {
-               "name": "b",
+                "name":"B",
-               "title": "B",
                 "type":"float",
                 "value":3950,
-               "step": 10,
+                "step":1,
                 "suffix":"K",
-               "noUnitEditing": true,
                 "decimals":4,
-               "compactHeight": false,
                 "param":[
                    "s-h",
                    "ch",
                    "b"
                 ],
-               "tip": "The Beta Parameter",
                 "lock":false
-            }
-         ]
              },
              {
-         "name": "postfilter",
+                "name":"Postfilter Rate",
-         "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,
                 "param":[
@@ -267,223 +195,171 @@
                    "rate"
                 ],
                 "limits":{
-                  "16.67 SPS": 16.67,
+                   "Off":null,
-                  "20 SPS": 20.0,
+                   "16.67 Hz":16.67,
-                  "21.25 SPS": 21.25,
+                   "20 Hz":20.0,
-                  "27 SPS": 27.0,
+                   "21.25 Hz":21.25,
-                  "Off": null
+                   "27 Hz":27.0
                 },
-               "tip": "Adjust the output data rate of the enhanced 50 Hz & 60 Hz rejection filter\n(Helps avoid mains interference)",
                 "lock":false
              }
           ]
        },
        {
-         "name": "pid",
+          "name":"PID Config",
-         "title": "PID Settings",
+          "expanded":true,
-         "expanded": false,
           "type":"group",
-         "tip": "Settings of PID parameters and clamping",
           "children":[
              {
-               "name": "kp",
+                "name":"Kp",
-               "title": "Kp",
                 "type":"float",
                 "step":0.1,
-               "compactHeight": false,
+                "suffix":"",
                 "param":[
                    "pid",
                    "ch",
                    "kp"
                 ],
-               "tip": "Proportional gain",
                 "lock":false
              },
              {
-               "name": "ki",
+                "name":"Ki",
-               "title": "Ki",
                 "type":"float",
                 "step":0.1,
                 "suffix":"Hz",
-               "noUnitEditing": true,
-               "compactHeight": false,
                 "param":[
                    "pid",
                    "ch",
                    "ki"
                 ],
-               "tip": "Integral gain",
                 "lock":false
              },
              {
-               "name": "kd",
+                "name":"Kd",
-               "title": "Kd",
                 "type":"float",
                 "step":0.1,
                 "suffix":"s",
-               "noUnitEditing": true,
-               "compactHeight": false,
                 "param":[
                    "pid",
                    "ch",
                    "kd"
                 ],
-               "tip": "Differential gain",
                 "lock":false
              },
              {
-               "name": "pid_output_clamping",
+                "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",
+                      "name":"Minimum",
-                     "title": "Minimum",
                       "type":"float",
-                     "step": 0.1,
+                      "step":100,
                       "limits":[
-                        -2,
+                         -2000,
-                        2
+                         2000
                       ],
                       "decimals":6,
-                     "siPrefix": true,
+                      "suffix":"mA",
-                     "pinSiPrefix": "m",
-                     "suffix": "A",
-                     "noUnitEditing": true,
-                     "compactHeight": false,
                       "param":[
                          "pid",
                          "ch",
                          "output_min"
                       ],
-                     "tip": "Minimum PID output",
                       "lock":false
                    },
                    {
-                     "name": "output_max",
+                      "name":"Maximum",
-                     "title": "Maximum",
                       "type":"float",
-                     "step": 0.1,
+                      "step":100,
                       "limits":[
-                        -2,
+                         -2000,
-                        2
+                         2000
                       ],
                       "decimals":6,
-                     "siPrefix": true,
+                      "suffix":"mA",
-                     "pinSiPrefix": "m",
-                     "suffix": "A",
-                     "noUnitEditing": true,
-                     "compactHeight": false,
                       "param":[
                          "pid",
                          "ch",
                          "output_max"
                       ],
-                     "tip": "Maximum PID output",
                       "lock":false
                    }
                 ]
              },
              {
-               "name": "pid_autotune",
+                "name":"PID Auto Tune",
-               "title": "PID Autotune",
                 "expanded":false,
                 "type":"group",
-               "tip": "Automatically tune PID parameters",
                 "children":[
                    {
-                     "name": "target_temp",
+                      "name":"Target Temperature",
-                     "title": "Target Temperature",
                       "type":"float",
                       "value":20,
                       "step":0.1,
-                     "format": "{value:.4f} {suffix}",
+                      "format":"{value:.4f} °C",
-                     "suffix": "°C",
-                     "noUnitEditing": true,
-                     "compactHeight": false,
                       "pid_autotune":[
                          "target_temp",
                          "ch"
-                     ],
+                      ]
-                     "tip": "The target temperature to autotune for"
                    },
                    {
-                     "name": "test_current",
+                      "name":"Test Current",
-                     "title": "Test Current",
                       "type":"float",
                       "value":0,
                       "decimals":6,
-                     "step": 0.1,
+                      "step":100,
                       "limits":[
-                        0,
+                         -2000,
-                        2
+                         2000
                       ],
-                     "siPrefix": true,
+                      "suffix":"mA",
-                     "pinSiPrefix": "m",
-                     "suffix": "A",
-                     "noUnitEditing": true,
-                     "compactHeight": false,
                       "pid_autotune":[
                          "test_current",
                          "ch"
-                     ],
+                      ]
-                     "tip": "The testing current when autotuning"
                    },
                    {
-                     "name": "temp_swing",
+                      "name":"Temperature Swing",
-                     "title": "Temperature Swing",
                       "type":"float",
                       "value":1.5,
                       "step":0.1,
-                     "format": "{value:.4f} {suffix}",
+                      "prefix":"±",
-                     "suffix": "K",
+                      "format":"{value:.4f} °C",
-                     "noUnitEditing": true,
-                     "compactHeight": false,
                       "pid_autotune":[
                          "temp_swing",
                          "ch"
-                     ],
+                      ]
-                     "tip": "The temperature swing around the target"
                    },
                    {
-                     "name": "lookback",
+                     "name":"Lookback",
-                     "title": "Lookback",
                      "type":"float",
                      "value":3.0,
                      "step":0.1,
-                     "format": "{value:.4f} {suffix}",
+                     "format":"{value:.4f} s",
-                     "noUnitEditing": true,
-                     "suffix": "s",
-                     "compactHeight": false,
                      "pid_autotune":[
                         "lookback",
                         "ch"
-                     ],
+                     ]
-                     "tip": "Amount of time referenced for tuning"
                   },
                    {
-                     "name": "run_pid",
+                      "name":"Run",
-                     "title": "Run",
                       "type":"action",
-                     "tip": "Run PID Autotune with above settings"
+                      "tip":"Run"
                    }
                 ]
              }
           ]
        },
        {
-         "name": "save",
+          "name":"Save to flash",
-         "title": "Save to flash",
           "type":"action",
-         "tip": "Save settings to thermostat, applies on reset"
+          "tip":"Save config to thermostat, applies on reset"
        },
        {
-         "name": "load",
+          "name":"Load from flash",
-         "title": "Load from flash",
           "type":"action",
-         "tip": "Load settings from thermostat"
+          "tip":"Load config from flash"
        }
     ]
  }

pytec/tec_qt.py

@@ -75,8 +75,8 @@ class MainWindow(QtWidgets.QMainWindow):
 
         self.thermostat.connection_error.connect(handle_connection_error)
 
-        self.client.connection_error.connect(self.thermostat.timed_out)
+        self.thermostat.connection_error.connect(self.thermostat.timed_out)
-        self.client.connection_error.connect(self.bail)
+        self.thermostat.connection_error.connect(self.bail)
 
         self.autotuners = PIDAutoTuner(self, self.thermostat, 2)
 
@@ -86,11 +86,11 @@ class MainWindow(QtWidgets.QMainWindow):
 
         param_tree_sigActivated_handles = [
             [
-                [["save"], partial(self.thermostat.save_cfg, ch)],
+                [["Save to flash"], partial(self.thermostat.save_cfg, ch)],
-                [["load"], partial(self.thermostat.load_cfg, ch)],
+                [["Load from flash"], partial(self.thermostat.load_cfg, ch)],
                 [
-                    ["pid", "pid_autotune", "run_pid"],
+                    ["PID Config", "PID Auto Tune", "Run"],
-                    partial(self.pid_autotune_request, ch),
+                    partial(self.pid_auto_tune_request, ch),
                 ],
             ]
             for ch in range(self.NUM_CHANNELS)
@@ -276,21 +276,24 @@ class MainWindow(QtWidgets.QMainWindow):
     @asyncSlot()
     async def bail(self):
         await self._on_connection_changed(False)
-        await self.thermostat.disconnect()
+        await self.thermostat.end_session()
 
     @asyncSlot(object, object)
     async def send_command(self, param, changes):
         """Translates parameter tree changes into thermostat set_param calls"""
-        ch = param.value()
+        ch = param.channel
 
         for inner_param, change, data in changes:
             if change == "value":
                 if inner_param.opts.get("param", None) is not None:
+                    if inner_param.opts.get("suffix", None) == "mA":
+                        data /= 1000  # Given in mA
+
                     thermostat_param = inner_param.opts["param"]
                     if thermostat_param[1] == "ch":
                         thermostat_param[1] = ch
 
-                    if inner_param.name() == "rate" and data is None:
+                    if inner_param.name() == "Postfilter Rate" and data is None:
                         set_param_args = (*thermostat_param[:2], "off")
                     else:
                         set_param_args = (*thermostat_param, data)
@@ -299,26 +302,22 @@ class MainWindow(QtWidgets.QMainWindow):
                     param.child(*param.childPath(inner_param)).setOpts(lock=False)
 
                 if inner_param.opts.get("pid_autotune", None) is not None:
-                    autotuner_param = inner_param.opts["pid_autotune"][0]
+                    auto_tuner_param = inner_param.opts["pid_autotune"][0]
                     if inner_param.opts["pid_autotune"][1] != "ch":
                         ch = inner_param.opts["pid_autotune"][1]
-                    self.autotuners.set_params(autotuner_param, ch, data)
+                    self.autotuners.set_params(auto_tuner_param, ch, data)
 
                 if inner_param.opts.get("activaters", None) is not None:
                     activater = inner_param.opts["activaters"][
-                        inner_param.reverse[0].index(data)  # ListParameter.reverse = list of codename values
+                        inner_param.opts["limits"].index(data)
                     ]
                     if activater is not None:
                         if activater[1] == "ch":
                             activater[1] = ch
                         await self.thermostat.set_param(*activater)
-                    else:
-                        await self.thermostat.set_param(
-                            "pwm", ch, "i_set", inner_param.child("i_set").value()
-                        )
 
     @asyncSlot()
-    async def pid_autotune_request(self, ch=0):
+    async def pid_auto_tune_request(self, ch=0):
         match self.autotuners.get_state(ch):
             case PIDAutotuneState.STATE_OFF | PIDAutotuneState.STATE_FAILED:
                 self.autotuners.load_params_and_set_ready(ch)
@@ -339,7 +338,7 @@ class MainWindow(QtWidgets.QMainWindow):
             match self.autotuners.get_state(ch):
                 case PIDAutotuneState.STATE_OFF:
                     self.ctrl_panel_view.change_params_title(
-                        ch, ("pid", "pid_autotune", "run_pid"), "Run"
+                        ch, ("PID Config", "PID Auto Tune", "Run"), "Run"
                     )
                 case (
                     PIDAutotuneState.STATE_READY
@@ -347,14 +346,14 @@ class MainWindow(QtWidgets.QMainWindow):
                     | PIDAutotuneState.STATE_RELAY_STEP_DOWN
                 ):
                     self.ctrl_panel_view.change_params_title(
-                        ch, ("pid", "pid_autotune", "run_pid"), "Stop"
+                        ch, ("PID Config", "PID Auto Tune", "Run"), "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.",
+                        f"Channel {ch} PID Config has been loaded to Thermostat. Regulating temperature.",
                     )
                     self.info_box.show()