update docs

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
 
@@ -94,42 +108,36 @@ The scope of this setting is per TCP session.
 Send commands as simple text string terminated by `\n`. Responses are
 formatted as line-delimited JSON.
 
-| Syntax                           | Function                                                                      |
-|----------------------------------|-------------------------------------------------------------------------------|
-| `report`                         | Show current input                                                            |
-| `report mode`                    | Show current report mode                                                      |
-| `report mode <off/on>`           | Set report mode                                                               |
-| `pwm`                            | Show current PWM settings                                                     |
-| `pwm <0/1> max_i_pos <amp>`      | Set maximum positive output current                                           |
-| `pwm <0/1> max_i_neg <amp>`      | Set maximum negative output current                                           |
-| `pwm <0/1> max_v <volt>`         | Set maximum output voltage                                                    |
-| `pwm <0/1> i_set <amp>`          | Disengage PID, set fixed output current                                       |
-| `pwm <0/1> pid`                  | Let output current to be controlled by the PID                                |
-| `center <0/1> <volt>`            | Set the MAX1968 0A-centerpoint to the specified fixed voltage                 |
-| `center <0/1> vref`              | Set the MAX1968 0A-centerpoint to measure from VREF                           |
-| `pid`                            | Show PID configuration                                                        |
-| `pid <0/1> target <deg_celsius>` | Set the PID controller target temperature                                     |
-| `pid <0/1> kp <value>`           | Set proportional gain                                                         |
-| `pid <0/1> ki <value>`           | Set integral gain                                                             |
-| `pid <0/1> kd <value>`           | Set differential gain                                                         |
-| `pid <0/1> output_min <amp>`     | Set mininum output                                                            |
-| `pid <0/1> output_max <amp>`     | Set maximum output                                                            |
-| `s-h`                            | Show Steinhart-Hart equation parameters                                       |
-| `s-h <0/1> <t0/b/r0> <value>`    | Set Steinhart-Hart parameter for a channel                                    |
-| `postfilter`                     | Show postfilter settings                                                      |
-| `postfilter <0/1> off`           | Disable postfilter                                                            |
-| `postfilter <0/1> rate <rate>`   | Set postfilter output data rate                                               |
-| `load [0/1]`                     | Restore configuration for channel all/0/1 from flash                          |
-| `save [0/1]`                     | Save configuration for channel all/0/1 to flash                               |
-| `reset`                          | Reset the device                                                              |
-| `dfu`                            | Reset device and enters USB device firmware update (DFU) mode                 |
-| `ipv4 <X.X.X.X/L> [Y.Y.Y.Y]`     | Configure IPv4 address, netmask length, and optional default gateway          |
-| `fan`                            | Show current fan settings and sensors' measurements                           |
-| `fan <value>`                    | Set fan power with values from 1 to 100                                       |
-| `fan auto`                       | Enable automatic fan speed control                                            |
-| `fcurve <a> <b> <c>`             | Set fan controller curve coefficients (see *Fan control* section)             |
-| `fcurve default`                 | Set fan controller curve coefficients to defaults (see *Fan control* section) |
-| `hwrev`                          | Show hardware revision, and settings related to it                            |
+| Syntax                           | Function                                                             |
+| ---                              | ---                                                                  |
+| `report`                         | Show current input                                                   |
+| `report mode`                    | Show current report mode                                             |
+| `report mode <off/on>`           | Set report mode                                                      |
+| `pwm`                            | Show current PWM settings                                            |
+| `pwm <0/1> max_i_pos <amp>`      | Set maximum positive output current                                  |
+| `pwm <0/1> max_i_neg <amp>`      | Set maximum negative output current                                  |
+| `pwm <0/1> max_v <volt>`         | Set maximum output voltage                                           |
+| `pwm <0/1> i_set <amp>`          | Disengage PID, set fixed output current                              |
+| `pwm <0/1> pid`                  | Let output current to be controlled by the PID                       |
+| `center <0/1> <volt>`            | Set the MAX1968 0A-centerpoint to the specified fixed voltage        |
+| `center <0/1> vref`              | Set the MAX1968 0A-centerpoint to measure from VREF                  |
+| `pid`                            | Show PID configuration                                               |
+| `pid <0/1> target <deg_celsius>` | Set the PID controller target temperature                            |
+| `pid <0/1> kp <value>`           | Set proportional gain                                                |
+| `pid <0/1> ki <value>`           | Set integral gain                                                    |
+| `pid <0/1> kd <value>`           | Set differential gain                                                |
+| `pid <0/1> output_min <amp>`     | Set mininum output                                                   |
+| `pid <0/1> output_max <amp>`     | Set maximum output                                                   |
+| `s-h`                            | Show Steinhart-Hart equation parameters                              |
+| `s-h <0/1> <t0/b/r0> <value>`    | Set Steinhart-Hart parameter for a channel                           |
+| `postfilter`                     | Show postfilter settings                                             |
+| `postfilter <0/1> off`           | Disable postfilter                                                   |
+| `postfilter <0/1> rate <rate>`   | Set postfilter output data rate                                      |
+| `load [0/1]`                     | Restore configuration for channel all/0/1 from flash                 |
+| `save [0/1]`                     | Save configuration for channel all/0/1 to flash                      |
+| `reset`                          | Reset the device                                                     |
+| `dfu`                            | Reset device and enters USB device firmware update (DFU) mode        |
+| `ipv4 <X.X.X.X/L> [Y.Y.Y.Y]`     | Configure IPv4 address, netmask length, and optional default gateway |
 
 
 ## USB
@@ -258,12 +266,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 +280,6 @@ 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:
-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.
-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`.

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": 1641870998,
+        "narHash": "sha256-6HkxR2WZsm37VoQS7jgp6Omd71iw6t1kP8bDbaqCDuI=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "011567f35433879aae5024fc6ec53f2a0568a6c4",
+        "rev": "386234e2a61e1e8acf94dfa3a3d3ca19a6776efb",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
-        "ref": "nixos-23.05",
+        "ref": "nixos-21.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-21.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";
 
@@ -67,10 +67,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
           ]);
+          shellHook=
+          ''
+            export QT_PLUGIN_PATH=${pkgs.qt5.qtbase}/${pkgs.qt5.qtbase.dev.qtPluginPrefix}
+            export QML2_IMPORT_PATH=${pkgs.qt5.qtbase}/${pkgs.qt5.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

@@ -1,6 +1,5 @@
 import socket
 import json
-import logging
 
 class CommandError(Exception):
     pass
@@ -9,14 +8,6 @@ class Client:
     def __init__(self, host="192.168.1.26", port=23, timeout=None):
         self._socket = socket.create_connection((host, port), timeout)
         self._lines = [""]
-        self._check_zero_limits()
-
-    def _check_zero_limits(self):
-        pwm_report = self.get_pwm()
-        for pwm_channel in pwm_report:
-            for limit in ["max_i_neg", "max_i_pos", "max_v"]:
-                if pwm_channel[limit]["value"] == 0.0:
-                    logging.warning("`{}` limit is set to zero on channel {}".format(limit, pwm_channel["channel"]))
 
     def _read_line(self):
         # read more lines
@@ -32,7 +23,7 @@ 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)

pytec/tecQT.py

@@ -0,0 +1,308 @@
+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()

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

@@ -1,5 +1,4 @@
-use core::cmp::max_by;
-use heapless::{consts::U2, Vec};
+use heapless::{consts::{U2, U1024}, Vec};
 use serde::{Serialize, Serializer};
 use smoltcp::time::Instant;
 use stm32f4xx_hal::hal;
@@ -17,34 +16,27 @@ use crate::{
     channel::{Channel, Channel0, Channel1},
     channel_state::ChannelState,
     command_parser::{CenterPoint, PwmPin},
-    command_handler::JsonBuffer,
-    pins::{self, Channel0VRef, Channel1VRef},
+    pins,
     steinhart_hart,
-    hw_rev,
 };
 
 pub const CHANNELS: usize = 2;
 pub const R_SENSE: f64 = 0.05;
-
-// as stated in the MAX1968 datasheet
-pub const MAX_TEC_I: f64 = 3.0;
-
 // DAC chip outputs 0-5v, which is then passed through a resistor dividor to provide 0-3v range
 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();
@@ -62,8 +54,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));
         }
@@ -103,8 +96,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()),
         }
@@ -117,8 +113,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
@@ -133,12 +137,7 @@ impl<'a> Channels<'a> {
         voltage
     }
 
-    pub fn set_i(&mut self, channel: usize, i_set: ElectricCurrent) -> ElectricCurrent {
-        // Silently clamp i_set
-        let i_ceiling = ElectricCurrent::new::<ampere>(MAX_TEC_I);
-        let i_floor = ElectricCurrent::new::<ampere>(-MAX_TEC_I);
-        let i_set = i_set.min(i_ceiling).max(i_floor);
-
+    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,
@@ -146,11 +145,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 {
@@ -212,30 +210,20 @@ impl<'a> Channels<'a> {
     pub fn read_vref(&mut self, channel: usize) -> ElectricPotential {
         match channel {
             0 => {
-                match &self.channel0.vref_pin {
-                    Channel0VRef::Analog(vref_pin) => {
-                        let sample = self.pins_adc.convert(
-                            vref_pin,
-                            stm32f4xx_hal::adc::config::SampleTime::Cycles_480
-                        );
-                        let mv = self.pins_adc.sample_to_millivolts(sample);
-                        ElectricPotential::new::<millivolt>(mv as f64)
-                    },
-                    Channel0VRef::Disabled(_) => ElectricPotential::new::<volt>(1.5)
-                }
+                let sample = self.pins_adc.convert(
+                    &self.channel0.vref_pin,
+                    stm32f4xx_hal::adc::config::SampleTime::Cycles_480
+                );
+                let mv = self.pins_adc.sample_to_millivolts(sample);
+                ElectricPotential::new::<millivolt>(mv as f64)
             }
             1 => {
-                match &self.channel1.vref_pin {
-                    Channel1VRef::Analog(vref_pin) => {
-                        let sample = self.pins_adc.convert(
-                            vref_pin,
-                            stm32f4xx_hal::adc::config::SampleTime::Cycles_480
-                        );
-                        let mv = self.pins_adc.sample_to_millivolts(sample);
-                        ElectricPotential::new::<millivolt>(mv as f64)
-                    },
-                    Channel1VRef::Disabled(_) => ElectricPotential::new::<volt>(1.5)
-                }
+                let sample = self.pins_adc.convert(
+                    &self.channel1.vref_pin,
+                    stm32f4xx_hal::adc::config::SampleTime::Cycles_480
+                );
+                let mv = self.pins_adc.sample_to_millivolts(sample);
+                ElectricPotential::new::<millivolt>(mv as f64)
             }
             _ => unreachable!(),
         }
@@ -447,9 +435,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);
@@ -463,6 +452,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,
@@ -488,15 +478,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,
@@ -542,14 +523,10 @@ 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(),
-               |a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal))
-    }
 }
 
+type JsonBuffer = Vec<u8, U1024>;
+
 #[derive(Serialize)]
 pub struct Report {
     channel: usize,
@@ -560,10 +537,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

@@ -1,7 +1,6 @@
 use smoltcp::socket::TcpSocket;
 use log::{error, warn};
 use core::fmt::Write;
-use heapless::{consts::U1024, Vec};
 use super::{
     net,
     command_parser::{
@@ -13,6 +12,7 @@ use super::{
         PwmPin, 
         ShParameter
     },
+    leds::Leds,
     ad7172,
     CHANNEL_CONFIG_KEY,
     channels::{
@@ -22,9 +22,7 @@ use super::{
     config::ChannelConfig,
     dfu,
     flash_store::FlashStore,
-    session::Session,
-    FanCtrl,
-    hw_rev::HWRev,
+    session::Session
 };
 
 use uom::{
@@ -57,8 +55,6 @@ pub enum Error {
     FlashError
 }
 
-pub type JsonBuffer = Vec<u8, U1024>;
-
 fn send_line(socket: &mut TcpSocket, data: &[u8]) -> bool {
     let send_free = socket.send_capacity() - socket.send_queue();
     if data.len() > send_free + 1 {
@@ -175,16 +171,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 +205,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)
@@ -343,88 +341,19 @@ impl Handler {
         Ok(Handler::Reset)
     }
 
-    fn set_fan(socket: &mut TcpSocket, fan_pwm: u32, fan_ctrl: &mut FanCtrl) -> Result<Handler, Error> {
-        if !fan_ctrl.fan_available() {
-            send_line(socket, b"{ \"warning\": \"this thermostat doesn't have fan!\" }");
-            return Ok(Handler::Handled);
-        }
-        fan_ctrl.set_auto_mode(false);
-        fan_ctrl.set_pwm(fan_pwm);
-        if fan_ctrl.fan_pwm_recommended() {
-            send_line(socket, b"{}");
-        } else {
-            send_line(socket, b"{ \"warning\": \"this fan doesn't have full PWM support. Use it at your own risk!\" }");
-        }
-        Ok(Handler::Handled)
-    }
-
-    fn show_fan(socket: &mut TcpSocket, fan_ctrl: &mut FanCtrl) -> Result<Handler, Error> {
-        match fan_ctrl.summary() {
-            Ok(buf) => {
-                send_line(socket, &buf);
-                Ok(Handler::Handled)
-            }
-            Err(e) => {
-                error!("unable to serialize fan summary: {:?}", e);
-                let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
-                Err(Error::ReportError)
-            }
-        }
-    }
-
-    fn fan_auto(socket: &mut TcpSocket, fan_ctrl: &mut FanCtrl) -> Result<Handler, Error> {
-        if !fan_ctrl.fan_available() {
-            send_line(socket, b"{ \"warning\": \"this thermostat doesn't have fan!\" }");
-            return Ok(Handler::Handled);
-        }
-        fan_ctrl.set_auto_mode(true);
-        if fan_ctrl.fan_pwm_recommended() {
-            send_line(socket, b"{}");
-        } else {
-            send_line(socket, b"{ \"warning\": \"this fan doesn't have full PWM support. Use it at your own risk!\" }");
-        }
-        Ok(Handler::Handled)
-    }
-
-    fn fan_curve(socket: &mut TcpSocket, fan_ctrl: &mut FanCtrl, k_a: f32, k_b: f32, k_c: f32) -> Result<Handler, Error> {
-        fan_ctrl.set_curve(k_a, k_b, k_c);
-        send_line(socket, b"{}");
-        Ok(Handler::Handled)
-    }
-
-    fn fan_defaults(socket: &mut TcpSocket, fan_ctrl: &mut FanCtrl) -> Result<Handler, Error> {
-        fan_ctrl.restore_defaults();
-        send_line(socket, b"{}");
-        Ok(Handler::Handled)
-    }
-
-    fn show_hwrev(socket: &mut TcpSocket, hwrev: HWRev) -> Result<Handler, Error> {
-        match hwrev.summary() {
-            Ok(buf) => {
-                send_line(socket, &buf);
-                Ok(Handler::Handled)
-            }
-            Err(e) => {
-                error!("unable to serialize HWRev summary: {:?}", e);
-                let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
-                Err(Error::ReportError)
-            }
-        }
-    }
-
-    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) -> Result<Self, Error> {
         match command {
             Command::Quit => Ok(Handler::CloseSocket),
             Command::Reporting(_reporting) => Handler::reporting(socket),            
             Command::Show(ShowCommand::Reporting) => Handler::show_report_mode(socket, session),            
-            Command::Show(ShowCommand::Input) => Handler::show_report(socket, channels),
-            Command::Show(ShowCommand::Pid) => Handler::show_pid(socket, channels),
-            Command::Show(ShowCommand::Pwm) => Handler::show_pwm(socket, channels),
-            Command::Show(ShowCommand::SteinhartHart) => Handler::show_steinhart_hart(socket, channels),
-            Command::Show(ShowCommand::PostFilter) => Handler::show_post_filter(socket, channels),
+            Command::Show(ShowCommand::Input) => Handler::show_report(socket, channels),            
+            Command::Show(ShowCommand::Pid) => Handler::show_pid(socket, channels),            
+            Command::Show(ShowCommand::Pwm) => Handler::show_pwm(socket, channels),            
+            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),
@@ -434,13 +363,7 @@ impl Handler {
             Command::Save { channel } => Handler::save_channel(socket, channels, channel, store),
             Command::Ipv4(config) => Handler::set_ipv4(socket, store, config),
             Command::Reset => Handler::reset(channels),
-            Command::Dfu => Handler::dfu(channels),
-            Command::FanSet {fan_pwm} => Handler::set_fan(socket, fan_pwm, fan_ctrl),
-            Command::ShowFan => Handler::show_fan(socket, fan_ctrl),
-            Command::FanAuto => Handler::fan_auto(socket, fan_ctrl),
-            Command::FanCurve { k_a, k_b, k_c } => Handler::fan_curve(socket, fan_ctrl, k_a, k_b, k_c),
-            Command::FanCurveDefaults => Handler::fan_defaults(socket, fan_ctrl),
-            Command::ShowHWRev => Handler::show_hwrev(socket, hwrev),
+            Command::Dfu => Handler::dfu(channels)
         }
     }
 }

src/command_parser.rs

@@ -10,7 +10,6 @@ use nom::{
     sequence::preceded,
     multi::{fold_many0, fold_many1},
     error::ErrorKind,
-    Needed,
 };
 use num_traits::{Num, ParseFloatError};
 use serde::{Serialize, Deserialize};
@@ -179,18 +178,6 @@ pub enum Command {
         rate: Option<f32>,
     },
     Dfu,
-    FanSet {
-        fan_pwm: u32
-    },
-    FanAuto,
-    ShowFan,
-    FanCurve {
-        k_a: f32,
-        k_b: f32,
-        k_c: f32,
-    },
-    FanCurveDefaults,
-    ShowHWRev,
 }
 
 fn end(input: &[u8]) -> IResult<&[u8], ()> {
@@ -533,57 +520,6 @@ fn ipv4(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
     ))(input)
 }
 
-fn fan(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
-    let (input, _) = tag("fan")(input)?;
-    alt((
-        |input| {
-            let (input, _) = whitespace(input)?;
-
-            let (input, result) = alt((
-                |input| {
-                    let (input, _) = tag("auto")(input)?;
-                    Ok((input, Ok(Command::FanAuto)))
-                },
-                |input| {
-                    let (input, value) = unsigned(input)?;
-                    Ok((input, Ok(Command::FanSet { fan_pwm: value.unwrap_or(0)})))
-                },
-            ))(input)?;
-            Ok((input, result))
-        },
-        value(Ok(Command::ShowFan), end)
-    ))(input)
-}
-
-fn fan_curve(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
-    let (input, _) = tag("fcurve")(input)?;
-    alt((
-        |input| {
-            let (input, _) = whitespace(input)?;
-            let (input, result) = alt((
-                |input| {
-                    let (input, _) = tag("default")(input)?;
-                    Ok((input, Ok(Command::FanCurveDefaults)))
-                },
-                |input| {
-                    let (input, k_a) = float(input)?;
-                    let (input, _) = whitespace(input)?;
-                    let (input, k_b) = float(input)?;
-                    let (input, _) = whitespace(input)?;
-                    let (input, k_c) = float(input)?;
-                    if k_a.is_ok() && k_b.is_ok() && k_c.is_ok() {
-                        Ok((input, Ok(Command::FanCurve { k_a: k_a.unwrap() as f32, k_b: k_b.unwrap() as f32, k_c: k_c.unwrap() as f32 })))
-                    } else {
-                        Err(nom::Err::Incomplete(Needed::Size(3)))
-                    }
-                },
-            ))(input)?;
-            Ok((input, result))
-        },
-        value(Err(Error::Incomplete), end)
-    ))(input)
-}
-
 fn command(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
     alt((value(Ok(Command::Quit), tag("quit")),
          load,
@@ -597,9 +533,6 @@ fn command(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
          steinhart_hart,
          postfilter,
          value(Ok(Command::Dfu), tag("dfu")),
-         fan,
-         fan_curve,
-         value(Ok(Command::ShowHWRev), tag("hwrev")),
     ))(input)
 }
 
@@ -821,44 +754,4 @@ mod test {
             center: CenterPoint::Vref,
         }));
     }
-
-    #[test]
-    fn parse_fan_show() {
-        let command = Command::parse(b"fan");
-        assert_eq!(command, Ok(Command::ShowFan));
-    }
-
-    #[test]
-    fn parse_fan_set() {
-        let command = Command::parse(b"fan 42");
-        assert_eq!(command, Ok(Command::FanSet {fan_pwm: 42}));
-    }
-
-    #[test]
-    fn parse_fan_auto() {
-        let command = Command::parse(b"fan auto");
-        assert_eq!(command, Ok(Command::FanAuto));
-    }
-
-    #[test]
-    fn parse_fcurve_set() {
-        let command = Command::parse(b"fcurve 1.2 3.4 5.6");
-        assert_eq!(command, Ok(Command::FanCurve {
-            k_a: 1.2,
-            k_b: 3.4,
-            k_c: 5.6
-        }));
-    }
-
-    #[test]
-    fn parse_fcurve_default() {
-        let command = Command::parse(b"fcurve default");
-        assert_eq!(command, Ok(Command::FanCurveDefaults));
-    }
-
-    #[test]
-    fn parse_hwrev() {
-        let command = Command::parse(b"hwrev");
-        assert_eq!(command, Ok(Command::ShowHWRev));
-    }
 }

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

@@ -1,152 +0,0 @@
-use num_traits::Float;
-use serde::Serialize;
-use stm32f4xx_hal::{
-    pwm::{self, PwmChannels},
-    pac::TIM8,
-};
-use uom::si::{
-    f64::ElectricCurrent,
-    electric_current::ampere,
-};
-use crate::{
-    hw_rev::HWSettings,
-    command_handler::JsonBuffer,
-    channels::MAX_TEC_I,
-};
-
-pub type FanPin = PwmChannels<TIM8, pwm::C4>;
-
-const MAX_USER_FAN_PWM: f32 = 100.0;
-const MIN_USER_FAN_PWM: f32 = 1.0;
-
-
-pub struct FanCtrl {
-    fan: Option<FanPin>,
-    fan_auto: bool,
-    pwm_enabled: bool,
-    k_a: f32,
-    k_b: f32,
-    k_c: f32,
-    abs_max_tec_i: f32,
-    hw_settings: HWSettings,
-}
-
-impl FanCtrl {
-    pub fn new(fan: Option<FanPin>, hw_settings: HWSettings) -> Self {
-        let mut fan_ctrl = FanCtrl {
-            fan,
-            // do not enable auto mode by default,
-            // but allow to turn it at the user's own risk
-            fan_auto: hw_settings.fan_pwm_recommended,
-            pwm_enabled: false,
-            k_a: hw_settings.fan_k_a,
-            k_b: hw_settings.fan_k_b,
-            k_c: hw_settings.fan_k_c,
-            abs_max_tec_i: 0f32,
-            hw_settings,
-        };
-        if fan_ctrl.fan_auto {
-            fan_ctrl.enable_pwm();
-        }
-        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;
-        if self.fan_auto && self.hw_settings.fan_available {
-            let scaled_current = self.abs_max_tec_i / MAX_TEC_I as f32;
-            // do not limit upper bound, as it will be limited in the set_pwm()
-            let pwm = (MAX_USER_FAN_PWM * (scaled_current * (scaled_current * self.k_a + self.k_b) + self.k_c)) as u32;
-            self.set_pwm(pwm);
-        }
-    }
-
-    pub fn summary(&mut self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
-        if self.hw_settings.fan_available {
-            let summary = FanSummary {
-                fan_pwm: self.get_pwm(),
-                abs_max_tec_i: self.abs_max_tec_i,
-                auto_mode: self.fan_auto,
-                k_a: self.k_a,
-                k_b: self.k_b,
-                k_c: self.k_c,
-            };
-            serde_json_core::to_vec(&summary)
-        } else {
-            let summary: Option<()> = None;
-            serde_json_core::to_vec(&summary)
-        }
-    }
-
-    pub fn set_auto_mode(&mut self, fan_auto: bool) {
-        self.fan_auto = fan_auto;
-    }
-
-    pub fn set_curve(&mut self, k_a: f32, k_b: f32, k_c: f32) {
-        self.k_a = k_a;
-        self.k_b = k_b;
-        self.k_c = k_c;
-    }
-
-    pub fn restore_defaults(&mut self) {
-        self.set_curve(self.hw_settings.fan_k_a,
-                       self.hw_settings.fan_k_b,
-                       self.hw_settings.fan_k_c);
-    }
-
-    pub fn set_pwm(&mut self, fan_pwm: u32) -> f32 {
-        if self.fan.is_none() || (!self.pwm_enabled && !self.enable_pwm())  {
-            return 0f32;
-        }
-        let fan = self.fan.as_mut().unwrap();
-        let fan_pwm = fan_pwm.min(MAX_USER_FAN_PWM as u32).max(MIN_USER_FAN_PWM as u32);
-        let duty = scale_number(fan_pwm as f32, self.hw_settings.min_fan_pwm, self.hw_settings.max_fan_pwm, MIN_USER_FAN_PWM, MAX_USER_FAN_PWM);
-        let max = fan.get_max_duty();
-        let value = ((duty * (max as f32)) as u16).min(max);
-        fan.set_duty(value);
-        value as f32 / (max as f32)
-    }
-
-    pub fn fan_pwm_recommended(&self) -> bool {
-        self.hw_settings.fan_pwm_recommended
-    }
-
-    pub fn fan_available(&self) -> bool {
-        self.hw_settings.fan_available
-    }
-
-    fn get_pwm(&self) -> u32 {
-        if let Some(fan) = &self.fan {
-            let duty = fan.get_duty();
-            let max = fan.get_max_duty();
-            scale_number(duty as f32 / (max as f32), MIN_USER_FAN_PWM, MAX_USER_FAN_PWM, self.hw_settings.min_fan_pwm, self.hw_settings.max_fan_pwm).round() as u32
-        } else { 0 }
-    }
-
-    fn enable_pwm(&mut self) -> bool {
-        if self.fan.is_some() && self.hw_settings.fan_available {
-            let fan = self.fan.as_mut().unwrap();
-            fan.set_duty(0);
-            fan.enable();
-            self.pwm_enabled = true;
-            true
-        } else {
-            false
-        }
-    }
-}
-
-
-fn scale_number(unscaled: f32, to_min: f32, to_max: f32, from_min: f32, from_max: f32) -> f32 {
-    (to_max - to_min) * (unscaled - from_min) / (from_max - from_min) + to_min
-}
-
-#[derive(Serialize)]
-pub struct FanSummary {
-    fan_pwm: u32,
-    abs_max_tec_i: f32,
-    auto_mode: bool,
-    k_a: f32,
-    k_b: f32,
-    k_c: f32,
-}

src/hw_rev.rs

@@ -1,82 +0,0 @@
-use serde::Serialize;
-
-use crate::{
-    pins::HWRevPins,
-    command_handler::JsonBuffer,
-};
-
-#[derive(Serialize, Copy, Clone)]
-pub struct HWRev {
-    pub major: u8,
-    pub minor: u8,
-}
-
-#[derive(Serialize, Clone)]
-pub struct HWSettings {
-    pub fan_k_a: f32,
-    pub fan_k_b: f32,
-    pub fan_k_c: f32,
-    pub min_fan_pwm: f32,
-    pub max_fan_pwm: f32,
-    pub fan_pwm_freq_hz: u32,
-    pub fan_available: bool,
-    pub fan_pwm_recommended: bool,
-}
-
-#[derive(Serialize, Clone)]
-struct HWSummary<'a> {
-    rev: &'a HWRev,
-    settings: &'a HWSettings,
-}
-
-impl HWRev {
-    pub fn detect_hw_rev(hwrev_pins: &HWRevPins) -> Self {
-        let (h0, h1, h2, h3) = (hwrev_pins.hwrev0.is_high(), hwrev_pins.hwrev1.is_high(),
-                                hwrev_pins.hwrev2.is_high(), hwrev_pins.hwrev3.is_high());
-        match (h0, h1, h2, h3) {
-            (true, true, true, false) => HWRev { major: 1, minor: 0 },
-            (true, false, false, false) => HWRev { major: 2, minor: 0 },
-            (false, true, false, false) => HWRev { major: 2, minor: 2 },
-            (_, _, _, _) => HWRev { major: 0, minor: 0 }
-        }
-    }
-
-    pub fn settings(&self) -> HWSettings {
-        match (self.major, self.minor) {
-            (2, 2) => HWSettings {
-                fan_k_a: 1.0,
-                fan_k_b: 0.0,
-                fan_k_c: 0.0,
-                // below this value motor's autostart feature may fail,
-                // according to internal experiments
-                min_fan_pwm: 0.04,
-                max_fan_pwm: 1.0,
-                // According to `SUNON DC Brushless Fan & Blower(255-E)` catalogue p.36-37
-                // model MF35101V1-1000U-G99 doesn't have a PWM wire, but we'll follow their others models'
-                // recommended frequency, as it is said by the Thermostat's schematics that we can
-                // use PWM, but not stated at which frequency
-                fan_pwm_freq_hz: 25_000,
-                fan_available: true,
-                // see https://github.com/sinara-hw/Thermostat/issues/115 and
-                // https://git.m-labs.hk/M-Labs/thermostat/issues/69#issuecomment-6464 for explanation
-                fan_pwm_recommended: false,
-            },
-            (_, _) => HWSettings {
-                fan_k_a: 0.0,
-                fan_k_b: 0.0,
-                fan_k_c: 0.0,
-                min_fan_pwm: 0.0,
-                max_fan_pwm: 0.0,
-                fan_pwm_freq_hz: 0,
-                fan_available: false,
-                fan_pwm_recommended: false,
-            }
-        }
-    }
-
-    pub fn summary(&self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
-        let settings = self.settings();
-        let summary = HWSummary { rev: self, settings: &settings };
-        serde_json_core::to_vec(&summary)
-    }
-}

src/main.rs

@@ -1,14 +1,16 @@
 #![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 _;
 
 use log::{error, info, warn};
+
 use cortex_m::asm::wfi;
 use cortex_m_rt::entry;
 use stm32f4xx_hal::{
@@ -52,9 +54,6 @@ mod flash_store;
 mod dfu;
 mod command_handler;
 use command_handler::Handler;
-mod fan_ctrl;
-use fan_ctrl::FanCtrl;
-mod hw_rev;
 
 const HSE: MegaHertz = MegaHertz(8);
 #[cfg(not(feature = "semihosting"))]
@@ -119,8 +118,8 @@ fn main() -> ! {
 
     timer::setup(cp.SYST, clocks);
 
-    let (pins, mut leds, mut eeprom, eth_pins, usb, fan, hwrev, hw_settings) = Pins::setup(
-        clocks, dp.TIM1, dp.TIM3, dp.TIM8,
+    let (pins, mut leds, mut eeprom, eth_pins, usb) = Pins::setup(
+        clocks, dp.TIM1, dp.TIM3,
         dp.GPIOA, dp.GPIOB, dp.GPIOC, dp.GPIOD, dp.GPIOE, dp.GPIOF, dp.GPIOG,
         dp.I2C1,
         dp.SPI2, dp.SPI4, dp.SPI5,
@@ -137,8 +136,9 @@ fn main() -> ! {
     usb::State::setup(usb);
 
     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)) =>
@@ -150,8 +150,6 @@ fn main() -> ! {
         }
     }
 
-    let mut fan_ctrl = FanCtrl::new(fan, hw_settings);
-
     // default net config:
     let mut ipv4_config = Ipv4Config {
         address: [192, 168, 1, 26],
@@ -185,14 +183,6 @@ 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();
-                }
-
                 let instant = Instant::from_millis(i64::from(timer::now()));
                 cortex_m::interrupt::free(net::clear_pending);
                 server.poll(instant)
@@ -216,7 +206,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) {
                                         Ok(Handler::NewIPV4(ip)) => new_ipv4_config = Some(ip),                                
                                         Ok(Handler::Handled) => {},
                                         Ok(Handler::CloseSocket) => socket.close(),

src/pins.rs

@@ -23,7 +23,7 @@ use stm32f4xx_hal::{
         I2C1,
         OTG_FS_GLOBAL, OTG_FS_DEVICE, OTG_FS_PWRCLK,
         SPI2, SPI4, SPI5,
-        TIM1, TIM3, TIM8
+        TIM1, TIM3,
     },
     timer::Timer,
     time::U32Ext,
@@ -33,8 +33,6 @@ use stm32_eth::EthPins;
 use crate::{
     channel::{Channel0, Channel1},
     leds::Leds,
-    fan_ctrl::FanPin,
-    hw_rev::{HWRev, HWSettings},
 };
 
 pub type Eeprom = Eeprom24x<
@@ -66,31 +64,21 @@ pub trait ChannelPins {
     type TecUMeasPin;
 }
 
-pub enum Channel0VRef {
-    Analog(PA0<Analog>),
-    Disabled(PA0<Input<Floating>>),
-}
-
 impl ChannelPins for Channel0 {
     type DacSpi = Dac0Spi;
     type DacSync = PE4<Output<PushPull>>;
     type Shdn = PE10<Output<PushPull>>;
-    type VRefPin = Channel0VRef;
+    type VRefPin = PA0<Analog>;
     type ItecPin = PA6<Analog>;
     type DacFeedbackPin = PA4<Analog>;
     type TecUMeasPin = PC2<Analog>;
 }
 
-pub enum Channel1VRef {
-    Analog(PA3<Analog>),
-    Disabled(PA3<Input<Floating>>),
-}
-
 impl ChannelPins for Channel1 {
     type DacSpi = Dac1Spi;
     type DacSync = PF6<Output<PushPull>>;
     type Shdn = PE15<Output<PushPull>>;
-    type VRefPin = Channel1VRef;
+    type VRefPin = PA3<Analog>;
     type ItecPin = PB0<Analog>;
     type DacFeedbackPin = PA5<Analog>;
     type TecUMeasPin = PC3<Analog>;
@@ -113,13 +101,6 @@ pub struct ChannelPinSet<C: ChannelPins> {
     pub tec_u_meas_pin: C::TecUMeasPin,
 }
 
-pub struct HWRevPins {
-    pub hwrev0: stm32f4xx_hal::gpio::gpiod::PD0<Input<Floating>>,
-    pub hwrev1: stm32f4xx_hal::gpio::gpiod::PD1<Input<Floating>>,
-    pub hwrev2: stm32f4xx_hal::gpio::gpiod::PD2<Input<Floating>>,
-    pub hwrev3: stm32f4xx_hal::gpio::gpiod::PD3<Input<Floating>>,
-}
-
 pub struct Pins {
     pub adc_spi: AdcSpi,
     pub adc_nss: AdcNss,
@@ -133,13 +114,13 @@ impl Pins {
     /// Setup GPIO pins and configure MCU peripherals
     pub fn setup(
         clocks: Clocks,
-        tim1: TIM1, tim3: TIM3, tim8: TIM8,
+        tim1: TIM1, tim3: TIM3,
         gpioa: GPIOA, gpiob: GPIOB, gpioc: GPIOC, gpiod: GPIOD, gpioe: GPIOE, gpiof: GPIOF, gpiog: GPIOG,
         i2c1: I2C1,
         spi2: SPI2, spi4: SPI4, spi5: SPI5,
         adc1: ADC1,
         otg_fs_global: OTG_FS_GLOBAL, otg_fs_device: OTG_FS_DEVICE, otg_fs_pwrclk: OTG_FS_PWRCLK,
-    ) -> (Self, Leds, Eeprom, EthernetPins, USB, Option<FanPin>, HWRev, HWSettings) {
+    ) -> (Self, Leds, Eeprom, EthernetPins, USB) {
         let gpioa = gpioa.split();
         let gpiob = gpiob.split();
         let gpioc = gpioc.split();
@@ -160,17 +141,13 @@ impl Pins {
             gpioe.pe13, gpioe.pe14
         );
 
-        let hwrev = HWRev::detect_hw_rev(&HWRevPins {hwrev0: gpiod.pd0, hwrev1: gpiod.pd1,
-            hwrev2: gpiod.pd2, hwrev3: gpiod.pd3});
-        let hw_settings = hwrev.settings();
-
         let (dac0_spi, dac0_sync) = Self::setup_dac0(
             clocks, spi4,
             gpioe.pe2, gpioe.pe4, gpioe.pe6
         );
         let mut shdn0 = gpioe.pe10.into_push_pull_output();
         let _ = shdn0.set_low();
-        let vref0_pin = if hwrev.major > 2 {Channel0VRef::Analog(gpioa.pa0.into_analog())} else {Channel0VRef::Disabled(gpioa.pa0)};
+        let vref0_pin = gpioa.pa0.into_analog();
         let itec0_pin = gpioa.pa6.into_analog();
         let dac_feedback0_pin = gpioa.pa4.into_analog();
         let tec_u_meas0_pin = gpioc.pc2.into_analog();
@@ -190,7 +167,7 @@ impl Pins {
         );
         let mut shdn1 = gpioe.pe15.into_push_pull_output();
         let _ = shdn1.set_low();
-        let vref1_pin = if hwrev.major > 2 {Channel1VRef::Analog(gpioa.pa3.into_analog())} else {Channel1VRef::Disabled(gpioa.pa3)};
+        let vref1_pin = gpioa.pa3.into_analog();
         let itec1_pin = gpiob.pb0.into_analog();
         let dac_feedback1_pin = gpioa.pa5.into_analog();
         let tec_u_meas1_pin = gpioc.pc3.into_analog();
@@ -238,11 +215,7 @@ impl Pins {
             hclk: clocks.hclk(),
         };
 
-        let fan = if hw_settings.fan_available {
-             Some(Timer::new(tim8, &clocks).pwm(gpioc.pc9.into_alternate(), hw_settings.fan_pwm_freq_hz.hz()))
-        } else { None };
-
-        (pins, leds, eeprom, eth_pins, usb, fan, hwrev, hw_settings)
+        (pins, leds, eeprom, eth_pins, usb)
     }
 
     /// Configure the GPIO pins for SPI operation, and initialize SPI

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,