ctrl_panel: Reformat SpinBox text always if valid

The parameter SpinBoxes previously would only update if the interpreted
value was changed, missing cases where the text would have changed but
the value stays the same, e.g. removing trailing decimal zeros.

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] / 1000,
+            self.test_current[ch],
             self.temp_swing[ch],
             1 / self.sampling_interval[ch],
             self.lookback[ch],

pytec/pytec/gui/model/thermostat.py

@@ -117,14 +117,14 @@ class Thermostat(QObject, metaclass=PropertyMeta):
     async def save_cfg(self, ch):
         await self._client.save_config(ch)
         self.info_box_trigger.emit(
-            "Config saved", f"Channel {ch} Config has been saved from flash."
+            "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(
-            "Config loaded", f"Channel {ch} Config has been loaded from flash."
+            "Settings loaded", f"Channel {ch} Settings has been loaded from flash."
         )
 
     async def dfu(self):

pytec/pytec/gui/view/ctrl_panel.py

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

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/param_tree.json

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

pytec/tec_qt.py

@@ -78,11 +78,11 @@ class MainWindow(QtWidgets.QMainWindow):
 
         param_tree_sigActivated_handles = [
             [
-                [["Save to flash"], partial(self.thermostat.save_cfg, ch)],
+                [["save"], partial(self.thermostat.save_cfg, ch)],
-                [["Load from flash"], partial(self.thermostat.load_cfg, ch)],
+                [["load"], partial(self.thermostat.load_cfg, ch)],
                 [
-                    ["PID Config", "PID Auto Tune", "Run"],
+                    ["pid", "pid_autotune", "run_pid"],
-                    partial(self.pid_auto_tune_request, ch),
+                    partial(self.pid_autotune_request, ch),
                 ],
             ]
             for ch in range(self.NUM_CHANNELS)
@@ -262,19 +262,16 @@ class MainWindow(QtWidgets.QMainWindow):
     @asyncSlot(object, object)
     async def send_command(self, param, changes):
         """Translates parameter tree changes into thermostat set_param calls"""
-        ch = param.channel
+        ch = param.value()
 
         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() == "Postfilter Rate" and data is None:
+                    if inner_param.name() == "rate" and data is None:
                         set_param_args = (*thermostat_param[:2], "off")
                     else:
                         set_param_args = (*thermostat_param, data)
@@ -283,22 +280,26 @@ class MainWindow(QtWidgets.QMainWindow):
                     param.child(*param.childPath(inner_param)).setOpts(lock=False)
 
                 if inner_param.opts.get("pid_autotune", None) is not None:
-                    auto_tuner_param = inner_param.opts["pid_autotune"][0]
+                    autotuner_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(auto_tuner_param, ch, data)
+                    self.autotuners.set_params(autotuner_param, ch, data)
 
                 if inner_param.opts.get("activaters", None) is not None:
                     activater = inner_param.opts["activaters"][
-                        inner_param.opts["limits"].index(data)
+                        inner_param.reverse[0].index(data)  # ListParameter.reverse = list of codename values
                     ]
                     if activater is not None:
                         if activater[1] == "ch":
                             activater[1] = ch
                         await self.client.set_param(*activater)
+                    else:
+                        await self.client.set_param(
+                            "pwm", ch, "i_set", inner_param.child("i_set").value()
+                        )
 
     @asyncSlot()
-    async def pid_auto_tune_request(self, ch=0):
+    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)
@@ -315,18 +316,18 @@ class MainWindow(QtWidgets.QMainWindow):
             match self.autotuners.get_state(ch):
                 case PIDAutotuneState.STATE_OFF:
                     self.ctrl_panel_view.change_params_title(
-                        ch, ("PID Config", "PID Auto Tune", "Run"), "Run"
+                        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 Config", "PID Auto Tune", "Run"), "Stop"
+                        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 Config has been loaded to Thermostat. Regulating temperature.",
+                        f"Channel {ch} PID Settings has been loaded to Thermostat. Regulating temperature.",
                     )
                     self.info_box.show()