Add paramtree view, without updates

Signed-off-by: Egor Savkin <es@m-labs.hk>

Cargo.lock

@@ -327,10 +327,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "panic-halt"
-version = "0.2.0"
+name = "panic-abort"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de96540e0ebde571dc55c73d60ef407c653844e6f9a1e2fdbd40c07b9252d812"
+checksum = "4e20e6499bbbc412f280b04a42346b356c6fa0753d5fd22b7bd752ff34c778ee"
 
 [[package]]
 name = "panic-semihosting"
@@ -563,7 +563,7 @@ dependencies = [
  "nb 1.0.0",
  "nom",
  "num-traits",
- "panic-halt",
+ "panic-abort",
  "panic-semihosting",
  "serde",
  "serde-json-core",

Cargo.toml

@@ -7,14 +7,14 @@ authors = ["Astro <astro@spaceboyz.net>"]
 version = "0.0.0"
 keywords = ["thermostat", "laser", "physics"]
 repository = "https://git.m-labs.hk/M-Labs/thermostat"
-edition = "2021"
+edition = "2018"
 
 [package.metadata.docs.rs]
 features = []
 default-target = "thumbv7em-none-eabihf"
 
 [dependencies]
-panic-halt = "0.2"
+panic-abort = "0.3"
 panic-semihosting = { version = "0.5", optional = true }
 log = "0.4"
 bare-metal = "1"

README.md

@@ -29,7 +29,7 @@ Alternatively, you can install the Rust toolchain without Nix using rustup; see
 
 Connect SWDIO/SWCLK/RST/GND to a programmer such as ST-Link v2.1. Run OpenOCD:
 ```shell
-openocd -f interface/stlink.cfg -f target/stm32f4x.cfg
+openocd -f interface/stlink-v2-1.cfg -f target/stm32f4x.cfg
 ```
 
 You may need to power up the programmer before powering the device.
@@ -64,10 +64,24 @@ On a Windows machine install [st.com](https://st.com) DfuSe USB device firmware
 
 ### OpenOCD
 ```shell
-openocd -f interface/stlink.cfg -f target/stm32f4x.cfg -c "program target/thumbv7em-none-eabihf/release/thermostat verify reset;exit"
+openocd -f interface/stlink-v2-1.cfg -f target/stm32f4x.cfg -c "program target/thumbv7em-none-eabihf/release/thermostat verify reset;exit"
 ```
 
-## Network
+## GUI Usage
+
+A GUI has been developed for easy configuration and plotting of key parameters.  
+
+The Python GUI program is located at pytec/tecQT.py
+
+The GUI is developed based on the Python library pyqtgraph. The environment needed to run the GUI is configured automatically by running:
+
+```shell
+nix develop
+```
+
+The GUI program assumes the default IP and port of 192.168.1.26 23 is used. If a different IP or port is used, the IP and port setting should be changed in the GUI code. 
+
+## Command Line Usage
 
 ### Connecting
 
@@ -258,12 +272,13 @@ with the following keys.
 | Key            | Unit            | Description                                          |
 | ---            | :---:           | ---                                                  |
 | `channel`      | Integer         | Channel `0`, or `1`                                  |
-| `time`         | Seconds         | Temperature measurement time                         |
+| `time`         | Milliseconds    | Temperature measurement time                         |
 | `adc`          | Volts           | AD7172 input                                         |
 | `sens`         | Ohms            | Thermistor resistance derived from `adc`             |
 | `temperature`  | Degrees Celsius | Steinhart-Hart conversion result derived from `sens` |
 | `pid_engaged`  | Boolean         | `true` if in closed-loop mode                        |
 | `i_set`        | Amperes         | TEC output current                                   |
+| `vref`         | Volts           | MAX1968 VREF (1.5 V)                                 |
 | `dac_value`    | Volts           | AD5680 output derived from `i_set`                   |
 | `dac_feedback` | Volts           | ADC measurement of the AD5680 output                 |
 | `i_tec`        | Volts           | MAX1968 TEC current monitor                          |
@@ -271,19 +286,18 @@ with the following keys.
 | `tec_u_meas`   | Volts           | Measurement of the voltage across the TEC            |
 | `pid_output`   | Amperes         | PID control output                                   |
 
-Note: With Thermostat v2 and below, the voltage and current readouts `i_tec` and `tec_i` are disabled and null due to faulty hardware that introduces a lot of noise in the signal.
-
 ## PID Tuning
 
 The thermostat implements a PID control loop for each of the TEC channels, more details on setting up the PID control loop can be found [here](./doc/PID%20tuning.md).
 
 ## Fan control
 
-Fan control commands are available for thermostat revisions with an integrated fan system:
+Fan control is available for the thermostat revisions with integrated fan system. For this purpose four commands are available:
 1. `fan` - show fan stats: `fan_pwm`, `abs_max_tec_i`, `auto_mode`, `k_a`, `k_b`, `k_c`.
-2. `fan auto` - enable auto speed controller mode, where fan speed is controlled by the fan curve `fcurve`.
-3. `fan <value>` - set the fan power with the value from `1` to `100` and disable auto mode. There is no way to completely disable the fan.
+2. `fan auto` - enable auto speed controller mode, which correlates with fan curve `fcurve`.
+3. `fan <value>` - set the fan power with the value from `1` to `100` and disable auto mode. There is no way to disable the fan.
 Please note that power doesn't correlate with the actual speed linearly.
-4. `fcurve <a> <b> <c>` - set coefficients of the controlling curve `a*x^2 + b*x + c`, where `x` is `abs_max_tec_i/MAX_TEC_I`, a normalized value in range [0,1],
-i.e. the (linear) proportion of current output capacity used, on the channel with the largest current flow. The controlling curve is also clamped to [0,1].
-5. `fcurve default` - restore fan curve coefficients to defaults: `a = 1.0, b = 0.0, c = 0.0`.
+4. `fcurve <a> <b> <c>` - set coefficients of the controlling curve `a*x^2 + b*x + c`, where `x` is `abs_max_tec_i/MAX_TEC_I`, 
+i.e. receives values from 0 to 1 linearly tied to the maximum current. The controlling curve should produce values from 0 to 1,
+as below and beyond values would be substituted by 0 and 1 respectively.
+5. `fcurve default` - restore fan curve settings to defaults: `a = 1.0, b = 0.0, c = 0.0`.

flake.lock

@@ -3,11 +3,11 @@
     "mozilla-overlay": {
       "flake": false,
       "locked": {
-        "lastModified": 1690536331,
-        "narHash": "sha256-aRIf2FB2GTdfF7gl13WyETmiV/J7EhBGkSWXfZvlxcA=",
+        "lastModified": 1638887313,
+        "narHash": "sha256-FMYV6rVtvSIfthgC1sK1xugh3y7muoQcvduMdriz4ag=",
         "owner": "mozilla",
         "repo": "nixpkgs-mozilla",
-        "rev": "db89c8707edcffefcd8e738459d511543a339ff5",
+        "rev": "7c1e8b1dd6ed0043fb4ee0b12b815256b0b9de6f",
         "type": "github"
       },
       "original": {
@@ -18,16 +18,16 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1691421349,
-        "narHash": "sha256-RRJyX0CUrs4uW4gMhd/X4rcDG8PTgaaCQM5rXEJOx6g=",
+        "lastModified": 1684171562,
+        "narHash": "sha256-BMUWjVWAUdyMWKk0ATMC9H0Bv4qAV/TXwwPUvTiC5IQ=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "011567f35433879aae5024fc6ec53f2a0568a6c4",
+        "rev": "55af203d468a6f5032a519cba4f41acf5a74b638",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
-        "ref": "nixos-23.05",
+        "ref": "nixos-22.11",
         "repo": "nixpkgs",
         "type": "github"
       }

flake.nix

@@ -1,15 +1,15 @@
 {
   description = "Firmware for the Sinara 8451 Thermostat";
 
-  inputs.nixpkgs.url = github:NixOS/nixpkgs/nixos-23.05;
+  inputs.nixpkgs.url = github:NixOS/nixpkgs/nixos-22.11;
   inputs.mozilla-overlay = { url = github:mozilla/nixpkgs-mozilla; flake = false; };
 
   outputs = { self, nixpkgs, mozilla-overlay }:
     let
       pkgs = import nixpkgs { system = "x86_64-linux"; overlays = [ (import mozilla-overlay) ]; };
       rustManifest = pkgs.fetchurl {
-        url = "https://static.rust-lang.org/dist/2022-12-15/channel-rust-stable.toml";
-        hash = "sha256-S7epLlflwt0d1GZP44u5Xosgf6dRrmr8xxC+Ml2Pq7c=";
+        url = "https://static.rust-lang.org/dist/2021-10-26/channel-rust-nightly.toml";
+        sha256 = "sha256-1hLbypXA+nuH7o3AHCokzSBZAvQxvef4x9+XxO3aBao=";
       };
 
       targets = [
@@ -22,12 +22,12 @@
           inherit targets;
           extensions = ["rust-src"];
         };
-      rust = rustChannelOfTargets "stable" null targets;
+      rust = rustChannelOfTargets "nightly" null targets;
       rustPlatform = pkgs.recurseIntoAttrs (pkgs.makeRustPlatform {
         rustc = rust;
         cargo = rust;
       });
-      thermostat = rustPlatform.buildRustPackage {
+      thermostat = rustPlatform.buildRustPackage rec {
         name = "thermostat";
         version = "0.0.0";
 
@@ -55,9 +55,45 @@
 
         dontFixup = true;
       };
+
+      qasync = pkgs.python3Packages.buildPythonPackage rec {
+        pname = "qasync";
+        version = "0.24.0";
+        src = pkgs.fetchFromGitHub {
+          owner = "CabbageDevelopment";
+          repo = "qasync";
+          rev = "v${version}";
+          sha256 = "sha256-ls5F+VntXXa3n+dULaYWK9sAmwly1nk/5+RGWLrcf2Y=";
+        };
+        propagatedBuildInputs = [ pkgs.python3Packages.pyqt6 ];
+        checkInputs = [ pkgs.python3Packages.pytest ];
+        checkPhase = ''
+          pytest -k 'test_qthreadexec.py' # the others cause the test execution to be aborted, I think because of asyncio
+        '';
+      };
+      thermostat_gui = pkgs.python3Packages.buildPythonPackage rec {
+        pname = "thermostat_gui";
+        version = "0.0.0";
+        src = self;
+
+        preBuild =
+          ''
+          export VERSIONEER_OVERRIDE=${version}
+          export VERSIONEER_REV=v0.0.0
+          '';
+
+        nativeBuildInputs = [ pkgs.qt6.wrapQtAppsHook ];
+        propagatedBuildInputs = (with pkgs.python3Packages; [ pyqtgraph pyqt6 qasync]);
+
+        dontWrapQtApps = true;
+        postFixup = ''
+          ls -al $out/
+          wrapQtApp "$out/pytec/tec_qt"
+        '';
+      };
     in {
       packages.x86_64-linux = {
-        inherit thermostat;
+        inherit thermostat qasync thermostat_gui;
       };
 
       hydraJobs = {
@@ -67,10 +103,17 @@
       devShell.x86_64-linux = pkgs.mkShell {
         name = "thermostat-dev-shell";
         buildInputs = with pkgs; [
-          rust openocd dfu-util
+          rustPlatform.rust.rustc
+          rustPlatform.rust.cargo
+          openocd dfu-util
           ] ++ (with python3Packages; [
-            numpy matplotlib
+            numpy matplotlib pyqtgraph setuptools pyqt6 qasync
           ]);
+          shellHook=
+          ''
+            export QT_PLUGIN_PATH=${pkgs.qt6.qtbase}/${pkgs.qt6.qtbase.dev.qtPluginPrefix}
+            export QML2_IMPORT_PATH=${pkgs.qt6.qtbase}/${pkgs.qt6.qtbase.dev.qtQmlPrefix}
+          '';
       };
       defaultPackage.x86_64-linux = thermostat;
     };

pytec/autotune.py

@@ -17,6 +17,7 @@ class PIDAutotuneState(Enum):
     STATE_RELAY_STEP_DOWN = 'relay step down'
     STATE_SUCCEEDED = 'succeeded'
     STATE_FAILED = 'failed'
+    STATE_READY = 'ready'
 
 
 class PIDAutotune:
@@ -56,6 +57,20 @@ class PIDAutotune:
         self._Ku = 0
         self._Pu = 0
 
+    def setParam(self, target, step, noiseband, sampletime, lookback):
+        self._setpoint = target
+        self._outputstep = step
+        self._out_max = step
+        self._out_min = -step
+        self._noiseband = noiseband
+        self._inputs = deque(maxlen=round(lookback / sampletime))
+
+    def setReady(self):
+        self._state = PIDAutotuneState.STATE_READY
+
+    def setOff(self):
+        self._state = PIDAutotuneState.STATE_OFF
+
     def state(self):
         """Get the current state."""
         return self._state
@@ -81,6 +96,13 @@ class PIDAutotune:
         kd = divisors[2] * self._Ku * self._Pu
         return PIDAutotune.PIDParams(kp, ki, kd)
 
+    def get_tec_pid (self):
+        divisors = self._tuning_rules["tyreus-luyben"]
+        kp = self._Ku * divisors[0]
+        ki = divisors[1] * self._Ku / self._Pu
+        kd = divisors[2] * self._Ku * self._Pu
+        return kp, ki, kd
+
     def run(self, input_val, time_input):
         """To autotune a system, this method must be called periodically.
 
@@ -95,7 +117,8 @@ class PIDAutotune:
 
         if (self._state == PIDAutotuneState.STATE_OFF
                 or self._state == PIDAutotuneState.STATE_SUCCEEDED
-                or self._state == PIDAutotuneState.STATE_FAILED):
+                or self._state == PIDAutotuneState.STATE_FAILED
+                or self._state == PIDAutotuneState.STATE_READY):
             self._state = PIDAutotuneState.STATE_RELAY_STEP_UP
 
         self._last_run_timestamp = now

pytec/pytec/client.py

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

pytec/tecQT.py

@@ -0,0 +1,335 @@
+from pyqtgraph.Qt import QtGui, QtCore
+import pyqtgraph.parametertree.parameterTypes as pTypes
+from pyqtgraph.parametertree import Parameter, ParameterTree, ParameterItem, registerParameterType
+import numpy as np
+import pyqtgraph as pg
+from pytec.client import Client
+from enum import Enum
+from autotune import PIDAutotune, PIDAutotuneState
+
+rec_len = 1000
+refresh_period = 20
+
+TECparams = [[
+    {'tag': 'report', 'type': 'parent', 'children': [
+        {'tag': 'pid_engaged', 'type': 'bool', 'value': False},
+    ]},
+    {'tag': 'pwm', 'type': 'parent', 'children': [
+        {'tag': 'max_i_pos', 'type': 'float', 'value': 0},
+        {'tag': 'max_i_neg', 'type': 'float', 'value': 0},
+        {'tag': 'max_v', 'type': 'float', 'value': 0},
+        {'tag': 'i_set', 'type': 'float', 'value': 0},
+    ]},
+    {'tag': 'pid', 'type': 'parent', 'children': [
+        {'tag': 'kp', 'type': 'float', 'value': 0},
+        {'tag': 'ki', 'type': 'float', 'value': 0},
+        {'tag': 'kd', 'type': 'float', 'value': 0},
+        {'tag': 'output_min', 'type': 'float', 'value': 0},
+        {'tag': 'output_max', 'type': 'float', 'value': 0},
+    ]},
+    {'tag': 's-h', 'type': 'parent', 'children': [
+        {'tag': 't0', 'type': 'float', 'value': 0},
+        {'tag': 'r0', 'type': 'float', 'value': 0},
+        {'tag': 'b', 'type': 'float', 'value': 0},
+    ]},
+    {'tag': 'PIDtarget', 'type': 'parent', 'children': [
+        {'tag': 'target', 'type': 'float', 'value': 0},
+    ]},
+] for _ in range(2)]
+
+GUIparams = [[
+    {'name': 'Disable Output', 'type': 'action', 'tip': 'Disable Output'},
+    {'name': 'Constant Current', 'type': 'group', 'children': [
+        {'name': 'Set Current', 'type': 'float', 'value': 0, 'step': 0.1, 'limits': (-3, 3), 'siPrefix': True,
+         'suffix': 'A'},
+    ]},
+    {'name': 'Temperature PID', 'type': 'bool', 'value': False, 'children': [
+        {'name': 'Set Temperature', 'type': 'float', 'value': 25, 'step': 0.1, 'limits': (-273, 300), 'siPrefix': True,
+         'suffix': 'C'},
+    ]},
+    {'name': 'Output Config', 'expanded': False, 'type': 'group', 'children': [
+        {'name': 'Max Current', 'type': 'float', 'value': 0, 'step': 0.1, 'limits': (0, 3), 'siPrefix': True,
+         'suffix': 'A'},
+        {'name': 'Max Voltage', 'type': 'float', 'value': 0, 'step': 0.1, 'limits': (0, 5), 'siPrefix': True,
+         'suffix': 'V'},
+    ]},
+    {'name': 'Thermistor Config', 'expanded': False, 'type': 'group', 'children': [
+        {'name': 'T0', 'type': 'float', 'value': 25, 'step': 0.1, 'limits': (-100, 100), 'siPrefix': True,
+         'suffix': 'C'},
+        {'name': 'R0', 'type': 'float', 'value': 10000, 'step': 1, 'siPrefix': True, 'suffix': 'Ohm'},
+        {'name': 'Beta', 'type': 'float', 'value': 3950, 'step': 1},
+    ]},
+    {'name': 'PID Config', 'expanded': False, 'type': 'group', 'children': [
+        {'name': 'kP', 'type': 'float', 'value': 0, 'step': 0.1},
+        {'name': 'kI', 'type': 'float', 'value': 0, 'step': 0.1},
+        {'name': 'kD', 'type': 'float', 'value': 0, 'step': 0.1},
+        {'name': 'PID Auto Tune', 'expanded': False, 'type': 'group', 'children': [
+            {'name': 'Target Temperature', 'type': 'float', 'value': 20, 'step': 0.1, 'siPrefix': True, 'suffix': 'C'},
+            {'name': 'Test Current', 'type': 'float', 'value': 1, 'step': 0.1, 'siPrefix': True, 'suffix': 'A'},
+            {'name': 'Temperature Swing', 'type': 'float', 'value': 1.5, 'step': 0.1, 'siPrefix': True, 'suffix': 'C'},
+            {'name': 'Run', 'type': 'action', 'tip': 'Run'},
+        ]},
+    ]},
+    {'name': 'Save to flash', 'type': 'action', 'tip': 'Save to flash'},
+] for _ in range(2)]
+
+autoTuner = [PIDAutotune(20, 1, 1, 1.5, refresh_period / 1000),
+             PIDAutotune(20, 1, 1, 1.5, refresh_period / 1000)]
+
+
+# If anything changes in the tree, print a message
+def change(param, changes, ch):
+    print("tree changes:")
+    for param, change, data in changes:
+        path = paramList[ch].childPath(param)
+        if path is not None:
+            childName = '.'.join(path)
+        else:
+            childName = param.name()
+        print('  parameter: %s' % childName)
+        print('  change:    %s' % change)
+        print('  data:      %s' % str(data))
+        print('  ----------')
+
+        if childName == 'Disable Output':
+            tec.set_param('pwm', ch, 'i_set', 0)
+            paramList[ch].child('Constant Current').child('Set Current').setValue(0)
+            paramList[ch].child('Temperature PID').setValue(False)
+            autoTuner[ch].setOff()
+
+        if childName == 'Temperature PID':
+            if (data):
+                tec.set_param("pwm", ch, "pid")
+            else:
+                tec.set_param('pwm', ch, 'i_set', paramList[ch].child('Constant Current').child('Set Current').value())
+
+        if childName == 'Constant Current.Set Current':
+            tec.set_param('pwm', ch, 'i_set', data)
+            paramList[ch].child('Temperature PID').setValue(False)
+
+        if childName == 'Temperature PID.Set Temperature':
+            tec.set_param('pid', ch, 'target', data)
+
+        if childName == 'Output Config.Max Current':
+            tec.set_param('pwm', ch, 'max_i_pos', data)
+            tec.set_param('pwm', ch, 'max_i_neg', data)
+            tec.set_param('pid', ch, 'output_min', -data)
+            tec.set_param('pid', ch, 'output_max', data)
+
+        if childName == 'Output Config.Max Voltage':
+            tec.set_param('pwm', ch, 'max_v', data)
+
+        if childName == 'Thermistor Config.T0':
+            tec.set_param('s-h', ch, 't0', data)
+
+        if childName == 'Thermistor Config.R0':
+            tec.set_param('s-h', ch, 'r0', data)
+
+        if childName == 'Thermistor Config.Beta':
+            tec.set_param('s-h', ch, 'b', data)
+
+        if childName == 'PID Config.kP':
+            tec.set_param('pid', ch, 'kp', data)
+
+        if childName == 'PID Config.kI':
+            tec.set_param('pid', ch, 'ki', data)
+
+        if childName == 'PID Config.kD':
+            tec.set_param('pid', ch, 'kd', data)
+
+        if childName == 'PID Config.PID Auto Tune.Run':
+            autoTuner[ch].setParam(
+                paramList[ch].child('PID Config').child('PID Auto Tune').child('Target Temperature').value(),
+                paramList[ch].child('PID Config').child('PID Auto Tune').child('Test Current').value(),
+                paramList[ch].child('PID Config').child('PID Auto Tune').child('Temperature Swing').value(),
+                refresh_period / 1000,
+                1)
+            autoTuner[ch].setReady()
+            paramList[ch].child('Temperature PID').setValue(False)
+
+        if childName == 'Save to flash':
+            tec.save_config()
+
+
+def change0(param, changes):
+    change(param, changes, 0)
+
+
+def change1(param, changes):
+    change(param, changes, 1)
+
+
+class Curves:
+    def __init__(self, legend: str, key: str, channel: int, color: str, buffer_len: int, period: int):
+        self.curveItem = pg.PlotCurveItem(pen=({'color': color, 'width': 1}))
+        self.legendStr = legend
+        self.keyStr = key
+        self.channel = channel
+        self.data_buf = np.zeros(buffer_len)
+        self.time_stamp = np.zeros(buffer_len)
+        self.buffLen = buffer_len
+        self.period = period
+
+    def update(self, tec_data, cnt):
+        if cnt == 0:
+            np.copyto(self.data_buf, np.full(self.buffLen, tec_data[self.channel][self.keyStr]))
+        else:
+            self.data_buf[:-1] = self.data_buf[1:]
+            self.data_buf[-1] = tec_data[self.channel][self.keyStr]
+            self.time_stamp[:-1] = self.time_stamp[1:]
+            self.time_stamp[-1] = cnt * self.period / 1000
+            self.curveItem.setData(x=self.time_stamp, y=self.data_buf)
+
+
+class Graph:
+    def __init__(self, parent: pg.LayoutWidget, title: str, row: int, col: int, curves: list[Curves]):
+        self.plotItem = pg.PlotWidget(title=title)
+        self.legendItem = pg.LegendItem(offset=(75, 30), brush=(50, 50, 200, 150))
+        self.legendItem.setParentItem(self.plotItem.getPlotItem())
+        parent.addWidget(self.plotItem, row, col)
+        self.curves = curves
+        for curve in self.curves:
+            self.plotItem.addItem(curve.curveItem)
+            self.legendItem.addItem(curve.curveItem, curve.legendStr)
+
+    def update(self, tec_data, cnt):
+        for curve in self.curves:
+            curve.update(tec_data, cnt)
+        self.plotItem.setRange(
+            xRange=[(cnt - self.curves[0].buffLen) * self.curves[0].period / 1000, cnt * self.curves[0].period / 1000])
+
+
+def TECsync():
+    global TECparams
+    for channel in range(2):
+        for parents in TECparams[channel]:
+            if parents['tag'] == 'report':
+                for data in tec.report_mode():
+                    for children in parents['children']:
+                        print(data)
+                        children['value'] = data[channel][children['tag']]
+                    if quit:
+                        break
+            if parents['tag'] == 'pwm':
+                for children in parents['children']:
+                    children['value'] = tec.get_pwm()[channel][children['tag']]['value']
+            if parents['tag'] == 'pid':
+                for children in parents['children']:
+                    children['value'] = tec.get_pid()[channel]['parameters'][children['tag']]
+            if parents['tag'] == 's-h':
+                for children in parents['children']:
+                    children['value'] = tec.get_steinhart_hart()[channel]['params'][children['tag']]
+            if parents['tag'] == 'PIDtarget':
+                for children in parents['children']:
+                    children['value'] = tec.get_pid()[channel]['target']
+
+
+def refreshTreeParam(tempTree: dict, channel: int) -> dict:
+    tempTree['children']['Constant Current']['children']['Set Current']['value'] = TECparams[channel][1]['children'][3][
+        'value']
+    tempTree['children']['Temperature PID']['value'] = TECparams[channel][0]['children'][0]['value']
+    tempTree['children']['Temperature PID']['children']['Set Temperature']['value'] = \
+        TECparams[channel][4]['children'][0]['value']
+    tempTree['children']['Output Config']['children']['Max Current']['value'] = TECparams[channel][1]['children'][0][
+        'value']
+    tempTree['children']['Output Config']['children']['Max Voltage']['value'] = TECparams[channel][1]['children'][2][
+        'value']
+    tempTree['children']['Thermistor Config']['children']['T0']['value'] = TECparams[channel][3]['children'][0][
+                                                                               'value'] - 273.15
+    tempTree['children']['Thermistor Config']['children']['R0']['value'] = TECparams[channel][3]['children'][1]['value']
+    tempTree['children']['Thermistor Config']['children']['Beta']['value'] = TECparams[channel][3]['children'][2][
+        'value']
+    tempTree['children']['PID Config']['children']['kP']['value'] = TECparams[channel][2]['children'][0]['value']
+    tempTree['children']['PID Config']['children']['kI']['value'] = TECparams[channel][2]['children'][1]['value']
+    tempTree['children']['PID Config']['children']['kD']['value'] = TECparams[channel][2]['children'][2]['value']
+    return tempTree
+
+
+cnt = 0
+
+
+def updateData():
+    global cnt
+    for data in tec.report_mode():
+
+        ch0tempGraph.update(data, cnt)
+        ch1tempGraph.update(data, cnt)
+        ch0currentGraph.update(data, cnt)
+        ch1currentGraph.update(data, cnt)
+
+        for channel in range(2):
+            if (autoTuner[channel].state() == PIDAutotuneState.STATE_READY or
+                    autoTuner[channel].state() == PIDAutotuneState.STATE_RELAY_STEP_UP or
+                    autoTuner[channel].state() == PIDAutotuneState.STATE_RELAY_STEP_DOWN):
+                autoTuner[channel].run(data[channel]['temperature'], data[channel]['time'])
+                tec.set_param('pwm', channel, 'i_set', autoTuner[channel].output())
+            elif autoTuner[channel].state() == PIDAutotuneState.STATE_SUCCEEDED:
+                kp, ki, kd = autoTuner[channel].get_tec_pid()
+                autoTuner[channel].setOff()
+                paramList[channel].child('PID Config').child('kP').setValue(kp)
+                paramList[channel].child('PID Config').child('kI').setValue(ki)
+                paramList[channel].child('PID Config').child('kD').setValue(kd)
+                tec.set_param('pid', channel, 'kp', kp)
+                tec.set_param('pid', channel, 'ki', ki)
+                tec.set_param('pid', channel, 'kd', kd)
+            elif autoTuner[channel].state() == PIDAutotuneState.STATE_FAILED:
+                tec.set_param('pwm', channel, 'i_set', 0)
+                autoTuner[channel].setOff()
+
+        if quit:
+            break
+    cnt += 1
+
+
+if __name__ == '__main__':
+    tec = Client(host="192.168.1.26", port=23, timeout=None)
+
+    app = pg.mkQApp()
+    pg.setConfigOptions(antialias=True)
+    mw = QtGui.QMainWindow()
+    mw.setWindowTitle('Thermostat Control Panel')
+    mw.resize(1920, 1200)
+    cw = QtGui.QWidget()
+    mw.setCentralWidget(cw)
+    l = QtGui.QVBoxLayout()
+    layout = pg.LayoutWidget()
+    l.addWidget(layout)
+    cw.setLayout(l)
+
+    ## Create tree of Parameter objects
+    paramList = [Parameter.create(name='GUIparams', type='group', children=GUIparams[0]),
+                 Parameter.create(name='GUIparams', type='group', children=GUIparams[1])]
+
+    ch0Tree = ParameterTree()
+    ch0Tree.setParameters(paramList[0], showTop=False)
+    ch1Tree = ParameterTree()
+    ch1Tree.setParameters(paramList[1], showTop=False)
+
+    TECsync()
+    paramList[0].restoreState(refreshTreeParam(paramList[0].saveState(), 0))
+    paramList[1].restoreState(refreshTreeParam(paramList[1].saveState(), 1))
+
+    paramList[0].sigTreeStateChanged.connect(change0)
+    paramList[1].sigTreeStateChanged.connect(change1)
+
+    layout.addWidget(ch0Tree, 1, 1, 1, 1)
+    layout.addWidget(ch1Tree, 2, 1, 1, 1)
+
+    ch0tempGraph = Graph(layout, 'Channel 0 Temperature', 1, 2,
+                         [Curves('Feedback', 'temperature', 0, 'r', rec_len, refresh_period)])
+    ch1tempGraph = Graph(layout, 'Channel 1 Temperature', 2, 2,
+                         [Curves('Feedback', 'temperature', 1, 'r', rec_len, refresh_period)])
+    ch0currentGraph = Graph(layout, 'Channel 0 Current', 1, 3,
+                            [Curves('Feedback', 'tec_i', 0, 'r', rec_len, refresh_period),
+                             Curves('Setpoint', 'i_set', 0, 'g', rec_len, refresh_period)])
+    ch1currentGraph = Graph(layout, 'Channel 1 Current', 2, 3,
+                            [Curves('Feedback', 'tec_i', 1, 'r', rec_len, refresh_period),
+                             Curves('Setpoint', 'i_set', 1, 'g', rec_len, refresh_period)])
+
+    t = QtCore.QTimer()
+    t.timeout.connect(updateData)
+    t.start(refresh_period)
+
+    mw.show()
+
+    pg.exec()

pytec/tec_qt.py

@@ -0,0 +1,328 @@
+from PyQt6 import QtWidgets, uic
+from PyQt6.QtCore import QThread, QThreadPool, pyqtSignal, QRunnable, QObject, QSignalBlocker, pyqtSlot, QDeadlineTimer
+from pyqtgraph import PlotWidget
+from pyqtgraph.parametertree import Parameter, ParameterTree, ParameterItem, registerParameterType
+import pyqtgraph as pg
+import sys
+import argparse
+import logging
+import asyncio
+import atexit
+from qasync import asyncSlot, QEventLoop
+import qasync
+from pytec.client import Client
+
+# pyuic6 -x tec_qt.ui  -o ui_tec_qt.py
+from ui_tec_qt import Ui_MainWindow
+
+tec_client: Client = None
+
+# ui = None
+ui: Ui_MainWindow = None
+
+thread_pool = QThreadPool.globalInstance()
+connection_watcher = None
+client_watcher = None
+app: QtWidgets.QApplication = None
+
+
+class CommandsParameter(Parameter):
+    def __init__(self, **opts):
+        super().__init__()
+        self.opts["commands"] = opts.get("commands", None)
+        self.opts["payload"] = opts.get("payload", None)
+
+
+ThermostatParams = [[
+    {'name': 'Constant Current', 'type': 'float', 'value': 0, 'step': 0.1, 'limits': (-3, 3), 'siPrefix': True,
+     'suffix': 'A', 'commands': [f'pwm {ch} i_set {{value}}']},
+    {'name': 'Temperature PID', 'type': 'bool', 'value': False, 'commands': [f'pwm {ch} pid'], 'payload': ch,
+     'children': [
+         {'name': 'Set Temperature', 'type': 'float', 'value': 25, 'step': 0.1, 'limits': (-273, 300), 'siPrefix': True,
+          'suffix': '°C', 'commands': [f'pid {ch} target {{value}}']},
+     ]},
+    {'name': 'Output Config', 'expanded': False, 'type': 'group', 'children': [
+        {'name': 'Max Current', 'type': 'float', 'value': 0, 'step': 0.1, 'limits': (0, 3), 'siPrefix': True,
+         'suffix': 'A', 'commands': [f'pwm {ch} max_i_pos {{value}}', f'pwm {ch} max_i_neg {{value}}',
+                                     f'pid {ch} output_min -{{value}}', f'pid {ch} output_max {{value}}']},
+        {'name': 'Max Voltage', 'type': 'float', 'value': 0, 'step': 0.1, 'limits': (0, 5), 'siPrefix': True,
+         'suffix': 'V', 'commands': [f'pwm {ch} max_v {{value}}']},
+    ]},
+    {'name': 'Thermistor Config', 'expanded': False, 'type': 'group', 'children': [
+        {'name': 'T0', 'type': 'float', 'value': 25, 'step': 0.1, 'limits': (-100, 100), 'siPrefix': True,
+         'suffix': 'C', 'commands': [f's-h {ch} t0 {{value}}']},
+        {'name': 'R0', 'type': 'float', 'value': 10000, 'step': 1, 'siPrefix': True, 'suffix': 'Ohm',
+         'commands': [f's-h {ch} r0 {{value}}']},
+        {'name': 'Beta', 'type': 'float', 'value': 3950, 'step': 1, 'commands': [f's-h {ch} b {{value}}']},
+    ]},
+    {'name': 'PID Config', 'expanded': False, 'type': 'group', 'children': [
+        {'name': 'kP', 'type': 'float', 'value': 0, 'step': 0.1, 'commands': [f'pid {ch} kp {{value}}']},
+        {'name': 'kI', 'type': 'float', 'value': 0, 'step': 0.1, 'commands': [f'pid {ch} ki {{value}}']},
+        {'name': 'kD', 'type': 'float', 'value': 0, 'step': 0.1, 'commands': [f'pid {ch} kd {{value}}']},
+        {'name': 'PID Auto Tune', 'expanded': False, 'type': 'group', 'children': [
+            {'name': 'Target Temperature', 'type': 'float', 'value': 20, 'step': 0.1, 'siPrefix': True, 'suffix': 'C'},
+            {'name': 'Test Current', 'type': 'float', 'value': 1, 'step': 0.1, 'siPrefix': True, 'suffix': 'A'},
+            {'name': 'Temperature Swing', 'type': 'float', 'value': 1.5, 'step': 0.1, 'siPrefix': True, 'suffix': 'C'},
+            {'name': 'Run', 'type': 'action', 'tip': 'Run'},
+        ]},
+    ]}
+] for ch in range(2)]
+
+params = [CommandsParameter.create(name='Thermostat Params 0', type='group', children=ThermostatParams[0]),
+          CommandsParameter.create(name='Thermostat Params 1', type='group', children=ThermostatParams[1])]
+
+
+def get_argparser():
+    parser = argparse.ArgumentParser(description="ARTIQ master")
+
+    parser.add_argument("--connect", default=None, action="store_true",
+                        help="Automatically connect to the specified Thermostat in IP:port format")
+    parser.add_argument('IP', metavar="ip", default=None, nargs='?')
+    parser.add_argument('PORT', metavar="port", default=None, nargs='?')
+    parser.add_argument("-l", "--log", dest="logLevel", choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
+                        help="Set the logging level")
+
+    return parser
+
+
+class WatchConnectTask(QThread):
+    connected = pyqtSignal(bool)
+    hw_rev = pyqtSignal(dict)
+    connecting = pyqtSignal()
+    fan_update = pyqtSignal(object)
+
+    def __init__(self, parent, ip, port):
+        self.ip = ip
+        self.port = port
+        super().__init__(parent)
+
+    def run(self):
+        global tec_client
+        try:
+            if tec_client:
+                tec_client.disconnect()
+                tec_client = None
+                self.connected.emit(False)
+            else:
+                self.connecting.emit()
+                tec_client = Client(host=self.ip, port=self.port, timeout=30)
+                self.connected.emit(True)
+                thread_pool.start(ClientTask(lambda: self.hw_rev.emit(tec_client.hw_rev())))
+                thread_pool.start(ClientTask(lambda: self.fan_update.emit(tec_client.fan())))
+        except Exception as e:
+            logging.error(f"Failed communicating to the {self.ip}:{self.port}: {e}")
+            self.connected.emit(False)
+
+    @pyqtSlot()
+    def client_disconnected(self):
+        global tec_client
+        if tec_client:
+            tec_client.disconnect()
+            tec_client = None
+            self.connected.emit(False)
+
+
+class ClientWatcher(QThread):
+    fan_update = pyqtSignal(object)
+    pwm_update = pyqtSignal(object)
+    report_update = pyqtSignal(object)
+    pid_update = pyqtSignal(object)
+
+    def __init__(self, parent, update_s):
+        self.update_s = update_s
+        self.running = True
+        super().__init__(parent)
+
+    def run(self):
+        while self.running:
+            thread_pool.start(ClientTask(lambda: self.update_params()))
+            self.msleep(int(self.update_s * 1000))
+
+    def update_params(self):
+        self.fan_update.emit(tec_client.fan())
+        self.pwm_update.emit(tec_client.get_pwm())
+        self.report_update.emit(tec_client._command("report"))
+        self.pid_update.emit(tec_client.get_pid())
+
+    @pyqtSlot()
+    def stop_watching(self):
+        self.running = False
+        deadline = QDeadlineTimer()
+        deadline.setDeadline(100)
+        self.wait(deadline)
+        self.terminate()
+
+    @pyqtSlot()
+    def set_update_s(self):
+        self.update_s = ui.report_refresh_spin.value()
+
+
+class ClientTask(QRunnable):
+    def __init__(self, func, *args, **kwargs):
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        super().__init__()
+
+    def run(self):
+        try:
+            self.func(*self.args, **self.kwargs)
+        except (TimeoutError, OSError):
+            logging.warning("Client connection error, disconnecting", exc_info=True)
+            if connection_watcher:
+                thread_pool.clear()  # clearing all next requests
+                connection_watcher.client_disconnected()
+
+
+def connected(result):
+    global client_watcher, connection_watcher
+    ui.graph_group.setEnabled(result)
+    ui.hw_rev_lbl.setEnabled(result)
+    ui.fan_group.setEnabled(result)
+    ui.report_group.setEnabled(result)
+
+    ui.ip_set_line.setEnabled(not result)
+    ui.port_set_spin.setEnabled(not result)
+    ui.status_lbl.setText("Connected" if result else "Disconnected")
+    ui.connect_btn.setText("Disconnect" if result else "Connect")
+    if not result:
+        ui.hw_rev_lbl.setText("Thermostat vX.Y")
+        ui.fan_group.setStyleSheet("")
+        if client_watcher:
+            client_watcher.stop_watching()
+            client_watcher = None
+    elif client_watcher is None:
+        client_watcher = ClientWatcher(ui.main_widget, ui.report_refresh_spin.value())
+        client_watcher.fan_update.connect(fan_update)
+        ui.report_apply_btn.clicked.connect(client_watcher.set_update_s)
+        app.aboutToQuit.connect(client_watcher.stop_watching)
+        client_watcher.start()
+
+
+def hw_rev(hw_rev_d: dict):
+    logging.debug(hw_rev_d)
+    ui.hw_rev_lbl.setText(f"Thermostat v{hw_rev_d['rev']['major']}.{hw_rev_d['rev']['major']}")
+    ui.fan_group.setEnabled(hw_rev_d["settings"]["fan_available"])
+    if hw_rev_d["settings"]["fan_pwm_recommended"]:
+        ui.fan_group.setStyleSheet("")
+        ui.fan_group.setToolTip("")
+    else:
+        ui.fan_group.setStyleSheet("background-color: yellow")
+        ui.fan_group.setToolTip("Changing the fan settings of not recommended")
+
+
+def fan_update(fan_settings):
+    logging.debug(fan_settings)
+    if fan_settings is None:
+        return
+    with QSignalBlocker(ui.fan_power_slider) as _:
+        ui.fan_power_slider.setValue(fan_settings["fan_pwm"])
+        ui.fan_power_slider.setEnabled(not fan_settings["auto_mode"])
+    with QSignalBlocker(ui.fan_auto_box) as _:
+        ui.fan_auto_box.setChecked(fan_settings["auto_mode"])
+
+
+def fan_set():
+    global tec_client
+    if tec_client is None or ui.fan_auto_box.isChecked():
+        return
+    thread_pool.start(ClientTask(lambda: tec_client.set_param("fan", ui.fan_power_slider.value())))
+
+
+def fan_auto_set(enabled):
+    global tec_client
+    if tec_client is None:
+        return
+    ui.fan_power_slider.setEnabled(not enabled)
+    if enabled:
+        thread_pool.start(ClientTask(lambda: tec_client.set_param("fan", "auto")))
+    else:
+        thread_pool.start(ClientTask(lambda: tec_client.set_param("fan", ui.fan_power_slider.value())))
+
+
+def connect():
+    global connection_watcher
+    connection_watcher = WatchConnectTask(ui.main_widget, ui.ip_set_line.text(), ui.port_set_spin.value())
+    connection_watcher.connected.connect(connected)
+    connection_watcher.connecting.connect(lambda: ui.status_lbl.setText("Connecting..."))
+    connection_watcher.hw_rev.connect(hw_rev)
+    connection_watcher.fan_update.connect(fan_update)
+    connection_watcher.start()
+    app.aboutToQuit.connect(connection_watcher.terminate)
+
+
+def update_pid(pid_settings):
+    for settings in pid_settings:
+        channel = settings["channel"]
+        with QSignalBlocker(params[channel].sigTreeStateChanged) as _:
+            params[channel].child("PID Config", "kP").setValue(settings["parameters"]["kp"])
+            params[channel].child("PID Config", "kI").setValue(settings["parameters"]["ki"])
+            params[channel].child("PID Config", "kD").setValue(settings["parameters"]["kd"])
+            if params[channel].child("Temperature PID").value():
+                params[channel].child("Temperature PID", "Set Temperature").setValue(settings["target"])
+
+def update_report(report_data):
+    for settings in report_data:
+        channel = settings["channel"]
+        with QSignalBlocker(params[channel].sigTreeStateChanged) as _:
+            params[channel].child("Temperature PID").setValue(settings["pid_engaged"])
+
+
+
+
+def send_command(param, changes):
+    for param, change, data in changes:
+        if param.name() == 'Temperature PID' and not data:
+            ch = param.opts["payload"]
+            thread_pool.start(ClientTask(
+                lambda: tec_client.set_param('pwm', ch, 'i_set', params[ch].child('Constant Current').value())))
+        elif param.opts.get("commands", None) is not None:
+            thread_pool.start(ClientTask(lambda: [tec_client._command(x.format(value=data)) for x in param.opts["commands"]]))
+
+
+def set_param_tree():
+    ui.ch0_tree.setParameters(params[0], showTop=False)
+    ui.ch1_tree.setParameters(params[1], showTop=False)
+    params[0].sigTreeStateChanged.connect(send_command)
+    params[1].sigTreeStateChanged.connect(send_command)
+
+
+def main():
+    global ui, thread_pool, app
+    args = get_argparser().parse_args()
+    if args.logLevel:
+        logging.basicConfig(level=getattr(logging, args.logLevel))
+
+    app = QtWidgets.QApplication(sys.argv)
+
+    loop = QEventLoop(app)
+    asyncio.set_event_loop(loop)
+    atexit.register(loop.close)
+
+    main_window = QtWidgets.QMainWindow()
+    ui = Ui_MainWindow()
+    ui.setupUi(main_window)
+    # ui = uic.loadUi('tec_qt.ui', main_window)
+
+    thread_pool = QThreadPool(parent=ui.main_widget)
+    thread_pool.setMaxThreadCount(1)  # avoid concurrent requests
+
+    ui.connect_btn.clicked.connect(lambda _checked: connect())
+    ui.fan_power_slider.valueChanged.connect(fan_set)
+    ui.fan_auto_box.stateChanged.connect(fan_auto_set)
+
+    set_param_tree()
+
+    if args.connect:
+        if args.IP:
+            ui.ip_set_line.setText(args.IP)
+        if args.PORT:
+            ui.port_set_spin.setValue(int(args.PORT))
+        ui.connect_btn.click()
+
+    main_window.show()
+    sys.exit(app.exec())
+
+
+if __name__ == '__main__':
+    main()

pytec/tec_qt.ui

@@ -0,0 +1,671 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>1280</width>
+    <height>720</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>1280</width>
+    <height>720</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>3840</width>
+    <height>2160</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Control TEC</string>
+  </property>
+  <widget class="QWidget" name="main_widget">
+   <property name="sizePolicy">
+    <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+     <horstretch>1</horstretch>
+     <verstretch>1</verstretch>
+    </sizepolicy>
+   </property>
+   <layout class="QGridLayout" name="gridLayout_2">
+    <property name="leftMargin">
+     <number>3</number>
+    </property>
+    <property name="topMargin">
+     <number>3</number>
+    </property>
+    <property name="rightMargin">
+     <number>3</number>
+    </property>
+    <property name="bottomMargin">
+     <number>3</number>
+    </property>
+    <property name="spacing">
+     <number>3</number>
+    </property>
+    <item row="0" column="1">
+     <layout class="QVBoxLayout" name="main_layout">
+      <property name="spacing">
+       <number>0</number>
+      </property>
+      <item>
+       <widget class="QFrame" name="graph_group">
+        <property name="enabled">
+         <bool>false</bool>
+        </property>
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+          <horstretch>1</horstretch>
+          <verstretch>1</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="frameShape">
+         <enum>QFrame::StyledPanel</enum>
+        </property>
+        <property name="frameShadow">
+         <enum>QFrame::Raised</enum>
+        </property>
+        <layout class="QGridLayout" name="graphs_layout" rowstretch="1,1" columnstretch="1,1,1" rowminimumheight="100,100" columnminimumwidth="100,100,100">
+         <property name="sizeConstraint">
+          <enum>QLayout::SetDefaultConstraint</enum>
+         </property>
+         <property name="leftMargin">
+          <number>3</number>
+         </property>
+         <property name="topMargin">
+          <number>3</number>
+         </property>
+         <property name="rightMargin">
+          <number>3</number>
+         </property>
+         <property name="bottomMargin">
+          <number>3</number>
+         </property>
+         <property name="spacing">
+          <number>2</number>
+         </property>
+         <item row="1" column="0">
+          <widget class="ParameterTree" name="ch1_tree" native="true"/>
+         </item>
+         <item row="0" column="0">
+          <widget class="ParameterTree" name="ch0_tree" native="true"/>
+         </item>
+         <item row="1" column="1">
+          <widget class="PlotWidget" name="ch1_t_graph" native="true">
+           <property name="title">
+            <string>Channel 1 Temperature</string>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="1">
+          <widget class="PlotWidget" name="ch0_t_graph" native="true">
+           <property name="title">
+            <string>Channel 0 Temperature</string>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="2">
+          <widget class="PlotWidget" name="ch0_i_graph" native="true">
+           <property name="title">
+            <string>Channel 0 Current</string>
+           </property>
+          </widget>
+         </item>
+         <item row="1" column="2">
+          <widget class="PlotWidget" name="ch1_i_graph" native="true">
+           <property name="title">
+            <string>Channel 1 Current</string>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </widget>
+      </item>
+      <item>
+       <widget class="QFrame" name="bottom_settings_group">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="minimumSize">
+         <size>
+          <width>0</width>
+          <height>40</height>
+         </size>
+        </property>
+        <property name="maximumSize">
+         <size>
+          <width>16777215</width>
+          <height>40</height>
+         </size>
+        </property>
+        <property name="frameShape">
+         <enum>QFrame::StyledPanel</enum>
+        </property>
+        <property name="frameShadow">
+         <enum>QFrame::Raised</enum>
+        </property>
+        <layout class="QHBoxLayout" name="horizontalLayout_2">
+         <property name="spacing">
+          <number>3</number>
+         </property>
+         <property name="leftMargin">
+          <number>3</number>
+         </property>
+         <property name="topMargin">
+          <number>3</number>
+         </property>
+         <property name="rightMargin">
+          <number>3</number>
+         </property>
+         <property name="bottomMargin">
+          <number>3</number>
+         </property>
+         <item>
+          <layout class="QHBoxLayout" name="settings_layout">
+           <item>
+            <widget class="QLineEdit" name="ip_set_line">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="minimumSize">
+              <size>
+               <width>160</width>
+               <height>0</height>
+              </size>
+             </property>
+             <property name="maximumSize">
+              <size>
+               <width>160</width>
+               <height>16777215</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>192.168.1.26</string>
+             </property>
+             <property name="maxLength">
+              <number>15</number>
+             </property>
+             <property name="placeholderText">
+              <string>IP:port for the Thermostat</string>
+             </property>
+             <property name="clearButtonEnabled">
+              <bool>true</bool>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QSpinBox" name="port_set_spin">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="minimumSize">
+              <size>
+               <width>70</width>
+               <height>0</height>
+              </size>
+             </property>
+             <property name="maximumSize">
+              <size>
+               <width>70</width>
+               <height>16777215</height>
+              </size>
+             </property>
+             <property name="maximum">
+              <number>65535</number>
+             </property>
+             <property name="value">
+              <number>23</number>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QPushButton" name="connect_btn">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="minimumSize">
+              <size>
+               <width>100</width>
+               <height>0</height>
+              </size>
+             </property>
+             <property name="maximumSize">
+              <size>
+               <width>100</width>
+               <height>16777215</height>
+              </size>
+             </property>
+             <property name="baseSize">
+              <size>
+               <width>100</width>
+               <height>0</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>Connect</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="status_lbl">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="minimumSize">
+              <size>
+               <width>120</width>
+               <height>0</height>
+              </size>
+             </property>
+             <property name="maximumSize">
+              <size>
+               <width>120</width>
+               <height>16777215</height>
+              </size>
+             </property>
+             <property name="baseSize">
+              <size>
+               <width>120</width>
+               <height>50</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>Disconnected</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="Line" name="line_0">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="orientation">
+              <enum>Qt::Vertical</enum>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QWidget" name="report_group" native="true">
+             <property name="enabled">
+              <bool>false</bool>
+             </property>
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Minimum" vsizetype="Expanding">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="minimumSize">
+              <size>
+               <width>40</width>
+               <height>0</height>
+              </size>
+             </property>
+             <layout class="QHBoxLayout" name="horizontalLayout_4">
+              <property name="spacing">
+               <number>0</number>
+              </property>
+              <property name="leftMargin">
+               <number>0</number>
+              </property>
+              <property name="topMargin">
+               <number>0</number>
+              </property>
+              <property name="rightMargin">
+               <number>0</number>
+              </property>
+              <property name="bottomMargin">
+               <number>0</number>
+              </property>
+              <item>
+               <layout class="QHBoxLayout" name="report_layout" stretch="1,1,1">
+                <property name="spacing">
+                 <number>6</number>
+                </property>
+                <property name="sizeConstraint">
+                 <enum>QLayout::SetDefaultConstraint</enum>
+                </property>
+                <property name="leftMargin">
+                 <number>0</number>
+                </property>
+                <item>
+                 <widget class="QDoubleSpinBox" name="report_refresh_spin">
+                  <property name="sizePolicy">
+                   <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+                    <horstretch>0</horstretch>
+                    <verstretch>0</verstretch>
+                   </sizepolicy>
+                  </property>
+                  <property name="minimumSize">
+                   <size>
+                    <width>70</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="maximumSize">
+                   <size>
+                    <width>70</width>
+                    <height>16777215</height>
+                   </size>
+                  </property>
+                  <property name="baseSize">
+                   <size>
+                    <width>70</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="decimals">
+                   <number>1</number>
+                  </property>
+                  <property name="minimum">
+                   <double>0.100000000000000</double>
+                  </property>
+                  <property name="singleStep">
+                   <double>0.100000000000000</double>
+                  </property>
+                  <property name="stepType">
+                   <enum>QAbstractSpinBox::AdaptiveDecimalStepType</enum>
+                  </property>
+                  <property name="value">
+                   <double>1.000000000000000</double>
+                  </property>
+                 </widget>
+                </item>
+                <item>
+                 <widget class="QCheckBox" name="report_box">
+                  <property name="sizePolicy">
+                   <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+                    <horstretch>0</horstretch>
+                    <verstretch>0</verstretch>
+                   </sizepolicy>
+                  </property>
+                  <property name="maximumSize">
+                   <size>
+                    <width>80</width>
+                    <height>16777215</height>
+                   </size>
+                  </property>
+                  <property name="baseSize">
+                   <size>
+                    <width>80</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="text">
+                   <string>Report</string>
+                  </property>
+                 </widget>
+                </item>
+                <item>
+                 <widget class="QPushButton" name="report_apply_btn">
+                  <property name="sizePolicy">
+                   <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+                    <horstretch>0</horstretch>
+                    <verstretch>0</verstretch>
+                   </sizepolicy>
+                  </property>
+                  <property name="minimumSize">
+                   <size>
+                    <width>80</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="maximumSize">
+                   <size>
+                    <width>80</width>
+                    <height>16777215</height>
+                   </size>
+                  </property>
+                  <property name="baseSize">
+                   <size>
+                    <width>80</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="text">
+                   <string>Apply</string>
+                  </property>
+                 </widget>
+                </item>
+               </layout>
+              </item>
+             </layout>
+            </widget>
+           </item>
+           <item>
+            <widget class="Line" name="line_1">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="orientation">
+              <enum>Qt::Vertical</enum>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QWidget" name="fan_group" native="true">
+             <property name="enabled">
+              <bool>false</bool>
+             </property>
+             <property name="minimumSize">
+              <size>
+               <width>40</width>
+               <height>0</height>
+              </size>
+             </property>
+             <layout class="QHBoxLayout" name="horizontalLayout_6">
+              <property name="spacing">
+               <number>0</number>
+              </property>
+              <property name="leftMargin">
+               <number>0</number>
+              </property>
+              <property name="topMargin">
+               <number>0</number>
+              </property>
+              <property name="rightMargin">
+               <number>0</number>
+              </property>
+              <property name="bottomMargin">
+               <number>0</number>
+              </property>
+              <item>
+               <layout class="QHBoxLayout" name="gan_layout">
+                <property name="spacing">
+                 <number>9</number>
+                </property>
+                <item>
+                 <widget class="QLabel" name="fan_lbl">
+                  <property name="sizePolicy">
+                   <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+                    <horstretch>0</horstretch>
+                    <verstretch>0</verstretch>
+                   </sizepolicy>
+                  </property>
+                  <property name="minimumSize">
+                   <size>
+                    <width>40</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="maximumSize">
+                   <size>
+                    <width>40</width>
+                    <height>16777215</height>
+                   </size>
+                  </property>
+                  <property name="baseSize">
+                   <size>
+                    <width>40</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="text">
+                   <string>Fan:</string>
+                  </property>
+                 </widget>
+                </item>
+                <item>
+                 <widget class="QSlider" name="fan_power_slider">
+                  <property name="sizePolicy">
+                   <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+                    <horstretch>0</horstretch>
+                    <verstretch>0</verstretch>
+                   </sizepolicy>
+                  </property>
+                  <property name="minimumSize">
+                   <size>
+                    <width>200</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="maximumSize">
+                   <size>
+                    <width>200</width>
+                    <height>16777215</height>
+                   </size>
+                  </property>
+                  <property name="baseSize">
+                   <size>
+                    <width>200</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="maximum">
+                   <number>100</number>
+                  </property>
+                  <property name="orientation">
+                   <enum>Qt::Horizontal</enum>
+                  </property>
+                 </widget>
+                </item>
+                <item>
+                 <widget class="QCheckBox" name="fan_auto_box">
+                  <property name="sizePolicy">
+                   <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+                    <horstretch>0</horstretch>
+                    <verstretch>0</verstretch>
+                   </sizepolicy>
+                  </property>
+                  <property name="minimumSize">
+                   <size>
+                    <width>70</width>
+                    <height>0</height>
+                   </size>
+                  </property>
+                  <property name="maximumSize">
+                   <size>
+                    <width>70</width>
+                    <height>16777215</height>
+                   </size>
+                  </property>
+                  <property name="text">
+                   <string>Auto</string>
+                  </property>
+                 </widget>
+                </item>
+               </layout>
+              </item>
+             </layout>
+            </widget>
+           </item>
+           <item>
+            <widget class="Line" name="line_3">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="orientation">
+              <enum>Qt::Vertical</enum>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="hw_rev_lbl">
+             <property name="enabled">
+              <bool>false</bool>
+             </property>
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="minimumSize">
+              <size>
+               <width>150</width>
+               <height>0</height>
+              </size>
+             </property>
+             <property name="maximumSize">
+              <size>
+               <width>150</width>
+               <height>16777215</height>
+              </size>
+             </property>
+             <property name="baseSize">
+              <size>
+               <width>150</width>
+               <height>0</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>Thermostat vX.Y</string>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+        </layout>
+       </widget>
+      </item>
+     </layout>
+    </item>
+   </layout>
+  </widget>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>PlotWidget</class>
+   <extends>QWidget</extends>
+   <header>pyqtgraph</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>ParameterTree</class>
+   <extends>QWidget</extends>
+   <header>pyqtgraph.parametertree</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

pytec/ui_tec_qt.py

@@ -0,0 +1,323 @@
+# Form implementation generated from reading ui file 'tec_qt.ui'
+#
+# Created by: PyQt6 UI code generator 6.4.2
+#
+# WARNING: Any manual changes made to this file will be lost when pyuic6 is
+# run again.  Do not edit this file unless you know what you are doing.
+
+
+from PyQt6 import QtCore, QtGui, QtWidgets
+
+
+class Ui_MainWindow(object):
+    def setupUi(self, MainWindow):
+        MainWindow.setObjectName("MainWindow")
+        MainWindow.resize(1280, 720)
+        MainWindow.setMinimumSize(QtCore.QSize(1280, 720))
+        MainWindow.setMaximumSize(QtCore.QSize(3840, 2160))
+        self.main_widget = QtWidgets.QWidget(parent=MainWindow)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Expanding)
+        sizePolicy.setHorizontalStretch(1)
+        sizePolicy.setVerticalStretch(1)
+        sizePolicy.setHeightForWidth(self.main_widget.sizePolicy().hasHeightForWidth())
+        self.main_widget.setSizePolicy(sizePolicy)
+        self.main_widget.setObjectName("main_widget")
+        self.gridLayout_2 = QtWidgets.QGridLayout(self.main_widget)
+        self.gridLayout_2.setContentsMargins(3, 3, 3, 3)
+        self.gridLayout_2.setSpacing(3)
+        self.gridLayout_2.setObjectName("gridLayout_2")
+        self.main_layout = QtWidgets.QVBoxLayout()
+        self.main_layout.setSpacing(0)
+        self.main_layout.setObjectName("main_layout")
+        self.graph_group = QtWidgets.QFrame(parent=self.main_widget)
+        self.graph_group.setEnabled(False)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Expanding)
+        sizePolicy.setHorizontalStretch(1)
+        sizePolicy.setVerticalStretch(1)
+        sizePolicy.setHeightForWidth(self.graph_group.sizePolicy().hasHeightForWidth())
+        self.graph_group.setSizePolicy(sizePolicy)
+        self.graph_group.setFrameShape(QtWidgets.QFrame.Shape.StyledPanel)
+        self.graph_group.setFrameShadow(QtWidgets.QFrame.Shadow.Raised)
+        self.graph_group.setObjectName("graph_group")
+        self.graphs_layout = QtWidgets.QGridLayout(self.graph_group)
+        self.graphs_layout.setSizeConstraint(QtWidgets.QLayout.SizeConstraint.SetDefaultConstraint)
+        self.graphs_layout.setContentsMargins(3, 3, 3, 3)
+        self.graphs_layout.setSpacing(2)
+        self.graphs_layout.setObjectName("graphs_layout")
+        self.ch1_tree = ParameterTree(parent=self.graph_group)
+        self.ch1_tree.setObjectName("ch1_tree")
+        self.graphs_layout.addWidget(self.ch1_tree, 1, 0, 1, 1)
+        self.ch0_tree = ParameterTree(parent=self.graph_group)
+        self.ch0_tree.setObjectName("ch0_tree")
+        self.graphs_layout.addWidget(self.ch0_tree, 0, 0, 1, 1)
+        self.ch1_t_graph = PlotWidget(parent=self.graph_group)
+        self.ch1_t_graph.setObjectName("ch1_t_graph")
+        self.graphs_layout.addWidget(self.ch1_t_graph, 1, 1, 1, 1)
+        self.ch0_t_graph = PlotWidget(parent=self.graph_group)
+        self.ch0_t_graph.setObjectName("ch0_t_graph")
+        self.graphs_layout.addWidget(self.ch0_t_graph, 0, 1, 1, 1)
+        self.ch0_i_graph = PlotWidget(parent=self.graph_group)
+        self.ch0_i_graph.setObjectName("ch0_i_graph")
+        self.graphs_layout.addWidget(self.ch0_i_graph, 0, 2, 1, 1)
+        self.ch1_i_graph = PlotWidget(parent=self.graph_group)
+        self.ch1_i_graph.setObjectName("ch1_i_graph")
+        self.graphs_layout.addWidget(self.ch1_i_graph, 1, 2, 1, 1)
+        self.graphs_layout.setColumnMinimumWidth(0, 100)
+        self.graphs_layout.setColumnMinimumWidth(1, 100)
+        self.graphs_layout.setColumnMinimumWidth(2, 100)
+        self.graphs_layout.setRowMinimumHeight(0, 100)
+        self.graphs_layout.setRowMinimumHeight(1, 100)
+        self.graphs_layout.setColumnStretch(0, 1)
+        self.graphs_layout.setColumnStretch(1, 1)
+        self.graphs_layout.setColumnStretch(2, 1)
+        self.graphs_layout.setRowStretch(0, 1)
+        self.graphs_layout.setRowStretch(1, 1)
+        self.main_layout.addWidget(self.graph_group)
+        self.bottom_settings_group = QtWidgets.QFrame(parent=self.main_widget)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.bottom_settings_group.sizePolicy().hasHeightForWidth())
+        self.bottom_settings_group.setSizePolicy(sizePolicy)
+        self.bottom_settings_group.setMinimumSize(QtCore.QSize(0, 40))
+        self.bottom_settings_group.setMaximumSize(QtCore.QSize(16777215, 40))
+        self.bottom_settings_group.setFrameShape(QtWidgets.QFrame.Shape.StyledPanel)
+        self.bottom_settings_group.setFrameShadow(QtWidgets.QFrame.Shadow.Raised)
+        self.bottom_settings_group.setObjectName("bottom_settings_group")
+        self.horizontalLayout_2 = QtWidgets.QHBoxLayout(self.bottom_settings_group)
+        self.horizontalLayout_2.setContentsMargins(3, 3, 3, 3)
+        self.horizontalLayout_2.setSpacing(3)
+        self.horizontalLayout_2.setObjectName("horizontalLayout_2")
+        self.settings_layout = QtWidgets.QHBoxLayout()
+        self.settings_layout.setObjectName("settings_layout")
+        self.ip_set_line = QtWidgets.QLineEdit(parent=self.bottom_settings_group)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Fixed, QtWidgets.QSizePolicy.Policy.Expanding)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.ip_set_line.sizePolicy().hasHeightForWidth())
+        self.ip_set_line.setSizePolicy(sizePolicy)
+        self.ip_set_line.setMinimumSize(QtCore.QSize(160, 0))
+        self.ip_set_line.setMaximumSize(QtCore.QSize(160, 16777215))
+        self.ip_set_line.setMaxLength(15)
+        self.ip_set_line.setClearButtonEnabled(True)
+        self.ip_set_line.setObjectName("ip_set_line")
+        self.settings_layout.addWidget(self.ip_set_line)
+        self.port_set_spin = QtWidgets.QSpinBox(parent=self.bottom_settings_group)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Fixed, QtWidgets.QSizePolicy.Policy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.port_set_spin.sizePolicy().hasHeightForWidth())
+        self.port_set_spin.setSizePolicy(sizePolicy)
+        self.port_set_spin.setMinimumSize(QtCore.QSize(70, 0))
+        self.port_set_spin.setMaximumSize(QtCore.QSize(70, 16777215))
+        self.port_set_spin.setMaximum(65535)
+        self.port_set_spin.setProperty("value", 23)
+        self.port_set_spin.setObjectName("port_set_spin")
+        self.settings_layout.addWidget(self.port_set_spin)
+        self.connect_btn = QtWidgets.QPushButton(parent=self.bottom_settings_group)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Fixed, QtWidgets.QSizePolicy.Policy.Expanding)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.connect_btn.sizePolicy().hasHeightForWidth())
+        self.connect_btn.setSizePolicy(sizePolicy)
+        self.connect_btn.setMinimumSize(QtCore.QSize(100, 0))
+        self.connect_btn.setMaximumSize(QtCore.QSize(100, 16777215))
+        self.connect_btn.setBaseSize(QtCore.QSize(100, 0))
+        self.connect_btn.setObjectName("connect_btn")
+        self.settings_layout.addWidget(self.connect_btn)
+        self.status_lbl = QtWidgets.QLabel(parent=self.bottom_settings_group)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Fixed, QtWidgets.QSizePolicy.Policy.Expanding)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.status_lbl.sizePolicy().hasHeightForWidth())
+        self.status_lbl.setSizePolicy(sizePolicy)
+        self.status_lbl.setMinimumSize(QtCore.QSize(120, 0))
+        self.status_lbl.setMaximumSize(QtCore.QSize(120, 16777215))
+        self.status_lbl.setBaseSize(QtCore.QSize(120, 50))
+        self.status_lbl.setObjectName("status_lbl")
+        self.settings_layout.addWidget(self.status_lbl)
+        self.line_0 = QtWidgets.QFrame(parent=self.bottom_settings_group)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.line_0.sizePolicy().hasHeightForWidth())
+        self.line_0.setSizePolicy(sizePolicy)
+        self.line_0.setFrameShape(QtWidgets.QFrame.Shape.VLine)
+        self.line_0.setFrameShadow(QtWidgets.QFrame.Shadow.Sunken)
+        self.line_0.setObjectName("line_0")
+        self.settings_layout.addWidget(self.line_0)
+        self.report_group = QtWidgets.QWidget(parent=self.bottom_settings_group)
+        self.report_group.setEnabled(False)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Minimum, QtWidgets.QSizePolicy.Policy.Expanding)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.report_group.sizePolicy().hasHeightForWidth())
+        self.report_group.setSizePolicy(sizePolicy)
+        self.report_group.setMinimumSize(QtCore.QSize(40, 0))
+        self.report_group.setObjectName("report_group")
+        self.horizontalLayout_4 = QtWidgets.QHBoxLayout(self.report_group)
+        self.horizontalLayout_4.setContentsMargins(0, 0, 0, 0)
+        self.horizontalLayout_4.setSpacing(0)
+        self.horizontalLayout_4.setObjectName("horizontalLayout_4")
+        self.report_layout = QtWidgets.QHBoxLayout()
+        self.report_layout.setSizeConstraint(QtWidgets.QLayout.SizeConstraint.SetDefaultConstraint)
+        self.report_layout.setContentsMargins(0, -1, -1, -1)
+        self.report_layout.setSpacing(6)
+        self.report_layout.setObjectName("report_layout")
+        self.report_refresh_spin = QtWidgets.QDoubleSpinBox(parent=self.report_group)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Fixed, QtWidgets.QSizePolicy.Policy.Expanding)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.report_refresh_spin.sizePolicy().hasHeightForWidth())
+        self.report_refresh_spin.setSizePolicy(sizePolicy)
+        self.report_refresh_spin.setMinimumSize(QtCore.QSize(70, 0))
+        self.report_refresh_spin.setMaximumSize(QtCore.QSize(70, 16777215))
+        self.report_refresh_spin.setBaseSize(QtCore.QSize(70, 0))
+        self.report_refresh_spin.setDecimals(1)
+        self.report_refresh_spin.setMinimum(0.1)
+        self.report_refresh_spin.setSingleStep(0.1)
+        self.report_refresh_spin.setStepType(QtWidgets.QAbstractSpinBox.StepType.AdaptiveDecimalStepType)
+        self.report_refresh_spin.setProperty("value", 1.0)
+        self.report_refresh_spin.setObjectName("report_refresh_spin")
+        self.report_layout.addWidget(self.report_refresh_spin)
+        self.report_box = QtWidgets.QCheckBox(parent=self.report_group)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Fixed, QtWidgets.QSizePolicy.Policy.Expanding)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.report_box.sizePolicy().hasHeightForWidth())
+        self.report_box.setSizePolicy(sizePolicy)
+        self.report_box.setMaximumSize(QtCore.QSize(80, 16777215))
+        self.report_box.setBaseSize(QtCore.QSize(80, 0))
+        self.report_box.setObjectName("report_box")
+        self.report_layout.addWidget(self.report_box)
+        self.report_apply_btn = QtWidgets.QPushButton(parent=self.report_group)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Fixed, QtWidgets.QSizePolicy.Policy.Expanding)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.report_apply_btn.sizePolicy().hasHeightForWidth())
+        self.report_apply_btn.setSizePolicy(sizePolicy)
+        self.report_apply_btn.setMinimumSize(QtCore.QSize(80, 0))
+        self.report_apply_btn.setMaximumSize(QtCore.QSize(80, 16777215))
+        self.report_apply_btn.setBaseSize(QtCore.QSize(80, 0))
+        self.report_apply_btn.setObjectName("report_apply_btn")
+        self.report_layout.addWidget(self.report_apply_btn)
+        self.report_layout.setStretch(0, 1)
+        self.report_layout.setStretch(1, 1)
+        self.report_layout.setStretch(2, 1)
+        self.horizontalLayout_4.addLayout(self.report_layout)
+        self.settings_layout.addWidget(self.report_group)
+        self.line_1 = QtWidgets.QFrame(parent=self.bottom_settings_group)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.line_1.sizePolicy().hasHeightForWidth())
+        self.line_1.setSizePolicy(sizePolicy)
+        self.line_1.setFrameShape(QtWidgets.QFrame.Shape.VLine)
+        self.line_1.setFrameShadow(QtWidgets.QFrame.Shadow.Sunken)
+        self.line_1.setObjectName("line_1")
+        self.settings_layout.addWidget(self.line_1)
+        self.fan_group = QtWidgets.QWidget(parent=self.bottom_settings_group)
+        self.fan_group.setEnabled(False)
+        self.fan_group.setMinimumSize(QtCore.QSize(40, 0))
+        self.fan_group.setObjectName("fan_group")
+        self.horizontalLayout_6 = QtWidgets.QHBoxLayout(self.fan_group)
+        self.horizontalLayout_6.setContentsMargins(0, 0, 0, 0)
+        self.horizontalLayout_6.setSpacing(0)
+        self.horizontalLayout_6.setObjectName("horizontalLayout_6")
+        self.gan_layout = QtWidgets.QHBoxLayout()
+        self.gan_layout.setSpacing(9)
+        self.gan_layout.setObjectName("gan_layout")
+        self.fan_lbl = QtWidgets.QLabel(parent=self.fan_group)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Fixed, QtWidgets.QSizePolicy.Policy.Expanding)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.fan_lbl.sizePolicy().hasHeightForWidth())
+        self.fan_lbl.setSizePolicy(sizePolicy)
+        self.fan_lbl.setMinimumSize(QtCore.QSize(40, 0))
+        self.fan_lbl.setMaximumSize(QtCore.QSize(40, 16777215))
+        self.fan_lbl.setBaseSize(QtCore.QSize(40, 0))
+        self.fan_lbl.setObjectName("fan_lbl")
+        self.gan_layout.addWidget(self.fan_lbl)
+        self.fan_power_slider = QtWidgets.QSlider(parent=self.fan_group)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Fixed, QtWidgets.QSizePolicy.Policy.Expanding)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.fan_power_slider.sizePolicy().hasHeightForWidth())
+        self.fan_power_slider.setSizePolicy(sizePolicy)
+        self.fan_power_slider.setMinimumSize(QtCore.QSize(200, 0))
+        self.fan_power_slider.setMaximumSize(QtCore.QSize(200, 16777215))
+        self.fan_power_slider.setBaseSize(QtCore.QSize(200, 0))
+        self.fan_power_slider.setMaximum(100)
+        self.fan_power_slider.setOrientation(QtCore.Qt.Orientation.Horizontal)
+        self.fan_power_slider.setObjectName("fan_power_slider")
+        self.gan_layout.addWidget(self.fan_power_slider)
+        self.fan_auto_box = QtWidgets.QCheckBox(parent=self.fan_group)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Fixed, QtWidgets.QSizePolicy.Policy.Expanding)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.fan_auto_box.sizePolicy().hasHeightForWidth())
+        self.fan_auto_box.setSizePolicy(sizePolicy)
+        self.fan_auto_box.setMinimumSize(QtCore.QSize(70, 0))
+        self.fan_auto_box.setMaximumSize(QtCore.QSize(70, 16777215))
+        self.fan_auto_box.setObjectName("fan_auto_box")
+        self.gan_layout.addWidget(self.fan_auto_box)
+        self.horizontalLayout_6.addLayout(self.gan_layout)
+        self.settings_layout.addWidget(self.fan_group)
+        self.line_3 = QtWidgets.QFrame(parent=self.bottom_settings_group)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.line_3.sizePolicy().hasHeightForWidth())
+        self.line_3.setSizePolicy(sizePolicy)
+        self.line_3.setFrameShape(QtWidgets.QFrame.Shape.VLine)
+        self.line_3.setFrameShadow(QtWidgets.QFrame.Shadow.Sunken)
+        self.line_3.setObjectName("line_3")
+        self.settings_layout.addWidget(self.line_3)
+        self.hw_rev_lbl = QtWidgets.QLabel(parent=self.bottom_settings_group)
+        self.hw_rev_lbl.setEnabled(False)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Fixed, QtWidgets.QSizePolicy.Policy.Expanding)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.hw_rev_lbl.sizePolicy().hasHeightForWidth())
+        self.hw_rev_lbl.setSizePolicy(sizePolicy)
+        self.hw_rev_lbl.setMinimumSize(QtCore.QSize(150, 0))
+        self.hw_rev_lbl.setMaximumSize(QtCore.QSize(150, 16777215))
+        self.hw_rev_lbl.setBaseSize(QtCore.QSize(150, 0))
+        self.hw_rev_lbl.setObjectName("hw_rev_lbl")
+        self.settings_layout.addWidget(self.hw_rev_lbl)
+        self.horizontalLayout_2.addLayout(self.settings_layout)
+        self.main_layout.addWidget(self.bottom_settings_group)
+        self.gridLayout_2.addLayout(self.main_layout, 0, 1, 1, 1)
+        MainWindow.setCentralWidget(self.main_widget)
+
+        self.retranslateUi(MainWindow)
+        QtCore.QMetaObject.connectSlotsByName(MainWindow)
+
+    def retranslateUi(self, MainWindow):
+        _translate = QtCore.QCoreApplication.translate
+        MainWindow.setWindowTitle(_translate("MainWindow", "Control TEC"))
+        self.ch1_t_graph.setTitle(_translate("MainWindow", "Channel 1 Temperature"))
+        self.ch0_t_graph.setTitle(_translate("MainWindow", "Channel 0 Temperature"))
+        self.ch0_i_graph.setTitle(_translate("MainWindow", "Channel 0 Current"))
+        self.ch1_i_graph.setTitle(_translate("MainWindow", "Channel 1 Current"))
+        self.ip_set_line.setText(_translate("MainWindow", "192.168.1.26"))
+        self.ip_set_line.setPlaceholderText(_translate("MainWindow", "IP:port for the Thermostat"))
+        self.connect_btn.setText(_translate("MainWindow", "Connect"))
+        self.status_lbl.setText(_translate("MainWindow", "Disconnected"))
+        self.report_box.setText(_translate("MainWindow", "Report"))
+        self.report_apply_btn.setText(_translate("MainWindow", "Apply"))
+        self.fan_lbl.setText(_translate("MainWindow", "Fan:"))
+        self.fan_auto_box.setText(_translate("MainWindow", "Auto"))
+        self.hw_rev_lbl.setText(_translate("MainWindow", "Thermostat vX.Y"))
+from pyqtgraph import PlotWidget
+from pyqtgraph.parametertree import ParameterTree
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtWidgets.QApplication(sys.argv)
+    MainWindow = QtWidgets.QMainWindow()
+    ui = Ui_MainWindow()
+    ui.setupUi(MainWindow)
+    MainWindow.show()
+    sys.exit(app.exec())

src/channel_state.rs

@@ -2,13 +2,11 @@ use smoltcp::time::{Duration, Instant};
 use uom::si::{
     f64::{
         ElectricPotential,
-        ElectricCurrent,
         ElectricalResistance,
         ThermodynamicTemperature,
         Time,
     },
     electric_potential::volt,
-    electric_current::ampere,
     electrical_resistance::ohm,
     thermodynamic_temperature::degree_celsius,
     time::millisecond,
@@ -28,10 +26,11 @@ pub struct ChannelState {
     pub adc_calibration: ad7172::ChannelCalibration,
     pub adc_time: Instant,
     pub adc_interval: Duration,
+    /// VREF for the TEC (1.5V)
+    pub vref: ElectricPotential,
     /// i_set 0A center point
     pub center: CenterPoint,
     pub dac_value: ElectricPotential,
-    pub i_set: ElectricCurrent,
     pub pid_engaged: bool,
     pub pid: pid::Controller,
     pub sh: sh::Parameters,
@@ -45,9 +44,10 @@ impl ChannelState {
             adc_time: Instant::from_secs(0),
             // default: 10 Hz
             adc_interval: Duration::from_millis(100),
+            // updated later with Channels.read_vref()
+            vref: ElectricPotential::new::<volt>(1.5),
             center: CenterPoint::Vref,
             dac_value: ElectricPotential::new::<volt>(0.0),
-            i_set: ElectricCurrent::new::<ampere>(0.0),
             pid_engaged: false,
             pid: pid::Controller::new(pid::Parameters::default()),
             sh: sh::Parameters::default(),

src/channels.rs

@@ -20,7 +20,6 @@ use crate::{
     command_handler::JsonBuffer,
     pins,
     steinhart_hart,
-    hw_rev,
 };
 
 pub const CHANNELS: usize = 2;
@@ -29,18 +28,17 @@ pub const R_SENSE: f64 = 0.05;
 const DAC_OUT_V_MAX: f64 = 3.0;
 
 // TODO: -pub
-pub struct Channels<'a> {
+pub struct Channels {
     channel0: Channel<Channel0>,
     channel1: Channel<Channel1>,
     pub adc: ad7172::Adc<pins::AdcSpi, pins::AdcNss>,
     /// stm32f4 integrated adc
     pins_adc: pins::PinsAdc,
     pub pwm: pins::PwmPins,
-    hwrev: &'a hw_rev::HWRev,
 }
 
-impl<'a> Channels<'a> {
-    pub fn new(pins: pins::Pins, hwrev: &'a hw_rev::HWRev) -> Self {
+impl Channels {
+    pub fn new(pins: pins::Pins) -> Self {
         let mut adc = ad7172::Adc::new(pins.adc_spi, pins.adc_nss).unwrap();
         // Feature not used
         adc.set_sync_enable(false).unwrap();
@@ -58,8 +56,9 @@ impl<'a> Channels<'a> {
         let channel1 = Channel::new(pins.channel1, adc_calibration1);
         let pins_adc = pins.pins_adc;
         let pwm = pins.pwm;
-        let mut channels = Channels { channel0, channel1, adc, pins_adc, pwm, hwrev };
+        let mut channels = Channels { channel0, channel1, adc, pins_adc, pwm };
         for channel in 0..CHANNELS {
+            channels.channel_state(channel).vref = channels.read_vref(channel);
             channels.calibrate_dac_value(channel);
             channels.set_i(channel, ElectricCurrent::new::<ampere>(0.0));
         }
@@ -99,8 +98,11 @@ impl<'a> Channels<'a> {
     /// calculate the TEC i_set centerpoint
     pub fn get_center(&mut self, channel: usize) -> ElectricPotential {
         match self.channel_state(channel).center {
-            CenterPoint::Vref =>
-                self.read_vref(channel),
+            CenterPoint::Vref => {
+                let vref = self.read_vref(channel);
+                self.channel_state(channel).vref = vref;
+                vref
+            },
             CenterPoint::Override(center_point) =>
                 ElectricPotential::new::<volt>(center_point.into()),
         }
@@ -113,8 +115,16 @@ impl<'a> Channels<'a> {
     }
 
     pub fn get_i(&mut self, channel: usize) -> ElectricCurrent {
-        let i_set = self.channel_state(channel).i_set;
-        i_set
+        let center_point = match channel.into() {
+            0 => self.channel0.vref_meas,
+            1 => self.channel1.vref_meas,
+            _ => unreachable!(),
+        };
+        // let center_point = self.get_center(channel);
+        let r_sense = ElectricalResistance::new::<ohm>(R_SENSE);
+        let voltage = self.get_dac(channel);
+        let i_tec = (voltage - center_point) / (10.0 * r_sense);
+        i_tec
     }
 
     /// i_set DAC
@@ -129,7 +139,7 @@ impl<'a> Channels<'a> {
         voltage
     }
 
-    pub fn set_i(&mut self, channel: usize, i_set: ElectricCurrent) -> ElectricCurrent {
+    pub fn set_i(&mut self, channel: usize, i_tec: ElectricCurrent) -> ElectricCurrent {
         let vref_meas = match channel.into() {
             0 => self.channel0.vref_meas,
             1 => self.channel1.vref_meas,
@@ -137,11 +147,10 @@ impl<'a> Channels<'a> {
         };
         let center_point = vref_meas;
         let r_sense = ElectricalResistance::new::<ohm>(R_SENSE);
-        let voltage = i_set * 10.0 * r_sense + center_point;
+        let voltage = i_tec * 10.0 * r_sense + center_point;
         let voltage = self.set_dac(channel, voltage);
-        let i_set = (voltage - center_point) / (10.0 * r_sense);
-        self.channel_state(channel).i_set = i_set;
-        i_set
+        let i_tec = (voltage - center_point) / (10.0 * r_sense);
+        i_tec
     }
 
     pub fn read_dac_feedback(&mut self, channel: usize) -> ElectricPotential {
@@ -428,9 +437,10 @@ impl<'a> Channels<'a> {
     }
 
     fn report(&mut self, channel: usize) -> Report {
+        let vref = self.channel_state(channel).vref;
         let i_set = self.get_i(channel);
-        let i_tec = if self.hwrev.major > 2 {Some(self.read_itec(channel))} else {None};
-        let tec_i = if self.hwrev.major > 2 {Some(self.get_tec_i(channel))} else {None};
+        let i_tec = self.read_itec(channel);
+        let tec_i = self.get_tec_i(channel);
         let dac_value = self.get_dac(channel);
         let state = self.channel_state(channel);
         let pid_output = ElectricCurrent::new::<ampere>(state.pid.y1);
@@ -444,6 +454,7 @@ impl<'a> Channels<'a> {
                 .map(|temperature| temperature.get::<degree_celsius>()),
             pid_engaged: state.pid_engaged,
             i_set,
+            vref,
             dac_value,
             dac_feedback: self.read_dac_feedback(channel),
             i_tec,
@@ -469,15 +480,6 @@ impl<'a> Channels<'a> {
         serde_json_core::to_vec(&summaries)
     }
 
-    pub fn pid_engaged(&mut self) -> bool {
-        for channel in 0..CHANNELS {
-            if self.channel_state(channel).pid_engaged {
-                return true;
-            }
-        }
-        false
-    }
-
     fn pwm_summary(&mut self, channel: usize) -> PwmSummary {
         PwmSummary {
             channel,
@@ -524,9 +526,9 @@ impl<'a> Channels<'a> {
         serde_json_core::to_vec(&summaries)
     }
 
-    pub fn current_abs_max_tec_i(&mut self) -> ElectricCurrent {
-        max_by(self.get_tec_i(0).abs(),
-               self.get_tec_i(1).abs(),
+    pub fn current_abs_max_tec_i(&mut self) -> f64 {
+        max_by(self.get_tec_i(0).abs().get::<ampere>(),
+               self.get_tec_i(1).abs().get::<ampere>(),
                |a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal))
     }
 }
@@ -541,10 +543,11 @@ pub struct Report {
     temperature: Option<f64>,
     pid_engaged: bool,
     i_set: ElectricCurrent,
+    vref: ElectricPotential,
     dac_value: ElectricPotential,
     dac_feedback: ElectricPotential,
-    i_tec: Option<ElectricPotential>,
-    tec_i: Option<ElectricCurrent>,
+    i_tec: ElectricPotential,
+    tec_i: ElectricCurrent,
     tec_u_meas: ElectricPotential,
     pid_output: ElectricCurrent,
 }

src/command_handler.rs

@@ -13,6 +13,7 @@ use super::{
         PwmPin, 
         ShParameter
     },
+    leds::Leds,
     ad7172,
     CHANNEL_CONFIG_KEY,
     channels::{
@@ -175,16 +176,18 @@ impl Handler {
         Ok(Handler::Handled)
     }
 
-    fn engage_pid (socket: &mut TcpSocket, channels: &mut Channels, channel: usize) -> Result<Handler, Error> {
+    fn engage_pid (socket: &mut TcpSocket, channels: &mut Channels, leds: &mut Leds, channel: usize) -> Result<Handler, Error> {
         channels.channel_state(channel).pid_engaged = true;
+        leds.g3.on();
         send_line(socket, b"{}");
         Ok(Handler::Handled)
     }
 
-    fn set_pwm (socket: &mut TcpSocket, channels: &mut Channels, channel: usize, pin: PwmPin, value: f64) -> Result<Handler, Error> {
+    fn set_pwm (socket: &mut TcpSocket, channels: &mut Channels, leds: &mut Leds, channel: usize, pin: PwmPin, value: f64) -> Result<Handler, Error> {
         match pin {
             PwmPin::ISet => {
                 channels.channel_state(channel).pid_engaged = false;
+                leds.g3.off();
                 let current = ElectricCurrent::new::<ampere>(value);
                 channels.set_i(channel, current);
                 channels.power_up(channel);
@@ -207,11 +210,11 @@ impl Handler {
     }
 
     fn set_center_point(socket: &mut TcpSocket, channels: &mut Channels, channel: usize, center: CenterPoint) -> Result<Handler, Error> {
-        let i_set = channels.get_i(channel);
+        let i_tec = channels.get_i(channel);
         let state = channels.channel_state(channel);
         state.center = center;
         if !state.pid_engaged {
-            channels.set_i(channel, i_set);
+            channels.set_i(channel, i_tec);
         }
         send_line(socket, b"{}");
         Ok(Handler::Handled)
@@ -412,7 +415,7 @@ impl Handler {
         }
     }
 
-    pub fn handle_command(command: Command, socket: &mut TcpSocket, channels: &mut Channels, session: &Session, store: &mut FlashStore, ipv4_config: &mut Ipv4Config, fan_ctrl: &mut FanCtrl, hwrev: HWRev) -> Result<Self, Error> {
+    pub fn handle_command(command: Command, socket: &mut TcpSocket, channels: &mut Channels, session: &Session, leds: &mut Leds, store: &mut FlashStore, ipv4_config: &mut Ipv4Config, fan_ctrl: &mut FanCtrl, hwrev: HWRev) -> Result<Self, Error> {
         match command {
             Command::Quit => Ok(Handler::CloseSocket),
             Command::Reporting(_reporting) => Handler::reporting(socket),            
@@ -423,8 +426,8 @@ impl Handler {
             Command::Show(ShowCommand::SteinhartHart) => Handler::show_steinhart_hart(socket, channels),
             Command::Show(ShowCommand::PostFilter) => Handler::show_post_filter(socket, channels),
             Command::Show(ShowCommand::Ipv4) => Handler::show_ipv4(socket, ipv4_config),
-            Command::PwmPid { channel } => Handler::engage_pid(socket, channels, channel),
-            Command::Pwm { channel, pin, value } => Handler::set_pwm(socket, channels, channel, pin, value),
+            Command::PwmPid { channel } => Handler::engage_pid(socket, channels, leds, channel),
+            Command::Pwm { channel, pin, value } => Handler::set_pwm(socket, channels, leds, channel, pin, value),
             Command::CenterPoint { channel, center } => Handler::set_center_point(socket, channels, channel, center),
             Command::Pid { channel, parameter, value } => Handler::set_pid(socket, channels, channel, parameter, value),
             Command::SteinhartHart { channel, parameter, value } => Handler::set_steinhart_hart(socket, channels, channel, parameter, value),

src/dfu.rs

@@ -1,4 +1,3 @@
-use core::arch::asm;
 use cortex_m_rt::pre_init;
 use stm32f4xx_hal::stm32::{RCC, SYSCFG};
 

src/fan_ctrl.rs

@@ -4,10 +4,7 @@ use stm32f4xx_hal::{
     pwm::{self, PwmChannels},
     pac::TIM8,
 };
-use uom::si::{
-    f64::ElectricCurrent,
-    electric_current::ampere,
-};
+
 use crate::{
     hw_rev::HWSettings,
     command_handler::JsonBuffer,
@@ -53,8 +50,8 @@ impl FanCtrl {
         fan_ctrl
     }
 
-    pub fn cycle(&mut self, abs_max_tec_i: ElectricCurrent) {
-        self.abs_max_tec_i = abs_max_tec_i.get::<ampere>() as f32;
+    pub fn cycle(&mut self, abs_max_tec_i: f32) {
+        self.abs_max_tec_i = abs_max_tec_i;
         if self.fan_auto && self.hw_settings.fan_available {
             let scaled_current = self.abs_max_tec_i / MAX_TEC_I;
             // do not limit upper bound, as it will be limited in the set_pwm()

src/main.rs

@@ -1,10 +1,11 @@
 #![cfg_attr(not(test), no_std)]
 #![cfg_attr(not(test), no_main)]
+#![feature(maybe_uninit_extra, asm)]
 #![cfg_attr(test, allow(unused))]
 // TODO: #![deny(warnings, unused)]
 
 #[cfg(not(any(feature = "semihosting", test)))]
-use panic_halt as _;
+use panic_abort as _;
 #[cfg(all(feature = "semihosting", not(test)))]
 use panic_semihosting as _;
 
@@ -138,7 +139,7 @@ fn main() -> ! {
 
     let mut store = flash_store::store(dp.FLASH);
 
-    let mut channels = Channels::new(pins, &hwrev);
+    let mut channels = Channels::new(pins);
     for c in 0..CHANNELS {
         match store.read_value::<ChannelConfig>(CHANNEL_CONFIG_KEY[c]) {
             Ok(Some(config)) =>
@@ -185,13 +186,7 @@ fn main() -> ! {
                     server.for_each(|_, session| session.set_report_pending(channel.into()));
                 }
 
-                fan_ctrl.cycle(channels.current_abs_max_tec_i());
-
-                if channels.pid_engaged() {
-                    leds.g3.on();
-                } else {
-                    leds.g3.off();
-                }
+                fan_ctrl.cycle(channels.current_abs_max_tec_i() as f32);
 
                 let instant = Instant::from_millis(i64::from(timer::now()));
                 cortex_m::interrupt::free(net::clear_pending);
@@ -216,7 +211,7 @@ fn main() -> ! {
                                 // Do nothing and feed more data to the line reader in the next loop cycle.
                                 Ok(SessionInput::Nothing) => {}
                                 Ok(SessionInput::Command(command)) => {
-                                    match Handler::handle_command(command, &mut socket, &mut channels, session, &mut store, &mut ipv4_config, &mut fan_ctrl, hwrev) {
+                                    match Handler::handle_command(command, &mut socket, &mut channels, session, &mut leds, &mut store, &mut ipv4_config, &mut fan_ctrl, hwrev) {
                                         Ok(Handler::NewIPV4(ip)) => new_ipv4_config = Some(ip),                                
                                         Ok(Handler::Handled) => {},
                                         Ok(Handler::CloseSocket) => socket.close(),

src/server.rs

@@ -1,3 +1,4 @@
+use core::mem::MaybeUninit;
 use smoltcp::{
     iface::EthernetInterface,
     socket::{SocketSet, SocketHandle, TcpSocket, TcpSocketBuffer, SocketRef},
@@ -12,18 +13,6 @@ pub struct SocketState<S> {
     state: S,
 }
 
-impl<'a, S: Default> SocketState<S>{
-    fn new(sockets: &mut SocketSet<'a>, tcp_rx_storage: &'a mut [u8; TCP_RX_BUFFER_SIZE], tcp_tx_storage: &'a mut [u8; TCP_TX_BUFFER_SIZE]) -> SocketState<S> {
-        let tcp_rx_buffer = TcpSocketBuffer::new(&mut tcp_rx_storage[..]);
-        let tcp_tx_buffer = TcpSocketBuffer::new(&mut tcp_tx_storage[..]);
-        let tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
-        SocketState::<S> {
-            handle: sockets.add(tcp_socket),
-            state: S::default()
-        }
-    }
-}
-
 /// Number of server sockets and therefore concurrent client
 /// sessions. Many data structures in `Server::run()` correspond to
 /// this const.
@@ -46,27 +35,28 @@ impl<'a, 'b, S: Default> Server<'a, 'b, S> {
     where
         F: FnOnce(&mut Server<'a, '_, S>),
     {
-        macro_rules! create_rtx_storage {
-            ($rx_storage:ident, $tx_storage:ident) => {
-                let mut $rx_storage = [0; TCP_RX_BUFFER_SIZE];
-                let mut $tx_storage = [0; TCP_TX_BUFFER_SIZE];
-            }
-        }
-
-        create_rtx_storage!(tcp_rx_storage0, tcp_tx_storage0);
-        create_rtx_storage!(tcp_rx_storage1, tcp_tx_storage1);
-        create_rtx_storage!(tcp_rx_storage2, tcp_tx_storage2);
-        create_rtx_storage!(tcp_rx_storage3, tcp_tx_storage3);
-
         let mut sockets_storage: [_; SOCKET_COUNT] = Default::default();
         let mut sockets = SocketSet::new(&mut sockets_storage[..]);
+        let mut states: [SocketState<S>; SOCKET_COUNT] = unsafe { MaybeUninit::uninit().assume_init() };
 
-        let states: [SocketState<S>; SOCKET_COUNT] = [
-            SocketState::<S>::new(&mut sockets, &mut tcp_rx_storage0, &mut tcp_tx_storage0),
-            SocketState::<S>::new(&mut sockets, &mut tcp_rx_storage1, &mut tcp_tx_storage1),
-            SocketState::<S>::new(&mut sockets, &mut tcp_rx_storage2, &mut tcp_tx_storage2),
-            SocketState::<S>::new(&mut sockets, &mut tcp_rx_storage3, &mut tcp_tx_storage3),
-        ];
+        macro_rules! create_socket {
+            ($set:ident, $rx_storage:ident, $tx_storage:ident, $target:expr) => {
+                let mut $rx_storage = [0; TCP_RX_BUFFER_SIZE];
+                let mut $tx_storage = [0; TCP_TX_BUFFER_SIZE];
+                let tcp_rx_buffer = TcpSocketBuffer::new(&mut $rx_storage[..]);
+                let tcp_tx_buffer = TcpSocketBuffer::new(&mut $tx_storage[..]);
+                let tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
+                $target = $set.add(tcp_socket);
+            }
+        }
+        create_socket!(sockets, tcp_rx_storage0, tcp_tx_storage0, states[0].handle);
+        create_socket!(sockets, tcp_rx_storage1, tcp_tx_storage1, states[1].handle);
+        create_socket!(sockets, tcp_rx_storage2, tcp_tx_storage2, states[2].handle);
+        create_socket!(sockets, tcp_rx_storage3, tcp_tx_storage3, states[3].handle);
+
+        for state in &mut states {
+            state.state = S::default();
+        }
 
         let mut server = Server {
             states,