PyThermostat: Improve pyproject metadata

PyThermostat: Replace setup.py with pyproject.toml
PyThermostat: Add entry points for runnables
2024-11-25 13:38:04 +08:00 · 2024-11-25 13:14:54 +08:00 · 2024-11-25 10:07:30 +08:00 · 2024-11-25 10:07:30 +08:00 · 2024-11-25 10:07:20 +08:00 · 2024-11-20 08:02:07 +08:00
49 changed files with 3862 additions and 2120 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,2 +1,5 @@
 target/
 result
 *.bin
 __pycache__/
--- a/Cargo.lock
+++ b/Cargo.lock
@ -1,5 +1,7 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
 version = 3
 [[package]]
 name = "aligned"
 version = "0.3.4"
@ -68,12 +70,9 @@ checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
 [[package]]
 name = "cast"
-version = "0.2.3"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b9434b9a5aa1450faa3f9cb14ea0e8c53bb5d2b3c1bfd1ab4fc03e9f33fbfb0"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 dependencies = [
 "rustc_version",
 ]
 [[package]]
 name = "cfg-if"
@ -82,14 +81,37 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
 [[package]]
-name = "cortex-m"
+name = "chrono"
-version = "0.6.4"
+version = "0.4.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88cdafeafba636c00c467ded7f1587210725a1adfab0c24028a7844b87738263"
+checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
 dependencies = [
 "num-integer",
 "num-traits",
 ]
 [[package]]
 name = "cortex-m"
 version = "0.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9075300b07c6a56263b9b582c214d0ff037b00d45ec9fde1cc711490c56f1bb9"
 dependencies = [
 "aligned",
 "bare-metal 0.2.5",
 "bitfield",
 "cortex-m 0.7.4",
 "volatile-register",
 ]
 [[package]]
 name = "cortex-m"
 version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37ff967e867ca14eba0c34ac25cd71ea98c678e741e3915d923999bb2fe7c826"
 dependencies = [
 "bare-metal 0.2.5",
 "bitfield",
 "embedded-hal",
 "volatile-register",
 ]
@ -99,7 +121,7 @@ version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d63959cb1e003dd97233fee6762351540253237eadf06fcdcb98cbfa3f9be4a"
 dependencies = [
- "cortex-m",
+ "cortex-m 0.6.7",
 "cortex-m-semihosting",
 "log",
 ]
@ -110,10 +132,19 @@ version = "0.6.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "980c9d0233a909f355ed297ef122f257942de5e0a2cb1c39f60684b65bcb90fb"
 dependencies = [
- "cortex-m-rt-macros",
+ "cortex-m-rt-macros 0.1.8",
 "r0",
 ]
 [[package]]
 name = "cortex-m-rt"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c433da385b720d5bb9f52362fa2782420798e68d40d67bfe4b0d992aba5dfe7"
 dependencies = [
 "cortex-m-rt-macros 0.7.0",
 ]
 [[package]]
 name = "cortex-m-rt-macros"
 version = "0.1.8"
@ -126,12 +157,23 @@ dependencies = [
 ]
 [[package]]
-name = "cortex-m-semihosting"
+name = "cortex-m-rt-macros"
-version = "0.3.5"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "113ef0ecffee2b62b58f9380f4469099b30e9f9cbee2804771b4203ba1762cfa"
+checksum = "f0f6f3e36f203cfedbc78b357fb28730aa2c6dc1ab060ee5c2405e843988d3c7"
 dependencies = [
- "cortex-m",
+ "proc-macro2",
 "quote",
 "syn",
 ]
 [[package]]
 name = "cortex-m-semihosting"
 version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6bffa6c1454368a6aa4811ae60964c38e6996d397ff8095a8b9211b1c1f749bc"
 dependencies = [
 "cortex-m 0.7.4",
 ]
 [[package]]
@ -154,9 +196,9 @@ dependencies = [
 [[package]]
 name = "embedded-hal"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa998ce59ec9765d15216393af37a58961ddcefb14c753b4816ba2191d865fcb"
+checksum = "e36cfb62ff156596c892272f3015ef952fe1525e85261fa3a7f327bd6b384ab9"
 dependencies = [
 "nb 0.1.3",
 "void",
@ -264,6 +306,16 @@ dependencies = [
 "version_check",
 ]
 [[package]]
 name = "num-integer"
 version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
 dependencies = [
 "autocfg",
 "num-traits",
 ]
 [[package]]
 name = "num-traits"
 version = "0.2.14"
@ -275,18 +327,18 @@ dependencies = [
 ]
 [[package]]
-name = "panic-abort"
+name = "panic-halt"
-version = "0.3.2"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e20e6499bbbc412f280b04a42346b356c6fa0753d5fd22b7bd752ff34c778ee"
+checksum = "de96540e0ebde571dc55c73d60ef407c653844e6f9a1e2fdbd40c07b9252d812"
 [[package]]
 name = "panic-semihosting"
-version = "0.5.4"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aed16eb761d0ee9161dd1319cb38c8007813b20f9720a5a682b283e7b8cdfe58"
+checksum = "c3d55dedd501dfd02514646e0af4d7016ce36bc12ae177ef52056989966a1eec"
 dependencies = [
- "cortex-m",
+ "cortex-m 0.7.4",
 "cortex-m-semihosting",
 ]
@ -333,9 +385,18 @@ checksum = "e2a38df5b15c8d5c7e8654189744d8e396bddc18ad48041a500ce52d6948941f"
 [[package]]
 name = "rand_core"
-version = "0.5.1"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
 [[package]]
 name = "rtcc"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef35f9dcbf434a34dcc99b3ebba1c1945d49c70832958e932e83dc63a5273994"
 dependencies = [
 "chrono",
 ]
 [[package]]
 name = "rustc_version"
@ -363,9 +424,9 @@ checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 [[package]]
 name = "serde"
-version = "1.0.117"
+version = "1.0.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b88fa983de7720629c9387e9f517353ed404164b1e482c970a90c1a4aaf7dc1a"
+checksum = "06c64263859d87aa2eb554587e2d23183398d617427327cf2b3d0ed8c69e4800"
 dependencies = [
 "serde_derive",
 ]
@ -382,9 +443,9 @@ dependencies = [
 [[package]]
 name = "serde_derive"
-version = "1.0.117"
+version = "1.0.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbd1ae72adb44aab48f325a02444a5fc079349a8d804c1fc922aed3f7454c74e"
+checksum = "c84d3526699cd55261af4b941e4e725444df67aa4f9e6a3564f18030d12672df"
 dependencies = [
 "proc-macro2",
 "quote",
@ -392,10 +453,21 @@ dependencies = [
 ]
 [[package]]
-name = "smoltcp"
+name = "sfkv"
-version = "0.6.0"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fe46639fd2ec79eadf8fe719f237a7a0bd4dac5d957f1ca5bbdbc1c3c39e53a"
+checksum = "25f5bfac3f66a7c10a6f37ee81aeaa471f4d35dc21665b59ad7c555adcb9e8aa"
 dependencies = [
 "byteorder",
 "postcard",
 "serde",
 ]
 [[package]]
 name = "smoltcp"
 version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3e4a069bef843d170df47e7c0a8bf8d037f217d9f5b325865acc3e466ffe40d3"
 dependencies = [
 "bitflags",
 "byteorder",
@ -412,10 +484,10 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 [[package]]
 name = "stm32-eth"
 version = "0.2.0"
-source = "git+https://github.com/stm32-rs/stm32-eth.git#4d6b29bf1ecdd1f68e5bc304a3d4f170049896c8"
+source = "git+https://github.com/stm32-rs/stm32-eth.git?rev=3759c5c9#3759c5c99c0ab69bb71759030766bc0fba0b6cde"
 dependencies = [
 "aligned",
- "cortex-m",
+ "cortex-m 0.7.4",
 "smoltcp",
 "stm32f4xx-hal",
 "volatile-register",
@ -423,29 +495,31 @@ dependencies = [
 [[package]]
 name = "stm32f4"
-version = "0.11.0"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11460b4de3a84f072e2cf6e76306c64d27f405a0e83bace0a726f555ddf4bf33"
+checksum = "da3d56009c8f32e4f208dbea17df72484154d1040a8969b75d8c73eb7b18fe8f"
 dependencies = [
 "bare-metal 0.2.5",
- "cortex-m",
+ "cortex-m 0.7.4",
- "cortex-m-rt",
+ "cortex-m-rt 0.6.13",
 "vcell",
 ]
 [[package]]
 name = "stm32f4xx-hal"
-version = "0.8.3"
+version = "0.10.1"
-source = "git+https://github.com/stm32-rs/stm32f4xx-hal.git#e80925770d2fe72f0f01a7b46147f4e31d512689"
+source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3a06fde2dd27c0ba934c9e69b62af66eb1c20dbb6d741b187a763912e9892d13"
 dependencies = [
- "bare-metal 0.2.5",
+ "bare-metal 1.0.0",
 "cast",
- "cortex-m",
+ "cortex-m 0.7.4",
- "cortex-m-rt",
+ "cortex-m-rt 0.7.1",
 "embedded-dma",
 "embedded-hal",
- "nb 0.1.3",
+ "nb 1.0.0",
 "rand_core",
 "rtcc",
 "stm32f4",
 "synopsys-usb-otg",
 "void",
@ -453,9 +527,9 @@ dependencies = [
 [[package]]
 name = "syn"
-version = "1.0.48"
+version = "1.0.54"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc371affeffc477f42a221a1e4297aedcea33d47d19b61455588bd9d8f6b19ac"
+checksum = "9a2af957a63d6bd42255c359c93d9bfdb97076bd3b820897ce55ffbfbf107f44"
 dependencies = [
 "proc-macro2",
 "quote",
@ -468,7 +542,7 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "461676dcf123675b3d3b02e2390e6a690cd186aacf2f439af7673c79e2561d53"
 dependencies = [
- "cortex-m",
+ "cortex-m 0.6.7",
 "usb-device",
 "vcell",
 ]
@ -480,20 +554,20 @@ dependencies = [
 "bare-metal 1.0.0",
 "bit_field",
 "byteorder",
- "cortex-m",
+ "cortex-m 0.6.7",
 "cortex-m-log",
- "cortex-m-rt",
+ "cortex-m-rt 0.6.13",
 "eeprom24x",
 "heapless",
 "log",
 "nb 1.0.0",
 "nom",
 "num-traits",
- "panic-abort",
+ "panic-halt",
 "panic-semihosting",
 "postcard",
 "serde",
 "serde-json-core",
 "sfkv",
 "smoltcp",
 "stm32-eth",
 "stm32f4xx-hal",
--- a/Cargo.toml
+++ b/Cargo.toml
@ -7,23 +7,23 @@ authors = ["Astro <astro@spaceboyz.net>"]
 version = "0.0.0"
 keywords = ["thermostat", "laser", "physics"]
 repository = "https://git.m-labs.hk/M-Labs/thermostat"
-edition = "2018"
+edition = "2021"
 [package.metadata.docs.rs]
 features = []
 default-target = "thumbv7em-none-eabihf"
 [dependencies]
-panic-abort = "0.3"
+panic-halt = "0.2"
 panic-semihosting = { version = "0.5", optional = true }
 log = "0.4"
 bare-metal = "1"
 cortex-m = "0.6"
 cortex-m-rt = { version = "0.6", features = ["device"] }
 cortex-m-log = { version = "0.6", features = ["log-integration"] }
-stm32f4xx-hal = { version = "0.8", features = ["rt", "stm32f427", "usb_fs"] }
+stm32f4xx-hal = { version = "=0.10.1", features = ["rt", "stm32f427", "usb_fs"] }
-stm32-eth = { version = "0.2", features = ["stm32f427", "smoltcp-phy"], git = "https://github.com/stm32-rs/stm32-eth.git" }
+stm32-eth = { rev = "3759c5c9", features = ["stm32f427", "smoltcp-phy"], git = "https://github.com/stm32-rs/stm32-eth.git" }
-smoltcp = { version = "0.6.0", default-features = false, features = ["proto-ipv4", "socket-tcp", "log"] }
+smoltcp = { version = "0.7.5", default-features = false, features = ["proto-ipv4", "socket-tcp", "log"] }
 bit_field = "0.10"
 byteorder = { version = "1", default-features = false }
 nom = { version = "5", default-features = false }
@ -34,13 +34,9 @@ nb = "1"
 uom = { version = "0.30", default-features = false, features = ["autoconvert", "si", "f64", "use_serde"] }
 eeprom24x = "0.3"
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 postcard = "0.5"
 heapless = "0.5"
 serde-json-core = "0.1"
-
+sfkv = "0.1"
 [patch.crates-io]
 stm32f4xx-hal = { git = "https://github.com/stm32-rs/stm32f4xx-hal.git" }
 [features]
 semihosting = ["panic-semihosting", "cortex-m-log/semihosting"]
--- a/README.md
+++ b/README.md
@ -1,32 +1,35 @@
 # Firmware for the Sinara 8451 Thermostat
- [x] [Continuous Integration](https://nixbld.m-labs.hk/job/stm32/stm32/thermostat)
+- [x] [Continuous Integration](https://nixbld.m-labs.hk/job/mcu/thermostat/thermostat)
- [x] [Download latest firmware build](https://nixbld.m-labs.hk/job/stm32/stm32/thermostat/latest/download-by-type/file/binary-dist)
+- [x] Download latest firmware build: [ELF](https://nixbld.m-labs.hk/job/mcu/thermostat/thermostat/latest/download/1) [BIN](https://nixbld.m-labs.hk/job/mcu/thermostat/thermostat/latest/download/2)
 NOTE: Firmware is not yet ready for production use. 
 ## Building
-### Debian-based systems (tested on Ubuntu 19.10)
+### Reproducible build with Nix
- install git, clone this repository
+Thermostat firmware is packaged using the [Nix](https://nixos.org) Flakes system. Install Nix 2.4+ and enable flakes by adding ``experimental-features = nix-command flakes`` to ``nix.conf`` (e.g. ``~/.config/nix/nix.conf``). 
- install [rustup](https://rustup.rs/)
+
 Once you have Flakes enabled, you can use ``nix build`` to build the firmware.
 ### Development environment
 Clone this repository and with Nix Flakes enabled, use the following commands:
 ```shell
-rustup toolchain install nightly
+nix develop
 rustup update
 rustup target add thumbv7em-none-eabihf --toolchain nightly
 rustup default nightly
 cargo build --release
 ```
-The resulting ELF file will be located under `target/thumbv7em-none-eabihf/release/thermostat`
+The resulting ELF file will be located under `target/thumbv7em-none-eabihf/release/thermostat`.
 Alternatively, you can install the Rust toolchain without Nix using rustup; see the `rust` variable in `flake.nix` to determine which Rust version to use.
 ## Debugging
 Connect SWDIO/SWCLK/RST/GND to a programmer such as ST-Link v2.1. Run OpenOCD:
 ```shell
-openocd -f interface/stlink-v2-1.cfg -f target/stm32f4x.cfg
+openocd -f interface/stlink.cfg -f target/stm32f4x.cfg
 ```
 You may need to power up the programmer before powering the device.
@ -38,21 +41,19 @@ gdb target/thumbv7em-none-eabihf/release/thermostat
 ```
 ## Flashing
-There are several options for performing device firmware upgrade (DFU) on Thermostat. The firmware is an .ELF file. 
+There are several options for flashing Thermostat. DFU requires only a micro-USB connector, whereas OpenOCD needs a JTAG/SWD adapter.
-### dfu-util
+### dfu-util on Linux
 This can be done from Linux machine using only micro-USB connector. 
 ([Issue #10](https://git.m-labs.hk/M-Labs/thermostat/issues/10))
 * Install the DFU USB tool (dfu-util).
-* Convert firmware from ELF to BIN: ```arm-none-eabi-objcopy -O binary thermostat.elf thermostat.bin```
+* Convert firmware from ELF to BIN: `llvm-objcopy -O binary target/thumbv7em-none-eabihf/release/thermostat thermostat.bin` (you can skip this step if using the BIN from Hydra)
 * Connect to the Micro USB connector to Thermostat below the RJ45.
 * Add jumper to Thermostat v2.0 across 2-pin jumper adjacent to JTAG connector.
 * Cycle board power to put it in DFU update mode
-* Push firmware to flash: ```dfu-util -a 0 -s 0x08000000:leave -D thermostat.bin```
+* Push firmware to flash: `dfu-util -a 0 -s 0x08000000:leave -D thermostat.bin`
 * Remove jumper
 * Cycle power to leave DFU update mode
-### st.com DfuSe tool
+### st.com DfuSe tool on Windows
 On a Windows machine install [st.com](https://st.com) DfuSe USB device firmware upgrade (DFU) software. [link](https://www.st.com/en/development-tools/stsw-stm32080.html).
 - add jumper to Thermostat v2.0 across 2-pin jumper adjacent to JTAG connector
 - cycle board power to put it in DFU update mode
@ -61,9 +62,9 @@ On a Windows machine install [st.com](https://st.com) DfuSe USB device firmware
 - remove jumper
 - cycle power to leave DFU update mode
-### openocd
+### OpenOCD
 ```shell
-openocd -f interface/stlink-v2-1.cfg -f target/stm32f4x.cfg -c "program target/thumbv7em-none-eabihf/release/thermostat verify reset;exit"
+openocd -f interface/stlink.cfg -f target/stm32f4x.cfg -c "program target/thumbv7em-none-eabihf/release/thermostat verify reset;exit"
 ```
 ## Network
@ -74,7 +75,7 @@ Ethernet, IP: 192.168.1.26/24
 Use netcat to connect to port 23/tcp (telnet)
 ```sh
-nc -vv 192.168.1.26 23
+rlwrap nc -vv 192.168.1.26 23
 ```
 telnet clients send binary data after connect. Enter \n once to
@ -83,44 +84,49 @@ invalidate the first line of input.
 ### Reading ADC input
-Set report mode to `on` for a continuous stream of input data.
+ADC input data is provided in reports. Query for the latest report with the command `report`. See the *Reports* section below.
 The scope of this setting is per TCP session.
-### Commands
+### TCP commands
-| Syntax                           | Function                                            |
+Send commands as simple text string terminated by `\n`. Responses are
-| ---                              | ---                                                 |
+formatted as line-delimited JSON.
-| `report`                         | Show current input                                  |
+
-| `report mode`                    | Show current report mode                            |
+| Syntax                                    | Function                                                                      |
-| `report mode <off/on>`           | Set report mode                                     |
+|-------------------------------------------|-------------------------------------------------------------------------------|
-| `pwm`                            | Show current PWM settings                           |
+| `report`                                  | Show latest report of channel parameters (see *Reports* section)              |
-| `pwm <0/1> max_i_pos <ratio>`    | Set PWM duty cycle for **max_i_pos** to *ampere*    |
+| `output`                                  | Show current output settings                                                  |
-| `pwm <0/1> max_i_neg <ratio>`    | Set PWM duty cycle for **max_i_neg** to *ampere*    |
+| `output <0/1> max_i_pos <amp>`            | Set maximum positive output current, clamped to [0, 2]                        |
-| `pwm <0/1> max_v <ratio>`        | Set PWM duty cycle for **max_v** to *volt*          |
+| `output <0/1> max_i_neg <amp>`            | Set maximum negative output current, clamped to [0, 2]                        |
-| `pwm <0/1> <volts>`              | Disengage PID, set **i_set** DAC to *ampere*        |
+| `output <0/1> max_v <volt>`               | Set maximum output voltage, clamped to [0, 4]                                 |
-| `pwm <0/1> pid`                  | Set PWM to be controlled by PID                     |
+| `output <0/1> i_set <amp>`                | Disengage PID, set fixed output current, clamped to [-2, 2]                   |
-| `center <0/1> <volts>`           | Set the MAX1968 0A-centerpoint to *volts*           |
+| `output <0/1> polarity <normal/reversed>` | Set output current polarity, with 'normal' being the front panel polarity     |
-| `center <0/1> vref`              | Set the MAX1968 0A-centerpoint to measure from VREF |
+| `output <0/1> pid`                        | Let output current to be controlled by the PID                                |
-| `pid`                            | Show PID configuration                              |
+| `center <0/1> <volt>`                     | Set the MAX1968 0A-centerpoint to the specified fixed voltage                 |
-| `pid <0/1> target <value>`       | Set the PID controller target                       |
+| `center <0/1> vref`                       | Set the MAX1968 0A-centerpoint to measure from VREF                           |
-| `pid <0/1> kp <value>`           | Set proportional gain                               |
+| `pid`                                     | Show PID configuration                                                        |
-| `pid <0/1> ki <value>`           | Set integral gain (unit: 10 Hz)                     |
+| `pid <0/1> target <deg_celsius>`          | Set the PID controller target temperature                                     |
-| `pid <0/1> kd <value>`           | Set differential gain (unit: 0.1 seconds)           |
+| `pid <0/1> kp <value>`                    | Set proportional gain                                                         |
-| `pid <0/1> output_min <value>`   | Set mininum output                                  |
+| `pid <0/1> ki <value>`                    | Set integral gain                                                             |
-| `pid <0/1> output_max <value>`   | Set maximum output                                  |
+| `pid <0/1> kd <value>`                    | Set differential gain                                                         |
-| `pid <0/1> integral_min <value>` | Set integral lower bound                            |
+| `pid <0/1> output_min <amp>`              | Set mininum output                                                            |
-| `pid <0/1> integral_max <value>` | Set integral upper bound                            |
+| `pid <0/1> output_max <amp>`              | Set maximum output                                                            |
-| `s-h`                            | Show Steinhart-Hart equation parameters             |
+| `b-p`                                     | Show B-Parameter equation parameters                                          |
-| `s-h <0/1> <t0/b/r0> <value>`    | Set Steinhart-Hart parameter for a channel          |
+| `b-p <0/1> <t0/b/r0> <value>`             | Set B-Parameter for a channel                                                 |
-| `postfilter`                     | Show postfilter settings                            |
+| `postfilter`                              | Show postfilter settings                                                      |
-| `postfilter <0/1> off`           | Disable postfilter                                  |
+| `postfilter <0/1> off`                    | Disable postfilter                                                            |
-| `postfilter <0/1> rate <rate>`   | Set postfilter output data rate                     |
+| `postfilter <0/1> rate <rate>`            | Set postfilter output data rate                                               |
-| `load`                           | Restore configuration from EEPROM                   |
+| `load [0/1]`                              | Restore configuration for channel all/0/1 from flash                          |
-| `save`                           | Save configuration to EEPROM                        |
+| `save [0/1]`                              | Save configuration for channel all/0/1 to flash                               |
-| `reset`                          | Reset the device                                    |
+| `reset`                                   | Reset the device                                                              |
-| `ipv4 <X.X.X.X>`                 | Configure IPv4 address                              |
+| `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                            |
 ## USB
@ -138,59 +144,86 @@ output will be truncated when USB buffers are full.
 Connect the thermistor with the SENS pins of the
 device. Temperature-depending resistance is measured by the AD7172
-ADC. To prepare conversion to a temperature, set the Beta parameters
+ADC. To prepare conversion to a temperature, set the parameters
-for the Steinhart-Hart equation.
+for the B-Parameter equation.
 Set the base temperature in degrees celsius for the channel 0 thermistor:
 ```
-s-h 0 t0 20
+b-p 0 t0 20
 ```
 Set the resistance in Ohms measured at the base temperature t0:
 ```
-s-h 0 r0 10000
+b-p 0 r0 10000
 ```
 Set the Beta parameter:
 ```
-s-h 0 b 3800
+b-p 0 b 3800
 ```
 ### 50/60 Hz filtering
 The AD7172-2 ADC on the SENS inputs supports simultaneous rejection of
 50 Hz ± 1 Hz and 60 Hz ± 1 Hz (dB). Affecting sampling rate, the
 postfilter rate can be tuned with the `postfilter` command.
 | Postfilter rate | Rejection | Effective sampling rate |
 | ---             | :---:     | ---                     |
 | 16.67 Hz        | 92 dB     | 8.4 Hz                  |
 | 20 Hz           | 86 dB     | 9.1 Hz                  |
 | 21.25 Hz        | 62 dB     | 10 Hz                   |
 | 27 Hz           | 47 dB     | 10.41 Hz                |
 ## Thermo-Electric Cooling (TEC)
- Connect Peltier device 0 to TEC0- and TEC0+.
+- Connect TEC module device 0 to TEC0- and TEC0+.
- Connect Peliter device 1 to TEC1- and TEC1+.
+- Connect TEC module device 1 to TEC1- and TEC1+.
- The GND pin is for shielding not for sinking Peltier currents.
+- The GND pin is for shielding not for sinking TEC module currents.
 When using a TEC module with the Thermostat, the Thermostat expects the thermal load (where the thermistor is located) to cool down with a positive software current set point, and heat up with a negative current set point.
 If the Thermostat is used for temperature control with the Sinara 5432 DAC "Zotino", and is connected via an IDC cable, the TEC polarity may need to be reversed with the `output <ch> polarity reversed` TCP command.
 Testing heat flow direction with a low set current is recommended before installation of the TEC module.
 ### Limits
-Each of the MAX1968 TEC driver has analog/PWM inputs for setting
+Each channel has maximum value settings, for setting
 output limits.
-Use the `pwm` command to see current settings and maximum values.
+Use the `output` command to see them.
-| Limit       | Unit    | Description                             |
+| Limit       | Unit    | Description                   |
-| ---         | :---:   | ---                                     |
+| ---         | :---:   | ---                           |
-| `max_v`     | Volts   | Maximum voltage                         |
+| `max_v`     | Volts   | Maximum voltage               |
-| `max_i_pos` | Amperes | Maximum positive current                |
+| `max_i_pos` | Amperes | Maximum positive current      |
-| `max_i_neg` | Amperes | Maximum negative current                |
+| `max_i_neg` | Amperes | Maximum negative current      |
 |             | Amperes | Output current control (Open-loop mode) |
 Example: set the maximum voltage of channel 0 to 1.5 V.
 ```
-pwm 0 max_v 1.5
+output 0 max_v 1.5
 ```
 Example: set the maximum negative current of channel 0 to -2 A.
 ```
 output 0 max_i_neg 2
 ```
 Example: set the maximum positive current of channel 1 to 2 A.
 ```
 output 1 max_i_pos 2
 ```
 ### Open-loop mode
-To manually control TEC output current, omit the limit parameter of
+To manually control TEC output current, set a fixed output current with
-the `pwm` command. Doing so will disengage the PID control for that
+the `output` command. Doing so will disengage the PID control for that
 channel.
 Example: set output current of channel 0 to 0 A.
 ```
-pwm 0 0
+output 0 i_set 0
 ```
 ## PID-stabilized temperature control
@ -203,7 +236,23 @@ pid 0 target 20
 Enter closed-loop mode by switching control of the TEC output current
 of channel 0 to the PID algorithm:
 ```
-pwm 0 pid
+output 0 pid
 ```
 ### PID output clamping
 It is possible to clamp the PID algorithm output independently of channel output limits. This is desirable when e.g. there is a need to keep the current value above a certain threshold in closed-loop mode.
 Note that the actual output will still ultimately be limited by the `max_i_pos` and `max_i_neg` values.
 Set PID maximum output of channel 0 to 1.5 A.
 ```
 pid 0 output_max 1.5
 ```
 Set PID minimum output of channel 0 to 0.1 A.
 ```
 pid 0 output_min 0.1
 ```
 ## LED indicators
@ -216,23 +265,39 @@ pwm 0 pid
 ## Reports
-Use the bare `report` command to obtain a single report. Enable
+Use the bare `report` command to obtain a single report. Reports are JSON objects
 continuous reporting with `report mode on`. Reports are JSON objects
 with the following keys.
 | Key            | Unit            | Description                                          |
 | ---            | :---:           | ---                                                  |
 | `channel`      | Integer         | Channel `0`, or `1`                                  |
-| `time`         | Milliseconds    | Temperature measurement time                         |
+| `time`         | Seconds         | Temperature measurement time                         |
 | `interval`     | Seconds         | Time elapsed since last report update on channel     |
 | `adc`          | Volts           | AD7172 input                                         |
 | `sens`         | Ohms            | Thermistor resistance derived from `adc`             |
-| `temperature`  | Degrees Celsius | Steinhart-Hart conversion result derived from `sens` |
+| `temperature`  | Degrees Celsius | B-Parameter 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                          |
 | `tec_i`        | Amperes         | TEC output current feedback derived from `i_tec`     |
 | `tec_u_meas`   | Volts           | Measurement of the voltage across the TEC            |
 | `pid_output`   | Amperes         | PID control output                                   |
 Note: Prior to Thermostat hardware revision v2.2.4, the voltage and current readouts `i_tec` and `tec_i` are noisy without the hardware fix shown in [this PR](https://git.m-labs.hk/M-Labs/thermostat/pulls/105).
 ## 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`.
--- a/cargosha256.nix
+++ b/cargosha256.nix
@ -1 +0,0 @@
 "055x3b3kqi7bi17ya6iaiq9hlsiy8f3v6bn47s6dizc6y4xn9v2y"
--- a/tuning.md
+++ b/tuning.md
@ -0,0 +1,81 @@
 # PID Tuning
 ## Note on hardware setup
 The heat sinking side of the TEC module should be thermally bonded to a large heat-sinking thermal mass to ensure maximum temperature stability, a large optical table had provided good results in tests.
 The thermal load under control should be well insulated from the surrounding for maximum stability, closed cell foam had been tested showing good results.
 ## Real time plot
 When tuning Thermostat PID parameters, it is helpful to view the temperature, PID output and other data in the form of a real time graph.
 To use the Python real-time plotting utility, run
 ```shell
 python pythermostat/pythermostat/plot.py
 ```
 ![default view](./assets/default%20view.png)
 ## Temperature Setpoints and Thermal Load
 A PID controller with the same set of PID parameters may not work identically across all temperatures, especially when comparing the performance of a TEC module cooling a load versus heating a load. This is due to self ohmic heating of the TEC module aiding efficiency when  heating, but harming efficiency when cooling.
 When a PID loop is expected to operate the TEC in both heating and cooling modes, it is important to verify the loop performance in both modes.
 For systems expected to operate at a narrow range of temperatures, it is a good idea to tune the PID loop at the temperature region of interest.
 The same is also true for controlling loads that are expected to produce heat, e.g. laser cooling blocks. Testing the loop performance across varying amount of thermal load is needed to ensure stability in operation.
 ## Manual Tuning
 Below are some general guidelines for manually tuning PID loops. Note that every system is different, and some of the values mentioned below may not apply to all systems.
 1. To start the manual tuning process, set the kp, ki and kd parameters to 0.
 2. Begin by increasing kp until the temperature begins to oscillate. Offset between the target temperature and the actual temperature can be ignored for now.
 3. Reduce kp by 30%, increase ki until the offset between target and actual temperature is eliminated.
 4. Increase kd until the maximum allowable amount of overshoot is observed.
 5. Some tweaking will be needed to obtain the desired result, especially when trying to balance between minimizing overshoot and maximizing response speed.
 ## Auto Tuning
 A PID auto tuning utility is provided in the PyThermostat library. The auto tuning utility drives the the load to a controlled oscillation, observes the ultimate gain and oscillation period and calculates a set of PID parameters.
 To run the auto tuning utility, run
 ```shell
 python pythermostat/pythermostat/autotune.py
 ```
 After some time, the auto tuning utility will output the auto tuning results, below is a sample output
 ```shell
 Ku: 0.7553203471147422
 Pu: 75.93899999999977
 rule: ziegler-nichols
 kp: 0.45319220826884526
 Ki: 0.011935690706194357
 Kd: 4.301870387965967
 rule: tyreus-luyben
 kp: 0.3432930977636503
 Ki: 0.0020549280832497956
 Kd: 4.137825730504864
        .
        .   
        .
 ```
 At the end of the test, the ultimate gain `Ku`, oscillation period `Pu` and a few sets of recommended PID parameters are calculated and displayed.  
 Multiple suggested sets of PID parameters based on different calculation rules are displayed. While all sets are expected to work, the different sets trade off response time with overshoot differently, and testing is needed to see which set works best for the system on hand.
 With a well designed and constructed setup, the PID parameters calculated by the auto tune utility together with some manual tweaking can yield sub-mK control stability.
 Below shows data captured on an experiment setup, with 300uK stability over 12 hours.
 ![twelve_hours](./assets/twelve_hours.png)
--- a/doc/assets/default
+++ b/doc/assets/default
--- a/doc/assets/twelve_hours.png
+++ b/doc/assets/twelve_hours.png
--- a/flake.lock
+++ b/flake.lock
@ -0,0 +1,48 @@
 {
  "nodes": {
    "nixpkgs": {
      "locked": {
        "lastModified": 1722791413,
        "narHash": "sha256-rCTrlCWvHzMCNcKxPE3Z/mMK2gDZ+BvvpEVyRM4tKmU=",
        "owner": "NixOS",
        "repo": "nixpkgs",
        "rev": "8b5b6723aca5a51edf075936439d9cd3947b7b2c",
        "type": "github"
      },
      "original": {
        "owner": "NixOS",
        "ref": "nixos-24.05",
        "repo": "nixpkgs",
        "type": "github"
      }
    },
    "root": {
      "inputs": {
        "nixpkgs": "nixpkgs",
        "rust-overlay": "rust-overlay"
      }
    },
    "rust-overlay": {
      "inputs": {
        "nixpkgs": [
          "nixpkgs"
        ]
      },
      "locked": {
        "lastModified": 1719281921,
        "narHash": "sha256-LIBMfhM9pMOlEvBI757GOK5l0R58SRi6YpwfYMbf4yc=",
        "owner": "oxalica",
        "repo": "rust-overlay",
        "rev": "b6032d3a404d8a52ecfc8571ff0c26dfbe221d07",
        "type": "github"
      },
      "original": {
        "owner": "oxalica",
        "repo": "rust-overlay",
        "type": "github"
      }
    }
  },
  "root": "root",
  "version": 7
 }
--- a/flake.nix
+++ b/flake.nix
@ -0,0 +1,103 @@
 {
  description = "Firmware for the Sinara 8451 Thermostat";
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05";
  inputs.rust-overlay = {
    url = "github:oxalica/rust-overlay";
    inputs.nixpkgs.follows = "nixpkgs";
  };
  outputs =
    {
      self,
      nixpkgs,
      rust-overlay,
    }:
    let
      pkgs = import nixpkgs {
        system = "x86_64-linux";
        overlays = [ (import rust-overlay) ];
      };
      rust = pkgs.rust-bin.stable."1.66.0".default.override {
        extensions = [ "rust-src" ];
        targets = [ "thumbv7em-none-eabihf" ];
      };
      rustPlatform = pkgs.makeRustPlatform {
        rustc = rust;
        cargo = rust;
      };
      thermostat = rustPlatform.buildRustPackage {
        name = "thermostat";
        version = "0.0.0";
        src = self;
        cargoLock = {
          lockFile = ./Cargo.lock;
          outputHashes = {
            "stm32-eth-0.2.0" = "sha256-48RpZgagUqgVeKm7GXdk3Oo0v19ScF9Uby0nTFlve2o=";
          };
        };
        nativeBuildInputs = [ pkgs.llvm ];
        buildPhase = ''
          cargo build --release --bin thermostat
        '';
        installPhase = ''
          mkdir -p $out $out/nix-support
          cp target/thumbv7em-none-eabihf/release/thermostat $out/thermostat.elf
          echo file binary-dist $out/thermostat.elf >> $out/nix-support/hydra-build-products
          llvm-objcopy -O binary target/thumbv7em-none-eabihf/release/thermostat $out/thermostat.bin
          echo file binary-dist $out/thermostat.bin >> $out/nix-support/hydra-build-products
        '';
        dontFixup = true;
        auditable = false;
      };
      pythermostat = pkgs.python3Packages.buildPythonPackage {
        pname = "pythermostat";
        version = "0.0.0";
        format = "pyproject";
        src = "${self}/pythermostat";
        propagatedBuildInputs =
          with pkgs.python3Packages; [
            numpy
            matplotlib
          ];
      };
    in
    {
      packages.x86_64-linux = {
        inherit thermostat pythermostat;
        default = thermostat;
      };
      hydraJobs = {
        inherit thermostat;
      };
      devShells.x86_64-linux.default = pkgs.mkShellNoCC {
        name = "thermostat-dev-shell";
        packages =
          with pkgs;
          [
            rust
            llvm
            openocd
            dfu-util
            rlwrap
          ]
          ++ (with python3Packages; [
            numpy
            matplotlib
          ]);
      };
      formatter.x86_64-linux = nixpkgs.legacyPackages.x86_64-linux.nixfmt-rfc-style;
    };
 }
--- a/memory.x
+++ b/memory.x
@ -1,10 +1,17 @@
 MEMORY
 {
-  FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 2048K
+  FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 1024K
-  RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 112K
+  /* reserved for config data */
  CONFIG (rx)     : ORIGIN = 0x8100000, LENGTH = 16K
  RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 112K - 4
  /* reserved for DFU trigger message */
  DFU_MSG (wrx)   : ORIGIN = 0x2001BFFC, LENGTH = 4
  RAM2 (xrw)      : ORIGIN = 0x2001C000, LENGTH = 16K
  RAM3 (xrw)      : ORIGIN = 0x20020000, LENGTH = 64K
  CCMRAM (rw)     : ORIGIN = 0x10000000, LENGTH = 64K
 }
 _flash_start = ORIGIN(FLASH);
 _config_start = ORIGIN(CONFIG);
 _dfu_msg = ORIGIN(DFU_MSG);
 _stack_start = ORIGIN(CCMRAM) + LENGTH(CCMRAM);
--- a/pytec/plot.py
+++ b/pytec/plot.py
@ -1,124 +0,0 @@
 import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.animation as animation
 from threading import Thread, Lock
 from pytec.client import Client
 TIME_WINDOW = 300.0
 tec = Client()
 target_temperature = tec.get_pid()[0]['target']
 print("Channel 0 target temperature: {:.3f}".format(target_temperature))
 class Series:
    def __init__(self, conv=lambda x: x):
        self.conv = conv
        self.x_data = []
        self.y_data = []
    def append(self, x, y):
        self.x_data.append(x)
        self.y_data.append(self.conv(y))
    def clip(self, min_x):
        drop = 0
        while drop < len(self.x_data) and self.x_data[drop] < min_x:
            drop += 1
        self.x_data = self.x_data[drop:]
        self.y_data = self.y_data[drop:]
 series = {
    'adc': Series(),
    'sens': Series(lambda x: x * 0.0001),
    'temperature': Series(lambda t: t - target_temperature),
    'i_set': Series(),
    'pid_output': Series(),
    'vref': Series(),
    'dac_value': Series(),
    'dac_feedback': Series(),
    'i_tec': Series(),
    'tec_i': Series(),
    'tec_u_meas': Series(),
 }
 series_lock = Lock()
 quit = False
 def recv_data(tec):
    for data in tec.report_mode():
        if data['channel'] == 0:
            series_lock.acquire()
            try:
                time = data['time'] / 1000.0
                for k, s in series.items():
                    v = data[k]
                    if k in data and type(v) is float:
                        s.append(time, v)
            finally:
                series_lock.release()
        if quit:
            break
 thread = Thread(target=recv_data, args=(tec,))
 thread.start()
 fig, ax = plt.subplots()
 for k, s in series.items():
    s.plot, = ax.plot([], [], label=k)
 legend = ax.legend()
 def animate(i):
    min_x, max_x, min_y, max_y = None, None, None, None
    series_lock.acquire()
    try:
        for k, s in series.items():
            s.plot.set_data(s.x_data, s.y_data)
            if len(s.y_data) > 0:
                s.plot.set_label("{}: {:.3f}".format(k, s.y_data[-1]))
            if len(s.x_data) > 0:
                min_x_ = min(s.x_data)
                if min_x is None:
                    min_x = min_x_
                else:
                    min_x = min(min_x, min_x_)
                max_x_ = max(s.x_data)
                if max_x is None:
                    max_x = max_x_
                else:
                    max_x = max(max_x, max_x_)
            if len(s.y_data) > 0:
                min_y_ = min(s.y_data)
                if min_y is None:
                    min_y = min_y_
                else:
                    min_y = min(min_y, min_y_)
                max_y_ = max(s.y_data)
                if max_y is None:
                    max_y = max_y_
                else:
                    max_y = max(max_y, max_y_)
        if min_x is not None and max_x - TIME_WINDOW > min_x:
            for s in series.values():
                s.clip(max_x - TIME_WINDOW)
    finally:
        series_lock.release()
    margin_y = 0.01 * (max_y - min_y)
    ax.set_xlim(min_x, max_x)
    ax.set_ylim(min_y - margin_y, max_y + margin_y)
    global legend
    legend.remove()
    legend = ax.legend()
 ani = animation.FuncAnimation(
    fig, animate, interval=1, blit=False, save_count=50)
 plt.show()
 quit = True
 thread.join()
--- a/pytec/pytec/client.py
+++ b/pytec/pytec/client.py
@ -1,163 +0,0 @@
 import socket
 import json
 CHANNELS = 2
 class Client:
    def __init__(self, host="192.168.1.26", port=23, timeout=None):
        self._socket = socket.create_connection((host, port), timeout)
        self._lines = [""]
    def _command(self, *command):
        self._socket.sendall((" ".join(command) + "\n").encode('utf-8'))
    def _read_line(self):
        # read more lines
        while len(self._lines) <= 1:
            chunk = self._socket.recv(4096)
            if not chunk:
                return None
            buf = self._lines[-1] + chunk.decode('utf-8', errors='ignore')
            self._lines = buf.split("\n")
        line = self._lines[0]
        self._lines = self._lines[1:]
        return line
    def _get_conf(self, topic):
        self._command(topic)
        result = []
        for channel in range(0, CHANNELS):
            line = self._read_line()
            conf = json.loads(line)
            result.append(conf)
        return result
    def get_pwm(self):
        """Retrieve PWM limits for the TEC
        Example::
            [{'channel': 0,
              'center': 'vref',
              'i_set': {'max': 2.9802790335151985, 'value': -0.02002179650216762},
              'max_i_neg': {'max': 3.0, 'value': 3.0},
              'max_v': {'max': 5.988, 'value': 5.988},
              'max_i_pos': {'max': 3.0, 'value': 3.0}},
             {'channel': 1,
              'center': 'vref',
              'i_set': {'max': 2.9802790335151985, 'value': -0.02002179650216762},
              'max_i_neg': {'max': 3.0, 'value': 3.0},
              'max_v': {'max': 5.988, 'value': 5.988},
              'max_i_pos': {'max': 3.0, 'value': 3.0}}
            ]
        """
        return self._get_conf("pwm")
    def get_pid(self):
        """Retrieve PID control state
        Example::
            [{'channel': 0,
              'parameters': {
                  'kp': 10.0,
                  'ki': 0.02,
                  'kd': 0.0,
                  'output_min': 0.0,
                  'output_max': 3.0,
                  'integral_min': -100.0,
                  'integral_max': 100.0},
              'target': 37.0,
              'integral': 38.41138597026372},
             {'channel': 1,
              'parameters': {
                  'kp': 10.0,
                  'ki': 0.02,
                  'kd': 0.0,
                  'output_min': 0.0,
                  'output_max': 3.0,
                  'integral_min': -100.0,
                  'integral_max': 100.0},
              'target': 36.5,
              'integral': nan}]
        """
        return self._get_conf("pid")
    def get_steinhart_hart(self):
        """Retrieve Steinhart-Hart parameters for resistance to temperature conversion
        Example::
            [{'params': {'b': 3800.0, 'r0': 10000.0, 't0': 298.15}, 'channel': 0},
             {'params': {'b': 3800.0, 'r0': 10000.0, 't0': 298.15}, 'channel': 1}]
        """
        return self._get_conf("s-h")
    def get_postfilter(self):
        """Retrieve DAC postfilter configuration
        Example::
            [{'rate': None, 'channel': 0},
             {'rate': 21.25, 'channel': 1}]
        """
        return self._get_conf("postfilter")
    def report_mode(self):
        """Start reporting measurement values
        Example of yielded data::
            {'channel': 0,
             'time': 2302524,
             'adc': 0.6199188965423515,
             'sens': 6138.519310282602,
             'temperature': 36.87032392655527,
             'pid_engaged': True,
             'i_set': 2.0635816680889123,
             'vref': 1.494,
             'dac_value': 2.527790834044456,
             'dac_feedback': 2.523,
             'i_tec': 2.331,
             'tec_i': 2.0925,
             'tec_u_meas': 2.5340000000000003,
             'pid_output': 2.067581958092247}
        """
        self._command("report mode", "on")
        while True:
            line = self._read_line()
            if not line:
                break
            try:
                yield json.loads(line)
            except json.decoder.JSONDecodeError:
                pass
    def set_param(self, topic, channel, field="", value=""):
        """Set configuration parameters
        Examples::
            tec.set_param("pwm", 0, "max_v", 2.0)
            tec.set_param("pid", 1, "output_max", 2.5)
            tec.set_param("s-h", 0, "t0", 20.0)
            tec.set_param("center", 0, "vref")
            tec.set_param("postfilter", 1, 21)
        See the firmware's README.md for a full list.
        """
        if type(value) is float:
            value = "{:f}".format(value)
        if type(value) is not str:
            value = str(value)
        self._command(topic, str(channel), field, value)
    def power_up(self, channel, target):
        """Start closed-loop mode"""
        self.set_param("pid", channel, "target", value=target)
        self.set_param("pwm", channel, "pid")
    def save_config(self):
        """Save current configuration to EEPROM"""
        self._command("save")
    def load_config(self):
        """Load current configuration from EEPROM"""
        self._command("load")
--- a/pytec/setup.py
+++ b/pytec/setup.py
@ -1,12 +0,0 @@
 from setuptools import setup, find_packages
 setup(
    name="pytec",
    version="0.0",
    author="M-Labs",
    url="https://git.m-labs.hk/M-Labs/thermostat",
    description="Control TEC",
    license="GPLv3",
    install_requires=["setuptools"],
    packages=find_packages(),
 )
--- a/pytec/test.py
+++ b/pytec/test.py
@ -1,8 +0,0 @@
 from pytec.client import Client
 tec = Client() #(host="localhost", port=6667)
 tec.set_param("s-h", 1, "t0", 20)
 print(tec.get_pid())
 print(tec.get_steinhart_hart())
 for data in tec.report_mode():
    print(data)
--- a/pythermostat/example.py
+++ b/pythermostat/example.py
@ -0,0 +1,13 @@
 import time
 from pythermostat.client import Client
 tec = Client() #(host="localhost", port=6667)
 tec.set_param("b-p", 1, "t0", 20)
 print(tec.get_output())
 print(tec.get_pid())
 print(tec.get_output())
 print(tec.get_postfilter())
 print(tec.get_b_parameter())
 while True:
    print(tec.get_report())
    time.sleep(0.05)
--- a/pythermostat/pyproject.toml
+++ b/pythermostat/pyproject.toml
@ -0,0 +1,18 @@
 [build-system]
 requires = ["setuptools"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "pythermostat"
 version = "0.0"
 authors = [{name = "M-Labs"}]
 description = "Python utilities for the Sinara 8451 Thermostat"
 urls.Repository = "https://git.m-labs.hk/M-Labs/thermostat"
 license = {text = "GPLv3"}
 [project.gui-scripts]
 thermostat_plot = "pythermostat.plot:main"
 [project.scripts]
 thermostat_autotune = "pythermostat.autotune:main"
 thermostat_test = "pythermostat.test:main"
--- a/pythermostat/pythermostat/init.py
+++ b/pythermostat/pythermostat/init.py
--- a/pythermostat/pythermostat/autotune.py
+++ b/pythermostat/pythermostat/autotune.py
@ -0,0 +1,266 @@
 import math
 import logging
 import time
 from collections import deque, namedtuple
 from enum import Enum
 from pythermostat.client import Client
 # Based on hirshmann pid-autotune libiary
 # See https://github.com/hirschmann/pid-autotune
 # Which is in turn based on a fork of Arduino PID AutoTune Library
 # See https://github.com/t0mpr1c3/Arduino-PID-AutoTune-Library
 class PIDAutotuneState(Enum):
    STATE_OFF = 'off'
    STATE_RELAY_STEP_UP = 'relay step up'
    STATE_RELAY_STEP_DOWN = 'relay step down'
    STATE_SUCCEEDED = 'succeeded'
    STATE_FAILED = 'failed'
 class PIDAutotune:
    PIDParams = namedtuple('PIDParams', ['Kp', 'Ki', 'Kd'])
    PEAK_AMPLITUDE_TOLERANCE = 0.05
    _tuning_rules = {
        "ziegler-nichols": [0.6, 1.2, 0.075],
        "tyreus-luyben": [0.4545,  0.2066, 0.07214],
        "ciancone-marlin": [0.303, 0.1364, 0.0481],
        "pessen-integral": [0.7, 1.75, 0.105],
        "some-overshoot": [0.333, 0.667,  0.111],
        "no-overshoot": [0.2, 0.4,  0.0667]
    }
    def __init__(self, setpoint, out_step=10, lookback=60,
                 noiseband=0.5, sampletime=1.2):
        if setpoint is None:
            raise ValueError('setpoint must be specified')
        self._inputs = deque(maxlen=round(lookback / sampletime))
        self._setpoint = setpoint
        self._outputstep = out_step
        self._noiseband = noiseband
        self._out_min = -out_step
        self._out_max = out_step
        self._state = PIDAutotuneState.STATE_OFF
        self._peak_timestamps = deque(maxlen=5)
        self._peaks = deque(maxlen=5)
        self._output = 0
        self._last_run_timestamp = 0
        self._peak_type = 0
        self._peak_count = 0
        self._initial_output = 0
        self._induced_amplitude = 0
        self._Ku = 0
        self._Pu = 0
    def state(self):
        """Get the current state."""
        return self._state
    def output(self):
        """Get the last output value."""
        return self._output
    def tuning_rules(self):
        """Get a list of all available tuning rules."""
        return self._tuning_rules.keys()
    def get_pid_parameters(self, tuning_rule='ziegler-nichols'):
        """Get PID parameters.
        Args:
            tuning_rule (str): Sets the rule which should be used to calculate
                the parameters.
        """
        divisors = self._tuning_rules[tuning_rule]
        kp = self._Ku * divisors[0]
        ki = divisors[1] * self._Ku / self._Pu
        kd = divisors[2] * self._Ku * self._Pu
        return PIDAutotune.PIDParams(kp, ki, kd)
    def run(self, input_val, time_input):
        """To autotune a system, this method must be called periodically.
        Args:
            input_val (float): The temperature input value.
            time_input (float): Current time in seconds.
        Returns:
            `true` if tuning is finished, otherwise `false`.
        """
        now = time_input * 1000
        if (self._state == PIDAutotuneState.STATE_OFF
                or self._state == PIDAutotuneState.STATE_SUCCEEDED
                or self._state == PIDAutotuneState.STATE_FAILED):
            self._state = PIDAutotuneState.STATE_RELAY_STEP_UP
        self._last_run_timestamp = now
        # check input and change relay state if necessary
        if (self._state == PIDAutotuneState.STATE_RELAY_STEP_UP
                and input_val > self._setpoint + self._noiseband):
            self._state = PIDAutotuneState.STATE_RELAY_STEP_DOWN
            logging.debug('switched state: {0}'.format(self._state))
            logging.debug('input: {0}'.format(input_val))
        elif (self._state == PIDAutotuneState.STATE_RELAY_STEP_DOWN
                and input_val < self._setpoint - self._noiseband):
            self._state = PIDAutotuneState.STATE_RELAY_STEP_UP
            logging.debug('switched state: {0}'.format(self._state))
            logging.debug('input: {0}'.format(input_val))
        # set output
        if (self._state == PIDAutotuneState.STATE_RELAY_STEP_UP):
            self._output = self._initial_output - self._outputstep
        elif self._state == PIDAutotuneState.STATE_RELAY_STEP_DOWN:
            self._output = self._initial_output + self._outputstep
        # respect output limits
        self._output = min(self._output, self._out_max)
        self._output = max(self._output, self._out_min)
        # identify peaks
        is_max = True
        is_min = True
        for val in self._inputs:
            is_max = is_max and (input_val >= val)
            is_min = is_min and (input_val <= val)
        self._inputs.append(input_val)
        # we don't trust the maxes or mins until the input array is full
        if len(self._inputs) < self._inputs.maxlen:
            return False
        # increment peak count and record peak time for maxima and minima
        inflection = False
        # peak types:
        # -1: minimum
        # +1: maximum
        if is_max:
            if self._peak_type == -1:
                inflection = True
            self._peak_type = 1
        elif is_min:
            if self._peak_type == 1:
                inflection = True
            self._peak_type = -1
        # update peak times and values
        if inflection:
            self._peak_count += 1
            self._peaks.append(input_val)
            self._peak_timestamps.append(now)
            logging.debug('found peak: {0}'.format(input_val))
            logging.debug('peak count: {0}'.format(self._peak_count))
        # check for convergence of induced oscillation
        # convergence of amplitude assessed on last 4 peaks (1.5 cycles)
        self._induced_amplitude = 0
        if inflection and (self._peak_count > 4):
            abs_max = self._peaks[-2]
            abs_min = self._peaks[-2]
            for i in range(0, len(self._peaks) - 2):
                self._induced_amplitude += abs(self._peaks[i]
                                               - self._peaks[i+1])
                abs_max = max(self._peaks[i], abs_max)
                abs_min = min(self._peaks[i], abs_min)
            self._induced_amplitude /= 6.0
            # check convergence criterion for amplitude of induced oscillation
            amplitude_dev = ((0.5 * (abs_max - abs_min)
                              - self._induced_amplitude)
                             / self._induced_amplitude)
            logging.debug('amplitude: {0}'.format(self._induced_amplitude))
            logging.debug('amplitude deviation: {0}'.format(amplitude_dev))
            if amplitude_dev < PIDAutotune.PEAK_AMPLITUDE_TOLERANCE:
                self._state = PIDAutotuneState.STATE_SUCCEEDED
        # if the autotune has not already converged
        # terminate after 10 cycles
        if self._peak_count >= 20:
            self._output = 0
            self._state = PIDAutotuneState.STATE_FAILED
            return True
        if self._state == PIDAutotuneState.STATE_SUCCEEDED:
            self._output = 0
            logging.debug('peak finding successful')
            # calculate ultimate gain
            self._Ku = 4.0 * self._outputstep / \
                (self._induced_amplitude * math.pi)
            print('Ku: {0}'.format(self._Ku))
            # calculate ultimate period in seconds
            period1 = self._peak_timestamps[3] - self._peak_timestamps[1]
            period2 = self._peak_timestamps[4] - self._peak_timestamps[2]
            self._Pu = 0.5 * (period1 + period2) / 1000.0
            print('Pu: {0}'.format(self._Pu))
            for rule in self._tuning_rules:
                params = self.get_pid_parameters(rule)
                print('rule: {0}'.format(rule))
                print('Kp: {0}'.format(params.Kp))
                print('Ki: {0}'.format(params.Ki))
                print('Kd: {0}'.format(params.Kd))
            return True
        return False
 def main():
    # Auto tune parameters
    # Thermostat channel
    channel = 0
    # Target temperature of the autotune routine, celcius
    target_temperature = 20
    # Value by which output will be increased/decreased from zero, amps
    output_step = 1
    # Reference period for local minima/maxima, seconds
    lookback = 3
    # Determines by how much the input value must
    # overshoot/undershoot the setpoint, celcius
    noiseband = 1.5
    # logging.basicConfig(level=logging.DEBUG)
    tec = Client()
    data = tec.get_report()
    ch = data[channel]
    tuner = PIDAutotune(target_temperature, output_step,
                        lookback, noiseband, ch['interval'])
    while True:
        data = tec.get_report()
        ch = data[channel]
        temperature = ch['temperature']
        if (tuner.run(temperature, ch['time'])):
            break
        tuner_out = tuner.output()
        tec.set_param("output", channel, "i_set", tuner_out)
        time.sleep(0.05)
    tec.set_param("output", channel, "i_set", 0)
 if __name__ == "__main__":
    main()
--- a/pythermostat/pythermostat/client.py
+++ b/pythermostat/pythermostat/client.py
@ -0,0 +1,207 @@
 import socket
 import json
 import logging
 class CommandError(Exception):
    pass
 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 disconnect(self):
        self._socket.shutdown(socket.SHUT_RDWR)
        self._socket.close()
    def _check_zero_limits(self):
        output_report = self.get_output()
        for output_channel in output_report:
            for limit in ["max_i_neg", "max_i_pos", "max_v"]:
                if output_channel[limit] == 0.0:
                    logging.warning("`{}` limit is set to zero on channel {}".format(limit, output_channel["channel"]))
    def _read_line(self):
        # read more lines
        while len(self._lines) <= 1:
            chunk = self._socket.recv(4096)
            if not chunk:
                return None
            buf = self._lines[-1] + chunk.decode('utf-8', errors='ignore')
            self._lines = buf.split("\n")
        line = self._lines[0]
        self._lines = self._lines[1:]
        return line
    def _command(self, *command):
        self._socket.sendall((" ".join(command) + "\n").encode('utf-8'))
        line = self._read_line()
        response = json.loads(line)
        if "error" in response:
            raise CommandError(response["error"])
        return response
    def _get_conf(self, topic):
        result = [None, None]
        for item in self._command(topic):
            result[int(item["channel"])] = item
        return result
    def get_output(self):
        """Retrieve output limits for the TEC
        Example::
            [{'channel': 0,
              'center': 'vref',
              'i_set': -0.02002179650216762,
              'max_i_neg': 2.0,
              'max_v': 3.988,
              'max_i_pos': 2.0,
              'polarity': 'normal',
             {'channel': 1,
              'center': 'vref',
              'i_set': -0.02002179650216762,
              'max_i_neg': 2.0,
              'max_v': 3.988,
              'max_i_pos': 2.0}
              'polarity': 'normal',
            ]
        """
        return self._get_conf("output")
    def get_pid(self):
        """Retrieve PID control state
        Example::
            [{'channel': 0,
              'parameters': {
                  'kp': 10.0,
                  'ki': 0.02,
                  'kd': 0.0,
                  'output_min': 0.0,
                  'output_max': 3.0},
              'target': 37.0},
             {'channel': 1,
              'parameters': {
                  'kp': 10.0,
                  'ki': 0.02,
                  'kd': 0.0,
                  'output_min': 0.0,
                  'output_max': 3.0},
              'target': 36.5}]
        """
        return self._get_conf("pid")
    def get_b_parameter(self):
        """Retrieve B-Parameter equation parameters for resistance to temperature conversion
        Example::
            [{'params': {'b': 3800.0, 'r0': 10000.0, 't0': 298.15}, 'channel': 0},
             {'params': {'b': 3800.0, 'r0': 10000.0, 't0': 298.15}, 'channel': 1}]
        """
        return self._get_conf("b-p")
    def get_postfilter(self):
        """Retrieve DAC postfilter configuration
        Example::
            [{'rate': None, 'channel': 0},
             {'rate': 21.25, 'channel': 1}]
        """
        return self._get_conf("postfilter")
    def get_report(self):
        """Obtain one-time report on measurement values
        Example of yielded data::
            {'channel': 0,
             'time': 2302524,
             'interval': 0.12
             'adc': 0.6199188965423515,
             'sens': 6138.519310282602,
             'temperature': 36.87032392655527,
             'pid_engaged': True,
             'i_set': 2.0635816680889123,
             'dac_value': 2.527790834044456,
             'dac_feedback': 2.523,
             'i_tec': 2.331,
             'tec_i': 2.0925,
             'tec_u_meas': 2.5340000000000003,
             'pid_output': 2.067581958092247}
        """
        return self._get_conf("report")
    def get_ipv4(self):
        """Get the IPv4 settings of the Thermostat"""
        return self._command("ipv4")
    def get_fan(self):
        """Get Thermostat current fan settings"""
        return self._command("fan")
    def get_hwrev(self):
        """Get Thermostat hardware revision"""
        return self._command("hwrev")
    def set_param(self, topic, channel, field="", value=""):
        """Set configuration parameters
        Examples::
            tec.set_param("output", 0, "max_v", 2.0)
            tec.set_param("pid", 1, "output_max", 2.5)
            tec.set_param("b-p", 0, "t0", 20.0)
            tec.set_param("center", 0, "vref")
            tec.set_param("postfilter", 1, 21)
        See the firmware's README.md for a full list.
        """
        if type(value) is float:
            value = "{:f}".format(value)
        if type(value) is not str:
            value = str(value)
        self._command(topic, str(channel), field, value)
    def power_up(self, channel, target):
        """Start closed-loop mode"""
        self.set_param("pid", channel, "target", value=target)
        self.set_param("output", channel, "pid")
    def save_config(self, channel=""):
        """Save current configuration to EEPROM"""
        self._command("save", channel)
        if channel != "":
            self._read_line()  # read the extra {}
    def load_config(self, channel=""):
        """Load current configuration from EEPROM"""
        self._command("load", channel)
        if channel != "":
            self._read_line()  # read the extra {}
    def reset(self):
        """Reset the device"""
        self._socket.sendall("reset".encode("utf-8"))
        self.disconnect()  # resetting ends the TCP session, disconnect anyway
    def enter_dfu_mode(self):
        """Reset device and enters USB device firmware update (DFU) mode"""
        self._socket.sendall("dfu".encode("utf-8"))
        self.disconnect()  # resetting ends the TCP session, disconnect anyway
    def set_ipv4(self, address, netmask, gateway=""):
        """Configure IPv4 address, netmask length, and optional default gateway"""
        self._command("ipv4", f"{address}/{netmask}", gateway)
    def set_fan(self, power=None):
        """Set fan power with values from 1 to 100. If omitted, set according to fcurve"""
        if power is None:
            power = "auto"
        self._command("fan", power)
    def set_fcurve(self, a=1.0, b=0.0, c=0.0):
        """Set fan controller curve coefficients"""
        self._command("fcurve", a, b, c)
--- a/pythermostat/pythermostat/plot.py
+++ b/pythermostat/pythermostat/plot.py
@ -0,0 +1,137 @@
 import time
 import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.animation as animation
 from threading import Thread, Lock
 from pythermostat.client import Client
 def main():
    TIME_WINDOW = 300.0
    tec = Client()
    target_temperature = tec.get_pid()[0]['target']
    print("Channel 0 target temperature: {:.3f}".format(target_temperature))
    class Series:
        def __init__(self, conv=lambda x: x):
            self.conv = conv
            self.x_data = []
            self.y_data = []
        def append(self, x, y):
            self.x_data.append(x)
            self.y_data.append(self.conv(y))
        def clip(self, min_x):
            drop = 0
            while drop < len(self.x_data) and self.x_data[drop] < min_x:
                drop += 1
            self.x_data = self.x_data[drop:]
            self.y_data = self.y_data[drop:]
    series = {
        # 'adc': Series(),
        # 'sens': Series(lambda x: x * 0.0001),
        'temperature': Series(),
        # 'i_set': Series(),
        'pid_output': Series(),
        # 'vref': Series(),
        # 'dac_value': Series(),
        # 'dac_feedback': Series(),
        # 'i_tec': Series(),
        'tec_i': Series(),
        'tec_u_meas': Series(),
        # 'interval': Series(),
    }
    series_lock = Lock()
    quit = False
    def recv_data(tec):
        global last_packet_time
        while True:
            data = tec.get_report()
            ch0 = data[0]
            series_lock.acquire()
            try:
                for k, s in series.items():
                    if k in ch0:
                        v = ch0[k]
                        if type(v) is float:
                            s.append(ch0['time'], v)
            finally:
                series_lock.release()
            if quit:
                break
            time.sleep(0.05)
    thread = Thread(target=recv_data, args=(tec,))
    thread.start()
    fig, ax = plt.subplots()
    for k, s in series.items():
        s.plot, = ax.plot([], [], label=k)
    legend = ax.legend()
    def animate(i):
        min_x, max_x, min_y, max_y = None, None, None, None
        series_lock.acquire()
        try:
            for k, s in series.items():
                s.plot.set_data(s.x_data, s.y_data)
                if len(s.y_data) > 0:
                    s.plot.set_label("{}: {:.3f}".format(k, s.y_data[-1]))
                if len(s.x_data) > 0:
                    min_x_ = min(s.x_data)
                    if min_x is None:
                        min_x = min_x_
                    else:
                        min_x = min(min_x, min_x_)
                    max_x_ = max(s.x_data)
                    if max_x is None:
                        max_x = max_x_
                    else:
                        max_x = max(max_x, max_x_)
                if len(s.y_data) > 0:
                    min_y_ = min(s.y_data)
                    if min_y is None:
                        min_y = min_y_
                    else:
                        min_y = min(min_y, min_y_)
                    max_y_ = max(s.y_data)
                    if max_y is None:
                        max_y = max_y_
                    else:
                        max_y = max(max_y, max_y_)
            if min_x and max_x - TIME_WINDOW > min_x:
                for s in series.values():
                    s.clip(max_x - TIME_WINDOW)
        finally:
            series_lock.release()
        if min_x != max_x:
            ax.set_xlim(min_x, max_x)
        if min_y != max_y:
            margin_y = 0.01 * (max_y - min_y)
            ax.set_ylim(min_y - margin_y, max_y + margin_y)
        nonlocal legend
        legend.remove()
        legend = ax.legend()
    ani = animation.FuncAnimation(
        fig, animate, interval=1, blit=False, save_count=50)
    plt.show()
    quit = True
    thread.join()
 if __name__ == "__main__":
    main()
--- a/pythermostat/pythermostat/test.py
+++ b/pythermostat/pythermostat/test.py
@ -0,0 +1,81 @@
 import argparse
 from contextlib import contextmanager
 from pythermostat.client import Client
 CHANNELS = 2
 def get_argparser():
    parser = argparse.ArgumentParser(description="Thermostat hardware testing script")
    parser.add_argument("host", metavar="HOST", default="192.168.1.26", nargs="?")
    parser.add_argument("port", metavar="PORT", default=23, nargs="?")
    parser.add_argument(
        "-r",
        "--testing_resistance",
        default=10_000,
        help="Testing resistance value through SENS pin in Ohms",
    )
    parser.add_argument(
        "-d",
        "--deviation",
        default=1,
        help="Allowed deviation of resistance in percentage",
    )
    return parser
 def main():
    args = get_argparser().parse_args()
    min_allowed_resistance = args.testing_resistance * (1 - args.deviation / 100)
    max_allowed_resistance = args.testing_resistance * (1 + args.deviation / 100)
    print(min_allowed_resistance, max_allowed_resistance)
    thermostat = Client(args.host, args.port)
    for channel in range(CHANNELS):
        print(f"Channel {channel} is active")
        print("Checking resistance through SENS input ....", end=" ")
        sens_resistance = thermostat.get_report()[channel]["sens"]
        if sens_resistance is not None:
            print(sens_resistance, "Ω")
            if min_allowed_resistance <= sens_resistance <= max_allowed_resistance:
                print("PASSED")
            else:
                print("FAILED")
        else:
            print("Floating SENS input! Is the channel connected?")
        with preserve_thermostat_output_settings(thermostat, channel):
            test_output_settings = {
                "max_i_pos": 2,
                "max_i_neg": 2,
                "max_v": 4,
                "i_set": 0.1,
                "polarity": "normal",
            }
            for field, value in test_output_settings.items():
                thermostat.set_param("output", channel, field, value)
            input(f"Check if channel {channel} current = 0.1 A, and press ENTER...")
        input(f"Channel {channel} testing done, press ENTER to continue.")
        print()
    print("Testing complete.")
@contextmanager
 def preserve_thermostat_output_settings(client, channel):
    original_output_settings = client.get_output()[channel]
    yield original_output_settings
    for setting in "max_i_pos", "max_i_neg", "max_v", "i_set", "polarity":
        client.set_param("output", channel, setting, original_output_settings[setting])
 if __name__ == "__main__":
    main()
--- a/src/ad5680.rs
+++ b/src/ad5680.rs
@ -1,12 +1,9 @@
 use stm32f4xx_hal::{
    hal::{
        blocking::spi::Transfer,
        digital::v2::OutputPin,
    },
    time::MegaHertz,
    spi,
 };
 use crate::timer::sleep;
 use stm32f4xx_hal::{
    hal::{blocking::spi::Transfer, digital::v2::OutputPin},
    spi,
    time::MegaHertz,
 };
 /// SPI Mode 1
 pub const SPI_MODE: spi::Mode = spi::Mode {
@ -28,10 +25,7 @@ impl<SPI: Transfer<u8>, S: OutputPin> Dac<SPI, S> {
    pub fn new(spi: SPI, mut sync: S) -> Self {
        let _ = sync.set_low();
-        Dac {
+        Dac { spi, sync }
            spi,
            sync,
        }
    }
    fn write(&mut self, buf: &mut [u8]) -> Result<(), SPI::Error> {
@ -47,11 +41,7 @@ impl<SPI: Transfer<u8>, S: OutputPin> Dac<SPI, S> {
    pub fn set(&mut self, value: u32) -> Result<u32, SPI::Error> {
        let value = value.min(MAX_VALUE);
-        let mut buf = [
+        let mut buf = [(value >> 14) as u8, (value >> 6) as u8, (value << 2) as u8];
            (value >> 14) as u8,
            (value >> 6) as u8,
            (value << 2) as u8,
        ];
        self.write(&mut buf)?;
        Ok(value)
    }
--- a/src/ad7172/adc.rs
+++ b/src/ad7172/adc.rs
@ -1,18 +1,12 @@
 use super::{
    checksum::{Checksum, ChecksumMode},
    regs::{self, Register, RegisterData},
    DigitalFilterOrder, Input, Mode, PostFilter, RefSource,
 };
 use core::fmt;
 use log::{info, warn};
-use stm32f4xx_hal::hal::{
+use stm32f4xx_hal::hal::{blocking::spi::Transfer, digital::v2::OutputPin};
-    blocking::spi::Transfer,
+use uom::si::{electric_potential::volt, f64::ElectricPotential};
    digital::v2::OutputPin,
 };
 use uom::si::{
    f64::ElectricPotential,
    electric_potential::volt,
 };
 use super::{
    regs::{self, Register, RegisterData},
    checksum::{ChecksumMode, Checksum},
    Mode, Input, RefSource, PostFilter, DigitalFilterOrder,
 };
 /// AD7172-2 implementation
 ///
@ -27,7 +21,8 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
    pub fn new(spi: SPI, mut nss: NSS) -> Result<Self, SPI::Error> {
        let _ = nss.set_high();
        let mut adc = Adc {
-            spi, nss,
+            spi,
            nss,
            checksum_mode: ChecksumMode::Off,
        };
        adc.reset()?;
@ -55,8 +50,7 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
    /// `0x00DX` for AD7172-2
    pub fn identify(&mut self) -> Result<u16, SPI::Error> {
-        self.read_reg(&regs::Id)
+        self.read_reg(&regs::Id).map(|id| id.id())
            .map(|id| id.id())
    }
    pub fn set_checksum_mode(&mut self, mode: ChecksumMode) -> Result<(), SPI::Error> {
@ -76,7 +70,10 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
    }
    pub fn setup_channel(
-        &mut self, index: u8, in_pos: Input, in_neg: Input
+        &mut self,
        index: u8,
        in_pos: Input,
        in_neg: Input,
    ) -> Result<(), SPI::Error> {
        self.update_reg(&regs::SetupCon { index }, |data| {
            data.set_bipolar(false);
@ -106,7 +103,11 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
        let offset = self.read_reg(&regs::Offset { index })?.offset();
        let gain = self.read_reg(&regs::Gain { index })?.gain();
        let bipolar = self.read_reg(&regs::SetupCon { index })?.bipolar();
-        Ok(ChannelCalibration { offset, gain, bipolar })
+        Ok(ChannelCalibration {
            offset,
            gain,
            bipolar,
        })
    }
    pub fn start_continuous_conversion(&mut self) -> Result<(), SPI::Error> {
@ -119,44 +120,43 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
    }
    pub fn get_postfilter(&mut self, index: u8) -> Result<Option<PostFilter>, SPI::Error> {
-        self.read_reg(&regs::FiltCon { index })
+        self.read_reg(&regs::FiltCon { index }).map(|data| {
-            .map(|data| {
+            if data.enh_filt_en() {
-                if data.enh_filt_en() {
+                Some(data.enh_filt())
-                    Some(data.enh_filt())
+            } else {
-                } else {
+                None
-                    None
+            }
-                }
+        })
            })
    }
-    pub fn set_postfilter(&mut self, index: u8, filter: Option<PostFilter>) -> Result<(), SPI::Error> {
+    pub fn set_postfilter(
-        self.update_reg(&regs::FiltCon { index }, |data| {
+        &mut self,
-            match filter {
+        index: u8,
-                None => data.set_enh_filt_en(false),
+        filter: Option<PostFilter>,
-                Some(filter) => {
+    ) -> Result<(), SPI::Error> {
-                    data.set_enh_filt_en(true);
+        self.update_reg(&regs::FiltCon { index }, |data| match filter {
-                    data.set_enh_filt(filter);
+            None => data.set_enh_filt_en(false),
-                }
+            Some(filter) => {
                data.set_enh_filt_en(true);
                data.set_enh_filt(filter);
            }
        })
    }
    /// Returns the channel the data is from
    pub fn data_ready(&mut self) -> Result<Option<u8>, SPI::Error> {
-        self.read_reg(&regs::Status)
+        self.read_reg(&regs::Status).map(|status| {
-            .map(|status| {
+            if status.ready() {
-                if status.ready() {
+                Some(status.channel())
-                    Some(status.channel())
+            } else {
-                } else {
+                None
-                    None
+            }
-                }
+        })
            })
    }
    /// Get data
    pub fn read_data(&mut self) -> Result<u32, SPI::Error> {
-        self.read_reg(&regs::Data)
+        self.read_reg(&regs::Data).map(|data| data.data())
            .map(|data| data.data())
    }
    fn read_reg<R: regs::Register>(&mut self, reg: &R) -> Result<R::Data, SPI::Error> {
@ -175,12 +175,21 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
                break;
            }
            // Retry
-            warn!("read_reg {:02X}: checksum error: {:?}!={:?}, retrying", reg.address(), checksum_expected, checksum_in);
+            warn!(
                "read_reg {:02X}: checksum error: {:?}!={:?}, retrying",
                reg.address(),
                checksum_expected,
                checksum_in
            );
        }
        Ok(reg_data)
    }
-    fn write_reg<R: regs::Register>(&mut self, reg: &R, reg_data: &mut R::Data) -> Result<(), SPI::Error> {
+    fn write_reg<R: regs::Register>(
        &mut self,
        reg: &R,
        reg_data: &mut R::Data,
    ) -> Result<(), SPI::Error> {
        loop {
            let address = reg.address();
            let mut checksum = Checksum::new(match self.checksum_mode {
@ -190,7 +199,7 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
                ChecksumMode::Crc => ChecksumMode::Crc,
            });
            checksum.feed(&[address]);
-            checksum.feed(&reg_data);
+            checksum.feed(reg_data);
            let checksum_out = checksum.result();
            let mut data = reg_data.clone();
@ -201,7 +210,10 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
            if *readback_data == **reg_data {
                return Ok(());
            }
-            warn!("write_reg {:02X}: readback error, {:?}!={:?}, retrying", address, &*readback_data, &**reg_data);
+            warn!(
                "write_reg {:02X}: readback error, {:?}!={:?}, retrying",
                address, &*readback_data, &**reg_data
            );
        }
    }
@ -225,7 +237,12 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
        Ok(())
    }
-    fn transfer<'w>(&mut self, addr: u8, reg_data: &'w mut [u8], checksum: Option<u8>) -> Result<Option<u8>, SPI::Error> {
+    fn transfer(
        &mut self,
        addr: u8,
        reg_data: &mut [u8],
        checksum: Option<u8>,
    ) -> Result<Option<u8>, SPI::Error> {
        let mut addr_buf = [addr];
        let _ = self.nss.set_low();
@ -234,8 +251,7 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
            Err(e) => Err(e),
        };
        let result = match (result, checksum) {
-            (Ok(_), None) =>
+            (Ok(_), None) => Ok(None),
                Ok(None),
            (Ok(_), Some(checksum_out)) => {
                let mut checksum_buf = [checksum_out; 1];
                match self.spi.transfer(&mut checksum_buf) {
@ -243,8 +259,7 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
                    Err(e) => Err(e),
                }
            }
-            (Err(e), _) =>
+            (Err(e), _) => Err(e),
                Err(e),
        };
        let _ = self.nss.set_high();
--- a/src/ad7172/checksum.rs
+++ b/src/ad7172/checksum.rs
@ -29,13 +29,13 @@ impl Checksum {
    fn feed_byte(&mut self, input: u8) {
        match self.mode {
-            ChecksumMode::Off => {},
+            ChecksumMode::Off => {}
            ChecksumMode::Xor => self.state ^= input,
            ChecksumMode::Crc => {
                for i in 0..8 {
                    let input_mask = 0x80 >> i;
-                    self.state = (self.state << 1) ^
+                    self.state = (self.state << 1)
-                        if ((self.state & 0x80) != 0) != ((input & input_mask) != 0) {
+                        ^ if ((self.state & 0x80) != 0) != ((input & input_mask) != 0) {
                            0x07 /* x8 + x2 + x + 1 */
                        } else {
                            0
@ -54,7 +54,7 @@ impl Checksum {
    pub fn result(&self) -> Option<u8> {
        match self.mode {
            ChecksumMode::Off => None,
-            _ => Some(self.state)
+            _ => Some(self.state),
        }
    }
 }
--- a/src/ad7172/mod.rs
+++ b/src/ad7172/mod.rs
@ -1,13 +1,10 @@
 use core::fmt;
 use num_traits::float::Float;
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
-use stm32f4xx_hal::{
+use stm32f4xx_hal::{spi, time::MegaHertz};
    time::MegaHertz,
    spi,
 };
 pub mod regs;
 mod checksum;
 pub mod regs;
 pub use checksum::ChecksumMode;
 mod adc;
 pub use adc::*;
@ -22,7 +19,6 @@ pub const SPI_CLOCK: MegaHertz = MegaHertz(2);
 pub const MAX_VALUE: u32 = 0xFF_FFFF;
 #[derive(Clone, Copy, Debug)]
 #[repr(u8)]
 pub enum Mode {
@ -105,7 +101,8 @@ impl fmt::Display for Input {
            RefPos => "ref+",
            RefNeg => "ref-",
            _ => "<INVALID>",
-        }.fmt(fmt)
+        }
        .fmt(fmt)
    }
 }
@ -141,7 +138,8 @@ impl fmt::Display for RefSource {
            Internal => "internal",
            Avdd1MinusAvss => "avdd1-avss",
            _ => "<INVALID>",
-        }.fmt(fmt)
+        }
        .fmt(fmt)
    }
 }
--- a/src/ad7172/regs.rs
+++ b/src/ad7172/regs.rs
@ -1,6 +1,6 @@
 use core::ops::{Deref, DerefMut};
 use byteorder::{BigEndian, ByteOrder};
 use bit_field::BitField;
 use byteorder::{BigEndian, ByteOrder};
 use core::ops::{Deref, DerefMut};
 use super::*;
@ -9,7 +9,7 @@ pub trait Register {
    fn address(&self) -> u8;
 }
-pub trait RegisterData: Clone + Deref<Target=[u8]> + DerefMut {
+pub trait RegisterData: Clone + Deref<Target = [u8]> + DerefMut {
    fn empty() -> Self;
 }
@ -49,7 +49,9 @@ macro_rules! def_reg {
        }
    };
    ($Reg: ident, u8, $reg: ident, $addr: expr, $size: expr) => {
-        pub struct $Reg { pub index: u8, }
+        pub struct $Reg {
            pub index: u8,
        }
        impl Register for $Reg {
            type Data = $reg::Data;
            fn address(&self) -> u8 {
@ -76,7 +78,7 @@ macro_rules! def_reg {
                }
            }
        }
-    }
+    };
 }
 macro_rules! reg_bit {
@ -146,7 +148,7 @@ def_reg!(Status, status, 0x00, 1);
 impl status::Data {
    /// Is there new data to read?
    pub fn ready(&self) -> bool {
-        ! self.not_ready()
+        !self.not_ready()
    }
    reg_bit!(not_ready, 0, 7, "No data ready indicator");
@ -159,9 +161,21 @@ impl status::Data {
 def_reg!(AdcMode, adc_mode, 0x01, 2);
 impl adc_mode::Data {
    reg_bits!(delay, set_delay, 0, 0..=2, "Delay after channel switch");
-    reg_bit!(sing_cyc, set_sing_cyc, 0, 5, "Can only used with single channel");
+    reg_bit!(
        sing_cyc,
        set_sing_cyc,
        0,
        5,
        "Can only used with single channel"
    );
    reg_bit!(hide_delay, set_hide_delay, 0, 6, "Hide delay");
-    reg_bit!(ref_en, set_ref_en, 0, 7, "Enable internal reference, output buffered 2.5 V to REFOUT");
+    reg_bit!(
        ref_en,
        set_ref_en,
        0,
        7,
        "Enable internal reference, output buffered 2.5 V to REFOUT"
    );
    reg_bits!(clockset, set_clocksel, 1, 2..=3, "Clock source");
    reg_bits!(mode, set_mode, 1, 4..=6, Mode, "Operating mode");
 }
@ -174,15 +188,19 @@ impl if_mode::Data {
 def_reg!(Data, data, 0x04, 3);
 impl data::Data {
    pub fn data(&self) -> u32 {
-        (u32::from(self.0[0]) << 16) |
+        (u32::from(self.0[0]) << 16) | (u32::from(self.0[1]) << 8) | u32::from(self.0[2])
        (u32::from(self.0[1]) << 8) |
        u32::from(self.0[2])
    }
 }
 def_reg!(GpioCon, gpio_con, 0x06, 2);
 impl gpio_con::Data {
-    reg_bit!(sync_en, set_sync_en, 0, 3, "Enables the SYNC/ERROR pin as a sync input");
+    reg_bit!(
        sync_en,
        set_sync_en,
        0,
        3,
        "Enables the SYNC/ERROR pin as a sync input"
    );
 }
 def_reg!(Id, id, 0x07, 2);
@ -200,8 +218,7 @@ impl channel::Data {
    /// Which input is connected to positive input of this channel
    #[allow(unused)]
    pub fn a_in_pos(&self) -> Input {
-        ((self.0[0].get_bits(0..=1) << 3) |
+        ((self.0[0].get_bits(0..=1) << 3) | self.0[1].get_bits(5..=7)).into()
         self.0[1].get_bits(5..=7)).into()
    }
    /// Set which input is connected to positive input of this channel
    #[allow(unused)]
@ -210,27 +227,66 @@ impl channel::Data {
        self.0[0].set_bits(0..=1, value >> 3);
        self.0[1].set_bits(5..=7, value & 0x7);
    }
-    reg_bits!(a_in_neg, set_a_in_neg, 1, 0..=4, Input,
+    reg_bits!(
-              "Which input is connected to negative input of this channel");
+        a_in_neg,
        set_a_in_neg,
        1,
        0..=4,
        Input,
        "Which input is connected to negative input of this channel"
    );
 }
 def_reg!(SetupCon, u8, setup_con, 0x20, 2);
 impl setup_con::Data {
-    reg_bit!(bipolar, set_bipolar, 0, 4, "Unipolar (`false`) or bipolar (`true`) coded output");
+    reg_bit!(
        bipolar,
        set_bipolar,
        0,
        4,
        "Unipolar (`false`) or bipolar (`true`) coded output"
    );
    reg_bit!(refbuf_pos, set_refbuf_pos, 0, 3, "Enable REF+ input buffer");
    reg_bit!(refbuf_neg, set_refbuf_neg, 0, 2, "Enable REF- input buffer");
    reg_bit!(ainbuf_pos, set_ainbuf_pos, 0, 1, "Enable AIN+ input buffer");
    reg_bit!(ainbuf_neg, set_ainbuf_neg, 0, 0, "Enable AIN- input buffer");
    reg_bit!(burnout_en, 1, 7, "enables a 10 µA current source on the positive analog input selected and a 10 µA current sink on the negative analog input selected");
-    reg_bits!(ref_sel, set_ref_sel, 1, 4..=5, RefSource, "Select reference source for conversion");
+    reg_bits!(
        ref_sel,
        set_ref_sel,
        1,
        4..=5,
        RefSource,
        "Select reference source for conversion"
    );
 }
 def_reg!(FiltCon, u8, filt_con, 0x28, 2);
 impl filt_con::Data {
    reg_bit!(sinc3_map, 0, 7, "If set, mapping of filter register changes to directly program the decimation rate of the sinc3 filter");
-    reg_bit!(enh_filt_en, set_enh_filt_en, 0, 3, "Enable postfilters for enhanced 50Hz and 60Hz rejection");
+    reg_bit!(
-    reg_bits!(enh_filt, set_enh_filt, 0, 0..=2, PostFilter, "Select postfilters for enhanced 50Hz and 60Hz rejection");
+        enh_filt_en,
-    reg_bits!(order, set_order, 1, 5..=6, DigitalFilterOrder, "order of the digital filter that processes the modulator data");
+        set_enh_filt_en,
        0,
        3,
        "Enable postfilters for enhanced 50Hz and 60Hz rejection"
    );
    reg_bits!(
        enh_filt,
        set_enh_filt,
        0,
        0..=2,
        PostFilter,
        "Select postfilters for enhanced 50Hz and 60Hz rejection"
    );
    reg_bits!(
        order,
        set_order,
        1,
        5..=6,
        DigitalFilterOrder,
        "order of the digital filter that processes the modulator data"
    );
    reg_bits!(odr, set_odr, 1, 0..=4, "Output data rate");
 }
@ -238,9 +294,7 @@ def_reg!(Offset, u8, offset, 0x30, 3);
 impl offset::Data {
    #[allow(unused)]
    pub fn offset(&self) -> u32 {
-        (u32::from(self.0[0]) << 16) |
+        (u32::from(self.0[0]) << 16) | (u32::from(self.0[1]) << 8) | u32::from(self.0[2])
        (u32::from(self.0[1]) << 8) |
        u32::from(self.0[2])
    }
    #[allow(unused)]
    pub fn set_offset(&mut self, value: u32) {
@ -254,9 +308,7 @@ def_reg!(Gain, u8, gain, 0x38, 3);
 impl gain::Data {
    #[allow(unused)]
    pub fn gain(&self) -> u32 {
-        (u32::from(self.0[0]) << 16) |
+        (u32::from(self.0[0]) << 16) | (u32::from(self.0[1]) << 8) | u32::from(self.0[2])
        (u32::from(self.0[1]) << 8) |
        u32::from(self.0[2])
    }
    #[allow(unused)]
    pub fn set_gain(&mut self, value: u32) {
--- a/src/b_parameter.rs
+++ b/src/b_parameter.rs
@ -0,0 +1,38 @@
 use num_traits::float::Float;
 use serde::{Deserialize, Serialize};
 use uom::si::{
    electrical_resistance::ohm,
    f64::{ElectricalResistance, TemperatureInterval, ThermodynamicTemperature},
    ratio::ratio,
    temperature_interval::kelvin as kelvin_interval,
    thermodynamic_temperature::{degree_celsius, kelvin},
 };
 /// B-Parameter equation parameters
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct Parameters {
    /// Base temperature
    pub t0: ThermodynamicTemperature,
    /// Thermistor resistance at base temperature
    pub r0: ElectricalResistance,
    /// Beta (average slope of the function ln R vs. 1/T)
    pub b: TemperatureInterval,
 }
 impl Parameters {
    /// Perform the resistance to temperature conversion.
    pub fn get_temperature(&self, r: ElectricalResistance) -> ThermodynamicTemperature {
        let temp = (self.t0.recip() + (r / self.r0).get::<ratio>().ln() / self.b).recip();
        ThermodynamicTemperature::new::<kelvin>(temp.get::<kelvin_interval>())
    }
 }
 impl Default for Parameters {
    fn default() -> Self {
        Parameters {
            t0: ThermodynamicTemperature::new::<degree_celsius>(25.0),
            r0: ElectricalResistance::new::<ohm>(10_000.0),
            b: TemperatureInterval::new::<kelvin_interval>(3800.0),
        }
    }
 }
--- a/src/channel.rs
+++ b/src/channel.rs
@ -1,10 +1,10 @@
 use stm32f4xx_hal::hal::digital::v2::OutputPin;
 use crate::{
-    ad5680,
+    ad5680, ad7172,
    ad7172,
    channel_state::ChannelState,
-    pins::{ChannelPins, ChannelPinSet},
+    pins::{ChannelPinSet, ChannelPins},
 };
 use stm32f4xx_hal::hal::digital::v2::OutputPin;
 use uom::si::{electric_potential::volt, f64::ElectricPotential};
 /// Marker type for the first channel
 pub struct Channel0;
@ -12,16 +12,15 @@ pub struct Channel0;
 /// Marker type for the second channel
 pub struct Channel1;
 pub struct Channel<C: ChannelPins> {
    pub state: ChannelState,
    /// for `i_set`
    pub dac: ad5680::Dac<C::DacSpi, C::DacSync>,
-    /// 1 / Volts
+    /// Measured vref of MAX driver chip
-    pub dac_factor: f64,
+    pub vref_meas: ElectricPotential,
    pub shdn: C::Shdn,
    pub vref_pin: C::VRefPin,
-    pub itec_pin: C::ItecPin,
+    pub itec_pin: C::ITecPin,
    /// feedback from `dac` output
    pub dac_feedback_pin: C::DacFeedbackPin,
    pub tec_u_meas_pin: C::TecUMeasPin,
@ -32,12 +31,13 @@ impl<C: ChannelPins> Channel<C> {
        let state = ChannelState::new(adc_calibration);
        let mut dac = ad5680::Dac::new(pins.dac_spi, pins.dac_sync);
        let _ = dac.set(0);
-        // sensible dummy preset. calibrate_i_set() must be used.
+        // sensible dummy preset taken from datasheet. calibrate_dac_value() should be used to override this value.
-        let dac_factor = ad5680::MAX_VALUE as f64 / 5.0;
+        let vref_meas = ElectricPotential::new::<volt>(1.5);
        Channel {
            state,
-            dac, dac_factor,
+            dac,
            vref_meas,
            shdn: pins.shdn,
            vref_pin: pins.vref_pin,
            itec_pin: pins.itec_pin,
--- a/src/channel_state.rs
+++ b/src/channel_state.rs
@ -1,19 +1,20 @@
-use smoltcp::time::Instant;
+use crate::{
    ad7172, b_parameter as bp,
    command_parser::{CenterPoint, Polarity},
    config::PwmLimits,
    pid,
 };
 use num_traits::Zero;
 use smoltcp::time::{Duration, Instant};
 use uom::si::{
-    f64::{
+    electric_current::ampere,
        ElectricPotential,
        ElectricalResistance,
        ThermodynamicTemperature,
    },
    electric_potential::volt,
    electrical_resistance::ohm,
    f64::{
        ElectricCurrent, ElectricPotential, ElectricalResistance, ThermodynamicTemperature, Time,
    },
    thermodynamic_temperature::degree_celsius,
-};
+    time::millisecond,
 use crate::{
    ad7172,
    pid,
    steinhart_hart as sh,
    command_parser::CenterPoint,
 };
 const R_INNER: f64 = 2.0 * 5100.0;
@ -23,14 +24,16 @@ pub struct ChannelState {
    pub adc_data: Option<u32>,
    pub adc_calibration: ad7172::ChannelCalibration,
    pub adc_time: Instant,
-    /// VREF for the TEC (1.5V)
+    pub adc_interval: Duration,
    pub vref: ElectricPotential,
    /// i_set 0A center point
    pub center: CenterPoint,
    pub dac_value: ElectricPotential,
    pub i_set: ElectricCurrent,
    pub pwm_limits: PwmLimits,
    pub pid_engaged: bool,
    pub pid: pid::Controller,
-    pub sh: sh::Parameters,
+    pub bp: bp::Parameters,
    pub polarity: Polarity,
 }
 impl ChannelState {
@ -39,13 +42,20 @@ impl ChannelState {
            adc_data: None,
            adc_calibration,
            adc_time: Instant::from_secs(0),
-            // updated later with Channels.read_vref()
+            // default: 10 Hz
-            vref: ElectricPotential::new::<volt>(1.5),
+            adc_interval: Duration::from_millis(100),
-            center: CenterPoint::Vref,
+            center: CenterPoint::VRef,
            dac_value: ElectricPotential::new::<volt>(0.0),
            i_set: ElectricCurrent::new::<ampere>(0.0),
            pwm_limits: PwmLimits {
                max_v: ElectricPotential::zero(),
                max_i_pos: ElectricCurrent::zero(),
                max_i_neg: ElectricCurrent::zero(),
            },
            pid_engaged: false,
            pid: pid::Controller::new(pid::Parameters::default()),
-            sh: sh::Parameters::default(),
+            bp: bp::Parameters::default(),
            polarity: Polarity::Normal,
        }
    }
@ -56,17 +66,25 @@ impl ChannelState {
        } else {
            Some(adc_data)
        };
        self.adc_interval = now - self.adc_time;
        self.adc_time = now;
    }
    /// Update PID state on ADC input, calculate new DAC output
    pub fn update_pid(&mut self) -> Option<f64> {
-        let temperature = self.get_temperature()?
+        let temperature = self.get_temperature()?.get::<degree_celsius>();
            .get::<degree_celsius>();
        let pid_output = self.pid.update(temperature);
        Some(pid_output)
    }
    pub fn get_adc_time(&self) -> Time {
        Time::new::<millisecond>(self.adc_time.total_millis() as f64)
    }
    pub fn get_adc_interval(&self) -> Time {
        Time::new::<millisecond>(self.adc_interval.total_millis() as f64)
    }
    pub fn get_adc(&self) -> Option<ElectricPotential> {
        Some(self.adc_calibration.convert_data(self.adc_data?))
    }
@ -82,7 +100,7 @@ impl ChannelState {
    pub fn get_temperature(&self) -> Option<ThermodynamicTemperature> {
        let r = self.get_sens()?;
-        let temperature = self.sh.get_temperature(r);
+        let temperature = self.bp.get_temperature(r);
        Some(temperature)
    }
 }
--- a/src/channels.rs
+++ b/src/channels.rs
@ -1,27 +1,59 @@
 use crate::timer::sleep;
 use crate::{
    ad5680, ad7172, b_parameter,
    channel::{Channel, Channel0, Channel1},
    channel_state::ChannelState,
    command_handler::JsonBuffer,
    command_parser::{CenterPoint, Polarity, PwmPin},
    pins::{self, Channel0VRef, Channel1VRef},
 };
 use core::marker::PhantomData;
 use heapless::{consts::U2, Vec};
 use num_traits::Zero;
 use serde::{Serialize, Serializer};
 use smoltcp::time::Instant;
 use stm32f4xx_hal::hal;
 use uom::si::{
    f64::{ElectricCurrent, ElectricPotential, ElectricalResistance},
    electric_potential::{millivolt, volt},
    electric_current::ampere,
    electric_potential::{millivolt, volt},
    electrical_resistance::ohm,
    f64::{ElectricCurrent, ElectricPotential, ElectricalResistance, Time},
    ratio::ratio,
    thermodynamic_temperature::degree_celsius,
 };
-use crate::{
+
-    ad5680,
+pub enum PinsAdcReadTarget {
-    ad7172,
+    VRef,
-    channel::{Channel, Channel0, Channel1},
+    DacVfb,
-    channel_state::ChannelState,
+    ITec,
-    command_parser::{CenterPoint, PwmPin},
+    VTec,
-    pins,
+}
    steinhart_hart,
 };
 pub const CHANNELS: usize = 2;
 pub const R_SENSE: f64 = 0.05;
 // From design specs
 pub const MAX_TEC_I: ElectricCurrent = ElectricCurrent {
    dimension: PhantomData,
    units: PhantomData,
    value: 2.0,
 };
 pub const MAX_TEC_V: ElectricPotential = ElectricPotential {
    dimension: PhantomData,
    units: PhantomData,
    value: 4.0,
 };
 const MAX_TEC_I_DUTY_TO_CURRENT_RATE: ElectricCurrent = ElectricCurrent {
    dimension: PhantomData,
    units: PhantomData,
    value: 1.0 / (10.0 * R_SENSE / 3.3),
 };
 // DAC chip outputs 0-5v, which is then passed through a resistor dividor to provide 0-3v range
 const DAC_OUT_V_MAX: ElectricPotential = ElectricPotential {
    dimension: PhantomData,
    units: PhantomData,
    value: 3.0,
 };
 // TODO: -pub
 pub struct Channels {
    channel0: Channel<Channel0>,
@ -39,21 +71,26 @@ impl Channels {
        adc.set_sync_enable(false).unwrap();
        // Setup channels and start ADC
-        adc.setup_channel(0, ad7172::Input::Ain2, ad7172::Input::Ain3).unwrap();
+        adc.setup_channel(0, ad7172::Input::Ain2, ad7172::Input::Ain3)
-        let adc_calibration0 = adc.get_calibration(0)
+            .unwrap();
-            .expect("adc_calibration0");
+        let adc_calibration0 = adc.get_calibration(0).expect("adc_calibration0");
-        adc.setup_channel(1, ad7172::Input::Ain0, ad7172::Input::Ain1).unwrap();
+        adc.setup_channel(1, ad7172::Input::Ain0, ad7172::Input::Ain1)
-        let adc_calibration1 = adc.get_calibration(1)
+            .unwrap();
-            .expect("adc_calibration1");
+        let adc_calibration1 = adc.get_calibration(1).expect("adc_calibration1");
        adc.start_continuous_conversion().unwrap();
        let channel0 = Channel::new(pins.channel0, adc_calibration0);
        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 };
+        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));
        }
@ -72,7 +109,6 @@ impl Channels {
    pub fn poll_adc(&mut self, instant: Instant) -> Option<u8> {
        self.adc.data_ready().unwrap().map(|channel| {
            let data = self.adc.read_data().unwrap();
            let state = self.channel_state(channel);
            state.update(instant, data);
            match state.update_pid() {
@ -94,177 +130,186 @@ impl Channels {
    /// calculate the TEC i_set centerpoint
    pub fn get_center(&mut self, channel: usize) -> ElectricPotential {
        match self.channel_state(channel).center {
-            CenterPoint::Vref => {
+            CenterPoint::VRef => self.adc_read(channel, PinsAdcReadTarget::VRef, 8),
-                let vref = self.read_vref(channel);
+            CenterPoint::Override(center_point) => {
-                self.channel_state(channel).vref = vref;
+                ElectricPotential::new::<volt>(center_point.into())
-                vref
+            }
            },
            CenterPoint::Override(center_point) =>
                ElectricPotential::new::<volt>(center_point.into()),
        }
    }
    /// i_set DAC
-    fn get_dac(&mut self, channel: usize) -> (ElectricPotential, ElectricPotential) {
+    fn get_dac(&mut self, channel: usize) -> ElectricPotential {
        let dac_factor = match channel.into() {
            0 => self.channel0.dac_factor,
            1 => self.channel1.dac_factor,
            _ => unreachable!(),
        };
        let voltage = self.channel_state(channel).dac_value;
-        let max = ElectricPotential::new::<volt>(ad5680::MAX_VALUE as f64 / dac_factor);
+        voltage
        (voltage, max)
    }
-    pub fn get_i(&mut self, channel: usize) -> (ElectricCurrent, ElectricCurrent) {
+    pub fn get_i_set(&mut self, channel: usize) -> ElectricCurrent {
-        let center_point = self.get_center(channel);
+        let i_set = self.channel_state(channel).i_set;
-        let r_sense = ElectricalResistance::new::<ohm>(R_SENSE);
+        i_set
        let (voltage, max) = self.get_dac(channel);
        let i_tec = (voltage - center_point) / (10.0 * r_sense);
        let max = (max - center_point) / (10.0 * r_sense);
        (i_tec, max)
    }
    /// i_set DAC
-    fn set_dac(&mut self, channel: usize, voltage: ElectricPotential) -> (ElectricPotential, ElectricPotential) {
+    fn set_dac(&mut self, channel: usize, voltage: ElectricPotential) -> ElectricPotential {
-        let dac_factor = match channel.into() {
+        let value = ((voltage / DAC_OUT_V_MAX).get::<ratio>() * (ad5680::MAX_VALUE as f64)) as u32;
-            0 => self.channel0.dac_factor,
+        match channel {
            1 => self.channel1.dac_factor,
            _ => unreachable!(),
        };
        let value = (voltage.get::<volt>() * dac_factor) as u32;
        let value = match channel {
            0 => self.channel0.dac.set(value).unwrap(),
            1 => self.channel1.dac.set(value).unwrap(),
            _ => unreachable!(),
        };
        let voltage = ElectricPotential::new::<volt>(value as f64 / dac_factor);
        self.channel_state(channel).dac_value = voltage;
-        let max = ElectricPotential::new::<volt>(ad5680::MAX_VALUE as f64 / dac_factor);
+        voltage
        (voltage, max)
    }
-    pub fn set_i(&mut self, channel: usize, i_tec: ElectricCurrent) -> (ElectricCurrent, ElectricCurrent) {
+    pub fn set_i(&mut self, channel: usize, i_set: ElectricCurrent) -> ElectricCurrent {
-        let center_point = self.get_center(channel);
+        let i_set = i_set.min(MAX_TEC_I).max(-MAX_TEC_I);
        self.channel_state(channel).i_set = i_set;
        let negate = match self.channel_state(channel).polarity {
            Polarity::Normal => 1.0,
            Polarity::Reversed => -1.0,
        };
        let vref_meas = match channel {
            0 => self.channel0.vref_meas,
            1 => self.channel1.vref_meas,
            _ => unreachable!(),
        };
        let center_point = vref_meas;
        let r_sense = ElectricalResistance::new::<ohm>(R_SENSE);
-        let voltage = i_tec * 10.0 * r_sense + center_point;
+        let voltage = negate * i_set * 10.0 * r_sense + center_point;
-        let (voltage, max) = self.set_dac(channel, voltage);
+        let voltage = self.set_dac(channel, voltage);
-        let i_tec = (voltage - center_point) / (10.0 * r_sense);
+
-        let max = (max - center_point) / (10.0 * r_sense);
+        negate * (voltage - center_point) / (10.0 * r_sense)
        (i_tec, max)
    }
-    pub fn read_dac_feedback(&mut self, channel: usize) -> ElectricPotential {
+    /// AN4073: ADC Reading Dispersion can be reduced through Averaging
    pub fn adc_read(
        &mut self,
        channel: usize,
        adc_read_target: PinsAdcReadTarget,
        avg_pt: u16,
    ) -> ElectricPotential {
        let mut sample: u32 = 0;
        match channel {
            0 => {
-                let sample = self.pins_adc.convert(
+                sample = match adc_read_target {
-                    &self.channel0.dac_feedback_pin,
+                    PinsAdcReadTarget::VRef => match &self.channel0.vref_pin {
-                    stm32f4xx_hal::adc::config::SampleTime::Cycles_480
+                        Channel0VRef::Analog(vref_pin) => {
-                );
+                            for _ in (0..avg_pt).rev() {
-                let mv = self.pins_adc.sample_to_millivolts(sample);
+                                sample += self.pins_adc.convert(
                                    vref_pin,
                                    stm32f4xx_hal::adc::config::SampleTime::Cycles_480,
                                ) as u32;
                            }
                            sample / avg_pt as u32
                        }
                        Channel0VRef::Disabled(_) => 2048_u32,
                    },
                    PinsAdcReadTarget::DacVfb => {
                        for _ in (0..avg_pt).rev() {
                            sample += self.pins_adc.convert(
                                &self.channel0.dac_feedback_pin,
                                stm32f4xx_hal::adc::config::SampleTime::Cycles_480,
                            ) as u32;
                        }
                        sample / avg_pt as u32
                    }
                    PinsAdcReadTarget::ITec => {
                        for _ in (0..avg_pt).rev() {
                            sample += self.pins_adc.convert(
                                &self.channel0.itec_pin,
                                stm32f4xx_hal::adc::config::SampleTime::Cycles_480,
                            ) as u32;
                        }
                        sample / avg_pt as u32
                    }
                    PinsAdcReadTarget::VTec => {
                        for _ in (0..avg_pt).rev() {
                            sample += self.pins_adc.convert(
                                &self.channel0.tec_u_meas_pin,
                                stm32f4xx_hal::adc::config::SampleTime::Cycles_480,
                            ) as u32;
                        }
                        sample / avg_pt as u32
                    }
                };
                let mv = self.pins_adc.sample_to_millivolts(sample as u16);
                ElectricPotential::new::<millivolt>(mv as f64)
            }
            1 => {
-                let sample = self.pins_adc.convert(
+                sample = match adc_read_target {
-                    &self.channel1.dac_feedback_pin,
+                    PinsAdcReadTarget::VRef => match &self.channel1.vref_pin {
-                    stm32f4xx_hal::adc::config::SampleTime::Cycles_480
+                        Channel1VRef::Analog(vref_pin) => {
-                );
+                            for _ in (0..avg_pt).rev() {
-                let mv = self.pins_adc.sample_to_millivolts(sample);
+                                sample += self.pins_adc.convert(
                                    vref_pin,
                                    stm32f4xx_hal::adc::config::SampleTime::Cycles_480,
                                ) as u32;
                            }
                            sample / avg_pt as u32
                        }
                        Channel1VRef::Disabled(_) => 2048_u32,
                    },
                    PinsAdcReadTarget::DacVfb => {
                        for _ in (0..avg_pt).rev() {
                            sample += self.pins_adc.convert(
                                &self.channel1.dac_feedback_pin,
                                stm32f4xx_hal::adc::config::SampleTime::Cycles_480,
                            ) as u32;
                        }
                        sample / avg_pt as u32
                    }
                    PinsAdcReadTarget::ITec => {
                        for _ in (0..avg_pt).rev() {
                            sample += self.pins_adc.convert(
                                &self.channel1.itec_pin,
                                stm32f4xx_hal::adc::config::SampleTime::Cycles_480,
                            ) as u32;
                        }
                        sample / avg_pt as u32
                    }
                    PinsAdcReadTarget::VTec => {
                        for _ in (0..avg_pt).rev() {
                            sample += self.pins_adc.convert(
                                &self.channel1.tec_u_meas_pin,
                                stm32f4xx_hal::adc::config::SampleTime::Cycles_480,
                            ) as u32;
                        }
                        sample / avg_pt as u32
                    }
                };
                let mv = self.pins_adc.sample_to_millivolts(sample as u16);
                ElectricPotential::new::<millivolt>(mv as f64)
            }
            _ => unreachable!(),
        }
    }
-    pub fn read_dac_feedback_until_stable(&mut self, channel: usize, tolerance: ElectricPotential) -> ElectricPotential {
+    /// Calibrates the DAC output to match vref of the MAX driver to reduce zero-current offset of the MAX driver output.
        let mut prev = self.read_dac_feedback(channel);
        loop {
            let current = self.read_dac_feedback(channel);
            if (current - prev).abs() < tolerance {
                return current;
            }
            prev = current;
        }
    }
    pub fn read_itec(&mut self, channel: usize) -> ElectricPotential {
        match channel {
            0 => {
                let sample = self.pins_adc.convert(
                    &self.channel0.itec_pin,
                    stm32f4xx_hal::adc::config::SampleTime::Cycles_480
                );
                let mv = self.pins_adc.sample_to_millivolts(sample);
                ElectricPotential::new::<millivolt>(mv as f64)
            }
            1 => {
                let sample = self.pins_adc.convert(
                    &self.channel1.itec_pin,
                    stm32f4xx_hal::adc::config::SampleTime::Cycles_480
                );
                let mv = self.pins_adc.sample_to_millivolts(sample);
                ElectricPotential::new::<millivolt>(mv as f64)
            }
            _ => unreachable!(),
        }
    }
    /// should be 1.5V
    pub fn read_vref(&mut self, channel: usize) -> ElectricPotential {
        match channel {
            0 => {
                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 => {
                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!(),
        }
    }
    pub fn read_tec_u_meas(&mut self, channel: usize) -> ElectricPotential {
        match channel {
            0 => {
                let sample = self.pins_adc.convert(
                    &self.channel0.tec_u_meas_pin,
                    stm32f4xx_hal::adc::config::SampleTime::Cycles_480
                );
                let mv = self.pins_adc.sample_to_millivolts(sample);
                ElectricPotential::new::<millivolt>(mv as f64)
            }
            1 => {
                let sample = self.pins_adc.convert(
                    &self.channel1.tec_u_meas_pin,
                    stm32f4xx_hal::adc::config::SampleTime::Cycles_480
                );
                let mv = self.pins_adc.sample_to_millivolts(sample);
                ElectricPotential::new::<millivolt>(mv as f64)
            }
            _ => unreachable!(),
        }
    }
    /// Calibrate the I_SET DAC using the DAC_FB ADC pin.
    ///
-    /// These loops perform a breadth-first search for the DAC setting
+    /// The thermostat DAC applies a control voltage signal to the CTLI pin of MAX driver chip to control its output current.
-    /// that will produce a `target_voltage`.
+    /// The CTLI input signal is centered around VREF of the MAX chip. Applying VREF to CTLI sets the output current to 0.
    ///
    /// This calibration routine measures the VREF voltage and the DAC output with the STM32 ADC, and uses a breadth-first     
    /// search to find the DAC setting that will produce a DAC output voltage closest to VREF. This DAC output voltage will
    /// be stored and used in subsequent i_set routines to bias the current control signal to the measured VREF, reducing
    /// the offset error of the current control signal.
    ///
    /// The input offset of the STM32 ADC is eliminated by using the same ADC for the measurements, and by only using the
    /// difference in VREF and DAC output for the calibration.
    ///
    /// This routine should be called only once after boot, repeated reading of the vref signal and changing of the stored
    /// VREF measurement can introduce significant noise at the current output, degrading the stabilily performance of the
    /// thermostat.
    pub fn calibrate_dac_value(&mut self, channel: usize) {
-        let target_voltage = ElectricPotential::new::<volt>(2.5);
+        let samples = 50;
        let mut target_voltage = ElectricPotential::new::<volt>(0.0);
        for _ in 0..samples {
            target_voltage += self.get_center(channel);
        }
        target_voltage /= samples as f64;
        let mut start_value = 1;
        let mut best_error = ElectricPotential::new::<volt>(100.0);
-        for step in (0..18).rev() {
+        for step in (5..18).rev() {
            let mut prev_value = start_value;
            for value in (start_value..=ad5680::MAX_VALUE).step_by(1 << step) {
                match channel {
                    0 => {
@ -275,24 +320,23 @@ impl Channels {
                    }
                    _ => unreachable!(),
                }
                sleep(10);
-                let dac_feedback = self.read_dac_feedback_until_stable(channel, ElectricPotential::new::<volt>(0.001));
+                let dac_feedback = self.adc_read(channel, PinsAdcReadTarget::DacVfb, 64);
                let error = target_voltage - dac_feedback;
                if error < ElectricPotential::new::<volt>(0.0) {
                    break;
                } else if error < best_error {
                    best_error = error;
-                    start_value = prev_value;
+                    start_value = value;
-                    let dac_factor = value as f64 / dac_feedback.get::<volt>();
+                    let vref = (value as f64 / ad5680::MAX_VALUE as f64) * DAC_OUT_V_MAX;
                    match channel {
-                        0 => self.channel0.dac_factor = dac_factor,
+                        0 => self.channel0.vref_meas = vref,
-                        1 => self.channel1.dac_factor = dac_factor,
+                        1 => self.channel1.vref_meas = vref,
                        _ => unreachable!(),
                    }
                }
                prev_value = value;
            }
        }
@ -318,176 +362,240 @@ impl Channels {
        }
    }
-    fn get_pwm(&self, channel: usize, pin: PwmPin) -> f64 {
+    pub fn get_max_v(&mut self, channel: usize) -> ElectricPotential {
-        fn get<P: hal::PwmPin<Duty=u16>>(pin: &P) -> f64 {
+        self.channel_state(channel).pwm_limits.max_v
-            let duty = pin.get_duty();
+    }
-            let max = pin.get_max_duty();
+
-            duty as f64 / (max as f64)
+    pub fn get_max_i_pos(&mut self, channel: usize) -> ElectricCurrent {
-        }
+        self.channel_state(channel).pwm_limits.max_i_pos
-        match (channel, pin) {
+    }
-            (_, PwmPin::ISet) =>
+
-                panic!("i_set is no pwm pin"),
+    pub fn get_max_i_neg(&mut self, channel: usize) -> ElectricCurrent {
-            (0, PwmPin::MaxIPos) =>
+        self.channel_state(channel).pwm_limits.max_i_neg
-                get(&self.pwm.max_i_pos0),
+    }
-            (0, PwmPin::MaxINeg) =>
+
-                get(&self.pwm.max_i_neg0),
+    // Get current passing through TEC
-            (0, PwmPin::MaxV) =>
+    pub fn get_tec_i(&mut self, channel: usize) -> ElectricCurrent {
-                get(&self.pwm.max_v0),
+        let tec_i = (self.adc_read(channel, PinsAdcReadTarget::ITec, 16)
-            (1, PwmPin::MaxIPos) =>
+            - self.adc_read(channel, PinsAdcReadTarget::VRef, 16))
-                get(&self.pwm.max_i_pos1),
+            / ElectricalResistance::new::<ohm>(0.4);
-            (1, PwmPin::MaxINeg) =>
+        match self.channel_state(channel).polarity {
-                get(&self.pwm.max_i_neg1),
+            Polarity::Normal => tec_i,
-            (1, PwmPin::MaxV) =>
+            Polarity::Reversed => -tec_i,
                get(&self.pwm.max_v1),
            _ =>
                unreachable!(),
        }
    }
-    pub fn get_max_v(&mut self, channel: usize) -> (ElectricPotential, ElectricPotential) {
+    // Get voltage across TEC
-        let vref = self.channel_state(channel).vref;
+    pub fn get_tec_v(&mut self, channel: usize) -> ElectricPotential {
-        let max = 4.0 * vref;
+        (self.adc_read(channel, PinsAdcReadTarget::VTec, 16) - ElectricPotential::new::<volt>(1.5))
-        let duty = self.get_pwm(channel, PwmPin::MaxV);
+            * 4.0
        (duty * max, max)
    }
    pub fn get_max_i_pos(&mut self, channel: usize) -> (ElectricCurrent, ElectricCurrent) {
        let max = ElectricCurrent::new::<ampere>(3.0);
        let duty = self.get_pwm(channel, PwmPin::MaxIPos);
        (duty * max, max)
    }
    pub fn get_max_i_neg(&mut self, channel: usize) -> (ElectricCurrent, ElectricCurrent) {
        let max = ElectricCurrent::new::<ampere>(3.0);
        let duty = self.get_pwm(channel, PwmPin::MaxINeg);
        (duty * max, max)
    }
    fn set_pwm(&mut self, channel: usize, pin: PwmPin, duty: f64) -> f64 {
-        fn set<P: hal::PwmPin<Duty=u16>>(pin: &mut P, duty: f64) -> f64 {
+        fn set<P: hal::PwmPin<Duty = u16>>(pin: &mut P, duty: f64) -> f64 {
            let max = pin.get_max_duty();
            let value = ((duty * (max as f64)) as u16).min(max);
            pin.set_duty(value);
            value as f64 / (max as f64)
        }
        match (channel, pin) {
-            (_, PwmPin::ISet) =>
+            (_, PwmPin::ISet) => panic!("i_set is no pwm pin"),
-                panic!("i_set is no pwm pin"),
+            (0, PwmPin::MaxIPos) => set(&mut self.pwm.max_i_pos0, duty),
-            (0, PwmPin::MaxIPos) =>
+            (0, PwmPin::MaxINeg) => set(&mut self.pwm.max_i_neg0, duty),
-                set(&mut self.pwm.max_i_pos0, duty),
+            (0, PwmPin::MaxV) => set(&mut self.pwm.max_v0, duty),
-            (0, PwmPin::MaxINeg) =>
+            (1, PwmPin::MaxIPos) => set(&mut self.pwm.max_i_pos1, duty),
-                set(&mut self.pwm.max_i_neg0, duty),
+            (1, PwmPin::MaxINeg) => set(&mut self.pwm.max_i_neg1, duty),
-            (0, PwmPin::MaxV) =>
+            (1, PwmPin::MaxV) => set(&mut self.pwm.max_v1, duty),
-                set(&mut self.pwm.max_v0, duty),
+            _ => unreachable!(),
            (1, PwmPin::MaxIPos) =>
                set(&mut self.pwm.max_i_pos1, duty),
            (1, PwmPin::MaxINeg) =>
                set(&mut self.pwm.max_i_neg1, duty),
            (1, PwmPin::MaxV) =>
                set(&mut self.pwm.max_v1, duty),
            _ =>
                unreachable!(),
        }
    }
-    pub fn set_max_v(&mut self, channel: usize, max_v: ElectricPotential) -> (ElectricPotential, ElectricPotential) {
+    pub fn set_max_v(
-        let vref = self.channel_state(channel).vref;
+        &mut self,
-        let max = 4.0 * vref;
+        channel: usize,
        max_v: ElectricPotential,
    ) -> (ElectricPotential, ElectricPotential) {
        let max = 4.0 * ElectricPotential::new::<volt>(3.3);
        let max_v = max_v.min(MAX_TEC_V).max(ElectricPotential::zero());
        let duty = (max_v / max).get::<ratio>();
        let duty = self.set_pwm(channel, PwmPin::MaxV, duty);
        self.channel_state(channel).pwm_limits.max_v = max_v;
        (duty * max, max)
    }
-    pub fn set_max_i_pos(&mut self, channel: usize, max_i_pos: ElectricCurrent) -> (ElectricCurrent, ElectricCurrent) {
+    pub fn set_max_i_pos(
        &mut self,
        channel: usize,
        max_i_pos: ElectricCurrent,
    ) -> (ElectricCurrent, ElectricCurrent) {
        let max = ElectricCurrent::new::<ampere>(3.0);
-        let duty = (max_i_pos / max).get::<ratio>();
+        let max_i_pos = max_i_pos.min(MAX_TEC_I).max(ElectricCurrent::zero());
-        let duty = self.set_pwm(channel, PwmPin::MaxIPos, duty);
+        let duty = (max_i_pos / MAX_TEC_I_DUTY_TO_CURRENT_RATE).get::<ratio>();
-        (duty * max, max)
+        let duty = match self.channel_state(channel).polarity {
            Polarity::Normal => self.set_pwm(channel, PwmPin::MaxIPos, duty),
            Polarity::Reversed => self.set_pwm(channel, PwmPin::MaxINeg, duty),
        };
        self.channel_state(channel).pwm_limits.max_i_pos = max_i_pos;
        (duty * MAX_TEC_I_DUTY_TO_CURRENT_RATE, max)
    }
-    pub fn set_max_i_neg(&mut self, channel: usize, max_i_neg: ElectricCurrent) -> (ElectricCurrent, ElectricCurrent) {
+    pub fn set_max_i_neg(
        &mut self,
        channel: usize,
        max_i_neg: ElectricCurrent,
    ) -> (ElectricCurrent, ElectricCurrent) {
        let max = ElectricCurrent::new::<ampere>(3.0);
-        let duty = (max_i_neg / max).get::<ratio>();
+        let max_i_neg = max_i_neg.min(MAX_TEC_I).max(ElectricCurrent::zero());
-        let duty = self.set_pwm(channel, PwmPin::MaxINeg, duty);
+        let duty = (max_i_neg / MAX_TEC_I_DUTY_TO_CURRENT_RATE).get::<ratio>();
-        (duty * max, max)
+        let duty = match self.channel_state(channel).polarity {
            Polarity::Normal => self.set_pwm(channel, PwmPin::MaxINeg, duty),
            Polarity::Reversed => self.set_pwm(channel, PwmPin::MaxIPos, duty),
        };
        self.channel_state(channel).pwm_limits.max_i_neg = max_i_neg;
        (duty * MAX_TEC_I_DUTY_TO_CURRENT_RATE, max)
    }
-    pub fn report(&mut self, channel: usize) -> Report {
+    pub fn set_polarity(&mut self, channel: usize, polarity: Polarity) {
-        let vref = self.channel_state(channel).vref;
+        if self.channel_state(channel).polarity != polarity {
-        let (i_set, _) = self.get_i(channel);
+            let i_set = self.channel_state(channel).i_set;
-        let i_tec = self.read_itec(channel);
+            let max_i_pos = self.get_max_i_pos(channel);
-        let tec_i = (i_tec - vref) / ElectricalResistance::new::<ohm>(0.4);
+            let max_i_neg = self.get_max_i_neg(channel);
-        let (dac_value, _) = self.get_dac(channel);
+            self.channel_state(channel).polarity = polarity;
            self.set_i(channel, i_set);
            self.set_max_i_pos(channel, max_i_pos);
            self.set_max_i_neg(channel, max_i_neg);
        }
    }
    fn report(&mut self, channel: usize) -> Report {
        let i_set = self.get_i_set(channel);
        let i_tec = self.adc_read(channel, PinsAdcReadTarget::ITec, 16);
        let tec_i = self.get_tec_i(channel);
        let dac_value = self.get_dac(channel);
        let state = self.channel_state(channel);
-        let pid_output = state.pid.last_output.map(|last_output|
+        let pid_output = ElectricCurrent::new::<ampere>(state.pid.y1);
            ElectricCurrent::new::<ampere>(last_output)
        );
        Report {
            channel,
-            time: state.adc_time.total_millis(),
+            time: state.get_adc_time(),
            interval: state.get_adc_interval(),
            adc: state.get_adc(),
            sens: state.get_sens(),
-            temperature: state.get_temperature()
+            temperature: state
                .get_temperature()
                .map(|temperature| temperature.get::<degree_celsius>()),
            pid_engaged: state.pid_engaged,
            i_set,
            vref,
            dac_value,
-            dac_feedback: self.read_dac_feedback(channel),
+            dac_feedback: self.adc_read(channel, PinsAdcReadTarget::DacVfb, 1),
            i_tec,
            tec_i,
-            tec_u_meas: self.read_tec_u_meas(channel),
+            tec_u_meas: self.get_tec_v(channel),
            pid_output,
        }
    }
-    pub fn pwm_summary(&mut self, channel: usize) -> PwmSummary {
+    pub fn reports_json(&mut self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
-        PwmSummary {
+        let mut reports = Vec::<_, U2>::new();
        for channel in 0..CHANNELS {
            let _ = reports.push(self.report(channel));
        }
        serde_json_core::to_vec(&reports)
    }
    pub fn pid_summaries_json(&mut self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
        let mut summaries = Vec::<_, U2>::new();
        for channel in 0..CHANNELS {
            let _ = summaries.push(self.channel_state(channel).pid.summary(channel));
        }
        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 output_summary(&mut self, channel: usize) -> OutputSummary {
        OutputSummary {
            channel,
            center: CenterPointJson(self.channel_state(channel).center.clone()),
-            i_set: self.get_i(channel).into(),
+            i_set: self.get_i_set(channel),
-            max_v: self.get_max_v(channel).into(),
+            max_v: self.get_max_v(channel),
-            max_i_pos: self.get_max_i_pos(channel).into(),
+            max_i_pos: self.get_max_i_pos(channel),
-            max_i_neg: self.get_max_i_neg(channel).into(),
+            max_i_neg: self.get_max_i_neg(channel),
            polarity: PolarityJson(self.channel_state(channel).polarity.clone()),
        }
    }
-    pub fn postfilter_summary(&mut self, channel: usize) -> PostFilterSummary {
+    pub fn output_summaries_json(&mut self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
-        let rate = self.adc.get_postfilter(channel as u8).unwrap()
+        let mut summaries = Vec::<_, U2>::new();
        for channel in 0..CHANNELS {
            let _ = summaries.push(self.output_summary(channel));
        }
        serde_json_core::to_vec(&summaries)
    }
    fn postfilter_summary(&mut self, channel: usize) -> PostFilterSummary {
        let rate = self
            .adc
            .get_postfilter(channel as u8)
            .unwrap()
            .and_then(|filter| filter.output_rate());
        PostFilterSummary { channel, rate }
    }
-    pub fn steinhart_hart_summary(&mut self, channel: usize) -> SteinhartHartSummary {
+    pub fn postfilter_summaries_json(&mut self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
-        let params = self.channel_state(channel).sh.clone();
+        let mut summaries = Vec::<_, U2>::new();
-        SteinhartHartSummary { channel, params }
+        for channel in 0..CHANNELS {
            let _ = summaries.push(self.postfilter_summary(channel));
        }
        serde_json_core::to_vec(&summaries)
    }
    fn b_parameter_summary(&mut self, channel: usize) -> BParameterSummary {
        let params = self.channel_state(channel).bp.clone();
        BParameterSummary { channel, params }
    }
    pub fn b_parameter_summaries_json(
        &mut self,
    ) -> Result<JsonBuffer, serde_json_core::ser::Error> {
        let mut summaries = Vec::<_, U2>::new();
        for channel in 0..CHANNELS {
            let _ = summaries.push(self.b_parameter_summary(channel));
        }
        serde_json_core::to_vec(&summaries)
    }
    pub fn current_abs_max_tec_i(&mut self) -> ElectricCurrent {
        (0..CHANNELS)
            .map(|channel| self.get_tec_i(channel).abs())
            .max_by(|a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal))
            .unwrap()
    }
 }
 type JsonBuffer = heapless::Vec<u8, heapless::consts::U512>;
 #[derive(Serialize)]
 pub struct Report {
    channel: usize,
-    time: i64,
+    time: Time,
    interval: Time,
    adc: Option<ElectricPotential>,
    sens: Option<ElectricalResistance>,
    temperature: Option<f64>,
    pid_engaged: bool,
    i_set: ElectricCurrent,
    vref: ElectricPotential,
    dac_value: ElectricPotential,
    dac_feedback: ElectricPotential,
    i_tec: ElectricPotential,
    tec_i: ElectricCurrent,
    tec_u_meas: ElectricPotential,
-    pid_output: Option<ElectricCurrent>,
+    pid_output: ElectricCurrent,
 }
 impl Report {
    pub fn to_json(&self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
        serde_json_core::to_vec(self)
    }
 }
 pub struct CenterPointJson(CenterPoint);
@ -499,40 +607,36 @@ impl Serialize for CenterPointJson {
        S: Serializer,
    {
        match self.0 {
-            CenterPoint::Vref =>
+            CenterPoint::VRef => serializer.serialize_str("vref"),
-                serializer.serialize_str("vref"),
+            CenterPoint::Override(vref) => serializer.serialize_f32(vref),
            CenterPoint::Override(vref) =>
                serializer.serialize_f32(vref),
        }
    }
 }
-#[derive(Serialize)]
+pub struct PolarityJson(Polarity);
 pub struct PwmSummaryField<T: Serialize> {
    value: T,
    max: T,
 }
-impl<T: Serialize> From<(T, T)> for PwmSummaryField<T> {
+// used in JSON encoding, not for config
-    fn from((value, max): (T, T)) -> Self {
+impl Serialize for PolarityJson {
-        PwmSummaryField { value, max }
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(match self.0 {
            Polarity::Normal => "normal",
            Polarity::Reversed => "reversed",
        })
    }
 }
 #[derive(Serialize)]
-pub struct PwmSummary {
+pub struct OutputSummary {
    channel: usize,
    center: CenterPointJson,
-    i_set: PwmSummaryField<ElectricCurrent>,
+    i_set: ElectricCurrent,
-    max_v: PwmSummaryField<ElectricPotential>,
+    max_v: ElectricPotential,
-    max_i_pos: PwmSummaryField<ElectricCurrent>,
+    max_i_pos: ElectricCurrent,
-    max_i_neg: PwmSummaryField<ElectricCurrent>,
+    max_i_neg: ElectricCurrent,
-}
+    polarity: PolarityJson,
 impl PwmSummary {
    pub fn to_json(&self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
        serde_json_core::to_vec(self)
    }
 }
 #[derive(Serialize)]
@ -541,79 +645,8 @@ pub struct PostFilterSummary {
    rate: Option<f32>,
 }
 impl PostFilterSummary {
    pub fn to_json(&self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
        serde_json_core::to_vec(self)
    }
 }
 #[derive(Serialize)]
-pub struct SteinhartHartSummary {
+pub struct BParameterSummary {
    channel: usize,
-    params: steinhart_hart::Parameters,
+    params: b_parameter::Parameters,
 }
 impl SteinhartHartSummary {
    pub fn to_json(&self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
        serde_json_core::to_vec(self)
    }
 }
 #[cfg(test)]
 mod test {
    use super::*;
    #[test]
    fn report_to_json() {
        // `/ 1.1` results in values with a really long serialization
        let report = Report {
            channel: 0,
            time: 3200,
            adc: Some(ElectricPotential::new::<volt>(0.65 / 1.1)),
            sens: Some(ElectricalResistance::new::<ohm>(10000.0 / 1.1)),
            temperature: Some(30.0 / 1.1),
            pid_engaged: false,
            i_set: ElectricCurrent::new::<ampere>(0.5 / 1.1),
            vref: ElectricPotential::new::<volt>(1.5 / 1.1),
            dac_value: ElectricPotential::new::<volt>(2.0 / 1.1),
            dac_feedback: ElectricPotential::new::<volt>(2.0 / 1.1),
            i_tec: ElectricPotential::new::<volt>(2.0 / 1.1),
            tec_i: ElectricCurrent::new::<ampere>(0.2 / 1.1),
            tec_u_meas: ElectricPotential::new::<volt>(2.0 / 1.1),
            pid_output: Some(ElectricCurrent::new::<ampere>(0.5 / 1.1)),
        };
        let buf = report.to_json().unwrap();
        assert_eq!(buf[0], b'{');
        assert_eq!(buf[buf.len() - 1], b'}');
    }
    #[test]
    fn pwm_summary_to_json() {
        let value = 1.0 / 1.1;
        let max = 5.0 / 1.1;
        let pwm_summary = PwmSummary {
            channel: 0,
            center: CenterPointJson(CenterPoint::Vref),
            i_set: PwmSummaryField {
                value: ElectricCurrent::new::<ampere>(value),
                max: ElectricCurrent::new::<ampere>(max),
            },
            max_v: PwmSummaryField {
                value: ElectricPotential::new::<volt>(value),
                max: ElectricPotential::new::<volt>(max),
            },
            max_i_pos: PwmSummaryField {
                value: ElectricCurrent::new::<ampere>(value),
                max: ElectricCurrent::new::<ampere>(max),
            },
            max_i_neg: PwmSummaryField {
                value: ElectricCurrent::new::<ampere>(value),
                max: ElectricCurrent::new::<ampere>(max),
            },
        };
        let buf = pwm_summary.to_json().unwrap();
        assert_eq!(buf[0], b'{');
        assert_eq!(buf[buf.len() - 1], b'}');
    }
 }
--- a/src/command_handler.rs
+++ b/src/command_handler.rs
@ -0,0 +1,528 @@
 use super::{
    ad7172,
    channels::{Channels, CHANNELS},
    command_parser::{
        BpParameter, CenterPoint, Command, Ipv4Config, PidParameter, Polarity, PwmPin, ShowCommand,
    },
    config::ChannelConfig,
    dfu,
    flash_store::FlashStore,
    hw_rev::HWRev,
    net, FanCtrl, CHANNEL_CONFIG_KEY,
 };
 use core::fmt::Write;
 use heapless::{consts::U1024, Vec};
 use log::{error, warn};
 use smoltcp::socket::TcpSocket;
 use uom::si::{
    electric_current::ampere,
    electric_potential::volt,
    electrical_resistance::ohm,
    f64::{
        ElectricCurrent, ElectricPotential, ElectricalResistance, TemperatureInterval,
        ThermodynamicTemperature,
    },
    temperature_interval::kelvin,
    thermodynamic_temperature::degree_celsius,
 };
 #[derive(Debug, Clone, PartialEq)]
 pub enum Handler {
    Handled,
    CloseSocket,
    NewIPV4(Ipv4Config),
    Reset,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub enum Error {
    Report,
    PostFilterRate,
    Flash,
 }
 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 {
        // Not enough buffer space, skip report for now,
        // instead of sending incomplete line
        warn!(
            "TCP socket has only {}/{} needed {}",
            send_free + 1,
            socket.send_capacity(),
            data.len(),
        );
    } else {
        match socket.send_slice(data) {
            Ok(sent) if sent == data.len() => {
                let _ = socket.send_slice(b"\n");
                // success
                return true;
            }
            Ok(sent) => warn!("sent only {}/{} bytes", sent, data.len()),
            Err(e) => error!("error sending line: {:?}", e),
        }
    }
    // not success
    false
 }
 impl Handler {
    fn show_report(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
        match channels.reports_json() {
            Ok(buf) => {
                send_line(socket, &buf[..]);
            }
            Err(e) => {
                error!("unable to serialize report: {:?}", e);
                let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
                return Err(Error::Report);
            }
        }
        Ok(Handler::Handled)
    }
    fn show_pid(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
        match channels.pid_summaries_json() {
            Ok(buf) => {
                send_line(socket, &buf);
            }
            Err(e) => {
                error!("unable to serialize pid summary: {:?}", e);
                let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
                return Err(Error::Report);
            }
        }
        Ok(Handler::Handled)
    }
    fn show_pwm(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
        match channels.output_summaries_json() {
            Ok(buf) => {
                send_line(socket, &buf);
            }
            Err(e) => {
                error!("unable to serialize pwm summary: {:?}", e);
                let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
                return Err(Error::Report);
            }
        }
        Ok(Handler::Handled)
    }
    fn show_b_parameter(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
        match channels.b_parameter_summaries_json() {
            Ok(buf) => {
                send_line(socket, &buf);
            }
            Err(e) => {
                error!("unable to serialize b parameter summaries: {:?}", e);
                let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
                return Err(Error::Report);
            }
        }
        Ok(Handler::Handled)
    }
    fn show_post_filter(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
        match channels.postfilter_summaries_json() {
            Ok(buf) => {
                send_line(socket, &buf);
            }
            Err(e) => {
                error!("unable to serialize postfilter summary: {:?}", e);
                let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
                return Err(Error::Report);
            }
        }
        Ok(Handler::Handled)
    }
    fn show_ipv4(socket: &mut TcpSocket, ipv4_config: &mut Ipv4Config) -> Result<Handler, Error> {
        let (cidr, gateway) = net::split_ipv4_config(ipv4_config.clone());
        let _ = write!(socket, "{{\"addr\":\"{}\"", cidr);
        gateway.map(|gateway| write!(socket, ",\"gateway\":\"{}\"", gateway));
        let _ = writeln!(socket, "}}");
        Ok(Handler::Handled)
    }
    fn engage_pid(
        socket: &mut TcpSocket,
        channels: &mut Channels,
        channel: usize,
    ) -> Result<Handler, Error> {
        channels.channel_state(channel).pid_engaged = true;
        send_line(socket, b"{}");
        Ok(Handler::Handled)
    }
    fn set_polarity(
        socket: &mut TcpSocket,
        channels: &mut Channels,
        channel: usize,
        polarity: Polarity,
    ) -> Result<Handler, Error> {
        channels.set_polarity(channel, polarity);
        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> {
        match pin {
            PwmPin::ISet => {
                channels.channel_state(channel).pid_engaged = false;
                let current = ElectricCurrent::new::<ampere>(value);
                channels.set_i(channel, current);
                channels.power_up(channel);
            }
            PwmPin::MaxV => {
                let voltage = ElectricPotential::new::<volt>(value);
                channels.set_max_v(channel, voltage);
            }
            PwmPin::MaxIPos => {
                let current = ElectricCurrent::new::<ampere>(value);
                channels.set_max_i_pos(channel, current);
            }
            PwmPin::MaxINeg => {
                let current = ElectricCurrent::new::<ampere>(value);
                channels.set_max_i_neg(channel, current);
            }
        }
        send_line(socket, b"{}");
        Ok(Handler::Handled)
    }
    fn set_center_point(
        socket: &mut TcpSocket,
        channels: &mut Channels,
        channel: usize,
        center: CenterPoint,
    ) -> Result<Handler, Error> {
        let i_set = channels.get_i_set(channel);
        let state = channels.channel_state(channel);
        state.center = center;
        if !state.pid_engaged {
            channels.set_i(channel, i_set);
        }
        send_line(socket, b"{}");
        Ok(Handler::Handled)
    }
    fn set_pid(
        socket: &mut TcpSocket,
        channels: &mut Channels,
        channel: usize,
        parameter: PidParameter,
        value: f64,
    ) -> Result<Handler, Error> {
        let pid = &mut channels.channel_state(channel).pid;
        use super::command_parser::PidParameter::*;
        match parameter {
            Target => pid.target = value,
            KP => pid.parameters.kp = value as f32,
            KI => pid.update_ki(value as f32),
            KD => pid.parameters.kd = value as f32,
            OutputMin => pid.parameters.output_min = value as f32,
            OutputMax => pid.parameters.output_max = value as f32,
        }
        send_line(socket, b"{}");
        Ok(Handler::Handled)
    }
    fn set_b_parameter(
        socket: &mut TcpSocket,
        channels: &mut Channels,
        channel: usize,
        parameter: BpParameter,
        value: f64,
    ) -> Result<Handler, Error> {
        let bp = &mut channels.channel_state(channel).bp;
        use super::command_parser::BpParameter::*;
        match parameter {
            T0 => bp.t0 = ThermodynamicTemperature::new::<degree_celsius>(value),
            B => bp.b = TemperatureInterval::new::<kelvin>(value),
            R0 => bp.r0 = ElectricalResistance::new::<ohm>(value),
        }
        send_line(socket, b"{}");
        Ok(Handler::Handled)
    }
    fn reset_post_filter(
        socket: &mut TcpSocket,
        channels: &mut Channels,
        channel: usize,
    ) -> Result<Handler, Error> {
        channels.adc.set_postfilter(channel as u8, None).unwrap();
        send_line(socket, b"{}");
        Ok(Handler::Handled)
    }
    fn set_post_filter(
        socket: &mut TcpSocket,
        channels: &mut Channels,
        channel: usize,
        rate: f32,
    ) -> Result<Handler, Error> {
        let filter = ad7172::PostFilter::closest(rate);
        match filter {
            Some(filter) => {
                channels
                    .adc
                    .set_postfilter(channel as u8, Some(filter))
                    .unwrap();
                send_line(socket, b"{}");
            }
            None => {
                error!("unable to choose postfilter for rate {:.3}", rate);
                send_line(
                    socket,
                    b"{{\"error\": \"unable to choose postfilter rate\"}}",
                );
                return Err(Error::PostFilterRate);
            }
        }
        Ok(Handler::Handled)
    }
    fn load_channel(
        socket: &mut TcpSocket,
        channels: &mut Channels,
        store: &mut FlashStore,
        channel: Option<usize>,
    ) -> Result<Handler, Error> {
        for (c, key) in CHANNEL_CONFIG_KEY.iter().enumerate().take(CHANNELS) {
            if channel.is_none() || channel == Some(c) {
                match store.read_value::<ChannelConfig>(key) {
                    Ok(Some(config)) => {
                        config.apply(channels, c);
                        send_line(socket, b"{}");
                    }
                    Ok(None) => {
                        error!("flash config not found");
                        send_line(socket, b"{{\"error\": \"flash config not found\"}}");
                    }
                    Err(e) => {
                        error!("unable to load config from flash: {:?}", e);
                        let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
                        return Err(Error::Flash);
                    }
                }
            }
        }
        Ok(Handler::Handled)
    }
    fn save_channel(
        socket: &mut TcpSocket,
        channels: &mut Channels,
        channel: Option<usize>,
        store: &mut FlashStore,
    ) -> Result<Handler, Error> {
        for (c, key) in CHANNEL_CONFIG_KEY.iter().enumerate().take(CHANNELS) {
            let mut store_value_buf = [0u8; 256];
            if channel.is_none() || channel == Some(c) {
                let config = ChannelConfig::new(channels, c);
                match store.write_value(key, &config, &mut store_value_buf) {
                    Ok(()) => {
                        send_line(socket, b"{}");
                    }
                    Err(e) => {
                        error!("unable to save channel {} config to flash: {:?}", c, e);
                        let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
                        return Err(Error::Flash);
                    }
                }
            }
        }
        Ok(Handler::Handled)
    }
    fn set_ipv4(
        socket: &mut TcpSocket,
        store: &mut FlashStore,
        config: Ipv4Config,
    ) -> Result<Handler, Error> {
        let _ = store
            .write_value("ipv4", &config, [0; 16])
            .map_err(|e| error!("unable to save ipv4 config to flash: {:?}", e));
        let new_ipv4_config = Some(config);
        send_line(socket, b"{}");
        Ok(Handler::NewIPV4(new_ipv4_config.unwrap()))
    }
    fn reset(channels: &mut Channels) -> Result<Handler, Error> {
        for i in 0..CHANNELS {
            channels.power_down(i);
        }
        // should_reset = true;
        Ok(Handler::Reset)
    }
    fn dfu(channels: &mut Channels) -> Result<Handler, Error> {
        for i in 0..CHANNELS {
            channels.power_down(i);
        }
        unsafe {
            dfu::set_dfu_trigger();
        }
        // should_reset = true;
        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 a 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::Report)
            }
        }
    }
    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 a 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::Report)
            }
        }
    }
    pub fn handle_command(
        command: Command,
        socket: &mut TcpSocket,
        channels: &mut Channels,
        store: &mut FlashStore,
        ipv4_config: &mut Ipv4Config,
        fan_ctrl: &mut FanCtrl,
        hwrev: HWRev,
    ) -> Result<Self, Error> {
        match command {
            Command::Quit => Ok(Handler::CloseSocket),
            Command::Show(ShowCommand::Input) => Handler::show_report(socket, channels),
            Command::Show(ShowCommand::Pid) => Handler::show_pid(socket, channels),
            Command::Show(ShowCommand::Output) => Handler::show_pwm(socket, channels),
            Command::Show(ShowCommand::BParameter) => Handler::show_b_parameter(socket, channels),
            Command::Show(ShowCommand::PostFilter) => Handler::show_post_filter(socket, channels),
            Command::Show(ShowCommand::Ipv4) => Handler::show_ipv4(socket, ipv4_config),
            Command::OutputPid { channel } => Handler::engage_pid(socket, channels, channel),
            Command::OutputPolarity { channel, polarity } => {
                Handler::set_polarity(socket, channels, channel, polarity)
            }
            Command::Output {
                channel,
                pin,
                value,
            } => Handler::set_pwm(socket, channels, 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::BParameter {
                channel,
                parameter,
                value,
            } => Handler::set_b_parameter(socket, channels, channel, parameter, value),
            Command::PostFilter {
                channel,
                rate: None,
            } => Handler::reset_post_filter(socket, channels, channel),
            Command::PostFilter {
                channel,
                rate: Some(rate),
            } => Handler::set_post_filter(socket, channels, channel, rate),
            Command::Load { channel } => Handler::load_channel(socket, channels, store, channel),
            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),
        }
    }
 }
--- a/src/command_parser.rs
+++ b/src/command_parser.rs
--- a/src/config.rs
+++ b/src/config.rs
@ -1,102 +1,23 @@
 use postcard::{from_bytes, to_slice};
 use serde::{Serialize, Deserialize};
 use smoltcp::wire::Ipv4Address;
 use stm32f4xx_hal::i2c;
 use uom::si::{
    electric_potential::volt,
    electric_current::ampere,
    electrical_resistance::ohm,
    f64::{ElectricCurrent, ElectricPotential, ElectricalResistance, ThermodynamicTemperature},
    thermodynamic_temperature::degree_celsius,
 };
 use crate::{
    ad7172::PostFilter,
-    channels::{CHANNELS, Channels},
+    b_parameter,
-    command_parser::CenterPoint,
+    channels::Channels,
-    EEPROM_SIZE, EEPROM_PAGE_SIZE,
+    command_parser::{CenterPoint, Polarity},
    pid,
    pins,
    steinhart_hart,
 };
-
+use num_traits::Zero;
-#[derive(Debug)]
+use serde::{Deserialize, Serialize};
-pub enum Error {
+use uom::si::f64::{ElectricCurrent, ElectricPotential};
    Eeprom(eeprom24x::Error<i2c::Error>),
    Encode(postcard::Error),
 }
 impl From<eeprom24x::Error<i2c::Error>> for Error {
    fn from(e: eeprom24x::Error<i2c::Error>) -> Self {
        Error::Eeprom(e)
    }
 }
 impl From<postcard::Error> for Error {
    fn from(e: postcard::Error) -> Self {
        Error::Encode(e)
    }
 }
 /// Just for encoding/decoding, actual state resides in ChannelState
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 pub struct Config {
    channels: [ChannelConfig; CHANNELS],
    pub ipv4_address: [u8; 4],
 }
 impl Config {
    pub fn new(channels: &mut Channels, ipv4_address: Ipv4Address) -> Self {
        Config {
            channels: [
                ChannelConfig::new(channels, 0),
                ChannelConfig::new(channels, 1),
            ],
            ipv4_address: ipv4_address.0,
        }
    }
    /// apply loaded config to system
    pub fn apply(&self, channels: &mut Channels) {
        for i in 0..CHANNELS {
            self.channels[i].apply(channels, i);
        }
    }
    pub fn load(eeprom: &mut pins::Eeprom) -> Result<Self, Error> {
        let mut buffer = [0; EEPROM_SIZE];
        eeprom.read_data(0, &mut buffer)?;
        log::info!("load: {:?}", buffer);
        let config = from_bytes(&mut buffer)?;
        Ok(config)
    }
    pub fn save(&self, eeprom: &mut pins::Eeprom) -> Result<(), Error> {
        let mut buffer = [0; EEPROM_SIZE];
        let config_buffer = to_slice(self, &mut buffer)?;
        log::info!("save: {:?}", config_buffer);
        let mut addr = 0;
        for chunk in config_buffer.chunks(EEPROM_PAGE_SIZE) {
            'write_retry: loop {
                match eeprom.write_page(addr, chunk) {
                    Ok(()) => break 'write_retry,
                    Err(eeprom24x::Error::I2C(i2c::Error::NACK)) => {},
                    Err(e) => Err(e)?,
                }
            }
            addr += chunk.len() as u32;
        }
        Ok(())
    }
 }
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct ChannelConfig {
    center: CenterPoint,
    pid: pid::Parameters,
    pid_target: f32,
-    sh: SteinhartHartConfig,
+    pid_engaged: bool,
    i_set: ElectricCurrent,
    polarity: Polarity,
    bp: b_parameter::Parameters,
    pwm: PwmLimits,
    /// uses variant `PostFilter::Invalid` instead of `None` to save space
    adc_postfilter: PostFilter,
@ -106,16 +27,26 @@ impl ChannelConfig {
    pub fn new(channels: &mut Channels, channel: usize) -> Self {
        let pwm = PwmLimits::new(channels, channel);
-        let adc_postfilter = channels.adc.get_postfilter(channel as u8)
+        let adc_postfilter = channels
            .adc
            .get_postfilter(channel as u8)
            .unwrap()
            .unwrap_or(PostFilter::Invalid);
        let state = channels.channel_state(channel);
        let i_set = if state.pid_engaged {
            ElectricCurrent::zero()
        } else {
            state.i_set
        };
        ChannelConfig {
            center: state.center.clone(),
            pid: state.pid.parameters.clone(),
            pid_target: state.pid.target as f32,
-            sh: (&state.sh).into(),
+            pid_engaged: state.pid_engaged,
            i_set,
            polarity: state.polarity.clone(),
            bp: state.bp.clone(),
            pwm,
            adc_postfilter,
        }
@ -126,7 +57,8 @@ impl ChannelConfig {
        state.center = self.center.clone();
        state.pid.parameters = self.pid.clone();
        state.pid.target = self.pid_target.into();
-        state.sh = (&self.sh).into();
+        state.pid_engaged = self.pid_engaged;
        state.bp = self.bp.clone();
        self.pwm.apply(channels, channel);
@ -135,119 +67,33 @@ impl ChannelConfig {
            adc_postfilter => Some(adc_postfilter),
        };
        let _ = channels.adc.set_postfilter(channel as u8, adc_postfilter);
        let _ = channels.set_i(channel, self.i_set);
        channels.set_polarity(channel, self.polarity.clone());
    }
 }
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-struct SteinhartHartConfig {
+pub struct PwmLimits {
-    t0: f32,
+    pub max_v: ElectricPotential,
-    r0: f32,
+    pub max_i_pos: ElectricCurrent,
-    b: f32,
+    pub max_i_neg: ElectricCurrent,
 }
 impl From<&steinhart_hart::Parameters> for SteinhartHartConfig {
    fn from(sh: &steinhart_hart::Parameters) -> Self {
        SteinhartHartConfig {
            t0: sh.t0.get::<degree_celsius>() as f32,
            r0: sh.r0.get::<ohm>() as f32,
            b: sh.b as f32,
        }
    }
 }
 impl Into<steinhart_hart::Parameters> for &SteinhartHartConfig {
    fn into(self) -> steinhart_hart::Parameters {
        steinhart_hart::Parameters {
            t0: ThermodynamicTemperature::new::<degree_celsius>(self.t0.into()),
            r0: ElectricalResistance::new::<ohm>(self.r0.into()),
            b: self.b.into(),
        }
    }
 }
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 struct PwmLimits {
    max_v: f32,
    max_i_pos: f32,
    max_i_neg: f32,
 }
 impl PwmLimits {
    pub fn new(channels: &mut Channels, channel: usize) -> Self {
-        let (max_v, _) = channels.get_max_v(channel);
+        let max_v = channels.get_max_v(channel);
-        let (max_i_pos, _) = channels.get_max_i_pos(channel);
+        let max_i_pos = channels.get_max_i_pos(channel);
-        let (max_i_neg, _) = channels.get_max_i_neg(channel);
+        let max_i_neg = channels.get_max_i_neg(channel);
        PwmLimits {
-            max_v: max_v.get::<volt>() as f32,
+            max_v,
-            max_i_pos: max_i_pos.get::<ampere>() as f32,
+            max_i_pos,
-            max_i_neg: max_i_neg.get::<ampere>() as f32,
+            max_i_neg,
        }
    }
    pub fn apply(&self, channels: &mut Channels, channel: usize) {
-        channels.set_max_v(channel, ElectricPotential::new::<volt>(self.max_v.into()));
+        channels.set_max_v(channel, self.max_v);
-        channels.set_max_i_pos(channel, ElectricCurrent::new::<ampere>(self.max_i_pos.into()));
+        channels.set_max_i_pos(channel, self.max_i_pos);
-        channels.set_max_i_neg(channel, ElectricCurrent::new::<ampere>(self.max_i_neg.into()));
+        channels.set_max_i_neg(channel, self.max_i_neg);
    }
 }
 #[cfg(test)]
 mod test {
    use super::*;
    use crate::DEFAULT_IPV4_ADDRESS;
    #[test]
    fn test_fit_eeprom() {
        let channel_config = ChannelConfig {
            center: CenterPoint::Override(1.5),
            pid: pid::Parameters::default(),
            pid_target: 93.7,
            sh: (&steinhart_hart::Parameters::default()).into(),
            pwm: PwmLimits {
                max_v: 1.65,
                max_i_pos: 2.1,
                max_i_neg: 2.25,
            },
            adc_postfilter: PostFilter::F21SPS,
        };
        let config = Config {
            channels: [
                channel_config.clone(),
                channel_config.clone(),
            ],
            ipv4_address: DEFAULT_IPV4_ADDRESS.0,
        };
        let mut buffer = [0; EEPROM_SIZE];
        let buffer = to_slice(&config, &mut buffer).unwrap();
        assert!(buffer.len() <= EEPROM_SIZE);
    }
    #[test]
    fn test_encode_decode() {
        let channel_config = ChannelConfig {
            center: CenterPoint::Override(1.5),
            pid: pid::Parameters::default(),
            pid_target: 93.7,
            sh: (&steinhart_hart::Parameters::default()).into(),
            pwm: PwmLimits {
                max_v: 1.65,
                max_i_pos: 2.1,
                max_i_neg: 2.25,
            },
            adc_postfilter: PostFilter::F21SPS,
        };
        let config = Config {
            channels: [
                channel_config.clone(),
                channel_config.clone(),
            ],
            ipv4_address: DEFAULT_IPV4_ADDRESS.0,
        };
        let mut buffer = [0; EEPROM_SIZE];
        to_slice(&config, &mut buffer).unwrap();
        let decoded: Config = from_bytes(&buffer).unwrap();
        assert_eq!(decoded, config);
    }
 }
--- a/src/dfu.rs
+++ b/src/dfu.rs
@ -0,0 +1,46 @@
 use core::arch::asm;
 use cortex_m_rt::pre_init;
 use stm32f4xx_hal::stm32::{RCC, SYSCFG};
 const DFU_TRIG_MSG: u32 = 0xDECAFBAD;
 extern "C" {
    // This symbol comes from memory.x
    static mut _dfu_msg: u32;
 }
 pub unsafe fn set_dfu_trigger() {
    _dfu_msg = DFU_TRIG_MSG;
 }
 /// Called by reset handler in lib.rs immediately after reset.
 /// This function should not be called outside of reset handler as
 /// bootloader expects MCU to be in reset state when called.
 #[cfg(target_arch = "arm")]
 #[pre_init]
 unsafe fn __pre_init() {
    if _dfu_msg == DFU_TRIG_MSG {
        _dfu_msg = 0x00000000;
        // Enable system config controller clock
        let rcc = &*RCC::ptr();
        rcc.apb2enr.modify(|_, w| w.syscfgen().set_bit());
        // Bypass BOOT pins and remap bootloader to 0x00000000
        let syscfg = &*SYSCFG::ptr();
        syscfg.memrm.write(|w| w.mem_mode().bits(0b01));
        // Impose instruction and memory barriers
        cortex_m::asm::isb();
        cortex_m::asm::dsb();
        asm!(
            // Set stack pointer to bootloader location
            "LDR R0, =0x1FFF0000",
            "LDR SP,[R0, #0]",
            // Jump to bootloader
            "LDR R0,[R0, #4]",
            "BX R0",
        );
    }
 }
--- a/src/fan_ctrl.rs
+++ b/src/fan_ctrl.rs
@ -0,0 +1,162 @@
 use crate::{channels::MAX_TEC_I, command_handler::JsonBuffer, hw_rev::HWSettings};
 use num_traits::Float;
 use serde::Serialize;
 use stm32f4xx_hal::{
    pac::TIM8,
    pwm::{self, PwmChannels},
 };
 use uom::si::{electric_current::ampere, f64::ElectricCurrent};
 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.get::<ampere>() 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.clamp(MIN_USER_FAN_PWM as u32, MAX_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,
 }
--- a/src/flash_store.rs
+++ b/src/flash_store.rs
@ -0,0 +1,69 @@
 use log::{error, info};
 use sfkv::{Store, StoreBackend};
 use stm32f4xx_hal::{
    flash::{Error, FlashExt},
    stm32::FLASH,
 };
 /// 16 KiB
 pub const FLASH_SECTOR_SIZE: usize = 0x4000;
 pub const FLASH_SECTOR: u8 = 12;
 static mut BACKUP_SPACE: [u8; FLASH_SECTOR_SIZE] = [0; FLASH_SECTOR_SIZE];
 extern "C" {
    // These are from memory.x
    static _config_start: usize;
    static _flash_start: usize;
 }
 pub struct FlashBackend {
    flash: FLASH,
 }
 fn get_offset() -> usize {
    unsafe { (&_config_start as *const usize as usize) - (&_flash_start as *const usize as usize) }
 }
 impl StoreBackend for FlashBackend {
    type Data = [u8];
    fn data(&self) -> &Self::Data {
        &self.flash.read()[get_offset()..(get_offset() + FLASH_SECTOR_SIZE)]
    }
    type Error = Error;
    fn erase(&mut self) -> Result<(), Self::Error> {
        info!("erasing store flash");
        self.flash.unlocked().erase(FLASH_SECTOR)
    }
    fn program(&mut self, offset: usize, payload: &[u8]) -> Result<(), Self::Error> {
        self.flash
            .unlocked()
            .program(get_offset() + offset, payload.iter())
    }
    fn backup_space(&self) -> &'static mut [u8] {
        unsafe { &mut BACKUP_SPACE }
    }
 }
 pub type FlashStore = Store<FlashBackend>;
 pub fn store(flash: FLASH) -> FlashStore {
    let backend = FlashBackend { flash };
    let mut store = FlashStore::new(backend);
    // just try to read the store
    match store.get_bytes_used() {
        Ok(_) => {}
        Err(e) => {
            error!("corrupt store, erasing. error: {:?}", e);
            let _ = store
                .erase()
                .map_err(|e| error!("flash erase failed: {:?}", e));
        }
    }
    store
 }
--- a/src/hw_rev.rs
+++ b/src/hw_rev.rs
@ -0,0 +1,86 @@
 use serde::Serialize;
 use crate::{command_handler::JsonBuffer, pins::HWRevPins};
 #[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)
    }
 }
--- a/src/init_log.rs
+++ b/src/init_log.rs
@ -1,3 +1,4 @@
 #[cfg(not(feature = "semihosting"))]
 use crate::usb;
 #[cfg(not(feature = "semihosting"))]
@ -9,17 +10,15 @@ pub fn init_log() {
 #[cfg(feature = "semihosting")]
 pub fn init_log() {
    use cortex_m_log::log::{init, Logger};
    use cortex_m_log::printer::semihosting::{hio::HStdout, InterruptOk};
    use log::LevelFilter;
    use cortex_m_log::log::{Logger, init};
    use cortex_m_log::printer::semihosting::{InterruptOk, hio::HStdout};
    static mut LOGGER: Option<Logger<InterruptOk<HStdout>>> = None;
    let logger = Logger {
        inner: InterruptOk::<_>::stdout().expect("semihosting stdout"),
        level: LevelFilter::Info,
    };
-    let logger = unsafe {
+    let logger = unsafe { LOGGER.get_or_insert(logger) };
        LOGGER.get_or_insert(logger)
    };
    init(logger).expect("set logger");
 }
--- a/src/leds.rs
+++ b/src/leds.rs
@ -1,6 +1,6 @@
 use stm32f4xx_hal::{
    gpio::{
-        gpiod::{PD9, PD10, PD11},
+        gpiod::{PD10, PD11, PD9},
        Output, PushPull,
    },
    hal::digital::v2::OutputPin,
--- a/src/main.rs
+++ b/src/main.rs
@ -1,71 +1,56 @@
 #![cfg_attr(not(test), no_std)]
 #![cfg_attr(not(test), no_main)]
 #![feature(maybe_uninit_extra, maybe_uninit_ref)]
 #![cfg_attr(test, allow(unused))]
 // TODO: #![deny(warnings, unused)]
 #[cfg(not(any(feature = "semihosting", test)))]
-use panic_abort as _;
+use panic_halt as _;
 #[cfg(all(feature = "semihosting", not(test)))]
 use panic_semihosting as _;
 use log::{error, info, warn};
 use core::fmt::Write;
 use cortex_m::asm::wfi;
 use cortex_m_rt::entry;
 use log::{error, info, warn};
 use smoltcp::{socket::TcpSocket, time::Instant, wire::EthernetAddress};
 use stm32f4xx_hal::{
-    hal::watchdog::{WatchdogEnable, Watchdog},
+    hal::watchdog::{Watchdog, WatchdogEnable},
    rcc::RccExt,
    watchdog::IndependentWatchdog,
    time::{U32Ext, MegaHertz},
    stm32::{CorePeripherals, Peripherals, SCB},
-};
+    time::{MegaHertz, U32Ext},
-use smoltcp::{
+    watchdog::IndependentWatchdog,
    time::Instant,
    socket::TcpSocket,
    wire::{EthernetAddress, Ipv4Address},
 };
 use uom::{
    si::{
        f64::{
            ElectricCurrent,
            ElectricPotential,
            ElectricalResistance,
            ThermodynamicTemperature,
        },
        electric_current::ampere,
        electric_potential::volt,
        electrical_resistance::ohm,
        thermodynamic_temperature::degree_celsius,
    },
 };
 mod init_log;
 use init_log::init_log;
 mod usb;
 mod leds;
 mod pins;
 mod usb;
 use pins::Pins;
 mod ad7172;
 mod ad5680;
 mod ad7172;
 mod net;
 mod server;
 use server::Server;
 mod session;
 use session::{Session, SessionInput};
 mod command_parser;
-use command_parser::{Command, ShowCommand, PwmPin};
+use command_parser::Ipv4Config;
-mod timer;
+mod b_parameter;
 mod pid;
 mod steinhart_hart;
 mod channels;
-use channels::{CHANNELS, Channels};
+mod pid;
 mod timer;
 use channels::{Channels, CHANNELS};
 mod channel;
 mod channel_state;
 mod config;
-use config::Config;
+use config::ChannelConfig;
-
+mod command_handler;
 mod dfu;
 mod flash_store;
 use command_handler::Handler;
 mod fan_ctrl;
 use fan_ctrl::FanCtrl;
 mod hw_rev;
 const HSE: MegaHertz = MegaHertz(8);
 #[cfg(not(feature = "semihosting"))]
@ -73,49 +58,36 @@ const WATCHDOG_INTERVAL: u32 = 1_000;
 #[cfg(feature = "semihosting")]
 const WATCHDOG_INTERVAL: u32 = 30_000;
-pub const EEPROM_PAGE_SIZE: usize = 8;
+const CHANNEL_CONFIG_KEY: [&str; 2] = ["ch0", "ch1"];
 pub const EEPROM_SIZE: usize = 128;
 pub const DEFAULT_IPV4_ADDRESS: Ipv4Address = Ipv4Address([192, 168, 1, 26]);
 const TCP_PORT: u16 = 23;
 fn send_line(socket: &mut TcpSocket, data: &[u8]) -> bool {
    let send_free = socket.send_capacity() - socket.send_queue();
    if data.len() > send_free + 1 {
-        // Not enough buffer space, skip report for now
+        // Not enough buffer space, skip report for now,
        // instead of sending incomplete line
        warn!(
            "TCP socket has only {}/{} needed {}",
-            send_free + 1, socket.send_capacity(), data.len(),
+            send_free + 1,
            socket.send_capacity(),
            data.len(),
        );
    } else {
-        match socket.send_slice(&data) {
+        match socket.send_slice(data) {
            Ok(sent) if sent == data.len() => {
                let _ = socket.send_slice(b"\n");
                // success
-                return true
+                return true;
            }
-            Ok(sent) =>
+            Ok(sent) => warn!("sent only {}/{} bytes", sent, data.len()),
-                warn!("sent only {}/{} bytes", sent, data.len()),
+            Err(e) => error!("error sending line: {:?}", e),
            Err(e) =>
                error!("error sending line: {:?}", e),
        }
    }
    // not success
    false
 }
 fn report_to(channel: usize, channels: &mut Channels, socket: &mut TcpSocket) -> bool {
    match channels.report(channel).to_json() {
        Ok(buf) =>
            send_line(socket, &buf[..]),
        Err(e) => {
            error!("unable to serialize report: {:?}", e);
            false
        }
    }
 }
 /// Initialization and main loop
 #[cfg(not(test))]
 #[entry]
@ -128,7 +100,9 @@ fn main() -> ! {
    cp.SCB.enable_dcache(&mut cp.CPUID);
    let dp = Peripherals::take().unwrap();
-    let clocks = dp.RCC.constrain()
+    let clocks = dp
        .RCC
        .constrain()
        .cfgr
        .use_hse(HSE)
        .sysclk(168.mhz())
@ -143,15 +117,16 @@ fn main() -> ! {
    timer::setup(cp.SYST, clocks);
-    let (pins, mut leds, mut eeprom, eth_pins, usb) = Pins::setup(
+    let (pins, mut leds, mut eeprom, eth_pins, usb, fan, hwrev, hw_settings) = Pins::setup(
-        clocks, dp.TIM1, dp.TIM3,
+        clocks,
-        dp.GPIOA, dp.GPIOB, dp.GPIOC, dp.GPIOD, dp.GPIOE, dp.GPIOF, dp.GPIOG,
+        (dp.TIM1, dp.TIM3, dp.TIM8),
        (
            dp.GPIOA, dp.GPIOB, dp.GPIOC, dp.GPIOD, dp.GPIOE, dp.GPIOF, dp.GPIOG,
        ),
        dp.I2C1,
-        dp.SPI2, dp.SPI4, dp.SPI5,
+        (dp.SPI2, dp.SPI4, dp.SPI5),
        dp.ADC1,
-        dp.OTG_FS_GLOBAL,
+        (dp.OTG_FS_GLOBAL, dp.OTG_FS_DEVICE, dp.OTG_FS_PWRCLK),
        dp.OTG_FS_DEVICE,
        dp.OTG_FS_PWRCLK,
    );
    leds.r1.on();
@ -160,15 +135,30 @@ fn main() -> ! {
    usb::State::setup(usb);
-    let mut ipv4_address = DEFAULT_IPV4_ADDRESS;
+    let mut store = flash_store::store(dp.FLASH);
    let mut channels = Channels::new(pins);
-    let _ = Config::load(&mut eeprom)
+    for (c, key) in CHANNEL_CONFIG_KEY.iter().enumerate().take(CHANNELS) {
-        .map(|config| {
+        match store.read_value::<ChannelConfig>(key) {
-            config.apply(&mut channels);
+            Ok(Some(config)) => config.apply(&mut channels, c),
-            ipv4_address = Ipv4Address::from_bytes(&config.ipv4_address);
+            Ok(None) => error!("flash config not found for channel {}", c),
-        })
+            Err(e) => error!("unable to load config {} from flash: {:?}", c, e),
-        .map_err(|e| warn!("error loading config: {:?}", e));
+        }
-    info!("IPv4 address: {}", ipv4_address);
+    }
    let mut fan_ctrl = FanCtrl::new(fan, hw_settings);
    // default net config:
    let mut ipv4_config = Ipv4Config {
        address: [192, 168, 1, 26],
        mask_len: 24,
        gateway: None,
    };
    match store.read_value("ipv4") {
        Ok(Some(config)) => ipv4_config = config,
        Ok(None) => {}
        Err(e) => error!("cannot read ipv4 config: {:?}", e),
    }
    // EEPROM ships with a read-only EUI-48 identifier
    let mut eui48 = [0; 6];
@ -176,237 +166,115 @@ fn main() -> ! {
    let hwaddr = EthernetAddress(eui48);
    info!("EEPROM MAC address: {}", hwaddr);
-    net::run(clocks, dp.ETHERNET_MAC, dp.ETHERNET_DMA, eth_pins, hwaddr, ipv4_address, |iface| {
+    net::run(
-        let mut new_ipv4_address = None;
+        clocks,
-        Server::<Session>::run(iface, |server| {
+        dp.ETHERNET_MAC,
-            leds.r1.off();
+        dp.ETHERNET_DMA,
        eth_pins,
        hwaddr,
        ipv4_config.clone(),
        |iface| {
            Server::<Session>::run(iface, |server| {
                leds.r1.off();
                let mut should_reset = false;
-            loop {
+                loop {
-                let instant = Instant::from_millis(i64::from(timer::now()));
+                    let mut new_ipv4_config = None;
-                let updated_channel = channels.poll_adc(instant);
+                    let instant = Instant::from_millis(i64::from(timer::now()));
-                if let Some(channel) = updated_channel {
+                    channels.poll_adc(instant);
                    server.for_each(|_, session| session.set_report_pending(channel.into()));
                }
-                let instant = Instant::from_millis(i64::from(timer::now()));
+                    fan_ctrl.cycle(channels.current_abs_max_tec_i());
-                cortex_m::interrupt::free(net::clear_pending);
+
-                server.poll(instant)
+                    if channels.pid_engaged() {
-                    .unwrap_or_else(|e| {
+                        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).unwrap_or_else(|e| {
                        warn!("poll: {:?}", e);
                    });
-                // TCP protocol handling
+                    if !should_reset {
-                server.for_each(|mut socket, session| {
+                        // TCP protocol handling
-                    if ! socket.is_active() {
+                        server.for_each(|mut socket, session| {
-                        let _ = socket.listen(TCP_PORT);
+                            if !socket.is_active() {
-                        session.reset();
+                                let _ = socket.listen(TCP_PORT);
-                    } else if socket.may_send() && !socket.may_recv() {
+                                session.reset();
-                        socket.close()
+                            } else if socket.may_send() && !socket.may_recv() {
-                    } else if socket.can_send() && socket.can_recv() {
+                                socket.close()
-                        match socket.recv(|buf| session.feed(buf)) {
+                            } else if socket.can_send() && socket.can_recv() {
-                            Ok(SessionInput::Nothing) => {}
+                                match socket.recv(|buf| session.feed(buf)) {
-                            Ok(SessionInput::Command(command)) => match command {
+                                    // SessionInput::Nothing happens when the line reader parses a string of characters that is not
-                                Command::Quit =>
+                                    // followed by a newline character. Could be due to partial commands not terminated with newline,
-                                    socket.close(),
+                                    // socket RX ring buffer wraps around, or when the command is sent as seperate TCP packets etc.
-                                Command::Reporting(_reporting) => {
+                                    // Do nothing and feed more data to the line reader in the next loop cycle.
-                                    // handled by session
+                                    Ok(SessionInput::Nothing) => {}
-                                }
+                                    Ok(SessionInput::Command(command)) => {
-                                Command::Show(ShowCommand::Reporting) => {
+                                        match Handler::handle_command(
-                                    let _ = writeln!(socket, "{{ \"report\": {:?} }}", session.reporting());
+                                            command,
-                                }
+                                            &mut socket,
-                                Command::Show(ShowCommand::Input) => {
+                                            &mut channels,
-                                    for channel in 0..CHANNELS {
+                                            &mut store,
-                                        report_to(channel, &mut channels, &mut socket);
+                                            &mut ipv4_config,
-                                    }
+                                            &mut fan_ctrl,
-                                }
+                                            hwrev,
-                                Command::Show(ShowCommand::Pid) => {
+                                        ) {
-                                    for channel in 0..CHANNELS {
+                                            Ok(Handler::NewIPV4(ip)) => new_ipv4_config = Some(ip),
-                                        match channels.channel_state(channel).pid.summary(channel).to_json() {
+                                            Ok(Handler::Handled) => {}
-                                            Ok(buf) => {
+                                            Ok(Handler::CloseSocket) => socket.close(),
-                                                send_line(&mut socket, &buf);
+                                            Ok(Handler::Reset) => should_reset = true,
-                                            }
+                                            Err(_) => {}
                                            Err(e) =>
                                                error!("unable to serialize pid summary: {:?}", e),
                                        }
                                    }
-                                }
+                                    Ok(SessionInput::Error(e)) => {
-                                Command::Show(ShowCommand::Pwm) => {
+                                        error!("session input: {:?}", e);
-                                    for channel in 0..CHANNELS {
+                                        send_line(&mut socket, b"{ \"error\": \"invalid input\" }");
                                        match channels.pwm_summary(channel).to_json() {
                                            Ok(buf) => {
                                                send_line(&mut socket, &buf);
                                            }
                                            Err(e) =>
                                                error!("unable to serialize pwm summary: {:?}", e),
                                        }
                                    }
-                                }
+                                    Err(_) => socket.close(),
                                Command::Show(ShowCommand::SteinhartHart) => {
                                    for channel in 0..CHANNELS {
                                        match channels.steinhart_hart_summary(channel).to_json() {
                                            Ok(buf) => {
                                                send_line(&mut socket, &buf);
                                            }
                                            Err(e) =>
                                                error!("unable to serialize steinhart-hart summary: {:?}", e),
                                        }
                                    }
                                }
                                Command::Show(ShowCommand::PostFilter) => {
                                    for channel in 0..CHANNELS {
                                        match channels.postfilter_summary(channel).to_json() {
                                            Ok(buf) => {
                                                send_line(&mut socket, &buf);
                                            }
                                            Err(e) =>
                                                error!("unable to serialize postfilter summary: {:?}", e),
                                        }
                                    }
                                }
                                Command::PwmPid { channel } => {
                                    channels.channel_state(channel).pid_engaged = true;
                                    leds.g3.on();
                                }
                                Command::Pwm { channel, pin, value } => {
                                    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);
                                        }
                                        PwmPin::MaxV => {
                                            let voltage = ElectricPotential::new::<volt>(value);
                                            channels.set_max_v(channel, voltage);
                                        }
                                        PwmPin::MaxIPos => {
                                            let current = ElectricCurrent::new::<ampere>(value);
                                            channels.set_max_i_pos(channel, current);
                                        }
                                        PwmPin::MaxINeg => {
                                            let current = ElectricCurrent::new::<ampere>(value);
                                            channels.set_max_i_neg(channel, current);
                                        }
                                    }
                                }
                                Command::CenterPoint { channel, center } => {
                                    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_tec);
                                    }
                                }
                                Command::Pid { channel, parameter, value } => {
                                    let pid = &mut channels.channel_state(channel).pid;
                                    use command_parser::PidParameter::*;
                                    match parameter {
                                        Target =>
                                            pid.target = value,
                                        KP =>
                                            pid.parameters.kp = value as f32,
                                        KI =>
                                            pid.parameters.ki = value as f32,
                                        KD =>
                                            pid.parameters.kd = value as f32,
                                        OutputMin =>
                                            pid.parameters.output_min = value as f32,
                                        OutputMax =>
                                            pid.parameters.output_max = value as f32,
                                        IntegralMin =>
                                            pid.parameters.integral_min = value as f32,
                                        IntegralMax =>
                                            pid.parameters.integral_max = value as f32,
                                    }
                                }
                                Command::SteinhartHart { channel, parameter, value } => {
                                    let sh = &mut channels.channel_state(channel).sh;
                                    use command_parser::ShParameter::*;
                                    match parameter {
                                        T0 => sh.t0 = ThermodynamicTemperature::new::<degree_celsius>(value),
                                        B => sh.b = value,
                                        R0 => sh.r0 = ElectricalResistance::new::<ohm>(value),
                                    }
                                }
                                Command::PostFilter { channel, rate: None } => {
                                    channels.adc.set_postfilter(channel as u8, None).unwrap();
                                }
                                Command::PostFilter { channel, rate: Some(rate) } => {
                                    let filter = ad7172::PostFilter::closest(rate);
                                    match filter {
                                        Some(filter) =>
                                            channels.adc.set_postfilter(channel as u8, Some(filter)).unwrap(),
                                        None =>
                                            error!("unable to choose postfilter for rate {:.3}", rate),
                                    }
                                }
                                Command::Load => {
                                    match Config::load(&mut eeprom) {
                                        Ok(config) => {
                                            config.apply(&mut channels);
                                            new_ipv4_address = Some(Ipv4Address::from_bytes(&config.ipv4_address));
                                        }
                                        Err(e) =>
                                            error!("unable to load eeprom config: {:?}", e),
                                    }
                                }
                                Command::Save => {
                                    let config = Config::new(&mut channels, ipv4_address);
                                    match config.save(&mut eeprom) {
                                        Ok(()) => {},
                                        Err(e) =>
                                            error!("unable to save eeprom config: {:?}", e),
                                    }
                                }
                                Command::Ipv4(address) => {
                                    new_ipv4_address = Some(Ipv4Address::from_bytes(&address));
                                }
                                Command::Reset => {
                                    for i in 0..CHANNELS {
                                        channels.power_down(i);
                                    }
                                    SCB::sys_reset();
                                }
                            }
-                            Ok(SessionInput::Error(e)) => {
+                        });
-                                error!("session input: {:?}", e);
+                    } else {
-                                send_line(&mut socket, b"{ \"error\": \"invalid input\" }");
+                        // Should reset, close all TCP sockets.
-                            }
+                        let mut any_socket_alive = false;
-                            Err(_) =>
+                        server.for_each(|mut socket, _| {
-                                socket.close(),
+                            if socket.is_active() {
-                        }
+                                socket.abort();
-                    } else if socket.can_send() {
+                                any_socket_alive = true;
                        if let Some(channel) = session.is_report_pending() {
                            if report_to(channel, &mut channels, &mut socket) {
                                session.mark_report_sent(channel);
                            }
                        });
                        // Must let loop run for one more cycle to poll server for RST to be sent,
                        // this makes sure system does not reset right after socket.abort() is called.
                        if !any_socket_alive {
                            SCB::sys_reset();
                        }
                    }
                });
-                // Apply new IPv4 address
+                    // Apply new IPv4 address/gateway
-                new_ipv4_address.map(|new_ipv4_address| {
+                    if let Some(config) = new_ipv4_config.take() {
-                    server.set_ipv4_address(ipv4_address);
+                        server.set_ipv4_config(config.clone());
-                    ipv4_address = new_ipv4_address;
+                        ipv4_config = config;
-                });
+                    };
-                // Update watchdog
+                    // Update watchdog
-                wd.feed();
+                    wd.feed();
-                leds.g4.off();
+                    leds.g4.off();
-                cortex_m::interrupt::free(|cs| {
+                    cortex_m::interrupt::free(|cs| {
-                    if !net::is_pending(cs) {
+                        if !net::is_pending(cs) {
-                        // Wait for interrupts
+                            // Wait for interrupts
-                        // (Ethernet, SysTick, or USB)
+                            // (Ethernet, SysTick, or USB)
-                        wfi();
+                            wfi();
-                    }
+                        }
-                });
+                    });
-                leds.g4.on();
+                    leds.g4.on();
-            }
+                }
-        });
+            });
-    });
+        },
    );
    unreachable!()
 }
--- a/src/net.rs
+++ b/src/net.rs
@ -1,16 +1,17 @@
 //! As there is only one peripheral, supporting data structures are
 //! declared once and globally.
 use crate::command_parser::Ipv4Config;
 use crate::pins::EthernetPins;
 use core::cell::RefCell;
 use cortex_m::interrupt::{CriticalSection, Mutex};
 use smoltcp::iface::{EthernetInterface, EthernetInterfaceBuilder, NeighborCache, Routes};
 use smoltcp::wire::{EthernetAddress, Ipv4Address, Ipv4Cidr};
 use stm32_eth::{Eth, RingEntry, RxDescriptor, TxDescriptor};
 use stm32f4xx_hal::{
    pac::{interrupt, Peripherals, ETHERNET_DMA, ETHERNET_MAC},
    rcc::Clocks,
    stm32::{interrupt, Peripherals, ETHERNET_MAC, ETHERNET_DMA},
 };
 use smoltcp::wire::{EthernetAddress, IpCidr, Ipv4Address};
 use smoltcp::iface::{NeighborCache, EthernetInterfaceBuilder, EthernetInterface};
 use stm32_eth::{Eth, RingEntry, PhyAddress, RxDescriptor, TxDescriptor};
 use crate::pins::EthernetPins;
 /// Not on the stack so that stack can be placed in CCMRAM (which the
 /// ethernet peripheral cannot access)
@ -26,40 +27,42 @@ static NET_PENDING: Mutex<RefCell<bool>> = Mutex::new(RefCell::new(false));
 /// Run callback `f` with ethernet driver and TCP/IP stack
 pub fn run<F>(
    clocks: Clocks,
-    ethernet_mac: ETHERNET_MAC, ethernet_dma: ETHERNET_DMA,
+    ethernet_mac: ETHERNET_MAC,
    ethernet_dma: ETHERNET_DMA,
    eth_pins: EthernetPins,
    ethernet_addr: EthernetAddress,
-    local_addr: Ipv4Address,
+    ipv4_config: Ipv4Config,
-    f: F
+    f: F,
 ) where
    F: FnOnce(EthernetInterface<&mut stm32_eth::Eth<'static, 'static>>),
 {
-    let rx_ring = unsafe {
+    let rx_ring = unsafe { RX_RING.get_or_insert(Default::default()) };
-        RX_RING.get_or_insert(Default::default())
+    let tx_ring = unsafe { TX_RING.get_or_insert(Default::default()) };
    };
    let tx_ring = unsafe {
        TX_RING.get_or_insert(Default::default())
    };
    // Ethernet driver
    let mut eth_dev = Eth::new(
-        ethernet_mac, ethernet_dma,
+        ethernet_mac,
-        &mut rx_ring[..], &mut tx_ring[..],
+        ethernet_dma,
-        PhyAddress::_0,
+        &mut rx_ring[..],
        &mut tx_ring[..],
        clocks,
        eth_pins,
-    ).unwrap();
+    )
    .unwrap();
    eth_dev.enable_interrupt();
    // IP stack
-    // Netmask 0 means we expect any IP address on the local segment.
+    let (ipv4_cidr, gateway) = split_ipv4_config(ipv4_config);
-    // No routing.
+    let mut ip_addrs = [ipv4_cidr.into()];
    let mut ip_addrs = [IpCidr::new(local_addr.into(), 0)];
    let mut neighbor_storage = [None; 16];
    let neighbor_cache = NeighborCache::new(&mut neighbor_storage[..]);
    let mut routes_storage = [None; 1];
    let mut routes = Routes::new(&mut routes_storage[..]);
    gateway.map(|gateway| routes.add_default_ipv4_route(gateway).unwrap());
    let iface = EthernetInterfaceBuilder::new(&mut eth_dev)
        .ethernet_addr(ethernet_addr)
        .ip_addrs(&mut ip_addrs[..])
        .neighbor_cache(neighbor_cache)
        .routes(routes)
        .finalize();
    f(iface);
@ -70,8 +73,7 @@ pub fn run<F>(
 #[interrupt]
 fn ETH() {
    cortex_m::interrupt::free(|cs| {
-        *NET_PENDING.borrow(cs)
+        *NET_PENDING.borrow(cs).borrow_mut() = true;
            .borrow_mut() = true;
    });
    let p = unsafe { Peripherals::steal() };
@ -80,13 +82,18 @@ fn ETH() {
 /// Has an interrupt occurred since last call to `clear_pending()`?
 pub fn is_pending(cs: &CriticalSection) -> bool {
-    *NET_PENDING.borrow(cs)
+    *NET_PENDING.borrow(cs).borrow()
        .borrow()
 }
 /// Clear the interrupt pending flag before polling the interface for
 /// data.
 pub fn clear_pending(cs: &CriticalSection) {
-    *NET_PENDING.borrow(cs)
+    *NET_PENDING.borrow(cs).borrow_mut() = false;
-        .borrow_mut() = false;
+}
 /// utility for destructuring into smoltcp types
 pub fn split_ipv4_config(config: Ipv4Config) -> (Ipv4Cidr, Option<Ipv4Address>) {
    let cidr = Ipv4Cidr::new(Ipv4Address(config.address), config.mask_len);
    let gateway = config.gateway.map(Ipv4Address);
    (cidr, gateway)
 }
--- a/src/pid.rs
+++ b/src/pid.rs
@ -1,26 +1,27 @@
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct Parameters {
    /// Gain coefficient for proportional term
    pub kp: f32,
    /// Gain coefficient for integral term
    pub ki: f32,
    /// Gain coefficient for derivative term
    pub kd: f32,
    /// Output limit minimum
    pub output_min: f32,
    /// Output limit maximum
    pub output_max: f32,
    pub integral_min: f32,
    pub integral_max: f32
 }
 impl Default for Parameters {
    fn default() -> Self {
        Parameters {
-            kp: 1.5,
+            kp: 0.0,
-            ki: 0.1,
+            ki: 0.0,
-            kd: 150.0,
+            kd: 0.0,
-            output_min: 0.0,
+            output_min: -2.0,
            output_max: 2.0,
            integral_min: -10.0,
            integral_max: 10.0,
        }
    }
 }
@ -29,55 +30,46 @@ impl Default for Parameters {
 pub struct Controller {
    pub parameters: Parameters,
    pub target: f64,
-    integral: f64,
+    u1: f64,
-    last_input: Option<f64>,
+    x1: f64,
-    pub last_output: Option<f64>,
+    x2: f64,
    pub y1: f64,
 }
 impl Controller {
    pub const fn new(parameters: Parameters) -> Controller {
        Controller {
-            parameters: parameters,
+            parameters,
            target: 0.0,
-            last_input: None,
+            u1: 0.0,
-            integral: 0.0,
+            x1: 0.0,
-            last_output: None,
+            x2: 0.0,
            y1: 0.0,
        }
    }
    // Based on https://hackmd.io/IACbwcOTSt6Adj3_F9bKuw PID implementation
    // Input x(t), target u(t), output y(t)
    // y0' =   y1 - ki * u0
    //       + x0 * (kp + ki + kd)
    //       - x1 * (kp + 2kd)
    //       + x2 * kd
    // y0  = clip(y0', ymin, ymax)
    pub fn update(&mut self, input: f64) -> f64 {
-        // error
+        let mut output: f64 = self.y1 - self.target * f64::from(self.parameters.ki)
-        let error = input - self.target;
+            + input * f64::from(self.parameters.kp + self.parameters.ki + self.parameters.kd)
-
+            - self.x1 * f64::from(self.parameters.kp + 2.0 * self.parameters.kd)
-        // partial
+            + self.x2 * f64::from(self.parameters.kd);
        let p = f64::from(self.parameters.kp) * error;
        // integral
        self.integral += f64::from(self.parameters.ki) * error;
        if self.integral < self.parameters.integral_min.into() {
            self.integral = self.parameters.integral_min.into();
        }
        if self.integral > self.parameters.integral_max.into() {
            self.integral = self.parameters.integral_max.into();
        }
        let i = self.integral;
        // derivative
        let d = match self.last_input {
            None => 0.0,
            Some(last_input) => f64::from(self.parameters.kd) * (input - last_input),
        };
        self.last_input = Some(input);
        // output
        let mut output = p + i + d;
        if output < self.parameters.output_min.into() {
            output = self.parameters.output_min.into();
        }
        if output > self.parameters.output_max.into() {
            output = self.parameters.output_max.into();
        }
-        self.last_output = Some(output);
+        self.x2 = self.x1;
        self.x1 = input;
        self.u1 = self.target;
        self.y1 = output;
        output
    }
@ -86,25 +78,19 @@ impl Controller {
            channel,
            parameters: self.parameters.clone(),
            target: self.target,
            integral: self.integral,
        }
    }
 }
-type JsonBuffer = heapless::Vec<u8, heapless::consts::U360>;
+    pub fn update_ki(&mut self, new_ki: f32) {
        self.parameters.ki = new_ki;
    }
 }
 #[derive(Clone, Serialize, Deserialize)]
 pub struct Summary {
    channel: usize,
    parameters: Parameters,
    target: f64,
    integral: f64,
 }
 impl Summary {
    pub fn to_json(&self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
        serde_json_core::to_vec(self)
    }
 }
 #[cfg(test)]
@ -112,21 +98,27 @@ mod test {
    use super::*;
    const PARAMETERS: Parameters = Parameters {
-        kp: 0.055,
+        kp: 0.03,
-        ki: 0.005,
+        ki: 0.002,
-        kd: 0.04,
+        kd: 0.15,
        output_min: -10.0,
        output_max: 10.0,
        integral_min: -100.0,
        integral_max: 100.0,
    };
    #[test]
    fn test_controller() {
-        const DEFAULT: f64 = 0.0;
+        // Initial and ambient temperature
-        const TARGET: f64 = -1234.56;
+        const DEFAULT: f64 = 20.0;
        // Target temperature
        const TARGET: f64 = 40.0;
        // Control tolerance
        const ERROR: f64 = 0.01;
        // System response delay
        const DELAY: usize = 10;
        // Heat lost
        const LOSS: f64 = 0.05;
        // Limit simulation cycle, reaching this limit before settling fails test
        const CYCLE_LIMIT: u32 = 1000;
        let mut pid = Controller::new(PARAMETERS.clone());
        pid.target = TARGET;
@ -134,24 +126,18 @@ mod test {
        let mut values = [DEFAULT; DELAY];
        let mut t = 0;
        let mut total_t = 0;
        let mut output: f64 = 0.0;
        let target = (TARGET - ERROR)..=(TARGET + ERROR);
-        while !values.iter().all(|value| target.contains(value)) {
+        while !values.iter().all(|value| target.contains(value)) && total_t < CYCLE_LIMIT {
            let next_t = (t + 1) % DELAY;
            // Feed the oldest temperature
-            let output = pid.update(values[next_t]);
+            output = pid.update(values[next_t]);
            // Overwrite oldest with previous temperature - output
-            values[next_t] = values[t] - output;
+            values[next_t] = values[t] - output - (values[t] - DEFAULT) * LOSS;
            t = next_t;
            total_t += 1;
            println!("{}", values[t].to_string());
        }
-    }
+        assert_ne!(CYCLE_LIMIT, total_t);
    #[test]
    fn summary_to_json() {
        let mut pid = Controller::new(PARAMETERS.clone());
        pid.target = 30.0 / 1.1;
        let buf = pid.summary(0).to_json().unwrap();
        assert_eq!(buf[0], b'{');
        assert_eq!(buf[buf.len() - 1], b'}');
    }
 }
--- a/src/pins.rs
+++ b/src/pins.rs
@ -1,95 +1,106 @@
 use crate::{
    channel::{Channel0, Channel1},
    fan_ctrl::FanPin,
    hw_rev::{HWRev, HWSettings},
    leds::Leds,
 };
 use eeprom24x::{self, Eeprom24x};
 use stm32_eth::EthPins;
 use stm32f4xx_hal::{
    adc::Adc,
    gpio::{
-        AF5, Alternate, AlternateOD, Analog, Floating, Input,
+        gpioa::*, gpiob::*, gpioc::*, gpioe::*, gpiof::*, gpiog::*, Alternate, AlternateOD, Analog,
-        gpioa::*,
+        Floating, GpioExt, Input, Output, PushPull, AF5,
        gpiob::*,
        gpioc::*,
        gpioe::*,
        gpiof::*,
        gpiog::*,
        GpioExt,
        Output, PushPull,
    },
    hal::{self, blocking::spi::Transfer, digital::v2::OutputPin},
    i2c::I2c,
    otg_fs::USB,
-    rcc::Clocks,
+    pac::{
-    pwm::{self, PwmChannels},
+        ADC1, GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, GPIOF, GPIOG, I2C1, OTG_FS_DEVICE, OTG_FS_GLOBAL,
-    spi::{Spi, NoMiso},
+        OTG_FS_PWRCLK, SPI2, SPI4, SPI5, TIM1, TIM3, TIM8,
    stm32::{
        ADC1,
        GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, GPIOF, GPIOG,
        I2C1,
        OTG_FS_GLOBAL, OTG_FS_DEVICE, OTG_FS_PWRCLK,
        SPI2, SPI4, SPI5,
        TIM1, TIM3,
    },
    pwm::{self, PwmChannels},
    rcc::Clocks,
    spi::{NoMiso, Spi, TransferModeNormal},
    time::U32Ext,
-};
+    timer::Timer,
 use eeprom24x::{self, Eeprom24x};
 use stm32_eth::EthPins;
 use crate::{
    channel::{Channel0, Channel1},
    leds::Leds,
 };
 pub type Eeprom = Eeprom24x<
-    I2c<I2C1, (
+    I2c<
-        PB8<AlternateOD<stm32f4xx_hal::gpio::AF4>>,
+        I2C1,
-        PB9<AlternateOD<stm32f4xx_hal::gpio::AF4>>
+        (
-    )>,
+            PB8<AlternateOD<{ stm32f4xx_hal::gpio::AF4 }>>,
            PB9<AlternateOD<{ stm32f4xx_hal::gpio::AF4 }>>,
        ),
    >,
    eeprom24x::page_size::B8,
-    eeprom24x::addr_size::OneByte
+    eeprom24x::addr_size::OneByte,
 >;
 pub type EthernetPins = EthPins<
    PA1<Input<Floating>>,
    PA2<Input<Floating>>,
    PC1<Input<Floating>>,
    PA7<Input<Floating>>,
    PB11<Input<Floating>>,
    PG13<Input<Floating>>,
    PB13<Input<Floating>>,
    PC4<Input<Floating>>,
    PC5<Input<Floating>>,
- >;
+>;
 pub trait ChannelPins {
    type DacSpi: Transfer<u8>;
    type DacSync: OutputPin;
    type Shdn: OutputPin;
    type VRefPin;
-    type ItecPin;
+    type ITecPin;
    type DacFeedbackPin;
    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 = PA0<Analog>;
+    type VRefPin = Channel0VRef;
-    type ItecPin = PA6<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 = PA3<Analog>;
+    type VRefPin = Channel1VRef;
-    type ItecPin = PB0<Analog>;
+    type ITecPin = PB0<Analog>;
    type DacFeedbackPin = PA5<Analog>;
    type TecUMeasPin = PC3<Analog>;
 }
 /// SPI peripheral used for communication with the ADC
-pub type AdcSpi = Spi<SPI2, (PB10<Alternate<AF5>>, PB14<Alternate<AF5>>, PB15<Alternate<AF5>>)>;
+pub type AdcSpi = Spi<
    SPI2,
    (
        PB10<Alternate<AF5>>,
        PB14<Alternate<AF5>>,
        PB15<Alternate<AF5>>,
    ),
    TransferModeNormal,
 >;
 pub type AdcNss = PB12<Output<PushPull>>;
-type Dac0Spi = Spi<SPI4, (PE2<Alternate<AF5>>, NoMiso, PE6<Alternate<AF5>>)>;
+type Dac0Spi = Spi<SPI4, (PE2<Alternate<AF5>>, NoMiso, PE6<Alternate<AF5>>), TransferModeNormal>;
-type Dac1Spi = Spi<SPI5, (PF7<Alternate<AF5>>, NoMiso, PF9<Alternate<AF5>>)>;
+type Dac1Spi = Spi<SPI5, (PF7<Alternate<AF5>>, NoMiso, PF9<Alternate<AF5>>), TransferModeNormal>;
 pub type PinsAdc = Adc<ADC1>;
 pub struct ChannelPinSet<C: ChannelPins> {
@ -97,11 +108,18 @@ pub struct ChannelPinSet<C: ChannelPins> {
    pub dac_sync: C::DacSync,
    pub shdn: C::Shdn,
    pub vref_pin: C::VRefPin,
-    pub itec_pin: C::ItecPin,
+    pub itec_pin: C::ITecPin,
    pub dac_feedback_pin: C::DacFeedbackPin,
    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,
@ -115,13 +133,34 @@ impl Pins {
    /// Setup GPIO pins and configure MCU peripherals
    pub fn setup(
        clocks: Clocks,
-        tim1: TIM1, tim3: TIM3,
+        (tim1, tim3, tim8): (TIM1, TIM3, TIM8),
-        gpioa: GPIOA, gpiob: GPIOB, gpioc: GPIOC, gpiod: GPIOD, gpioe: GPIOE, gpiof: GPIOF, gpiog: GPIOG,
+        (gpioa, gpiob, gpioc, gpiod, gpioe, gpiof, gpiog): (
            GPIOA,
            GPIOB,
            GPIOC,
            GPIOD,
            GPIOE,
            GPIOF,
            GPIOG,
        ),
        i2c1: I2C1,
-        spi2: SPI2, spi4: SPI4, spi5: SPI5,
+        (spi2, spi4, spi5): (SPI2, SPI4, SPI5),
        adc1: ADC1,
-        otg_fs_global: OTG_FS_GLOBAL, otg_fs_device: OTG_FS_DEVICE, otg_fs_pwrclk: OTG_FS_PWRCLK,
+        (otg_fs_global, otg_fs_device, otg_fs_pwrclk): (
-    ) -> (Self, Leds, Eeprom, EthernetPins, USB) {
+            OTG_FS_GLOBAL,
            OTG_FS_DEVICE,
            OTG_FS_PWRCLK,
        ),
    ) -> (
        Self,
        Leds,
        Eeprom,
        EthernetPins,
        USB,
        Option<FanPin>,
        HWRev,
        HWSettings,
    ) {
        let gpioa = gpioa.split();
        let gpiob = gpiob.split();
        let gpioc = gpioc.split();
@ -136,19 +175,29 @@ impl Pins {
        let pins_adc = Adc::adc1(adc1, true, Default::default());
        let pwm = PwmPins::setup(
-            clocks, tim1, tim3,
+            clocks,
-            gpioc.pc6, gpioc.pc7,
+            (tim1, tim3),
-            gpioe.pe9, gpioe.pe11,
+            (gpioc.pc6, gpioc.pc7),
-            gpioe.pe13, gpioe.pe14
+            (gpioe.pe9, gpioe.pe11),
            (gpioe.pe13, gpioe.pe14),
        );
-        let (dac0_spi, dac0_sync) = Self::setup_dac0(
+        let hwrev = HWRev::detect_hw_rev(&HWRevPins {
-            clocks, spi4,
+            hwrev0: gpiod.pd0,
-            gpioe.pe2, gpioe.pe4, gpioe.pe6
+            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();
+        shdn0.set_low();
-        let vref0_pin = gpioa.pa0.into_analog();
+        let vref0_pin = if hwrev.major > 2 {
            Channel0VRef::Analog(gpioa.pa0.into_analog())
        } else {
            Channel0VRef::Disabled(gpioa.pa0)
        };
        let itec0_pin = gpioa.pa6.into_analog();
        let dac_feedback0_pin = gpioa.pa4.into_analog();
        let tec_u_meas0_pin = gpioc.pc2.into_analog();
@ -162,13 +211,14 @@ impl Pins {
            tec_u_meas_pin: tec_u_meas0_pin,
        };
-        let (dac1_spi, dac1_sync) = Self::setup_dac1(
+        let (dac1_spi, dac1_sync) = Self::setup_dac1(clocks, spi5, gpiof.pf7, gpiof.pf6, gpiof.pf9);
            clocks, spi5,
            gpiof.pf7, gpiof.pf6, gpiof.pf9
        );
        let mut shdn1 = gpioe.pe15.into_push_pull_output();
-        let _ = shdn1.set_low();
+        shdn1.set_low();
-        let vref1_pin = gpioa.pa3.into_analog();
+        let vref1_pin = if hwrev.major > 2 {
            Channel1VRef::Analog(gpioa.pa3.into_analog())
        } else {
            Channel1VRef::Disabled(gpioa.pa3)
        };
        let itec1_pin = gpiob.pb0.into_analog();
        let dac_feedback1_pin = gpioa.pa5.into_analog();
        let tec_u_meas1_pin = gpioc.pc3.into_analog();
@ -183,24 +233,27 @@ impl Pins {
        };
        let pins = Pins {
-            adc_spi, adc_nss,
+            adc_spi,
            adc_nss,
            pins_adc,
            pwm,
            channel0,
            channel1,
        };
-        let leds = Leds::new(gpiod.pd9, gpiod.pd10.into_push_pull_output(), gpiod.pd11.into_push_pull_output());
+        let leds = Leds::new(
            gpiod.pd9,
            gpiod.pd10.into_push_pull_output(),
            gpiod.pd11.into_push_pull_output(),
        );
-        let eeprom_scl = gpiob.pb8.into_alternate_af4().set_open_drain();
+        let eeprom_scl = gpiob.pb8.into_alternate().set_open_drain();
-        let eeprom_sda = gpiob.pb9.into_alternate_af4().set_open_drain();
+        let eeprom_sda = gpiob.pb9.into_alternate().set_open_drain();
-        let eeprom_i2c = I2c::i2c1(i2c1, (eeprom_scl, eeprom_sda), 400.khz(), clocks);
+        let eeprom_i2c = I2c::new(i2c1, (eeprom_scl, eeprom_sda), 400.khz(), clocks);
        let eeprom = Eeprom24x::new_24x02(eeprom_i2c, eeprom24x::SlaveAddr::default());
        let eth_pins = EthPins {
            ref_clk: gpioa.pa1,
            md_io: gpioa.pa2,
            md_clk: gpioc.pc1,
            crs: gpioa.pa7,
            tx_en: gpiob.pb11,
            tx_d0: gpiog.pg13,
@ -213,12 +266,21 @@ impl Pins {
            usb_global: otg_fs_global,
            usb_device: otg_fs_device,
            usb_pwrclk: otg_fs_pwrclk,
-            pin_dm: gpioa.pa11.into_alternate_af10(),
+            pin_dm: gpioa.pa11.into_alternate(),
-            pin_dp: gpioa.pa12.into_alternate_af10(),
+            pin_dp: gpioa.pa12.into_alternate(),
            hclk: clocks.hclk(),
        };
-        (pins, leds, eeprom, eth_pins, usb)
+        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)
    }
    /// Configure the GPIO pins for SPI operation, and initialize SPI
@ -228,32 +290,34 @@ impl Pins {
        sck: PB10<M1>,
        miso: PB14<M2>,
        mosi: PB15<M3>,
-    ) -> AdcSpi
+    ) -> AdcSpi {
-    {
+        let sck = sck.into_alternate();
-        let sck = sck.into_alternate_af5();
+        let miso = miso.into_alternate();
-        let miso = miso.into_alternate_af5();
+        let mosi = mosi.into_alternate();
-        let mosi = mosi.into_alternate_af5();
+        Spi::new(
        Spi::spi2(
            spi2,
            (sck, miso, mosi),
            crate::ad7172::SPI_MODE,
-            crate::ad7172::SPI_CLOCK.into(),
+            crate::ad7172::SPI_CLOCK,
-            clocks
+            clocks,
        )
    }
    fn setup_dac0<M1, M2, M3>(
-        clocks: Clocks, spi4: SPI4,
+        clocks: Clocks,
-        sclk: PE2<M1>, sync: PE4<M2>, sdin: PE6<M3>
+        spi4: SPI4,
        sclk: PE2<M1>,
        sync: PE4<M2>,
        sdin: PE6<M3>,
    ) -> (Dac0Spi, <Channel0 as ChannelPins>::DacSync) {
-        let sclk = sclk.into_alternate_af5();
+        let sclk = sclk.into_alternate();
-        let sdin = sdin.into_alternate_af5();
+        let sdin = sdin.into_alternate();
-        let spi = Spi::spi4(
+        let spi = Spi::new(
            spi4,
-            (sclk, NoMiso, sdin),
+            (sclk, NoMiso {}, sdin),
            crate::ad5680::SPI_MODE,
-            crate::ad5680::SPI_CLOCK.into(),
+            crate::ad5680::SPI_CLOCK,
-            clocks
+            clocks,
        );
        let sync = sync.into_push_pull_output();
@ -261,17 +325,20 @@ impl Pins {
    }
    fn setup_dac1<M1, M2, M3>(
-        clocks: Clocks, spi5: SPI5,
+        clocks: Clocks,
-        sclk: PF7<M1>, sync: PF6<M2>, sdin: PF9<M3>
+        spi5: SPI5,
        sclk: PF7<M1>,
        sync: PF6<M2>,
        sdin: PF9<M3>,
    ) -> (Dac1Spi, <Channel1 as ChannelPins>::DacSync) {
-        let sclk = sclk.into_alternate_af5();
+        let sclk = sclk.into_alternate();
-        let sdin = sdin.into_alternate_af5();
+        let sdin = sdin.into_alternate();
-        let spi = Spi::spi5(
+        let spi = Spi::new(
            spi5,
-            (sclk, NoMiso, sdin),
+            (sclk, NoMiso {}, sdin),
            crate::ad5680::SPI_MODE,
-            crate::ad5680::SPI_CLOCK.into(),
+            crate::ad5680::SPI_CLOCK,
-            clocks
+            clocks,
        );
        let sync = sync.into_push_pull_output();
@ -291,46 +358,43 @@ pub struct PwmPins {
 impl PwmPins {
    fn setup<M1, M2, M3, M4, M5, M6>(
        clocks: Clocks,
-        tim1: TIM1,
+        (tim1, tim3): (TIM1, TIM3),
-        tim3: TIM3,
+        (max_v0, max_v1): (PC6<M1>, PC7<M2>),
-        max_v0: PC6<M1>,
+        (max_i_pos0, max_i_pos1): (PE9<M3>, PE11<M4>),
-        max_v1: PC7<M2>,
+        (max_i_neg0, max_i_neg1): (PE13<M5>, PE14<M6>),
        max_i_pos0: PE9<M3>,
        max_i_pos1: PE11<M4>,
        max_i_neg0: PE13<M5>,
        max_i_neg1: PE14<M6>,
    ) -> PwmPins {
        let freq = 20u32.khz();
-        fn init_pwm_pin<P: hal::PwmPin<Duty=u16>>(pin: &mut P) {
+        fn init_pwm_pin<P: hal::PwmPin<Duty = u16>>(pin: &mut P) {
            pin.set_duty(0);
            pin.enable();
        }
-        let channels = (
+        let channels = (max_v0.into_alternate(), max_v1.into_alternate());
-            max_v0.into_alternate_af2(),
+        //let (mut max_v0, mut max_v1) = pwm::tim3(tim3, channels, clocks, freq);
-            max_v1.into_alternate_af2(),
+        let (mut max_v0, mut max_v1) = Timer::new(tim3, &clocks).pwm(channels, freq);
        );
        let (mut max_v0, mut max_v1) = pwm::tim3(tim3, channels, clocks, freq);
        init_pwm_pin(&mut max_v0);
        init_pwm_pin(&mut max_v1);
        let channels = (
-            max_i_pos0.into_alternate_af1(),
+            max_i_pos0.into_alternate(),
-            max_i_pos1.into_alternate_af1(),
+            max_i_pos1.into_alternate(),
-            max_i_neg0.into_alternate_af1(),
+            max_i_neg0.into_alternate(),
-            max_i_neg1.into_alternate_af1(),
+            max_i_neg1.into_alternate(),
        );
        let (mut max_i_pos0, mut max_i_pos1, mut max_i_neg0, mut max_i_neg1) =
-            pwm::tim1(tim1, channels, clocks, freq);
+            Timer::new(tim1, &clocks).pwm(channels, freq);
        init_pwm_pin(&mut max_i_pos0);
        init_pwm_pin(&mut max_i_neg0);
        init_pwm_pin(&mut max_i_pos1);
        init_pwm_pin(&mut max_i_neg1);
        PwmPins {
-            max_v0, max_v1,
+            max_v0,
-            max_i_pos0, max_i_pos1,
+            max_v1,
-            max_i_neg0, max_i_neg1,
+            max_i_pos0,
            max_i_pos1,
            max_i_neg0,
            max_i_neg1,
        }
    }
 }
--- a/src/server.rs
+++ b/src/server.rs
@ -1,17 +1,33 @@
-use core::mem::MaybeUninit;
+use crate::command_parser::Ipv4Config;
 use crate::net::split_ipv4_config;
 use smoltcp::{
    iface::EthernetInterface,
-    socket::{SocketSet, SocketHandle, TcpSocket, TcpSocketBuffer, SocketRef},
+    socket::{SocketHandle, SocketRef, SocketSet, TcpSocket, TcpSocketBuffer},
    time::Instant,
-    wire::{IpCidr, Ipv4Address, Ipv4Cidr},
+    wire::{IpAddress, IpCidr, Ipv4Address, Ipv4Cidr},
 };
 pub struct SocketState<S> {
    handle: SocketHandle,
    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.
@ -23,39 +39,38 @@ const TCP_TX_BUFFER_SIZE: usize = 2048;
 /// Contains a number of server sockets that get all sent the same
 /// data (through `fmt::Write`).
 pub struct Server<'a, 'b, S> {
-    net: EthernetInterface<'a, 'a, 'a, &'a mut stm32_eth::Eth<'static, 'static>>,
+    net: EthernetInterface<'a, &'a mut stm32_eth::Eth<'static, 'static>>,
-    sockets: SocketSet<'b, 'b, 'b>,
+    sockets: SocketSet<'b>,
    states: [SocketState<S>; SOCKET_COUNT],
 }
 impl<'a, 'b, S: Default> Server<'a, 'b, S> {
    /// Run a server with stack-allocated sockets
-    pub fn run<F>(net: EthernetInterface<'a, 'a, 'a, &'a mut stm32_eth::Eth<'static, 'static>>, f: F)
+    pub fn run<F>(net: EthernetInterface<'a, &'a mut stm32_eth::Eth<'static, 'static>>, f: F)
    where
        F: FnOnce(&mut Server<'a, '_, S>),
    {
-        let mut sockets_storage: [_; SOCKET_COUNT] = Default::default();
+        macro_rules! create_rtx_storage {
-        let mut sockets = SocketSet::new(&mut sockets_storage[..]);
+            ($rx_storage:ident, $tx_storage:ident) => {
        let mut states: [SocketState<S>; SOCKET_COUNT] = unsafe { MaybeUninit::uninit().assume_init() };
        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 {
+        create_rtx_storage!(tcp_rx_storage0, tcp_tx_storage0);
-            state.state = S::default();
+        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 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),
        ];
        let mut server = Server {
            states,
@ -85,20 +100,33 @@ impl<'a, 'b, S: Default> Server<'a, 'b, S> {
        }
    }
-    pub fn set_ipv4_address(&mut self, ipv4_address: Ipv4Address) {
+    fn set_ipv4_address(&mut self, ipv4_address: Ipv4Cidr) {
        self.net.update_ip_addrs(|addrs| {
            for addr in addrs.iter_mut() {
-                match addr {
+                if let IpCidr::Ipv4(_) = addr {
-                    IpCidr::Ipv4(_) => {
+                    *addr = IpCidr::Ipv4(ipv4_address);
-                        *addr = IpCidr::Ipv4(Ipv4Cidr::new(ipv4_address, 0));
+                    // done
-                        // done
+                    break;
                        break
                    }
                    _ => {
                        // skip
                    }
                }
            }
        });
    }
    fn set_gateway(&mut self, gateway: Option<Ipv4Address>) {
        let routes = self.net.routes_mut();
        match gateway {
            None => routes.update(|routes_storage| {
                routes_storage.remove(&IpCidr::new(IpAddress::v4(0, 0, 0, 0), 0));
            }),
            Some(gateway) => {
                routes.add_default_ipv4_route(gateway).unwrap();
            }
        }
    }
    pub fn set_ipv4_config(&mut self, config: Ipv4Config) {
        let (address, gateway) = split_ipv4_config(config);
        self.set_ipv4_address(address);
        self.set_gateway(gateway);
    }
 }
--- a/src/session.rs
+++ b/src/session.rs
@ -1,5 +1,4 @@
 use super::command_parser::{Command, Error as ParserError};
 use super::channels::CHANNELS;
 const MAX_LINE_LEN: usize = 64;
@ -46,15 +45,14 @@ pub enum SessionInput {
 impl From<Result<Command, ParserError>> for SessionInput {
    fn from(input: Result<Command, ParserError>) -> Self {
-        input.map(SessionInput::Command)
+        input
            .map(SessionInput::Command)
            .unwrap_or_else(SessionInput::Error)
    }
 }
 pub struct Session {
    reader: LineReader,
    reporting: bool,
    report_pending: [bool; CHANNELS],
 }
 impl Default for Session {
@ -67,43 +65,11 @@ impl Session {
    pub fn new() -> Self {
        Session {
            reader: LineReader::new(),
            reporting: false,
            report_pending: [false; CHANNELS],
        }
    }
    pub fn reset(&mut self) {
        self.reader = LineReader::new();
        self.reporting = false;
        self.report_pending = [false; CHANNELS];
    }
    pub fn reporting(&self) -> bool {
        self.reporting
    }
    pub fn set_report_pending(&mut self, channel: usize) {
        if self.reporting {
            self.report_pending[channel] = true;
        }
    }
    pub fn is_report_pending(&self) -> Option<usize> {
        if ! self.reporting {
            None
        } else {
            self.report_pending.iter()
                .enumerate()
                .fold(None, |result, (channel, report_pending)| {
                    result.or_else(|| {
                        if *report_pending { Some(channel) } else { None }
                    })
                })
        }
    }
    pub fn mark_report_sent(&mut self, channel: usize) {
        self.report_pending[channel] = false;
    }
    pub fn feed(&mut self, buf: &[u8]) -> (usize, SessionInput) {
@ -111,18 +77,9 @@ impl Session {
        for (i, b) in buf.iter().enumerate() {
            buf_bytes = i + 1;
            let line = self.reader.feed(*b);
-            match line {
+            if let Some(line) = line {
-                Some(line) => {
+                let command = Command::parse(line);
-                    let command = Command::parse(&line);
+                return (buf_bytes, command.into());
                    match command {
                        Ok(Command::Reporting(reporting)) => {
                            self.reporting = reporting;
                        }
                        _ => {}
                    }
                    return (buf_bytes, command.into());
                }
                None => {}
            }
        }
        (buf_bytes, SessionInput::Nothing)
--- a/src/steinhart_hart.rs
+++ b/src/steinhart_hart.rs
@ -1,46 +0,0 @@
 use num_traits::float::Float;
 use uom::si::{
    f64::{
        ElectricalResistance,
        ThermodynamicTemperature,
    },
    electrical_resistance::ohm,
    ratio::ratio,
    thermodynamic_temperature::{degree_celsius, kelvin},
 };
 use serde::Serialize;
 type JsonBuffer = heapless::Vec<u8, heapless::consts::U200>;
 /// Steinhart-Hart equation parameters
 #[derive(Clone, Debug, Serialize)]
 pub struct Parameters {
    /// Base temperature
    pub t0: ThermodynamicTemperature,
    /// Base resistance
    pub r0: ElectricalResistance,
    /// Beta
    pub b: f64,
 }
 impl Parameters {
    /// Perform the voltage to temperature conversion.
    pub fn get_temperature(&self, r: ElectricalResistance) -> ThermodynamicTemperature {
        let inv_temp = 1.0 / self.t0.get::<kelvin>() + (r / self.r0).get::<ratio>().ln() / self.b;
        ThermodynamicTemperature::new::<kelvin>(1.0 / inv_temp)
    }
    pub fn to_json(&self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
        serde_json_core::to_vec(self)
    }
 }
 impl Default for Parameters {
    fn default() -> Self {
        Parameters {
            t0: ThermodynamicTemperature::new::<degree_celsius>(25.0),
            r0: ElectricalResistance::new::<ohm>(10_000.0),
            b: 3800.0,
        }
    }
 }
--- a/src/timer.rs
+++ b/src/timer.rs
@ -4,9 +4,9 @@ use cortex_m::interrupt::Mutex;
 use cortex_m_rt::exception;
 use stm32f4xx_hal::{
    rcc::Clocks,
    time::U32Ext,
    timer::{Timer, Event as TimerEvent},
    stm32::SYST,
    time::U32Ext,
    timer::{Event as TimerEvent, Timer},
 };
 /// Rate in Hz
@ -18,26 +18,22 @@ static TIMER_MS: Mutex<RefCell<u32>> = Mutex::new(RefCell::new(0));
 /// Setup SysTick exception
 pub fn setup(syst: SYST, clocks: Clocks) {
-    let mut timer = Timer::syst(syst, TIMER_RATE.hz(), clocks);
+    let timer = Timer::syst(syst, &clocks);
-    timer.listen(TimerEvent::TimeOut);
+    let mut countdown = timer.start_count_down(TIMER_RATE.hz());
    countdown.listen(TimerEvent::TimeOut);
 }
 /// SysTick exception (Timer)
 #[exception]
 fn SysTick() {
    cortex_m::interrupt::free(|cs| {
-        *TIMER_MS.borrow(cs)
+        *TIMER_MS.borrow(cs).borrow_mut() += TIMER_DELTA;
            .borrow_mut() += TIMER_DELTA;
    });
 }
 /// Obtain current time in milliseconds
 pub fn now() -> u32 {
-    cortex_m::interrupt::free(|cs| {
+    cortex_m::interrupt::free(|cs| *TIMER_MS.borrow(cs).borrow().deref())
        *TIMER_MS.borrow(cs)
            .borrow()
            .deref()
    })
 }
 /// block for at least `amount` milliseconds
--- a/src/usb.rs
+++ b/src/usb.rs
@ -1,15 +1,18 @@
-use core::{fmt::{self, Write}, mem::MaybeUninit};
+use core::{
    fmt::{self, Write},
    mem::MaybeUninit,
 };
 use cortex_m::interrupt::free;
 use log::{Log, Metadata, Record};
 use stm32f4xx_hal::{
-    otg_fs::{USB, UsbBus as Bus},
+    otg_fs::{UsbBus as Bus, USB},
    stm32::{interrupt, Interrupt, NVIC},
 };
 use usb_device::{
-    class_prelude::{UsbBusAllocator},
+    class_prelude::UsbBusAllocator,
    prelude::{UsbDevice, UsbDeviceBuilder, UsbVidPid},
 };
 use usbd_serial::SerialPort;
 use log::{Record, Log, Metadata};
 static mut EP_MEMORY: [u32; 1024] = [0; 1024];
@ -36,8 +39,8 @@ impl State {
            .device_class(usbd_serial::USB_CLASS_CDC)
            .build();
-        free(|_| {
+        free(|_| unsafe {
-            unsafe { STATE = Some(State { serial, dev }); }
+            STATE = Some(State { serial, dev });
        });
        unsafe {
@ -94,8 +97,7 @@ impl Write for SerialOutput {
    fn write_str(&mut self, s: &str) -> core::result::Result<(), core::fmt::Error> {
        if let Some(ref mut state) = State::get() {
            for chunk in s.as_bytes().chunks(16) {
-                free(|_| state.serial.write(chunk))
+                free(|_| state.serial.write(chunk)).map_err(|_| fmt::Error)?;
                    .map_err(|_| fmt::Error)?;
            }
        }
        Ok(())
		`@ -1 +0,0 @@`
			`"055x3b3kqi7bi17ya6iaiq9hlsiy8f3v6bn47s6dizc6y4xn9v2y"`