Try make the i_set parameter adjustable pid

"Auto" box

pytec/pytec/gui/view/ctrl_panel.py

@@ -1,45 +1,81 @@
 from PyQt6.QtCore import pyqtSignal, QObject, QSignalBlocker, pyqtSlot
+from PyQt6.QtWidgets import QCheckBox
 import pyqtgraph.parametertree.parameterTypes as pTypes
 from pyqtgraph.parametertree import (
     Parameter,
-    registerParameterType,
+    registerParameterItemType,
 )
 
 
-class MutexParameter(pTypes.ListParameter):
+class SimpleAutoParameter(pTypes.SimpleParameter):
-    """
-    Mutually exclusive parameter where only one of its children is visible at a time, list selectable.
 
-    The ordering of the list items determines which children will be visible.
+    sigAutoChanged = pyqtSignal(object, object)  ## self, auto
-    """
 
     def __init__(self, **opts):
         super().__init__(**opts)
+        if "auto" not in self.opts:
+            self.opts["auto"] = False
 
-        self.sigValueChanged.connect(self.show_chosen_child)
+        self.sigAutoChanged.connect(self._emitAutoChanged)
-        self.sigValueChanged.emit(self, self.opts["value"])
 
-    def _get_param_from_value(self, value):
+    def setAuto(self, auto, blockSignal=None):
-        if isinstance(self.opts["limits"], dict):
+        try:
-            values_list = list(self.opts["limits"].values())
+            if blockSignal is not None:
-        else:
+                self.sigAutochanged.disconnect(blockSignal)
-            values_list = self.opts["limits"]
 
-        return self.children()[values_list.index(value)]
+            if self.opts["auto"] == auto:
+                return auto
+            self.opts["auto"] = auto
+            self.sigAutoChanged.emit(self, auto)
+        finally:
+            if blockSignal is not None:
+                self.sigAutoChanged.connect(blockSignal)
 
-    @pyqtSlot(object, object)
+        return auto
-    def show_chosen_child(self, value):
-        for param in self.children():
-            param.hide()
 
-        child_to_show = self._get_param_from_value(value.value())
+    def _emitAutoChanged(self, param, data):
-        child_to_show.show()
+        self.emitStateChanged("auto", data)
-
-        if child_to_show.opts.get("triggerOnShow", None):
-            child_to_show.sigValueChanged.emit(child_to_show, child_to_show.value())
 
 
-registerParameterType("mutex", MutexParameter)
+class NumericWithAutoParameterItem(pTypes.NumericParameterItem):
+    """
+    Subclasses `NumericParameterItem` to add an auto checkbox option
+
+    ==========================  =============================================================
+    **Registered Types:**
+    int_auto                    Displays a :class:`SpinBox <pyqtgraph.SpinBox>` in integer
+                                mode, with a :class:`QCheckBox <QtWidgets.SpinBox>` QCheckBox beside it.
+    float_auto                  Displays a :class:`SpinBox <pyqtgraph.SpinBox>`, with a
+                                :class:`QCheckBox <QtWidgets.SpinBox>` QCheckBox beside it.
+    ==========================  =============================================================
+    """
+
+    def __init__(self, param, depth):
+        # Defer normal numeric handling to base class
+        t = param.opts["type"]
+        param.opts["type"] = t.removesuffix("_auto")
+        super().__init__(param, depth)
+
+        # Set up the auto checkbox and insert it to the right of the SpinBox
+        auto_lbl_txt = param.opts.get("auto_label", "Auto")
+        auto_tip = param.opts.get("auto_tip")
+        self.auto_checkbox = QCheckBox(auto_lbl_txt)
+        self.auto_checkbox.setChecked(param.opts.get("auto"))
+        self.auto_checkbox.setToolTip(auto_tip)
+        self.layoutWidget.layout().insertWidget(2, self.auto_checkbox)
+
+        # Connect it up
+        self.auto_checkbox.toggled.connect(self.param.setAuto)
+        param.sigAutoChanged.connect(self.auto_changed)
+
+    def auto_changed(self, param, auto):
+        self.auto_checkbox.setChecked(auto)
+
+
+registerParameterItemType("int_auto", NumericWithAutoParameterItem, SimpleAutoParameter)
+registerParameterItemType(
+    "float_auto", NumericWithAutoParameterItem, SimpleAutoParameter
+)
 
 
 def set_tree_label_tips(tree):
@@ -125,6 +161,7 @@ class CtrlPanel(QObject):
         for settings in pid_settings:
             channel = settings["channel"]
             with QSignalBlocker(self.params[channel]):
+                self.params[channel].child("pid", "target").setValue(settings["target"])
                 self.params[channel].child("pid", "kp").setValue(
                     settings["parameters"]["kp"]
                 )
@@ -140,29 +177,25 @@ class CtrlPanel(QObject):
                 self.params[channel].child(
                     "pid", "pid_output_clamping", "output_max"
                 ).setValue(settings["parameters"]["output_max"] * 1000)
-                self.params[channel].child(
-                    "output", "control_method", "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("output", "control_method").setValue(
+                self.params[channel].child("output", "i_set").setValue(
-                    "temperature_pid" if settings["pid_engaged"] else "constant_current"
+                    settings["i_set"] * 1000
                 )
-                self.params[channel].child(
+                self.params[channel].child("output", "i_set").setAuto(
-                    "output", "control_method", "i_set"
+                    settings["pid_engaged"]
-                ).setValue(settings["i_set"] * 1000)
+                )
+
                 if settings["temperature"] is not None:
                     self.params[channel].child("temperature").setValue(
                         settings["temperature"]
                     )
                     if settings["tec_i"] is not None:
-                        self.params[channel].child("tec_i").setValue(
+                        self.params[channel].child("tec_i").setValue(settings["tec_i"])
-                            settings["tec_i"]
-                        )
 
     @pyqtSlot("QVariantList")
     def update_thermistor(self, sh_data):

pytec/pytec/gui/view/param_tree.json

@@ -24,36 +24,17 @@
           "expanded":true,
           "type":"group",
           "tip": "Settings of the output through to the load",
-          "children":[
-             {
-                "name":"control_method",
-                "title":"Control Method",
-                "type":"mutex",
-                "limits":{
-                   "Constant Current": "constant_current",
-                   "Temperature PID": "temperature_pid"
-                },
-                "activaters":[
-                   null,
-                   [
-                      "pwm",
-                      "$ch",
-                      "pid"
-                   ]
-                ],
-                "tip":"Select control method of output",
           "children":[
             {
                 "name":"i_set",
                 "title":"Set Current (mA)",
-                      "type":"float",
+                "type":"float_auto",
                 "value":0,
                 "step":100,
                 "limits":[
                    -2000,
                    2000
                 ],
-                      "triggerOnShow":true,
                 "decimals":6,
                 "compactHeight":false,
                 "param":[
@@ -61,30 +42,16 @@
                    "$ch",
                    "i_set"
                 ],
-                      "tip": "Set current through output",
+                "auto":false,
-                      "lock":false
+                "auto_label":"PID",
-                   },
+                "auto_tip":"Control by PID",
-                   {
+                "auto_param":[
-                      "name": "target",
+                   "pwm",
-                      "title":"Set Temperature (°C)",
-                      "type":"float",
-                      "value":25,
-                      "step":0.1,
-                      "limits":[
-                         -273,
-                         300
-                      ],
-                      "format":"{value:.4f}",
-                      "compactHeight":false,
-                      "param":[
-                         "pid",
                    "$ch",
-                         "target"
+                   "pid"
                 ],
-                      "tip": "Set target temperature",
+                "tip": "",
                 "lock":false
-                   }
-                ]
              },
              {
                 "name":"limits",
@@ -244,6 +211,26 @@
           "type":"group",
           "tip": "",
           "children":[
+            {
+                "name":"target",
+                "title":"Setpoint (°C)",
+                "type":"float",
+                "value":25,
+                "step":0.1,
+                "limits":[
+                   -273,
+                   300
+                ],
+                "format":"{value:.4f}",
+                "compactHeight":false,
+                "param":[
+                   "pid",
+                   "ch",
+                   "target"
+                ],
+                "tip": "",
+                "lock":false
+             },
              {
                 "name":"kp",
                 "title":"Kp",

pytec/tec_qt.py

@@ -296,14 +296,21 @@ class MainWindow(QtWidgets.QMainWindow):
                         ch = inner_param.opts["pid_autotune"][1]
                     self.autotuners.set_params(auto_tuner_param, ch, data)
 
-                if inner_param.opts.get("activaters", None) is not None:
+            if change == "auto":
-                    activater = inner_param.opts["activaters"][
+                is_auto = data
-                        inner_param.reverse[0].index(data)  # ListParameter.reverse = list of codename values
+                if is_auto:
-                    ]
+                    if "auto_param" in inner_param.opts:
-                    if activater is not None:
+                        thermostat_param = inner_param.opts["auto_param"]
-                        if activater[1] == "$ch":
+                else:
-                            activater[1] = ch
+                    thermostat_param = [*inner_param.opts["param"], inner_param.value() / 1000]
-                        await self.client.set_param(*activater)
+
+                if thermostat_param[1] == "$ch":
+                    thermostat_param[1] = ch
+
+                inner_param.setOpts(lock=True)
+                await self.client.set_param(*thermostat_param)
+                inner_param.setOpts(lock=False)
+
 
     @asyncSlot()
     async def pid_auto_tune_request(self, ch=0):