M-Labs
/
thermostat
9
0
Fork 5
Code Issues 10 Pull Requests 7 Releases Wiki Activity

Compare commits

base: M-Labs:master
Branches Tags
M-Labs:master
M-Labs:dev-gui
M-Labs:GUI
M-Labs:softspi
esavkin:zotino-tec
esavkin:master
esavkin:gui-paramtree
esavkin:GUI
esavkin:72-warning-on-zeroed-limits
esavkin:63-fix-pid-error
esavkin:69-fan_pwm
esavkin:71-update-nixos22_11
esavkin:softspi
..
compare: esavkin:master
Branches Tags
esavkin:zotino-tec
esavkin:master
esavkin:gui-paramtree
esavkin:GUI
esavkin:72-warning-on-zeroed-limits
esavkin:63-fix-pid-error
esavkin:69-fan_pwm
esavkin:71-update-nixos22_11
esavkin:softspi
M-Labs:master
M-Labs:dev-gui
M-Labs:GUI
M-Labs:softspi

No commits in common. "master" and "master" have entirely different histories.
master ... master

39 changed files with 1470 additions and 1839 deletions
Show Stats Expand all files Collapse all files

3
.gitignore vendored
View File

@ -1,5 +1,2 @@
target/ target/
result result
*.bin
__pycache__/

138
README.md
View File

@ -23,7 +23,7 @@ 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. Alternatively, you can install the Rust toolchain without Nix using rustup; see the Rust manifest file pulled in `flake.nix` to determine which Rust version to use.
## Debugging ## Debugging
@ -45,7 +45,7 @@ There are several options for flashing Thermostat. DFU requires only a micro-USB
### dfu-util on Linux ### dfu-util on Linux
* Install the DFU USB tool (dfu-util). * Install the DFU USB tool (dfu-util).
* 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) * Convert firmware from ELF to BIN: `arm-none-eabi-objcopy -O binary 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. * 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. * Add jumper to Thermostat v2.0 across 2-pin jumper adjacent to JTAG connector.
* Cycle board power to put it in DFU update mode * Cycle board power to put it in DFU update mode
@ -84,7 +84,9 @@ invalidate the first line of input.
### Reading ADC input ### Reading ADC input
ADC input data is provided in reports. Query for the latest report with the command `report`. See the *Reports* section below. Set report mode to `on` for a continuous stream of input data.
The scope of this setting is per TCP session.
### TCP commands ### TCP commands
@ -92,41 +94,42 @@ ADC input data is provided in reports. Query for the latest report with the comm
Send commands as simple text string terminated by `\n`. Responses are Send commands as simple text string terminated by `\n`. Responses are
formatted as line-delimited JSON. formatted as line-delimited JSON.
| Syntax | Function | | Syntax | Function |
|-------------------------------------------|-------------------------------------------------------------------------------| |----------------------------------|-------------------------------------------------------------------------------|
| `report` | Show latest report of channel parameters (see *Reports* section) | | `report` | Show current input |
| `output` | Show current output settings | | `report mode` | Show current report mode |
| `output <0/1> max_i_pos <amp>` | Set maximum positive output current, clamped to [0, 2] | | `report mode <off/on>` | Set report mode |
| `output <0/1> max_i_neg <amp>` | Set maximum negative output current, clamped to [0, 2] | | `pwm` | Show current PWM settings |
| `output <0/1> max_v <volt>` | Set maximum output voltage, clamped to [0, 4] | | `pwm <0/1> max_i_pos <amp>` | Set maximum positive output current |
| `output <0/1> i_set <amp>` | Disengage PID, set fixed output current, clamped to [-2, 2] | | `pwm <0/1> max_i_neg <amp>` | Set maximum negative output current |
| `output <0/1> polarity <normal/reversed>` | Set output current polarity, with 'normal' being the front panel polarity | | `pwm <0/1> max_v <volt>` | Set maximum output voltage |
| `output <0/1> pid` | Let output current to be controlled by the PID | | `pwm <0/1> i_set <amp>` | Disengage PID, set fixed output current |
| `center <0/1> <volt>` | Set the MAX1968 0A-centerpoint to the specified fixed voltage | | `pwm <0/1> pid` | Let output current to be controlled by the PID |
| `center <0/1> vref` | Set the MAX1968 0A-centerpoint to measure from VREF | | `center <0/1> <volt>` | Set the MAX1968 0A-centerpoint to the specified fixed voltage |
| `pid` | Show PID configuration | | `center <0/1> vref` | Set the MAX1968 0A-centerpoint to measure from VREF |
| `pid <0/1> target <deg_celsius>` | Set the PID controller target temperature | | `pid` | Show PID configuration |
| `pid <0/1> kp <value>` | Set proportional gain | | `pid <0/1> target <deg_celsius>` | Set the PID controller target temperature |
| `pid <0/1> ki <value>` | Set integral gain | | `pid <0/1> kp <value>` | Set proportional gain |
| `pid <0/1> kd <value>` | Set differential gain | | `pid <0/1> ki <value>` | Set integral gain |
| `pid <0/1> output_min <amp>` | Set mininum output | | `pid <0/1> kd <value>` | Set differential gain |
| `pid <0/1> output_max <amp>` | Set maximum output | | `pid <0/1> output_min <amp>` | Set mininum output |
| `b-p` | Show B-Parameter equation parameters | | `pid <0/1> output_max <amp>` | Set maximum output |
| `b-p <0/1> <t0/b/r0> <value>` | Set B-Parameter for a channel | | `s-h` | Show Steinhart-Hart equation parameters |
| `postfilter` | Show postfilter settings | | `s-h <0/1> <t0/b/r0> <value>` | Set Steinhart-Hart parameter for a channel |
| `postfilter <0/1> off` | Disable postfilter | | `postfilter` | Show postfilter settings |
| `postfilter <0/1> rate <rate>` | Set postfilter output data rate | | `postfilter <0/1> off` | Disable postfilter |
| `load [0/1]` | Restore configuration for channel all/0/1 from flash | | `postfilter <0/1> rate <rate>` | Set postfilter output data rate |
| `save [0/1]` | Save configuration for channel all/0/1 to flash | | `load [0/1]` | Restore configuration for channel all/0/1 from flash |
| `reset` | Reset the device | | `save [0/1]` | Save configuration for channel all/0/1 to flash |
| `dfu` | Reset device and enters USB device firmware update (DFU) mode | | `reset` | Reset the device |
| `ipv4 <X.X.X.X/L> [Y.Y.Y.Y]` | Configure IPv4 address, netmask length, and optional default gateway | | `dfu` | Reset device and enters USB device firmware update (DFU) mode |
| `fan` | Show current fan settings and sensors' measurements | | `ipv4 <X.X.X.X/L> [Y.Y.Y.Y]` | Configure IPv4 address, netmask length, and optional default gateway |
| `fan <value>` | Set fan power with values from 1 to 100 | | `fan` | Show current fan settings and sensors' measurements |
| `fan auto` | Enable automatic fan speed control | | `fan <value>` | Set fan power with values from 1 to 100 |
| `fcurve <a> <b> <c>` | Set fan controller curve coefficients (see *Fan control* section) | | `fan auto` | Enable automatic fan speed control |
| `fcurve default` | Set fan controller curve coefficients to defaults (see *Fan control* section) | | `fcurve <a> <b> <c>` | Set fan controller curve coefficients (see *Fan control* section) |
| `hwrev` | Show hardware revision, and settings related to it | | `fcurve default` | Set fan controller curve coefficients to defaults (see *Fan control* section) |
| `hwrev` | Show hardware revision, and settings related to it |
## USB ## USB
@ -144,22 +147,22 @@ output will be truncated when USB buffers are full.
Connect the thermistor with the SENS pins of the Connect the thermistor with the SENS pins of the
device. Temperature-depending resistance is measured by the AD7172 device. Temperature-depending resistance is measured by the AD7172
ADC. To prepare conversion to a temperature, set the parameters ADC. To prepare conversion to a temperature, set the Beta parameters
for the B-Parameter equation. for the Steinhart-Hart equation.
Set the base temperature in degrees celsius for the channel 0 thermistor: Set the base temperature in degrees celsius for the channel 0 thermistor:
``` ```
b-p 0 t0 20 s-h 0 t0 20
``` ```
Set the resistance in Ohms measured at the base temperature t0: Set the resistance in Ohms measured at the base temperature t0:
``` ```
b-p 0 r0 10000 s-h 0 r0 10000
``` ```
Set the Beta parameter: Set the Beta parameter:
``` ```
b-p 0 b 3800 s-h 0 b 3800
``` ```
### 50/60 Hz filtering ### 50/60 Hz filtering
@ -183,47 +186,46 @@ postfilter rate can be tuned with the `postfilter` command.
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. 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. Testing heat flow direction with a low set current is recommended before installation of the TEC module.
### Limits ### Limits
Each channel has maximum value settings, for setting Each of the MAX1968 TEC driver has analog/PWM inputs for setting
output limits. output limits.
Use the `output` command to see them. Use the `pwm` command to see current settings and maximum values.
| 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 |
| `i_set` | Amperes | (Not a limit; Open-loop mode) |
Example: set the maximum voltage of channel 0 to 1.5 V. Example: set the maximum voltage of channel 0 to 1.5 V.
``` ```
output 0 max_v 1.5 pwm 0 max_v 1.5
``` ```
Example: set the maximum negative current of channel 0 to -2 A. Example: set the maximum negative current of channel 0 to -3 A.
``` ```
output 0 max_i_neg 2 pwm 0 max_i_neg 3
``` ```
Example: set the maximum positive current of channel 1 to 2 A. Example: set the maximum positive current of channel 1 to 3 A.
``` ```
output 1 max_i_pos 2 pwm 0 max_i_pos 3
``` ```
### Open-loop mode ### Open-loop mode
To manually control TEC output current, set a fixed output current with To manually control TEC output current, omit the limit parameter of
the `output` command. Doing so will disengage the PID control for that the `pwm` command. Doing so will disengage the PID control for that
channel. channel.
Example: set output current of channel 0 to 0 A. Example: set output current of channel 0 to 0 A.
``` ```
output 0 i_set 0 pwm 0 i_set 0
``` ```
## PID-stabilized temperature control ## PID-stabilized temperature control
@ -236,23 +238,7 @@ pid 0 target 20
Enter closed-loop mode by switching control of the TEC output current Enter closed-loop mode by switching control of the TEC output current
of channel 0 to the PID algorithm: of channel 0 to the PID algorithm:
``` ```
output 0 pid pwm 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 ## LED indicators
@ -265,17 +251,17 @@ pid 0 output_min 0.1
## Reports ## Reports
Use the bare `report` command to obtain a single report. Reports are JSON objects Use the bare `report` command to obtain a single report. Enable
continuous reporting with `report mode on`. Reports are JSON objects
with the following keys. with the following keys.
| Key | Unit | Description | | Key | Unit | Description |
| --- | :---: | --- | | --- | :---: | --- |
| `channel` | Integer | Channel `0`, or `1` | | `channel` | Integer | Channel `0`, or `1` |
| `time` | Seconds | Temperature measurement time | | `time` | Seconds | Temperature measurement time |
| `interval` | Seconds | Time elapsed since last report update on channel |
| `adc` | Volts | AD7172 input | | `adc` | Volts | AD7172 input |
| `sens` | Ohms | Thermistor resistance derived from `adc` | | `sens` | Ohms | Thermistor resistance derived from `adc` |
| `temperature` | Degrees Celsius | B-Parameter conversion result derived from `sens` | | `temperature` | Degrees Celsius | Steinhart-Hart conversion result derived from `sens` |
| `pid_engaged` | Boolean | `true` if in closed-loop mode | | `pid_engaged` | Boolean | `true` if in closed-loop mode |
| `i_set` | Amperes | TEC output current | | `i_set` | Amperes | TEC output current |
| `dac_value` | Volts | AD5680 output derived from `i_set` | | `dac_value` | Volts | AD5680 output derived from `i_set` |
@ -285,7 +271,7 @@ with the following keys.
| `tec_u_meas` | Volts | Measurement of the voltage across the TEC | | `tec_u_meas` | Volts | Measurement of the voltage across the TEC |
| `pid_output` | Amperes | PID control output | | `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). Note: With Thermostat v2 and below, the voltage and current readouts `i_tec` and `tec_i` are disabled and null due to faulty hardware that introduces a lot of noise in the signal.
## PID Tuning ## PID Tuning

6
doc/PID tuning.md
View File

@ -13,7 +13,7 @@ When tuning Thermostat PID parameters, it is helpful to view the temperature, PI
To use the Python real-time plotting utility, run To use the Python real-time plotting utility, run
```shell ```shell
python pythermostat/plot.py python pytec/plot.py
``` ```
![default view](./assets/default%20view.png) ![default view](./assets/default%20view.png)
@ -44,12 +44,12 @@ Below are some general guidelines for manually tuning PID loops. Note that every
## Auto Tuning ## 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. A PID auto tuning utility is provided in the Pytec 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 To run the auto tuning utility, run
```shell ```shell
python pythermostat/autotune.py python pytec/autotune.py
``` ```
After some time, the auto tuning utility will output the auto tuning results, below is a sample output After some time, the auto tuning utility will output the auto tuning results, below is a sample output

48
flake.lock
View File

@ -1,45 +1,41 @@
{ {
"nodes": { "nodes": {
"mozilla-overlay": {
"flake": false,
"locked": {
"lastModified": 1690536331,
"narHash": "sha256-aRIf2FB2GTdfF7gl13WyETmiV/J7EhBGkSWXfZvlxcA=",
"owner": "mozilla",
"repo": "nixpkgs-mozilla",
"rev": "db89c8707edcffefcd8e738459d511543a339ff5",
"type": "github"
},
"original": {
"owner": "mozilla",
"repo": "nixpkgs-mozilla",
"type": "github"
}
},
"nixpkgs": { "nixpkgs": {
"locked": { "locked": {
"lastModified": 1722791413, "lastModified": 1691421349,
"narHash": "sha256-rCTrlCWvHzMCNcKxPE3Z/mMK2gDZ+BvvpEVyRM4tKmU=", "narHash": "sha256-RRJyX0CUrs4uW4gMhd/X4rcDG8PTgaaCQM5rXEJOx6g=",
"owner": "NixOS", "owner": "NixOS",
"repo": "nixpkgs", "repo": "nixpkgs",
"rev": "8b5b6723aca5a51edf075936439d9cd3947b7b2c", "rev": "011567f35433879aae5024fc6ec53f2a0568a6c4",
"type": "github" "type": "github"
}, },
"original": { "original": {
"owner": "NixOS", "owner": "NixOS",
"ref": "nixos-24.05", "ref": "nixos-23.05",
"repo": "nixpkgs", "repo": "nixpkgs",
"type": "github" "type": "github"
} }
}, },
"root": { "root": {
"inputs": { "inputs": {
"nixpkgs": "nixpkgs", "mozilla-overlay": "mozilla-overlay",
"rust-overlay": "rust-overlay" "nixpkgs": "nixpkgs"
}
},
"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"
} }
} }
}, },

81
flake.nix
View File

@ -1,33 +1,32 @@
{ {
description = "Firmware for the Sinara 8451 Thermostat"; description = "Firmware for the Sinara 8451 Thermostat";
inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05"; inputs.nixpkgs.url = github:NixOS/nixpkgs/nixos-23.05;
inputs.rust-overlay = { inputs.mozilla-overlay = { url = github:mozilla/nixpkgs-mozilla; flake = false; };
url = "github:oxalica/rust-overlay";
inputs.nixpkgs.follows = "nixpkgs";
};
outputs = outputs = { self, nixpkgs, mozilla-overlay }:
{
self,
nixpkgs,
rust-overlay,
}:
let let
pkgs = import nixpkgs { pkgs = import nixpkgs { system = "x86_64-linux"; overlays = [ (import mozilla-overlay) ]; };
system = "x86_64-linux"; rustManifest = pkgs.fetchurl {
overlays = [ (import rust-overlay) ]; url = "https://static.rust-lang.org/dist/2022-12-15/channel-rust-stable.toml";
hash = "sha256-S7epLlflwt0d1GZP44u5Xosgf6dRrmr8xxC+Ml2Pq7c=";
}; };
rust = pkgs.rust-bin.stable."1.66.0".default.override { targets = [
extensions = [ "rust-src" ]; "thumbv7em-none-eabihf"
targets = [ "thumbv7em-none-eabihf" ]; ];
}; rustChannelOfTargets = _channel: _date: targets:
rustPlatform = pkgs.makeRustPlatform { (pkgs.lib.rustLib.fromManifestFile rustManifest {
inherit (pkgs) stdenv lib fetchurl patchelf;
}).rust.override {
inherit targets;
extensions = ["rust-src"];
};
rust = rustChannelOfTargets "stable" null targets;
rustPlatform = pkgs.recurseIntoAttrs (pkgs.makeRustPlatform {
rustc = rust; rustc = rust;
cargo = rust; cargo = rust;
}; });
thermostat = rustPlatform.buildRustPackage { thermostat = rustPlatform.buildRustPackage {
name = "thermostat"; name = "thermostat";
version = "0.0.0"; version = "0.0.0";
@ -55,48 +54,24 @@
''; '';
dontFixup = true; dontFixup = true;
auditable = false;
}; };
in {
pythermostat = pkgs.python3Packages.buildPythonPackage {
pname = "pythermostat";
version = "0.0.0";
src = "${self}/pythermostat";
propagatedBuildInputs =
with pkgs.python3Packages; [
numpy
matplotlib
];
};
in
{
packages.x86_64-linux = { packages.x86_64-linux = {
inherit thermostat pythermostat; inherit thermostat;
default = thermostat;
}; };
hydraJobs = { hydraJobs = {
inherit thermostat; inherit thermostat;
}; };
devShells.x86_64-linux.default = pkgs.mkShellNoCC { devShell.x86_64-linux = pkgs.mkShell {
name = "thermostat-dev-shell"; name = "thermostat-dev-shell";
packages = buildInputs = with pkgs; [
with pkgs; rust openocd dfu-util
[ ] ++ (with python3Packages; [
rust numpy matplotlib
llvm
openocd
dfu-util
rlwrap
]
++ (with python3Packages; [
numpy
matplotlib
]); ]);
}; };
defaultPackage.x86_64-linux = thermostat;
formatter.x86_64-linux = nixpkgs.legacyPackages.x86_64-linux.nixfmt-rfc-style;
}; };
} }

14
pythermostat/autotune.py → pytec/autotune.py
View File

@ -1,10 +1,9 @@
import math import math
import logging import logging
import time
from collections import deque, namedtuple from collections import deque, namedtuple
from enum import Enum from enum import Enum
from pythermostat.client import Client from pytec.client import Client
# Based on hirshmann pid-autotune libiary # Based on hirshmann pid-autotune libiary
# See https://github.com/hirschmann/pid-autotune # See https://github.com/hirschmann/pid-autotune
@ -237,14 +236,13 @@ def main():
tec = Client() tec = Client()
data = tec.get_report() data = next(tec.report_mode())
ch = data[channel] ch = data[channel]
tuner = PIDAutotune(target_temperature, output_step, tuner = PIDAutotune(target_temperature, output_step,
lookback, noiseband, ch['interval']) lookback, noiseband, ch['interval'])
while True: for data in tec.report_mode():
data = tec.get_report()
ch = data[channel] ch = data[channel]
@ -255,11 +253,9 @@ def main():
tuner_out = tuner.output() tuner_out = tuner.output()
tec.set_param("output", channel, "i_set", tuner_out) tec.set_param("pwm", channel, "i_set", tuner_out)
time.sleep(0.05) tec.set_param("pwm", channel, "i_set", 0)
tec.set_param("output", channel, "i_set", 0)
if __name__ == "__main__": if __name__ == "__main__":

11
pytec/example.py Normal file
View File

@ -0,0 +1,11 @@
from pytec.client import Client
tec = Client() #(host="localhost", port=6667)
tec.set_param("s-h", 1, "t0", 20)
print(tec.get_pwm())
print(tec.get_pid())
print(tec.get_pwm())
print(tec.get_postfilter())
print(tec.get_steinhart_hart())
for data in tec.report_mode():
print(data)

7
pythermostat/plot.py → pytec/plot.py
View File

@ -1,9 +1,8 @@
import time
import numpy as np import numpy as np
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
import matplotlib.animation as animation import matplotlib.animation as animation
from threading import Thread, Lock from threading import Thread, Lock
from pythermostat.client import Client from pytec.client import Client
TIME_WINDOW = 300.0 TIME_WINDOW = 300.0
@ -48,8 +47,7 @@ quit = False
def recv_data(tec): def recv_data(tec):
global last_packet_time global last_packet_time
while True: for data in tec.report_mode():
data = tec.get_report()
ch0 = data[0] ch0 = data[0]
series_lock.acquire() series_lock.acquire()
try: try:
@ -63,7 +61,6 @@ def recv_data(tec):
if quit: if quit:
break break
time.sleep(0.05)
thread = Thread(target=recv_data, args=(tec,)) thread = Thread(target=recv_data, args=(tec,))
thread.start() thread.start()

0
pythermostat/pythermostat/__init__.py → pytec/pytec/__init__.py
View File

112
pythermostat/pythermostat/client.py → pytec/pytec/client.py
View File

@ -2,7 +2,6 @@ import socket
import json import json
import logging import logging
class CommandError(Exception): class CommandError(Exception):
pass pass
@ -12,16 +11,12 @@ class Client:
self._lines = [""] self._lines = [""]
self._check_zero_limits() self._check_zero_limits()
def disconnect(self):
self._socket.shutdown(socket.SHUT_RDWR)
self._socket.close()
def _check_zero_limits(self): def _check_zero_limits(self):
output_report = self.get_output() pwm_report = self.get_pwm()
for output_channel in output_report: for pwm_channel in pwm_report:
for limit in ["max_i_neg", "max_i_pos", "max_v"]: for limit in ["max_i_neg", "max_i_pos", "max_v"]:
if output_channel[limit] == 0.0: if pwm_channel[limit]["value"] == 0.0:
logging.warning("`{}` limit is set to zero on channel {}".format(limit, output_channel["channel"])) logging.warning("`{}` limit is set to zero on channel {}".format(limit, pwm_channel["channel"]))
def _read_line(self): def _read_line(self):
# read more lines # read more lines
@ -51,27 +46,25 @@ class Client:
result[int(item["channel"])] = item result[int(item["channel"])] = item
return result return result
def get_output(self): def get_pwm(self):
"""Retrieve output limits for the TEC """Retrieve PWM limits for the TEC
Example:: Example::
[{'channel': 0, [{'channel': 0,
'center': 'vref', 'center': 'vref',
'i_set': -0.02002179650216762, 'i_set': {'max': 2.9802790335151985, 'value': -0.02002179650216762},
'max_i_neg': 2.0, 'max_i_neg': {'max': 3.0, 'value': 3.0},
'max_v': 3.988, 'max_v': {'max': 5.988, 'value': 5.988},
'max_i_pos': 2.0, 'max_i_pos': {'max': 3.0, 'value': 3.0}},
'polarity': 'normal',
{'channel': 1, {'channel': 1,
'center': 'vref', 'center': 'vref',
'i_set': -0.02002179650216762, 'i_set': {'max': 2.9802790335151985, 'value': -0.02002179650216762},
'max_i_neg': 2.0, 'max_i_neg': {'max': 3.0, 'value': 3.0},
'max_v': 3.988, 'max_v': {'max': 5.988, 'value': 5.988},
'max_i_pos': 2.0} 'max_i_pos': {'max': 3.0, 'value': 3.0}}
'polarity': 'normal',
] ]
""" """
return self._get_conf("output") return self._get_conf("pwm")
def get_pid(self): def get_pid(self):
"""Retrieve PID control state """Retrieve PID control state
@ -96,14 +89,14 @@ class Client:
""" """
return self._get_conf("pid") return self._get_conf("pid")
def get_b_parameter(self): def get_steinhart_hart(self):
"""Retrieve B-Parameter equation parameters for resistance to temperature conversion """Retrieve Steinhart-Hart parameters for resistance to temperature conversion
Example:: Example::
[{'params': {'b': 3800.0, 'r0': 10000.0, 't0': 298.15}, 'channel': 0}, [{'params': {'b': 3800.0, 'r0': 10000.0, 't0': 298.15}, 'channel': 0},
{'params': {'b': 3800.0, 'r0': 10000.0, 't0': 298.15}, 'channel': 1}] {'params': {'b': 3800.0, 'r0': 10000.0, 't0': 298.15}, 'channel': 1}]
""" """
return self._get_conf("b-p") return self._get_conf("s-h")
def get_postfilter(self): def get_postfilter(self):
"""Retrieve DAC postfilter configuration """Retrieve DAC postfilter configuration
@ -114,18 +107,18 @@ class Client:
""" """
return self._get_conf("postfilter") return self._get_conf("postfilter")
def get_report(self): def report_mode(self):
"""Obtain one-time report on measurement values """Start reporting measurement values
Example of yielded data:: Example of yielded data::
{'channel': 0, {'channel': 0,
'time': 2302524, 'time': 2302524,
'interval': 0.12
'adc': 0.6199188965423515, 'adc': 0.6199188965423515,
'sens': 6138.519310282602, 'sens': 6138.519310282602,
'temperature': 36.87032392655527, 'temperature': 36.87032392655527,
'pid_engaged': True, 'pid_engaged': True,
'i_set': 2.0635816680889123, 'i_set': 2.0635816680889123,
'vref': 1.494,
'dac_value': 2.527790834044456, 'dac_value': 2.527790834044456,
'dac_feedback': 2.523, 'dac_feedback': 2.523,
'i_tec': 2.331, 'i_tec': 2.331,
@ -133,27 +126,24 @@ class Client:
'tec_u_meas': 2.5340000000000003, 'tec_u_meas': 2.5340000000000003,
'pid_output': 2.067581958092247} 'pid_output': 2.067581958092247}
""" """
return self._get_conf("report") self._command("report mode", "on")
def get_ipv4(self): while True:
"""Get the IPv4 settings of the Thermostat""" line = self._read_line()
return self._command("ipv4") if not line:
break
def get_fan(self): try:
"""Get Thermostat current fan settings""" yield json.loads(line)
return self._command("fan") except json.decoder.JSONDecodeError:
pass
def get_hwrev(self):
"""Get Thermostat hardware revision"""
return self._command("hwrev")
def set_param(self, topic, channel, field="", value=""): def set_param(self, topic, channel, field="", value=""):
"""Set configuration parameters """Set configuration parameters
Examples:: Examples::
tec.set_param("output", 0, "max_v", 2.0) tec.set_param("pwm", 0, "max_v", 2.0)
tec.set_param("pid", 1, "output_max", 2.5) tec.set_param("pid", 1, "output_max", 2.5)
tec.set_param("b-p", 0, "t0", 20.0) tec.set_param("s-h", 0, "t0", 20.0)
tec.set_param("center", 0, "vref") tec.set_param("center", 0, "vref")
tec.set_param("postfilter", 1, 21) tec.set_param("postfilter", 1, 21)
@ -168,40 +158,12 @@ class Client:
def power_up(self, channel, target): def power_up(self, channel, target):
"""Start closed-loop mode""" """Start closed-loop mode"""
self.set_param("pid", channel, "target", value=target) self.set_param("pid", channel, "target", value=target)
self.set_param("output", channel, "pid") self.set_param("pwm", channel, "pid")
def save_config(self, channel=""): def save_config(self):
"""Save current configuration to EEPROM""" """Save current configuration to EEPROM"""
self._command("save", channel) self._command("save")
if channel != "":
self._read_line() # read the extra {}
def load_config(self, channel=""): def load_config(self):
"""Load current configuration from EEPROM""" """Load current configuration from EEPROM"""
self._command("load", channel) self._command("load")
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)

2
pythermostat/setup.py → pytec/setup.py
View File

@ -1,7 +1,7 @@
from setuptools import setup, find_packages from setuptools import setup, find_packages
setup( setup(
name="pythermostat", name="pytec",
version="0.0", version="0.0",
author="M-Labs", author="M-Labs",
url="https://git.m-labs.hk/M-Labs/thermostat", url="https://git.m-labs.hk/M-Labs/thermostat",

13
pythermostat/example.py
View File

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

81
pythermostat/test.py
View File

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

20
src/ad5680.rs
View File

@ -1,9 +1,12 @@
use crate::timer::sleep;
use stm32f4xx_hal::{ use stm32f4xx_hal::{
hal::{blocking::spi::Transfer, digital::v2::OutputPin}, hal::{
spi, blocking::spi::Transfer,
digital::v2::OutputPin,
},
time::MegaHertz, time::MegaHertz,
spi,
}; };
use crate::timer::sleep;
/// SPI Mode 1 /// SPI Mode 1
pub const SPI_MODE: spi::Mode = spi::Mode { pub const SPI_MODE: spi::Mode = spi::Mode {
@ -25,7 +28,10 @@ impl<SPI: Transfer<u8>, S: OutputPin> Dac<SPI, S> {
pub fn new(spi: SPI, mut sync: S) -> Self { pub fn new(spi: SPI, mut sync: S) -> Self {
let _ = sync.set_low(); let _ = sync.set_low();
Dac { spi, sync } Dac {
spi,
sync,
}
} }
fn write(&mut self, buf: &mut [u8]) -> Result<(), SPI::Error> { fn write(&mut self, buf: &mut [u8]) -> Result<(), SPI::Error> {
@ -41,7 +47,11 @@ impl<SPI: Transfer<u8>, S: OutputPin> Dac<SPI, S> {
pub fn set(&mut self, value: u32) -> Result<u32, SPI::Error> { pub fn set(&mut self, value: u32) -> Result<u32, SPI::Error> {
let value = value.min(MAX_VALUE); let value = value.min(MAX_VALUE);
let mut buf = [(value >> 14) as u8, (value >> 6) as u8, (value << 2) as u8]; let mut buf = [
(value >> 14) as u8,
(value >> 6) as u8,
(value << 2) as u8,
];
self.write(&mut buf)?; self.write(&mut buf)?;
Ok(value) Ok(value)
} }

121
src/ad7172/adc.rs
View File

@ -1,12 +1,18 @@
use super::{
checksum::{Checksum, ChecksumMode},
regs::{self, Register, RegisterData},
DigitalFilterOrder, Input, Mode, PostFilter, RefSource,
};
use core::fmt; use core::fmt;
use log::{info, warn}; use log::{info, warn};
use stm32f4xx_hal::hal::{blocking::spi::Transfer, digital::v2::OutputPin}; use stm32f4xx_hal::hal::{
use uom::si::{electric_potential::volt, f64::ElectricPotential}; blocking::spi::Transfer,
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 /// AD7172-2 implementation
/// ///
@ -21,8 +27,7 @@ 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> { pub fn new(spi: SPI, mut nss: NSS) -> Result<Self, SPI::Error> {
let _ = nss.set_high(); let _ = nss.set_high();
let mut adc = Adc { let mut adc = Adc {
spi, spi, nss,
nss,
checksum_mode: ChecksumMode::Off, checksum_mode: ChecksumMode::Off,
}; };
adc.reset()?; adc.reset()?;
@ -50,7 +55,8 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
/// `0x00DX` for AD7172-2 /// `0x00DX` for AD7172-2
pub fn identify(&mut self) -> Result<u16, SPI::Error> { pub fn identify(&mut self) -> Result<u16, SPI::Error> {
self.read_reg(&regs::Id).map(|id| id.id()) self.read_reg(&regs::Id)
.map(|id| id.id())
} }
pub fn set_checksum_mode(&mut self, mode: ChecksumMode) -> Result<(), SPI::Error> { pub fn set_checksum_mode(&mut self, mode: ChecksumMode) -> Result<(), SPI::Error> {
@ -70,10 +76,7 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
} }
pub fn setup_channel( pub fn setup_channel(
&mut self, &mut self, index: u8, in_pos: Input, in_neg: Input
index: u8,
in_pos: Input,
in_neg: Input,
) -> Result<(), SPI::Error> { ) -> Result<(), SPI::Error> {
self.update_reg(&regs::SetupCon { index }, |data| { self.update_reg(&regs::SetupCon { index }, |data| {
data.set_bipolar(false); data.set_bipolar(false);
@ -103,11 +106,7 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
let offset = self.read_reg(&regs::Offset { index })?.offset(); let offset = self.read_reg(&regs::Offset { index })?.offset();
let gain = self.read_reg(&regs::Gain { index })?.gain(); let gain = self.read_reg(&regs::Gain { index })?.gain();
let bipolar = self.read_reg(&regs::SetupCon { index })?.bipolar(); let bipolar = self.read_reg(&regs::SetupCon { index })?.bipolar();
Ok(ChannelCalibration { Ok(ChannelCalibration { offset, gain, bipolar })
offset,
gain,
bipolar,
})
} }
pub fn start_continuous_conversion(&mut self) -> Result<(), SPI::Error> { pub fn start_continuous_conversion(&mut self) -> Result<(), SPI::Error> {
@ -120,43 +119,44 @@ 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> { pub fn get_postfilter(&mut self, index: u8) -> Result<Option<PostFilter>, SPI::Error> {
self.read_reg(&regs::FiltCon { index }).map(|data| { self.read_reg(&regs::FiltCon { index })
if data.enh_filt_en() { .map(|data| {
Some(data.enh_filt()) if data.enh_filt_en() {
} else { Some(data.enh_filt())
None } else {
} None
}) }
})
} }
pub fn set_postfilter( pub fn set_postfilter(&mut self, index: u8, filter: Option<PostFilter>) -> Result<(), SPI::Error> {
&mut self, self.update_reg(&regs::FiltCon { index }, |data| {
index: u8, match filter {
filter: Option<PostFilter>, None => data.set_enh_filt_en(false),
) -> Result<(), SPI::Error> { Some(filter) => {
self.update_reg(&regs::FiltCon { index }, |data| match filter { data.set_enh_filt_en(true);
None => data.set_enh_filt_en(false), data.set_enh_filt(filter);
Some(filter) => { }
data.set_enh_filt_en(true);
data.set_enh_filt(filter);
} }
}) })
} }
/// Returns the channel the data is from /// Returns the channel the data is from
pub fn data_ready(&mut self) -> Result<Option<u8>, SPI::Error> { pub fn data_ready(&mut self) -> Result<Option<u8>, SPI::Error> {
self.read_reg(&regs::Status).map(|status| { self.read_reg(&regs::Status)
if status.ready() { .map(|status| {
Some(status.channel()) if status.ready() {
} else { Some(status.channel())
None } else {
} None
}) }
})
} }
/// Get data /// Get data
pub fn read_data(&mut self) -> Result<u32, SPI::Error> { pub fn read_data(&mut self) -> Result<u32, SPI::Error> {
self.read_reg(&regs::Data).map(|data| data.data()) self.read_reg(&regs::Data)
.map(|data| data.data())
} }
fn read_reg<R: regs::Register>(&mut self, reg: &R) -> Result<R::Data, SPI::Error> { fn read_reg<R: regs::Register>(&mut self, reg: &R) -> Result<R::Data, SPI::Error> {
@ -175,21 +175,12 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
break; break;
} }
// Retry // Retry
warn!( warn!("read_reg {:02X}: checksum error: {:?}!={:?}, retrying", reg.address(), checksum_expected, checksum_in);
"read_reg {:02X}: checksum error: {:?}!={:?}, retrying",
reg.address(),
checksum_expected,
checksum_in
);
} }
Ok(reg_data) Ok(reg_data)
} }
fn write_reg<R: regs::Register>( fn write_reg<R: regs::Register>(&mut self, reg: &R, reg_data: &mut R::Data) -> Result<(), SPI::Error> {
&mut self,
reg: &R,
reg_data: &mut R::Data,
) -> Result<(), SPI::Error> {
loop { loop {
let address = reg.address(); let address = reg.address();
let mut checksum = Checksum::new(match self.checksum_mode { let mut checksum = Checksum::new(match self.checksum_mode {
@ -199,7 +190,7 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
ChecksumMode::Crc => ChecksumMode::Crc, ChecksumMode::Crc => ChecksumMode::Crc,
}); });
checksum.feed(&[address]); checksum.feed(&[address]);
checksum.feed(reg_data); checksum.feed(&reg_data);
let checksum_out = checksum.result(); let checksum_out = checksum.result();
let mut data = reg_data.clone(); let mut data = reg_data.clone();
@ -210,10 +201,7 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
if *readback_data == **reg_data { if *readback_data == **reg_data {
return Ok(()); return Ok(());
} }
warn!( warn!("write_reg {:02X}: readback error, {:?}!={:?}, retrying", address, &*readback_data, &**reg_data);
"write_reg {:02X}: readback error, {:?}!={:?}, retrying",
address, &*readback_data, &**reg_data
);
} }
} }
@ -237,12 +225,7 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
Ok(()) Ok(())
} }
fn transfer( fn transfer<'w>(&mut self, addr: u8, reg_data: &'w mut [u8], checksum: Option<u8>) -> Result<Option<u8>, SPI::Error> {
&mut self,
addr: u8,
reg_data: &mut [u8],
checksum: Option<u8>,
) -> Result<Option<u8>, SPI::Error> {
let mut addr_buf = [addr]; let mut addr_buf = [addr];
let _ = self.nss.set_low(); let _ = self.nss.set_low();
@ -251,7 +234,8 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
Err(e) => Err(e), Err(e) => Err(e),
}; };
let result = match (result, checksum) { let result = match (result, checksum) {
(Ok(_), None) => Ok(None), (Ok(_), None) =>
Ok(None),
(Ok(_), Some(checksum_out)) => { (Ok(_), Some(checksum_out)) => {
let mut checksum_buf = [checksum_out; 1]; let mut checksum_buf = [checksum_out; 1];
match self.spi.transfer(&mut checksum_buf) { match self.spi.transfer(&mut checksum_buf) {
@ -259,7 +243,8 @@ 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), (Err(e), _) =>
Err(e),
}; };
let _ = self.nss.set_high(); let _ = self.nss.set_high();

8
src/ad7172/checksum.rs
View File

@ -29,13 +29,13 @@ impl Checksum {
fn feed_byte(&mut self, input: u8) { fn feed_byte(&mut self, input: u8) {
match self.mode { match self.mode {
ChecksumMode::Off => {} ChecksumMode::Off => {},
ChecksumMode::Xor => self.state ^= input, ChecksumMode::Xor => self.state ^= input,
ChecksumMode::Crc => { ChecksumMode::Crc => {
for i in 0..8 { for i in 0..8 {
let input_mask = 0x80 >> i; 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 */ 0x07 /* x8 + x2 + x + 1 */
} else { } else {
0 0
@ -54,7 +54,7 @@ impl Checksum {
pub fn result(&self) -> Option<u8> { pub fn result(&self) -> Option<u8> {
match self.mode { match self.mode {
ChecksumMode::Off => None, ChecksumMode::Off => None,
_ => Some(self.state), _ => Some(self.state)
} }
} }
} }

16
src/ad7172/mod.rs
View File

@ -1,10 +1,13 @@
use core::fmt; use core::fmt;
use num_traits::float::Float; use num_traits::float::Float;
use serde::{Deserialize, Serialize}; use serde::{Serialize, Deserialize};
use stm32f4xx_hal::{spi, time::MegaHertz}; use stm32f4xx_hal::{
time::MegaHertz,
spi,
};
mod checksum;
pub mod regs; pub mod regs;
mod checksum;
pub use checksum::ChecksumMode; pub use checksum::ChecksumMode;
mod adc; mod adc;
pub use adc::*; pub use adc::*;
@ -19,6 +22,7 @@ pub const SPI_CLOCK: MegaHertz = MegaHertz(2);
pub const MAX_VALUE: u32 = 0xFF_FFFF; pub const MAX_VALUE: u32 = 0xFF_FFFF;
#[derive(Clone, Copy, Debug)] #[derive(Clone, Copy, Debug)]
#[repr(u8)] #[repr(u8)]
pub enum Mode { pub enum Mode {
@ -101,8 +105,7 @@ impl fmt::Display for Input {
RefPos => "ref+", RefPos => "ref+",
RefNeg => "ref-", RefNeg => "ref-",
_ => "<INVALID>", _ => "<INVALID>",
} }.fmt(fmt)
.fmt(fmt)
} }
} }
@ -138,8 +141,7 @@ impl fmt::Display for RefSource {
Internal => "internal", Internal => "internal",
Avdd1MinusAvss => "avdd1-avss", Avdd1MinusAvss => "avdd1-avss",
_ => "<INVALID>", _ => "<INVALID>",
} }.fmt(fmt)
.fmt(fmt)
} }
} }

106
src/ad7172/regs.rs
View File

@ -1,6 +1,6 @@
use bit_field::BitField;
use byteorder::{BigEndian, ByteOrder};
use core::ops::{Deref, DerefMut}; use core::ops::{Deref, DerefMut};
use byteorder::{BigEndian, ByteOrder};
use bit_field::BitField;
use super::*; use super::*;
@ -9,7 +9,7 @@ pub trait Register {
fn address(&self) -> u8; fn address(&self) -> u8;
} }
pub trait RegisterData: Clone + Deref<Target = [u8]> + DerefMut { pub trait RegisterData: Clone + Deref<Target=[u8]> + DerefMut {
fn empty() -> Self; fn empty() -> Self;
} }
@ -49,9 +49,7 @@ macro_rules! def_reg {
} }
}; };
($Reg: ident, u8, $reg: ident, $addr: expr, $size: expr) => { ($Reg: ident, u8, $reg: ident, $addr: expr, $size: expr) => {
pub struct $Reg { pub struct $Reg { pub index: u8, }
pub index: u8,
}
impl Register for $Reg { impl Register for $Reg {
type Data = $reg::Data; type Data = $reg::Data;
fn address(&self) -> u8 { fn address(&self) -> u8 {
@ -78,7 +76,7 @@ macro_rules! def_reg {
} }
} }
} }
}; }
} }
macro_rules! reg_bit { macro_rules! reg_bit {
@ -148,7 +146,7 @@ def_reg!(Status, status, 0x00, 1);
impl status::Data { impl status::Data {
/// Is there new data to read? /// Is there new data to read?
pub fn ready(&self) -> bool { pub fn ready(&self) -> bool {
!self.not_ready() ! self.not_ready()
} }
reg_bit!(not_ready, 0, 7, "No data ready indicator"); reg_bit!(not_ready, 0, 7, "No data ready indicator");
@ -161,21 +159,9 @@ impl status::Data {
def_reg!(AdcMode, adc_mode, 0x01, 2); def_reg!(AdcMode, adc_mode, 0x01, 2);
impl adc_mode::Data { impl adc_mode::Data {
reg_bits!(delay, set_delay, 0, 0..=2, "Delay after channel switch"); reg_bits!(delay, set_delay, 0, 0..=2, "Delay after channel switch");
reg_bit!( reg_bit!(sing_cyc, set_sing_cyc, 0, 5, "Can only used with single channel");
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!(hide_delay, set_hide_delay, 0, 6, "Hide delay");
reg_bit!( reg_bit!(ref_en, set_ref_en, 0, 7, "Enable internal reference, output buffered 2.5 V to REFOUT");
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!(clockset, set_clocksel, 1, 2..=3, "Clock source");
reg_bits!(mode, set_mode, 1, 4..=6, Mode, "Operating mode"); reg_bits!(mode, set_mode, 1, 4..=6, Mode, "Operating mode");
} }
@ -188,19 +174,15 @@ impl if_mode::Data {
def_reg!(Data, data, 0x04, 3); def_reg!(Data, data, 0x04, 3);
impl data::Data { impl data::Data {
pub fn data(&self) -> u32 { pub fn data(&self) -> u32 {
(u32::from(self.0[0]) << 16) | (u32::from(self.0[1]) << 8) | u32::from(self.0[2]) (u32::from(self.0[0]) << 16) |
(u32::from(self.0[1]) << 8) |
u32::from(self.0[2])
} }
} }
def_reg!(GpioCon, gpio_con, 0x06, 2); def_reg!(GpioCon, gpio_con, 0x06, 2);
impl gpio_con::Data { impl gpio_con::Data {
reg_bit!( reg_bit!(sync_en, set_sync_en, 0, 3, "Enables the SYNC/ERROR pin as a sync input");
sync_en,
set_sync_en,
0,
3,
"Enables the SYNC/ERROR pin as a sync input"
);
} }
def_reg!(Id, id, 0x07, 2); def_reg!(Id, id, 0x07, 2);
@ -218,7 +200,8 @@ impl channel::Data {
/// Which input is connected to positive input of this channel /// Which input is connected to positive input of this channel
#[allow(unused)] #[allow(unused)]
pub fn a_in_pos(&self) -> Input { pub fn a_in_pos(&self) -> Input {
((self.0[0].get_bits(0..=1) << 3) | self.0[1].get_bits(5..=7)).into() ((self.0[0].get_bits(0..=1) << 3) |
self.0[1].get_bits(5..=7)).into()
} }
/// Set which input is connected to positive input of this channel /// Set which input is connected to positive input of this channel
#[allow(unused)] #[allow(unused)]
@ -227,66 +210,27 @@ impl channel::Data {
self.0[0].set_bits(0..=1, value >> 3); self.0[0].set_bits(0..=1, value >> 3);
self.0[1].set_bits(5..=7, value & 0x7); self.0[1].set_bits(5..=7, value & 0x7);
} }
reg_bits!( reg_bits!(a_in_neg, set_a_in_neg, 1, 0..=4, Input,
a_in_neg, "Which input is connected to negative input of this channel");
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); def_reg!(SetupCon, u8, setup_con, 0x20, 2);
impl setup_con::Data { impl setup_con::Data {
reg_bit!( reg_bit!(bipolar, set_bipolar, 0, 4, "Unipolar (`false`) or bipolar (`true`) coded output");
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_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!(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_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!(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_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!( reg_bits!(ref_sel, set_ref_sel, 1, 4..=5, RefSource, "Select reference source for conversion");
ref_sel,
set_ref_sel,
1,
4..=5,
RefSource,
"Select reference source for conversion"
);
} }
def_reg!(FiltCon, u8, filt_con, 0x28, 2); def_reg!(FiltCon, u8, filt_con, 0x28, 2);
impl filt_con::Data { 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!(sinc3_map, 0, 7, "If set, mapping of filter register changes to directly program the decimation rate of the sinc3 filter");
reg_bit!( reg_bit!(enh_filt_en, set_enh_filt_en, 0, 3, "Enable postfilters for enhanced 50Hz and 60Hz rejection");
enh_filt_en, reg_bits!(enh_filt, set_enh_filt, 0, 0..=2, PostFilter, "Select postfilters for enhanced 50Hz and 60Hz rejection");
set_enh_filt_en, reg_bits!(order, set_order, 1, 5..=6, DigitalFilterOrder, "order of the digital filter that processes the modulator data");
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"); reg_bits!(odr, set_odr, 1, 0..=4, "Output data rate");
} }
@ -294,7 +238,9 @@ def_reg!(Offset, u8, offset, 0x30, 3);
impl offset::Data { impl offset::Data {
#[allow(unused)] #[allow(unused)]
pub fn offset(&self) -> u32 { pub fn offset(&self) -> u32 {
(u32::from(self.0[0]) << 16) | (u32::from(self.0[1]) << 8) | u32::from(self.0[2]) (u32::from(self.0[0]) << 16) |
(u32::from(self.0[1]) << 8) |
u32::from(self.0[2])
} }
#[allow(unused)] #[allow(unused)]
pub fn set_offset(&mut self, value: u32) { pub fn set_offset(&mut self, value: u32) {
@ -308,7 +254,9 @@ def_reg!(Gain, u8, gain, 0x38, 3);
impl gain::Data { impl gain::Data {
#[allow(unused)] #[allow(unused)]
pub fn gain(&self) -> u32 { pub fn gain(&self) -> u32 {
(u32::from(self.0[0]) << 16) | (u32::from(self.0[1]) << 8) | u32::from(self.0[2]) (u32::from(self.0[0]) << 16) |
(u32::from(self.0[1]) << 8) |
u32::from(self.0[2])
} }
#[allow(unused)] #[allow(unused)]
pub fn set_gain(&mut self, value: u32) { pub fn set_gain(&mut self, value: u32) {

21
src/channel.rs
View File

@ -1,10 +1,14 @@
use crate::{
ad5680, ad7172,
channel_state::ChannelState,
pins::{ChannelPinSet, ChannelPins},
};
use stm32f4xx_hal::hal::digital::v2::OutputPin; use stm32f4xx_hal::hal::digital::v2::OutputPin;
use uom::si::{electric_potential::volt, f64::ElectricPotential}; use uom::si::{
f64::ElectricPotential,
electric_potential::volt,
};
use crate::{
ad5680,
ad7172,
channel_state::ChannelState,
pins::{ChannelPins, ChannelPinSet},
};
/// Marker type for the first channel /// Marker type for the first channel
pub struct Channel0; pub struct Channel0;
@ -20,7 +24,7 @@ pub struct Channel<C: ChannelPins> {
pub vref_meas: ElectricPotential, pub vref_meas: ElectricPotential,
pub shdn: C::Shdn, pub shdn: C::Shdn,
pub vref_pin: C::VRefPin, pub vref_pin: C::VRefPin,
pub itec_pin: C::ITecPin, pub itec_pin: C::ItecPin,
/// feedback from `dac` output /// feedback from `dac` output
pub dac_feedback_pin: C::DacFeedbackPin, pub dac_feedback_pin: C::DacFeedbackPin,
pub tec_u_meas_pin: C::TecUMeasPin, pub tec_u_meas_pin: C::TecUMeasPin,
@ -36,8 +40,7 @@ impl<C: ChannelPins> Channel<C> {
Channel { Channel {
state, state,
dac, dac, vref_meas,
vref_meas,
shdn: pins.shdn, shdn: pins.shdn,
vref_pin: pins.vref_pin, vref_pin: pins.vref_pin,
itec_pin: pins.itec_pin, itec_pin: pins.itec_pin,

44
src/channel_state.rs
View File

@ -1,21 +1,24 @@
use crate::{
ad7172, b_parameter as bp,
command_parser::{CenterPoint, Polarity},
config::PwmLimits,
pid,
};
use num_traits::Zero;
use smoltcp::time::{Duration, Instant}; use smoltcp::time::{Duration, Instant};
use uom::si::{ use uom::si::{
electric_current::ampere,
electric_potential::volt,
electrical_resistance::ohm,
f64::{ f64::{
ElectricCurrent, ElectricPotential, ElectricalResistance, ThermodynamicTemperature, Time, ElectricPotential,
ElectricCurrent,
ElectricalResistance,
ThermodynamicTemperature,
Time,
}, },
electric_potential::volt,
electric_current::ampere,
electrical_resistance::ohm,
thermodynamic_temperature::degree_celsius, thermodynamic_temperature::degree_celsius,
time::millisecond, time::millisecond,
}; };
use crate::{
ad7172,
pid,
steinhart_hart as sh,
command_parser::CenterPoint,
};
const R_INNER: f64 = 2.0 * 5100.0; const R_INNER: f64 = 2.0 * 5100.0;
const VREF_SENS: f64 = 3.3 / 2.0; const VREF_SENS: f64 = 3.3 / 2.0;
@ -29,11 +32,9 @@ pub struct ChannelState {
pub center: CenterPoint, pub center: CenterPoint,
pub dac_value: ElectricPotential, pub dac_value: ElectricPotential,
pub i_set: ElectricCurrent, pub i_set: ElectricCurrent,
pub pwm_limits: PwmLimits,
pub pid_engaged: bool, pub pid_engaged: bool,
pub pid: pid::Controller, pub pid: pid::Controller,
pub bp: bp::Parameters, pub sh: sh::Parameters,
pub polarity: Polarity,
} }
impl ChannelState { impl ChannelState {
@ -44,18 +45,12 @@ impl ChannelState {
adc_time: Instant::from_secs(0), adc_time: Instant::from_secs(0),
// default: 10 Hz // default: 10 Hz
adc_interval: Duration::from_millis(100), adc_interval: Duration::from_millis(100),
center: CenterPoint::VRef, center: CenterPoint::Vref,
dac_value: ElectricPotential::new::<volt>(0.0), dac_value: ElectricPotential::new::<volt>(0.0),
i_set: ElectricCurrent::new::<ampere>(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_engaged: false,
pid: pid::Controller::new(pid::Parameters::default()), pid: pid::Controller::new(pid::Parameters::default()),
bp: bp::Parameters::default(), sh: sh::Parameters::default(),
polarity: Polarity::Normal,
} }
} }
@ -72,7 +67,8 @@ impl ChannelState {
/// Update PID state on ADC input, calculate new DAC output /// Update PID state on ADC input, calculate new DAC output
pub fn update_pid(&mut self) -> Option<f64> { pub fn update_pid(&mut self) -> Option<f64> {
let temperature = self.get_temperature()?.get::<degree_celsius>(); let temperature = self.get_temperature()?
.get::<degree_celsius>();
let pid_output = self.pid.update(temperature); let pid_output = self.pid.update(temperature);
Some(pid_output) Some(pid_output)
} }
@ -100,7 +96,7 @@ impl ChannelState {
pub fn get_temperature(&self) -> Option<ThermodynamicTemperature> { pub fn get_temperature(&self) -> Option<ThermodynamicTemperature> {
let r = self.get_sens()?; let r = self.get_sens()?;
let temperature = self.bp.get_temperature(r); let temperature = self.sh.get_temperature(r);
Some(temperature) Some(temperature)
} }
} }

541
src/channels.rs
View File

@ -1,95 +1,64 @@
use crate::timer::sleep; use core::cmp::max_by;
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 heapless::{consts::U2, Vec};
use num_traits::Zero;
use serde::{Serialize, Serializer}; use serde::{Serialize, Serializer};
use smoltcp::time::Instant; use smoltcp::time::Instant;
use stm32f4xx_hal::hal; use stm32f4xx_hal::hal;
use uom::si::{ use uom::si::{
electric_current::ampere,
electric_potential::{millivolt, volt},
electrical_resistance::ohm,
f64::{ElectricCurrent, ElectricPotential, ElectricalResistance, Time}, f64::{ElectricCurrent, ElectricPotential, ElectricalResistance, Time},
electric_potential::{millivolt, volt},
electric_current::ampere,
electrical_resistance::ohm,
ratio::ratio, ratio::ratio,
thermodynamic_temperature::degree_celsius, thermodynamic_temperature::degree_celsius,
}; };
use crate::{
pub enum PinsAdcReadTarget { ad5680,
VRef, ad7172,
DacVfb, channel::{Channel, Channel0, Channel1},
ITec, channel_state::ChannelState,
VTec, command_parser::{CenterPoint, PwmPin},
} command_handler::JsonBuffer,
pins,
steinhart_hart,
hw_rev,
};
pub const CHANNELS: usize = 2; pub const CHANNELS: usize = 2;
pub const R_SENSE: f64 = 0.05; 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 // 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 { const DAC_OUT_V_MAX: f64 = 3.0;
dimension: PhantomData,
units: PhantomData,
value: 3.0,
};
// TODO: -pub // TODO: -pub
pub struct Channels { pub struct Channels<'a> {
channel0: Channel<Channel0>, channel0: Channel<Channel0>,
channel1: Channel<Channel1>, channel1: Channel<Channel1>,
pub adc: ad7172::Adc<pins::AdcSpi, pins::AdcNss>, pub adc: ad7172::Adc<pins::AdcSpi, pins::AdcNss>,
/// stm32f4 integrated adc /// stm32f4 integrated adc
pins_adc: pins::PinsAdc, pins_adc: pins::PinsAdc,
pub pwm: pins::PwmPins, pub pwm: pins::PwmPins,
hwrev: &'a hw_rev::HWRev,
} }
impl Channels { impl<'a> Channels<'a> {
pub fn new(pins: pins::Pins) -> Self { pub fn new(pins: pins::Pins, hwrev: &'a hw_rev::HWRev) -> Self {
let mut adc = ad7172::Adc::new(pins.adc_spi, pins.adc_nss).unwrap(); let mut adc = ad7172::Adc::new(pins.adc_spi, pins.adc_nss).unwrap();
// Feature not used // Feature not used
adc.set_sync_enable(false).unwrap(); adc.set_sync_enable(false).unwrap();
// Setup channels and start ADC // Setup channels and start ADC
adc.setup_channel(0, ad7172::Input::Ain2, ad7172::Input::Ain3) adc.setup_channel(0, ad7172::Input::Ain2, ad7172::Input::Ain3).unwrap();
.unwrap(); let adc_calibration0 = adc.get_calibration(0)
let adc_calibration0 = adc.get_calibration(0).expect("adc_calibration0"); .expect("adc_calibration0");
adc.setup_channel(1, ad7172::Input::Ain0, ad7172::Input::Ain1) adc.setup_channel(1, ad7172::Input::Ain0, ad7172::Input::Ain1).unwrap();
.unwrap(); let adc_calibration1 = adc.get_calibration(1)
let adc_calibration1 = adc.get_calibration(1).expect("adc_calibration1"); .expect("adc_calibration1");
adc.start_continuous_conversion().unwrap(); adc.start_continuous_conversion().unwrap();
let channel0 = Channel::new(pins.channel0, adc_calibration0); let channel0 = Channel::new(pins.channel0, adc_calibration0);
let channel1 = Channel::new(pins.channel1, adc_calibration1); let channel1 = Channel::new(pins.channel1, adc_calibration1);
let pins_adc = pins.pins_adc; let pins_adc = pins.pins_adc;
let pwm = pins.pwm; let pwm = pins.pwm;
let mut channels = Channels { let mut channels = Channels { channel0, channel1, adc, pins_adc, pwm, hwrev };
channel0,
channel1,
adc,
pins_adc,
pwm,
};
for channel in 0..CHANNELS { for channel in 0..CHANNELS {
channels.calibrate_dac_value(channel); channels.calibrate_dac_value(channel);
channels.set_i(channel, ElectricCurrent::new::<ampere>(0.0)); channels.set_i(channel, ElectricCurrent::new::<ampere>(0.0));
@ -130,10 +99,10 @@ impl Channels {
/// calculate the TEC i_set centerpoint /// calculate the TEC i_set centerpoint
pub fn get_center(&mut self, channel: usize) -> ElectricPotential { pub fn get_center(&mut self, channel: usize) -> ElectricPotential {
match self.channel_state(channel).center { match self.channel_state(channel).center {
CenterPoint::VRef => self.adc_read(channel, PinsAdcReadTarget::VRef, 8), CenterPoint::Vref =>
CenterPoint::Override(center_point) => { self.read_vref(channel),
ElectricPotential::new::<volt>(center_point.into()) CenterPoint::Override(center_point) =>
} ElectricPotential::new::<volt>(center_point.into()),
} }
} }
@ -143,14 +112,14 @@ impl Channels {
voltage voltage
} }
pub fn get_i_set(&mut self, channel: usize) -> ElectricCurrent { pub fn get_i(&mut self, channel: usize) -> ElectricCurrent {
let i_set = self.channel_state(channel).i_set; let i_set = self.channel_state(channel).i_set;
i_set i_set
} }
/// i_set DAC /// i_set DAC
fn set_dac(&mut self, channel: usize, voltage: ElectricPotential) -> ElectricPotential { fn set_dac(&mut self, channel: usize, voltage: ElectricPotential) -> ElectricPotential {
let value = ((voltage / DAC_OUT_V_MAX).get::<ratio>() * (ad5680::MAX_VALUE as f64)) as u32; let value = ((voltage / ElectricPotential::new::<volt>(DAC_OUT_V_MAX)).get::<ratio>() * (ad5680::MAX_VALUE as f64)) as u32 ;
match channel { match channel {
0 => self.channel0.dac.set(value).unwrap(), 0 => self.channel0.dac.set(value).unwrap(),
1 => self.channel1.dac.set(value).unwrap(), 1 => self.channel1.dac.set(value).unwrap(),
@ -161,122 +130,114 @@ impl Channels {
} }
pub fn set_i(&mut self, channel: usize, i_set: ElectricCurrent) -> ElectricCurrent { pub fn set_i(&mut self, channel: usize, i_set: ElectricCurrent) -> ElectricCurrent {
let i_set = i_set.min(MAX_TEC_I).max(-MAX_TEC_I); let vref_meas = match channel.into() {
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, 0 => self.channel0.vref_meas,
1 => self.channel1.vref_meas, 1 => self.channel1.vref_meas,
_ => unreachable!(), _ => unreachable!(),
}; };
let center_point = vref_meas; let center_point = vref_meas;
let r_sense = ElectricalResistance::new::<ohm>(R_SENSE); let r_sense = ElectricalResistance::new::<ohm>(R_SENSE);
let voltage = negate * i_set * 10.0 * r_sense + center_point; let voltage = i_set * 10.0 * r_sense + center_point;
let voltage = self.set_dac(channel, voltage); let voltage = self.set_dac(channel, voltage);
let i_set = (voltage - center_point) / (10.0 * r_sense);
negate * (voltage - center_point) / (10.0 * r_sense) self.channel_state(channel).i_set = i_set;
i_set
} }
/// AN4073: ADC Reading Dispersion can be reduced through Averaging pub fn read_dac_feedback(&mut self, channel: usize) -> ElectricPotential {
pub fn adc_read(
&mut self,
channel: usize,
adc_read_target: PinsAdcReadTarget,
avg_pt: u16,
) -> ElectricPotential {
let mut sample: u32 = 0;
match channel { match channel {
0 => { 0 => {
sample = match adc_read_target { let sample = self.pins_adc.convert(
PinsAdcReadTarget::VRef => match &self.channel0.vref_pin { &self.channel0.dac_feedback_pin,
Channel0VRef::Analog(vref_pin) => { stm32f4xx_hal::adc::config::SampleTime::Cycles_480
for _ in (0..avg_pt).rev() { );
sample += self.pins_adc.convert( let mv = self.pins_adc.sample_to_millivolts(sample);
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) ElectricPotential::new::<millivolt>(mv as f64)
} }
1 => { 1 => {
sample = match adc_read_target { let sample = self.pins_adc.convert(
PinsAdcReadTarget::VRef => match &self.channel1.vref_pin { &self.channel1.dac_feedback_pin,
Channel1VRef::Analog(vref_pin) => { stm32f4xx_hal::adc::config::SampleTime::Cycles_480
for _ in (0..avg_pt).rev() { );
sample += self.pins_adc.convert( let mv = self.pins_adc.sample_to_millivolts(sample);
vref_pin, ElectricPotential::new::<millivolt>(mv as f64)
stm32f4xx_hal::adc::config::SampleTime::Cycles_480, }
) as u32; _ => unreachable!(),
} }
sample / avg_pt as u32 }
}
Channel1VRef::Disabled(_) => 2048_u32, pub fn read_dac_feedback_until_stable(&mut self, channel: usize, tolerance: ElectricPotential) -> ElectricPotential {
}, let mut prev = self.read_dac_feedback(channel);
PinsAdcReadTarget::DacVfb => { loop {
for _ in (0..avg_pt).rev() { let current = self.read_dac_feedback(channel);
sample += self.pins_adc.convert( if (current - prev).abs() < tolerance {
&self.channel1.dac_feedback_pin, return current;
stm32f4xx_hal::adc::config::SampleTime::Cycles_480, }
) as u32; prev = current;
} }
sample / avg_pt as u32 }
}
PinsAdcReadTarget::ITec => { pub fn read_itec(&mut self, channel: usize) -> ElectricPotential {
for _ in (0..avg_pt).rev() { match channel {
sample += self.pins_adc.convert( 0 => {
&self.channel1.itec_pin, let sample = self.pins_adc.convert(
stm32f4xx_hal::adc::config::SampleTime::Cycles_480, &self.channel0.itec_pin,
) as u32; stm32f4xx_hal::adc::config::SampleTime::Cycles_480
} );
sample / avg_pt as u32 let mv = self.pins_adc.sample_to_millivolts(sample);
} ElectricPotential::new::<millivolt>(mv as f64)
PinsAdcReadTarget::VTec => { }
for _ in (0..avg_pt).rev() { 1 => {
sample += self.pins_adc.convert( let sample = self.pins_adc.convert(
&self.channel1.tec_u_meas_pin, &self.channel1.itec_pin,
stm32f4xx_hal::adc::config::SampleTime::Cycles_480, stm32f4xx_hal::adc::config::SampleTime::Cycles_480
) as u32; );
} let mv = self.pins_adc.sample_to_millivolts(sample);
sample / avg_pt as u32 ElectricPotential::new::<millivolt>(mv as f64)
} }
}; _ => unreachable!(),
let mv = self.pins_adc.sample_to_millivolts(sample as u16); }
}
/// 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) ElectricPotential::new::<millivolt>(mv as f64)
} }
_ => unreachable!(), _ => unreachable!(),
@ -303,13 +264,14 @@ impl Channels {
let samples = 50; let samples = 50;
let mut target_voltage = ElectricPotential::new::<volt>(0.0); let mut target_voltage = ElectricPotential::new::<volt>(0.0);
for _ in 0..samples { for _ in 0..samples {
target_voltage += self.get_center(channel); target_voltage = target_voltage + self.get_center(channel);
} }
target_voltage /= samples as f64; target_voltage = target_voltage / samples as f64;
let mut start_value = 1; let mut start_value = 1;
let mut best_error = ElectricPotential::new::<volt>(100.0); let mut best_error = ElectricPotential::new::<volt>(100.0);
for step in (5..18).rev() { for step in (0..18).rev() {
let mut prev_value = start_value;
for value in (start_value..=ad5680::MAX_VALUE).step_by(1 << step) { for value in (start_value..=ad5680::MAX_VALUE).step_by(1 << step) {
match channel { match channel {
0 => { 0 => {
@ -320,23 +282,24 @@ impl Channels {
} }
_ => unreachable!(), _ => unreachable!(),
} }
sleep(10);
let dac_feedback = self.adc_read(channel, PinsAdcReadTarget::DacVfb, 64); let dac_feedback = self.read_dac_feedback_until_stable(channel, ElectricPotential::new::<volt>(0.001));
let error = target_voltage - dac_feedback; let error = target_voltage - dac_feedback;
if error < ElectricPotential::new::<volt>(0.0) { if error < ElectricPotential::new::<volt>(0.0) {
break; break;
} else if error < best_error { } else if error < best_error {
best_error = error; best_error = error;
start_value = value; start_value = prev_value;
let vref = (value as f64 / ad5680::MAX_VALUE as f64) * DAC_OUT_V_MAX; let vref = (value as f64 / ad5680::MAX_VALUE as f64) * ElectricPotential::new::<volt>(DAC_OUT_V_MAX);
match channel { match channel {
0 => self.channel0.vref_meas = vref, 0 => self.channel0.vref_meas = vref,
1 => self.channel1.vref_meas = vref, 1 => self.channel1.vref_meas = vref,
_ => unreachable!(), _ => unreachable!(),
} }
} }
prev_value = value;
} }
} }
@ -362,116 +325,112 @@ impl Channels {
} }
} }
fn get_pwm(&self, channel: usize, pin: PwmPin) -> f64 {
fn get<P: hal::PwmPin<Duty=u16>>(pin: &P) -> f64 {
let duty = pin.get_duty();
let max = pin.get_max_duty();
duty as f64 / (max as f64)
}
match (channel, pin) {
(_, PwmPin::ISet) =>
panic!("i_set is no pwm pin"),
(0, PwmPin::MaxIPos) =>
get(&self.pwm.max_i_pos0),
(0, PwmPin::MaxINeg) =>
get(&self.pwm.max_i_neg0),
(0, PwmPin::MaxV) =>
get(&self.pwm.max_v0),
(1, PwmPin::MaxIPos) =>
get(&self.pwm.max_i_pos1),
(1, PwmPin::MaxINeg) =>
get(&self.pwm.max_i_neg1),
(1, PwmPin::MaxV) =>
get(&self.pwm.max_v1),
_ =>
unreachable!(),
}
}
pub fn get_max_v(&mut self, channel: usize) -> ElectricPotential { pub fn get_max_v(&mut self, channel: usize) -> ElectricPotential {
self.channel_state(channel).pwm_limits.max_v let max = 4.0 * ElectricPotential::new::<volt>(3.3);
let duty = self.get_pwm(channel, PwmPin::MaxV);
duty * max
} }
pub fn get_max_i_pos(&mut self, channel: usize) -> ElectricCurrent { pub fn get_max_i_pos(&mut self, channel: usize) -> (ElectricCurrent, ElectricCurrent) {
self.channel_state(channel).pwm_limits.max_i_pos 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 { pub fn get_max_i_neg(&mut self, channel: usize) -> (ElectricCurrent, ElectricCurrent) {
self.channel_state(channel).pwm_limits.max_i_neg let max = ElectricCurrent::new::<ampere>(3.0);
let duty = self.get_pwm(channel, PwmPin::MaxINeg);
(duty * max, max)
} }
// Get current passing through TEC // Get current passing through TEC
pub fn get_tec_i(&mut self, channel: usize) -> ElectricCurrent { pub fn get_tec_i(&mut self, channel: usize) -> ElectricCurrent {
let tec_i = (self.adc_read(channel, PinsAdcReadTarget::ITec, 16) (self.read_itec(channel) - self.read_vref(channel)) / ElectricalResistance::new::<ohm>(0.4)
- self.adc_read(channel, PinsAdcReadTarget::VRef, 16))
/ ElectricalResistance::new::<ohm>(0.4);
match self.channel_state(channel).polarity {
Polarity::Normal => tec_i,
Polarity::Reversed => -tec_i,
}
} }
// Get voltage across TEC // Get voltage across TEC
pub fn get_tec_v(&mut self, channel: usize) -> ElectricPotential { pub fn get_tec_v(&mut self, channel: usize) -> ElectricPotential {
(self.adc_read(channel, PinsAdcReadTarget::VTec, 16) - ElectricPotential::new::<volt>(1.5)) (self.read_tec_u_meas(channel) - ElectricPotential::new::<volt>(1.5)) * 4.0
* 4.0
} }
fn set_pwm(&mut self, channel: usize, pin: PwmPin, duty: f64) -> f64 { 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 max = pin.get_max_duty();
let value = ((duty * (max as f64)) as u16).min(max); let value = ((duty * (max as f64)) as u16).min(max);
pin.set_duty(value); pin.set_duty(value);
value as f64 / (max as f64) value as f64 / (max as f64)
} }
match (channel, pin) { match (channel, pin) {
(_, PwmPin::ISet) => panic!("i_set is no pwm pin"), (_, PwmPin::ISet) =>
(0, PwmPin::MaxIPos) => set(&mut self.pwm.max_i_pos0, duty), panic!("i_set is no pwm pin"),
(0, PwmPin::MaxINeg) => set(&mut self.pwm.max_i_neg0, duty), (0, PwmPin::MaxIPos) =>
(0, PwmPin::MaxV) => set(&mut self.pwm.max_v0, duty), set(&mut self.pwm.max_i_pos0, duty),
(1, PwmPin::MaxIPos) => set(&mut self.pwm.max_i_pos1, duty), (0, PwmPin::MaxINeg) =>
(1, PwmPin::MaxINeg) => set(&mut self.pwm.max_i_neg1, duty), set(&mut self.pwm.max_i_neg0, duty),
(1, PwmPin::MaxV) => set(&mut self.pwm.max_v1, duty), (0, PwmPin::MaxV) =>
_ => unreachable!(), set(&mut self.pwm.max_v0, duty),
(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( pub fn set_max_v(&mut self, channel: usize, max_v: ElectricPotential) -> (ElectricPotential, ElectricPotential) {
&mut self,
channel: usize,
max_v: ElectricPotential,
) -> (ElectricPotential, ElectricPotential) {
let max = 4.0 * ElectricPotential::new::<volt>(3.3); 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 = (max_v / max).get::<ratio>();
let duty = self.set_pwm(channel, PwmPin::MaxV, duty); let duty = self.set_pwm(channel, PwmPin::MaxV, duty);
self.channel_state(channel).pwm_limits.max_v = max_v;
(duty * max, max) (duty * max, max)
} }
pub fn set_max_i_pos( pub fn set_max_i_pos(&mut self, channel: usize, max_i_pos: ElectricCurrent) -> (ElectricCurrent, ElectricCurrent) {
&mut self,
channel: usize,
max_i_pos: ElectricCurrent,
) -> (ElectricCurrent, ElectricCurrent) {
let max = ElectricCurrent::new::<ampere>(3.0); let max = ElectricCurrent::new::<ampere>(3.0);
let max_i_pos = max_i_pos.min(MAX_TEC_I).max(ElectricCurrent::zero()); let duty = (max_i_pos / max).get::<ratio>();
let duty = (max_i_pos / MAX_TEC_I_DUTY_TO_CURRENT_RATE).get::<ratio>(); let duty = self.set_pwm(channel, PwmPin::MaxIPos, duty);
let duty = match self.channel_state(channel).polarity { (duty * max, max)
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( pub fn set_max_i_neg(&mut self, channel: usize, max_i_neg: ElectricCurrent) -> (ElectricCurrent, ElectricCurrent) {
&mut self,
channel: usize,
max_i_neg: ElectricCurrent,
) -> (ElectricCurrent, ElectricCurrent) {
let max = ElectricCurrent::new::<ampere>(3.0); let max = ElectricCurrent::new::<ampere>(3.0);
let max_i_neg = max_i_neg.min(MAX_TEC_I).max(ElectricCurrent::zero()); let duty = (max_i_neg / max).get::<ratio>();
let duty = (max_i_neg / MAX_TEC_I_DUTY_TO_CURRENT_RATE).get::<ratio>(); let duty = self.set_pwm(channel, PwmPin::MaxINeg, duty);
let duty = match self.channel_state(channel).polarity { (duty * max, max)
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 set_polarity(&mut self, channel: usize, polarity: Polarity) {
if self.channel_state(channel).polarity != polarity {
let i_set = self.channel_state(channel).i_set;
let max_i_pos = self.get_max_i_pos(channel);
let max_i_neg = self.get_max_i_neg(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 { fn report(&mut self, channel: usize) -> Report {
let i_set = self.get_i_set(channel); let i_set = self.get_i(channel);
let i_tec = self.adc_read(channel, PinsAdcReadTarget::ITec, 16); let i_tec = if self.hwrev.major > 2 {Some(self.read_itec(channel))} else {None};
let tec_i = self.get_tec_i(channel); let tec_i = if self.hwrev.major > 2 {Some(self.get_tec_i(channel))} else {None};
let dac_value = self.get_dac(channel); let dac_value = self.get_dac(channel);
let state = self.channel_state(channel); let state = self.channel_state(channel);
let pid_output = ElectricCurrent::new::<ampere>(state.pid.y1); let pid_output = ElectricCurrent::new::<ampere>(state.pid.y1);
@ -481,13 +440,12 @@ impl Channels {
interval: state.get_adc_interval(), interval: state.get_adc_interval(),
adc: state.get_adc(), adc: state.get_adc(),
sens: state.get_sens(), sens: state.get_sens(),
temperature: state temperature: state.get_temperature()
.get_temperature()
.map(|temperature| temperature.get::<degree_celsius>()), .map(|temperature| temperature.get::<degree_celsius>()),
pid_engaged: state.pid_engaged, pid_engaged: state.pid_engaged,
i_set, i_set,
dac_value, dac_value,
dac_feedback: self.adc_read(channel, PinsAdcReadTarget::DacVfb, 1), dac_feedback: self.read_dac_feedback(channel),
i_tec, i_tec,
tec_i, tec_i,
tec_u_meas: self.get_tec_v(channel), tec_u_meas: self.get_tec_v(channel),
@ -520,31 +478,27 @@ impl Channels {
false false
} }
fn output_summary(&mut self, channel: usize) -> OutputSummary { fn pwm_summary(&mut self, channel: usize) -> PwmSummary {
OutputSummary { PwmSummary {
channel, channel,
center: CenterPointJson(self.channel_state(channel).center.clone()), center: CenterPointJson(self.channel_state(channel).center.clone()),
i_set: self.get_i_set(channel), i_set: (self.get_i(channel), ElectricCurrent::new::<ampere>(3.0)).into(),
max_v: self.get_max_v(channel), max_v: (self.get_max_v(channel), ElectricPotential::new::<volt>(5.0)).into(),
max_i_pos: self.get_max_i_pos(channel), max_i_pos: self.get_max_i_pos(channel).into(),
max_i_neg: self.get_max_i_neg(channel), max_i_neg: self.get_max_i_neg(channel).into(),
polarity: PolarityJson(self.channel_state(channel).polarity.clone()),
} }
} }
pub fn output_summaries_json(&mut self) -> Result<JsonBuffer, serde_json_core::ser::Error> { pub fn pwm_summaries_json(&mut self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
let mut summaries = Vec::<_, U2>::new(); let mut summaries = Vec::<_, U2>::new();
for channel in 0..CHANNELS { for channel in 0..CHANNELS {
let _ = summaries.push(self.output_summary(channel)); let _ = summaries.push(self.pwm_summary(channel));
} }
serde_json_core::to_vec(&summaries) serde_json_core::to_vec(&summaries)
} }
fn postfilter_summary(&mut self, channel: usize) -> PostFilterSummary { fn postfilter_summary(&mut self, channel: usize) -> PostFilterSummary {
let rate = self let rate = self.adc.get_postfilter(channel as u8).unwrap()
.adc
.get_postfilter(channel as u8)
.unwrap()
.and_then(|filter| filter.output_rate()); .and_then(|filter| filter.output_rate());
PostFilterSummary { channel, rate } PostFilterSummary { channel, rate }
} }
@ -557,26 +511,23 @@ impl Channels {
serde_json_core::to_vec(&summaries) serde_json_core::to_vec(&summaries)
} }
fn b_parameter_summary(&mut self, channel: usize) -> BParameterSummary { fn steinhart_hart_summary(&mut self, channel: usize) -> SteinhartHartSummary {
let params = self.channel_state(channel).bp.clone(); let params = self.channel_state(channel).sh.clone();
BParameterSummary { channel, params } SteinhartHartSummary { channel, params }
} }
pub fn b_parameter_summaries_json( pub fn steinhart_hart_summaries_json(&mut self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
&mut self,
) -> Result<JsonBuffer, serde_json_core::ser::Error> {
let mut summaries = Vec::<_, U2>::new(); let mut summaries = Vec::<_, U2>::new();
for channel in 0..CHANNELS { for channel in 0..CHANNELS {
let _ = summaries.push(self.b_parameter_summary(channel)); let _ = summaries.push(self.steinhart_hart_summary(channel));
} }
serde_json_core::to_vec(&summaries) serde_json_core::to_vec(&summaries)
} }
pub fn current_abs_max_tec_i(&mut self) -> ElectricCurrent { pub fn current_abs_max_tec_i(&mut self) -> ElectricCurrent {
(0..CHANNELS) max_by(self.get_tec_i(0).abs(),
.map(|channel| self.get_tec_i(channel).abs()) self.get_tec_i(1).abs(),
.max_by(|a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal)) |a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal))
.unwrap()
} }
} }
@ -592,8 +543,8 @@ pub struct Report {
i_set: ElectricCurrent, i_set: ElectricCurrent,
dac_value: ElectricPotential, dac_value: ElectricPotential,
dac_feedback: ElectricPotential, dac_feedback: ElectricPotential,
i_tec: ElectricPotential, i_tec: Option<ElectricPotential>,
tec_i: ElectricCurrent, tec_i: Option<ElectricCurrent>,
tec_u_meas: ElectricPotential, tec_u_meas: ElectricPotential,
pid_output: ElectricCurrent, pid_output: ElectricCurrent,
} }
@ -607,36 +558,34 @@ impl Serialize for CenterPointJson {
S: Serializer, S: Serializer,
{ {
match self.0 { match self.0 {
CenterPoint::VRef => serializer.serialize_str("vref"), CenterPoint::Vref =>
CenterPoint::Override(vref) => serializer.serialize_f32(vref), serializer.serialize_str("vref"),
CenterPoint::Override(vref) =>
serializer.serialize_f32(vref),
} }
} }
} }
pub struct PolarityJson(Polarity); #[derive(Serialize)]
pub struct PwmSummaryField<T: Serialize> {
value: T,
max: T,
}
// used in JSON encoding, not for config impl<T: Serialize> From<(T, T)> for PwmSummaryField<T> {
impl Serialize for PolarityJson { fn from((value, max): (T, T)) -> Self {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> PwmSummaryField { value, max }
where
S: Serializer,
{
serializer.serialize_str(match self.0 {
Polarity::Normal => "normal",
Polarity::Reversed => "reversed",
})
} }
} }
#[derive(Serialize)] #[derive(Serialize)]
pub struct OutputSummary { pub struct PwmSummary {
channel: usize, channel: usize,
center: CenterPointJson, center: CenterPointJson,
i_set: ElectricCurrent, i_set: PwmSummaryField<ElectricCurrent>,
max_v: ElectricPotential, max_v: PwmSummaryField<ElectricPotential>,
max_i_pos: ElectricCurrent, max_i_pos: PwmSummaryField<ElectricCurrent>,
max_i_neg: ElectricCurrent, max_i_neg: PwmSummaryField<ElectricCurrent>,
polarity: PolarityJson,
} }
#[derive(Serialize)] #[derive(Serialize)]
@ -646,7 +595,7 @@ pub struct PostFilterSummary {
} }
#[derive(Serialize)] #[derive(Serialize)]
pub struct BParameterSummary { pub struct SteinhartHartSummary {
channel: usize, channel: usize,
params: b_parameter::Parameters, params: steinhart_hart::Parameters,
} }

328
src/command_handler.rs
View File

@ -1,30 +1,45 @@
use smoltcp::socket::TcpSocket;
use log::{error, warn};
use core::fmt::Write;
use heapless::{consts::U1024, Vec};
use super::{ use super::{
ad7172, net,
channels::{Channels, CHANNELS},
command_parser::{ command_parser::{
BpParameter, CenterPoint, Command, Ipv4Config, PidParameter, Polarity, PwmPin, ShowCommand, Ipv4Config,
Command,
ShowCommand,
CenterPoint,
PidParameter,
PwmPin,
ShParameter
},
ad7172,
CHANNEL_CONFIG_KEY,
channels::{
Channels,
CHANNELS
}, },
config::ChannelConfig, config::ChannelConfig,
dfu, dfu,
flash_store::FlashStore, flash_store::FlashStore,
session::Session,
FanCtrl,
hw_rev::HWRev, 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::{ use uom::{
electric_current::ampere, si::{
electric_potential::volt, f64::{
electrical_resistance::ohm, ElectricCurrent,
f64::{ ElectricPotential,
ElectricCurrent, ElectricPotential, ElectricalResistance, TemperatureInterval, ElectricalResistance,
ThermodynamicTemperature, ThermodynamicTemperature,
},
electric_current::ampere,
electric_potential::volt,
electrical_resistance::ohm,
thermodynamic_temperature::degree_celsius,
}, },
temperature_interval::kelvin,
thermodynamic_temperature::degree_celsius,
}; };
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq)]
@ -37,9 +52,9 @@ pub enum Handler {
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
pub enum Error { pub enum Error {
Report, ReportError,
PostFilterRate, PostFilterRateError,
Flash, FlashError
} }
pub type JsonBuffer = Vec<u8, U1024>; pub type JsonBuffer = Vec<u8, U1024>;
@ -51,19 +66,19 @@ fn send_line(socket: &mut TcpSocket, data: &[u8]) -> bool {
// instead of sending incomplete line // instead of sending incomplete line
warn!( warn!(
"TCP socket has only {}/{} needed {}", "TCP socket has only {}/{} needed {}",
send_free + 1, send_free + 1, socket.send_capacity(), data.len(),
socket.send_capacity(),
data.len(),
); );
} else { } else {
match socket.send_slice(data) { match socket.send_slice(&data) {
Ok(sent) if sent == data.len() => { Ok(sent) if sent == data.len() => {
let _ = socket.send_slice(b"\n"); let _ = socket.send_slice(b"\n");
// success // success
return true; return true
} }
Ok(sent) => warn!("sent only {}/{} bytes", sent, data.len()), Ok(sent) =>
Err(e) => error!("error sending line: {:?}", e), warn!("sent only {}/{} bytes", sent, data.len()),
Err(e) =>
error!("error sending line: {:?}", e),
} }
} }
// not success // not success
@ -71,6 +86,17 @@ fn send_line(socket: &mut TcpSocket, data: &[u8]) -> bool {
} }
impl Handler { impl Handler {
fn reporting(socket: &mut TcpSocket) -> Result<Handler, Error> {
send_line(socket, b"{}");
Ok(Handler::Handled)
}
fn show_report_mode(socket: &mut TcpSocket, session: &Session) -> Result<Handler, Error> {
let _ = writeln!(socket, "{{ \"report\": {:?} }}", session.reporting());
Ok(Handler::Handled)
}
fn show_report(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> { fn show_report(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
match channels.reports_json() { match channels.reports_json() {
Ok(buf) => { Ok(buf) => {
@ -79,7 +105,7 @@ impl Handler {
Err(e) => { Err(e) => {
error!("unable to serialize report: {:?}", e); error!("unable to serialize report: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e); let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Report); return Err(Error::ReportError);
} }
} }
Ok(Handler::Handled) Ok(Handler::Handled)
@ -93,41 +119,41 @@ impl Handler {
Err(e) => { Err(e) => {
error!("unable to serialize pid summary: {:?}", e); error!("unable to serialize pid summary: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e); let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Report); return Err(Error::ReportError);
} }
} }
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn show_pwm(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> { fn show_pwm(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
match channels.output_summaries_json() { match channels.pwm_summaries_json() {
Ok(buf) => { Ok(buf) => {
send_line(socket, &buf); send_line(socket, &buf);
} }
Err(e) => { Err(e) => {
error!("unable to serialize pwm summary: {:?}", e); error!("unable to serialize pwm summary: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e); let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Report); return Err(Error::ReportError);
} }
} }
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn show_b_parameter(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> { fn show_steinhart_hart(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
match channels.b_parameter_summaries_json() { match channels.steinhart_hart_summaries_json() {
Ok(buf) => { Ok(buf) => {
send_line(socket, &buf); send_line(socket, &buf);
} }
Err(e) => { Err(e) => {
error!("unable to serialize b parameter summaries: {:?}", e); error!("unable to serialize steinhart-hart summaries: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e); let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Report); return Err(Error::ReportError);
} }
} }
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn show_post_filter(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> { fn show_post_filter (socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
match channels.postfilter_summaries_json() { match channels.postfilter_summaries_json() {
Ok(buf) => { Ok(buf) => {
send_line(socket, &buf); send_line(socket, &buf);
@ -135,13 +161,13 @@ impl Handler {
Err(e) => { Err(e) => {
error!("unable to serialize postfilter summary: {:?}", e); error!("unable to serialize postfilter summary: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e); let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Report); return Err(Error::ReportError);
} }
} }
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn show_ipv4(socket: &mut TcpSocket, ipv4_config: &mut Ipv4Config) -> Result<Handler, Error> { fn show_ipv4 (socket: &mut TcpSocket, ipv4_config: &mut Ipv4Config) -> Result<Handler, Error> {
let (cidr, gateway) = net::split_ipv4_config(ipv4_config.clone()); let (cidr, gateway) = net::split_ipv4_config(ipv4_config.clone());
let _ = write!(socket, "{{\"addr\":\"{}\"", cidr); let _ = write!(socket, "{{\"addr\":\"{}\"", cidr);
gateway.map(|gateway| write!(socket, ",\"gateway\":\"{}\"", gateway)); gateway.map(|gateway| write!(socket, ",\"gateway\":\"{}\"", gateway));
@ -149,34 +175,13 @@ impl Handler {
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn engage_pid( fn engage_pid (socket: &mut TcpSocket, channels: &mut Channels, channel: usize) -> Result<Handler, Error> {
socket: &mut TcpSocket,
channels: &mut Channels,
channel: usize,
) -> Result<Handler, Error> {
channels.channel_state(channel).pid_engaged = true; channels.channel_state(channel).pid_engaged = true;
send_line(socket, b"{}"); send_line(socket, b"{}");
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn set_polarity( fn set_pwm (socket: &mut TcpSocket, channels: &mut Channels, channel: usize, pin: PwmPin, value: f64) -> Result<Handler, Error> {
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 { match pin {
PwmPin::ISet => { PwmPin::ISet => {
channels.channel_state(channel).pid_engaged = false; channels.channel_state(channel).pid_engaged = false;
@ -201,13 +206,8 @@ impl Handler {
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn set_center_point( fn set_center_point(socket: &mut TcpSocket, channels: &mut Channels, channel: usize, center: CenterPoint) -> Result<Handler, Error> {
socket: &mut TcpSocket, let i_set = channels.get_i(channel);
channels: &mut Channels,
channel: usize,
center: CenterPoint,
) -> Result<Handler, Error> {
let i_set = channels.get_i_set(channel);
let state = channels.channel_state(channel); let state = channels.channel_state(channel);
state.center = center; state.center = center;
if !state.pid_engaged { if !state.pid_engaged {
@ -217,91 +217,65 @@ impl Handler {
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn set_pid( fn set_pid (socket: &mut TcpSocket, channels: &mut Channels, channel: usize, parameter: PidParameter, value: f64) -> Result<Handler, Error> {
socket: &mut TcpSocket,
channels: &mut Channels,
channel: usize,
parameter: PidParameter,
value: f64,
) -> Result<Handler, Error> {
let pid = &mut channels.channel_state(channel).pid; let pid = &mut channels.channel_state(channel).pid;
use super::command_parser::PidParameter::*; use super::command_parser::PidParameter::*;
match parameter { match parameter {
Target => pid.target = value, Target =>
KP => pid.parameters.kp = value as f32, pid.target = value,
KI => pid.update_ki(value as f32), KP =>
KD => pid.parameters.kd = value as f32, pid.parameters.kp = value as f32,
OutputMin => pid.parameters.output_min = value as f32, KI =>
OutputMax => pid.parameters.output_max = value as f32, 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"{}"); send_line(socket, b"{}");
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn set_b_parameter( fn set_steinhart_hart (socket: &mut TcpSocket, channels: &mut Channels, channel: usize, parameter: ShParameter, value: f64) -> Result<Handler, Error> {
socket: &mut TcpSocket, let sh = &mut channels.channel_state(channel).sh;
channels: &mut Channels, use super::command_parser::ShParameter::*;
channel: usize,
parameter: BpParameter,
value: f64,
) -> Result<Handler, Error> {
let bp = &mut channels.channel_state(channel).bp;
use super::command_parser::BpParameter::*;
match parameter { match parameter {
T0 => bp.t0 = ThermodynamicTemperature::new::<degree_celsius>(value), T0 => sh.t0 = ThermodynamicTemperature::new::<degree_celsius>(value),
B => bp.b = TemperatureInterval::new::<kelvin>(value), B => sh.b = value,
R0 => bp.r0 = ElectricalResistance::new::<ohm>(value), R0 => sh.r0 = ElectricalResistance::new::<ohm>(value),
} }
send_line(socket, b"{}"); send_line(socket, b"{}");
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn reset_post_filter( fn reset_post_filter (socket: &mut TcpSocket, channels: &mut Channels, channel: usize) -> Result<Handler, Error> {
socket: &mut TcpSocket,
channels: &mut Channels,
channel: usize,
) -> Result<Handler, Error> {
channels.adc.set_postfilter(channel as u8, None).unwrap(); channels.adc.set_postfilter(channel as u8, None).unwrap();
send_line(socket, b"{}"); send_line(socket, b"{}");
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn set_post_filter( fn set_post_filter (socket: &mut TcpSocket, channels: &mut Channels, channel: usize, rate: f32) -> Result<Handler, Error> {
socket: &mut TcpSocket,
channels: &mut Channels,
channel: usize,
rate: f32,
) -> Result<Handler, Error> {
let filter = ad7172::PostFilter::closest(rate); let filter = ad7172::PostFilter::closest(rate);
match filter { match filter {
Some(filter) => { Some(filter) => {
channels channels.adc.set_postfilter(channel as u8, Some(filter)).unwrap();
.adc
.set_postfilter(channel as u8, Some(filter))
.unwrap();
send_line(socket, b"{}"); send_line(socket, b"{}");
} }
None => { None => {
error!("unable to choose postfilter for rate {:.3}", rate); error!("unable to choose postfilter for rate {:.3}", rate);
send_line( send_line(socket, b"{{\"error\": \"unable to choose postfilter rate\"}}");
socket, return Err(Error::PostFilterRateError);
b"{{\"error\": \"unable to choose postfilter rate\"}}",
);
return Err(Error::PostFilterRate);
} }
} }
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn load_channel( fn load_channel (socket: &mut TcpSocket, channels: &mut Channels, store: &mut FlashStore, channel: Option<usize>) -> Result<Handler, Error> {
socket: &mut TcpSocket, for c in 0..CHANNELS {
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) { if channel.is_none() || channel == Some(c) {
match store.read_value::<ChannelConfig>(key) { match store.read_value::<ChannelConfig>(CHANNEL_CONFIG_KEY[c]) {
Ok(Some(config)) => { Ok(Some(config)) => {
config.apply(channels, c); config.apply(channels, c);
send_line(socket, b"{}"); send_line(socket, b"{}");
@ -313,7 +287,7 @@ impl Handler {
Err(e) => { Err(e) => {
error!("unable to load config from flash: {:?}", e); error!("unable to load config from flash: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e); let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Flash); return Err(Error::FlashError);
} }
} }
} }
@ -321,24 +295,19 @@ impl Handler {
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn save_channel( fn save_channel (socket: &mut TcpSocket, channels: &mut Channels, channel: Option<usize>, store: &mut FlashStore) -> Result<Handler, Error> {
socket: &mut TcpSocket, for c in 0..CHANNELS {
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]; let mut store_value_buf = [0u8; 256];
if channel.is_none() || channel == Some(c) { if channel.is_none() || channel == Some(c) {
let config = ChannelConfig::new(channels, c); let config = ChannelConfig::new(channels, c);
match store.write_value(key, &config, &mut store_value_buf) { match store.write_value(CHANNEL_CONFIG_KEY[c], &config, &mut store_value_buf) {
Ok(()) => { Ok(()) => {
send_line(socket, b"{}"); send_line(socket, b"{}");
} }
Err(e) => { Err(e) => {
error!("unable to save channel {} config to flash: {:?}", c, e); error!("unable to save channel {} config to flash: {:?}", c, e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e); let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Flash); return Err(Error::FlashError);
} }
} }
} }
@ -346,11 +315,7 @@ impl Handler {
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn set_ipv4( fn set_ipv4 (socket: &mut TcpSocket, store: &mut FlashStore, config: Ipv4Config) -> Result<Handler, Error> {
socket: &mut TcpSocket,
store: &mut FlashStore,
config: Ipv4Config,
) -> Result<Handler, Error> {
let _ = store let _ = store
.write_value("ipv4", &config, [0; 16]) .write_value("ipv4", &config, [0; 16])
.map_err(|e| error!("unable to save ipv4 config to flash: {:?}", e)); .map_err(|e| error!("unable to save ipv4 config to flash: {:?}", e));
@ -359,7 +324,7 @@ impl Handler {
Ok(Handler::NewIPV4(new_ipv4_config.unwrap())) Ok(Handler::NewIPV4(new_ipv4_config.unwrap()))
} }
fn reset(channels: &mut Channels) -> Result<Handler, Error> { fn reset (channels: &mut Channels) -> Result<Handler, Error> {
for i in 0..CHANNELS { for i in 0..CHANNELS {
channels.power_down(i); channels.power_down(i);
} }
@ -367,7 +332,7 @@ impl Handler {
Ok(Handler::Reset) Ok(Handler::Reset)
} }
fn dfu(channels: &mut Channels) -> Result<Handler, Error> { fn dfu (channels: &mut Channels) -> Result<Handler, Error> {
for i in 0..CHANNELS { for i in 0..CHANNELS {
channels.power_down(i); channels.power_down(i);
} }
@ -378,16 +343,9 @@ impl Handler {
Ok(Handler::Reset) Ok(Handler::Reset)
} }
fn set_fan( fn set_fan(socket: &mut TcpSocket, fan_pwm: u32, fan_ctrl: &mut FanCtrl) -> Result<Handler, Error> {
socket: &mut TcpSocket,
fan_pwm: u32,
fan_ctrl: &mut FanCtrl,
) -> Result<Handler, Error> {
if !fan_ctrl.fan_available() { if !fan_ctrl.fan_available() {
send_line( send_line(socket, b"{ \"warning\": \"this thermostat doesn't have fan!\" }");
socket,
b"{ \"warning\": \"this thermostat doesn't have a fan!\" }",
);
return Ok(Handler::Handled); return Ok(Handler::Handled);
} }
fan_ctrl.set_auto_mode(false); fan_ctrl.set_auto_mode(false);
@ -409,17 +367,14 @@ impl Handler {
Err(e) => { Err(e) => {
error!("unable to serialize fan summary: {:?}", e); error!("unable to serialize fan summary: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e); let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
Err(Error::Report) Err(Error::ReportError)
} }
} }
} }
fn fan_auto(socket: &mut TcpSocket, fan_ctrl: &mut FanCtrl) -> Result<Handler, Error> { fn fan_auto(socket: &mut TcpSocket, fan_ctrl: &mut FanCtrl) -> Result<Handler, Error> {
if !fan_ctrl.fan_available() { if !fan_ctrl.fan_available() {
send_line( send_line(socket, b"{ \"warning\": \"this thermostat doesn't have fan!\" }");
socket,
b"{ \"warning\": \"this thermostat doesn't have a fan!\" }",
);
return Ok(Handler::Handled); return Ok(Handler::Handled);
} }
fan_ctrl.set_auto_mode(true); fan_ctrl.set_auto_mode(true);
@ -431,13 +386,7 @@ impl Handler {
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn fan_curve( fn fan_curve(socket: &mut TcpSocket, fan_ctrl: &mut FanCtrl, k_a: f32, k_b: f32, k_c: f32) -> Result<Handler, Error> {
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); fan_ctrl.set_curve(k_a, k_b, k_c);
send_line(socket, b"{}"); send_line(socket, b"{}");
Ok(Handler::Handled) Ok(Handler::Handled)
@ -458,69 +407,38 @@ impl Handler {
Err(e) => { Err(e) => {
error!("unable to serialize HWRev summary: {:?}", e); error!("unable to serialize HWRev summary: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e); let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
Err(Error::Report) Err(Error::ReportError)
} }
} }
} }
pub fn handle_command( pub fn handle_command(command: Command, socket: &mut TcpSocket, channels: &mut Channels, session: &Session, store: &mut FlashStore, ipv4_config: &mut Ipv4Config, fan_ctrl: &mut FanCtrl, hwrev: HWRev) -> Result<Self, Error> {
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 { match command {
Command::Quit => Ok(Handler::CloseSocket), Command::Quit => Ok(Handler::CloseSocket),
Command::Reporting(_reporting) => Handler::reporting(socket),
Command::Show(ShowCommand::Reporting) => Handler::show_report_mode(socket, session),
Command::Show(ShowCommand::Input) => Handler::show_report(socket, channels), Command::Show(ShowCommand::Input) => Handler::show_report(socket, channels),
Command::Show(ShowCommand::Pid) => Handler::show_pid(socket, channels), Command::Show(ShowCommand::Pid) => Handler::show_pid(socket, channels),
Command::Show(ShowCommand::Output) => Handler::show_pwm(socket, channels), Command::Show(ShowCommand::Pwm) => Handler::show_pwm(socket, channels),
Command::Show(ShowCommand::BParameter) => Handler::show_b_parameter(socket, channels), Command::Show(ShowCommand::SteinhartHart) => Handler::show_steinhart_hart(socket, channels),
Command::Show(ShowCommand::PostFilter) => Handler::show_post_filter(socket, channels), Command::Show(ShowCommand::PostFilter) => Handler::show_post_filter(socket, channels),
Command::Show(ShowCommand::Ipv4) => Handler::show_ipv4(socket, ipv4_config), Command::Show(ShowCommand::Ipv4) => Handler::show_ipv4(socket, ipv4_config),
Command::OutputPid { channel } => Handler::engage_pid(socket, channels, channel), Command::PwmPid { channel } => Handler::engage_pid(socket, channels, channel),
Command::OutputPolarity { channel, polarity } => { Command::Pwm { channel, pin, value } => Handler::set_pwm(socket, channels, channel, pin, value),
Handler::set_polarity(socket, channels, channel, polarity) 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::Output { Command::SteinhartHart { channel, parameter, value } => Handler::set_steinhart_hart(socket, channels, channel, parameter, value),
channel, Command::PostFilter { channel, rate: None } => Handler::reset_post_filter(socket, channels, channel),
pin, Command::PostFilter { channel, rate: Some(rate) } => Handler::set_post_filter(socket, channels, channel, rate),
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::Load { channel } => Handler::load_channel(socket, channels, store, channel),
Command::Save { channel } => Handler::save_channel(socket, channels, channel, store), Command::Save { channel } => Handler::save_channel(socket, channels, channel, store),
Command::Ipv4(config) => Handler::set_ipv4(socket, store, config), Command::Ipv4(config) => Handler::set_ipv4(socket, store, config),
Command::Reset => Handler::reset(channels), Command::Reset => Handler::reset(channels),
Command::Dfu => Handler::dfu(channels), Command::Dfu => Handler::dfu(channels),
Command::FanSet { fan_pwm } => Handler::set_fan(socket, fan_pwm, fan_ctrl), Command::FanSet {fan_pwm} => Handler::set_fan(socket, fan_pwm, fan_ctrl),
Command::ShowFan => Handler::show_fan(socket, fan_ctrl), Command::ShowFan => Handler::show_fan(socket, fan_ctrl),
Command::FanAuto => Handler::fan_auto(socket, fan_ctrl), Command::FanAuto => Handler::fan_auto(socket, fan_ctrl),
Command::FanCurve { k_a, k_b, k_c } => { Command::FanCurve { k_a, k_b, k_c } => Handler::fan_curve(socket, fan_ctrl, 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::FanCurveDefaults => Handler::fan_defaults(socket, fan_ctrl),
Command::ShowHWRev => Handler::show_hwrev(socket, hwrev), Command::ShowHWRev => Handler::show_hwrev(socket, hwrev),
} }

636
src/command_parser.rs
View File

@ -2,20 +2,19 @@ use core::fmt;
use core::num::ParseIntError; use core::num::ParseIntError;
use core::str::{from_utf8, Utf8Error}; use core::str::{from_utf8, Utf8Error};
use nom::{ use nom::{
IResult,
branch::alt, branch::alt,
bytes::complete::{is_a, tag, take_while1}, bytes::complete::{is_a, tag, take_while1},
character::{ character::{is_digit, complete::{char, one_of}},
complete::{char, one_of},
is_digit,
},
combinator::{complete, map, opt, value}, combinator::{complete, map, opt, value},
error::ErrorKind,
multi::{fold_many0, fold_many1},
sequence::preceded, sequence::preceded,
IResult, Needed, multi::{fold_many0, fold_many1},
error::ErrorKind,
Needed,
}; };
use num_traits::{Num, ParseFloatError}; use num_traits::{Num, ParseFloatError};
use serde::{Deserialize, Serialize}; use serde::{Serialize, Deserialize};
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
pub enum Error { pub enum Error {
@ -31,9 +30,12 @@ pub enum Error {
impl<'t> From<nom::Err<(&'t [u8], ErrorKind)>> for Error { impl<'t> From<nom::Err<(&'t [u8], ErrorKind)>> for Error {
fn from(e: nom::Err<(&'t [u8], ErrorKind)>) -> Self { fn from(e: nom::Err<(&'t [u8], ErrorKind)>) -> Self {
match e { match e {
nom::Err::Incomplete(_) => Error::Incomplete, nom::Err::Incomplete(_) =>
nom::Err::Error((_, e)) => Error::Parser(e), Error::Incomplete,
nom::Err::Failure((_, e)) => Error::Parser(e), nom::Err::Error((_, e)) =>
Error::Parser(e),
nom::Err::Failure((_, e)) =>
Error::Parser(e),
} }
} }
} }
@ -59,7 +61,8 @@ impl From<ParseFloatError> for Error {
impl fmt::Display for Error { impl fmt::Display for Error {
fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> { fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
match self { match self {
Error::Incomplete => "incomplete input".fmt(fmt), Error::Incomplete =>
"incomplete input".fmt(fmt),
Error::UnexpectedInput(c) => { Error::UnexpectedInput(c) => {
"unexpected input: ".fmt(fmt)?; "unexpected input: ".fmt(fmt)?;
c.fmt(fmt) c.fmt(fmt)
@ -76,7 +79,9 @@ impl fmt::Display for Error {
"parsing int: ".fmt(fmt)?; "parsing int: ".fmt(fmt)?;
(e as &dyn core::fmt::Debug).fmt(fmt) (e as &dyn core::fmt::Debug).fmt(fmt)
} }
Error::ParseFloat => "parsing float".fmt(fmt), Error::ParseFloat => {
"parsing float".fmt(fmt)
}
} }
} }
} }
@ -91,9 +96,10 @@ pub struct Ipv4Config {
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq)]
pub enum ShowCommand { pub enum ShowCommand {
Input, Input,
Output, Reporting,
Pwm,
Pid, Pid,
BParameter, SteinhartHart,
PostFilter, PostFilter,
Ipv4, Ipv4,
} }
@ -108,9 +114,9 @@ pub enum PidParameter {
OutputMax, OutputMax,
} }
/// B-Parameter equation parameter /// Steinhart-Hart equation parameter
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq)]
pub enum BpParameter { pub enum ShParameter {
T0, T0,
B, B,
R0, R0,
@ -126,16 +132,10 @@ pub enum PwmPin {
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum CenterPoint { pub enum CenterPoint {
VRef, Vref,
Override(f32), Override(f32),
} }
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Polarity {
Normal,
Reversed,
}
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq)]
pub enum Command { pub enum Command {
Quit, Quit,
@ -148,20 +148,17 @@ pub enum Command {
Reset, Reset,
Ipv4(Ipv4Config), Ipv4(Ipv4Config),
Show(ShowCommand), Show(ShowCommand),
Reporting(bool),
/// PWM parameter setting /// PWM parameter setting
Output { Pwm {
channel: usize, channel: usize,
pin: PwmPin, pin: PwmPin,
value: f64, value: f64,
}, },
/// Enable PID control for `i_set` /// Enable PID control for `i_set`
OutputPid { PwmPid {
channel: usize, channel: usize,
}, },
OutputPolarity {
channel: usize,
polarity: Polarity,
},
CenterPoint { CenterPoint {
channel: usize, channel: usize,
center: CenterPoint, center: CenterPoint,
@ -172,9 +169,9 @@ pub enum Command {
parameter: PidParameter, parameter: PidParameter,
value: f64, value: f64,
}, },
BParameter { SteinhartHart {
channel: usize, channel: usize,
parameter: BpParameter, parameter: ShParameter,
value: f64, value: f64,
}, },
PostFilter { PostFilter {
@ -183,7 +180,7 @@ pub enum Command {
}, },
Dfu, Dfu,
FanSet { FanSet {
fan_pwm: u32, fan_pwm: u32
}, },
FanAuto, FanAuto,
ShowFan, ShowFan,
@ -197,7 +194,12 @@ pub enum Command {
} }
fn end(input: &[u8]) -> IResult<&[u8], ()> { fn end(input: &[u8]) -> IResult<&[u8], ()> {
complete(fold_many0(one_of("\r\n\t "), (), |(), _| ()))(input) complete(
fold_many0(
one_of("\r\n\t "),
(), |(), _| ()
)
)(input)
} }
fn whitespace(input: &[u8]) -> IResult<&[u8], ()> { fn whitespace(input: &[u8]) -> IResult<&[u8], ()> {
@ -205,25 +207,38 @@ fn whitespace(input: &[u8]) -> IResult<&[u8], ()> {
} }
fn unsigned(input: &[u8]) -> IResult<&[u8], Result<u32, Error>> { fn unsigned(input: &[u8]) -> IResult<&[u8], Result<u32, Error>> {
take_while1(is_digit)(input).map(|(input, digits)| { take_while1(is_digit)(input)
let result = from_utf8(digits) .map(|(input, digits)| {
.map_err(|e| e.into()) let result =
.and_then(|digits| digits.parse::<u32>().map_err(|e| e.into())); from_utf8(digits)
(input, result) .map_err(|e| e.into())
}) .and_then(|digits| u32::from_str_radix(digits, 10)
.map_err(|e| e.into())
);
(input, result)
})
} }
fn float(input: &[u8]) -> IResult<&[u8], Result<f64, Error>> { fn float(input: &[u8]) -> IResult<&[u8], Result<f64, Error>> {
let (input, sign) = opt(is_a("-"))(input)?; let (input, sign) = opt(is_a("-"))(input)?;
let negative = sign.is_some(); let negative = sign.is_some();
let (input, digits) = take_while1(|c| is_digit(c) || c == b'.')(input)?; let (input, digits) = take_while1(|c| is_digit(c) || c == '.' as u8)(input)?;
let result = from_utf8(digits) let result =
from_utf8(digits)
.map_err(|e| e.into()) .map_err(|e| e.into())
.and_then(|digits| f64::from_str_radix(digits, 10).map_err(|e| e.into())) .and_then(|digits| f64::from_str_radix(digits, 10)
.map_err(|e| e.into())
)
.map(|result: f64| if negative { -result } else { result }); .map(|result: f64| if negative { -result } else { result });
Ok((input, result)) Ok((input, result))
} }
fn off_on(input: &[u8]) -> IResult<&[u8], bool> {
alt((value(false, tag("off")),
value(true, tag("on"))
))(input)
}
fn channel(input: &[u8]) -> IResult<&[u8], usize> { fn channel(input: &[u8]) -> IResult<&[u8], usize> {
map(one_of("01"), |c| (c as usize) - ('0' as usize))(input) map(one_of("01"), |c| (c as usize) - ('0' as usize))(input)
} }
@ -231,55 +246,83 @@ fn channel(input: &[u8]) -> IResult<&[u8], usize> {
fn report(input: &[u8]) -> IResult<&[u8], Command> { fn report(input: &[u8]) -> IResult<&[u8], Command> {
preceded( preceded(
tag("report"), tag("report"),
// `report` - Report once alt((
value(Command::Show(ShowCommand::Input), end), preceded(
whitespace,
preceded(
tag("mode"),
alt((
preceded(
whitespace,
// `report mode <on | off>` - Switch repoting mode
map(off_on, Command::Reporting)
),
// `report mode` - Show current reporting state
value(Command::Show(ShowCommand::Reporting), end)
))
)),
// `report` - Report once
value(Command::Show(ShowCommand::Input), end)
))
)(input) )(input)
} }
fn pwm_setup(input: &[u8]) -> IResult<&[u8], Result<(PwmPin, f64), Error>> { fn pwm_setup(input: &[u8]) -> IResult<&[u8], Result<(PwmPin, f64), Error>> {
let result_with_pin = let result_with_pin = |pin: PwmPin|
|pin: PwmPin| move |result: Result<f64, Error>| result.map(|value| (pin, value)); move |result: Result<f64, Error>|
result.map(|value| (pin, value));
alt(( alt((
map( map(
preceded(tag("i_set"), preceded(whitespace, float)), preceded(
result_with_pin(PwmPin::ISet), tag("i_set"),
preceded(
whitespace,
float
)
),
result_with_pin(PwmPin::ISet)
), ),
map( map(
preceded(tag("max_i_pos"), preceded(whitespace, float)), preceded(
result_with_pin(PwmPin::MaxIPos), tag("max_i_pos"),
preceded(
whitespace,
float
)
),
result_with_pin(PwmPin::MaxIPos)
), ),
map( map(
preceded(tag("max_i_neg"), preceded(whitespace, float)), preceded(
result_with_pin(PwmPin::MaxINeg), tag("max_i_neg"),
preceded(
whitespace,
float
)
),
result_with_pin(PwmPin::MaxINeg)
), ),
map( map(
preceded(tag("max_v"), preceded(whitespace, float)), preceded(
result_with_pin(PwmPin::MaxV), tag("max_v"),
), preceded(
))(input) whitespace,
} float
)
/// `output <0-1> pid` - Set output to be controlled by PID ),
fn output_pid(input: &[u8]) -> IResult<&[u8], ()> { result_with_pin(PwmPin::MaxV)
value((), tag("pid"))(input) ))
}
fn output_polarity(input: &[u8]) -> IResult<&[u8], Polarity> {
preceded(
tag("polarity"),
preceded(
whitespace,
alt((
value(Polarity::Normal, tag("normal")),
value(Polarity::Reversed, tag("reversed")),
)),
),
)(input) )(input)
} }
fn output(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> { /// `pwm <0-1> pid` - Set PWM to be controlled by PID
let (input, _) = tag("output")(input)?; fn pwm_pid(input: &[u8]) -> IResult<&[u8], ()> {
value((), tag("pid"))(input)
}
fn pwm(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, _) = tag("pwm")(input)?;
alt(( alt((
|input| { |input| {
let (input, _) = whitespace(input)?; let (input, _) = whitespace(input)?;
@ -287,32 +330,23 @@ fn output(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, _) = whitespace(input)?; let (input, _) = whitespace(input)?;
let (input, result) = alt(( let (input, result) = alt((
|input| { |input| {
let (input, ()) = output_pid(input)?; let (input, ()) = pwm_pid(input)?;
Ok((input, Ok(Command::OutputPid { channel }))) Ok((input, Ok(Command::PwmPid { channel })))
},
|input| {
let (input, polarity) = output_polarity(input)?;
Ok((input, Ok(Command::OutputPolarity { channel, polarity })))
}, },
|input| { |input| {
let (input, config) = pwm_setup(input)?; let (input, config) = pwm_setup(input)?;
match config { match config {
Ok((pin, value)) => Ok(( Ok((pin, value)) =>
input, Ok((input, Ok(Command::Pwm { channel, pin, value }))),
Ok(Command::Output { Err(e) =>
channel, Ok((input, Err(e))),
pin,
value,
}),
)),
Err(e) => Ok((input, Err(e))),
} }
}, },
))(input)?; ))(input)?;
end(input)?; end(input)?;
Ok((input, result)) Ok((input, result))
}, },
value(Ok(Command::Show(ShowCommand::Output)), end), value(Ok(Command::Show(ShowCommand::Pwm)), end)
))(input) ))(input)
} }
@ -321,39 +355,36 @@ fn center_point(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, _) = whitespace(input)?; let (input, _) = whitespace(input)?;
let (input, channel) = channel(input)?; let (input, channel) = channel(input)?;
let (input, _) = whitespace(input)?; let (input, _) = whitespace(input)?;
let (input, center) = alt((value(Ok(CenterPoint::VRef), tag("vref")), |input| { let (input, center) = alt((
let (input, value) = float(input)?; value(Ok(CenterPoint::Vref), tag("vref")),
Ok(( |input| {
input, let (input, value) = float(input)?;
value.map(|value| CenterPoint::Override(value as f32)), Ok((input, value.map(|value| CenterPoint::Override(value as f32))))
)) }
}))(input)?; ))(input)?;
end(input)?; end(input)?;
Ok(( Ok((input, center.map(|center| Command::CenterPoint {
input, channel,
center.map(|center| Command::CenterPoint { channel, center }), center,
)) })))
} }
/// `pid <0-1> <parameter> <value>` /// `pid <0-1> <parameter> <value>`
fn pid_parameter(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> { fn pid_parameter(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, channel) = channel(input)?; let (input, channel) = channel(input)?;
let (input, _) = whitespace(input)?; let (input, _) = whitespace(input)?;
let (input, parameter) = alt(( let (input, parameter) =
value(PidParameter::Target, tag("target")), alt((value(PidParameter::Target, tag("target")),
value(PidParameter::KP, tag("kp")), value(PidParameter::KP, tag("kp")),
value(PidParameter::KI, tag("ki")), value(PidParameter::KI, tag("ki")),
value(PidParameter::KD, tag("kd")), value(PidParameter::KD, tag("kd")),
value(PidParameter::OutputMin, tag("output_min")), value(PidParameter::OutputMin, tag("output_min")),
value(PidParameter::OutputMax, tag("output_max")), value(PidParameter::OutputMax, tag("output_max")),
))(input)?; ))(input)?;
let (input, _) = whitespace(input)?; let (input, _) = whitespace(input)?;
let (input, value) = float(input)?; let (input, value) = float(input)?;
let result = value.map(|value| Command::Pid { let result = value
channel, .map(|value| Command::Pid { channel, parameter, value });
parameter,
value,
});
Ok((input, result)) Ok((input, result))
} }
@ -361,66 +392,70 @@ fn pid_parameter(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
fn pid(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> { fn pid(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, _) = tag("pid")(input)?; let (input, _) = tag("pid")(input)?;
alt(( alt((
preceded(whitespace, pid_parameter), preceded(
value(Ok(Command::Show(ShowCommand::Pid)), end), whitespace,
pid_parameter
),
value(Ok(Command::Show(ShowCommand::Pid)), end)
))(input) ))(input)
} }
/// `b-p <0-1> <parameter> <value>` /// `s-h <0-1> <parameter> <value>`
fn b_parameter_parameter(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> { fn steinhart_hart_parameter(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, channel) = channel(input)?; let (input, channel) = channel(input)?;
let (input, _) = whitespace(input)?; let (input, _) = whitespace(input)?;
let (input, parameter) = alt(( let (input, parameter) =
value(BpParameter::T0, tag("t0")), alt((value(ShParameter::T0, tag("t0")),
value(BpParameter::B, tag("b")), value(ShParameter::B, tag("b")),
value(BpParameter::R0, tag("r0")), value(ShParameter::R0, tag("r0"))
))(input)?; ))(input)?;
let (input, _) = whitespace(input)?; let (input, _) = whitespace(input)?;
let (input, value) = float(input)?; let (input, value) = float(input)?;
let result = value.map(|value| Command::BParameter { let result = value
channel, .map(|value| Command::SteinhartHart { channel, parameter, value });
parameter,
value,
});
Ok((input, result)) Ok((input, result))
} }
/// `b-p` | `b-p <b_parameter_parameter>` /// `s-h` | `s-h <steinhart_hart_parameter>`
fn b_parameter(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> { fn steinhart_hart(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, _) = tag("b-p")(input)?; let (input, _) = tag("s-h")(input)?;
alt(( alt((
preceded(whitespace, b_parameter_parameter), preceded(
value(Ok(Command::Show(ShowCommand::BParameter)), end), whitespace,
steinhart_hart_parameter
),
value(Ok(Command::Show(ShowCommand::SteinhartHart)), end)
))(input) ))(input)
} }
fn postfilter(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> { fn postfilter(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, _) = tag("postfilter")(input)?; let (input, _) = tag("postfilter")(input)?;
alt(( alt((
preceded(whitespace, |input| { preceded(
let (input, channel) = channel(input)?; whitespace,
let (input, _) = whitespace(input)?; |input| {
alt(( let (input, channel) = channel(input)?;
value( let (input, _) = whitespace(input)?;
Ok(Command::PostFilter { alt((
value(Ok(Command::PostFilter {
channel, channel,
rate: None, rate: None,
}), }), tag("off")),
tag("off"), move |input| {
), let (input, _) = tag("rate")(input)?;
move |input| { let (input, _) = whitespace(input)?;
let (input, _) = tag("rate")(input)?; let (input, rate) = float(input)?;
let (input, _) = whitespace(input)?; let result = rate
let (input, rate) = float(input)?; .map(|rate| Command::PostFilter {
let result = rate.map(|rate| Command::PostFilter { channel,
channel, rate: Some(rate as f32),
rate: Some(rate as f32), });
}); Ok((input, result))
Ok((input, result)) }
}, ))(input)
))(input) }
}), ),
value(Ok(Command::Show(ShowCommand::PostFilter)), end), value(Ok(Command::Show(ShowCommand::PostFilter)), end)
))(input) ))(input)
} }
@ -433,7 +468,7 @@ fn load(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, _) = end(input)?; let (input, _) = end(input)?;
Ok((input, Some(channel))) Ok((input, Some(channel)))
}, },
value(None, end), value(None, end)
))(input)?; ))(input)?;
let result = Ok(Command::Load { channel }); let result = Ok(Command::Load { channel });
@ -449,7 +484,7 @@ fn save(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, _) = end(input)?; let (input, _) = end(input)?;
Ok((input, Some(channel))) Ok((input, Some(channel)))
}, },
value(None, end), value(None, end)
))(input)?; ))(input)?;
let result = Ok(Command::Save { channel }); let result = Ok(Command::Save { channel });
@ -511,17 +546,12 @@ fn fan(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
}, },
|input| { |input| {
let (input, value) = unsigned(input)?; let (input, value) = unsigned(input)?;
Ok(( Ok((input, Ok(Command::FanSet { fan_pwm: value.unwrap_or(0)})))
input,
Ok(Command::FanSet {
fan_pwm: value.unwrap_or(0),
}),
))
}, },
))(input)?; ))(input)?;
Ok((input, result)) Ok((input, result))
}, },
value(Ok(Command::ShowFan), end), value(Ok(Command::ShowFan), end)
))(input) ))(input)
} }
@ -541,15 +571,8 @@ fn fan_curve(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, k_b) = float(input)?; let (input, k_b) = float(input)?;
let (input, _) = whitespace(input)?; let (input, _) = whitespace(input)?;
let (input, k_c) = float(input)?; let (input, k_c) = float(input)?;
if let (Ok(k_a), Ok(k_b), Ok(k_c)) = (k_a, k_b, k_c) { if k_a.is_ok() && k_b.is_ok() && k_c.is_ok() {
Ok(( Ok((input, Ok(Command::FanCurve { k_a: k_a.unwrap() as f32, k_b: k_b.unwrap() as f32, k_c: k_c.unwrap() as f32 })))
input,
Ok(Command::FanCurve {
k_a: k_a as f32,
k_b: k_b as f32,
k_c: k_c as f32,
}),
))
} else { } else {
Err(nom::Err::Incomplete(Needed::Size(3))) Err(nom::Err::Incomplete(Needed::Size(3)))
} }
@ -557,36 +580,38 @@ fn fan_curve(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
))(input)?; ))(input)?;
Ok((input, result)) Ok((input, result))
}, },
value(Err(Error::Incomplete), end), value(Err(Error::Incomplete), end)
))(input) ))(input)
} }
fn command(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> { fn command(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
alt(( alt((value(Ok(Command::Quit), tag("quit")),
value(Ok(Command::Quit), tag("quit")), load,
load, save,
save, value(Ok(Command::Reset), tag("reset")),
value(Ok(Command::Reset), tag("reset")), ipv4,
ipv4, map(report, Ok),
map(report, Ok), pwm,
output, center_point,
center_point, pid,
pid, steinhart_hart,
b_parameter, postfilter,
postfilter, value(Ok(Command::Dfu), tag("dfu")),
value(Ok(Command::Dfu), tag("dfu")), fan,
fan, fan_curve,
fan_curve, value(Ok(Command::ShowHWRev), tag("hwrev")),
value(Ok(Command::ShowHWRev), tag("hwrev")),
))(input) ))(input)
} }
impl Command { impl Command {
pub fn parse(input: &[u8]) -> Result<Self, Error> { pub fn parse(input: &[u8]) -> Result<Self, Error> {
match command(input) { match command(input) {
Ok((input_remain, result)) if input_remain.is_empty() => result, Ok((input_remain, result)) if input_remain.len() == 0 =>
Ok((input_remain, _)) => Err(Error::UnexpectedInput(input_remain[0])), result,
Err(e) => Err(e.into()), Ok((input_remain, _)) =>
Err(Error::UnexpectedInput(input_remain[0])),
Err(e) =>
Err(e.into()),
} }
} }
} }
@ -634,27 +659,21 @@ mod test {
#[test] #[test]
fn parse_ipv4() { fn parse_ipv4() {
let command = Command::parse(b"ipv4 192.168.1.26/24"); let command = Command::parse(b"ipv4 192.168.1.26/24");
assert_eq!( assert_eq!(command, Ok(Command::Ipv4(Ipv4Config {
command, address: [192, 168, 1, 26],
Ok(Command::Ipv4(Ipv4Config { mask_len: 24,
address: [192, 168, 1, 26], gateway: None,
mask_len: 24, })));
gateway: None,
}))
);
} }
#[test] #[test]
fn parse_ipv4_and_gateway() { fn parse_ipv4_and_gateway() {
let command = Command::parse(b"ipv4 10.42.0.126/8 10.1.0.1"); let command = Command::parse(b"ipv4 10.42.0.126/8 10.1.0.1");
assert_eq!( assert_eq!(command, Ok(Command::Ipv4(Ipv4Config {
command, address: [10, 42, 0, 126],
Ok(Command::Ipv4(Ipv4Config { mask_len: 8,
address: [10, 42, 0, 126], gateway: Some([10, 1, 0, 1]),
mask_len: 8, })));
gateway: Some([10, 1, 0, 1]),
}))
);
} }
#[test] #[test]
@ -664,73 +683,69 @@ mod test {
} }
#[test] #[test]
fn parse_output_i_set() { fn parse_report_mode() {
let command = Command::parse(b"output 1 i_set 16383"); let command = Command::parse(b"report mode");
assert_eq!( assert_eq!(command, Ok(Command::Show(ShowCommand::Reporting)));
command,
Ok(Command::Output {
channel: 1,
pin: PwmPin::ISet,
value: 16383.0,
})
);
} }
#[test] #[test]
fn parse_output_polarity() { fn parse_report_mode_on() {
let command = Command::parse(b"output 0 polarity reversed"); let command = Command::parse(b"report mode on");
assert_eq!( assert_eq!(command, Ok(Command::Reporting(true)));
command,
Ok(Command::OutputPolarity {
channel: 0,
polarity: Polarity::Reversed,
})
);
} }
#[test] #[test]
fn parse_output_pid() { fn parse_report_mode_off() {
let command = Command::parse(b"output 0 pid"); let command = Command::parse(b"report mode off");
assert_eq!(command, Ok(Command::OutputPid { channel: 0 })); assert_eq!(command, Ok(Command::Reporting(false)));
} }
#[test] #[test]
fn parse_output_max_i_pos() { fn parse_pwm_i_set() {
let command = Command::parse(b"output 0 max_i_pos 7"); let command = Command::parse(b"pwm 1 i_set 16383");
assert_eq!( assert_eq!(command, Ok(Command::Pwm {
command, channel: 1,
Ok(Command::Output { pin: PwmPin::ISet,
channel: 0, value: 16383.0,
pin: PwmPin::MaxIPos, }));
value: 7.0,
})
);
} }
#[test] #[test]
fn parse_output_max_i_neg() { fn parse_pwm_pid() {
let command = Command::parse(b"output 0 max_i_neg 128"); let command = Command::parse(b"pwm 0 pid");
assert_eq!( assert_eq!(command, Ok(Command::PwmPid {
command, channel: 0,
Ok(Command::Output { }));
channel: 0,
pin: PwmPin::MaxINeg,
value: 128.0,
})
);
} }
#[test] #[test]
fn parse_output_max_v() { fn parse_pwm_max_i_pos() {
let command = Command::parse(b"output 0 max_v 32768"); let command = Command::parse(b"pwm 0 max_i_pos 7");
assert_eq!( assert_eq!(command, Ok(Command::Pwm {
command, channel: 0,
Ok(Command::Output { pin: PwmPin::MaxIPos,
channel: 0, value: 7.0,
pin: PwmPin::MaxV, }));
value: 32768.0, }
})
); #[test]
fn parse_pwm_max_i_neg() {
let command = Command::parse(b"pwm 0 max_i_neg 128");
assert_eq!(command, Ok(Command::Pwm {
channel: 0,
pin: PwmPin::MaxINeg,
value: 128.0,
}));
}
#[test]
fn parse_pwm_max_v() {
let command = Command::parse(b"pwm 0 max_v 32768");
assert_eq!(command, Ok(Command::Pwm {
channel: 0,
pin: PwmPin::MaxV,
value: 32768.0,
}));
} }
#[test] #[test]
@ -742,33 +757,27 @@ mod test {
#[test] #[test]
fn parse_pid_target() { fn parse_pid_target() {
let command = Command::parse(b"pid 0 target 36.5"); let command = Command::parse(b"pid 0 target 36.5");
assert_eq!( assert_eq!(command, Ok(Command::Pid {
command, channel: 0,
Ok(Command::Pid { parameter: PidParameter::Target,
channel: 0, value: 36.5,
parameter: PidParameter::Target, }));
value: 36.5,
})
);
} }
#[test] #[test]
fn parse_b_parameter() { fn parse_steinhart_hart() {
let command = Command::parse(b"b-p"); let command = Command::parse(b"s-h");
assert_eq!(command, Ok(Command::Show(ShowCommand::BParameter))); assert_eq!(command, Ok(Command::Show(ShowCommand::SteinhartHart)));
} }
#[test] #[test]
fn parse_b_parameter_set() { fn parse_steinhart_hart_set() {
let command = Command::parse(b"b-p 1 t0 23.05"); let command = Command::parse(b"s-h 1 t0 23.05");
assert_eq!( assert_eq!(command, Ok(Command::SteinhartHart {
command, channel: 1,
Ok(Command::BParameter { parameter: ShParameter::T0,
channel: 1, value: 23.05,
parameter: BpParameter::T0, }));
value: 23.05,
})
);
} }
#[test] #[test]
@ -780,49 +789,37 @@ mod test {
#[test] #[test]
fn parse_postfilter_off() { fn parse_postfilter_off() {
let command = Command::parse(b"postfilter 1 off"); let command = Command::parse(b"postfilter 1 off");
assert_eq!( assert_eq!(command, Ok(Command::PostFilter {
command, channel: 1,
Ok(Command::PostFilter { rate: None,
channel: 1, }));
rate: None,
})
);
} }
#[test] #[test]
fn parse_postfilter_rate() { fn parse_postfilter_rate() {
let command = Command::parse(b"postfilter 0 rate 21"); let command = Command::parse(b"postfilter 0 rate 21");
assert_eq!( assert_eq!(command, Ok(Command::PostFilter {
command, channel: 0,
Ok(Command::PostFilter { rate: Some(21.0),
channel: 0, }));
rate: Some(21.0),
})
);
} }
#[test] #[test]
fn parse_center_point() { fn parse_center_point() {
let command = Command::parse(b"center 0 1.5"); let command = Command::parse(b"center 0 1.5");
assert_eq!( assert_eq!(command, Ok(Command::CenterPoint {
command, channel: 0,
Ok(Command::CenterPoint { center: CenterPoint::Override(1.5),
channel: 0, }));
center: CenterPoint::Override(1.5),
})
);
} }
#[test] #[test]
fn parse_center_point_vref() { fn parse_center_point_vref() {
let command = Command::parse(b"center 1 vref"); let command = Command::parse(b"center 1 vref");
assert_eq!( assert_eq!(command, Ok(Command::CenterPoint {
command, channel: 1,
Ok(Command::CenterPoint { center: CenterPoint::Vref,
channel: 1, }));
center: CenterPoint::VRef,
})
);
} }
#[test] #[test]
@ -834,7 +831,7 @@ mod test {
#[test] #[test]
fn parse_fan_set() { fn parse_fan_set() {
let command = Command::parse(b"fan 42"); let command = Command::parse(b"fan 42");
assert_eq!(command, Ok(Command::FanSet { fan_pwm: 42 })); assert_eq!(command, Ok(Command::FanSet {fan_pwm: 42}));
} }
#[test] #[test]
@ -846,14 +843,11 @@ mod test {
#[test] #[test]
fn parse_fcurve_set() { fn parse_fcurve_set() {
let command = Command::parse(b"fcurve 1.2 3.4 5.6"); let command = Command::parse(b"fcurve 1.2 3.4 5.6");
assert_eq!( assert_eq!(command, Ok(Command::FanCurve {
command, k_a: 1.2,
Ok(Command::FanCurve { k_b: 3.4,
k_a: 1.2, k_c: 5.6
k_b: 3.4, }));
k_c: 5.6
})
);
} }
#[test] #[test]

58
src/config.rs
View File

@ -1,13 +1,16 @@
use serde::{Serialize, Deserialize};
use uom::si::{
electric_potential::volt,
electric_current::ampere,
f64::{ElectricCurrent, ElectricPotential},
};
use crate::{ use crate::{
ad7172::PostFilter, ad7172::PostFilter,
b_parameter,
channels::Channels, channels::Channels,
command_parser::{CenterPoint, Polarity}, command_parser::CenterPoint,
pid, pid,
steinhart_hart,
}; };
use num_traits::Zero;
use serde::{Deserialize, Serialize};
use uom::si::f64::{ElectricCurrent, ElectricPotential};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ChannelConfig { pub struct ChannelConfig {
@ -15,9 +18,7 @@ pub struct ChannelConfig {
pid: pid::Parameters, pid: pid::Parameters,
pid_target: f32, pid_target: f32,
pid_engaged: bool, pid_engaged: bool,
i_set: ElectricCurrent, sh: steinhart_hart::Parameters,
polarity: Polarity,
bp: b_parameter::Parameters,
pwm: PwmLimits, pwm: PwmLimits,
/// uses variant `PostFilter::Invalid` instead of `None` to save space /// uses variant `PostFilter::Invalid` instead of `None` to save space
adc_postfilter: PostFilter, adc_postfilter: PostFilter,
@ -27,26 +28,17 @@ impl ChannelConfig {
pub fn new(channels: &mut Channels, channel: usize) -> Self { pub fn new(channels: &mut Channels, channel: usize) -> Self {
let pwm = PwmLimits::new(channels, channel); let pwm = PwmLimits::new(channels, channel);
let adc_postfilter = channels let adc_postfilter = channels.adc.get_postfilter(channel as u8)
.adc
.get_postfilter(channel as u8)
.unwrap() .unwrap()
.unwrap_or(PostFilter::Invalid); .unwrap_or(PostFilter::Invalid);
let state = channels.channel_state(channel); let state = channels.channel_state(channel);
let i_set = if state.pid_engaged {
ElectricCurrent::zero()
} else {
state.i_set
};
ChannelConfig { ChannelConfig {
center: state.center.clone(), center: state.center.clone(),
pid: state.pid.parameters.clone(), pid: state.pid.parameters.clone(),
pid_target: state.pid.target as f32, pid_target: state.pid.target as f32,
pid_engaged: state.pid_engaged, pid_engaged: state.pid_engaged,
i_set, sh: state.sh.clone(),
polarity: state.polarity.clone(),
bp: state.bp.clone(),
pwm, pwm,
adc_postfilter, adc_postfilter,
} }
@ -58,7 +50,7 @@ impl ChannelConfig {
state.pid.parameters = self.pid.clone(); state.pid.parameters = self.pid.clone();
state.pid.target = self.pid_target.into(); state.pid.target = self.pid_target.into();
state.pid_engaged = self.pid_engaged; state.pid_engaged = self.pid_engaged;
state.bp = self.bp.clone(); state.sh = self.sh.clone();
self.pwm.apply(channels, channel); self.pwm.apply(channels, channel);
@ -67,33 +59,31 @@ impl ChannelConfig {
adc_postfilter => Some(adc_postfilter), adc_postfilter => Some(adc_postfilter),
}; };
let _ = channels.adc.set_postfilter(channel as u8, 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)] #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PwmLimits { struct PwmLimits {
pub max_v: ElectricPotential, max_v: f64,
pub max_i_pos: ElectricCurrent, max_i_pos: f64,
pub max_i_neg: ElectricCurrent, max_i_neg: f64,
} }
impl PwmLimits { impl PwmLimits {
pub fn new(channels: &mut Channels, channel: usize) -> Self { 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 { PwmLimits {
max_v, max_v: max_v.get::<volt>(),
max_i_pos, max_i_pos: max_i_pos.get::<ampere>(),
max_i_neg, max_i_neg: max_i_neg.get::<ampere>(),
} }
} }
pub fn apply(&self, channels: &mut Channels, channel: usize) { pub fn apply(&self, channels: &mut Channels, channel: usize) {
channels.set_max_v(channel, self.max_v); channels.set_max_v(channel, ElectricPotential::new::<volt>(self.max_v));
channels.set_max_i_pos(channel, self.max_i_pos); channels.set_max_i_pos(channel, ElectricCurrent::new::<ampere>(self.max_i_pos));
channels.set_max_i_neg(channel, self.max_i_neg); channels.set_max_i_neg(channel, ElectricCurrent::new::<ampere>(self.max_i_neg));
} }
} }

2
src/dfu.rs
View File

@ -27,7 +27,7 @@ unsafe fn __pre_init() {
rcc.apb2enr.modify(|_, w| w.syscfgen().set_bit()); rcc.apb2enr.modify(|_, w| w.syscfgen().set_bit());
// Bypass BOOT pins and remap bootloader to 0x00000000 // Bypass BOOT pins and remap bootloader to 0x00000000
let syscfg = &*SYSCFG::ptr(); let syscfg = &*SYSCFG::ptr() ;
syscfg.memrm.write(|w| w.mem_mode().bits(0b01)); syscfg.memrm.write(|w| w.mem_mode().bits(0b01));
// Impose instruction and memory barriers // Impose instruction and memory barriers

56
src/fan_ctrl.rs
View File

@ -1,17 +1,27 @@
use crate::{channels::MAX_TEC_I, command_handler::JsonBuffer, hw_rev::HWSettings};
use num_traits::Float; use num_traits::Float;
use serde::Serialize; use serde::Serialize;
use stm32f4xx_hal::{ use stm32f4xx_hal::{
pac::TIM8,
pwm::{self, PwmChannels}, pwm::{self, PwmChannels},
pac::TIM8,
};
use uom::si::{
f64::ElectricCurrent,
electric_current::ampere,
};
use crate::{
hw_rev::HWSettings,
command_handler::JsonBuffer,
}; };
use uom::si::{electric_current::ampere, f64::ElectricCurrent};
pub type FanPin = PwmChannels<TIM8, pwm::C4>; pub type FanPin = PwmChannels<TIM8, pwm::C4>;
// as stated in the schematics
const MAX_TEC_I: f32 = 3.0;
const MAX_USER_FAN_PWM: f32 = 100.0; const MAX_USER_FAN_PWM: f32 = 100.0;
const MIN_USER_FAN_PWM: f32 = 1.0; const MIN_USER_FAN_PWM: f32 = 1.0;
pub struct FanCtrl { pub struct FanCtrl {
fan: Option<FanPin>, fan: Option<FanPin>,
fan_auto: bool, fan_auto: bool,
@ -46,11 +56,9 @@ impl FanCtrl {
pub fn cycle(&mut self, abs_max_tec_i: ElectricCurrent) { pub fn cycle(&mut self, abs_max_tec_i: ElectricCurrent) {
self.abs_max_tec_i = abs_max_tec_i.get::<ampere>() as f32; self.abs_max_tec_i = abs_max_tec_i.get::<ampere>() as f32;
if self.fan_auto && self.hw_settings.fan_available { if self.fan_auto && self.hw_settings.fan_available {
let scaled_current = self.abs_max_tec_i / MAX_TEC_I.get::<ampere>() as f32; let scaled_current = self.abs_max_tec_i / MAX_TEC_I;
// do not limit upper bound, as it will be limited in the set_pwm() // do not limit upper bound, as it will be limited in the set_pwm()
let pwm = (MAX_USER_FAN_PWM let pwm = (MAX_USER_FAN_PWM * (scaled_current * (scaled_current * self.k_a + self.k_b) + self.k_c)) as u32;
* (scaled_current * (scaled_current * self.k_a + self.k_b) + self.k_c))
as u32;
self.set_pwm(pwm); self.set_pwm(pwm);
} }
} }
@ -83,26 +91,18 @@ impl FanCtrl {
} }
pub fn restore_defaults(&mut self) { pub fn restore_defaults(&mut self) {
self.set_curve( self.set_curve(self.hw_settings.fan_k_a,
self.hw_settings.fan_k_a, self.hw_settings.fan_k_b,
self.hw_settings.fan_k_b, self.hw_settings.fan_k_c);
self.hw_settings.fan_k_c,
);
} }
pub fn set_pwm(&mut self, fan_pwm: u32) -> f32 { pub fn set_pwm(&mut self, fan_pwm: u32) -> f32 {
if self.fan.is_none() || (!self.pwm_enabled && !self.enable_pwm()) { if self.fan.is_none() || (!self.pwm_enabled && !self.enable_pwm()) {
return 0f32; return 0f32;
} }
let fan = self.fan.as_mut().unwrap(); 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 fan_pwm = fan_pwm.min(MAX_USER_FAN_PWM as u32).max(MIN_USER_FAN_PWM as u32);
let duty = scale_number( 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);
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 max = fan.get_max_duty();
let value = ((duty * (max as f32)) as u16).min(max); let value = ((duty * (max as f32)) as u16).min(max);
fan.set_duty(value); fan.set_duty(value);
@ -121,17 +121,8 @@ impl FanCtrl {
if let Some(fan) = &self.fan { if let Some(fan) = &self.fan {
let duty = fan.get_duty(); let duty = fan.get_duty();
let max = fan.get_max_duty(); let max = fan.get_max_duty();
scale_number( 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
duty as f32 / (max as f32), } else { 0 }
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 { fn enable_pwm(&mut self) -> bool {
@ -147,6 +138,7 @@ impl FanCtrl {
} }
} }
fn scale_number(unscaled: f32, to_min: f32, to_max: f32, from_min: f32, from_max: f32) -> f32 { 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 (to_max - to_min) * (unscaled - from_min) / (from_max - from_min) + to_min
} }

14
src/flash_store.rs
View File

@ -1,9 +1,9 @@
use log::{error, info}; use log::{info, error};
use sfkv::{Store, StoreBackend};
use stm32f4xx_hal::{ use stm32f4xx_hal::{
flash::{Error, FlashExt}, flash::{Error, FlashExt},
stm32::FLASH, stm32::FLASH,
}; };
use sfkv::{Store, StoreBackend};
/// 16 KiB /// 16 KiB
pub const FLASH_SECTOR_SIZE: usize = 0x4000; pub const FLASH_SECTOR_SIZE: usize = 0x4000;
@ -21,7 +21,9 @@ pub struct FlashBackend {
} }
fn get_offset() -> usize { fn get_offset() -> usize {
unsafe { (&_config_start as *const usize as usize) - (&_flash_start as *const usize as usize) } unsafe {
(&_config_start as *const usize as usize) - (&_flash_start as *const usize as usize)
}
} }
impl StoreBackend for FlashBackend { impl StoreBackend for FlashBackend {
@ -38,8 +40,7 @@ impl StoreBackend for FlashBackend {
} }
fn program(&mut self, offset: usize, payload: &[u8]) -> Result<(), Self::Error> { fn program(&mut self, offset: usize, payload: &[u8]) -> Result<(), Self::Error> {
self.flash self.flash.unlocked()
.unlocked()
.program(get_offset() + offset, payload.iter()) .program(get_offset() + offset, payload.iter())
} }
@ -59,8 +60,7 @@ pub fn store(flash: FLASH) -> FlashStore {
Ok(_) => {} Ok(_) => {}
Err(e) => { Err(e) => {
error!("corrupt store, erasing. error: {:?}", e); error!("corrupt store, erasing. error: {:?}", e);
let _ = store let _ = store.erase()
.erase()
.map_err(|e| error!("flash erase failed: {:?}", e)); .map_err(|e| error!("flash erase failed: {:?}", e));
} }
} }

22
src/hw_rev.rs
View File

@ -1,6 +1,9 @@
use serde::Serialize; use serde::Serialize;
use crate::{command_handler::JsonBuffer, pins::HWRevPins}; use crate::{
pins::HWRevPins,
command_handler::JsonBuffer,
};
#[derive(Serialize, Copy, Clone)] #[derive(Serialize, Copy, Clone)]
pub struct HWRev { pub struct HWRev {
@ -28,17 +31,13 @@ struct HWSummary<'a> {
impl HWRev { impl HWRev {
pub fn detect_hw_rev(hwrev_pins: &HWRevPins) -> Self { pub fn detect_hw_rev(hwrev_pins: &HWRevPins) -> Self {
let (h0, h1, h2, h3) = ( let (h0, h1, h2, h3) = (hwrev_pins.hwrev0.is_high(), hwrev_pins.hwrev1.is_high(),
hwrev_pins.hwrev0.is_high(), hwrev_pins.hwrev2.is_high(), hwrev_pins.hwrev3.is_high());
hwrev_pins.hwrev1.is_high(),
hwrev_pins.hwrev2.is_high(),
hwrev_pins.hwrev3.is_high(),
);
match (h0, h1, h2, h3) { match (h0, h1, h2, h3) {
(true, true, true, false) => HWRev { major: 1, minor: 0 }, (true, true, true, false) => HWRev { major: 1, minor: 0 },
(true, false, false, false) => HWRev { major: 2, minor: 0 }, (true, false, false, false) => HWRev { major: 2, minor: 0 },
(false, true, false, false) => HWRev { major: 2, minor: 2 }, (false, true, false, false) => HWRev { major: 2, minor: 2 },
(_, _, _, _) => HWRev { major: 0, minor: 0 }, (_, _, _, _) => HWRev { major: 0, minor: 0 }
} }
} }
@ -71,16 +70,13 @@ impl HWRev {
fan_pwm_freq_hz: 0, fan_pwm_freq_hz: 0,
fan_available: false, fan_available: false,
fan_pwm_recommended: false, fan_pwm_recommended: false,
}, }
} }
} }
pub fn summary(&self) -> Result<JsonBuffer, serde_json_core::ser::Error> { pub fn summary(&self) -> Result<JsonBuffer, serde_json_core::ser::Error> {
let settings = self.settings(); let settings = self.settings();
let summary = HWSummary { let summary = HWSummary { rev: self, settings: &settings };
rev: self,
settings: &settings,
};
serde_json_core::to_vec(&summary) serde_json_core::to_vec(&summary)
} }
} }

8
src/init_log.rs
View File

@ -10,15 +10,17 @@ pub fn init_log() {
#[cfg(feature = "semihosting")] #[cfg(feature = "semihosting")]
pub fn init_log() { pub fn init_log() {
use cortex_m_log::log::{init, Logger};
use cortex_m_log::printer::semihosting::{hio::HStdout, InterruptOk};
use log::LevelFilter; 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; static mut LOGGER: Option<Logger<InterruptOk<HStdout>>> = None;
let logger = Logger { let logger = Logger {
inner: InterruptOk::<_>::stdout().expect("semihosting stdout"), inner: InterruptOk::<_>::stdout().expect("semihosting stdout"),
level: LevelFilter::Info, level: LevelFilter::Info,
}; };
let logger = unsafe { LOGGER.get_or_insert(logger) }; let logger = unsafe {
LOGGER.get_or_insert(logger)
};
init(logger).expect("set logger"); init(logger).expect("set logger");
} }

2
src/leds.rs
View File

@ -1,6 +1,6 @@
use stm32f4xx_hal::{ use stm32f4xx_hal::{
gpio::{ gpio::{
gpiod::{PD10, PD11, PD9}, gpiod::{PD9, PD10, PD11},
Output, PushPull, Output, PushPull,
}, },
hal::digital::v2::OutputPin, hal::digital::v2::OutputPin,

273
src/main.rs
View File

@ -8,26 +8,30 @@ use panic_halt as _;
#[cfg(all(feature = "semihosting", not(test)))] #[cfg(all(feature = "semihosting", not(test)))]
use panic_semihosting as _; use panic_semihosting as _;
use log::{error, info, warn};
use cortex_m::asm::wfi; use cortex_m::asm::wfi;
use cortex_m_rt::entry; use cortex_m_rt::entry;
use log::{error, info, warn};
use smoltcp::{socket::TcpSocket, time::Instant, wire::EthernetAddress};
use stm32f4xx_hal::{ use stm32f4xx_hal::{
hal::watchdog::{Watchdog, WatchdogEnable}, hal::watchdog::{WatchdogEnable, Watchdog},
rcc::RccExt, rcc::RccExt,
stm32::{CorePeripherals, Peripherals, SCB}, stm32::{CorePeripherals, Peripherals, SCB},
time::{MegaHertz, U32Ext}, time::{U32Ext, MegaHertz},
watchdog::IndependentWatchdog, watchdog::IndependentWatchdog,
}; };
use smoltcp::{
time::Instant,
socket::TcpSocket,
wire::EthernetAddress,
};
mod init_log; mod init_log;
use init_log::init_log; use init_log::init_log;
mod usb;
mod leds; mod leds;
mod pins; mod pins;
mod usb;
use pins::Pins; use pins::Pins;
mod ad5680;
mod ad7172; mod ad7172;
mod ad5680;
mod net; mod net;
mod server; mod server;
use server::Server; use server::Server;
@ -35,18 +39,18 @@ mod session;
use session::{Session, SessionInput}; use session::{Session, SessionInput};
mod command_parser; mod command_parser;
use command_parser::Ipv4Config; use command_parser::Ipv4Config;
mod b_parameter;
mod channels;
mod pid;
mod timer; mod timer;
use channels::{Channels, CHANNELS}; mod pid;
mod steinhart_hart;
mod channels;
use channels::{CHANNELS, Channels};
mod channel; mod channel;
mod channel_state; mod channel_state;
mod config; mod config;
use config::ChannelConfig; use config::ChannelConfig;
mod command_handler;
mod dfu;
mod flash_store; mod flash_store;
mod dfu;
mod command_handler;
use command_handler::Handler; use command_handler::Handler;
mod fan_ctrl; mod fan_ctrl;
use fan_ctrl::FanCtrl; use fan_ctrl::FanCtrl;
@ -69,19 +73,19 @@ fn send_line(socket: &mut TcpSocket, data: &[u8]) -> bool {
// instead of sending incomplete line // instead of sending incomplete line
warn!( warn!(
"TCP socket has only {}/{} needed {}", "TCP socket has only {}/{} needed {}",
send_free + 1, send_free + 1, socket.send_capacity(), data.len(),
socket.send_capacity(),
data.len(),
); );
} else { } else {
match socket.send_slice(data) { match socket.send_slice(&data) {
Ok(sent) if sent == data.len() => { Ok(sent) if sent == data.len() => {
let _ = socket.send_slice(b"\n"); let _ = socket.send_slice(b"\n");
// success // success
return true; return true
} }
Ok(sent) => warn!("sent only {}/{} bytes", sent, data.len()), Ok(sent) =>
Err(e) => error!("error sending line: {:?}", e), warn!("sent only {}/{} bytes", sent, data.len()),
Err(e) =>
error!("error sending line: {:?}", e),
} }
} }
// not success // not success
@ -100,9 +104,7 @@ fn main() -> ! {
cp.SCB.enable_dcache(&mut cp.CPUID); cp.SCB.enable_dcache(&mut cp.CPUID);
let dp = Peripherals::take().unwrap(); let dp = Peripherals::take().unwrap();
let clocks = dp let clocks = dp.RCC.constrain()
.RCC
.constrain()
.cfgr .cfgr
.use_hse(HSE) .use_hse(HSE)
.sysclk(168.mhz()) .sysclk(168.mhz())
@ -118,15 +120,14 @@ fn main() -> ! {
timer::setup(cp.SYST, clocks); timer::setup(cp.SYST, clocks);
let (pins, mut leds, mut eeprom, eth_pins, usb, fan, hwrev, hw_settings) = Pins::setup( let (pins, mut leds, mut eeprom, eth_pins, usb, fan, hwrev, hw_settings) = Pins::setup(
clocks, clocks, dp.TIM1, dp.TIM3, dp.TIM8,
(dp.TIM1, dp.TIM3, dp.TIM8), dp.GPIOA, dp.GPIOB, dp.GPIOC, dp.GPIOD, dp.GPIOE, dp.GPIOF, dp.GPIOG,
(
dp.GPIOA, dp.GPIOB, dp.GPIOC, dp.GPIOD, dp.GPIOE, dp.GPIOF, dp.GPIOG,
),
dp.I2C1, dp.I2C1,
(dp.SPI2, dp.SPI4, dp.SPI5), dp.SPI2, dp.SPI4, dp.SPI5,
dp.ADC1, dp.ADC1,
(dp.OTG_FS_GLOBAL, dp.OTG_FS_DEVICE, dp.OTG_FS_PWRCLK), dp.OTG_FS_GLOBAL,
dp.OTG_FS_DEVICE,
dp.OTG_FS_PWRCLK,
); );
leds.r1.on(); leds.r1.on();
@ -137,12 +138,15 @@ fn main() -> ! {
let mut store = flash_store::store(dp.FLASH); let mut store = flash_store::store(dp.FLASH);
let mut channels = Channels::new(pins); let mut channels = Channels::new(pins, &hwrev);
for (c, key) in CHANNEL_CONFIG_KEY.iter().enumerate().take(CHANNELS) { for c in 0..CHANNELS {
match store.read_value::<ChannelConfig>(key) { match store.read_value::<ChannelConfig>(CHANNEL_CONFIG_KEY[c]) {
Ok(Some(config)) => config.apply(&mut channels, c), Ok(Some(config)) =>
Ok(None) => error!("flash config not found for channel {}", c), config.apply(&mut channels, c),
Err(e) => error!("unable to load config {} from flash: {:?}", c, e), Ok(None) =>
error!("flash config not found for channel {}", c),
Err(e) =>
error!("unable to load config {} from flash: {:?}", c, e),
} }
} }
@ -155,9 +159,11 @@ fn main() -> ! {
gateway: None, gateway: None,
}; };
match store.read_value("ipv4") { match store.read_value("ipv4") {
Ok(Some(config)) => ipv4_config = config, Ok(Some(config)) =>
ipv4_config = config,
Ok(None) => {} Ok(None) => {}
Err(e) => error!("cannot read ipv4 config: {:?}", e), Err(e) =>
error!("cannot read ipv4 config: {:?}", e),
} }
// EEPROM ships with a read-only EUI-48 identifier // EEPROM ships with a read-only EUI-48 identifier
@ -166,115 +172,118 @@ fn main() -> ! {
let hwaddr = EthernetAddress(eui48); let hwaddr = EthernetAddress(eui48);
info!("EEPROM MAC address: {}", hwaddr); info!("EEPROM MAC address: {}", hwaddr);
net::run( net::run(clocks, dp.ETHERNET_MAC, dp.ETHERNET_DMA, eth_pins, hwaddr, ipv4_config.clone(), |iface| {
clocks, Server::<Session>::run(iface, |server| {
dp.ETHERNET_MAC, leds.r1.off();
dp.ETHERNET_DMA, let mut should_reset = false;
eth_pins,
hwaddr,
ipv4_config.clone(),
|iface| {
Server::<Session>::run(iface, |server| {
leds.r1.off();
let mut should_reset = false;
loop { loop {
let mut new_ipv4_config = None; let mut new_ipv4_config = None;
let instant = Instant::from_millis(i64::from(timer::now())); let instant = Instant::from_millis(i64::from(timer::now()));
channels.poll_adc(instant); let updated_channel = channels.poll_adc(instant);
if let Some(channel) = updated_channel {
server.for_each(|_, session| session.set_report_pending(channel.into()));
}
fan_ctrl.cycle(channels.current_abs_max_tec_i()); fan_ctrl.cycle(channels.current_abs_max_tec_i());
if channels.pid_engaged() { if channels.pid_engaged() {
leds.g3.on(); leds.g3.on();
} else { } else {
leds.g3.off(); leds.g3.off();
} }
let instant = Instant::from_millis(i64::from(timer::now())); let instant = Instant::from_millis(i64::from(timer::now()));
cortex_m::interrupt::free(net::clear_pending); cortex_m::interrupt::free(net::clear_pending);
server.poll(instant).unwrap_or_else(|e| { server.poll(instant)
.unwrap_or_else(|e| {
warn!("poll: {:?}", e); warn!("poll: {:?}", e);
}); });
if !should_reset { if ! should_reset {
// TCP protocol handling // TCP protocol handling
server.for_each(|mut socket, session| { server.for_each(|mut socket, session| {
if !socket.is_active() { if ! socket.is_active() {
let _ = socket.listen(TCP_PORT); let _ = socket.listen(TCP_PORT);
session.reset(); session.reset();
} else if socket.may_send() && !socket.may_recv() { } else if socket.may_send() && !socket.may_recv() {
socket.close() socket.close()
} else if socket.can_send() && socket.can_recv() { } else if socket.can_send() && socket.can_recv() {
match socket.recv(|buf| session.feed(buf)) { match socket.recv(|buf| session.feed(buf)) {
// SessionInput::Nothing happens when the line reader parses a string of characters that is not // SessionInput::Nothing happens when the line reader parses a string of characters that is not
// followed by a newline character. Could be due to partial commands not terminated with newline, // followed by a newline character. Could be due to partial commands not terminated with newline,
// socket RX ring buffer wraps around, or when the command is sent as seperate TCP packets etc. // socket RX ring buffer wraps around, or when the command is sent as seperate TCP packets etc.
// Do nothing and feed more data to the line reader in the next loop cycle. // Do nothing and feed more data to the line reader in the next loop cycle.
Ok(SessionInput::Nothing) => {} Ok(SessionInput::Nothing) => {}
Ok(SessionInput::Command(command)) => { Ok(SessionInput::Command(command)) => {
match Handler::handle_command( match Handler::handle_command(command, &mut socket, &mut channels, session, &mut store, &mut ipv4_config, &mut fan_ctrl, hwrev) {
command, Ok(Handler::NewIPV4(ip)) => new_ipv4_config = Some(ip),
&mut socket, Ok(Handler::Handled) => {},
&mut channels, Ok(Handler::CloseSocket) => socket.close(),
&mut store, Ok(Handler::Reset) => should_reset = true,
&mut ipv4_config, Err(_) => {},
&mut fan_ctrl,
hwrev,
) {
Ok(Handler::NewIPV4(ip)) => new_ipv4_config = Some(ip),
Ok(Handler::Handled) => {}
Ok(Handler::CloseSocket) => socket.close(),
Ok(Handler::Reset) => should_reset = true,
Err(_) => {}
}
} }
Ok(SessionInput::Error(e)) => { }
error!("session input: {:?}", e); Ok(SessionInput::Error(e)) => {
send_line(&mut socket, b"{ \"error\": \"invalid input\" }"); error!("session input: {:?}", e);
send_line(&mut socket, b"{ \"error\": \"invalid input\" }");
}
Err(_) =>
socket.close(),
}
} else if socket.can_send() {
if let Some(channel) = session.is_report_pending() {
match channels.reports_json() {
Ok(buf) => {
send_line(&mut socket, &buf[..]);
session.mark_report_sent(channel);
}
Err(e) => {
error!("unable to serialize report: {:?}", e);
} }
Err(_) => socket.close(),
} }
} }
});
} else {
// Should reset, close all TCP sockets.
let mut any_socket_alive = false;
server.for_each(|mut socket, _| {
if socket.is_active() {
socket.abort();
any_socket_alive = true;
}
});
// 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/gateway
if let Some(config) = new_ipv4_config.take() {
server.set_ipv4_config(config.clone());
ipv4_config = config;
};
// Update watchdog
wd.feed();
leds.g4.off();
cortex_m::interrupt::free(|cs| {
if !net::is_pending(cs) {
// Wait for interrupts
// (Ethernet, SysTick, or USB)
wfi();
} }
}); });
leds.g4.on(); } else {
// Should reset, close all TCP sockets.
let mut any_socket_alive = false;
server.for_each(|mut socket, _| {
if socket.is_active() {
socket.abort();
any_socket_alive = true;
}
});
// 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/gateway
); new_ipv4_config.take()
.map(|config| {
server.set_ipv4_config(config.clone());
ipv4_config = config;
});
// Update watchdog
wd.feed();
leds.g4.off();
cortex_m::interrupt::free(|cs| {
if !net::is_pending(cs) {
// Wait for interrupts
// (Ethernet, SysTick, or USB)
wfi();
}
});
leds.g4.on();
}
});
});
unreachable!() unreachable!()
} }

46
src/net.rs
View File

@ -1,17 +1,20 @@
//! As there is only one peripheral, supporting data structures are //! As there is only one peripheral, supporting data structures are
//! declared once and globally. //! declared once and globally.
use crate::command_parser::Ipv4Config;
use crate::pins::EthernetPins;
use core::cell::RefCell; use core::cell::RefCell;
use cortex_m::interrupt::{CriticalSection, Mutex}; 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::{ use stm32f4xx_hal::{
pac::{interrupt, Peripherals, ETHERNET_DMA, ETHERNET_MAC},
rcc::Clocks, rcc::Clocks,
pac::{interrupt, Peripherals, ETHERNET_MAC, ETHERNET_DMA},
}; };
use smoltcp::wire::{EthernetAddress, Ipv4Address, Ipv4Cidr};
use smoltcp::iface::{
EthernetInterfaceBuilder, EthernetInterface,
NeighborCache, Routes,
};
use stm32_eth::{Eth, RingEntry, RxDescriptor, TxDescriptor};
use crate::command_parser::Ipv4Config;
use crate::pins::EthernetPins;
/// Not on the stack so that stack can be placed in CCMRAM (which the /// Not on the stack so that stack can be placed in CCMRAM (which the
/// ethernet peripheral cannot access) /// ethernet peripheral cannot access)
@ -27,27 +30,27 @@ static NET_PENDING: Mutex<RefCell<bool>> = Mutex::new(RefCell::new(false));
/// Run callback `f` with ethernet driver and TCP/IP stack /// Run callback `f` with ethernet driver and TCP/IP stack
pub fn run<F>( pub fn run<F>(
clocks: Clocks, clocks: Clocks,
ethernet_mac: ETHERNET_MAC, ethernet_mac: ETHERNET_MAC, ethernet_dma: ETHERNET_DMA,
ethernet_dma: ETHERNET_DMA,
eth_pins: EthernetPins, eth_pins: EthernetPins,
ethernet_addr: EthernetAddress, ethernet_addr: EthernetAddress,
ipv4_config: Ipv4Config, ipv4_config: Ipv4Config,
f: F, f: F
) where ) where
F: FnOnce(EthernetInterface<&mut stm32_eth::Eth<'static, 'static>>), F: FnOnce(EthernetInterface<&mut stm32_eth::Eth<'static, 'static>>),
{ {
let rx_ring = unsafe { RX_RING.get_or_insert(Default::default()) }; let rx_ring = unsafe {
let tx_ring = unsafe { TX_RING.get_or_insert(Default::default()) }; RX_RING.get_or_insert(Default::default())
};
let tx_ring = unsafe {
TX_RING.get_or_insert(Default::default())
};
// Ethernet driver // Ethernet driver
let mut eth_dev = Eth::new( let mut eth_dev = Eth::new(
ethernet_mac, ethernet_mac, ethernet_dma,
ethernet_dma, &mut rx_ring[..], &mut tx_ring[..],
&mut rx_ring[..],
&mut tx_ring[..],
clocks, clocks,
eth_pins, eth_pins,
) ).unwrap();
.unwrap();
eth_dev.enable_interrupt(); eth_dev.enable_interrupt();
// IP stack // IP stack
@ -73,7 +76,8 @@ pub fn run<F>(
#[interrupt] #[interrupt]
fn ETH() { fn ETH() {
cortex_m::interrupt::free(|cs| { cortex_m::interrupt::free(|cs| {
*NET_PENDING.borrow(cs).borrow_mut() = true; *NET_PENDING.borrow(cs)
.borrow_mut() = true;
}); });
let p = unsafe { Peripherals::steal() }; let p = unsafe { Peripherals::steal() };
@ -82,13 +86,15 @@ fn ETH() {
/// Has an interrupt occurred since last call to `clear_pending()`? /// Has an interrupt occurred since last call to `clear_pending()`?
pub fn is_pending(cs: &CriticalSection) -> bool { pub fn is_pending(cs: &CriticalSection) -> bool {
*NET_PENDING.borrow(cs).borrow() *NET_PENDING.borrow(cs)
.borrow()
} }
/// Clear the interrupt pending flag before polling the interface for /// Clear the interrupt pending flag before polling the interface for
/// data. /// data.
pub fn clear_pending(cs: &CriticalSection) { pub fn clear_pending(cs: &CriticalSection) {
*NET_PENDING.borrow(cs).borrow_mut() = false; *NET_PENDING.borrow(cs)
.borrow_mut() = false;
} }
/// utility for destructuring into smoltcp types /// utility for destructuring into smoltcp types

33
src/pid.rs
View File

@ -1,4 +1,4 @@
use serde::{Deserialize, Serialize}; use serde::{Serialize, Deserialize};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Parameters { pub struct Parameters {
@ -29,22 +29,22 @@ impl Default for Parameters {
#[derive(Clone)] #[derive(Clone)]
pub struct Controller { pub struct Controller {
pub parameters: Parameters, pub parameters: Parameters,
pub target: f64, pub target : f64,
u1: f64, u1 : f64,
x1: f64, x1 : f64,
x2: f64, x2 : f64,
pub y1: f64, pub y1 : f64,
} }
impl Controller { impl Controller {
pub const fn new(parameters: Parameters) -> Controller { pub const fn new(parameters: Parameters) -> Controller {
Controller { Controller {
parameters, parameters: parameters,
target: 0.0, target : 0.0,
u1: 0.0, u1 : 0.0,
x1: 0.0, x1 : 0.0,
x2: 0.0, x2 : 0.0,
y1: 0.0, y1 : 0.0,
} }
} }
@ -54,12 +54,15 @@ impl Controller {
// + x0 * (kp + ki + kd) // + x0 * (kp + ki + kd)
// - x1 * (kp + 2kd) // - x1 * (kp + 2kd)
// + x2 * kd // + x2 * kd
// + kp * (u0 - u1)
// y0 = clip(y0', ymin, ymax) // y0 = clip(y0', ymin, ymax)
pub fn update(&mut self, input: f64) -> f64 { pub fn update(&mut self, input: f64) -> f64 {
let mut output: f64 = self.y1 - self.target * f64::from(self.parameters.ki) let mut output: f64 = self.y1 - self.target * f64::from(self.parameters.ki)
+ input * f64::from(self.parameters.kp + self.parameters.ki + self.parameters.kd) + input * f64::from(self.parameters.kp + self.parameters.ki + self.parameters.kd)
- self.x1 * f64::from(self.parameters.kp + 2.0 * self.parameters.kd) - self.x1 * f64::from(self.parameters.kp + 2.0 * self.parameters.kd)
+ self.x2 * f64::from(self.parameters.kd); + self.x2 * f64::from(self.parameters.kd)
+ f64::from(self.parameters.kp) * (self.target - self.u1);
if output < self.parameters.output_min.into() { if output < self.parameters.output_min.into() {
output = self.parameters.output_min.into(); output = self.parameters.output_min.into();
} }

239
src/pins.rs
View File

@ -1,41 +1,49 @@
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::{ use stm32f4xx_hal::{
adc::Adc, adc::Adc,
gpio::{ gpio::{
gpioa::*, gpiob::*, gpioc::*, gpioe::*, gpiof::*, gpiog::*, Alternate, AlternateOD, Analog, AF5, Alternate, AlternateOD, Analog, Floating, Input,
Floating, GpioExt, Input, Output, PushPull, AF5, gpioa::*,
gpiob::*,
gpioc::*,
gpioe::*,
gpiof::*,
gpiog::*,
GpioExt,
Output, PushPull,
}, },
hal::{self, blocking::spi::Transfer, digital::v2::OutputPin}, hal::{self, blocking::spi::Transfer, digital::v2::OutputPin},
i2c::I2c, i2c::I2c,
otg_fs::USB, otg_fs::USB,
pac::{
ADC1, GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, GPIOF, GPIOG, I2C1, OTG_FS_DEVICE, OTG_FS_GLOBAL,
OTG_FS_PWRCLK, SPI2, SPI4, SPI5, TIM1, TIM3, TIM8,
},
pwm::{self, PwmChannels},
rcc::Clocks, rcc::Clocks,
spi::{NoMiso, Spi, TransferModeNormal}, pwm::{self, PwmChannels},
time::U32Ext, spi::{Spi, NoMiso, TransferModeNormal},
pac::{
ADC1,
GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, GPIOF, GPIOG,
I2C1,
OTG_FS_GLOBAL, OTG_FS_DEVICE, OTG_FS_PWRCLK,
SPI2, SPI4, SPI5,
TIM1, TIM3, TIM8
},
timer::Timer, timer::Timer,
time::U32Ext,
};
use eeprom24x::{self, Eeprom24x};
use stm32_eth::EthPins;
use crate::{
channel::{Channel0, Channel1},
leds::Leds,
fan_ctrl::FanPin,
hw_rev::{HWRev, HWSettings},
}; };
pub type Eeprom = Eeprom24x< pub type Eeprom = Eeprom24x<
I2c< I2c<I2C1, (
I2C1, PB8<AlternateOD<{ stm32f4xx_hal::gpio::AF4 }>>,
( PB9<AlternateOD<{ stm32f4xx_hal::gpio::AF4 }>>
PB8<AlternateOD<{ stm32f4xx_hal::gpio::AF4 }>>, )>,
PB9<AlternateOD<{ stm32f4xx_hal::gpio::AF4 }>>,
),
>,
eeprom24x::page_size::B8, eeprom24x::page_size::B8,
eeprom24x::addr_size::OneByte, eeprom24x::addr_size::OneByte
>; >;
pub type EthernetPins = EthPins< pub type EthernetPins = EthPins<
@ -46,58 +54,40 @@ pub type EthernetPins = EthPins<
PB13<Input<Floating>>, PB13<Input<Floating>>,
PC4<Input<Floating>>, PC4<Input<Floating>>,
PC5<Input<Floating>>, PC5<Input<Floating>>,
>; >;
pub trait ChannelPins { pub trait ChannelPins {
type DacSpi: Transfer<u8>; type DacSpi: Transfer<u8>;
type DacSync: OutputPin; type DacSync: OutputPin;
type Shdn: OutputPin; type Shdn: OutputPin;
type VRefPin; type VRefPin;
type ITecPin; type ItecPin;
type DacFeedbackPin; type DacFeedbackPin;
type TecUMeasPin; type TecUMeasPin;
} }
pub enum Channel0VRef {
Analog(PA0<Analog>),
Disabled(PA0<Input<Floating>>),
}
impl ChannelPins for Channel0 { impl ChannelPins for Channel0 {
type DacSpi = Dac0Spi; type DacSpi = Dac0Spi;
type DacSync = PE4<Output<PushPull>>; type DacSync = PE4<Output<PushPull>>;
type Shdn = PE10<Output<PushPull>>; type Shdn = PE10<Output<PushPull>>;
type VRefPin = Channel0VRef; type VRefPin = PA0<Analog>;
type ITecPin = PA6<Analog>; type ItecPin = PA6<Analog>;
type DacFeedbackPin = PA4<Analog>; type DacFeedbackPin = PA4<Analog>;
type TecUMeasPin = PC2<Analog>; type TecUMeasPin = PC2<Analog>;
} }
pub enum Channel1VRef {
Analog(PA3<Analog>),
Disabled(PA3<Input<Floating>>),
}
impl ChannelPins for Channel1 { impl ChannelPins for Channel1 {
type DacSpi = Dac1Spi; type DacSpi = Dac1Spi;
type DacSync = PF6<Output<PushPull>>; type DacSync = PF6<Output<PushPull>>;
type Shdn = PE15<Output<PushPull>>; type Shdn = PE15<Output<PushPull>>;
type VRefPin = Channel1VRef; type VRefPin = PA3<Analog>;
type ITecPin = PB0<Analog>; type ItecPin = PB0<Analog>;
type DacFeedbackPin = PA5<Analog>; type DacFeedbackPin = PA5<Analog>;
type TecUMeasPin = PC3<Analog>; type TecUMeasPin = PC3<Analog>;
} }
/// SPI peripheral used for communication with the ADC /// SPI peripheral used for communication with the ADC
pub type AdcSpi = Spi< pub type AdcSpi = Spi<SPI2, (PB10<Alternate<AF5>>, PB14<Alternate<AF5>>, PB15<Alternate<AF5>>), TransferModeNormal>;
SPI2,
(
PB10<Alternate<AF5>>,
PB14<Alternate<AF5>>,
PB15<Alternate<AF5>>,
),
TransferModeNormal,
>;
pub type AdcNss = PB12<Output<PushPull>>; pub type AdcNss = PB12<Output<PushPull>>;
type Dac0Spi = Spi<SPI4, (PE2<Alternate<AF5>>, NoMiso, PE6<Alternate<AF5>>), TransferModeNormal>; type Dac0Spi = Spi<SPI4, (PE2<Alternate<AF5>>, NoMiso, PE6<Alternate<AF5>>), TransferModeNormal>;
type Dac1Spi = Spi<SPI5, (PF7<Alternate<AF5>>, NoMiso, PF9<Alternate<AF5>>), TransferModeNormal>; type Dac1Spi = Spi<SPI5, (PF7<Alternate<AF5>>, NoMiso, PF9<Alternate<AF5>>), TransferModeNormal>;
@ -108,7 +98,7 @@ pub struct ChannelPinSet<C: ChannelPins> {
pub dac_sync: C::DacSync, pub dac_sync: C::DacSync,
pub shdn: C::Shdn, pub shdn: C::Shdn,
pub vref_pin: C::VRefPin, pub vref_pin: C::VRefPin,
pub itec_pin: C::ITecPin, pub itec_pin: C::ItecPin,
pub dac_feedback_pin: C::DacFeedbackPin, pub dac_feedback_pin: C::DacFeedbackPin,
pub tec_u_meas_pin: C::TecUMeasPin, pub tec_u_meas_pin: C::TecUMeasPin,
} }
@ -133,34 +123,13 @@ impl Pins {
/// Setup GPIO pins and configure MCU peripherals /// Setup GPIO pins and configure MCU peripherals
pub fn setup( pub fn setup(
clocks: Clocks, clocks: Clocks,
(tim1, tim3, tim8): (TIM1, TIM3, TIM8), tim1: TIM1, tim3: TIM3, tim8: TIM8,
(gpioa, gpiob, gpioc, gpiod, gpioe, gpiof, gpiog): ( gpioa: GPIOA, gpiob: GPIOB, gpioc: GPIOC, gpiod: GPIOD, gpioe: GPIOE, gpiof: GPIOF, gpiog: GPIOG,
GPIOA,
GPIOB,
GPIOC,
GPIOD,
GPIOE,
GPIOF,
GPIOG,
),
i2c1: I2C1, i2c1: I2C1,
(spi2, spi4, spi5): (SPI2, SPI4, SPI5), spi2: SPI2, spi4: SPI4, spi5: SPI5,
adc1: ADC1, adc1: ADC1,
(otg_fs_global, otg_fs_device, otg_fs_pwrclk): ( otg_fs_global: OTG_FS_GLOBAL, otg_fs_device: OTG_FS_DEVICE, otg_fs_pwrclk: OTG_FS_PWRCLK,
OTG_FS_GLOBAL, ) -> (Self, Leds, Eeprom, EthernetPins, USB, Option<FanPin>, HWRev, HWSettings) {
OTG_FS_DEVICE,
OTG_FS_PWRCLK,
),
) -> (
Self,
Leds,
Eeprom,
EthernetPins,
USB,
Option<FanPin>,
HWRev,
HWSettings,
) {
let gpioa = gpioa.split(); let gpioa = gpioa.split();
let gpiob = gpiob.split(); let gpiob = gpiob.split();
let gpioc = gpioc.split(); let gpioc = gpioc.split();
@ -175,29 +144,19 @@ impl Pins {
let pins_adc = Adc::adc1(adc1, true, Default::default()); let pins_adc = Adc::adc1(adc1, true, Default::default());
let pwm = PwmPins::setup( let pwm = PwmPins::setup(
clocks, clocks, tim1, tim3,
(tim1, tim3), gpioc.pc6, gpioc.pc7,
(gpioc.pc6, gpioc.pc7), gpioe.pe9, gpioe.pe11,
(gpioe.pe9, gpioe.pe11), gpioe.pe13, gpioe.pe14
(gpioe.pe13, gpioe.pe14),
); );
let hwrev = HWRev::detect_hw_rev(&HWRevPins { let (dac0_spi, dac0_sync) = Self::setup_dac0(
hwrev0: gpiod.pd0, clocks, spi4,
hwrev1: gpiod.pd1, gpioe.pe2, gpioe.pe4, gpioe.pe6
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 mut shdn0 = gpioe.pe10.into_push_pull_output();
shdn0.set_low(); let _ = shdn0.set_low();
let vref0_pin = if hwrev.major > 2 { let vref0_pin = gpioa.pa0.into_analog();
Channel0VRef::Analog(gpioa.pa0.into_analog())
} else {
Channel0VRef::Disabled(gpioa.pa0)
};
let itec0_pin = gpioa.pa6.into_analog(); let itec0_pin = gpioa.pa6.into_analog();
let dac_feedback0_pin = gpioa.pa4.into_analog(); let dac_feedback0_pin = gpioa.pa4.into_analog();
let tec_u_meas0_pin = gpioc.pc2.into_analog(); let tec_u_meas0_pin = gpioc.pc2.into_analog();
@ -211,14 +170,13 @@ impl Pins {
tec_u_meas_pin: tec_u_meas0_pin, tec_u_meas_pin: tec_u_meas0_pin,
}; };
let (dac1_spi, dac1_sync) = Self::setup_dac1(clocks, spi5, gpiof.pf7, gpiof.pf6, gpiof.pf9); let (dac1_spi, dac1_sync) = Self::setup_dac1(
clocks, spi5,
gpiof.pf7, gpiof.pf6, gpiof.pf9
);
let mut shdn1 = gpioe.pe15.into_push_pull_output(); let mut shdn1 = gpioe.pe15.into_push_pull_output();
shdn1.set_low(); let _ = shdn1.set_low();
let vref1_pin = if hwrev.major > 2 { let vref1_pin = gpioa.pa3.into_analog();
Channel1VRef::Analog(gpioa.pa3.into_analog())
} else {
Channel1VRef::Disabled(gpioa.pa3)
};
let itec1_pin = gpiob.pb0.into_analog(); let itec1_pin = gpiob.pb0.into_analog();
let dac_feedback1_pin = gpioa.pa5.into_analog(); let dac_feedback1_pin = gpioa.pa5.into_analog();
let tec_u_meas1_pin = gpioc.pc3.into_analog(); let tec_u_meas1_pin = gpioc.pc3.into_analog();
@ -233,19 +191,18 @@ impl Pins {
}; };
let pins = Pins { let pins = Pins {
adc_spi, adc_spi, adc_nss,
adc_nss,
pins_adc, pins_adc,
pwm, pwm,
channel0, channel0,
channel1, channel1,
}; };
let leds = Leds::new( let hwrev = HWRev::detect_hw_rev(&HWRevPins {hwrev0: gpiod.pd0, hwrev1: gpiod.pd1,
gpiod.pd9, hwrev2: gpiod.pd2, hwrev3: gpiod.pd3});
gpiod.pd10.into_push_pull_output(), let hw_settings = hwrev.settings();
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().set_open_drain(); let eeprom_scl = gpiob.pb8.into_alternate().set_open_drain();
let eeprom_sda = gpiob.pb9.into_alternate().set_open_drain(); let eeprom_sda = gpiob.pb9.into_alternate().set_open_drain();
@ -272,13 +229,8 @@ impl Pins {
}; };
let fan = if hw_settings.fan_available { let fan = if hw_settings.fan_available {
Some( Some(Timer::new(tim8, &clocks).pwm(gpioc.pc9.into_alternate(), hw_settings.fan_pwm_freq_hz.hz()))
Timer::new(tim8, &clocks) } else { None };
.pwm(gpioc.pc9.into_alternate(), hw_settings.fan_pwm_freq_hz.hz()),
)
} else {
None
};
(pins, leds, eeprom, eth_pins, usb, fan, hwrev, hw_settings) (pins, leds, eeprom, eth_pins, usb, fan, hwrev, hw_settings)
} }
@ -290,7 +242,8 @@ impl Pins {
sck: PB10<M1>, sck: PB10<M1>,
miso: PB14<M2>, miso: PB14<M2>,
mosi: PB15<M3>, mosi: PB15<M3>,
) -> AdcSpi { ) -> AdcSpi
{
let sck = sck.into_alternate(); let sck = sck.into_alternate();
let miso = miso.into_alternate(); let miso = miso.into_alternate();
let mosi = mosi.into_alternate(); let mosi = mosi.into_alternate();
@ -299,16 +252,13 @@ impl Pins {
(sck, miso, mosi), (sck, miso, mosi),
crate::ad7172::SPI_MODE, crate::ad7172::SPI_MODE,
crate::ad7172::SPI_CLOCK, crate::ad7172::SPI_CLOCK,
clocks, clocks
) )
} }
fn setup_dac0<M1, M2, M3>( fn setup_dac0<M1, M2, M3>(
clocks: Clocks, clocks: Clocks, spi4: SPI4,
spi4: SPI4, sclk: PE2<M1>, sync: PE4<M2>, sdin: PE6<M3>
sclk: PE2<M1>,
sync: PE4<M2>,
sdin: PE6<M3>,
) -> (Dac0Spi, <Channel0 as ChannelPins>::DacSync) { ) -> (Dac0Spi, <Channel0 as ChannelPins>::DacSync) {
let sclk = sclk.into_alternate(); let sclk = sclk.into_alternate();
let sdin = sdin.into_alternate(); let sdin = sdin.into_alternate();
@ -317,7 +267,7 @@ impl Pins {
(sclk, NoMiso {}, sdin), (sclk, NoMiso {}, sdin),
crate::ad5680::SPI_MODE, crate::ad5680::SPI_MODE,
crate::ad5680::SPI_CLOCK, crate::ad5680::SPI_CLOCK,
clocks, clocks
); );
let sync = sync.into_push_pull_output(); let sync = sync.into_push_pull_output();
@ -325,11 +275,8 @@ impl Pins {
} }
fn setup_dac1<M1, M2, M3>( fn setup_dac1<M1, M2, M3>(
clocks: Clocks, clocks: Clocks, spi5: SPI5,
spi5: SPI5, sclk: PF7<M1>, sync: PF6<M2>, sdin: PF9<M3>
sclk: PF7<M1>,
sync: PF6<M2>,
sdin: PF9<M3>,
) -> (Dac1Spi, <Channel1 as ChannelPins>::DacSync) { ) -> (Dac1Spi, <Channel1 as ChannelPins>::DacSync) {
let sclk = sclk.into_alternate(); let sclk = sclk.into_alternate();
let sdin = sdin.into_alternate(); let sdin = sdin.into_alternate();
@ -338,7 +285,7 @@ impl Pins {
(sclk, NoMiso {}, sdin), (sclk, NoMiso {}, sdin),
crate::ad5680::SPI_MODE, crate::ad5680::SPI_MODE,
crate::ad5680::SPI_CLOCK, crate::ad5680::SPI_CLOCK,
clocks, clocks
); );
let sync = sync.into_push_pull_output(); let sync = sync.into_push_pull_output();
@ -358,18 +305,25 @@ pub struct PwmPins {
impl PwmPins { impl PwmPins {
fn setup<M1, M2, M3, M4, M5, M6>( fn setup<M1, M2, M3, M4, M5, M6>(
clocks: Clocks, clocks: Clocks,
(tim1, tim3): (TIM1, TIM3), tim1: TIM1,
(max_v0, max_v1): (PC6<M1>, PC7<M2>), tim3: TIM3,
(max_i_pos0, max_i_pos1): (PE9<M3>, PE11<M4>), max_v0: PC6<M1>,
(max_i_neg0, max_i_neg1): (PE13<M5>, PE14<M6>), max_v1: PC7<M2>,
max_i_pos0: PE9<M3>,
max_i_pos1: PE11<M4>,
max_i_neg0: PE13<M5>,
max_i_neg1: PE14<M6>,
) -> PwmPins { ) -> PwmPins {
let freq = 20u32.khz(); 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.set_duty(0);
pin.enable(); pin.enable();
} }
let channels = (max_v0.into_alternate(), max_v1.into_alternate()); let channels = (
max_v0.into_alternate(),
max_v1.into_alternate(),
);
//let (mut max_v0, mut max_v1) = pwm::tim3(tim3, channels, clocks, freq); //let (mut max_v0, mut max_v1) = pwm::tim3(tim3, channels, clocks, freq);
let (mut max_v0, mut max_v1) = Timer::new(tim3, &clocks).pwm(channels, freq); let (mut max_v0, mut max_v1) = Timer::new(tim3, &clocks).pwm(channels, freq);
init_pwm_pin(&mut max_v0); init_pwm_pin(&mut max_v0);
@ -389,12 +343,9 @@ impl PwmPins {
init_pwm_pin(&mut max_i_neg1); init_pwm_pin(&mut max_i_neg1);
PwmPins { PwmPins {
max_v0, max_v0, max_v1,
max_v1, max_i_pos0, max_i_pos1,
max_i_pos0, max_i_neg0, max_i_neg1,
max_i_pos1,
max_i_neg0,
max_i_neg1,
} }
} }
} }

38
src/server.rs
View File

@ -1,29 +1,25 @@
use crate::command_parser::Ipv4Config;
use crate::net::split_ipv4_config;
use smoltcp::{ use smoltcp::{
iface::EthernetInterface, iface::EthernetInterface,
socket::{SocketHandle, SocketRef, SocketSet, TcpSocket, TcpSocketBuffer}, socket::{SocketSet, SocketHandle, TcpSocket, TcpSocketBuffer, SocketRef},
time::Instant, time::Instant,
wire::{IpAddress, IpCidr, Ipv4Address, Ipv4Cidr}, wire::{IpAddress, IpCidr, Ipv4Address, Ipv4Cidr},
}; };
use crate::command_parser::Ipv4Config;
use crate::net::split_ipv4_config;
pub struct SocketState<S> { pub struct SocketState<S> {
handle: SocketHandle, handle: SocketHandle,
state: S, state: S,
} }
impl<'a, S: Default> SocketState<S> { impl<'a, S: Default> SocketState<S>{
fn new( 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> {
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_rx_buffer = TcpSocketBuffer::new(&mut tcp_rx_storage[..]);
let tcp_tx_buffer = TcpSocketBuffer::new(&mut tcp_tx_storage[..]); let tcp_tx_buffer = TcpSocketBuffer::new(&mut tcp_tx_storage[..]);
let tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer); let tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
SocketState::<S> { SocketState::<S> {
handle: sockets.add(tcp_socket), handle: sockets.add(tcp_socket),
state: S::default(), state: S::default()
} }
} }
} }
@ -54,7 +50,7 @@ impl<'a, 'b, S: Default> Server<'a, 'b, S> {
($rx_storage:ident, $tx_storage:ident) => { ($rx_storage:ident, $tx_storage:ident) => {
let mut $rx_storage = [0; TCP_RX_BUFFER_SIZE]; let mut $rx_storage = [0; TCP_RX_BUFFER_SIZE];
let mut $tx_storage = [0; TCP_TX_BUFFER_SIZE]; let mut $tx_storage = [0; TCP_TX_BUFFER_SIZE];
}; }
} }
create_rtx_storage!(tcp_rx_storage0, tcp_tx_storage0); create_rtx_storage!(tcp_rx_storage0, tcp_tx_storage0);
@ -103,10 +99,15 @@ impl<'a, 'b, S: Default> Server<'a, 'b, S> {
fn set_ipv4_address(&mut self, ipv4_address: Ipv4Cidr) { fn set_ipv4_address(&mut self, ipv4_address: Ipv4Cidr) {
self.net.update_ip_addrs(|addrs| { self.net.update_ip_addrs(|addrs| {
for addr in addrs.iter_mut() { for addr in addrs.iter_mut() {
if let IpCidr::Ipv4(_) = addr { match addr {
*addr = IpCidr::Ipv4(ipv4_address); IpCidr::Ipv4(_) => {
// done *addr = IpCidr::Ipv4(ipv4_address);
break; // done
break
}
_ => {
// skip
}
} }
} }
}); });
@ -115,9 +116,10 @@ impl<'a, 'b, S: Default> Server<'a, 'b, S> {
fn set_gateway(&mut self, gateway: Option<Ipv4Address>) { fn set_gateway(&mut self, gateway: Option<Ipv4Address>) {
let routes = self.net.routes_mut(); let routes = self.net.routes_mut();
match gateway { match gateway {
None => routes.update(|routes_storage| { None =>
routes_storage.remove(&IpCidr::new(IpAddress::v4(0, 0, 0, 0), 0)); routes.update(|routes_storage| {
}), routes_storage.remove(&IpCidr::new(IpAddress::v4(0, 0, 0, 0), 0));
}),
Some(gateway) => { Some(gateway) => {
routes.add_default_ipv4_route(gateway).unwrap(); routes.add_default_ipv4_route(gateway).unwrap();
} }

53
src/session.rs
View File

@ -1,4 +1,5 @@
use super::command_parser::{Command, Error as ParserError}; use super::command_parser::{Command, Error as ParserError};
use super::channels::CHANNELS;
const MAX_LINE_LEN: usize = 64; const MAX_LINE_LEN: usize = 64;
@ -45,14 +46,15 @@ pub enum SessionInput {
impl From<Result<Command, ParserError>> for SessionInput { impl From<Result<Command, ParserError>> for SessionInput {
fn from(input: Result<Command, ParserError>) -> Self { fn from(input: Result<Command, ParserError>) -> Self {
input input.map(SessionInput::Command)
.map(SessionInput::Command)
.unwrap_or_else(SessionInput::Error) .unwrap_or_else(SessionInput::Error)
} }
} }
pub struct Session { pub struct Session {
reader: LineReader, reader: LineReader,
reporting: bool,
report_pending: [bool; CHANNELS],
} }
impl Default for Session { impl Default for Session {
@ -65,11 +67,43 @@ impl Session {
pub fn new() -> Self { pub fn new() -> Self {
Session { Session {
reader: LineReader::new(), reader: LineReader::new(),
reporting: false,
report_pending: [false; CHANNELS],
} }
} }
pub fn reset(&mut self) { pub fn reset(&mut self) {
self.reader = LineReader::new(); 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) { pub fn feed(&mut self, buf: &[u8]) -> (usize, SessionInput) {
@ -77,9 +111,18 @@ impl Session {
for (i, b) in buf.iter().enumerate() { for (i, b) in buf.iter().enumerate() {
buf_bytes = i + 1; buf_bytes = i + 1;
let line = self.reader.feed(*b); let line = self.reader.feed(*b);
if let Some(line) = line { match line {
let command = Command::parse(line); Some(line) => {
return (buf_bytes, command.into()); let command = Command::parse(&line);
match command {
Ok(Command::Reporting(reporting)) => {
self.reporting = reporting;
}
_ => {}
}
return (buf_bytes, command.into());
}
None => {}
} }
} }
(buf_bytes, SessionInput::Nothing) (buf_bytes, SessionInput::Nothing)

24
src/b_parameter.rs → src/steinhart_hart.rs
View File

@ -1,29 +1,31 @@
use num_traits::float::Float; use num_traits::float::Float;
use serde::{Deserialize, Serialize};
use uom::si::{ use uom::si::{
f64::{
ElectricalResistance,
ThermodynamicTemperature,
},
electrical_resistance::ohm, electrical_resistance::ohm,
f64::{ElectricalResistance, TemperatureInterval, ThermodynamicTemperature},
ratio::ratio, ratio::ratio,
temperature_interval::kelvin as kelvin_interval,
thermodynamic_temperature::{degree_celsius, kelvin}, thermodynamic_temperature::{degree_celsius, kelvin},
}; };
use serde::{Deserialize, Serialize};
/// B-Parameter equation parameters /// Steinhart-Hart equation parameters
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Parameters { pub struct Parameters {
/// Base temperature /// Base temperature
pub t0: ThermodynamicTemperature, pub t0: ThermodynamicTemperature,
/// Thermistor resistance at base temperature /// Base resistance
pub r0: ElectricalResistance, pub r0: ElectricalResistance,
/// Beta (average slope of the function ln R vs. 1/T) /// Beta
pub b: TemperatureInterval, pub b: f64,
} }
impl Parameters { impl Parameters {
/// Perform the resistance to temperature conversion. /// Perform the voltage to temperature conversion.
pub fn get_temperature(&self, r: ElectricalResistance) -> ThermodynamicTemperature { pub fn get_temperature(&self, r: ElectricalResistance) -> ThermodynamicTemperature {
let temp = (self.t0.recip() + (r / self.r0).get::<ratio>().ln() / self.b).recip(); let inv_temp = 1.0 / self.t0.get::<kelvin>() + (r / self.r0).get::<ratio>().ln() / self.b;
ThermodynamicTemperature::new::<kelvin>(temp.get::<kelvin_interval>()) ThermodynamicTemperature::new::<kelvin>(1.0 / inv_temp)
} }
} }
@ -32,7 +34,7 @@ impl Default for Parameters {
Parameters { Parameters {
t0: ThermodynamicTemperature::new::<degree_celsius>(25.0), t0: ThermodynamicTemperature::new::<degree_celsius>(25.0),
r0: ElectricalResistance::new::<ohm>(10_000.0), r0: ElectricalResistance::new::<ohm>(10_000.0),
b: TemperatureInterval::new::<kelvin_interval>(3800.0), b: 3800.0,
} }
} }
} }

14
src/timer.rs
View File

@ -4,9 +4,9 @@ use cortex_m::interrupt::Mutex;
use cortex_m_rt::exception; use cortex_m_rt::exception;
use stm32f4xx_hal::{ use stm32f4xx_hal::{
rcc::Clocks, rcc::Clocks,
stm32::SYST,
time::U32Ext, time::U32Ext,
timer::{Event as TimerEvent, Timer}, timer::{Timer, Event as TimerEvent},
stm32::SYST,
}; };
/// Rate in Hz /// Rate in Hz
@ -18,6 +18,7 @@ static TIMER_MS: Mutex<RefCell<u32>> = Mutex::new(RefCell::new(0));
/// Setup SysTick exception /// Setup SysTick exception
pub fn setup(syst: SYST, clocks: Clocks) { pub fn setup(syst: SYST, clocks: Clocks) {
let timer = Timer::syst(syst, &clocks); let timer = Timer::syst(syst, &clocks);
let mut countdown = timer.start_count_down(TIMER_RATE.hz()); let mut countdown = timer.start_count_down(TIMER_RATE.hz());
countdown.listen(TimerEvent::TimeOut); countdown.listen(TimerEvent::TimeOut);
@ -27,13 +28,18 @@ pub fn setup(syst: SYST, clocks: Clocks) {
#[exception] #[exception]
fn SysTick() { fn SysTick() {
cortex_m::interrupt::free(|cs| { cortex_m::interrupt::free(|cs| {
*TIMER_MS.borrow(cs).borrow_mut() += TIMER_DELTA; *TIMER_MS.borrow(cs)
.borrow_mut() += TIMER_DELTA;
}); });
} }
/// Obtain current time in milliseconds /// Obtain current time in milliseconds
pub fn now() -> u32 { pub fn now() -> u32 {
cortex_m::interrupt::free(|cs| *TIMER_MS.borrow(cs).borrow().deref()) cortex_m::interrupt::free(|cs| {
*TIMER_MS.borrow(cs)
.borrow()
.deref()
})
} }
/// block for at least `amount` milliseconds /// block for at least `amount` milliseconds

18
src/usb.rs
View File

@ -1,18 +1,15 @@
use core::{ use core::{fmt::{self, Write}, mem::MaybeUninit};
fmt::{self, Write},
mem::MaybeUninit,
};
use cortex_m::interrupt::free; use cortex_m::interrupt::free;
use log::{Log, Metadata, Record};
use stm32f4xx_hal::{ use stm32f4xx_hal::{
otg_fs::{UsbBus as Bus, USB}, otg_fs::{USB, UsbBus as Bus},
stm32::{interrupt, Interrupt, NVIC}, stm32::{interrupt, Interrupt, NVIC},
}; };
use usb_device::{ use usb_device::{
class_prelude::UsbBusAllocator, class_prelude::{UsbBusAllocator},
prelude::{UsbDevice, UsbDeviceBuilder, UsbVidPid}, prelude::{UsbDevice, UsbDeviceBuilder, UsbVidPid},
}; };
use usbd_serial::SerialPort; use usbd_serial::SerialPort;
use log::{Record, Log, Metadata};
static mut EP_MEMORY: [u32; 1024] = [0; 1024]; static mut EP_MEMORY: [u32; 1024] = [0; 1024];
@ -39,8 +36,8 @@ impl State {
.device_class(usbd_serial::USB_CLASS_CDC) .device_class(usbd_serial::USB_CLASS_CDC)
.build(); .build();
free(|_| unsafe { free(|_| {
STATE = Some(State { serial, dev }); unsafe { STATE = Some(State { serial, dev }); }
}); });
unsafe { unsafe {
@ -97,7 +94,8 @@ impl Write for SerialOutput {
fn write_str(&mut self, s: &str) -> core::result::Result<(), core::fmt::Error> { fn write_str(&mut self, s: &str) -> core::result::Result<(), core::fmt::Error> {
if let Some(ref mut state) = State::get() { if let Some(ref mut state) = State::get() {
for chunk in s.as_bytes().chunks(16) { for chunk in s.as_bytes().chunks(16) {
free(|_| state.serial.write(chunk)).map_err(|_| fmt::Error)?; free(|_| state.serial.write(chunk))
.map_err(|_| fmt::Error)?;
} }
} }
Ok(()) Ok(())